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;