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) => [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 isFinite: (self: Duration) => boolean

export declare const Equivalence: equivalence.Equivalence<Duration>

export declare const Order: order.Order<Duration>

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

export declare const subtract: {
  (that: DurationInput): (self: DurationInput) => Duration
  (self: DurationInput, that: DurationInput): 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 declare const unsafeDivide: {
  (by: number): (self: DurationInput) => Duration
  (self: DurationInput, by: number): Duration
}

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

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

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

export type Unit =
  | "nano"
  | "nanos"
  | "micro"
  | "micros"
  | "milli"
  | "millis"
  | "second"
  | "seconds"
  | "minute"
  | "minutes"
  | "hour"
  | "hours"
  | "day"
  | "days"
  | "week"
  | "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: {
  (options: { minimum: DurationInput; maximum: DurationInput }): (self: DurationInput) => boolean
  (self: DurationInput, options: { 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: {
  (options: { minimum: DurationInput; maximum: DurationInput }): (self: DurationInput) => Duration
  (self: DurationInput, options: { minimum: DurationInput; maximum: DurationInput }): Duration
}

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

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

export declare const format: (self: DurationInput) => string

import * as Duration from "effect/Duration"

Duration.format(Duration.millis(1000)) // "1s"
Duration.format(Duration.millis(1001)) // "1s 1ms"

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
}