@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/DateTime.ts

@@ -1,1686 +0,0 @@
-/**
- * @since 3.6.0
- */
-import type { IllegalArgumentException } from "./Cause.js"
-import * as Context from "./Context.js"
-import type * as Duration from "./Duration.js"
-import * as Effect from "./Effect.js"
-import type * as Either from "./Either.js"
-import type * as equivalence from "./Equivalence.js"
-import { dual, type LazyArg } from "./Function.js"
-import type { Inspectable } from "./Inspectable.js"
-import * as Internal from "./internal/dateTime.js"
-import * as Layer from "./Layer.js"
-import type * as Option from "./Option.js"
-import type * as order from "./Order.js"
-import type { Pipeable } from "./Pipeable.js"
-
-/**
- * @since 3.6.0
- * @category type ids
- */
-export const TypeId: unique symbol = Internal.TypeId
-
-/**
- * @since 3.6.0
- * @category type ids
- */
-export type TypeId = typeof TypeId
-
-/**
- * A `DateTime` represents a point in time. It can optionally have a time zone
- * associated with it.
- *
- * @since 3.6.0
- * @category models
- */
-export type DateTime = Utc | Zoned
-
-/**
- * @since 3.6.0
- * @category models
- */
-export interface Utc extends DateTime.Proto {
-  readonly _tag: "Utc"
-  readonly epochMillis: number
-  partsUtc: DateTime.PartsWithWeekday | undefined
-}
-
-/**
- * @since 3.6.0
- * @category models
- */
-export interface Zoned extends DateTime.Proto {
-  readonly _tag: "Zoned"
-  readonly epochMillis: number
-  readonly zone: TimeZone
-  adjustedEpochMillis: number | undefined
-  partsAdjusted: DateTime.PartsWithWeekday | undefined
-  partsUtc: DateTime.PartsWithWeekday | undefined
-}
-
-/**
- * @since 3.6.0
- * @category models
- */
-export declare namespace DateTime {
-  /**
-   * @since 3.6.0
-   * @category models
-   */
-  export type Input = DateTime | Partial<Parts> | Date | number | string
-
-  /**
-   * @since 3.6.0
-   * @category models
-   */
-  export type PreserveZone<A extends DateTime.Input> = A extends Zoned ? Zoned : Utc
-
-  /**
-   * @since 3.6.0
-   * @category models
-   */
-  export type Unit = UnitSingular | UnitPlural
-
-  /**
-   * @since 3.6.0
-   * @category models
-   */
-  export type UnitSingular =
-    | "milli"
-    | "second"
-    | "minute"
-    | "hour"
-    | "day"
-    | "week"
-    | "month"
-    | "year"
-
-  /**
-   * @since 3.6.0
-   * @category models
-   */
-  export type UnitPlural =
-    | "millis"
-    | "seconds"
-    | "minutes"
-    | "hours"
-    | "days"
-    | "weeks"
-    | "months"
-    | "years"
-
-  /**
-   * @since 3.6.0
-   * @category models
-   */
-  export interface PartsWithWeekday {
-    readonly millis: number
-    readonly seconds: number
-    readonly minutes: number
-    readonly hours: number
-    readonly day: number
-    readonly weekDay: number
-    readonly month: number
-    readonly year: number
-  }
-
-  /**
-   * @since 3.6.0
-   * @category models
-   */
-  export interface Parts {
-    readonly millis: number
-    readonly seconds: number
-    readonly minutes: number
-    readonly hours: number
-    readonly day: number
-    readonly month: number
-    readonly year: number
-  }
-
-  /**
-   * @since 3.6.0
-   * @category models
-   */
-  export interface PartsForMath {
-    readonly millis: number
-    readonly seconds: number
-    readonly minutes: number
-    readonly hours: number
-    readonly days: number
-    readonly weeks: number
-    readonly months: number
-    readonly years: number
-  }
-
-  /**
-   * @since 3.6.0
-   * @category models
-   */
-  export interface Proto extends Pipeable, Inspectable {
-    readonly [TypeId]: TypeId
-  }
-}
-
-/**
- * @since 3.6.0
- * @category type ids
- */
-export const TimeZoneTypeId: unique symbol = Internal.TimeZoneTypeId
-
-/**
- * @since 3.6.0
- * @category type ids
- */
-export type TimeZoneTypeId = typeof TimeZoneTypeId
-
-/**
- * @since 3.6.0
- * @category models
- */
-export type TimeZone = TimeZone.Offset | TimeZone.Named
-
-/**
- * @since 3.6.0
- * @category models
- */
-export declare namespace TimeZone {
-  /**
-   * @since 3.6.0
-   * @category models
-   */
-  export interface Proto extends Inspectable {
-    readonly [TimeZoneTypeId]: TimeZoneTypeId
-  }
-
-  /**
-   * @since 3.6.0
-   * @category models
-   */
-  export interface Offset extends Proto {
-    readonly _tag: "Offset"
-    readonly offset: number
-  }
-
-  /**
-   * @since 3.6.0
-   * @category models
-   */
-  export interface Named extends Proto {
-    readonly _tag: "Named"
-    readonly id: string
-    /** @internal */
-    readonly format: Intl.DateTimeFormat
-  }
-}
-
-/**
- * A `Disambiguation` is used to resolve ambiguities when a `DateTime` is
- * ambiguous, such as during a daylight saving time transition.
- *
- * For more information, see the [Temporal documentation](https://tc39.es/proposal-temporal/docs/timezone.html#ambiguity-due-to-dst-or-other-time-zone-offset-changes)
- *
- * - `"compatible"`: (default) Behavior matching Temporal API and legacy JavaScript Date and moment.js.
- *   For repeated times, chooses the earlier occurrence. For gap times, chooses the later interpretation.
- *
- * - `"earlier"`: For repeated times, always choose the earlier occurrence.
- *   For gap times, choose the time before the gap.
- *
- * - `"later"`: For repeated times, always choose the later occurrence.
- *   For gap times, choose the time after the gap.
- *
- * - `"reject"`: Throw an `RangeError` when encountering ambiguous or non-existent times.
- *
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * // Fall-back example: 01:30 on Nov 2, 2025 in New York happens twice
- * const ambiguousTime = { year: 2025, month: 11, day: 2, hours: 1, minutes: 30 }
- * const timeZone = DateTime.zoneUnsafeMakeNamed("America/New_York")
- *
- * DateTime.makeZoned(ambiguousTime, { timeZone, adjustForTimeZone: true, disambiguation: "earlier" })
- * // Earlier occurrence (DST time): 2025-11-02T05:30:00.000Z
- *
- * DateTime.makeZoned(ambiguousTime, { timeZone, adjustForTimeZone: true, disambiguation: "later" })
- * // Later occurrence (standard time): 2025-11-02T06:30:00.000Z
- *
- * // Gap example: 02:30 on Mar 9, 2025 in New York doesn't exist
- * const gapTime = { year: 2025, month: 3, day: 9, hours: 2, minutes: 30 }
- *
- * DateTime.makeZoned(gapTime, { timeZone, adjustForTimeZone: true, disambiguation: "earlier" })
- * // Time before gap: 2025-03-09T06:30:00.000Z (01:30 EST)
- *
- * DateTime.makeZoned(gapTime, { timeZone, adjustForTimeZone: true, disambiguation: "later" })
- * // Time after gap: 2025-03-09T07:30:00.000Z (03:30 EDT)
- * ```
- *
- * @since 3.18.0
- * @category models
- */
-export type Disambiguation = "compatible" | "earlier" | "later" | "reject"
-
-// =============================================================================
-// guards
-// =============================================================================
-
-/**
- * @since 3.6.0
- * @category guards
- */
-export const isDateTime: (u: unknown) => u is DateTime = Internal.isDateTime
-
-/**
- * @since 3.6.0
- * @category guards
- */
-export const isTimeZone: (u: unknown) => u is TimeZone = Internal.isTimeZone
-
-/**
- * @since 3.6.0
- * @category guards
- */
-export const isTimeZoneOffset: (u: unknown) => u is TimeZone.Offset = Internal.isTimeZoneOffset
-
-/**
- * @since 3.6.0
- * @category guards
- */
-export const isTimeZoneNamed: (u: unknown) => u is TimeZone.Named = Internal.isTimeZoneNamed
-
-/**
- * @since 3.6.0
- * @category guards
- */
-export const isUtc: (self: DateTime) => self is Utc = Internal.isUtc
-
-/**
- * @since 3.6.0
- * @category guards
- */
-export const isZoned: (self: DateTime) => self is Zoned = Internal.isZoned
-
-// =============================================================================
-// instances
-// =============================================================================
-
-/**
- * @since 3.6.0
- * @category instances
- */
-export const Equivalence: equivalence.Equivalence<DateTime> = Internal.Equivalence
-
-/**
- * @since 3.6.0
- * @category instances
- */
-export const Order: order.Order<DateTime> = Internal.Order
-
-/**
- * @since 3.6.0
- */
-export const clamp: {
-  <Min extends DateTime, Max extends DateTime>(
-    options: { readonly minimum: Min; readonly maximum: Max }
-  ): <A extends DateTime>(self: A) => A | Min | Max
-  <A extends DateTime, Min extends DateTime, Max extends DateTime>(
-    self: A,
-    options: { readonly minimum: Min; readonly maximum: Max }
-  ): A | Min | Max
-} = Internal.clamp
-
-// =============================================================================
-// constructors
-// =============================================================================
-
-/**
- * Create a `DateTime` from a `Date`.
- *
- * If the `Date` is invalid, an `IllegalArgumentException` will be thrown.
- *
- * @since 3.6.0
- * @category constructors
- */
-export const unsafeFromDate: (date: Date) => Utc = Internal.unsafeFromDate
-
-/**
- * Create a `DateTime` from one of the following:
- *
- * - A `DateTime`
- * - A `Date` instance (invalid dates will throw an `IllegalArgumentException`)
- * - The `number` of milliseconds since the Unix epoch
- * - An object with the parts of a date
- * - A `string` that can be parsed by `Date.parse`
- *
- * @since 3.6.0
- * @category constructors
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * // from Date
- * DateTime.unsafeMake(new Date())
- *
- * // from parts
- * DateTime.unsafeMake({ year: 2024 })
- *
- * // from string
- * DateTime.unsafeMake("2024-01-01")
- * ```
- */
-export const unsafeMake: <A extends DateTime.Input>(input: A) => DateTime.PreserveZone<A> = Internal.unsafeMake
-
-/**
- * Create a `DateTime.Zoned` using `DateTime.unsafeMake` and a time zone.
- *
- * The input is treated as UTC and then the time zone is attached, unless
- * `adjustForTimeZone` is set to `true`. In that case, the input is treated as
- * already in the time zone.
- *
- * When `adjustForTimeZone` is true and ambiguous times occur during DST transitions,
- * the `disambiguation` option controls how to resolve the ambiguity:
- * - `compatible` (default): Choose earlier time for repeated times, later for gaps
- * - `earlier`: Always choose the earlier of two possible times
- * - `later`: Always choose the later of two possible times
- * - `reject`: Throw an error when ambiguous times are encountered
- *
- * @since 3.6.0
- * @category constructors
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * DateTime.unsafeMakeZoned(new Date(), { timeZone: "Europe/London" })
- * ```
- */
-export const unsafeMakeZoned: (input: DateTime.Input, options?: {
-  readonly timeZone?: number | string | TimeZone | undefined
-  readonly adjustForTimeZone?: boolean | undefined
-  readonly disambiguation?: Disambiguation | undefined
-}) => Zoned = Internal.unsafeMakeZoned
-
-/**
- * Create a `DateTime.Zoned` using `DateTime.make` and a time zone.
- *
- * The input is treated as UTC and then the time zone is attached, unless
- * `adjustForTimeZone` is set to `true`. In that case, the input is treated as
- * already in the time zone.
- *
- * When `adjustForTimeZone` is true and ambiguous times occur during DST transitions,
- * the `disambiguation` option controls how to resolve the ambiguity:
- * - `compatible` (default): Choose earlier time for repeated times, later for gaps
- * - `earlier`: Always choose the earlier of two possible times
- * - `later`: Always choose the later of two possible times
- * - `reject`: Throw an error when ambiguous times are encountered
- *
- * If the date time input or time zone is invalid, `None` will be returned.
- *
- * @since 3.6.0
- * @category constructors
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * DateTime.makeZoned(new Date(), { timeZone: "Europe/London" })
- * ```
- */
-export const makeZoned: (
-  input: DateTime.Input,
-  options?: {
-    readonly timeZone?: number | string | TimeZone | undefined
-    readonly adjustForTimeZone?: boolean | undefined
-    readonly disambiguation?: Disambiguation | undefined
-  }
-) => Option.Option<Zoned> = Internal.makeZoned
-
-/**
- * Create a `DateTime` from one of the following:
- *
- * - A `DateTime`
- * - A `Date` instance (invalid dates will throw an `IllegalArgumentException`)
- * - The `number` of milliseconds since the Unix epoch
- * - An object with the parts of a date
- * - A `string` that can be parsed by `Date.parse`
- *
- * If the input is invalid, `None` will be returned.
- *
- * @since 3.6.0
- * @category constructors
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * // from Date
- * DateTime.make(new Date())
- *
- * // from parts
- * DateTime.make({ year: 2024 })
- *
- * // from string
- * DateTime.make("2024-01-01")
- * ```
- */
-export const make: <A extends DateTime.Input>(input: A) => Option.Option<DateTime.PreserveZone<A>> = Internal.make
-
-/**
- * Create a `DateTime.Zoned` from a string.
- *
- * It uses the format: `YYYY-MM-DDTHH:mm:ss.sss+HH:MM[Time/Zone]`.
- *
- * @since 3.6.0
- * @category constructors
- */
-export const makeZonedFromString: (input: string) => Option.Option<Zoned> = Internal.makeZonedFromString
-
-/**
- * Get the current time using the `Clock` service and convert it to a `DateTime`.
- *
- * @since 3.6.0
- * @category constructors
- * @example
- * ```ts
- * import { DateTime, Effect } from "effect"
- *
- * Effect.gen(function* () {
- *   const now = yield* DateTime.now
- * })
- * ```
- */
-export const now: Effect.Effect<Utc> = Internal.now
-
-/**
- * Get the current time using the `Clock` service.
- *
- * @since 3.14.0
- * @category constructors
- * @example
- * ```ts
- * import { DateTime, Effect } from "effect"
- *
- * Effect.gen(function* () {
- *   const now = yield* DateTime.nowAsDate
- * })
- * ```
- */
-export const nowAsDate: Effect.Effect<Date> = Internal.nowAsDate
-
-/**
- * Get the current time using `Date.now`.
- *
- * @since 3.6.0
- * @category constructors
- */
-export const unsafeNow: LazyArg<Utc> = Internal.unsafeNow
-
-// =============================================================================
-// time zones
-// =============================================================================
-
-/**
- * For a `DateTime` returns a new `DateTime.Utc`.
- *
- * @since 3.13.0
- * @category time zones
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * const now = DateTime.unsafeMakeZoned({ year: 2024 }, { timeZone: "Europe/London" })
- *
- * // set as UTC
- * const utc: DateTime.Utc = DateTime.toUtc(now)
- * ```
- */
-export const toUtc: (self: DateTime) => Utc = Internal.toUtc
-
-/**
- * Set the time zone of a `DateTime`, returning a new `DateTime.Zoned`.
- *
- * @since 3.6.0
- * @category time zones
- * @example
- * ```ts
- * import { DateTime, Effect } from "effect"
- *
- * Effect.gen(function* () {
- *   const now = yield* DateTime.now
- *   const zone = DateTime.zoneUnsafeMakeNamed("Europe/London")
- *
- *   // set the time zone
- *   const zoned: DateTime.Zoned = DateTime.setZone(now, zone)
- * })
- * ```
- */
-export const setZone: {
-  (zone: TimeZone, options?: {
-    readonly adjustForTimeZone?: boolean | undefined
-    readonly disambiguation?: Disambiguation | undefined
-  }): (self: DateTime) => Zoned
-  (self: DateTime, zone: TimeZone, options?: {
-    readonly adjustForTimeZone?: boolean | undefined
-    readonly disambiguation?: Disambiguation | undefined
-  }): Zoned
-} = Internal.setZone
-
-/**
- * Add a fixed offset time zone to a `DateTime`.
- *
- * The offset is in milliseconds.
- *
- * @since 3.6.0
- * @category time zones
- * @example
- * ```ts
- * import { DateTime, Effect } from "effect"
- *
- * Effect.gen(function* () {
- *   const now = yield* DateTime.now
- *
- *   // set the offset time zone in milliseconds
- *   const zoned: DateTime.Zoned = DateTime.setZoneOffset(now, 3 * 60 * 60 * 1000)
- * })
- * ```
- */
-export const setZoneOffset: {
-  (offset: number, options?: {
-    readonly adjustForTimeZone?: boolean | undefined
-    readonly disambiguation?: Disambiguation | undefined
-  }): (self: DateTime) => Zoned
-  (self: DateTime, offset: number, options?: {
-    readonly adjustForTimeZone?: boolean | undefined
-    readonly disambiguation?: Disambiguation | undefined
-  }): Zoned
-} = Internal.setZoneOffset
-
-/**
- * Attempt to create a named time zone from a IANA time zone identifier.
- *
- * If the time zone is invalid, an `IllegalArgumentException` will be thrown.
- *
- * @since 3.6.0
- * @category time zones
- */
-export const zoneUnsafeMakeNamed: (zoneId: string) => TimeZone.Named = Internal.zoneUnsafeMakeNamed
-
-/**
- * Create a fixed offset time zone.
- *
- * @since 3.6.0
- * @category time zones
- */
-export const zoneMakeOffset: (offset: number) => TimeZone.Offset = Internal.zoneMakeOffset
-
-/**
- * Create a named time zone from a IANA time zone identifier. If the time zone
- * is invalid, `None` will be returned.
- *
- * @since 3.6.0
- * @category time zones
- */
-export const zoneMakeNamed: (zoneId: string) => Option.Option<TimeZone.Named> = Internal.zoneMakeNamed
-
-/**
- * Create a named time zone from a IANA time zone identifier. If the time zone
- * is invalid, it will fail with an `IllegalArgumentException`.
- *
- * @since 3.6.0
- * @category time zones
- */
-export const zoneMakeNamedEffect: (zoneId: string) => Effect.Effect<TimeZone.Named, IllegalArgumentException> =
-  Internal.zoneMakeNamedEffect
-
-/**
- * Create a named time zone from the system's local time zone.
- *
- * @since 3.6.0
- * @category time zones
- */
-export const zoneMakeLocal: () => TimeZone.Named = Internal.zoneMakeLocal
-
-/**
- * Try parse a TimeZone from a string
- *
- * @since 3.6.0
- * @category time zones
- */
-export const zoneFromString: (zone: string) => Option.Option<TimeZone> = Internal.zoneFromString
-
-/**
- * Format a `TimeZone` as a string.
- *
- * @since 3.6.0
- * @category time zones
- * @example
- * ```ts
- * import { DateTime, Effect } from "effect"
- *
- * // Outputs "+03:00"
- * DateTime.zoneToString(DateTime.zoneMakeOffset(3 * 60 * 60 * 1000))
- *
- * // Outputs "Europe/London"
- * DateTime.zoneToString(DateTime.zoneUnsafeMakeNamed("Europe/London"))
- * ```
- */
-export const zoneToString: (self: TimeZone) => string = Internal.zoneToString
-
-/**
- * Set the time zone of a `DateTime` from an IANA time zone identifier. If the
- * time zone is invalid, `None` will be returned.
- *
- * @since 3.6.0
- * @category time zones
- * @example
- * ```ts
- * import { DateTime, Effect } from "effect"
- *
- * Effect.gen(function* () {
- *   const now = yield* DateTime.now
- *   // set the time zone, returns an Option
- *   DateTime.setZoneNamed(now, "Europe/London")
- * })
- * ```
- */
-export const setZoneNamed: {
-  (zoneId: string, options?: {
-    readonly adjustForTimeZone?: boolean | undefined
-    readonly disambiguation?: Disambiguation | undefined
-  }): (self: DateTime) => Option.Option<Zoned>
-  (self: DateTime, zoneId: string, options?: {
-    readonly adjustForTimeZone?: boolean | undefined
-    readonly disambiguation?: Disambiguation | undefined
-  }): Option.Option<Zoned>
-} = Internal.setZoneNamed
-
-/**
- * Set the time zone of a `DateTime` from an IANA time zone identifier. If the
- * time zone is invalid, an `IllegalArgumentException` will be thrown.
- *
- * @since 3.6.0
- * @category time zones
- * @example
- * ```ts
- * import { DateTime, Effect } from "effect"
- *
- * Effect.gen(function* () {
- *   const now = yield* DateTime.now
- *   // set the time zone
- *   DateTime.unsafeSetZoneNamed(now, "Europe/London")
- * })
- * ```
- */
-export const unsafeSetZoneNamed: {
-  (zoneId: string, options?: {
-    readonly adjustForTimeZone?: boolean | undefined
-    readonly disambiguation?: Disambiguation | undefined
-  }): (self: DateTime) => Zoned
-  (self: DateTime, zoneId: string, options?: {
-    readonly adjustForTimeZone?: boolean | undefined
-    readonly disambiguation?: Disambiguation | undefined
-  }): Zoned
-} = Internal.unsafeSetZoneNamed
-
-// =============================================================================
-// comparisons
-// =============================================================================
-
-/**
- * Calulate the difference between two `DateTime` values, returning the number
- * of milliseconds the `other` DateTime is from `self`.
- *
- * If `other` is *after* `self`, the result will be a positive number.
- *
- * @since 3.6.0
- * @category comparisons
- * @example
- * ```ts
- * import { DateTime, Effect } from "effect"
- *
- * Effect.gen(function* () {
- *   const now = yield* DateTime.now
- *   const other = DateTime.add(now, { minutes: 1 })
- *
- *   // returns 60000
- *   DateTime.distance(now, other)
- * })
- * ```
- */
-export const distance: {
-  (other: DateTime): (self: DateTime) => number
-  (self: DateTime, other: DateTime): number
-} = Internal.distance
-
-/**
- * Calulate the difference between two `DateTime` values.
- *
- * If the `other` DateTime is before `self`, the result will be a negative
- * `Duration`, returned as a `Left`.
- *
- * If the `other` DateTime is after `self`, the result will be a positive
- * `Duration`, returned as a `Right`.
- *
- * @since 3.6.0
- * @category comparisons
- * @example
- * ```ts
- * import { DateTime, Effect } from "effect"
- *
- * Effect.gen(function* () {
- *   const now = yield* DateTime.now
- *   const other = DateTime.add(now, { minutes: 1 })
- *
- *   // returns Either.right(Duration.minutes(1))
- *   DateTime.distanceDurationEither(now, other)
- *
- *   // returns Either.left(Duration.minutes(1))
- *   DateTime.distanceDurationEither(other, now)
- * })
- * ```
- */
-export const distanceDurationEither: {
-  (other: DateTime): (self: DateTime) => Either.Either<Duration.Duration, Duration.Duration>
-  (self: DateTime, other: DateTime): Either.Either<Duration.Duration, Duration.Duration>
-} = Internal.distanceDurationEither
-
-/**
- * Calulate the distance between two `DateTime` values.
- *
- * @since 3.6.0
- * @category comparisons
- * @example
- * ```ts
- * import { DateTime, Effect } from "effect"
- *
- * Effect.gen(function* () {
- *   const now = yield* DateTime.now
- *   const other = DateTime.add(now, { minutes: 1 })
- *
- *   // returns Duration.minutes(1)
- *   DateTime.distanceDuration(now, other)
- * })
- * ```
- */
-export const distanceDuration: {
-  (other: DateTime): (self: DateTime) => Duration.Duration
-  (self: DateTime, other: DateTime): Duration.Duration
-} = Internal.distanceDuration
-
-/**
- * @since 3.6.0
- * @category comparisons
- */
-export const min: {
-  <That extends DateTime>(that: That): <Self extends DateTime>(self: Self) => Self | That
-  <Self extends DateTime, That extends DateTime>(self: Self, that: That): Self | That
-} = Internal.min
-
-/**
- * @since 3.6.0
- * @category comparisons
- */
-export const max: {
-  <That extends DateTime>(that: That): <Self extends DateTime>(self: Self) => Self | That
-  <Self extends DateTime, That extends DateTime>(self: Self, that: That): Self | That
-} = Internal.max
-
-/**
- * @since 3.6.0
- * @category comparisons
- */
-export const greaterThan: {
-  (that: DateTime): (self: DateTime) => boolean
-  (self: DateTime, that: DateTime): boolean
-} = Internal.greaterThan
-
-/**
- * @since 3.6.0
- * @category comparisons
- */
-export const greaterThanOrEqualTo: {
-  (that: DateTime): (self: DateTime) => boolean
-  (self: DateTime, that: DateTime): boolean
-} = Internal.greaterThanOrEqualTo
-
-/**
- * @since 3.6.0
- * @category comparisons
- */
-export const lessThan: {
-  (that: DateTime): (self: DateTime) => boolean
-  (self: DateTime, that: DateTime): boolean
-} = Internal.lessThan
-
-/**
- * @since 3.6.0
- * @category comparisons
- */
-export const lessThanOrEqualTo: {
-  (that: DateTime): (self: DateTime) => boolean
-  (self: DateTime, that: DateTime): boolean
-} = Internal.lessThanOrEqualTo
-
-/**
- * @since 3.6.0
- * @category comparisons
- */
-export const between: {
-  (options: { minimum: DateTime; maximum: DateTime }): (self: DateTime) => boolean
-  (self: DateTime, options: { minimum: DateTime; maximum: DateTime }): boolean
-} = Internal.between
-
-/**
- * @since 3.6.0
- * @category comparisons
- */
-export const isFuture: (self: DateTime) => Effect.Effect<boolean> = Internal.isFuture
-
-/**
- * @since 3.6.0
- * @category comparisons
- */
-export const unsafeIsFuture: (self: DateTime) => boolean = Internal.unsafeIsFuture
-
-/**
- * @since 3.6.0
- * @category comparisons
- */
-export const isPast: (self: DateTime) => Effect.Effect<boolean> = Internal.isPast
-
-/**
- * @since 3.6.0
- * @category comparisons
- */
-export const unsafeIsPast: (self: DateTime) => boolean = Internal.unsafeIsPast
-
-// =============================================================================
-// conversions
-// =============================================================================
-
-/**
- * Get the UTC `Date` of a `DateTime`.
- *
- * @since 3.6.0
- * @category conversions
- */
-export const toDateUtc: (self: DateTime) => Date = Internal.toDateUtc
-
-/**
- * Convert a `DateTime` to a `Date`, applying the time zone first.
- *
- * @since 3.6.0
- * @category conversions
- */
-export const toDate: (self: DateTime) => Date = Internal.toDate
-
-/**
- * Calculate the time zone offset of a `DateTime.Zoned` in milliseconds.
- *
- * @since 3.6.0
- * @category conversions
- */
-export const zonedOffset: (self: Zoned) => number = Internal.zonedOffset
-
-/**
- * Calculate the time zone offset of a `DateTime` in milliseconds.
- *
- * The offset is formatted as "±HH:MM".
- *
- * @since 3.6.0
- * @category conversions
- */
-export const zonedOffsetIso: (self: Zoned) => string = Internal.zonedOffsetIso
-
-/**
- * Get the milliseconds since the Unix epoch of a `DateTime`.
- *
- * @since 3.6.0
- * @category conversions
- */
-export const toEpochMillis: (self: DateTime) => number = Internal.toEpochMillis
-
-/**
- * Remove the time aspect of a `DateTime`, first adjusting for the time
- * zone. It will return a `DateTime.Utc` only containing the date.
- *
- * @since 3.6.0
- * @category conversions
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * // returns "2024-01-01T00:00:00Z"
- * DateTime.unsafeMakeZoned("2024-01-01T05:00:00Z", {
- *   timeZone: "Pacific/Auckland",
- *   adjustForTimeZone: true
- * }).pipe(
- *   DateTime.removeTime,
- *   DateTime.formatIso
- * )
- * ```
- */
-export const removeTime: (self: DateTime) => Utc = Internal.removeTime
-
-// =============================================================================
-// parts
-// =============================================================================
-
-/**
- * Get the different parts of a `DateTime` as an object.
- *
- * The parts will be time zone adjusted.
- *
- * @since 3.6.0
- * @category parts
- */
-export const toParts: (self: DateTime) => DateTime.PartsWithWeekday = Internal.toParts
-
-/**
- * Get the different parts of a `DateTime` as an object.
- *
- * The parts will be in UTC.
- *
- * @since 3.6.0
- * @category parts
- */
-export const toPartsUtc: (self: DateTime) => DateTime.PartsWithWeekday = Internal.toPartsUtc
-
-/**
- * Get a part of a `DateTime` as a number.
- *
- * The part will be in the UTC time zone.
- *
- * @since 3.6.0
- * @category parts
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { DateTime } from "effect"
- *
- * const now = DateTime.unsafeMake({ year: 2024 })
- * const year = DateTime.getPartUtc(now, "year")
- * assert.strictEqual(year, 2024)
- * ```
- */
-export const getPartUtc: {
-  (part: keyof DateTime.PartsWithWeekday): (self: DateTime) => number
-  (self: DateTime, part: keyof DateTime.PartsWithWeekday): number
-} = Internal.getPartUtc
-
-/**
- * Get a part of a `DateTime` as a number.
- *
- * The part will be time zone adjusted.
- *
- * @since 3.6.0
- * @category parts
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { DateTime } from "effect"
- *
- * const now = DateTime.unsafeMakeZoned({ year: 2024 }, { timeZone: "Europe/London" })
- * const year = DateTime.getPart(now, "year")
- * assert.strictEqual(year, 2024)
- * ```
- */
-export const getPart: {
-  (part: keyof DateTime.PartsWithWeekday): (self: DateTime) => number
-  (self: DateTime, part: keyof DateTime.PartsWithWeekday): number
-} = Internal.getPart
-
-/**
- * Set the different parts of a `DateTime` as an object.
- *
- * The Date will be time zone adjusted.
- *
- * @since 3.6.0
- * @category parts
- */
-export const setParts: {
-  (parts: Partial<DateTime.PartsWithWeekday>): <A extends DateTime>(self: A) => A
-  <A extends DateTime>(self: A, parts: Partial<DateTime.PartsWithWeekday>): A
-} = Internal.setParts
-
-/**
- * Set the different parts of a `DateTime` as an object.
- *
- * @since 3.6.0
- * @category parts
- */
-export const setPartsUtc: {
-  (parts: Partial<DateTime.PartsWithWeekday>): <A extends DateTime>(self: A) => A
-  <A extends DateTime>(self: A, parts: Partial<DateTime.PartsWithWeekday>): A
-} = Internal.setPartsUtc
-
-// =============================================================================
-// current time zone
-// =============================================================================
-
-/**
- * @since 3.11.0
- * @category current time zone
- */
-export class CurrentTimeZone extends Context.Tag("effect/DateTime/CurrentTimeZone")<CurrentTimeZone, TimeZone>() {}
-
-/**
- * Set the time zone of a `DateTime` to the current time zone, which is
- * determined by the `CurrentTimeZone` service.
- *
- * @since 3.6.0
- * @category current time zone
- * @example
- * ```ts
- * import { DateTime, Effect } from "effect"
- *
- * Effect.gen(function* () {
- *   const now = yield* DateTime.now
- *
- *   // set the time zone to "Europe/London"
- *   const zoned = yield* DateTime.setZoneCurrent(now)
- * }).pipe(DateTime.withCurrentZoneNamed("Europe/London"))
- * ```
- */
-export const setZoneCurrent = (self: DateTime): Effect.Effect<Zoned, never, CurrentTimeZone> =>
-  Effect.map(CurrentTimeZone, (zone) => setZone(self, zone))
-
-/**
- * Provide the `CurrentTimeZone` to an effect.
- *
- * @since 3.6.0
- * @category current time zone
- * @example
- * ```ts
- * import { DateTime, Effect } from "effect"
- *
- * const zone = DateTime.zoneUnsafeMakeNamed("Europe/London")
- *
- * Effect.gen(function* () {
- *   const now = yield* DateTime.nowInCurrentZone
- * }).pipe(DateTime.withCurrentZone(zone))
- * ```
- */
-export const withCurrentZone: {
-  (
-    zone: TimeZone
-  ): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, CurrentTimeZone>>
-  <A, E, R>(effect: Effect.Effect<A, E, R>, zone: TimeZone): Effect.Effect<A, E, Exclude<R, CurrentTimeZone>>
-} = dual(
-  2,
-  <A, E, R>(
-    effect: Effect.Effect<A, E, R>,
-    zone: TimeZone
-  ): Effect.Effect<A, E, Exclude<R, CurrentTimeZone>> => Effect.provideService(effect, CurrentTimeZone, zone)
-)
-
-/**
- * Provide the `CurrentTimeZone` to an effect, using the system's local time
- * zone.
- *
- * @since 3.6.0
- * @category current time zone
- * @example
- * ```ts
- * import { DateTime, Effect } from "effect"
- *
- * Effect.gen(function* () {
- *   // will use the system's local time zone
- *   const now = yield* DateTime.nowInCurrentZone
- * }).pipe(DateTime.withCurrentZoneLocal)
- * ```
- */
-export const withCurrentZoneLocal = <A, E, R>(
-  effect: Effect.Effect<A, E, R>
-): Effect.Effect<A, E, Exclude<R, CurrentTimeZone>> =>
-  Effect.provideServiceEffect(effect, CurrentTimeZone, Effect.sync(zoneMakeLocal))
-
-/**
- * Provide the `CurrentTimeZone` to an effect, using a offset.
- *
- * @since 3.6.0
- * @category current time zone
- * @example
- * ```ts
- * import { DateTime, Effect } from "effect"
- *
- * Effect.gen(function* () {
- *   // will use the system's local time zone
- *   const now = yield* DateTime.nowInCurrentZone
- * }).pipe(DateTime.withCurrentZoneOffset(3 * 60 * 60 * 1000))
- * ```
- */
-export const withCurrentZoneOffset: {
-  (offset: number): <A, E, R>(
-    effect: Effect.Effect<A, E, R>
-  ) => Effect.Effect<A, E, Exclude<R, CurrentTimeZone>>
-  <A, E, R>(effect: Effect.Effect<A, E, R>, offset: number): Effect.Effect<A, E, Exclude<R, CurrentTimeZone>>
-} = dual(
-  2,
-  <A, E, R>(effect: Effect.Effect<A, E, R>, offset: number): Effect.Effect<A, E, Exclude<R, CurrentTimeZone>> =>
-    Effect.provideService(effect, CurrentTimeZone, zoneMakeOffset(offset))
-)
-
-/**
- * Provide the `CurrentTimeZone` to an effect using an IANA time zone
- * identifier.
- *
- * If the time zone is invalid, it will fail with an `IllegalArgumentException`.
- *
- * @since 3.6.0
- * @category current time zone
- * @example
- * ```ts
- * import { DateTime, Effect } from "effect"
- *
- * Effect.gen(function* () {
- *   // will use the "Europe/London" time zone
- *   const now = yield* DateTime.nowInCurrentZone
- * }).pipe(DateTime.withCurrentZoneNamed("Europe/London"))
- * ```
- */
-export const withCurrentZoneNamed: {
-  (zone: string): <A, E, R>(
-    effect: Effect.Effect<A, E, R>
-  ) => Effect.Effect<A, E | IllegalArgumentException, Exclude<R, CurrentTimeZone>>
-  <A, E, R>(
-    effect: Effect.Effect<A, E, R>,
-    zone: string
-  ): Effect.Effect<A, E | IllegalArgumentException, Exclude<R, CurrentTimeZone>>
-} = dual(
-  2,
-  <A, E, R>(
-    effect: Effect.Effect<A, E, R>,
-    zone: string
-  ): Effect.Effect<A, E | IllegalArgumentException, Exclude<R, CurrentTimeZone>> =>
-    Effect.provideServiceEffect(effect, CurrentTimeZone, zoneMakeNamedEffect(zone))
-)
-
-/**
- * Get the current time as a `DateTime.Zoned`, using the `CurrentTimeZone`.
- *
- * @since 3.6.0
- * @category current time zone
- * @example
- * ```ts
- * import { DateTime, Effect } from "effect"
- *
- * Effect.gen(function* () {
- *   // will use the "Europe/London" time zone
- *   const now = yield* DateTime.nowInCurrentZone
- * }).pipe(DateTime.withCurrentZoneNamed("Europe/London"))
- * ```
- */
-export const nowInCurrentZone: Effect.Effect<Zoned, never, CurrentTimeZone> = Effect.flatMap(now, setZoneCurrent)
-
-// =============================================================================
-// mapping
-// =============================================================================
-
-/**
- * Modify a `DateTime` by applying a function to a cloned `Date` instance.
- *
- * The `Date` will first have the time zone applied if possible, and then be
- * converted back to a `DateTime` within the same time zone.
- *
- * Supports `disambiguation` when the new wall clock time is ambiguous.
- *
- * @since 3.6.0
- * @category mapping
- */
-export const mutate: {
-  (
-    f: (date: Date) => void,
-    options?: {
-      readonly disambiguation?: Disambiguation | undefined
-    }
-  ): <A extends DateTime>(self: A) => A
-  <A extends DateTime>(
-    self: A,
-    f: (date: Date) => void,
-    options?: {
-      readonly disambiguation?: Disambiguation | undefined
-    }
-  ): A
-} = Internal.mutate
-
-/**
- * Modify a `DateTime` by applying a function to a cloned UTC `Date` instance.
- *
- * @since 3.6.0
- * @category mapping
- */
-export const mutateUtc: {
-  (f: (date: Date) => void): <A extends DateTime>(self: A) => A
-  <A extends DateTime>(self: A, f: (date: Date) => void): A
-} = Internal.mutateUtc
-
-/**
- * Transform a `DateTime` by applying a function to the number of milliseconds
- * since the Unix epoch.
- *
- * @since 3.6.0
- * @category mapping
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * // add 10 milliseconds
- * DateTime.unsafeMake(0).pipe(
- *   DateTime.mapEpochMillis((millis) => millis + 10)
- * )
- * ```
- */
-export const mapEpochMillis: {
-  (f: (millis: number) => number): <A extends DateTime>(self: A) => A
-  <A extends DateTime>(self: A, f: (millis: number) => number): A
-} = Internal.mapEpochMillis
-
-/**
- * Using the time zone adjusted `Date`, apply a function to the `Date` and
- * return the result.
- *
- * @since 3.6.0
- * @category mapping
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * // get the time zone adjusted date in milliseconds
- * DateTime.unsafeMakeZoned(0, { timeZone: "Europe/London" }).pipe(
- *   DateTime.withDate((date) => date.getTime())
- * )
- * ```
- */
-export const withDate: {
-  <A>(f: (date: Date) => A): (self: DateTime) => A
-  <A>(self: DateTime, f: (date: Date) => A): A
-} = Internal.withDate
-
-/**
- * Using the time zone adjusted `Date`, apply a function to the `Date` and
- * return the result.
- *
- * @since 3.6.0
- * @category mapping
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * // get the date in milliseconds
- * DateTime.unsafeMake(0).pipe(
- *   DateTime.withDateUtc((date) => date.getTime())
- * )
- * ```
- */
-export const withDateUtc: {
-  <A>(f: (date: Date) => A): (self: DateTime) => A
-  <A>(self: DateTime, f: (date: Date) => A): A
-} = Internal.withDateUtc
-
-/**
- * @since 3.6.0
- * @category mapping
- */
-export const match: {
-  <A, B>(options: {
-    readonly onUtc: (_: Utc) => A
-    readonly onZoned: (_: Zoned) => B
-  }): (self: DateTime) => A | B
-  <A, B>(self: DateTime, options: {
-    readonly onUtc: (_: Utc) => A
-    readonly onZoned: (_: Zoned) => B
-  }): A | B
-} = Internal.match
-
-// =============================================================================
-// math
-// =============================================================================
-
-/**
- * Add the given `Duration` to a `DateTime`.
- *
- * @since 3.6.0
- * @category math
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * // add 5 minutes
- * DateTime.unsafeMake(0).pipe(
- *   DateTime.addDuration("5 minutes")
- * )
- * ```
- */
-export const addDuration: {
-  (duration: Duration.DurationInput): <A extends DateTime>(self: A) => A
-  <A extends DateTime>(self: A, duration: Duration.DurationInput): A
-} = Internal.addDuration
-
-/**
- * Subtract the given `Duration` from a `DateTime`.
- *
- * @since 3.6.0
- * @category math
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * // subtract 5 minutes
- * DateTime.unsafeMake(0).pipe(
- *   DateTime.subtractDuration("5 minutes")
- * )
- * ```
- */
-export const subtractDuration: {
-  (duration: Duration.DurationInput): <A extends DateTime>(self: A) => A
-  <A extends DateTime>(self: A, duration: Duration.DurationInput): A
-} = Internal.subtractDuration
-
-/**
- * Add the given `amount` of `unit`'s to a `DateTime`.
- *
- * The time zone is taken into account when adding days, weeks, months, and
- * years.
- *
- * @since 3.6.0
- * @category math
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * // add 5 minutes
- * DateTime.unsafeMake(0).pipe(
- *   DateTime.add({ minutes: 5 })
- * )
- * ```
- */
-export const add: {
-  (parts: Partial<DateTime.PartsForMath>): <A extends DateTime>(self: A) => A
-  <A extends DateTime>(self: A, parts: Partial<DateTime.PartsForMath>): A
-} = Internal.add
-
-/**
- * Subtract the given `amount` of `unit`'s from a `DateTime`.
- *
- * @since 3.6.0
- * @category math
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * // subtract 5 minutes
- * DateTime.unsafeMake(0).pipe(
- *   DateTime.subtract({ minutes: 5 })
- * )
- * ```
- */
-export const subtract: {
-  (parts: Partial<DateTime.PartsForMath>): <A extends DateTime>(self: A) => A
-  <A extends DateTime>(self: A, parts: Partial<DateTime.PartsForMath>): A
-} = Internal.subtract
-
-/**
- * Converts a `DateTime` to the start of the given `part`.
- *
- * If the part is `week`, the `weekStartsOn` option can be used to specify the
- * day of the week that the week starts on. The default is 0 (Sunday).
- *
- * @since 3.6.0
- * @category math
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * // returns "2024-01-01T00:00:00Z"
- * DateTime.unsafeMake("2024-01-01T12:00:00Z").pipe(
- *   DateTime.startOf("day"),
- *   DateTime.formatIso
- * )
- * ```
- */
-export const startOf: {
-  (
-    part: DateTime.UnitSingular,
-    options?: { readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined }
-  ): <A extends DateTime>(self: A) => A
-  <A extends DateTime>(
-    self: A,
-    part: DateTime.UnitSingular,
-    options?: { readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined }
-  ): A
-} = Internal.startOf
-
-/**
- * Converts a `DateTime` to the end of the given `part`.
- *
- * If the part is `week`, the `weekStartsOn` option can be used to specify the
- * day of the week that the week starts on. The default is 0 (Sunday).
- *
- * @since 3.6.0
- * @category math
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * // returns "2024-01-01T23:59:59.999Z"
- * DateTime.unsafeMake("2024-01-01T12:00:00Z").pipe(
- *   DateTime.endOf("day"),
- *   DateTime.formatIso
- * )
- * ```
- */
-export const endOf: {
-  (
-    part: DateTime.UnitSingular,
-    options?: { readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined }
-  ): <A extends DateTime>(self: A) => A
-  <A extends DateTime>(
-    self: A,
-    part: DateTime.UnitSingular,
-    options?: { readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined }
-  ): A
-} = Internal.endOf
-
-/**
- * Converts a `DateTime` to the nearest given `part`.
- *
- * If the part is `week`, the `weekStartsOn` option can be used to specify the
- * day of the week that the week starts on. The default is 0 (Sunday).
- *
- * @since 3.6.0
- * @category math
- * @example
- * ```ts
- * import { DateTime } from "effect"
- *
- * // returns "2024-01-02T00:00:00Z"
- * DateTime.unsafeMake("2024-01-01T12:01:00Z").pipe(
- *   DateTime.nearest("day"),
- *   DateTime.formatIso
- * )
- * ```
- */
-export const nearest: {
-  (
-    part: DateTime.UnitSingular,
-    options?: { readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined }
-  ): <A extends DateTime>(self: A) => A
-  <A extends DateTime>(
-    self: A,
-    part: DateTime.UnitSingular,
-    options?: { readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined }
-  ): A
-} = Internal.nearest
-
-// =============================================================================
-// formatting
-// =============================================================================
-
-/**
- * Format a `DateTime` as a string using the `DateTimeFormat` API.
- *
- * The `timeZone` option is set to the offset of the time zone.
- *
- * Note: On Node versions < 22, fixed "Offset" zones will set the time zone to
- * "UTC" and use the adjusted `Date`.
- *
- * @since 3.6.0
- * @category formatting
- */
-export const format: {
-  (
-    options?:
-      | Intl.DateTimeFormatOptions & {
-        readonly locale?: Intl.LocalesArgument
-      }
-      | undefined
-  ): (self: DateTime) => string
-  (
-    self: DateTime,
-    options?:
-      | Intl.DateTimeFormatOptions & {
-        readonly locale?: Intl.LocalesArgument
-      }
-      | undefined
-  ): string
-} = Internal.format
-
-/**
- * Format a `DateTime` as a string using the `DateTimeFormat` API.
- *
- * It will use the system's local time zone & locale.
- *
- * @since 3.6.0
- * @category formatting
- */
-export const formatLocal: {
-  (
-    options?:
-      | Intl.DateTimeFormatOptions & {
-        readonly locale?: Intl.LocalesArgument
-      }
-      | undefined
-  ): (self: DateTime) => string
-  (
-    self: DateTime,
-    options?:
-      | Intl.DateTimeFormatOptions & {
-        readonly locale?: Intl.LocalesArgument
-      }
-      | undefined
-  ): string
-} = Internal.formatLocal
-
-/**
- * Format a `DateTime` as a string using the `DateTimeFormat` API.
- *
- * This forces the time zone to be UTC.
- *
- * @since 3.6.0
- * @category formatting
- */
-export const formatUtc: {
-  (
-    options?:
-      | Intl.DateTimeFormatOptions & {
-        readonly locale?: Intl.LocalesArgument
-      }
-      | undefined
-  ): (self: DateTime) => string
-  (
-    self: DateTime,
-    options?:
-      | Intl.DateTimeFormatOptions & {
-        readonly locale?: Intl.LocalesArgument
-      }
-      | undefined
-  ): string
-} = Internal.formatUtc
-
-/**
- * Format a `DateTime` as a string using the `DateTimeFormat` API.
- *
- * @since 3.6.0
- * @category formatting
- */
-export const formatIntl: {
-  (format: Intl.DateTimeFormat): (self: DateTime) => string
-  (self: DateTime, format: Intl.DateTimeFormat): string
-} = Internal.formatIntl
-
-/**
- * Format a `DateTime` as a UTC ISO string.
- *
- * @since 3.6.0
- * @category formatting
- */
-export const formatIso: (self: DateTime) => string = Internal.formatIso
-
-/**
- * Format a `DateTime` as a time zone adjusted ISO date string.
- *
- * @since 3.6.0
- * @category formatting
- */
-export const formatIsoDate: (self: DateTime) => string = Internal.formatIsoDate
-
-/**
- * Format a `DateTime` as a UTC ISO date string.
- *
- * @since 3.6.0
- * @category formatting
- */
-export const formatIsoDateUtc: (self: DateTime) => string = Internal.formatIsoDateUtc
-
-/**
- * Format a `DateTime.Zoned` as a ISO string with an offset.
- *
- * @since 3.6.0
- * @category formatting
- */
-export const formatIsoOffset: (self: DateTime) => string = Internal.formatIsoOffset
-
-/**
- * Format a `DateTime.Zoned` as a string.
- *
- * It uses the format: `YYYY-MM-DDTHH:mm:ss.sss+HH:MM[Time/Zone]`.
- *
- * @since 3.6.0
- * @category formatting
- */
-export const formatIsoZoned: (self: Zoned) => string = Internal.formatIsoZoned
-
-/**
- * Create a Layer from the given time zone.
- *
- * @since 3.6.0
- * @category current time zone
- */
-export const layerCurrentZone = (zone: TimeZone): Layer.Layer<CurrentTimeZone> => Layer.succeed(CurrentTimeZone, zone)
-
-/**
- * Create a Layer from the given time zone offset.
- *
- * @since 3.6.0
- * @category current time zone
- */
-export const layerCurrentZoneOffset = (offset: number): Layer.Layer<CurrentTimeZone> =>
-  Layer.succeed(CurrentTimeZone, Internal.zoneMakeOffset(offset))
-
-/**
- * Create a Layer from the given IANA time zone identifier.
- *
- * @since 3.6.0
- * @category current time zone
- */
-export const layerCurrentZoneNamed = (
-  zoneId: string
-): Layer.Layer<CurrentTimeZone, IllegalArgumentException> =>
-  Layer.effect(CurrentTimeZone, Internal.zoneMakeNamedEffect(zoneId))
-
-/**
- * Create a Layer from the systems local time zone.
- *
- * @since 3.6.0
- * @category current time zone
- */
-export const layerCurrentZoneLocal: Layer.Layer<CurrentTimeZone> = Layer.sync(CurrentTimeZone, zoneMakeLocal)