Duration

declare function days(days: number): Duration

declare function hours(hours: number): Duration

declare const infinity: Duration

declare function micros(micros: bigint): Duration

declare function millis(millis: number): Duration

declare function minutes(minutes: number): Duration

declare function nanos(nanos: bigint): Duration

declare function seconds(seconds: number): Duration

declare function weeks(weeks: number): Duration

declare const zero: Duration

declare function format(self: DurationInput): string

declare function formatIso(self: DurationInput): Option<string>

declare function fromIso(iso: string): Option<Duration>

declare function parts(self: DurationInput): {
  days: number;
  hours: number;
  millis: number;
  minutes: number;
  nanos: number;
  seconds: number;
}

declare function unsafeFormatIso(self: DurationInput): string

declare function toDays(self: DurationInput): number

declare function toHours(self: DurationInput): number

declare function toHrTime(self: DurationInput): [seconds: number, nanos: number]

declare function toMillis(self: DurationInput): number

declare function toMinutes(self: DurationInput): number

declare function toNanos(self: DurationInput): Option<bigint>

declare function toSeconds(self: DurationInput): number

declare function toWeeks(self: DurationInput): number

declare function unsafeToNanos(self: DurationInput): bigint

declare function isDuration(u: unknown): u is Duration

declare function isFinite(self: Duration): boolean

declare function isZero(self: Duration): boolean

declare const Equivalence: equivalence.Equivalence<Duration>

declare const Order: order.Order<Duration>

declare const divide: {
  (by: number): (self: DurationInput) => Option<Duration>;
  (self: DurationInput, by: number): Option<Duration>;
}

declare const subtract: {
  (that: DurationInput): (self: DurationInput) => Duration;
  (self: DurationInput, that: DurationInput): Duration;
}

declare const sum: {
  (that: DurationInput): (self: DurationInput) => Duration;
  (self: DurationInput, that: DurationInput): Duration;
}

declare const times: {
  (times: number): (self: DurationInput) => Duration;
  (self: DurationInput, times: number): Duration;
}

declare const unsafeDivide: {
  (by: number): (self: DurationInput) => Duration;
  (self: DurationInput, by: number): Duration;
}

interface Duration extends Equal, Pipeable, Inspectable {
  readonly [TypeId]: typeof TypeId;
  readonly value: DurationValue;
}

type DurationInput = Duration | number | bigint | readonly [seconds: number, nanos: number] | `${number} ${Unit}`

type DurationValue = {
  readonly _tag: "Millis";
  readonly millis: number;
} | {
  readonly _tag: "Nanos";
  readonly nanos: bigint;
} | {
  readonly _tag: "Infinity";
}

type Unit = "nano" | "nanos" | "micro" | "micros" | "milli" | "millis" | "second" | "seconds" | "minute" | "minutes" | "hour" | "hours" | "day" | "days" | "week" | "weeks"

declare const clamp: {
  (options: {
    maximum: DurationInput;
    minimum: DurationInput;
  }): (self: DurationInput) => Duration;
  (self: DurationInput, options: {
    maximum: DurationInput;
    minimum: DurationInput;
  }): Duration;
}

declare const max: {
  (that: DurationInput): (self: DurationInput) => Duration;
  (self: DurationInput, that: DurationInput): Duration;
}

declare function decode(input: DurationInput): Duration

declare const decodeUnknown: (u: unknown) => Option.Option<Duration>

declare const min: {
  (that: DurationInput): (self: DurationInput) => Duration;
  (self: DurationInput, that: DurationInput): Duration;
}

declare const match: {
  <A, B>(options: {
    readonly onMillis: (millis: number) => A;
    readonly onNanos: (nanos: bigint) => B;
  }): (self: DurationInput) => A | B;
  <A, B>(self: DurationInput, options: {
    readonly onMillis: (millis: number) => A;
    readonly onNanos: (nanos: bigint) => B;
  }): A | B;
}

declare const matchWith: {
  <A, B>(that: DurationInput, options: {
    readonly onMillis: (self: number, that: number) => A;
    readonly onNanos: (self: bigint, that: bigint) => B;
  }): (self: DurationInput) => A | B;
  <A, B>(self: DurationInput, that: DurationInput, options: {
    readonly onMillis: (self: number, that: number) => A;
    readonly onNanos: (self: bigint, that: bigint) => B;
  }): A | B;
}

declare const between: {
  (options: {
    maximum: DurationInput;
    minimum: DurationInput;
  }): (self: DurationInput) => boolean;
  (self: DurationInput, options: {
    maximum: DurationInput;
    minimum: DurationInput;
  }): boolean;
}

declare const equals: {
  (that: DurationInput): (self: DurationInput) => boolean;
  (self: DurationInput, that: DurationInput): boolean;
}

declare const greaterThan: {
  (that: DurationInput): (self: DurationInput) => boolean;
  (self: DurationInput, that: DurationInput): boolean;
}

declare const greaterThanOrEqualTo: {
  (that: DurationInput): (self: DurationInput) => boolean;
  (self: DurationInput, that: DurationInput): boolean;
}

declare const lessThan: {
  (that: DurationInput): (self: DurationInput) => boolean;
  (self: DurationInput, that: DurationInput): boolean;
}

declare const lessThanOrEqualTo: {
  (that: DurationInput): (self: DurationInput) => boolean;
  (self: DurationInput, that: DurationInput): boolean;
}

type TypeId = typeof TypeId