@dereekb/date 13.0.7 → 13.2.0

package/src/lib/date/date.week.d.ts

@@ -21,10 +21,15 @@ export type UnknownYearWeekCode = typeof UNKNOWN_YEAR_WEEK_CODE;
  */
 export type YearWeekCodeIndex = number;
 /**
- * Returns the YearWeekCodeIndex for the YearWeekCode.
+ * Extracts the week-of-year index (1-52) from a {@link YearWeekCode}.
  *
- * @param yearWeekCode
- * @returns
+ * @param yearWeekCode - the encoded year+week code (e.g. 202401 = week 1 of 2024)
+ * @returns the week index portion
+ *
+ * @example
+ * ```ts
+ * yearWeekCodeIndex(202415); // 15
+ * ```
  */
 export declare function yearWeekCodeIndex(yearWeekCode: YearWeekCode): YearWeekCodeIndex;
 /**
@@ -35,35 +40,59 @@ export interface YearWeekCodePair {
     year: number;
 }
 /**
- * Returns the YearWeekCodePair for the YearWeekCode.
+ * Decodes a {@link YearWeekCode} into its year and week components.
+ *
+ * @param yearWeekCode - the encoded year+week code
+ * @returns the decoded pair with year and week
  *
- * @param yearWeekCode
- * @returns
+ * @example
+ * ```ts
+ * yearWeekCodePair(202415); // { year: 2024, week: 15 }
+ * ```
  */
 export declare function yearWeekCodePair(yearWeekCode: YearWeekCode): YearWeekCodePair;
 /**
- * Creates a YearWeekCodePair using the input date and the current/system timezone.
+ * Creates a {@link YearWeekCodePair} from a Date using the system timezone.
+ *
+ * Handles year-boundary weeks correctly (e.g. Dec 31 that falls in week 1 of the next year).
+ *
+ * @param date - the date to compute the week pair for
+ * @returns the year and week-of-year pair
  *
- * @param date
- * @returns
+ * @example
+ * ```ts
+ * yearWeekCodePairFromDate(new Date('2024-04-15'));
+ * // { year: 2024, week: 16 }
+ * ```
  */
 export declare function yearWeekCodePairFromDate(date: Date): YearWeekCodePair;
 /**
- * Creates a YearWeekCode from the input pair.
+ * Encodes a {@link YearWeekCodePair} into a single {@link YearWeekCode} number.
  *
- * @param pair
- * @returns
+ * @param pair - the year and week to encode
+ * @returns the encoded code (e.g. { year: 2024, week: 15 } => 202415)
+ *
+ * @example
+ * ```ts
+ * yearWeekCodeFromPair({ year: 2024, week: 15 }); // 202415
+ * ```
  */
 export declare function yearWeekCodeFromPair(pair: YearWeekCodePair): YearWeekCode;
 /**
- * Creates a YearWeekCode from the input Date.
+ * Computes the {@link YearWeekCode} for a Date, optionally in a specific timezone.
+ *
+ * @param date - the date to compute the week code for
+ * @param timezone - optional timezone (defaults to system timezone)
+ * @returns the encoded year+week code
  *
- * @param date
- * @returns
+ * @example
+ * ```ts
+ * yearWeekCodeFromDate(new Date('2024-04-15')); // 202416
+ * ```
  */
 export declare function yearWeekCodeFromDate(date: Date, timezone?: YearWeekCodeDateTimezoneInput): YearWeekCode;
 /**
- * Used to convert the input to a YearWeekCode.
+ * A function that computes a {@link YearWeekCode} from either a Date or explicit year+week values.
  */
 export type YearWeekCodeFactory = ((dateOrYear: Date | number, inputWeek?: YearWeekCodeIndex) => YearWeekCode) & {
     _normal: DateTimezoneUtcNormalInstance;
@@ -78,24 +107,39 @@ export interface YearWeekCodeConfig {
     timezone?: YearWeekCodeDateTimezoneInput;
 }
 /**
- * Creates a DateTimezoneUtcNormalInstance using the input config.
+ * Resolves a timezone input into a {@link DateTimezoneUtcNormalInstance} for use with YearWeekCode calculations.
  *
- * @param input
- * @returns
+ * Falls back to the system timezone instance if the input is falsy.
+ *
+ * @param input - timezone string, config, or instance
+ * @returns the resolved normal instance
  */
 export declare function yearWeekCodeDateTimezoneInstance(input: YearWeekCodeDateTimezoneInput): DateTimezoneUtcNormalInstance;
 /**
- * Returns the yearWeekCode for the input system Date or Year/Week combo.
+ * Computes the {@link YearWeekCode} from a Date (using system timezone) or from explicit year and week values.
  *
- * @param date
+ * @example
+ * ```ts
+ * yearWeekCode(new Date('2024-04-15')); // 202416
+ * yearWeekCode(2024, 15);               // 202415
+ * ```
  */
 export declare function yearWeekCode(date: Date): YearWeekCode;
 export declare function yearWeekCode(year: number, week: YearWeekCodeIndex): YearWeekCode;
 /**
- * Creates a YearWeekCodeFactory using the optional input config.
+ * Creates a {@link YearWeekCodeFactory} that computes YearWeekCode values in the configured timezone.
+ *
+ * The factory accepts either a Date or explicit year+week values.
  *
- * @param config
- * @returns
+ * @param config - optional timezone configuration (defaults to system timezone)
+ * @returns a factory function for computing YearWeekCode values
+ *
+ * @example
+ * ```ts
+ * const factory = yearWeekCodeFactory({ timezone: 'America/Chicago' });
+ * factory(new Date('2024-04-15')); // 202416
+ * factory(2024, 15);               // 202415
+ * ```
  */
 export declare function yearWeekCodeFactory(config?: YearWeekCodeConfig): YearWeekCodeFactory;
 /**
@@ -103,24 +147,24 @@ export declare function yearWeekCodeFactory(config?: YearWeekCodeConfig): YearWe
  */
 export type YearWeekCodeForDateRangeFactory = (dateRange: DateRange) => YearWeekCode[];
 /**
- * Returns the yearWeekCodes for the input Date's calendar month.
+ * Returns all {@link YearWeekCode} values that overlap with the given date range, using the system timezone.
  *
- * @param date
+ * @param dateRange - the date range to compute week codes for
+ * @returns an array of YearWeekCode values covering the range
  */
 export declare function yearWeekCodeForDateRange(dateRange: DateRange): YearWeekCode[];
 /**
- * Returns the yearWeekCodes for the input date range's calendar month and evaluates those dates from the input timezone.
- *
- * The timezone of the DateRange should be passed to ensure the proper yearWeekCodes are returned.
+ * Returns all {@link YearWeekCode} values that overlap with the given date range, evaluated in the specified timezone.
  *
- * @param date
+ * @param dateRange - the range to compute week codes for
+ * @param dateRangeTimezone - the timezone context for accurate week boundary calculation
  */
 export declare function yearWeekCodeForDateRangeInTimezone(dateRange: DateRange, dateRangeTimezone: YearWeekCodeDateTimezoneInput): YearWeekCode[];
 /**
- * Create a YearWeekCodeForMonthFactory.
+ * Creates a {@link YearWeekCodeForDateRangeFactory} that computes all week codes overlapping a date range.
  *
- * @param factory
- * @returns
+ * @param factory - the YearWeekCodeFactory to use (defaults to system timezone)
+ * @returns a factory that accepts a DateRange and returns overlapping YearWeekCode values
  */
 export declare function yearWeekCodeForDateRangeFactory(factory?: YearWeekCodeFactory): YearWeekCodeForDateRangeFactory;
 /**
@@ -128,38 +172,47 @@ export declare function yearWeekCodeForDateRangeFactory(factory?: YearWeekCodeFa
  */
 export type YearWeekCodeForCalendarMonthFactory = (date: Date) => YearWeekCode[];
 /**
- * Returns the yearWeekCodes for the input Date's calendar month.
+ * Returns all {@link YearWeekCode} values for the calendar month containing the given date, using the system timezone.
  *
- * The date is expected to be relative to UTC.
- *
- * @param date
+ * @param date - a date within the target month
  */
 export declare function yearWeekCodeForCalendarMonth(date: Date): YearWeekCode[];
 /**
- * Create a YearWeekCodeForMonthFactory.
+ * Creates a {@link YearWeekCodeForCalendarMonthFactory} that computes all week codes for a calendar month.
  *
- * @param factory
- * @returns
+ * @param factory - the YearWeekCodeFactory to use (defaults to system timezone)
+ * @returns a factory that accepts a Date and returns YearWeekCode values for that month
  */
 export declare function yearWeekCodeForCalendarMonthFactory(factory?: YearWeekCodeFactory): YearWeekCodeForCalendarMonthFactory;
 /**
- * Used to convert the input to a YearWeekCode.
+ * A function that converts a {@link YearWeekCode} back to the start-of-week Date.
  */
 export type YearWeekCodeDateFactory = (yearWeekCode: YearWeekCode) => Date;
 export type YearWeekCodeDateConfig = Pick<YearWeekCodeConfig, 'timezone'>;
 /**
- * Creates a YearWeekCodeDateFactory using the optional input config.
+ * Creates a factory that converts a {@link YearWeekCode} back into the start-of-week Date for that week.
+ *
+ * @param config - optional timezone configuration
+ * @returns a function that converts a YearWeekCode to its corresponding start-of-week Date
  *
- * @param config
- * @returns
+ * @example
+ * ```ts
+ * const toDate = yearWeekCodeDateFactory({ timezone: 'America/Chicago' });
+ * const weekStart = toDate(202415); // Sunday of week 15, 2024
+ * ```
  */
 export declare function yearWeekCodeDateFactory(config?: YearWeekCodeDateConfig): YearWeekCodeDateFactory;
 /**
- * Convenience function for calling yearWeekCodeDateFactory() with the input year week code and optional timezone.
+ * Returns the start-of-week Date for the given {@link YearWeekCode}, optionally in a specific timezone.
  *
- * @param yearWeekCode
- * @param timezone
- * @returns
+ * @param yearWeekCode - the encoded year+week code
+ * @param timezone - optional timezone (defaults to system timezone)
+ * @returns the Date at the start of the specified week
+ *
+ * @example
+ * ```ts
+ * startOfWeekForYearWeekCode(202415); // Sunday of week 15, 2024
+ * ```
  */
 export declare function startOfWeekForYearWeekCode(yearWeekCode: YearWeekCode, timezone?: YearWeekCodeDateTimezoneInput): Date;
 /**
@@ -184,9 +237,20 @@ export interface YearWeekCodeGroupFactoryConfig<B> {
     dateReader: YearWeekCodeDateReader<B>;
 }
 /**
- * Creates a YearWeekCodeGroupFactory.
+ * Creates a {@link YearWeekCodeGroupFactory} that groups items by their {@link YearWeekCode}.
+ *
+ * Uses the configured date reader to extract a date or week code from each item, then groups items that share the same week.
+ *
+ * @param config - reader and factory configuration
+ * @returns a factory that groups input items by YearWeekCode
  *
- * @param config
- * @returns
+ * @example
+ * ```ts
+ * const group = yearWeekCodeGroupFactory({
+ *   dateReader: (item) => item.date,
+ * });
+ * const groups = group([{ date: new Date('2024-04-15') }, { date: new Date('2024-04-16') }]);
+ * // groups[0].week === 202416, groups[0].items has both items
+ * ```
  */
 export declare function yearWeekCodeGroupFactory<B>(config: YearWeekCodeGroupFactoryConfig<B>): YearWeekCodeGroupFactory<B>;

package/src/lib/query/query.builder.d.ts

@@ -1,5 +1,11 @@
 import { type Maybe, type TimezoneString } from '@dereekb/util';
 import { type DateDayTimezoneHintFilter, type DateItemOccuringFilter, type DateItemQueryStartsEndsFilter, type DateItemRangeFilter } from './query.filter';
+/**
+ * Paired time and day filters produced by a {@link DaysAndTimeFiltersFunction}.
+ *
+ * Separates the UTC-based time filter from the timezone-adjusted day filter so
+ * that consumers can apply each independently or together.
+ */
 export interface DaysAndTimeFilter<F> {
     /**
      * The time filter is the primary filter.
@@ -10,6 +16,13 @@ export interface DaysAndTimeFilter<F> {
      */
     daysFilter: Maybe<F>;
 }
+/**
+ * Intermediate representation of a date query before it is compiled into
+ * database-specific filters via a {@link DateQueryBuilder}.
+ *
+ * Captures upper/lower bounds for both the starts-at and ends-at fields,
+ * plus the implied recurrence range used internally for range-based filtering.
+ */
 export interface RawDateQuery extends DateDayTimezoneHintFilter {
     timezone?: Maybe<TimezoneString>;
     startsLte?: Maybe<Date>;
@@ -27,7 +40,10 @@ export interface RawDateQuery extends DateDayTimezoneHintFilter {
     rEnd?: Maybe<Date>;
 }
 /**
+ * Strategy interface that converts {@link RawDateQuery} bounds into
+ * database-specific range objects (`R`) and field filter objects (`F`).
  *
+ * Implementations are provided for different query backends (e.g. MongoDB-like).
  */
 export interface DateQueryBuilder<R, F> {
     /**
@@ -47,13 +63,88 @@ export type MakeRangeFilterFunction<R> = (gte: Maybe<Date>, lte: Maybe<Date>) =>
  * The "ends" should be equal to the endsAt end range first, and then the startsAt end range if provided.
  */
 export type MergeStartsAtEndsAtFilterFunction<R> = (startsAt: Maybe<R>, endsAt: Maybe<R>) => R;
+/**
+ * Input to {@link MakeFieldFilterFunction} containing the optional range
+ * objects for starts-at and ends-at fields.
+ */
 export interface MakeFieldFilterInput<R> {
     startsAt?: Maybe<R>;
     endsAt?: Maybe<R>;
 }
 export type MakeFieldFilterFunction<R, F> = (input: MakeFieldFilterInput<R>) => F;
+/**
+ * Builds a {@link RawDateQuery} that matches items occurring at a single point in time.
+ *
+ * Sets `startsLte` and `endsGte` to the same instant so only items whose
+ * active window contains the target date are included.
+ *
+ * @example
+ * ```ts
+ * const query = makeDateQueryForOccuringFilter({
+ *   occuringAt: new Date('2026-06-15T12:00:00Z'),
+ *   timezone: 'America/Chicago'
+ * });
+ * ```
+ *
+ * @param find - Filter specifying the target date and optional timezone hint.
+ * @returns A raw date query representing the "occurring at" constraint.
+ */
 export declare function makeDateQueryForOccuringFilter(find: DateItemOccuringFilter & DateDayTimezoneHintFilter): RawDateQuery;
+/**
+ * Builds a {@link RawDateQuery} from a {@link DateItemRangeFilter}, deriving
+ * the concrete start/end dates from the provided {@link DateRangeParams}.
+ *
+ * When `rangeContained` is true, only items fully enclosed within the range
+ * are matched. Otherwise items merely overlapping the range are included.
+ *
+ * @example
+ * ```ts
+ * const query = makeDateQueryForDateItemRangeFilter({
+ *   range: { type: DateRangeType.WEEK, date: new Date() },
+ *   timezone: 'America/New_York',
+ *   rangeContained: false
+ * });
+ * ```
+ *
+ * @param find - Range filter with optional timezone and containment flag.
+ * @returns A raw date query bounded by the resolved range.
+ */
 export declare function makeDateQueryForDateItemRangeFilter(find: DateItemRangeFilter): RawDateQuery;
+/**
+ * Builds a {@link RawDateQuery} from explicit starts/ends boundary constraints.
+ *
+ * Allows callers to independently control the before/after bounds for both
+ * the start and end fields of date items.
+ *
+ * @example
+ * ```ts
+ * const query = makeDateQueryForDateStartsEndsFilter({
+ *   starts: { after: new Date('2026-01-01'), before: new Date('2026-12-31') },
+ *   ends: { after: new Date('2026-06-01') },
+ *   timezone: 'UTC'
+ * });
+ * ```
+ *
+ * @param find - Filter with optional starts/ends boundaries and timezone hint.
+ * @returns A raw date query with the corresponding GTE/LTE bounds populated.
+ */
 export declare function makeDateQueryForDateStartsEndsFilter(find: DateItemQueryStartsEndsFilter & DateDayTimezoneHintFilter): RawDateQuery;
 export type DaysAndTimeFiltersFunction<F> = (dateQueryInstance: RawDateQuery) => DaysAndTimeFilter<F>;
+/**
+ * Creates a function that splits a {@link RawDateQuery} into separate time
+ * and day filters using the supplied {@link DateQueryBuilder}.
+ *
+ * The day filter is only produced when a timezone is present, allowing
+ * timezone-aware day-level filtering alongside the UTC time filter.
+ *
+ * @example
+ * ```ts
+ * const filtersFunction = makeDaysAndTimeFiltersFunction(mongoBuilder);
+ * const rawQuery = makeDateQueryForOccuringFilter({ occuringAt: new Date() });
+ * const { timeFilter, daysFilter } = filtersFunction(rawQuery);
+ * ```
+ *
+ * @param builder - Strategy for converting date bounds into backend-specific filters.
+ * @returns A function that produces a {@link DaysAndTimeFilter} from a raw query.
+ */
 export declare function makeDaysAndTimeFiltersFunction<R, F>(builder: DateQueryBuilder<R, F>): DaysAndTimeFiltersFunction<F>;

package/src/lib/query/query.builder.mongo.d.ts

@@ -1,15 +1,46 @@
 import { type Maybe } from '@dereekb/util';
 import { type DateQueryBuilder } from './query.builder';
+/**
+ * Describes the document field names that store temporal start/end values,
+ * used by {@link makeMongoDBLikeDateQueryBuilder} to produce query filters.
+ */
 export interface TimeFieldsNameSet {
+    /** Field name storing the start (or combined start+end) timestamp. */
     start: string;
+    /** Field name storing the end timestamp. Ignored when `singleFieldForStartAndEnd` is true. */
     end?: string;
+    /** When true, a single field represents both start and end so range bounds are merged. */
     singleFieldForStartAndEnd?: boolean;
 }
+/**
+ * A MongoDB-style range filter object with optional upper and lower date bounds.
+ */
 export interface MongoDBLikeDateRangeFilter {
     $lte?: Date;
     $gte?: Date;
 }
 export type MongoDBLikeDateQueryFilter = object;
+/**
+ * Merges separate starts-at and ends-at range filters into a single
+ * {@link MongoDBLikeDateRangeFilter} for documents that use one field
+ * to represent both start and end.
+ *
+ * Takes `$lte` from `startsAt` (falling back to `endsAt`) and `$gte` from
+ * `endsAt` (falling back to `startsAt`).
+ *
+ * @example
+ * ```ts
+ * const merged = mergeMongoDBLikeRangeFilters(
+ *   { $lte: new Date('2026-12-31') },
+ *   { $gte: new Date('2026-01-01') }
+ * );
+ * // { $lte: 2026-12-31, $gte: 2026-01-01 }
+ * ```
+ *
+ * @param startsAt - Range filter derived from the starts-at bounds.
+ * @param endsAt - Range filter derived from the ends-at bounds.
+ * @returns A single merged range filter.
+ */
 export declare function mergeMongoDBLikeRangeFilters(startsAt: Maybe<MongoDBLikeDateRangeFilter>, endsAt: Maybe<MongoDBLikeDateRangeFilter>): {
     $lte: Date | undefined;
     $gte: Date | undefined;
@@ -17,4 +48,23 @@ export declare function mergeMongoDBLikeRangeFilters(startsAt: Maybe<MongoDBLike
 export interface MakeMongoDBLikeDateQueryBuilderConfig {
     fields: TimeFieldsNameSet;
 }
+/**
+ * Creates a {@link DateQueryBuilder} that produces MongoDB-style `$gte`/`$lte`
+ * query filter objects for the configured time fields.
+ *
+ * Supports both two-field (start + end) and single-field date models.
+ *
+ * @example
+ * ```ts
+ * const builder = makeMongoDBLikeDateQueryBuilder({
+ *   fields: { start: 'startsAt', end: 'endsAt' }
+ * });
+ * const filter = builder.makeFieldFilter({
+ *   startsAt: { $gte: new Date('2026-01-01') }
+ * });
+ * ```
+ *
+ * @param config - Configuration specifying the document field names.
+ * @returns A date query builder producing MongoDB-like filter objects.
+ */
 export declare function makeMongoDBLikeDateQueryBuilder(config: MakeMongoDBLikeDateQueryBuilderConfig): DateQueryBuilder<MongoDBLikeDateRangeFilter, MongoDBLikeDateQueryFilter>;

package/src/lib/query/query.filter.d.ts

@@ -1,11 +1,17 @@
 import { type Maybe, type TimezoneString } from '@dereekb/util';
 import { type DateRangeParams } from '../date/date.range';
+/**
+ * Filter parameter that matches a date exactly equal to a given value.
+ */
 export interface FindEqualsDateParam {
     /**
      * Date exactly equals this.
      */
     at?: Date;
 }
+/**
+ * Extends {@link FindEqualsDateParam} with before/after bounds for range-based matching.
+ */
 export interface FindDateParam extends FindEqualsDateParam {
     /**
      * Date is before or equal to this point.
@@ -17,7 +23,8 @@ export interface FindDateParam extends FindEqualsDateParam {
     after?: Date;
 }
 /**
- * Filter that denotes which timezone to use when searching for full-date items.
+ * Provides a timezone hint so that day-level (all-day) items can be correctly
+ * resolved relative to the caller's local day boundaries.
  */
 export interface DateDayTimezoneHintFilter {
     /**
@@ -27,6 +34,9 @@ export interface DateDayTimezoneHintFilter {
      */
     timezone?: Maybe<TimezoneString>;
 }
+/**
+ * Filter for querying date items that are active ("occurring") at a specific instant.
+ */
 export interface DateItemOccuringFilter {
     /**
      * Queries items that will be "ongoing" during this period.
@@ -35,6 +45,9 @@ export interface DateItemOccuringFilter {
      */
     occuringAt?: Date;
 }
+/**
+ * Filter that matches items whose start and/or end dates exactly equal the given values.
+ */
 export interface DateItemQueryStartsEndsEqualsFilter {
     /**
      * The start of a range.
@@ -46,7 +59,8 @@ export interface DateItemQueryStartsEndsEqualsFilter {
     ends?: FindEqualsDateParam;
 }
 /**
- * Simple filter for quering against items that may start and/or end within a certain range.
+ * Filter for querying items whose start and/or end dates fall within
+ * independently specified before/after boundaries.
  */
 export interface DateItemQueryStartsEndsFilter {
     /**
@@ -58,6 +72,10 @@ export interface DateItemQueryStartsEndsFilter {
      */
     ends?: FindDateParam;
 }
+/**
+ * Filter that constrains results to a single date range, optionally
+ * adjusted for a specific timezone.
+ */
 export interface DateRangeFilter extends DateDayTimezoneHintFilter {
     /**
      * Queries items that start within the specified date range.
@@ -66,6 +84,10 @@ export interface DateRangeFilter extends DateDayTimezoneHintFilter {
      */
     range: DateRangeParams;
 }
+/**
+ * Extends {@link DateRangeFilter} with an option to require items to be fully
+ * contained within the range rather than merely overlapping it.
+ */
 export interface DateItemRangeFilter extends DateRangeFilter {
     /**
      * Whether or not to filter on only items occuring within this range.
@@ -74,5 +96,10 @@ export interface DateItemRangeFilter extends DateRangeFilter {
      */
     rangeContained?: boolean;
 }
+/**
+ * Composite filter combining explicit starts/ends boundaries with a
+ * range-based filter, enabling both range containment and fine-grained
+ * boundary constraints in a single query.
+ */
 export interface DateItemQueryStartsEndsWithRangeFilter extends DateItemQueryStartsEndsFilter, DateItemRangeFilter {
 }

package/src/lib/query/query.request.d.ts

@@ -1,18 +1,34 @@
 import { type ISO8601DateString } from '@dereekb/util';
 import { type DateRangeType } from '../date';
+/**
+ * Serializable request counterpart to {@link FindDateParam}, using ISO 8601
+ * strings so it can be sent over the wire.
+ */
 export interface FindDateParamRequest {
     before?: ISO8601DateString;
     after?: ISO8601DateString;
 }
+/**
+ * Serializable request counterpart to {@link DateItemOccuringFilter}, using
+ * an ISO 8601 string for the target instant.
+ */
 export interface DateItemOccuringFilterRequest {
     occuringAt?: ISO8601DateString;
 }
+/**
+ * Serializable request for filtering by starts/ends boundaries, extending
+ * {@link DateItemOccuringFilterRequest} with ISO 8601 string bounds.
+ */
 export interface DateItemQueryStartsEndsFilterRequest extends DateItemOccuringFilterRequest {
     startsBefore?: ISO8601DateString;
     startsAfter?: ISO8601DateString;
     endsBefore?: ISO8601DateString;
     endsAfter?: ISO8601DateString;
 }
+/**
+ * Serializable request combining starts/ends boundaries with a date range
+ * filter, including range type, distance, containment flag, and timezone.
+ */
 export interface DateItemQueryStartsEndsWithRangeFilterRequest extends DateItemQueryStartsEndsFilterRequest {
     rangeType?: DateRangeType;
     rangeDate?: ISO8601DateString;