@dereekb/date 13.1.0 → 13.2.1

package/index.cjs.js

@@ -2,8 +2,8 @@
 
 var util = require('@dereekb/util');
 var dateFns = require('date-fns');
-var arktype = require('arktype');
 var dateFnsTz = require('date-fns-tz');
+var arktype = require('arktype');
 var tzdb = require('@vvo/tzdb');
 var rxjs = require('rxjs');
 var rrule = require('rrule');
@@ -687,13 +687,6 @@ function isDateRangeStart(value) {
  * ```
  */
 const sortDateRangeStartAscendingCompareFunction = sortByDateFunction((x) => x.start);
-/**
- * ArkType schema for {@link DateRange}.
- */
-const dateRangeType = arktype.type({
-    start: 'Date',
-    end: 'Date'
-});
 /**
  * Counts the total number of calendar days spanned by the range, inclusive of both endpoints.
  * Always returns at least 1, even for same-day ranges.
@@ -869,14 +862,6 @@ exports.DateRangeType = void 0;
      */
     DateRangeType["CALENDAR_MONTH"] = "calendar_month";
 })(exports.DateRangeType || (exports.DateRangeType = {}));
-/**
- * ArkType schema for {@link DateRangeParams}.
- */
-const dateRangeParamsType = arktype.type({
-    type: arktype.type.enumerated(...Object.values(exports.DateRangeType)),
-    date: 'Date',
-    'distance?': 'number'
-});
 /**
  * Creates a {@link DateRange} from the given type and optional parameters. Supports many range
  * strategies including fixed periods (day, week, month), directional ranges, and radii.
@@ -1473,75 +1458,6 @@ function getDaysOfWeekInDateRange(dateRange) {
     return days;
 }
 
-/**
- * ArkType schema for {@link DateDurationSpan}.
- */
-const dateDurationSpanType = arktype.type({
-    startsAt: 'Date',
-    duration: 'number >= 0'
-});
-/**
- * Computes the end date for a duration span by adding the duration to the start time.
- *
- * @param span - the duration span to compute the end for
- * @returns the date when the span ends
- *
- * @example
- * ```ts
- * const span = { startsAt: new Date('2024-01-01T10:00:00Z'), duration: 60 };
- * dateDurationSpanEndDate(span); // 2024-01-01T11:00:00Z
- * ```
- */
-function dateDurationSpanEndDate(span) {
-    return dateFns.addMinutes(span.startsAt, span.duration);
-}
-/**
- * Converts a {@link DateDurationSpan} to a {@link DateRange} with start and end dates.
- *
- * @param span - the duration span to convert
- * @returns a date range from startsAt to startsAt + duration
- */
-function durationSpanToDateRange(span) {
-    return {
-        start: span.startsAt,
-        end: dateFns.addMinutes(span.startsAt, span.duration)
-    };
-}
-/**
- * Creates a {@link DateDurationSpan} from a {@link DateRange} by computing the duration in minutes between start and end.
- *
- * @param dateRange - the date range to convert
- * @returns a duration span with the range's start as startsAt
- */
-function durationSpanFromDateRange(dateRange) {
-    return {
-        startsAt: dateRange.start,
-        duration: dateFns.differenceInMinutes(dateRange.end, dateRange.start)
-    };
-}
-/**
- * Determines whether a duration span is in the past, present, or future relative to the given time.
- *
- * @param span - the duration span to check
- * @param now - reference time (defaults to current time)
- * @returns 'past', 'present', or 'future'
- */
-function durationSpanDateRelativeState(span, now) {
-    return dateRangeRelativeState(durationSpanToDateRange(span), now);
-}
-/**
- * Converts a duration span's duration from minutes to fractional hours.
- *
- * @param span - the duration span to measure
- * @returns the duration expressed as fractional hours (e.g. 90 minutes = 1.5)
- */
-function fractionalHoursInDurationSpan(span) {
-    return util.minutesToFractionalHours(span.duration);
-}
-function isSameDurationSpan(a, b) {
-    return util.safeCompareEquality(a, b, (a, b) => a.duration === b.duration && isSameDate(a.startsAt, b.startsAt));
-}
-
 /**
  * String code for the start of the current day.
  */
@@ -2453,158 +2369,6 @@ function copyHoursAndMinutesFromDateWithTimezoneNormal(input, copyFrom, timezone
     return result;
 }
 
-/**
- * Returns all recognized IANA timezone strings, including the explicit UTC entry.
- *
- * @example
- * ```ts
- * const zones = allTimezoneStrings();
- * // ['Africa/Abidjan', ..., 'UTC']
- * ```
- */
-function allTimezoneStrings() {
-    return tzdb.timeZonesNames.concat(util.UTC_TIMEZONE_STRING);
-}
-/**
- * Lazily-computed set of all known timezone strings for O(1) membership checks.
- *
- * @example
- * ```ts
- * allKnownTimezoneStrings().has('America/New_York'); // true
- * ```
- */
-const allKnownTimezoneStrings = util.cachedGetter(() => {
-    return new Set(allTimezoneStrings());
-});
-/**
- * Lazily-computed array of {@link TimezoneInfo} for every known timezone.
- *
- * Abbreviations are resolved at the time of first access, so results reflect
- * the DST state at that moment.
- */
-const allTimezoneInfos = util.cachedGetter(() => {
-    const now = new Date();
-    return allTimezoneStrings().map((x) => timezoneStringToTimezoneInfo(x, now));
-});
-/**
- * Returns the {@link TimezoneInfo} for the current system timezone, falling back to UTC.
- *
- * @example
- * ```ts
- * const info = timezoneInfoForSystem();
- * console.log(info.abbreviation); // e.g., 'CST'
- * ```
- */
-function timezoneInfoForSystem() {
-    return timezoneStringToTimezoneInfo(guessCurrentTimezone() ?? util.UTC_TIMEZONE_STRING);
-}
-/**
- * Returns the short abbreviation (e.g., `"EST"`, `"PDT"`) for the given timezone at the specified date.
- *
- * The date matters because abbreviations change with DST transitions.
- * Returns `"UKNOWN"` if no timezone is provided.
- *
- * @example
- * ```ts
- * getTimezoneAbbreviation('America/New_York'); // 'EST' or 'EDT'
- * ```
- */
-function getTimezoneAbbreviation(timezone, date = new Date()) {
-    return timezone === util.UTC_TIMEZONE_STRING ? util.UTC_TIMEZONE_STRING : timezone ? dateFnsTz.formatInTimeZone(date, timezone, 'zzz') : 'UKNOWN';
-}
-/**
- * Returns the full display name (e.g., `"Eastern Standard Time"`) for the given timezone.
- *
- * Returns `"Unknown Timezone"` if no timezone is provided.
- *
- * @example
- * ```ts
- * getTimezoneLongName('America/New_York'); // 'Eastern Standard Time'
- * ```
- */
-function getTimezoneLongName(timezone, date = new Date()) {
-    return timezone ? dateFnsTz.formatInTimeZone(date, timezone, 'zzzz') : 'Unknown Timezone';
-}
-/**
- * Builds a {@link TimezoneInfo} for the given timezone, computing abbreviation and search variants.
- *
- * @example
- * ```ts
- * const info = timezoneStringToTimezoneInfo('America/Chicago');
- * // info.abbreviation => 'CST' or 'CDT'
- * // info.search => 'america chicago'
- * ```
- */
-function timezoneStringToTimezoneInfo(timezone, date = new Date()) {
-    const abbreviation = getTimezoneAbbreviation(timezone, date);
-    const result = {
-        timezone,
-        search: timezoneStringToSearchableString(timezone),
-        lowercase: timezone.toLowerCase(),
-        abbreviation,
-        lowercaseAbbreviation: abbreviation.toLowerCase()
-    };
-    return result;
-}
-/**
- * Filters timezone infos by a search string, matching against the searchable name,
- * lowercase identifier, and abbreviation.
- *
- * For queries longer than 2 characters, substring matching on the searchable name is also used.
- *
- * @example
- * ```ts
- * const results = searchTimezoneInfos('eastern', allTimezoneInfos());
- * ```
- */
-function searchTimezoneInfos(search, infos) {
-    const searchString = search.toLocaleLowerCase();
-    return infos.filter((x) => (search.length > 2 && x.search.includes(searchString)) || x.lowercase.startsWith(searchString) || x.lowercaseAbbreviation.startsWith(searchString) || x.abbreviation.includes(search) || x.search === x.timezone);
-}
-const timezoneStringToSearchableStringReplace = util.replaceStringsFunction({
-    replace: ['/', '_'],
-    replaceWith: ' '
-});
-/**
- * Converts a timezone identifier into a lowercase, space-separated string for search indexing.
- *
- * Replaces `/` and `_` with spaces (e.g., `"America/New_York"` becomes `"america new york"`).
- *
- * @example
- * ```ts
- * timezoneStringToSearchableString('America/New_York'); // 'america new york'
- * ```
- */
-function timezoneStringToSearchableString(timezone) {
-    return timezoneStringToSearchableStringReplace(timezone.toLocaleLowerCase());
-}
-/**
- * Checks whether the input string is a recognized IANA timezone identifier.
- *
- * Uses the cached set from {@link allKnownTimezoneStrings} for O(1) lookup.
- *
- * @example
- * ```ts
- * isKnownTimezone('America/New_York'); // true
- * isKnownTimezone('Mars/Olympus');     // false
- * ```
- */
-function isKnownTimezone(input) {
-    return allKnownTimezoneStrings().has(input);
-}
-
-/**
- * ArkType schema that validates a string is a recognized IANA timezone.
- *
- * Delegates to {@link isKnownTimezone} for the actual check.
- *
- * @example
- * ```ts
- * const result = knownTimezoneType('America/Denver');
- * ```
- */
-const knownTimezoneType = arktype.type('string > 0').narrow((val, ctx) => isKnownTimezone(val) || ctx.mustBe('a known timezone'));
-
 /**
  * Creates a {@link FitDateRangeToDayPeriodFunction} that collapses a multi-day date range into a single-day period within the given timezone.
  *
@@ -3145,12 +2909,6 @@ function parseISO8601DayStringToDate(dayString) {
 function isValidDateCellIndex(input) {
     return input >= 0 && Number.isInteger(input);
 }
-/**
- * ArkType schema for {@link DateCell}.
- */
-const dateCellType = arktype.type({
-    i: 'number.integer >= 0'
-});
 /**
  * Normalizes a number or {@link DateCell} to a DateCell object.
  *
@@ -3191,13 +2949,6 @@ function dateCellTimingStartsAtForStartOfDay(input = {}) {
         timezone
     };
 }
-/**
- * ArkType schema for {@link DateCellTiming}.
- */
-const dateCellTimingType = dateDurationSpanType.merge({
-    end: 'Date',
-    timezone: knownTimezoneType
-});
 /**
  * Creates a {@link DateTimezoneUtcNormalInstance} from the input, guaranteeing that a timezone string is configured.
  *
@@ -3783,12 +3534,6 @@ function isValidFullDateCellTiming(timing) {
     return isValid;
 }
 
-/**
- * ArkType schema for {@link DateCellRange}.
- */
-const dateCellRangeType = dateCellType.merge({
-    'to?': 'number.integer >= 0'
-});
 /**
  * Returns true if the input is a DateCellRange.
  *
@@ -5242,19 +4987,81 @@ function isDateWithinDateCellRangeFunction(config) {
 }
 
 /**
- * Creates a filter that passes date cell duration spans whose start time is at or before the given reference time.
- *
- * Useful for identifying events or blocks that have already begun relative to a point in time.
+ * Computes the end date for a duration span by adding the duration to the start time.
  *
- * @param now - Reference time to compare against. Defaults to the current time.
+ * @param span - the duration span to compute the end for
+ * @returns the date when the span ends
  *
  * @example
  * ```ts
- * const hasStarted = dateCellDurationSpanHasStartedFilterFunction(new Date());
- * const startedSpans = allSpans.filter(hasStarted);
+ * const span = { startsAt: new Date('2024-01-01T10:00:00Z'), duration: 60 };
+ * dateDurationSpanEndDate(span); // 2024-01-01T11:00:00Z
  * ```
  */
-function dateCellDurationSpanHasStartedFilterFunction(now = new Date()) {
+function dateDurationSpanEndDate(span) {
+    return dateFns.addMinutes(span.startsAt, span.duration);
+}
+/**
+ * Converts a {@link DateDurationSpan} to a {@link DateRange} with start and end dates.
+ *
+ * @param span - the duration span to convert
+ * @returns a date range from startsAt to startsAt + duration
+ */
+function durationSpanToDateRange(span) {
+    return {
+        start: span.startsAt,
+        end: dateFns.addMinutes(span.startsAt, span.duration)
+    };
+}
+/**
+ * Creates a {@link DateDurationSpan} from a {@link DateRange} by computing the duration in minutes between start and end.
+ *
+ * @param dateRange - the date range to convert
+ * @returns a duration span with the range's start as startsAt
+ */
+function durationSpanFromDateRange(dateRange) {
+    return {
+        startsAt: dateRange.start,
+        duration: dateFns.differenceInMinutes(dateRange.end, dateRange.start)
+    };
+}
+/**
+ * Determines whether a duration span is in the past, present, or future relative to the given time.
+ *
+ * @param span - the duration span to check
+ * @param now - reference time (defaults to current time)
+ * @returns 'past', 'present', or 'future'
+ */
+function durationSpanDateRelativeState(span, now) {
+    return dateRangeRelativeState(durationSpanToDateRange(span), now);
+}
+/**
+ * Converts a duration span's duration from minutes to fractional hours.
+ *
+ * @param span - the duration span to measure
+ * @returns the duration expressed as fractional hours (e.g. 90 minutes = 1.5)
+ */
+function fractionalHoursInDurationSpan(span) {
+    return util.minutesToFractionalHours(span.duration);
+}
+function isSameDurationSpan(a, b) {
+    return util.safeCompareEquality(a, b, (a, b) => a.duration === b.duration && isSameDate(a.startsAt, b.startsAt));
+}
+
+/**
+ * Creates a filter that passes date cell duration spans whose start time is at or before the given reference time.
+ *
+ * Useful for identifying events or blocks that have already begun relative to a point in time.
+ *
+ * @param now - Reference time to compare against. Defaults to the current time.
+ *
+ * @example
+ * ```ts
+ * const hasStarted = dateCellDurationSpanHasStartedFilterFunction(new Date());
+ * const startedSpans = allSpans.filter(hasStarted);
+ * ```
+ */
+function dateCellDurationSpanHasStartedFilterFunction(now = new Date()) {
     return (x) => !dateFns.isAfter(x.startsAt, now); // startsAt <= now
 }
 /**
@@ -6060,14 +5867,6 @@ function isSameDateCellSchedule(a, b) {
         return a == b;
     }
 }
-/**
- * ArkType schema for {@link DateCellSchedule}.
- */
-const dateCellScheduleType = arktype.type({
-    w: [DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX, '&', 'string'],
-    'd?': 'number.integer >= 0 []',
-    'ex?': 'number.integer >= 0 []'
-});
 /**
  * Returns true if the input is possibly a DateCellScheduleDateRange (has schedule fields and valid start/end dates).
  *
@@ -6577,17 +6376,144 @@ function dateCellIndexsForDateCellScheduleDayCodes(sundayIndex, dayCodes) {
 }
 
 /**
- * ArkType schema that validates a value is a valid {@link DateCellTiming}.
+ * Returns all recognized IANA timezone strings, including the explicit UTC entry.
+ *
+ * @example
+ * ```ts
+ * const zones = allTimezoneStrings();
+ * // ['Africa/Abidjan', ..., 'UTC']
+ * ```
+ */
+function allTimezoneStrings() {
+    return tzdb.timeZonesNames.concat(util.UTC_TIMEZONE_STRING);
+}
+/**
+ * Lazily-computed set of all known timezone strings for O(1) membership checks.
+ *
+ * @example
+ * ```ts
+ * allKnownTimezoneStrings().has('America/New_York'); // true
+ * ```
+ */
+const allKnownTimezoneStrings = util.cachedGetter(() => {
+    return new Set(allTimezoneStrings());
+});
+/**
+ * Lazily-computed array of {@link TimezoneInfo} for every known timezone.
+ *
+ * Abbreviations are resolved at the time of first access, so results reflect
+ * the DST state at that moment.
+ */
+const allTimezoneInfos = util.cachedGetter(() => {
+    const now = new Date();
+    return allTimezoneStrings().map((x) => timezoneStringToTimezoneInfo(x, now));
+});
+/**
+ * Returns the {@link TimezoneInfo} for the current system timezone, falling back to UTC.
+ *
+ * @example
+ * ```ts
+ * const info = timezoneInfoForSystem();
+ * console.log(info.abbreviation); // e.g., 'CST'
+ * ```
+ */
+function timezoneInfoForSystem() {
+    return timezoneStringToTimezoneInfo(guessCurrentTimezone() ?? util.UTC_TIMEZONE_STRING);
+}
+/**
+ * Returns the short abbreviation (e.g., `"EST"`, `"PDT"`) for the given timezone at the specified date.
+ *
+ * The date matters because abbreviations change with DST transitions.
+ * Returns `"UKNOWN"` if no timezone is provided.
+ *
+ * @example
+ * ```ts
+ * getTimezoneAbbreviation('America/New_York'); // 'EST' or 'EDT'
+ * ```
+ */
+function getTimezoneAbbreviation(timezone, date = new Date()) {
+    return timezone === util.UTC_TIMEZONE_STRING ? util.UTC_TIMEZONE_STRING : timezone ? dateFnsTz.formatInTimeZone(date, timezone, 'zzz') : 'UKNOWN';
+}
+/**
+ * Returns the full display name (e.g., `"Eastern Standard Time"`) for the given timezone.
+ *
+ * Returns `"Unknown Timezone"` if no timezone is provided.
+ *
+ * @example
+ * ```ts
+ * getTimezoneLongName('America/New_York'); // 'Eastern Standard Time'
+ * ```
+ */
+function getTimezoneLongName(timezone, date = new Date()) {
+    return timezone ? dateFnsTz.formatInTimeZone(date, timezone, 'zzzz') : 'Unknown Timezone';
+}
+/**
+ * Builds a {@link TimezoneInfo} for the given timezone, computing abbreviation and search variants.
+ *
+ * @example
+ * ```ts
+ * const info = timezoneStringToTimezoneInfo('America/Chicago');
+ * // info.abbreviation => 'CST' or 'CDT'
+ * // info.search => 'america chicago'
+ * ```
+ */
+function timezoneStringToTimezoneInfo(timezone, date = new Date()) {
+    const abbreviation = getTimezoneAbbreviation(timezone, date);
+    const result = {
+        timezone,
+        search: timezoneStringToSearchableString(timezone),
+        lowercase: timezone.toLowerCase(),
+        abbreviation,
+        lowercaseAbbreviation: abbreviation.toLowerCase()
+    };
+    return result;
+}
+/**
+ * Filters timezone infos by a search string, matching against the searchable name,
+ * lowercase identifier, and abbreviation.
+ *
+ * For queries longer than 2 characters, substring matching on the searchable name is also used.
+ *
+ * @example
+ * ```ts
+ * const results = searchTimezoneInfos('eastern', allTimezoneInfos());
+ * ```
  */
-const validDateCellTimingType = arktype.type('unknown').narrow((val, ctx) => isValidDateCellTiming(val) || ctx.mustBe('a valid DateCellTiming'));
+function searchTimezoneInfos(search, infos) {
+    const searchString = search.toLocaleLowerCase();
+    return infos.filter((x) => (search.length > 2 && x.search.includes(searchString)) || x.lowercase.startsWith(searchString) || x.lowercaseAbbreviation.startsWith(searchString) || x.abbreviation.includes(search) || x.search === x.timezone);
+}
+const timezoneStringToSearchableStringReplace = util.replaceStringsFunction({
+    replace: ['/', '_'],
+    replaceWith: ' '
+});
 /**
- * ArkType schema that validates a value is a valid {@link DateCellRange} (non-negative indexes, `to >= i`).
+ * Converts a timezone identifier into a lowercase, space-separated string for search indexing.
+ *
+ * Replaces `/` and `_` with spaces (e.g., `"America/New_York"` becomes `"america new york"`).
+ *
+ * @example
+ * ```ts
+ * timezoneStringToSearchableString('America/New_York'); // 'america new york'
+ * ```
  */
-const validDateCellRangeType = arktype.type('unknown').narrow((val, ctx) => isValidDateCellRange(val) || ctx.mustBe('a valid DateCellRange'));
+function timezoneStringToSearchableString(timezone) {
+    return timezoneStringToSearchableStringReplace(timezone.toLocaleLowerCase());
+}
 /**
- * ArkType schema that validates a value is a sorted array of non-overlapping {@link DateCellRange} values.
+ * Checks whether the input string is a recognized IANA timezone identifier.
+ *
+ * Uses the cached set from {@link allKnownTimezoneStrings} for O(1) lookup.
+ *
+ * @example
+ * ```ts
+ * isKnownTimezone('America/New_York'); // true
+ * isKnownTimezone('Mars/Olympus');     // false
+ * ```
  */
-const validDateCellRangeSeriesType = arktype.type('unknown').narrow((val, ctx) => isValidDateCellRangeSeries(val) || ctx.mustBe('a valid DateCellRange series with items sorted in ascending order and no repeat indexes'));
+function isKnownTimezone(input) {
+    return allKnownTimezoneStrings().has(input);
+}
 
 /**
  * Distinguishes between time-based calendar events and all-day/multi-day events.
@@ -6603,12 +6529,6 @@ exports.CalendarDateType = void 0;
      */
     CalendarDateType["DAYS"] = "days";
 })(exports.CalendarDateType || (exports.CalendarDateType = {}));
-/**
- * ArkType schema for {@link CalendarDate}.
- */
-const calendarDateType = dateDurationSpanType.merge({
-    type: arktype.type.enumerated(...Object.values(exports.CalendarDateType))
-});
 /**
  * Creates a {@link CalendarDateFactory} that produces all-day calendar events with timezone-aware start times.
  *
@@ -6678,6 +6598,151 @@ function calendarDateForDateDurationSpan(dateDurationSpan) {
     };
 }
 
+// MARK: Timezone
+/**
+ * ArkType DTO schema that validates a string is a recognized IANA timezone.
+ *
+ * Delegates to {@link isKnownTimezone} for the actual check.
+ *
+ * Intended for validating and parsing DTO/JSON data where timezones arrive as strings.
+ *
+ * @example
+ * ```ts
+ * const result = knownTimezoneType('America/Denver');
+ * ```
+ */
+const knownTimezoneType = arktype.type('string > 0').narrow((val, ctx) => (val != null && isKnownTimezone(val)) || ctx.mustBe('a known timezone'));
+// MARK: DateDurationSpan
+/**
+ * ArkType DTO schema for {@link DateDurationSpan}.
+ *
+ * Parses date strings from JSON/DTO input into Date objects using `string.date.parse`.
+ * Use this schema when validating and converting serialized data (e.g., API responses, JSON payloads)
+ * into the corresponding runtime types.
+ */
+const dateDurationSpanType = arktype.type({
+    startsAt: 'string.date.parse',
+    duration: 'number >= 0'
+});
+// MARK: DateRange
+/**
+ * ArkType DTO schema for {@link DateRange}.
+ *
+ * Parses date strings from JSON/DTO input into Date objects using `string.date.parse`.
+ * Use this schema when validating and converting serialized data (e.g., API responses, JSON payloads)
+ * into the corresponding runtime types.
+ */
+const dateRangeType = arktype.type({
+    start: 'string.date.parse',
+    end: 'string.date.parse'
+});
+// MARK: DateRangeParams
+/**
+ * ArkType DTO schema for {@link DateRangeParams}.
+ *
+ * Parses date strings from JSON/DTO input into Date objects using `string.date.parse`.
+ * Use this schema when validating and converting serialized data (e.g., API responses, JSON payloads)
+ * into the corresponding runtime types.
+ */
+const dateRangeParamsType = arktype.type({
+    type: arktype.type.enumerated(...Object.values(exports.DateRangeType)),
+    date: 'string.date.parse',
+    'distance?': 'number'
+});
+// MARK: DateCell
+/**
+ * ArkType DTO schema for {@link DateCell}.
+ *
+ * Validates a cell index from JSON/DTO input.
+ * Use this schema when validating and converting serialized data (e.g., API responses, JSON payloads)
+ * into the corresponding runtime types.
+ */
+const dateCellType = arktype.type({
+    i: 'number.integer >= 0'
+});
+// MARK: DateCellRange
+/**
+ * ArkType DTO schema for {@link DateCellRange}.
+ *
+ * Validates cell range indexes from JSON/DTO input.
+ * Use this schema when validating and converting serialized data (e.g., API responses, JSON payloads)
+ * into the corresponding runtime types.
+ */
+const dateCellRangeType = dateCellType.merge({
+    'to?': 'number.integer >= 0'
+});
+// MARK: DateCellTiming
+/**
+ * ArkType DTO schema for {@link DateCellTiming}.
+ *
+ * Parses date strings from JSON/DTO input into Date objects using `string.date.parse`.
+ * Use this schema when validating and converting serialized data (e.g., API responses, JSON payloads)
+ * into the corresponding runtime types.
+ */
+const dateCellTimingType = dateDurationSpanType.merge({
+    end: 'string.date.parse',
+    timezone: knownTimezoneType
+});
+// MARK: CalendarDate
+/**
+ * ArkType DTO schema for {@link CalendarDate}.
+ *
+ * Parses date strings from JSON/DTO input into Date objects using `string.date.parse`.
+ * Use this schema when validating and converting serialized data (e.g., API responses, JSON payloads)
+ * into the corresponding runtime types.
+ */
+const calendarDateType = dateDurationSpanType.merge({
+    type: arktype.type.enumerated(...Object.values(exports.CalendarDateType))
+});
+// MARK: DateCellSchedule
+/**
+ * ArkType DTO schema for {@link DateCellSchedule}.
+ *
+ * Validates schedule data from JSON/DTO input.
+ * Use this schema when validating and converting serialized data (e.g., API responses, JSON payloads)
+ * into the corresponding runtime types.
+ */
+const dateCellScheduleType = arktype.type({
+    w: [DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX, '&', 'string'],
+    'd?': 'number.integer >= 0 []',
+    'ex?': 'number.integer >= 0 []'
+});
+// MARK: ModelRecurrenceInfo
+/**
+ * ArkType DTO schema for {@link ModelRecurrenceInfo}.
+ *
+ * Parses date strings from JSON/DTO input into Date objects using `string.date.parse`.
+ * Use this schema when validating and converting serialized data (e.g., API responses, JSON payloads)
+ * into the corresponding runtime types.
+ */
+const modelRecurrenceInfoType = arktype.type({
+    'timezone?': 'string',
+    rrule: 'string',
+    start: 'string.date.parse',
+    end: 'string.date.parse',
+    'forever?': 'boolean'
+});
+// MARK: Validators
+/**
+ * ArkType DTO schema that validates a value is a valid {@link DateCellTiming}.
+ *
+ * Parses date strings from JSON/DTO input into Date objects, then validates the resulting timing
+ * using {@link isValidDateCellTiming}.
+ */
+const validDateCellTimingType = dateCellTimingType.narrow((val, ctx) => (val != null && isValidDateCellTiming(val)) || ctx.mustBe('a valid DateCellTiming'));
+/**
+ * ArkType DTO schema that validates a value is a valid {@link DateCellRange} (non-negative indexes, `to >= i`).
+ *
+ * Validates cell range data from JSON/DTO input.
+ */
+const validDateCellRangeType = dateCellRangeType.narrow((val, ctx) => (val != null && isValidDateCellRange(val)) || ctx.mustBe('a valid DateCellRange'));
+/**
+ * ArkType DTO schema that validates a value is a sorted array of non-overlapping {@link DateCellRange} values.
+ *
+ * Validates cell range series data from JSON/DTO input.
+ */
+const validDateCellRangeSeriesType = arktype.type(dateCellRangeType.array()).narrow((val, ctx) => (val != null && isValidDateCellRangeSeries(val)) || ctx.mustBe('a valid DateCellRange series with items sorted in ascending order and no repeat indexes'));
+
 /**
  * A {@link HashSet} specialized for Date values, using the millisecond timestamp as the hash key.
  *
@@ -8781,16 +8846,6 @@ class DateRRuleUtility {
     }
 }
 
-/**
- * ArkType schema for {@link ModelRecurrenceInfo}.
- */
-const modelRecurrenceInfoType = arktype.type({
-    'timezone?': 'string',
-    rrule: 'string',
-    start: 'Date',
-    end: 'Date',
-    'forever?': 'boolean'
-});
 /**
  * Stateless utility for converting between recurrence input
  * ({@link ModelRecurrenceStart}) and the indexed storage form