@northguild/gmt 1.14.2

package/dist/plain/parse/parseWeekFromDate.js

@@ -0,0 +1,30 @@
+import { getWeekNumber } from "../calculate/getWeekNumber.js";
+import { isValidDate } from "../validate/index.js";
+/**
+ * Return the week number for a given ISO 8601 date string.
+ *
+ * - By default uses ISO weeks (Monday-based).
+ * - Returns null for invalid input.
+ *
+ * @param value ISO date string
+ * @param optionsArg optional: weekStartsOn ("monday" | "sunday") for week calculations
+ * @returns Week number (1-53) or null on invalid input
+ *
+ * @example parseWeekFromDate("2024-01-01") // 1
+ * @example parseWeekFromDate("2024-01-08") // 2
+ * @example parseWeekFromDate("2024-12-31") // 1
+ * @example parseWeekFromDate("2024-01-01", { weekStartsOn: "sunday" }) // 1
+ * @example parseWeekFromDate("invalid") // null
+ */
+export function parseWeekFromDate(value, optionsArg) {
+    if (!isValidDate(value)) {
+        return null;
+    }
+    const weekStartsOn = optionsArg?.weekStartsOn ?? "monday";
+    try {
+        return getWeekNumber(value, weekStartsOn);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/plain/parse/parseWeekFromDateTime.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Return the week number for a given ISO 8601 datetime string.
+ *
+ * - By default uses ISO weeks (Monday-based).
+ * - Returns null for invalid input.
+ *
+ * @param value ISO 8601 datetime string
+ * @param optionsArg optional: weekStartsOn ("monday" | "sunday") for week calculations
+ * @returns Week number (1-53) or null on invalid input
+ *
+ * @example parseWeekFromDateTime("2024-01-01T12:00:00") // 1
+ * @example parseWeekFromDateTime("2024-01-08T00:00:00") // 2
+ * @example parseWeekFromDateTime("2024-01-01T00:00:00", { weekStartsOn: "sunday" }) // 1
+ * @example parseWeekFromDateTime("invalid") // null
+ */
+export declare function parseWeekFromDateTime(value: string, optionsArg?: {
+    weekStartsOn?: "monday" | "sunday";
+}): number | null;

package/dist/plain/parse/parseWeekFromDateTime.js

@@ -0,0 +1,29 @@
+import { getWeekNumber } from "../calculate/getWeekNumber.js";
+import { isValidDateTime } from "../validate/index.js";
+/**
+ * Return the week number for a given ISO 8601 datetime string.
+ *
+ * - By default uses ISO weeks (Monday-based).
+ * - Returns null for invalid input.
+ *
+ * @param value ISO 8601 datetime string
+ * @param optionsArg optional: weekStartsOn ("monday" | "sunday") for week calculations
+ * @returns Week number (1-53) or null on invalid input
+ *
+ * @example parseWeekFromDateTime("2024-01-01T12:00:00") // 1
+ * @example parseWeekFromDateTime("2024-01-08T00:00:00") // 2
+ * @example parseWeekFromDateTime("2024-01-01T00:00:00", { weekStartsOn: "sunday" }) // 1
+ * @example parseWeekFromDateTime("invalid") // null
+ */
+export function parseWeekFromDateTime(value, optionsArg) {
+    if (!isValidDateTime(value)) {
+        return null;
+    }
+    const weekStartsOn = optionsArg?.weekStartsOn ?? "monday";
+    try {
+        return getWeekNumber(value, weekStartsOn);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/plain/parse/parseYearFromDate.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Return the year for a given ISO 8601 date string.
+ *
+ * - Returns the year as a string (e.g., "2024").
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO date string
+ * @returns Year (YYYY) or "" on invalid input
+ *
+ * @example parseYearFromDate("2024-03-15") // "2024"
+ * @example parseYearFromDate("invalid") // ""
+ */
+export declare function parseYearFromDate(value: string): string;

package/dist/plain/parse/parseYearFromDate.js

@@ -0,0 +1,25 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidDate } from "../validate/index.js";
+/**
+ * Return the year for a given ISO 8601 date string.
+ *
+ * - Returns the year as a string (e.g., "2024").
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO date string
+ * @returns Year (YYYY) or "" on invalid input
+ *
+ * @example parseYearFromDate("2024-03-15") // "2024"
+ * @example parseYearFromDate("invalid") // ""
+ */
+export function parseYearFromDate(value) {
+    if (!isValidDate(value))
+        return "";
+    try {
+        const date = Temporal.PlainDate.from(value);
+        return date.year.toString();
+    }
+    catch {
+        return "";
+    }
+}

package/dist/plain/parse/parseYearFromDateTime.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Return the year for a given ISO 8601 datetime string.
+ *
+ * - Returns the year as a string (e.g., "2024").
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO datetime string
+ * @returns Year (YYYY) or "" on invalid input
+ *
+ * @example parseYearFromDateTime("2024-03-15T12:30:00") // "2024"
+ * @example parseYearFromDateTime("invalid") // ""
+ */
+export declare function parseYearFromDateTime(value: string): string;

package/dist/plain/parse/parseYearFromDateTime.js

@@ -0,0 +1,25 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidDateTime } from "../validate/index.js";
+/**
+ * Return the year for a given ISO 8601 datetime string.
+ *
+ * - Returns the year as a string (e.g., "2024").
+ * - Returns "" for invalid input.
+ *
+ * @param value ISO datetime string
+ * @returns Year (YYYY) or "" on invalid input
+ *
+ * @example parseYearFromDateTime("2024-03-15T12:30:00") // "2024"
+ * @example parseYearFromDateTime("invalid") // ""
+ */
+export function parseYearFromDateTime(value) {
+    if (!isValidDateTime(value))
+        return "";
+    try {
+        const dateTime = Temporal.PlainDateTime.from(value);
+        return dateTime.year.toString();
+    }
+    catch {
+        return "";
+    }
+}

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

@@ -0,0 +1,19 @@
+export * from "./isLeapSecond.js";
+export * from "./isLeapYear.js";
+export * from "./isValidCalendarDate.js";
+export * from "./isValidDate.js";
+export * from "./isValidDateCycleField.js";
+export * from "./isValidDateDurationUnit.js";
+export * from "./isValidDateRange.js";
+export * from "./isValidDateTime.js";
+export * from "./isValidDateTimeCycleField.js";
+export * from "./isValidDateTimeDurationUnit.js";
+export * from "./isValidDateTimeRange.js";
+export * from "./isValidDateTimeUnit.js";
+export * from "./isValidDateUnit.js";
+export * from "./isValidIsoDateLike.js";
+export * from "./isValidTime.js";
+export * from "./isValidTimeCycleField.js";
+export * from "./isValidTimeDurationUnit.js";
+export * from "./isValidTimeRange.js";
+export * from "./isValidTimeUnit.js";

package/dist/plain/validate/index.js

@@ -0,0 +1,19 @@
+export * from "./isLeapSecond.js";
+export * from "./isLeapYear.js";
+export * from "./isValidCalendarDate.js";
+export * from "./isValidDate.js";
+export * from "./isValidDateCycleField.js";
+export * from "./isValidDateDurationUnit.js";
+export * from "./isValidDateRange.js";
+export * from "./isValidDateTime.js";
+export * from "./isValidDateTimeCycleField.js";
+export * from "./isValidDateTimeDurationUnit.js";
+export * from "./isValidDateTimeRange.js";
+export * from "./isValidDateTimeUnit.js";
+export * from "./isValidDateUnit.js";
+export * from "./isValidIsoDateLike.js";
+export * from "./isValidTime.js";
+export * from "./isValidTimeCycleField.js";
+export * from "./isValidTimeDurationUnit.js";
+export * from "./isValidTimeRange.js";
+export * from "./isValidTimeUnit.js";

package/dist/plain/validate/isLeapSecond.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Return true if the provided string is a valid ISO 8601 leap second datetime.
+ *
+ * - Validates leap second format using regex: "YYYY-MM-DDT23:59:60Z" or "YYYY-MM-DDT23:59:60+00:00".
+ * - Accepts optional fractional seconds.
+ *
+ * @param value ISO datetime string
+ * @returns boolean indicating whether the input string is a valid leap second datetime
+ *
+ * @example isLeapSecond("2024-12-31T23:59:60Z") // true
+ * @example isLeapSecond("2024-12-31T23:59:60.123Z") // true
+ * @example isLeapSecond("2024-12-31T23:59:60+00:00") // true
+ * @example isLeapSecond("2024-12-31T23:59:60.123+00:00") // true
+ * @example isLeapSecond("2024-12-31T23:59:59Z") // false
+ */
+export declare function isLeapSecond(value: string): boolean;

package/dist/plain/validate/isLeapSecond.js

@@ -0,0 +1,19 @@
+import { leapSecond } from "../../regex/leap-second.js";
+/**
+ * Return true if the provided string is a valid ISO 8601 leap second datetime.
+ *
+ * - Validates leap second format using regex: "YYYY-MM-DDT23:59:60Z" or "YYYY-MM-DDT23:59:60+00:00".
+ * - Accepts optional fractional seconds.
+ *
+ * @param value ISO datetime string
+ * @returns boolean indicating whether the input string is a valid leap second datetime
+ *
+ * @example isLeapSecond("2024-12-31T23:59:60Z") // true
+ * @example isLeapSecond("2024-12-31T23:59:60.123Z") // true
+ * @example isLeapSecond("2024-12-31T23:59:60+00:00") // true
+ * @example isLeapSecond("2024-12-31T23:59:60.123+00:00") // true
+ * @example isLeapSecond("2024-12-31T23:59:59Z") // false
+ */
+export function isLeapSecond(value) {
+    return leapSecond.test(value);
+}

package/dist/plain/validate/isLeapYear.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Return true when the given PlainDate falls in a leap year.
+ *
+ * - A leap year is divisible by 4, except for century years which must be divisible by 400.
+ * - Returns false for invalid input strings.
+ *
+ * @param value ISO PlainDate string
+ * @returns boolean indicating whether the date is in a leap year
+ *
+ * @example isLeapYear("2024-03-15") // true
+ * @example isLeapYear("2023-03-15") // false
+ * @example isLeapYear("invalid") // false
+ */
+export declare function isLeapYear(value: string): boolean;

package/dist/plain/validate/isLeapYear.js

@@ -0,0 +1,23 @@
+import { Temporal } from "@js-temporal/polyfill";
+/**
+ * Return true when the given PlainDate falls in a leap year.
+ *
+ * - A leap year is divisible by 4, except for century years which must be divisible by 400.
+ * - Returns false for invalid input strings.
+ *
+ * @param value ISO PlainDate string
+ * @returns boolean indicating whether the date is in a leap year
+ *
+ * @example isLeapYear("2024-03-15") // true
+ * @example isLeapYear("2023-03-15") // false
+ * @example isLeapYear("invalid") // false
+ */
+export function isLeapYear(value) {
+    try {
+        const date = Temporal.PlainDate.from(value);
+        return date.inLeapYear;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/validate/isValidCalendarDate.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Return true if `value` is a valid GMT PlainDate string: a plain ISO date
+ * ("2024-10-03") or a calendar-annotated date with calendar-native fields
+ * ("5785-01-01[u-ca=hebrew]"), as produced by `convertDateToCalendar`.
+ *
+ * - Delegates all field-range and calendar-identifier checking to
+ *   `Temporal.PlainDate.from` (via `parseCalendarDateValue`).
+ *
+ * @param value ISO PlainDate string, optionally calendar-annotated
+ * @returns boolean indicating validity
+ *
+ * @example isValidCalendarDate("2024-10-03") // true
+ * @example isValidCalendarDate("5785-01-01[u-ca=hebrew]") // true
+ * @example isValidCalendarDate("2024-10-03[u-ca=martian]") // false (unknown calendar identifier)
+ * @example isValidCalendarDate("invalid") // false
+ */
+export declare function isValidCalendarDate(value: string): boolean;

package/dist/plain/validate/isValidCalendarDate.js

@@ -0,0 +1,29 @@
+import { parseCalendarDateValue } from "../../internal/index.js";
+/**
+ * Return true if `value` is a valid GMT PlainDate string: a plain ISO date
+ * ("2024-10-03") or a calendar-annotated date with calendar-native fields
+ * ("5785-01-01[u-ca=hebrew]"), as produced by `convertDateToCalendar`.
+ *
+ * - Delegates all field-range and calendar-identifier checking to
+ *   `Temporal.PlainDate.from` (via `parseCalendarDateValue`).
+ *
+ * @param value ISO PlainDate string, optionally calendar-annotated
+ * @returns boolean indicating validity
+ *
+ * @example isValidCalendarDate("2024-10-03") // true
+ * @example isValidCalendarDate("5785-01-01[u-ca=hebrew]") // true
+ * @example isValidCalendarDate("2024-10-03[u-ca=martian]") // false (unknown calendar identifier)
+ * @example isValidCalendarDate("invalid") // false
+ */
+export function isValidCalendarDate(value) {
+    if (typeof value !== "string" || value.length === 0) {
+        return false;
+    }
+    try {
+        parseCalendarDateValue(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/validate/isValidDate.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Return true if `value` is a valid ISO PlainDate string.
+ *
+ * - Uses regex to check format before parsing.
+ * - Rejects leap seconds (e.g., "2024-12-31T23:59:60").
+ * - Rejects invalid dates (e.g., "2024-02-30").
+ *
+ * @param value ISO PlainDate string
+ * @returns boolean indicating validity
+ *
+ * @example isValidDate("2024-03-10") // true
+ * @example isValidDate("2024-02-30") // false
+ * @example isValidDate("invalid") // false
+ * @example isValidDate("2024-12-31T23:59:60") // false (leap second - not a valid date)
+ */
+export declare function isValidDate(value: string): boolean;

package/dist/plain/validate/isValidDate.js

@@ -0,0 +1,33 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { plainDate } from "../../regex/index.js";
+import { isLeapSecond } from "./isLeapSecond.js";
+/**
+ * Return true if `value` is a valid ISO PlainDate string.
+ *
+ * - Uses regex to check format before parsing.
+ * - Rejects leap seconds (e.g., "2024-12-31T23:59:60").
+ * - Rejects invalid dates (e.g., "2024-02-30").
+ *
+ * @param value ISO PlainDate string
+ * @returns boolean indicating validity
+ *
+ * @example isValidDate("2024-03-10") // true
+ * @example isValidDate("2024-02-30") // false
+ * @example isValidDate("invalid") // false
+ * @example isValidDate("2024-12-31T23:59:60") // false (leap second - not a valid date)
+ */
+export function isValidDate(value) {
+    if (isLeapSecond(value)) {
+        return false;
+    }
+    if (!plainDate.test(value)) {
+        return false;
+    }
+    try {
+        Temporal.PlainDate.from(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/validate/isValidDateCycleField.d.ts

@@ -0,0 +1,21 @@
+import type { DateCycleField } from "../../types/index.js";
+/**
+ * Return true when `field` is a valid DateCycleField.
+ *
+ * - Valid fields are: "year", "month", "day".
+ * - Accepts any input type and returns false for non-string values.
+ * - Note "week" is a valid DateUnit elsewhere in GMT but is NOT a valid cycle field — it isn't a
+ *   `.with()`-settable field, so it can't be cycled.
+ *
+ * @param field candidate value of any type
+ * @returns boolean indicating validity
+ *
+ * @example isValidDateCycleField("year") // true
+ * @example isValidDateCycleField("month") // true
+ * @example isValidDateCycleField("day") // true
+ * @example isValidDateCycleField("week") // false
+ * @example isValidDateCycleField("invalid") // false
+ * @example isValidDateCycleField(123) // false
+ * @example isValidDateCycleField(null) // false
+ */
+export declare function isValidDateCycleField(field: unknown): field is DateCycleField;

package/dist/plain/validate/isValidDateCycleField.js

@@ -0,0 +1,25 @@
+/**
+ * Return true when `field` is a valid DateCycleField.
+ *
+ * - Valid fields are: "year", "month", "day".
+ * - Accepts any input type and returns false for non-string values.
+ * - Note "week" is a valid DateUnit elsewhere in GMT but is NOT a valid cycle field — it isn't a
+ *   `.with()`-settable field, so it can't be cycled.
+ *
+ * @param field candidate value of any type
+ * @returns boolean indicating validity
+ *
+ * @example isValidDateCycleField("year") // true
+ * @example isValidDateCycleField("month") // true
+ * @example isValidDateCycleField("day") // true
+ * @example isValidDateCycleField("week") // false
+ * @example isValidDateCycleField("invalid") // false
+ * @example isValidDateCycleField(123) // false
+ * @example isValidDateCycleField(null) // false
+ */
+export function isValidDateCycleField(field) {
+    if (typeof field !== "string") {
+        return false;
+    }
+    return field === "year" || field === "month" || field === "day";
+}

package/dist/plain/validate/isValidDateDurationUnit.d.ts

@@ -0,0 +1,16 @@
+import type { DateDurationUnit } from "../../types/index.js";
+/**
+ * Return true when `unit` is a valid DateDurationUnit.
+ *
+ * - Valid units are: "years", "months", "weeks", "days".
+ * - Uses type assertion to narrow the type.
+ *
+ * @param unit string candidate
+ * @returns boolean indicating whether the unit is valid
+ *
+ * @example isValidDateDurationUnit("days") // true
+ * @example isValidDateDurationUnit("months") // true
+ * @example isValidDateDurationUnit("years") // true
+ * @example isValidDateDurationUnit("invalid") // false
+ */
+export declare const isValidDateDurationUnit: (unit: string) => unit is DateDurationUnit;

package/dist/plain/validate/isValidDateDurationUnit.js

@@ -0,0 +1,17 @@
+/**
+ * Return true when `unit` is a valid DateDurationUnit.
+ *
+ * - Valid units are: "years", "months", "weeks", "days".
+ * - Uses type assertion to narrow the type.
+ *
+ * @param unit string candidate
+ * @returns boolean indicating whether the unit is valid
+ *
+ * @example isValidDateDurationUnit("days") // true
+ * @example isValidDateDurationUnit("months") // true
+ * @example isValidDateDurationUnit("years") // true
+ * @example isValidDateDurationUnit("invalid") // false
+ */
+export const isValidDateDurationUnit = (unit) => {
+    return (unit === "years" || unit === "months" || unit === "weeks" || unit === "days");
+};

package/dist/plain/validate/isValidDateRange.d.ts

@@ -0,0 +1,26 @@
+interface IsValidDateRangeProps {
+    value1: string;
+    value2: string;
+    options?: {
+        allowEqual?: boolean;
+    };
+}
+/**
+ * Return whether `value1` is before `value2`.
+ *
+ * - Validates both dates using regex and Temporal.PlainDate.from().
+ * - Rejects leap seconds in either date.
+ * - When `options.allowEqual` is true, equality is considered valid as well.
+ *
+ * @param value1 first ISO PlainDate string
+ * @param value2 second ISO PlainDate string
+ * @param options optional allowEqual flag
+ * @returns boolean indicating whether the date range is valid
+ *
+ * @example isValidDateRange({ value1: "2024-02-28", value2: "2024-02-29" }) // true
+ * @example isValidDateRange({ value1: "2024-02-29", value2: "2024-02-28" }) // false
+ * @example isValidDateRange({ value1: "2024-02-29", value2: "2024-02-29" }) // false
+ * @example isValidDateRange({ value1: "2024-02-29", value2: "2024-02-29", options: { allowEqual: true } }) // true
+ */
+export declare function isValidDateRange({ value1, value2, options, }: IsValidDateRangeProps): boolean;
+export {};

package/dist/plain/validate/isValidDateRange.js

@@ -0,0 +1,47 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { plainDate } from "../../regex/index.js";
+import { isLeapSecond } from "./isLeapSecond.js";
+/**
+ * Return whether `value1` is before `value2`.
+ *
+ * - Validates both dates using regex and Temporal.PlainDate.from().
+ * - Rejects leap seconds in either date.
+ * - When `options.allowEqual` is true, equality is considered valid as well.
+ *
+ * @param value1 first ISO PlainDate string
+ * @param value2 second ISO PlainDate string
+ * @param options optional allowEqual flag
+ * @returns boolean indicating whether the date range is valid
+ *
+ * @example isValidDateRange({ value1: "2024-02-28", value2: "2024-02-29" }) // true
+ * @example isValidDateRange({ value1: "2024-02-29", value2: "2024-02-28" }) // false
+ * @example isValidDateRange({ value1: "2024-02-29", value2: "2024-02-29" }) // false
+ * @example isValidDateRange({ value1: "2024-02-29", value2: "2024-02-29", options: { allowEqual: true } }) // true
+ */
+export function isValidDateRange({ value1, value2, options, }) {
+    if (isLeapSecond(value1) || isLeapSecond(value2)) {
+        return false;
+    }
+    if (!plainDate.test(value1) || !plainDate.test(value2)) {
+        return false;
+    }
+    try {
+        const date1 = Temporal.PlainDate.from(value1);
+        const date2 = Temporal.PlainDate.from(value2);
+        const isLessThan = date1.year < date2.year ||
+            (date1.year === date2.year && date1.month < date2.month) ||
+            (date1.year === date2.year &&
+                date1.month === date2.month &&
+                date1.day < date2.day);
+        const isEqual = date1.year === date2.year &&
+            date1.month === date2.month &&
+            date1.day === date2.day;
+        if (options?.allowEqual) {
+            return isLessThan || isEqual;
+        }
+        return isLessThan;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/validate/isValidDateTime.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Return true when `value` is a valid PlainDateTime string.
+ *
+ * - Uses regex to check format before parsing.
+ * - Rejects leap seconds (e.g., "2024-02-29T23:59:60").
+ * - Rejects invalid dates (e.g., "2024-02-30") and invalid times (e.g., "2024-02-29T24:00:00").
+ *
+ * @param value string candidate
+ * @returns boolean indicating whether the value is a valid PlainDateTime string
+ *
+ * @example isValidDateTime("2024-02-29T12:34:56") // true
+ * @example isValidDateTime("2024-02-30T12:34:56") // false (invalid date)
+ * @example isValidDateTime("2024-02-29T24:00:00") // false (invalid time)
+ * @example isValidDateTime("2024-02-29T23:59:60") // false (leap second)
+ */
+export declare function isValidDateTime(value: string): boolean;

package/dist/plain/validate/isValidDateTime.js

@@ -0,0 +1,33 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { plainDateTime } from "../../regex/index.js";
+import { isLeapSecond } from "./isLeapSecond.js";
+/**
+ * Return true when `value` is a valid PlainDateTime string.
+ *
+ * - Uses regex to check format before parsing.
+ * - Rejects leap seconds (e.g., "2024-02-29T23:59:60").
+ * - Rejects invalid dates (e.g., "2024-02-30") and invalid times (e.g., "2024-02-29T24:00:00").
+ *
+ * @param value string candidate
+ * @returns boolean indicating whether the value is a valid PlainDateTime string
+ *
+ * @example isValidDateTime("2024-02-29T12:34:56") // true
+ * @example isValidDateTime("2024-02-30T12:34:56") // false (invalid date)
+ * @example isValidDateTime("2024-02-29T24:00:00") // false (invalid time)
+ * @example isValidDateTime("2024-02-29T23:59:60") // false (leap second)
+ */
+export function isValidDateTime(value) {
+    if (isLeapSecond(value)) {
+        return false;
+    }
+    if (!plainDateTime.test(value)) {
+        return false;
+    }
+    try {
+        Temporal.PlainDateTime.from(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/validate/isValidDateTimeCycleField.d.ts

@@ -0,0 +1,16 @@
+import type { DateTimeCycleField } from "../../types/index.js";
+/**
+ * Return true when `field` is a valid DateTimeCycleField (a valid DateCycleField or
+ * TimeCycleField). Used by `cycleDateTime` and `cycleZoned`, which can cycle either kind of field.
+ *
+ * @param field candidate value of any type
+ * @returns boolean indicating validity
+ *
+ * @example isValidDateTimeCycleField("year") // true
+ * @example isValidDateTimeCycleField("hour") // true
+ * @example isValidDateTimeCycleField("week") // false
+ * @example isValidDateTimeCycleField("invalid") // false
+ * @example isValidDateTimeCycleField(123) // false
+ * @example isValidDateTimeCycleField(null) // false
+ */
+export declare function isValidDateTimeCycleField(field: unknown): field is DateTimeCycleField;

package/dist/plain/validate/isValidDateTimeCycleField.js

@@ -0,0 +1,19 @@
+import { isValidDateCycleField } from "./isValidDateCycleField.js";
+import { isValidTimeCycleField } from "./isValidTimeCycleField.js";
+/**
+ * Return true when `field` is a valid DateTimeCycleField (a valid DateCycleField or
+ * TimeCycleField). Used by `cycleDateTime` and `cycleZoned`, which can cycle either kind of field.
+ *
+ * @param field candidate value of any type
+ * @returns boolean indicating validity
+ *
+ * @example isValidDateTimeCycleField("year") // true
+ * @example isValidDateTimeCycleField("hour") // true
+ * @example isValidDateTimeCycleField("week") // false
+ * @example isValidDateTimeCycleField("invalid") // false
+ * @example isValidDateTimeCycleField(123) // false
+ * @example isValidDateTimeCycleField(null) // false
+ */
+export function isValidDateTimeCycleField(field) {
+    return isValidDateCycleField(field) || isValidTimeCycleField(field);
+}

package/dist/plain/validate/isValidDateTimeDurationUnit.d.ts

@@ -0,0 +1,16 @@
+import type { DateTimeDurationUnit } from "../../types/index.js";
+/**
+ * Return true when `unit` is a valid DateTimeDurationUnit.
+ *
+ * - Valid units are: "years", "months", "weeks", "days", "hours", "minutes", "seconds", "milliseconds", "microseconds", "nanoseconds".
+ * - Uses type assertion to narrow the type.
+ *
+ * @param unit candidate string
+ * @returns boolean indicating validity
+ *
+ * @example isValidDateTimeDurationUnit("days") // true
+ * @example isValidDateTimeDurationUnit("hours") // true
+ * @example isValidDateTimeDurationUnit("minutes") // true
+ * @example isValidDateTimeDurationUnit("invalid") // false
+ */
+export declare const isValidDateTimeDurationUnit: (unit: string) => unit is DateTimeDurationUnit;