chronolizer 0.1.0 → 0.2.0

package/README.md

@@ -2,12 +2,27 @@
 
 Chronolizer is an Effect v4 library for bidirectional natural-language date ranges.
 
-It converts complete English and German date-range expressions to a small date-math format. It also renders supported ranges to canonical natural language and resolves the AST with an explicit Effect time zone.
+It converts complete English, German, Spanish, French, Dutch, Turkish, Czech, and Polish date-range expressions to a small date-math format. It also renders supported ranges to canonical natural language and resolves the AST with an explicit Effect time zone.
 
 ## Status
 
 This package uses `effect@4.0.0-rc.112`. Its API can change while Effect v4 is in release-candidate status.
 
+## Package entry points
+
+Chronolizer is side-effect free and publishes separate ESM entry points:
+
+```ts
+import { formatNatural, parseFilter, parseNatural, resolve, suggestNatural } from "chronolizer";
+import { GermanLanguageLayer } from "chronolizer/locales/de";
+```
+
+- `chronolizer` is the single main API entry. It also includes the English language pack.
+- `chronolizer/locales/en`, `chronolizer/locales/de`, `chronolizer/locales/es`, `chronolizer/locales/fr`, `chronolizer/locales/nl`, `chronolizer/locales/tr`, `chronolizer/locales/cs`, and `chronolizer/locales/pl` expose language packs separately.
+- Every non-English language must be imported from its own locale subpath.
+
+The package declares `sideEffects: false`, so consumer bundlers can remove unused main API exports. The package build runs Publint and Are the Types Wrong. CI checks transitive gzip limits and verifies that the main entry does not load non-English locales.
+
 ## Main concepts
 
 - Effect Schema owns the date AST, filter data, results, and errors.
