@northguild/gmt 1.14.2

package/dist/duration/format/formatDuration.js

@@ -0,0 +1,93 @@
+import { Temporal } from "@js-temporal/polyfill";
+const UNIT_TO_INTL = {
+    years: "year",
+    months: "month",
+    weeks: "week",
+    days: "day",
+    hours: "hour",
+    minutes: "minute",
+    seconds: "second",
+};
+const UNITS_IN_ORDER = [
+    "years",
+    "months",
+    "weeks",
+    "days",
+    "hours",
+    "minutes",
+    "seconds",
+];
+/**
+ * Render an ISO 8601 duration string as a locale-aware, human-readable string.
+ *
+ * - Uses Temporal.Duration.from to parse, then Intl.NumberFormat({ style: "unit" })
+ *   to render each nonzero year/month/week/day/hour/minute/second component with
+ *   correct per-locale unit labels and pluralization, joined via Intl.ListFormat.
+ * - Sub-second components (milliseconds/microseconds/nanoseconds) are folded into
+ *   the seconds component as a fractional value (e.g. "PT1.5S" -> one "1.5 seconds"
+ *   component), since Intl.NumberFormat's "second" unit accepts fractional input.
+ * - By default, zero-valued components are omitted (e.g. "P1DT0H30M" -> "1 day, 30
+ *   minutes"). Pass { zero: true } to include them.
+ * - A zero-length duration (e.g. "PT0S") always renders its seconds component
+ *   ("0 seconds") even with the default zero-omitting behavior, since omitting
+ *   every component would otherwise produce "".
+ * - Negative durations render each component with a leading "-" (Temporal stores
+ *   every field of a negative duration as a negative number).
+ * - Returns "" for invalid input: non-string value or invalid duration string.
+ *
+ * @param value ISO 8601 duration string
+ * @param locale BCP 47 locale tag, passed to Intl.NumberFormat/Intl.ListFormat; system default if omitted
+ * @param options optional: { style: "long" | "short" | "narrow" (default "long"), zero: boolean (default false) }
+ * @returns human-readable rendering of the duration, or "" on invalid input
+ *
+ * @example formatDuration("P1DT2H30M", "en-US") // "1 day, 2 hours, and 30 minutes"
+ * @example formatDuration("PT90M", "en-US", { style: "short" }) // "90 min"
+ * @example formatDuration("PT90M", "en-US", { style: "narrow" }) // "90m"
+ * @example formatDuration("P1DT0H30M", "en-US") // "1 day and 30 minutes"
+ * @example formatDuration("PT0S", "en-US") // "0 seconds"
+ * @example formatDuration("-P1DT2H", "en-US") // "-1 day and -2 hours"
+ * @example formatDuration("P1DT2H30M", "de-DE") // "1 Tag, 2 Stunden und 30 Minuten"
+ * @example formatDuration("invalid") // ""
+ */
+export function formatDuration(value, locale, options = {}) {
+    if (typeof value !== "string") {
+        return "";
+    }
+    try {
+        const duration = Temporal.Duration.from(value);
+        const style = options.style ?? "long";
+        const includeZero = options.zero ?? false;
+        const seconds = duration.seconds +
+            duration.milliseconds / 1e3 +
+            duration.microseconds / 1e6 +
+            duration.nanoseconds / 1e9;
+        const amounts = {
+            years: duration.years,
+            months: duration.months,
+            weeks: duration.weeks,
+            days: duration.days,
+            hours: duration.hours,
+            minutes: duration.minutes,
+            seconds,
+        };
+        const parts = UNITS_IN_ORDER.filter((unit) => includeZero || amounts[unit] !== 0).map((unit) => new Intl.NumberFormat(locale, {
+            style: "unit",
+            unit: UNIT_TO_INTL[unit],
+            unitDisplay: style,
+        }).format(amounts[unit]));
+        if (parts.length === 0) {
+            parts.push(new Intl.NumberFormat(locale, {
+                style: "unit",
+                unit: "second",
+                unitDisplay: style,
+            }).format(0));
+        }
+        return new Intl.ListFormat(locale, {
+            style: style === "long" ? "long" : "short",
+            type: "conjunction",
+        }).format(parts);
+    }
+    catch {
+        return "";
+    }
+}

