chronolizer 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,969 @@
+import { Context, DateTime, Effect, Layer, Option, Schema, Scope } from "effect";
+//#region src/ast/schemas.d.ts
+declare const Unit: Schema.Literals<readonly ["day", "week", "month", "quarter", "year"]>;
+type Unit = typeof Unit.Type;
+declare const daysInMonth: (year: number, month: number) => 28 | 29 | 30 | 31;
+declare const isIsoDate: (value: string) => boolean;
+declare const IsoDate: Schema.String;
+type IsoDate = typeof IsoDate.Type;
+interface Now {
+  readonly _tag: "Now";
+}
+interface DateLiteral {
+  readonly _tag: "DateLiteral";
+  readonly value: IsoDate;
+}
+interface Shift {
+  readonly _tag: "Shift";
+  readonly base: InstantExpr;
+  readonly amount: number;
+  readonly unit: Unit;
+}
+interface StartOf {
+  readonly _tag: "StartOf";
+  readonly base: InstantExpr;
+  readonly unit: Unit;
+}
+type InstantExpr = Now | DateLiteral | Shift | StartOf;
+declare const Now: Schema.TaggedStruct<"Now", {}>;
+declare const DateLiteral: Schema.TaggedStruct<"DateLiteral", {
+  readonly value: Schema.String;
+}>;
+declare const Shift: Schema.Codec<Shift>;
+declare const StartOf: Schema.Codec<StartOf>;
+declare const InstantExpr: Schema.Codec<InstantExpr>;
+declare const GreaterThan: Schema.TaggedStruct<"GreaterThan", {
+  readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+}>;
+declare const GreaterThanOrEqual: Schema.TaggedStruct<"GreaterThanOrEqual", {
+  readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+}>;
+declare const LessThan: Schema.TaggedStruct<"LessThan", {
+  readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+}>;
+declare const LessThanOrEqual: Schema.TaggedStruct<"LessThanOrEqual", {
+  readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+}>;
+declare const LowerBound: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+  readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+}>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+  readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+}>]>;
+type LowerBound = typeof LowerBound.Type;
+declare const UpperBound: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+  readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+}>, Schema.TaggedStruct<"LessThanOrEqual", {
+  readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+}>]>;
+type UpperBound = typeof UpperBound.Type;
+declare const DateRangeExpr: Schema.Union<readonly [Schema.TaggedStruct<"DateRange", {
+  readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>]>;
+  readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>, Schema.TaggedStruct<"LessThanOrEqual", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>]>;
+}>, Schema.TaggedStruct<"DateRange", {
+  readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>]>;
+  readonly upper: Schema.optionalKey<Schema.Never>;
+}>, Schema.TaggedStruct<"DateRange", {
+  readonly lower: Schema.optionalKey<Schema.Never>;
+  readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>, Schema.TaggedStruct<"LessThanOrEqual", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>]>;
+}>]>;
+type DateRangeExpr = typeof DateRangeExpr.Type;
+//#endregion
+//#region src/ast/constructors.d.ts
+declare const now: () => {
+  readonly _tag: "Now";
+};
+declare const dateLiteral: (value: IsoDate) => {
+  readonly _tag: "DateLiteral";
+  readonly value: string;
+};
+declare const shift: (base: InstantExpr, amount: number, unit: Unit) => Shift;
+declare const startOf: (base: InstantExpr, unit: Unit) => StartOf;
+declare const greaterThan: (value: InstantExpr) => {
+  readonly _tag: "GreaterThan";
+  readonly value: InstantExpr;
+};
+declare const greaterThanOrEqual: (value: InstantExpr) => {
+  readonly _tag: "GreaterThanOrEqual";
+  readonly value: InstantExpr;
+};
+declare const lessThan: (value: InstantExpr) => {
+  readonly _tag: "LessThan";
+  readonly value: InstantExpr;
+};
+declare const lessThanOrEqual: (value: InstantExpr) => {
+  readonly _tag: "LessThanOrEqual";
+  readonly value: InstantExpr;
+};
+declare const boundedRange: (lower: LowerBound, upper: UpperBound) => {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+} | {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper?: undefined;
+} | {
+  readonly _tag: "DateRange";
+  readonly lower?: undefined;
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+};
+declare const lowerOpenRange: (lower: LowerBound) => {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+} | {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper?: undefined;
+} | {
+  readonly _tag: "DateRange";
+  readonly lower?: undefined;
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+};
+declare const upperOpenRange: (upper: UpperBound) => {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+} | {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper?: undefined;
+} | {
+  readonly _tag: "DateRange";
+  readonly lower?: undefined;
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+};
+//#endregion
+//#region src/ast/fold.d.ts
+interface InstantAlgebra<A> {
+  readonly now: () => A;
+  readonly dateLiteral: (value: IsoDate) => A;
+  readonly shift: (base: A, amount: number, unit: Unit) => A;
+  readonly startOf: (base: A, unit: Unit) => A;
+}
+declare const foldInstant: <A>(expression: InstantExpr, algebra: InstantAlgebra<A>) => A;
+declare const containsPositiveShift: (range: DateRangeExpr) => boolean;
+//#endregion
+//#region src/ast/normalize.d.ts
+declare const normalizeInstant: (expression: InstantExpr) => InstantExpr;
+declare const normalizeRange: (range: DateRangeExpr) => {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+} | {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper?: undefined;
+} | {
+  readonly _tag: "DateRange";
+  readonly lower?: undefined;
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+};
+//#endregion
+//#region src/filter/errors.d.ts
+declare const FilterExpressionParseError_base: Schema.Class<FilterExpressionParseError, Schema.TaggedStruct<"FilterExpressionParseError", {
+  readonly input: Schema.String;
+  readonly offset: Schema.Int;
+  readonly expected: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class FilterExpressionParseError extends FilterExpressionParseError_base {}
+declare const InvalidDateFilterError_base: Schema.Class<InvalidDateFilterError, Schema.TaggedStruct<"InvalidDateFilterError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class InvalidDateFilterError extends InvalidDateFilterError_base {}
+//#endregion
+//#region src/filter/codec.d.ts
+declare const parseFilter: (filter: {
+  readonly gt?: string | undefined;
+  readonly gte?: string | undefined;
+  readonly lt?: string | undefined;
+  readonly lte?: string | undefined;
+}) => Effect.Effect<{
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+} | {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper?: undefined;
+} | {
+  readonly _tag: "DateRange";
+  readonly lower?: undefined;
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+}, FilterExpressionParseError | InvalidDateFilterError, never>;
+declare const formatFilter: (range: DateRangeExpr) => {
+  readonly gt?: string | undefined;
+  readonly gte?: string | undefined;
+  readonly lt?: string | undefined;
+  readonly lte?: string | undefined;
+};
+declare const rangeKey: (range: DateRangeExpr) => string;
+declare const completePeriod: (start: InstantExpr, end: InstantExpr) => {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+} | {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper?: undefined;
+} | {
+  readonly _tag: "DateRange";
+  readonly lower?: undefined;
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+};
+//#endregion
+//#region src/filter/expression.d.ts
+declare const parseInstantExpression: (input: string) => Effect.Effect<InstantExpr, FilterExpressionParseError, never>;
+declare const formatInstantExpression: (expression: InstantExpr) => string;
+//#endregion
+//#region src/filter/schema.d.ts
+declare const DateExpressionString: Schema.String;
+type DateExpressionString = typeof DateExpressionString.Type;
+declare const DateFilter: Schema.Struct<{
+  readonly gt: Schema.optionalKey<Schema.String>;
+  readonly gte: Schema.optionalKey<Schema.String>;
+  readonly lt: Schema.optionalKey<Schema.String>;
+  readonly lte: Schema.optionalKey<Schema.String>;
+}>;
+type DateFilter = typeof DateFilter.Type;
+//#endregion
+//#region src/filter/transformation.d.ts
+declare const InstantExpressionFromString: Schema.decodeTo<Schema.Codec<InstantExpr, InstantExpr, never, never>, Schema.String, never, never>;
+declare const DateRangeFromFilter: Schema.decodeTo<Schema.Union<readonly [Schema.TaggedStruct<"DateRange", {
+  readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>]>;
+  readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>, Schema.TaggedStruct<"LessThanOrEqual", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>]>;
+}>, Schema.TaggedStruct<"DateRange", {
+  readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>]>;
+  readonly upper: Schema.optionalKey<Schema.Never>;
+}>, Schema.TaggedStruct<"DateRange", {
+  readonly lower: Schema.optionalKey<Schema.Never>;
+  readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>, Schema.TaggedStruct<"LessThanOrEqual", {
+    readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+  }>]>;
+}>]>, Schema.Struct<{
+  readonly gt: Schema.optionalKey<Schema.String>;
+  readonly gte: Schema.optionalKey<Schema.String>;
+  readonly lt: Schema.optionalKey<Schema.String>;
+  readonly lte: Schema.optionalKey<Schema.String>;
+}>, never, never>;
+//#endregion
+//#region src/language/errors.d.ts
+declare const UnsupportedLocaleError_base: Schema.Class<UnsupportedLocaleError, Schema.TaggedStruct<"UnsupportedLocaleError", {
+  readonly locale: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class UnsupportedLocaleError extends UnsupportedLocaleError_base {}
+declare const LanguageConflictError_base: Schema.Class<LanguageConflictError, Schema.TaggedStruct<"LanguageConflictError", {
+  readonly locale: Schema.String;
+  readonly firstPluginId: Schema.String;
+  readonly secondPluginId: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class LanguageConflictError extends LanguageConflictError_base {}
+declare const LanguageRegistrationError_base: Schema.Class<LanguageRegistrationError, Schema.TaggedStruct<"LanguageRegistrationError", {
+  readonly pluginId: Schema.String;
+  readonly locale: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class LanguageRegistrationError extends LanguageRegistrationError_base {}
+declare const NaturalLanguageParseError_base: Schema.Class<NaturalLanguageParseError, Schema.TaggedStruct<"NaturalLanguageParseError", {
+  readonly input: Schema.String;
+  readonly locale: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class NaturalLanguageParseError extends NaturalLanguageParseError_base {}
+declare const AmbiguousNaturalLanguageError_base: Schema.Class<AmbiguousNaturalLanguageError, Schema.TaggedStruct<"AmbiguousNaturalLanguageError", {
+  readonly input: Schema.String;
+  readonly locale: Schema.String;
+  readonly alternatives: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+declare class AmbiguousNaturalLanguageError extends AmbiguousNaturalLanguageError_base {}
+declare const NaturalLanguageRenderError_base: Schema.Class<NaturalLanguageRenderError, Schema.TaggedStruct<"NaturalLanguageRenderError", {
+  readonly locale: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class NaturalLanguageRenderError extends NaturalLanguageRenderError_base {}
+//#endregion
+//#region src/language/model.d.ts
+declare const ParseQuality: Schema.Literals<readonly ["exact", "corrected", "ambiguous"]>;
+type ParseQuality = typeof ParseQuality.Type;
+declare const Correction: Schema.Struct<{
+  readonly original: Schema.String;
+  readonly replacement: Schema.String;
+  readonly distance: Schema.Int;
+  readonly offset: Schema.Int;
+}>;
+type Correction = typeof Correction.Type;
+declare const NaturalCorrectionCandidate: Schema.Struct<{
+  readonly text: Schema.String;
+  readonly corrections: Schema.$Array<Schema.Struct<{
+    readonly original: Schema.String;
+    readonly replacement: Schema.String;
+    readonly distance: Schema.Int;
+    readonly offset: Schema.Int;
+  }>>;
+  readonly cost: Schema.Int;
+}>;
+type NaturalCorrectionCandidate = typeof NaturalCorrectionCandidate.Type;
+declare const NaturalAlternative: Schema.Struct<{
+  readonly canonical: Schema.String;
+  readonly range: Schema.Union<readonly [Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+    readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"LessThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+  }>, Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+    readonly upper: Schema.optionalKey<Schema.Never>;
+  }>, Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.optionalKey<Schema.Never>;
+    readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"LessThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+  }>]>;
+}>;
+type NaturalAlternative = typeof NaturalAlternative.Type;
+declare const NaturalParseResult: Schema.Struct<{
+  readonly range: Schema.Union<readonly [Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+    readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"LessThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+  }>, Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+    readonly upper: Schema.optionalKey<Schema.Never>;
+  }>, Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.optionalKey<Schema.Never>;
+    readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"LessThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+  }>]>;
+  readonly quality: Schema.Literals<readonly ["exact", "corrected", "ambiguous"]>;
+  readonly corrections: Schema.$Array<Schema.Struct<{
+    readonly original: Schema.String;
+    readonly replacement: Schema.String;
+    readonly distance: Schema.Int;
+    readonly offset: Schema.Int;
+  }>>;
+  readonly alternatives: Schema.$Array<Schema.Struct<{
+    readonly canonical: Schema.String;
+    readonly range: Schema.Union<readonly [Schema.TaggedStruct<"DateRange", {
+      readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+        readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+      }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+        readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+      }>]>;
+      readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+        readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+      }>, Schema.TaggedStruct<"LessThanOrEqual", {
+        readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+      }>]>;
+    }>, Schema.TaggedStruct<"DateRange", {
+      readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+        readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+      }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+        readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+      }>]>;
+      readonly upper: Schema.optionalKey<Schema.Never>;
+    }>, Schema.TaggedStruct<"DateRange", {
+      readonly lower: Schema.optionalKey<Schema.Never>;
+      readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+        readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+      }>, Schema.TaggedStruct<"LessThanOrEqual", {
+        readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+      }>]>;
+    }>]>;
+  }>>;
+}>;
+type NaturalParseResult = typeof NaturalParseResult.Type;
+declare const NaturalCandidate: Schema.Struct<{
+  readonly range: Schema.Union<readonly [Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+    readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"LessThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+  }>, Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+    readonly upper: Schema.optionalKey<Schema.Never>;
+  }>, Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.optionalKey<Schema.Never>;
+    readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"LessThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+  }>]>;
+  readonly canonical: Schema.String;
+}>;
+type NaturalCandidate = typeof NaturalCandidate.Type;
+declare const BaseLanguageContribution_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Readonly<A> & {
+  readonly _tag: "BaseLanguage";
+} & import("effect/Pipeable").Pipeable;
+declare class BaseLanguageContribution extends BaseLanguageContribution_base<{
+  readonly locale: string;
+  readonly vocabulary: ReadonlyArray<string>;
+  readonly normalize?: (input: string, locale: string) => string;
+  readonly correct: ((input: string, vocabulary: ReadonlyArray<string>) => ReadonlyArray<NaturalCorrectionCandidate>) | undefined;
+  readonly parseExact: (input: string) => Option.Option<NaturalCandidate>;
+  readonly render: (range: DateRangeExpr) => Option.Option<string>;
+}> {}
+declare const LanguageExtensionContribution_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Readonly<A> & {
+  readonly _tag: "LanguageExtension";
+} & import("effect/Pipeable").Pipeable;
+declare class LanguageExtensionContribution extends LanguageExtensionContribution_base<{
+  readonly locale: string;
+  readonly priority: number;
+  readonly vocabulary: ReadonlyArray<string>;
+  readonly parseExact: (input: string) => Option.Option<NaturalCandidate>;
+}> {}
+type LanguageContribution = BaseLanguageContribution | LanguageExtensionContribution;
+declare const canonicalBaseLocale: (input: string) => Option.Option<string>;
+declare const Locale: Schema.String;
+declare const BaseLanguageMetadata: Schema.TaggedStruct<"BaseLanguage", {
+  readonly locale: Schema.String;
+  readonly vocabulary: Schema.$Array<Schema.String>;
+}>;
+declare const LanguageExtensionMetadata: Schema.TaggedStruct<"LanguageExtension", {
+  readonly locale: Schema.String;
+  readonly priority: Schema.Int;
+  readonly vocabulary: Schema.$Array<Schema.String>;
+}>;
+declare const LanguageContributionMetadata: Schema.Union<readonly [Schema.TaggedStruct<"BaseLanguage", {
+  readonly locale: Schema.String;
+  readonly vocabulary: Schema.$Array<Schema.String>;
+}>, Schema.TaggedStruct<"LanguageExtension", {
+  readonly locale: Schema.String;
+  readonly priority: Schema.Int;
+  readonly vocabulary: Schema.$Array<Schema.String>;
+}>]>;
+interface LanguagePluginContext {
+  readonly register: (pluginId: string, contribution: LanguageContribution) => Effect.Effect<void, LanguageRegistrationError | LanguageConflictError, Scope.Scope>;
+}
+interface LanguagePlugin {
+  readonly id: string;
+  readonly effect: (context: LanguagePluginContext) => Effect.Effect<void, LanguageRegistrationError | LanguageConflictError, Scope.Scope>;
+}
+interface CompiledLanguage {
+  readonly locale: string;
+  readonly vocabulary: ReadonlyArray<string>;
+  readonly normalize: (input: string, locale: string) => string;
+  readonly correct: ((input: string, vocabulary: ReadonlyArray<string>) => ReadonlyArray<NaturalCorrectionCandidate>) | undefined;
+  readonly parseExact: (input: string) => ReadonlyArray<NaturalCandidate>;
+  readonly render: (range: DateRangeExpr) => Option.Option<string>;
+}
+//#endregion
+//#region src/language/registry.d.ts
+declare namespace LanguageRegistry {
+  interface Service {
+    readonly register: (pluginId: string, contribution: LanguageContribution) => Effect.Effect<void, LanguageRegistrationError | LanguageConflictError, Scope.Scope>;
+    readonly resolve: (locale: string) => Effect.Effect<CompiledLanguage, UnsupportedLocaleError>;
+  }
+}
+declare const LanguageRegistry_base: Context.ServiceClass<LanguageRegistry, "chronolizer/LanguageRegistry", LanguageRegistry.Service>;
+declare class LanguageRegistry extends LanguageRegistry_base {}
+declare const LanguageRegistryLayer: Layer.Layer<LanguageRegistry, never, never>;
+declare const languagePluginsLayer: (plugins: ReadonlyArray<LanguagePlugin>) => Layer.Layer<LanguageRegistry, LanguageConflictError | LanguageRegistrationError, never>;
+declare const defineLanguagePlugin: (plugin: LanguagePlugin) => LanguagePlugin;
+//#endregion
+//#region src/locales/de.d.ts
+declare const GermanContribution: BaseLanguageContribution;
+declare const GermanLanguage: LanguagePlugin;
+declare const GermanLanguageLayer: import("effect/Layer").Layer<LanguageRegistry, LanguageConflictError | LanguageRegistrationError, never>;
+//#endregion
+//#region src/locales/default.d.ts
+declare const DefaultLanguageLayer: import("effect/Layer").Layer<LanguageRegistry, LanguageConflictError | LanguageRegistrationError, never>;
+//#endregion
+//#region src/locales/en.d.ts
+declare const EnglishContribution: BaseLanguageContribution;
+declare const EnglishLanguage: LanguagePlugin;
+declare const EnglishLanguageLayer: import("effect/Layer").Layer<LanguageRegistry, LanguageConflictError | LanguageRegistrationError, never>;
+//#endregion
+//#region src/natural/api.d.ts
+interface ParseNaturalOptions {
+  readonly locale: string;
+  readonly typoMode?: "strict" | "tolerant";
+  readonly allowFuture?: boolean;
+}
+interface FormatNaturalOptions {
+  readonly locale: string;
+}
+declare const parseNatural: (input: string, options: ParseNaturalOptions) => Effect.Effect<{
+  readonly range: {
+    readonly _tag: "DateRange";
+    readonly lower: {
+      readonly _tag: "GreaterThan";
+      readonly value: InstantExpr;
+    } | {
+      readonly _tag: "GreaterThanOrEqual";
+      readonly value: InstantExpr;
+    };
+    readonly upper: {
+      readonly _tag: "LessThan";
+      readonly value: InstantExpr;
+    } | {
+      readonly _tag: "LessThanOrEqual";
+      readonly value: InstantExpr;
+    };
+  } | {
+    readonly _tag: "DateRange";
+    readonly lower: {
+      readonly _tag: "GreaterThan";
+      readonly value: InstantExpr;
+    } | {
+      readonly _tag: "GreaterThanOrEqual";
+      readonly value: InstantExpr;
+    };
+    readonly upper?: undefined;
+  } | {
+    readonly _tag: "DateRange";
+    readonly lower?: undefined;
+    readonly upper: {
+      readonly _tag: "LessThan";
+      readonly value: InstantExpr;
+    } | {
+      readonly _tag: "LessThanOrEqual";
+      readonly value: InstantExpr;
+    };
+  };
+  readonly quality: "ambiguous" | "corrected" | "exact";
+  readonly corrections: readonly {
+    readonly original: string;
+    readonly replacement: string;
+    readonly distance: number;
+    readonly offset: number;
+  }[];
+  readonly alternatives: readonly {
+    readonly canonical: string;
+    readonly range: {
+      readonly _tag: "DateRange";
+      readonly lower: {
+        readonly _tag: "GreaterThan";
+        readonly value: InstantExpr;
+      } | {
+        readonly _tag: "GreaterThanOrEqual";
+        readonly value: InstantExpr;
+      };
+      readonly upper: {
+        readonly _tag: "LessThan";
+        readonly value: InstantExpr;
+      } | {
+        readonly _tag: "LessThanOrEqual";
+        readonly value: InstantExpr;
+      };
+    } | {
+      readonly _tag: "DateRange";
+      readonly lower: {
+        readonly _tag: "GreaterThan";
+        readonly value: InstantExpr;
+      } | {
+        readonly _tag: "GreaterThanOrEqual";
+        readonly value: InstantExpr;
+      };
+      readonly upper?: undefined;
+    } | {
+      readonly _tag: "DateRange";
+      readonly lower?: undefined;
+      readonly upper: {
+        readonly _tag: "LessThan";
+        readonly value: InstantExpr;
+      } | {
+        readonly _tag: "LessThanOrEqual";
+        readonly value: InstantExpr;
+      };
+    };
+  }[];
+}, NaturalLanguageParseError | UnsupportedLocaleError, LanguageRegistry>;
+declare const formatNatural: (range: {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+} | {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper?: undefined;
+} | {
+  readonly _tag: "DateRange";
+  readonly lower?: undefined;
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+}, options: FormatNaturalOptions) => Effect.Effect<string, NaturalLanguageRenderError | UnsupportedLocaleError, LanguageRegistry>;
+//#endregion
+//#region src/natural/correction.d.ts
+declare const correctWhitespaceSeparatedText: (input: string, vocabulary: ReadonlyArray<string>) => {
+  readonly text: string;
+  readonly corrections: readonly {
+    readonly original: string;
+    readonly replacement: string;
+    readonly distance: number;
+    readonly offset: number;
+  }[];
+  readonly cost: number;
+}[];
+//#endregion
+//#region src/natural/text.d.ts
+declare const normalizeNaturalText: (input: string, locale: string) => string;
+declare const naturalWords: (input: string) => string[];
+//#endregion
+//#region src/resolve/schema.d.ts
+declare const ResolvedGreaterThan: Schema.TaggedStruct<"GreaterThan", {
+  readonly value: Schema.DateTimeZoned;
+}>;
+declare const ResolvedGreaterThanOrEqual: Schema.TaggedStruct<"GreaterThanOrEqual", {
+  readonly value: Schema.DateTimeZoned;
+}>;
+declare const ResolvedLessThan: Schema.TaggedStruct<"LessThan", {
+  readonly value: Schema.DateTimeZoned;
+}>;
+declare const ResolvedLessThanOrEqual: Schema.TaggedStruct<"LessThanOrEqual", {
+  readonly value: Schema.DateTimeZoned;
+}>;
+declare const ResolvedLowerBound: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+  readonly value: Schema.DateTimeZoned;
+}>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+  readonly value: Schema.DateTimeZoned;
+}>]>;
+type ResolvedLowerBound = typeof ResolvedLowerBound.Type;
+declare const ResolvedUpperBound: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+  readonly value: Schema.DateTimeZoned;
+}>, Schema.TaggedStruct<"LessThanOrEqual", {
+  readonly value: Schema.DateTimeZoned;
+}>]>;
+type ResolvedUpperBound = typeof ResolvedUpperBound.Type;
+declare const ResolvedDateRange: Schema.Union<readonly [Schema.TaggedStruct<"ResolvedDateRange", {
+  readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+    readonly value: Schema.DateTimeZoned;
+  }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+    readonly value: Schema.DateTimeZoned;
+  }>]>;
+  readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+    readonly value: Schema.DateTimeZoned;
+  }>, Schema.TaggedStruct<"LessThanOrEqual", {
+    readonly value: Schema.DateTimeZoned;
+  }>]>;
+}>, Schema.TaggedStruct<"ResolvedDateRange", {
+  readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+    readonly value: Schema.DateTimeZoned;
+  }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+    readonly value: Schema.DateTimeZoned;
+  }>]>;
+  readonly upper: Schema.optionalKey<Schema.Never>;
+}>, Schema.TaggedStruct<"ResolvedDateRange", {
+  readonly lower: Schema.optionalKey<Schema.Never>;
+  readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+    readonly value: Schema.DateTimeZoned;
+  }>, Schema.TaggedStruct<"LessThanOrEqual", {
+    readonly value: Schema.DateTimeZoned;
+  }>]>;
+}>]>;
+type ResolvedDateRange = typeof ResolvedDateRange.Type;
+declare const ResolutionError_base: Schema.Class<ResolutionError, Schema.TaggedStruct<"ResolutionError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ResolutionError extends ResolutionError_base {}
+//#endregion
+//#region src/resolve/resolve.d.ts
+declare const resolve: (range: {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+} | {
+  readonly _tag: "DateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: InstantExpr;
+  };
+  readonly upper?: undefined;
+} | {
+  readonly _tag: "DateRange";
+  readonly lower?: undefined;
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+}) => Effect.Effect<{
+  readonly _tag: "ResolvedDateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: DateTime.Zoned;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: DateTime.Zoned;
+  };
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: DateTime.Zoned;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: DateTime.Zoned;
+  };
+} | {
+  readonly _tag: "ResolvedDateRange";
+  readonly lower: {
+    readonly _tag: "GreaterThan";
+    readonly value: DateTime.Zoned;
+  } | {
+    readonly _tag: "GreaterThanOrEqual";
+    readonly value: DateTime.Zoned;
+  };
+  readonly upper?: undefined;
+} | {
+  readonly _tag: "ResolvedDateRange";
+  readonly lower?: undefined;
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: DateTime.Zoned;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: DateTime.Zoned;
+  };
+}, ResolutionError, DateTime.CurrentTimeZone>;
+//#endregion
+export { AmbiguousNaturalLanguageError, BaseLanguageContribution, BaseLanguageMetadata, CompiledLanguage, Correction, DateExpressionString, DateFilter, DateLiteral, DateRangeExpr, DateRangeFromFilter, DefaultLanguageLayer, EnglishContribution, EnglishLanguage, EnglishLanguageLayer, FilterExpressionParseError, FormatNaturalOptions, GermanContribution, GermanLanguage, GermanLanguageLayer, GreaterThan, GreaterThanOrEqual, InstantAlgebra, InstantExpr, InstantExpressionFromString, InvalidDateFilterError, IsoDate, LanguageConflictError, LanguageContribution, LanguageContributionMetadata, LanguageExtensionContribution, LanguageExtensionMetadata, LanguagePlugin, LanguagePluginContext, LanguageRegistrationError, LanguageRegistry, LanguageRegistryLayer, LessThan, LessThanOrEqual, Locale, LowerBound, NaturalAlternative, NaturalCandidate, NaturalCorrectionCandidate, NaturalLanguageParseError, NaturalLanguageRenderError, NaturalParseResult, Now, ParseNaturalOptions, ParseQuality, ResolutionError, ResolvedDateRange, ResolvedGreaterThan, ResolvedGreaterThanOrEqual, ResolvedLessThan, ResolvedLessThanOrEqual, ResolvedLowerBound, ResolvedUpperBound, Shift, StartOf, Unit, UnsupportedLocaleError, UpperBound, boundedRange, canonicalBaseLocale, completePeriod, containsPositiveShift, correctWhitespaceSeparatedText, dateLiteral, daysInMonth, defineLanguagePlugin, foldInstant, formatFilter, formatInstantExpression, formatNatural, greaterThan, greaterThanOrEqual, isIsoDate, languagePluginsLayer, lessThan, lessThanOrEqual, lowerOpenRange, naturalWords, normalizeInstant, normalizeNaturalText, normalizeRange, now, parseFilter, parseInstantExpression, parseNatural, rangeKey, resolve, shift, startOf, upperOpenRange };