export declare const days: (days: number) => Duration

export declare const hours: (hours: number) => Duration

export declare const infinity: Duration

export declare const micros: (micros: bigint) => Duration

export declare const millis: (millis: number) => Duration

export declare const minutes: (minutes: number) => Duration

export declare const nanos: (nanos: bigint) => Duration

export declare const seconds: (seconds: number) => Duration

export declare const weeks: (weeks: number) => Duration

export declare const zero: Duration

export declare const toHrTime: (self: DurationInput) => readonly [seconds: number, nanos: number]

export declare const toMillis: (self: DurationInput) => number

export declare const toNanos: (self: DurationInput) => Option.Option<bigint>

export declare const toSeconds: (self: DurationInput) => number

export declare const unsafeToNanos: (self: DurationInput) => bigint

export declare const isDuration: (u: unknown) => u is Duration

export declare const Equivalence: equivalence.Equivalence<Duration>

export declare const Order: order.Order<Duration>

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

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

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

export type DurationInput =
  | Duration
  | number // millis
  | bigint // nanos
  | `${number} ${Unit}`

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

export type Unit = 'nanos' | 'micros' | 'millis' | 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks'

export 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
}

export 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
}

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

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

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

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

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

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

export type TypeId = typeof TypeId

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

export declare const decode: (input: DurationInput) => Duration

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

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