package/dist/duration/format/index.d.ts

@@ -0,0 +1 @@
+export * from "./formatDuration.js";

package/dist/duration/format/index.js

@@ -0,0 +1 @@
+export * from "./formatDuration.js";

package/dist/duration/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./calculate/index.js";
+export * from "./compare/index.js";
+export * from "./format/index.js";
+export * from "./normalize/index.js";
+export * from "./parse/index.js";
+export * from "./validate/index.js";

package/dist/duration/index.js

@@ -0,0 +1,6 @@
+export * from "./calculate/index.js";
+export * from "./compare/index.js";
+export * from "./format/index.js";
+export * from "./normalize/index.js";
+export * from "./parse/index.js";
+export * from "./validate/index.js";

package/dist/duration/normalize/index.d.ts

@@ -0,0 +1 @@
+export * from "./normalizeDuration.js";

package/dist/duration/normalize/index.js

@@ -0,0 +1 @@
+export * from "./normalizeDuration.js";

package/dist/duration/normalize/normalizeDuration.d.ts

@@ -0,0 +1,36 @@
+import { Temporal } from "@js-temporal/polyfill";
+import type { DurationRelativeTo } from "../../types/index.js";
+/**
+ * Roll an ISO 8601 duration string's small units into larger ones.
+ *
+ * - Uses Temporal.Duration.from and .round to rebalance, then .toString() to re-emit.
+ * - Defaults to { largestUnit: "auto" } when no options are given, which reformats a
+ *   day/time-only duration without promoting units (e.g. "PT90M" stays "PT90M" — pass
+ *   an explicit largestUnit to promote).
+ * - relativeTo is required whenever a calendar unit (year/month/week) is involved,
+ *   either as the requested largestUnit or because the input duration already has a
+ *   nonzero year/month/week component (this applies even under the "auto" default).
+ *   Without relativeTo in either case, returns "".
+ * - roundingIncrement must evenly divide 60 for minute/second (24 for hour);
+ *   unconstrained for day/week/month/year. An invalid increment returns "".
+ * - Returns "" for invalid input: non-string value, invalid duration string, or
+ *   invalid relativeTo.
+ *
+ * @param value ISO 8601 duration string
+ * @param options optional: { largestUnit, smallestUnit, roundingIncrement, roundingMode, relativeTo } per Temporal's Duration.round options
+ * @returns rebalanced ISO 8601 duration string, or "" on invalid input
+ *
+ * @example normalizeDuration("PT90M", { largestUnit: "hour" }) // "PT1H30M"
+ * @example normalizeDuration("PT90M30S", { smallestUnit: "minute" }) // "PT91M"
+ * @example normalizeDuration("P45D", { largestUnit: "month" }) // "" (relativeTo required)
+ * @example normalizeDuration("P45D", { largestUnit: "month", relativeTo: "2024-01-01" }) // "P1M14D"
+ * @example normalizeDuration("invalid") // ""
+ * @example normalizeDuration("P400D", { largestUnit: "year", relativeTo: "5784-06-15[u-ca=hebrew]" }) // "P1Y15D" (Hebrew leap year — relativeTo accepts GMT's calendar-annotated PlainDate string, not Temporal's own ISO-digit u-ca convention)
+ */
+export declare function normalizeDuration(value: string, options?: {
+    largestUnit?: Temporal.LargestUnit<Temporal.DateTimeUnit>;
+    smallestUnit?: Temporal.SmallestUnit<Temporal.DateTimeUnit>;
+    roundingIncrement?: number;
+    roundingMode?: Temporal.RoundingMode;
+    relativeTo?: DurationRelativeTo;
+}): string;

package/dist/duration/normalize/normalizeDuration.js