@@ -22,7 +37,7 @@ This package uses `effect@4.0.0-rc.112`. Its API can change while Effect v4 is i
 ## Natural language to filter
 
 ```ts
-import { DefaultLanguageLayer, formatFilter, parseNatural } from "chronolizer";
+import { EnglishLanguageLayer, formatFilter, parseNatural } from "chronolizer";
 import { Effect } from "effect";
 
 const run = Effect.fn(function* () {
@@ -32,7 +47,7 @@ const run = Effect.fn(function* () {
   });
 
   return formatFilter(result.range);
-}, Effect.provide(DefaultLanguageLayer));
+}, Effect.provide(EnglishLanguageLayer));
 
 const program = run();
 
@@ -60,7 +75,27 @@ seit Januar 2025                -> { gte: "2025-01-01" }
 
 Chronolizer parses the complete input. It does not extract a date phrase from a larger sentence.
 
-Supported families include named and abbreviated months, named dates, quarters, weekends, period starts and ends, past and future rolling windows, calendar offsets, open boundaries, `now`-bounded ranges, and explicit inclusive connectors. English and German use their own grammar and canonical forms.
+Supported families include named and abbreviated months, named dates, quarters, weekends, period starts and ends, past and future rolling windows, calendar offsets, open boundaries, `now`-bounded ranges, and explicit inclusive connectors. Each language uses its own grammar and canonical forms.
+
+## Autocomplete natural language
+
+Use `suggestNatural()` for autocomplete fields. Each Schema-owned suggestion contains canonical display text and the semantic range that it represents:
+
+```ts
+import { EnglishLanguageLayer, suggestNatural } from "chronolizer";
+import { Effect } from "effect";
+
+const program = suggestNatural("last m", {
+  locale: "en",
+  limit: 5,
+}).pipe(Effect.provide(EnglishLanguageLayer));
+
+// [{ text: "last month", range: ... }]
+```
+
+Suggestions support incomplete words, bounded spelling errors, numeric rolling periods, and partial four-digit years. For example, `january 202` suggests `January 2020`, `January 2021`, and later matching years. Every returned suggestion is checked by the exact parser. `allowFuture: false` applies the same positive-relative-range policy as `parseNatural()`.
+
+The default limit is 10. The maximum accepted limit is 100. A nonpositive or invalid limit returns no suggestions.
 
 ### Exclude positive relative ranges
 
@@ -78,7 +113,8 @@ This option rejects relative forms such as `next month`, `this year`, and `in 3
 ## Filter to natural language
 
 ```ts
-import { DefaultLanguageLayer, formatNatural, parseFilter } from "chronolizer";
+import { formatNatural, parseFilter } from "chronolizer";
+import { GermanLanguageLayer } from "chronolizer/locales/de";
 import { Effect } from "effect";
 
 const run = Effect.fn(function* () {
@@ -88,7 +124,7 @@ const run = Effect.fn(function* () {
   });
 
   return yield* formatNatural(range, { locale: "de" });
-}, Effect.provide(DefaultLanguageLayer));
+}, Effect.provide(GermanLanguageLayer));
 
 const program = run();
 
@@ -170,22 +206,49 @@ Strict mode never runs correction.
 
 `LanguageRegistry` is an Effect service. A language is a scoped plugin contribution. `languagePluginsLayer` validates plugin identifiers, rejects conflicting base languages, applies deterministic extension order, and removes registrations when the Layer scope closes.
 
+Combine all required language plugins in one registry Layer:
+
+```ts
+import { EnglishLanguage, languagePluginsLayer, parseNatural } from "chronolizer";
+import { GermanLanguage } from "chronolizer/locales/de";
+import { PolishLanguage } from "chronolizer/locales/pl";
+import { Effect } from "effect";
+
+const Languages = languagePluginsLayer([EnglishLanguage, GermanLanguage, PolishLanguage]);
+
+const program = parseNatural("letzten Monat", {
+  locale: "de",
+}).pipe(Effect.provide(Languages));
+```
+
+Importing a language plugin does not register it globally. Do not merge individual `*LanguageLayer` values for multi-language use because each one creates a separate registry. Use `languagePluginsLayer([...plugins])` instead.
+
 Language identifiers use canonical BCP 47 base tags. Lookup removes one subtag at a time. For example, `zh-Hant-TW` tries `zh-Hant-TW`, `zh-Hant`, and then `zh`.
 
 Each base language owns:
 
 - exact parsing and canonical rendering;
+- autocomplete phrase generation;
 - optional text normalization;
 - its typo-correction strategy, which can be disabled;
 - vocabulary shared with registered language extensions.
 
+Language extensions can add both exact parsers and autocomplete phrases. The registry combines extension suggestions in the same deterministic order as extension parsers. The core accepts only suggestions that one of the compiled exact parsers can parse.
+
 `normalizeNaturalText` and `correctWhitespaceSeparatedText` are available for languages that use whitespace-separated words. A compact-script language can provide character, dictionary, or `Intl.Segmenter` based correction without changing Chronolizer core.
 
 Built-in plugins:
 
 - `EnglishLanguage`
 - `GermanLanguage`
-- `DefaultLanguageLayer`
+- `SpanishLanguage`
+- `FrenchLanguage`
+- `DutchLanguage`
+- `TurkishLanguage`
+- `CzechLanguage`
+- `PolishLanguage`
+
+Import every non-English language from its locale subpath. This keeps the main bundle small and makes language selection explicit.
 
 Chinese and Japanese language packs are not included yet.
 

package/dist/ast/constructors.d.mts

@@ -0,0 +1,140 @@
+import { InstantExpr, IsoDate, LowerBound, Shift, StartOf, Unit, UpperBound } from "./schemas.mjs";
+//#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?: never;
+} | {
+  readonly _tag: "DateRange";
+  readonly lower?: never;
+  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?: never;
+} | {
+  readonly _tag: "DateRange";
+  readonly lower?: never;
+  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?: never;
+} | {
+  readonly _tag: "DateRange";
+  readonly lower?: never;
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+};
+//#endregion
+export { boundedRange, dateLiteral, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, lowerOpenRange, now, shift, startOf, upperOpenRange };

package/dist/ast/constructors.mjs

@@ -0,0 +1,25 @@
+import { DateLiteral, DateRangeExpr, GreaterThan, GreaterThanOrEqual, LessThan, LessThanOrEqual, Now, Shift, StartOf } from "./schemas.mjs";
+//#region src/ast/constructors.ts
+const now = () => Now.make({});
+const dateLiteral = (value) => DateLiteral.make({ value });
+const shift = (base, amount, unit) => Shift.make({
+	base,
+	amount,
+	unit
+});
+const startOf = (base, unit) => StartOf.make({
+	base,
+	unit
+});
+const greaterThan = (value) => GreaterThan.make({ value });
+const greaterThanOrEqual = (value) => GreaterThanOrEqual.make({ value });
+const lessThan = (value) => LessThan.make({ value });
+const lessThanOrEqual = (value) => LessThanOrEqual.make({ value });
+const boundedRange = (lower, upper) => DateRangeExpr.make({
+	lower,
+	upper
+});
+const lowerOpenRange = (lower) => DateRangeExpr.make({ lower });
+const upperOpenRange = (upper) => DateRangeExpr.make({ upper });
+//#endregion
+export { boundedRange, dateLiteral, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, lowerOpenRange, now, shift, startOf, upperOpenRange };

package/dist/ast/fold.d.mts

@@ -0,0 +1,12 @@
+import { DateRangeExpr, InstantExpr, IsoDate, Unit } from "./schemas.mjs";
+//#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
+export { InstantAlgebra, containsPositiveShift, foldInstant };

package/dist/ast/fold.mjs

@@ -0,0 +1,51 @@
+//#region src/ast/fold.ts
+const foldInstant = (expression, algebra) => {
+	switch (expression._tag) {
+		case "Now": return algebra.now();
+		case "DateLiteral": return algebra.dateLiteral(expression.value);
+		case "Shift": return algebra.shift(foldInstant(expression.base, algebra), expression.amount, expression.unit);
+		case "StartOf": return algebra.startOf(foldInstant(expression.base, algebra), expression.unit);
+	}
+};
+const shiftOffset = (base, amount, unit) => {
+	switch (unit) {
+		case "year": return {
+			...base,
+			months: base.months + amount * 12
+		};
+		case "quarter": return {
+			...base,
+			months: base.months + amount * 3
+		};
+		case "month": return {
+			...base,
+			months: base.months + amount
+		};
+		case "week": return {
+			...base,
+			days: base.days + amount * 7
+		};
+		case "day": return {
+			...base,
+			days: base.days + amount
+		};
+	}
+};
+const containsPositiveShiftInstant = (expression) => {
+	const offset = foldInstant(expression, {
+		now: () => ({
+			months: 0,
+			days: 0
+		}),
+		dateLiteral: () => ({
+			months: 0,
+			days: 0
+		}),
+		shift: shiftOffset,
+		startOf: (base) => base
+	});
+	return offset.months > 0 || offset.days > 0;
+};
+const containsPositiveShift = (range) => range.lower !== void 0 && containsPositiveShiftInstant(range.lower.value) || range.upper !== void 0 && containsPositiveShiftInstant(range.upper.value);
+//#endregion
+export { containsPositiveShift, foldInstant };

package/dist/ast/normalize.d.mts

@@ -0,0 +1,42 @@
+import { DateRangeExpr, InstantExpr } from "./schemas.mjs";
+//#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?: never;
+} | {
+  readonly _tag: "DateRange";
+  readonly lower?: never;
+  readonly upper: {
+    readonly _tag: "LessThan";
+    readonly value: InstantExpr;
+  } | {
+    readonly _tag: "LessThanOrEqual";
+    readonly value: InstantExpr;
+  };
+};
+//#endregion
+export { normalizeInstant, normalizeRange };

package/dist/ast/normalize.mjs

@@ -0,0 +1,32 @@
+import { boundedRange, dateLiteral, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, lowerOpenRange, now, shift, startOf, upperOpenRange } from "./constructors.mjs";
+import { Match } from "effect";
+//#region src/ast/normalize.ts
+const normalizeInstant = (expression) => Match.valueTags(expression, {
+	Now: () => now(),
+	DateLiteral: (literal) => dateLiteral(literal.value),
+	StartOf: (operation) => startOf(normalizeInstant(operation.base), operation.unit),
+	Shift: (operation) => {
+		const base = normalizeInstant(operation.base);
+		if (operation.amount === 0) return base;
+		if (base._tag === "Shift" && base.unit === operation.unit) {
+			const amount = base.amount + operation.amount;
+			if (Number.isSafeInteger(amount)) return normalizeInstant(shift(base.base, amount, operation.unit));
+		}
+		return shift(base, operation.amount, operation.unit);
+	}
+});
+const normalizeLower = (bound) => Match.valueTags(bound, {
+	GreaterThan: (value) => greaterThan(normalizeInstant(value.value)),
+	GreaterThanOrEqual: (value) => greaterThanOrEqual(normalizeInstant(value.value))
+});
+const normalizeUpper = (bound) => Match.valueTags(bound, {
+	LessThan: (value) => lessThan(normalizeInstant(value.value)),
+	LessThanOrEqual: (value) => lessThanOrEqual(normalizeInstant(value.value))
+});
+const normalizeRange = (range) => {
+	if (range.lower !== void 0 && range.upper !== void 0) return boundedRange(normalizeLower(range.lower), normalizeUpper(range.upper));
+	if (range.lower !== void 0) return lowerOpenRange(normalizeLower(range.lower));
+	return upperOpenRange(normalizeUpper(range.upper));
+};
+//#endregion
+export { normalizeInstant, normalizeRange };

package/dist/ast/schemas.d.mts

@@ -0,0 +1,87 @@
+import { Schema } 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
+export { DateLiteral, DateRangeExpr, GreaterThan, GreaterThanOrEqual, InstantExpr, IsoDate, LessThan, LessThanOrEqual, LowerBound, Now, Shift, StartOf, Unit, UpperBound, daysInMonth, isIsoDate };

package/dist/ast/schemas.mjs

@@ -0,0 +1,74 @@
+import { Option, Schema, String } from "effect";
+//#region src/ast/schemas.ts
+const Unit = Schema.Literals([
+	"day",
+	"week",
+	"month",
+	"quarter",
+	"year"
+]);
+const isLeapYear = (year) => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+const daysInMonth = (year, month) => {
+	switch (month) {
+		case 2: return isLeapYear(year) ? 29 : 28;
+		case 4:
+		case 6:
+		case 9:
+		case 11: return 30;
+		default: return 31;
+	}
+};
+const isIsoDate = (value) => {
+	if (Option.isNone(String.match(/^\d{4}-\d{2}-\d{2}$/)(value))) return false;
+	const year = Number(value.slice(0, 4));
+	const month = Number(value.slice(5, 7));
+	const day = Number(value.slice(8, 10));
+	return month >= 1 && month <= 12 && day >= 1 && day <= daysInMonth(year, month);
+};
+const IsoDate = Schema.String.check(Schema.makeFilter(isIsoDate, { expected: "an ISO calendar date (YYYY-MM-DD)" })).annotate({ identifier: "IsoDate" });
+const Now = Schema.TaggedStruct("Now", {});
+const DateLiteral = Schema.TaggedStruct("DateLiteral", { value: IsoDate });
+const ShiftAmount = Schema.Int.check(Schema.isBetween({
+	minimum: Number.MIN_SAFE_INTEGER,
+	maximum: Number.MAX_SAFE_INTEGER
+}));
+const Shift = Schema.TaggedStruct("Shift", {
+	base: Schema.suspend(() => InstantExpr),
+	amount: ShiftAmount,
+	unit: Unit
+});
+const StartOf = Schema.TaggedStruct("StartOf", {
+	base: Schema.suspend(() => InstantExpr),
+	unit: Unit
+});
+const InstantExpr = Schema.suspend(() => Schema.Union([
+	Now,
+	DateLiteral,
+	Shift,
+	StartOf
+])).annotate({ identifier: "InstantExpr" });
+const GreaterThan = Schema.TaggedStruct("GreaterThan", { value: InstantExpr });
+const GreaterThanOrEqual = Schema.TaggedStruct("GreaterThanOrEqual", { value: InstantExpr });
+const LessThan = Schema.TaggedStruct("LessThan", { value: InstantExpr });
+const LessThanOrEqual = Schema.TaggedStruct("LessThanOrEqual", { value: InstantExpr });
+const LowerBound = Schema.Union([GreaterThan, GreaterThanOrEqual]);
+const UpperBound = Schema.Union([LessThan, LessThanOrEqual]);
+const BoundedDateRange = Schema.TaggedStruct("DateRange", {
+	lower: LowerBound,
+	upper: UpperBound
+});
+const LowerOpenDateRange = Schema.TaggedStruct("DateRange", {
+	lower: LowerBound,
+	upper: Schema.optionalKey(Schema.Never)
+});
+const UpperOpenDateRange = Schema.TaggedStruct("DateRange", {
+	lower: Schema.optionalKey(Schema.Never),
+	upper: UpperBound
+});
+const DateRangeExpr = Schema.Union([
+	BoundedDateRange,
+	LowerOpenDateRange,
+	UpperOpenDateRange
+]).annotate({ identifier: "DateRangeExpr" });
+//#endregion
+export { DateLiteral, DateRangeExpr, GreaterThan, GreaterThanOrEqual, InstantExpr, IsoDate, LessThan, LessThanOrEqual, LowerBound, Now, Shift, StartOf, Unit, UpperBound, daysInMonth, isIsoDate };