@@ -0,0 +1,49 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { resolveDurationRelativeTo } from "../../internal/index.js";
+/**
+ * Roll an ISO 8601 duration string's small units into larger ones.
+ *
+ * - Uses Temporal.Duration.from and .round to rebalance, then .toString() to re-emit.
+ * - Defaults to { largestUnit: "auto" } when no options are given, which reformats a
+ *   day/time-only duration without promoting units (e.g. "PT90M" stays "PT90M" — pass
+ *   an explicit largestUnit to promote).
+ * - relativeTo is required whenever a calendar unit (year/month/week) is involved,
+ *   either as the requested largestUnit or because the input duration already has a
+ *   nonzero year/month/week component (this applies even under the "auto" default).
+ *   Without relativeTo in either case, returns "".
+ * - roundingIncrement must evenly divide 60 for minute/second (24 for hour);
+ *   unconstrained for day/week/month/year. An invalid increment returns "".
+ * - Returns "" for invalid input: non-string value, invalid duration string, or
+ *   invalid relativeTo.
+ *
+ * @param value ISO 8601 duration string
+ * @param options optional: { largestUnit, smallestUnit, roundingIncrement, roundingMode, relativeTo } per Temporal's Duration.round options
+ * @returns rebalanced ISO 8601 duration string, or "" on invalid input
+ *
+ * @example normalizeDuration("PT90M", { largestUnit: "hour" }) // "PT1H30M"
+ * @example normalizeDuration("PT90M30S", { smallestUnit: "minute" }) // "PT91M"
+ * @example normalizeDuration("P45D", { largestUnit: "month" }) // "" (relativeTo required)
+ * @example normalizeDuration("P45D", { largestUnit: "month", relativeTo: "2024-01-01" }) // "P1M14D"
+ * @example normalizeDuration("invalid") // ""
+ * @example normalizeDuration("P400D", { largestUnit: "year", relativeTo: "5784-06-15[u-ca=hebrew]" }) // "P1Y15D" (Hebrew leap year — relativeTo accepts GMT's calendar-annotated PlainDate string, not Temporal's own ISO-digit u-ca convention)
+ */
+export function normalizeDuration(value, options) {
+    if (typeof value !== "string") {
+        return "";
+    }
+    try {
+        const duration = Temporal.Duration.from(value);
+        return duration
+            .round({
+            largestUnit: options?.largestUnit ?? "auto",
+            smallestUnit: options?.smallestUnit,
+            roundingIncrement: options?.roundingIncrement,
+            roundingMode: options?.roundingMode,
+            relativeTo: resolveDurationRelativeTo(options?.relativeTo),
+        })
+            .toString();
+    }
+    catch {
+        return "";
+    }
+}

package/dist/duration/parse/index.d.ts

@@ -0,0 +1 @@
+export * from "./parseDuration.js";

package/dist/duration/parse/index.js

@@ -0,0 +1 @@
+export * from "./parseDuration.js";

package/dist/duration/parse/parseDuration.d.ts

@@ -0,0 +1,24 @@
+import { Temporal } from "@js-temporal/polyfill";
+/**
+ * Parse and re-normalize an ISO 8601 duration string.
+ *
+ * - Uses Temporal.Duration.from to parse, then .toString() to re-emit.
+ * - `smallestUnit`, `fractionalSecondDigits`, and `roundingMode` control the precision/rounding
+ *   of the re-emitted string, per Temporal's ToStringPrecisionOptions.
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO 8601 duration string
+ * @param options optional: smallestUnit ("second" | "millisecond" | "microsecond" | "nanosecond" — "minute"/"hour" are rejected by Temporal, resulting in ""), fractionalSecondDigits ("auto" | 0-9, ignored when smallestUnit is also set), roundingMode
+ * @returns re-normalized ISO 8601 duration string, or "" on invalid input
+ *
+ * @example parseDuration("P1DT2H30M") // "P1DT2H30M"
+ * @example parseDuration("PT1.5S") // "PT1.5S"
+ * @example parseDuration("PT1.5S", { smallestUnit: "second" }) // "PT1S"
+ * @example parseDuration("PT1.5S", { fractionalSecondDigits: 3 }) // "PT1.500S"
+ * @example parseDuration("invalid") // ""
+ */
+export declare function parseDuration(value: string, options?: {
+    smallestUnit?: Temporal.ToStringPrecisionOptions["smallestUnit"];
+    fractionalSecondDigits?: Temporal.ToStringPrecisionOptions["fractionalSecondDigits"];
+    roundingMode?: Temporal.ToStringPrecisionOptions["roundingMode"];
+}): string;

package/dist/duration/parse/parseDuration.js

@@ -0,0 +1,35 @@
+import { Temporal } from "@js-temporal/polyfill";
+/**
+ * Parse and re-normalize an ISO 8601 duration string.
+ *
+ * - Uses Temporal.Duration.from to parse, then .toString() to re-emit.
+ * - `smallestUnit`, `fractionalSecondDigits`, and `roundingMode` control the precision/rounding
+ *   of the re-emitted string, per Temporal's ToStringPrecisionOptions.
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO 8601 duration string
+ * @param options optional: smallestUnit ("second" | "millisecond" | "microsecond" | "nanosecond" — "minute"/"hour" are rejected by Temporal, resulting in ""), fractionalSecondDigits ("auto" | 0-9, ignored when smallestUnit is also set), roundingMode
+ * @returns re-normalized ISO 8601 duration string, or "" on invalid input
+ *
+ * @example parseDuration("P1DT2H30M") // "P1DT2H30M"
+ * @example parseDuration("PT1.5S") // "PT1.5S"
+ * @example parseDuration("PT1.5S", { smallestUnit: "second" }) // "PT1S"
+ * @example parseDuration("PT1.5S", { fractionalSecondDigits: 3 }) // "PT1.500S"
+ * @example parseDuration("invalid") // ""
+ */
+export function parseDuration(value, options) {
+    if (typeof value !== "string") {
+        return "";
+    }
+    try {
+        const duration = Temporal.Duration.from(value);
+        return duration.toString({
+            smallestUnit: options?.smallestUnit,
+            fractionalSecondDigits: options?.fractionalSecondDigits,
+            roundingMode: options?.roundingMode,
+        });
+    }
+    catch {
+        return "";
+    }
+}

package/dist/duration/validate/index.d.ts

@@ -0,0 +1 @@
+export * from "./isValidDuration.js";

package/dist/duration/validate/index.js

@@ -0,0 +1 @@
+export * from "./isValidDuration.js";

package/dist/duration/validate/isValidDuration.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Return true if `value` is a valid ISO 8601 duration string.
+ *
+ * - Uses Temporal.Duration.from to validate.
+ * - Accepts date, time, and combined durations, including negative and fractional units.
+ *
+ * @param value ISO 8601 duration string
+ * @returns true if value is a valid ISO 8601 duration string, or false on invalid input
+ *
+ * @example isValidDuration("P1DT2H30M") // true
+ * @example isValidDuration("PT0S") // true
+ * @example isValidDuration("-P1D") // true
+ * @example isValidDuration("not a duration") // false
+ * @example isValidDuration("") // false
+ */
+export declare function isValidDuration(value: string): boolean;

package/dist/duration/validate/isValidDuration.js

@@ -0,0 +1,28 @@
+import { Temporal } from "@js-temporal/polyfill";
+/**
+ * Return true if `value` is a valid ISO 8601 duration string.
+ *
+ * - Uses Temporal.Duration.from to validate.
+ * - Accepts date, time, and combined durations, including negative and fractional units.
+ *
+ * @param value ISO 8601 duration string
+ * @returns true if value is a valid ISO 8601 duration string, or false on invalid input
+ *
+ * @example isValidDuration("P1DT2H30M") // true
+ * @example isValidDuration("PT0S") // true
+ * @example isValidDuration("-P1D") // true
+ * @example isValidDuration("not a duration") // false
+ * @example isValidDuration("") // false
+ */
+export function isValidDuration(value) {
+    if (typeof value !== "string") {
+        return false;
+    }
+    try {
+        Temporal.Duration.from(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "@js-temporal/polyfill";
+export * from "./duration/index.js";
+export * from "./plain/index.js";
+export * from "./regex/index.js";
+export * from "./unix/index.js";
+export * from "./utc/index.js";
+export * from "./zoned/index.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from "@js-temporal/polyfill";
+export * from "./duration/index.js";
+export * from "./plain/index.js";
+export * from "./regex/index.js";
+export * from "./unix/index.js";
+export * from "./utc/index.js";
+export * from "./zoned/index.js";

package/dist/internal/adjustZonedBusinessDays.d.ts

@@ -0,0 +1 @@
+export declare function adjustZonedBusinessDays(value: string, direction: 1 | -1, absAmount: number): string;

package/dist/internal/adjustZonedBusinessDays.js

@@ -0,0 +1,16 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { advanceBusinessDays } from "./advanceBusinessDays.js";
+export function adjustZonedBusinessDays(value, direction, absAmount) {
+    try {
+        const zoned = Temporal.ZonedDateTime.from(value);
+        const plainDate = zoned.toPlainDate();
+        const resultDate = advanceBusinessDays(plainDate, direction, absAmount);
+        const resultZoned = resultDate
+            .toZonedDateTime(zoned.timeZoneId)
+            .withPlainTime(zoned.toPlainTime());
+        return resultZoned.toString();
+    }
+    catch {
+        return "";
+    }
+}

package/dist/internal/advanceBusinessDays.d.ts

@@ -0,0 +1,2 @@
+import type { Temporal } from "@js-temporal/polyfill";
+export declare function advanceBusinessDays(start: Temporal.PlainDate, direction: 1 | -1, target: number): Temporal.PlainDate;

package/dist/internal/advanceBusinessDays.js

@@ -0,0 +1,15 @@
+function getStep(date, direction) {
+    return direction === 1 ? date.add({ days: 1 }) : date.subtract({ days: 1 });
+}
+export function advanceBusinessDays(start, direction, target) {
+    const advance = (date, remaining) => {
+        if (remaining === 0)
+            return date;
+        const next = getStep(date, direction);
+        if (next.dayOfWeek >= 1 && next.dayOfWeek <= 5) {
+            return advance(next, remaining - 1);
+        }
+        return advance(next, remaining);
+    };
+    return advance(start, target);
+}

package/dist/internal/advanceToWeekday.d.ts

@@ -0,0 +1,12 @@
+import type { Temporal } from "@js-temporal/polyfill";
+/**
+ * Return the PlainDate for the next/previous occurrence of `dayOfWeek` relative to `date`.
+ *
+ * @param date starting PlainDate
+ * @param dayOfWeek target ISO day of week (1-7)
+ * @param direction 1 to search forward (next), -1 to search backward (previous)
+ * @param inclusive when `date` already falls on `dayOfWeek`, return it as-is instead of
+ *   advancing a full week
+ * @returns PlainDate for the resolved weekday
+ */
+export declare function advanceToWeekday(date: Temporal.PlainDate, dayOfWeek: number, direction: 1 | -1, inclusive: boolean): Temporal.PlainDate;

package/dist/internal/advanceToWeekday.js

@@ -0,0 +1,24 @@
+/**
+ * Return the PlainDate for the next/previous occurrence of `dayOfWeek` relative to `date`.
+ *
+ * @param date starting PlainDate
+ * @param dayOfWeek target ISO day of week (1-7)
+ * @param direction 1 to search forward (next), -1 to search backward (previous)
+ * @param inclusive when `date` already falls on `dayOfWeek`, return it as-is instead of
+ *   advancing a full week
+ * @returns PlainDate for the resolved weekday
+ */
+export function advanceToWeekday(date, dayOfWeek, direction, inclusive) {
+    const current = date.dayOfWeek;
+    if (current === dayOfWeek) {
+        if (inclusive)
+            return date;
+        return date.add({ days: 7 * direction });
+    }
+    // Distance to the target weekday walking in `direction`, always 1-6 days since
+    // current !== dayOfWeek here.
+    const diff = direction === 1
+        ? (dayOfWeek - current + 7) % 7
+        : (current - dayOfWeek + 7) % 7;
+    return date.add({ days: diff * direction });
+}

package/dist/internal/calendarDatePairPolicy.d.ts

@@ -0,0 +1,25 @@
+import type { Temporal } from "@js-temporal/polyfill";
+import type { CalendarSystem } from "../types/index.js";
+export interface CalendarDatePair {
+    calendar: CalendarSystem;
+    a: Temporal.PlainDate;
+    b: Temporal.PlainDate;
+}
+/**
+ * Parse two GMT PlainDate values for calendar-unit arithmetic (diff, count, length, split-by-
+ * unit): measure in the endpoints' shared calendar when both match, fall back to Gregorian/ISO
+ * otherwise, rather than rejecting outright.
+ *
+ * E5 decision of record D5: unlike D4's value-returning interval set-operations (union,
+ * intersection, difference, xor, split, divide, merge — which reject a mismatch via
+ * `calendarOfAllDateValues` instead, since there's no principled output calendar to pick for a
+ * *value* the caller reads back as a date), ordering and duration math both remain well-defined
+ * across mismatched calendars: Temporal's own `compare` is calendar-independent, and falling
+ * back to ISO for a genuinely mismatched pair is a reasonable, well-defined answer rather than
+ * an arbitrary pick.
+ *
+ * Throws if either value fails to parse as a valid GMT PlainDate string — callers are expected
+ * to have already validated both values (e.g. via `isValidCalendarDate`) before calling this,
+ * consistent with GMT's existing gate-then-parse-inside-try structure.
+ */
+export declare function parseCalendarDatePairForArithmetic(aValue: string, bValue: string): CalendarDatePair;

package/dist/internal/calendarDatePairPolicy.js

@@ -0,0 +1,33 @@
+import { parseCalendarDateValue } from "./calendarDateString.js";
+import { calendarSystemOfDateValue } from "./calendarValueOfDate.js";
+/**
+ * Parse two GMT PlainDate values for calendar-unit arithmetic (diff, count, length, split-by-
+ * unit): measure in the endpoints' shared calendar when both match, fall back to Gregorian/ISO
+ * otherwise, rather than rejecting outright.
+ *
+ * E5 decision of record D5: unlike D4's value-returning interval set-operations (union,
+ * intersection, difference, xor, split, divide, merge — which reject a mismatch via
+ * `calendarOfAllDateValues` instead, since there's no principled output calendar to pick for a
+ * *value* the caller reads back as a date), ordering and duration math both remain well-defined
+ * across mismatched calendars: Temporal's own `compare` is calendar-independent, and falling
+ * back to ISO for a genuinely mismatched pair is a reasonable, well-defined answer rather than
+ * an arbitrary pick.
+ *
+ * Throws if either value fails to parse as a valid GMT PlainDate string — callers are expected
+ * to have already validated both values (e.g. via `isValidCalendarDate`) before calling this,
+ * consistent with GMT's existing gate-then-parse-inside-try structure.
+ */
+export function parseCalendarDatePairForArithmetic(aValue, bValue) {
+    const calendarA = calendarSystemOfDateValue(aValue);
+    const calendarB = calendarSystemOfDateValue(bValue);
+    const a = parseCalendarDateValue(aValue);
+    const b = parseCalendarDateValue(bValue);
+    if (calendarA && calendarB && calendarA === calendarB) {
+        return { calendar: calendarA, a, b };
+    }
+    return {
+        calendar: "gregorian",
+        a: a.withCalendar("iso8601"),
+        b: b.withCalendar("iso8601"),
+    };
+}

package/dist/internal/calendarDateString.d.ts

@@ -0,0 +1,65 @@
+import { Temporal } from "@js-temporal/polyfill";
+/**
+ * Parse a plain ISO PlainDate string or a GMT calendar-annotated PlainDate string
+ * (`"5785-01-01[u-ca=hebrew]"`, calendar-native fields, not Temporal's own ISO-digit
+ * `[u-ca=...]` annotation convention) into a Temporal.PlainDate. Throws on invalid input —
+ * callers wrap this in try-catch per GMT's sentinel-return contract.
+ *
+ * The regex only proves shape; `Temporal.PlainDate.from` performs the real construction
+ * and validation (rejecting overflowed fields and unknown calendar identifiers), per the
+ * scoped manual-string-parsing exception for fixed, non-caller-supplied grammars. The
+ * Ethiopic family ("ethiopic" / "ethiopic-amete-alem" / "coptic") is the one exception —
+ * see ethiopicFamilyCalendar.ts for why they're constructed via GMT-owned arithmetic
+ * instead of Temporal's own calendar ids for those three.
+ *
+ * The non-annotated fallback branch requires the strict PlainDate-only shape (via the
+ * `plainDate` regex) before delegating to `Temporal.PlainDate.from` — bare `.from()` silently
+ * truncates a full datetime/zoned string to its date portion (`Temporal.PlainDate.from("2024-
+ * 03-10T14:30:00")` succeeds), which would make this function (and therefore
+ * `isValidCalendarDate`/`convertDateToCalendar`) wrongly accept datetime input. Found and
+ * fixed as part of E5 (issue #78) — it predates this story but this function is E5's shared
+ * gate, so it must not inherit the hazard.
+ */
+export declare function parseCalendarDateValue(value: string): Temporal.PlainDate;
+/**
+ * The two halves of GMT's calendar-annotated PlainDate string, kept separate so a zoned string
+ * can splice its own time/offset between them: `<date>` is the calendar-native (or bare ISO)
+ * `YYYY-MM-DD`, `<annotation>` is the `[u-ca=...]` tail (empty for the "iso8601" calendar).
+ *
+ * `formatCalendarDate` is `date + annotation`; `internal/calendarZonedString.ts`'s
+ * `formatZonedInCalendar` is `date + "T" + time + offset + annotation + "[" + timeZone + "]"`,
+ * since GMT's zoned grammar orders `[u-ca=...]` before `[timeZone]` (see
+ * `regex/calendar-zoned-date-time.ts` for why). Splitting here rather than string-slicing
+ * `formatCalendarDate`'s output on `"["` keeps the era/zero-padding logic in exactly one place.
+ */
+export interface CalendarDateStringParts {
+    date: string;
+    annotation: string;
+}
+/**
+ * Split a Temporal.PlainDate into GMT's calendar-annotated string halves: a bare ISO date with
+ * an empty annotation for the "iso8601" calendar (GMT's existing default, unannotated), or the
+ * calendar's own native year/month/day plus a `[u-ca=<identifier>]` annotation for any other.
+ *
+ * "japanese" is the one exception to "native year": Temporal's `.year` for it stays
+ * proleptic across era changes (Meiji 1 and Reiwa 1 don't both read `1`), which would
+ * contradict the era-based numbering the calendar is for — so it's tagged with `.eraYear`
+ * and `;era=<name>` instead, both of which Temporal always populates for this calendar
+ * (including for pre-Meiji dates, under a synthetic "japanese" era — see the README's
+ * calendar-systems section for why GMT doesn't reject those unlike `@internationalized/date`).
+ *
+ * This function is never called with an Ethiopic-family ("ethiopic" /
+ * "ethiopic-amete-alem" / "coptic") calendared date — those three format through
+ * `ethiopicFamilyDateParts` in ethiopicFamilyCalendar.ts instead, which never touches
+ * Temporal's own "ethiopic"/"coptic" calendar ids. See that file for why.
+ */
+export declare function calendarDateParts(date: Temporal.PlainDate): CalendarDateStringParts;
+/**
+ * Format a Temporal.PlainDate as GMT's calendar-annotated string: a bare ISO string for
+ * the "iso8601" calendar (GMT's existing default, unannotated), or the calendar's own
+ * native year/month/day tagged with `[u-ca=<identifier>]` for any other calendar.
+ *
+ * See `calendarDateParts` (the shared primitive this concatenates) for the era handling and
+ * the Ethiopic-family carve-out.
+ */
+export declare function formatCalendarDate(date: Temporal.PlainDate): string;