@checkdigit/time 4.0.0 → 5.0.0-PR.21-7813

package/dist-types/date-fns/differenceInDays/index.d.ts

@@ -1,3 +1,9 @@
+import type { ContextOptions, DateArg } from '../types.ts';
+/**
+ * The {@link differenceInDays} function options.
+ */
+export interface DifferenceInDaysOptions extends ContextOptions<Date> {
+}
 /**
  * @name differenceInDays
  * @category Day Helpers
@@ -14,10 +20,9 @@
  * To ignore DST and only measure exact 24-hour periods, use this instead:
  * `Math.trunc(differenceInHours(dateLeft, dateRight)/24)|0`.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
- * @param dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
+ * @param options - An object with options
  *
  * @returns The number of full days according to the local timezone
  *
@@ -52,4 +57,4 @@
  * )
  * //=> 92
  */
-export declare function differenceInDays<DateType extends Date>(dateLeft: DateType | number | string, dateRight: DateType | number | string): number;
+export declare function differenceInDays(laterDate: DateArg<Date> & {}, earlierDate: DateArg<Date> & {}, options?: DifferenceInDaysOptions | undefined): number;

package/dist-types/date-fns/differenceInHours/index.d.ts

@@ -1,8 +1,8 @@
-import type { RoundingOptions } from '../types';
+import type { ContextOptions, DateArg, RoundingOptions } from '../types.ts';
 /**
  * The {@link differenceInHours} function options.
  */
-export interface DifferenceInHoursOptions extends RoundingOptions {
+export interface DifferenceInHoursOptions extends RoundingOptions, ContextOptions<Date> {
 }
 /**
  * @name differenceInHours
@@ -12,10 +12,8 @@ export interface DifferenceInHoursOptions extends RoundingOptions {
  * @description
  * Get the number of hours between the given dates.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
- * @param dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
  * @param options - An object with options.
  *
  * @returns The number of hours
@@ -28,4 +26,4 @@ export interface DifferenceInHoursOptions extends RoundingOptions {
  * )
  * //=> 12
  */
-export declare function differenceInHours<DateType extends Date>(dateLeft: DateType | number | string, dateRight: DateType | number | string, options?: DifferenceInHoursOptions): number;
+export declare function differenceInHours(laterDate: DateArg<Date> & {}, earlierDate: DateArg<Date> & {}, options?: DifferenceInHoursOptions): number;

package/dist-types/date-fns/differenceInISOWeekYears/index.d.ts

@@ -1,3 +1,9 @@
+import type { ContextOptions, DateArg } from '../types.ts';
+/**
+ * The {@link differenceInISOWeekYears} function options.
+ */
+export interface DifferenceInISOWeekYearsOptions extends ContextOptions<Date> {
+}
 /**
  * @name differenceInISOWeekYears
  * @category ISO Week-Numbering Year Helpers
@@ -8,10 +14,9 @@
  *
  * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
- * @param dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
+ * @param options - The options
  *
  * @returns The number of full ISO week-numbering years
  *
@@ -21,6 +26,6 @@
  *   new Date(2012, 0, 1),
  *   new Date(2010, 0, 1)
  * )
- * //=> 1
+ * // => 1
  */
-export declare function differenceInISOWeekYears<DateType extends Date>(dateLeft: DateType | number | string, dateRight: DateType | number | string): number;
+export declare function differenceInISOWeekYears(laterDate: DateArg<Date> & {}, earlierDate: DateArg<Date> & {}, options?: DifferenceInISOWeekYearsOptions | undefined): number;

package/dist-types/date-fns/differenceInMilliseconds/index.d.ts

@@ -1,3 +1,4 @@
+import type { DateArg } from '../types.ts';
 /**
  * @name differenceInMilliseconds
  * @category Millisecond Helpers
@@ -6,10 +7,8 @@
  * @description
  * Get the number of milliseconds between the given dates.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
- * @param dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
  *
  * @returns The number of milliseconds
  *
@@ -22,4 +21,4 @@
  * )
  * //=> 1100
  */
-export declare function differenceInMilliseconds<DateType extends Date>(dateLeft: DateType | number | string, dateRight: DateType | number | string): number;
+export declare function differenceInMilliseconds(laterDate: DateArg<Date> & {}, earlierDate: DateArg<Date> & {}): number;

package/dist-types/date-fns/differenceInMinutes/index.d.ts

@@ -1,4 +1,4 @@
-import type { RoundingOptions } from '../types';
+import type { DateArg, RoundingOptions } from '../types.ts';
 /**
  * The {@link differenceInMinutes} function options.
  */
@@ -12,8 +12,6 @@ export interface DifferenceInMinutesOptions extends RoundingOptions {
  * @description
  * Get the signed number of full (rounded towards 0) minutes between the given dates.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
  * @param dateLeft - The later date
  * @param dateRight - The earlier date
  * @param options - An object with options.
@@ -36,4 +34,4 @@ export interface DifferenceInMinutesOptions extends RoundingOptions {
  * )
  * //=> -1
  */
-export declare function differenceInMinutes<DateType extends Date>(dateLeft: DateType | number | string, dateRight: DateType | number | string, options?: DifferenceInMinutesOptions): number;
+export declare function differenceInMinutes(dateLeft: DateArg<Date> & {}, dateRight: DateArg<Date> & {}, options?: DifferenceInMinutesOptions): number;

package/dist-types/date-fns/differenceInMonths/index.d.ts

@@ -1,15 +1,17 @@
+import type { ContextOptions, DateArg } from '../types.ts';
+/**
+ * The {@link differenceInMonths} function options.
+ */
+export interface DifferenceInMonthsOptions extends ContextOptions<Date> {
+}
 /**
  * @name differenceInMonths
  * @category Month Helpers
  * @summary Get the number of full months between the given dates.
  *
- * @description
- * Get the number of full months between the given dates using trunc as a default rounding method.
- *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
- * @param dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
+ * @param options - An object with options
  *
  * @returns The number of full months
  *
@@ -18,4 +20,4 @@
  * const result = differenceInMonths(new Date(2014, 8, 1), new Date(2014, 0, 31))
  * //=> 7
  */
-export declare function differenceInMonths<DateType extends Date>(dateLeft: DateType | number | string, dateRight: DateType | number | string): number;
+export declare function differenceInMonths(laterDate: DateArg<Date> & {}, earlierDate: DateArg<Date> & {}, options?: DifferenceInMonthsOptions | undefined): number;

package/dist-types/date-fns/differenceInQuarters/index.d.ts

@@ -1,8 +1,8 @@
-import type { RoundingOptions } from '../types';
+import type { ContextOptions, DateArg, RoundingOptions } from '../types.ts';
 /**
  * The {@link differenceInQuarters} function options.
  */
-export interface DifferenceInQuartersOptions extends RoundingOptions {
+export interface DifferenceInQuartersOptions extends RoundingOptions, ContextOptions<Date> {
 }
 /**
  * @name differenceInQuarters
@@ -12,10 +12,8 @@ export interface DifferenceInQuartersOptions extends RoundingOptions {
  * @description
  * Get the number of quarters between the given dates.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
- * @param dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
  * @param options - An object with options.
  *
  * @returns The number of full quarters
@@ -25,4 +23,4 @@ export interface DifferenceInQuartersOptions extends RoundingOptions {
  * const result = differenceInQuarters(new Date(2014, 6, 2), new Date(2013, 11, 31))
  * //=> 2
  */
-export declare function differenceInQuarters<DateType extends Date>(dateLeft: DateType | number | string, dateRight: DateType | number | string, options?: DifferenceInQuartersOptions): number;
+export declare function differenceInQuarters(laterDate: DateArg<Date> & {}, earlierDate: DateArg<Date> & {}, options?: DifferenceInQuartersOptions | undefined): number;

package/dist-types/date-fns/differenceInSeconds/index.d.ts

@@ -1,4 +1,4 @@
-import type { RoundingOptions } from '../types';
+import type { DateArg, RoundingOptions } from '../types.ts';
 /**
  * The {@link differenceInSeconds} function options.
  */
@@ -12,10 +12,8 @@ export interface DifferenceInSecondsOptions extends RoundingOptions {
  * @description
  * Get the number of seconds between the given dates.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
- * @param dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
  * @param options - An object with options.
  *
  * @returns The number of seconds
@@ -29,4 +27,4 @@ export interface DifferenceInSecondsOptions extends RoundingOptions {
  * )
  * //=> 12
  */
-export declare function differenceInSeconds<DateType extends Date>(dateLeft: DateType | number | string, dateRight: DateType | number | string, options?: DifferenceInSecondsOptions): number;
+export declare function differenceInSeconds(laterDate: DateArg<Date> & {}, earlierDate: DateArg<Date> & {}, options?: DifferenceInSecondsOptions): number;

package/dist-types/date-fns/differenceInWeeks/index.d.ts

@@ -1,8 +1,8 @@
-import type { RoundingOptions } from '../types';
+import type { ContextOptions, DateArg, RoundingOptions } from '../types.ts';
 /**
  * The {@link differenceInWeeks} function options.
  */
-export interface DifferenceInWeeksOptions extends RoundingOptions {
+export interface DifferenceInWeeksOptions extends RoundingOptions, ContextOptions<Date> {
 }
 /**
  * @name differenceInWeeks
@@ -20,10 +20,8 @@ export interface DifferenceInWeeksOptions extends RoundingOptions {
  * To ignore DST and only measure exact 7*24-hour periods, use this instead:
  * `Math.trunc(differenceInHours(dateLeft, dateRight)/(7*24))|0`.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
- * @param dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
  * @param options - An object with options
  *
  * @returns The number of full weeks
@@ -46,4 +44,4 @@ export interface DifferenceInWeeksOptions extends RoundingOptions {
  * )
  * //=> 8
  */
-export declare function differenceInWeeks<DateType extends Date>(dateLeft: DateType | number | string, dateRight: DateType | number | string, options?: DifferenceInWeeksOptions): number;
+export declare function differenceInWeeks(laterDate: DateArg<Date> & {}, earlierDate: DateArg<Date> & {}, options?: DifferenceInWeeksOptions | undefined): number;

package/dist-types/date-fns/differenceInYears/index.d.ts

@@ -1,3 +1,9 @@
+import type { ContextOptions, DateArg } from '../types.ts';
+/**
+ * The {@link differenceInYears} function options.
+ */
+export interface DifferenceInYearsOptions extends ContextOptions<Date> {
+}
 /**
  * @name differenceInYears
  * @category Year Helpers
@@ -6,10 +12,9 @@
  * @description
  * Get the number of full years between the given dates.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
- * @param dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
+ * @param options - An object with options
  *
  * @returns The number of full years
  *
@@ -18,4 +23,4 @@
  * const result = differenceInYears(new Date(2015, 1, 11), new Date(2013, 11, 31))
  * //=> 1
  */
-export declare function differenceInYears<DateType extends Date>(dateLeft: DateType | number | string, dateRight: DateType | number | string): number;
+export declare function differenceInYears(laterDate: DateArg<Date> & {}, earlierDate: DateArg<Date> & {}, options?: DifferenceInYearsOptions | undefined): number;

package/dist-types/date-fns/eachDayOfInterval/index.d.ts

@@ -1,9 +1,16 @@
-import type { Interval, StepOptions } from '../types';
+import type { ContextOptions, Interval, StepOptions } from '../types.ts';
 /**
  * The {@link eachDayOfInterval} function options.
  */
-export interface EachDayOfIntervalOptions extends StepOptions {
+export interface EachDayOfIntervalOptions<DateType extends Date = Date> extends StepOptions, ContextOptions<DateType> {
 }
+/**
+ * The {@link eachDayOfInterval} function result type. It resolves the proper data type.
+ * It uses the first argument date object type, starting from the date argument,
+ * then the start interval date, and finally the end interval date. If
+ * a context function is passed, it uses the context function return type.
+ */
+export type EachDayOfIntervalResult<IntervalType extends Interval, Options extends EachDayOfIntervalOptions | undefined> = Array<Options extends EachDayOfIntervalOptions<infer DateType> ? DateType : IntervalType['start'] extends Date ? IntervalType['start'] : IntervalType['end'] extends Date ? IntervalType['end'] : Date>;
 /**
  * @name eachDayOfInterval
  * @category Interval Helpers
@@ -12,7 +19,8 @@ export interface EachDayOfIntervalOptions extends StepOptions {
  * @description
  * Return the array of dates within the specified time interval.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam IntervalType - Interval type.
+ * @typeParam Options - Options type.
  *
  * @param interval - The interval.
  * @param options - An object with options.
@@ -33,4 +41,4 @@ export interface EachDayOfIntervalOptions extends StepOptions {
  * //   Fri Oct 10 2014 00:00:00
  * // ]
  */
-export declare function eachDayOfInterval<DateType extends Date>(interval: Interval<DateType>, options?: EachDayOfIntervalOptions): DateType[];
+export declare function eachDayOfInterval<IntervalType extends Interval, Options extends EachDayOfIntervalOptions | undefined = undefined>(interval: IntervalType, options?: Options): EachDayOfIntervalResult<IntervalType, Options>;

package/dist-types/date-fns/eachHourOfInterval/index.d.ts

@@ -1,9 +1,14 @@
-import type { Interval, StepOptions } from '../types';
+import type { ContextOptions, Interval, StepOptions } from '../types.ts';
 /**
  * The {@link eachHourOfInterval} function options.
  */
-export interface EachHourOfIntervalOptions extends StepOptions {
+export interface EachHourOfIntervalOptions<DateType extends Date = Date> extends StepOptions, ContextOptions<DateType> {
 }
+/**
+ * The {@link eachHourOfInterval} function result type.
+ * Resolves to the appropriate date type based on inputs.
+ */
+export type EachHourOfIntervalResult<IntervalType extends Interval, Options extends EachHourOfIntervalOptions | undefined> = Array<Options extends EachHourOfIntervalOptions<infer DateType> ? DateType : IntervalType['start'] extends Date ? IntervalType['start'] : IntervalType['end'] extends Date ? IntervalType['end'] : Date>;
 /**
  * @name eachHourOfInterval
  * @category Interval Helpers
@@ -12,7 +17,8 @@ export interface EachHourOfIntervalOptions extends StepOptions {
  * @description
  * Return the array of hours within the specified time interval.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam IntervalType - Interval type.
+ * @typeParam Options - Options type.
  *
  * @param interval - The interval.
  * @param options - An object with options.
@@ -24,7 +30,7 @@ export interface EachHourOfIntervalOptions extends StepOptions {
  * const result = eachHourOfInterval({
  *   start: new Date(2014, 9, 6, 12),
  *   end: new Date(2014, 9, 6, 15)
- * })
+ * });
  * //=> [
  * //   Mon Oct 06 2014 12:00:00,
  * //   Mon Oct 06 2014 13:00:00,
@@ -32,4 +38,4 @@ export interface EachHourOfIntervalOptions extends StepOptions {
  * //   Mon Oct 06 2014 15:00:00
  * // ]
  */
-export declare function eachHourOfInterval<DateType extends Date>(interval: Interval<DateType>, options?: EachHourOfIntervalOptions): DateType[];
+export declare function eachHourOfInterval<IntervalType extends Interval, Options extends EachHourOfIntervalOptions | undefined = undefined>(interval: IntervalType, options?: Options): EachHourOfIntervalResult<IntervalType, Options>;

package/dist-types/date-fns/eachMinuteOfInterval/index.d.ts

@@ -1,9 +1,16 @@
-import type { Interval, StepOptions } from '../types';
+import type { ContextOptions, Interval, StepOptions } from '../types.ts';
 /**
  * The {@link eachMinuteOfInterval} function options.
  */
-export interface EachMinuteOfIntervalOptions extends StepOptions {
+export interface EachMinuteOfIntervalOptions<DateType extends Date = Date> extends StepOptions, ContextOptions<DateType> {
 }
+/**
+ * The {@link eachMinuteOfInterval} function result type. It resolves the proper data type.
+ * It uses the first argument date object type, starting from the date argument,
+ * then the start interval date, and finally the end interval date. If
+ * a context function is passed, it uses the context function return type.
+ */
+export type EachMinuteOfIntervalResult<IntervalType extends Interval, Options extends EachMinuteOfIntervalOptions | undefined> = Array<Options extends EachMinuteOfIntervalOptions<infer DateType> ? DateType : IntervalType['start'] extends Date ? IntervalType['start'] : IntervalType['end'] extends Date ? IntervalType['end'] : Date>;
 /**
  * @name eachMinuteOfInterval
  * @category Interval Helpers
@@ -12,7 +19,8 @@ export interface EachMinuteOfIntervalOptions extends StepOptions {
  * @description
  * Returns the array of minutes within the specified time interval.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam IntervalType - Interval type.
+ * @typeParam Options - Options type.
  *
  * @param interval - The interval.
  * @param options - An object with options.
@@ -32,4 +40,4 @@ export interface EachMinuteOfIntervalOptions extends StepOptions {
  * //   Wed Oct 14 2014 13:03:00
  * // ]
  */
-export declare function eachMinuteOfInterval<DateType extends Date>(interval: Interval<DateType>, options?: EachMinuteOfIntervalOptions): DateType[];
+export declare function eachMinuteOfInterval<IntervalType extends Interval, Options extends EachMinuteOfIntervalOptions | undefined = undefined>(interval: IntervalType, options?: Options): EachMinuteOfIntervalResult<IntervalType, Options>;

package/dist-types/date-fns/eachMonthOfInterval/index.d.ts

@@ -1,9 +1,13 @@
-import type { Interval, StepOptions } from '../types';
+import type { ContextOptions, Interval, StepOptions } from '../types.ts';
 /**
  * The {@link eachMonthOfInterval} function options.
  */
-export interface EachMonthOfIntervalOptions extends StepOptions {
+export interface EachMonthOfIntervalOptions<DateType extends Date = Date> extends StepOptions, ContextOptions<DateType> {
 }
+/**
+ * The {@link eachMonthOfInterval} function result type. It resolves the proper data type.
+ */
+export type EachMonthOfIntervalResult<IntervalType extends Interval, Options extends EachMonthOfIntervalOptions | undefined> = Array<Options extends EachMonthOfIntervalOptions<infer DateType> ? DateType : IntervalType['start'] extends Date ? IntervalType['start'] : IntervalType['end'] extends Date ? IntervalType['end'] : Date>;
 /**
  * @name eachMonthOfInterval
  * @category Interval Helpers
@@ -12,9 +16,11 @@ export interface EachMonthOfIntervalOptions extends StepOptions {
  * @description
  * Return the array of months within the specified time interval.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam IntervalType - Interval type.
+ * @typeParam Options - Options type.
  *
- * @param interval - The interval
+ * @param interval - The interval.
+ * @param options - An object with options.
  *
  * @returns The array with starts of months from the month of the interval start to the month of the interval end
  *
@@ -34,4 +40,4 @@ export interface EachMonthOfIntervalOptions extends StepOptions {
  * //   Fri Aug 01 2014 00:00:00
  * // ]
  */
-export declare function eachMonthOfInterval<DateType extends Date>(interval: Interval<DateType>, options?: EachMonthOfIntervalOptions): DateType[];
+export declare function eachMonthOfInterval<IntervalType extends Interval, Options extends EachMonthOfIntervalOptions | undefined = undefined>(interval: IntervalType, options?: Options): EachMonthOfIntervalResult<IntervalType, Options>;

package/dist-types/date-fns/eachQuarterOfInterval/index.d.ts

@@ -1,9 +1,16 @@
-import type { Interval, StepOptions } from '../types';
+import type { ContextOptions, Interval, StepOptions } from '../types.ts';
 /**
  * The {@link eachQuarterOfInterval} function options.
  */
-export interface EachQuarterOfIntervalOptions extends StepOptions {
+export interface EachQuarterOfIntervalOptions<DateType extends Date = Date> extends StepOptions, ContextOptions<DateType> {
 }
+/**
+ * The {@link eachQuarterOfInterval} function result type. It resolves the proper data type.
+ * It uses the first argument date object type, starting from the date argument,
+ * then the start interval date, and finally the end interval date. If
+ * a context function is passed, it uses the context function return type.
+ */
+export type EachQuarterOfIntervalResult<IntervalType extends Interval, Options extends EachQuarterOfIntervalOptions | undefined> = Array<Options extends EachQuarterOfIntervalOptions<infer DateType> ? DateType : IntervalType['start'] extends Date ? IntervalType['start'] : IntervalType['end'] extends Date ? IntervalType['end'] : Date>;
 /**
  * @name eachQuarterOfInterval
  * @category Interval Helpers
@@ -12,9 +19,11 @@ export interface EachQuarterOfIntervalOptions extends StepOptions {
  * @description
  * Return the array of quarters within the specified time interval.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam IntervalType - Interval type.
+ * @typeParam Options - Options type.
  *
  * @param interval - The interval
+ * @param options - An object with options
  *
  * @returns The array with starts of quarters from the quarter of the interval start to the quarter of the interval end
  *
@@ -22,7 +31,7 @@ export interface EachQuarterOfIntervalOptions extends StepOptions {
  * // Each quarter within interval 6 February 2014 - 10 August 2014:
  * const result = eachQuarterOfInterval({
  *   start: new Date(2014, 1, 6),
- *   end: new Date(2014, 7, 10)
+ *   end: new Date(2014, 7, 10),
  * })
  * //=> [
  * //   Wed Jan 01 2014 00:00:00,
@@ -30,4 +39,4 @@ export interface EachQuarterOfIntervalOptions extends StepOptions {
  * //   Tue Jul 01 2014 00:00:00,
  * // ]
  */
-export declare function eachQuarterOfInterval<DateType extends Date>(interval: Interval<DateType>, options?: EachQuarterOfIntervalOptions): DateType[];
+export declare function eachQuarterOfInterval<IntervalType extends Interval, Options extends EachQuarterOfIntervalOptions | undefined = undefined>(interval: IntervalType, options?: Options): EachQuarterOfIntervalResult<IntervalType, Options>;

package/dist-types/date-fns/eachWeekOfInterval/index.d.ts

@@ -1,9 +1,15 @@
-import type { Interval, LocalizedOptions, StepOptions, WeekOptions } from '../types';
+import type { ContextOptions, Interval, LocalizedOptions, StepOptions, WeekOptions } from '../types.ts';
 /**
  * The {@link eachWeekOfInterval} function options.
  */
-export interface EachWeekOfIntervalOptions extends StepOptions, WeekOptions, LocalizedOptions<'options'> {
+export interface EachWeekOfIntervalOptions<DateType extends Date = Date> extends StepOptions, WeekOptions, LocalizedOptions<'options'>, ContextOptions<DateType> {
 }
+/**
+ * The {@link eachWeekOfInterval} function result type. It resolves the proper data type.
+ * It uses the first argument date object type, starting from the interval start date,
+ * then the end interval date. If a context function is passed, it uses the context function return type.
+ */
+export type EachWeekOfIntervalResult<IntervalType extends Interval, Options extends EachWeekOfIntervalOptions | undefined> = Array<Options extends EachWeekOfIntervalOptions<infer DateType> ? DateType : IntervalType['start'] extends Date ? IntervalType['start'] : IntervalType['end'] extends Date ? IntervalType['end'] : Date>;
 /**
  * @name eachWeekOfInterval
  * @category Interval Helpers
@@ -12,8 +18,6 @@ export interface EachWeekOfIntervalOptions extends StepOptions, WeekOptions, Loc
  * @description
  * Return the array of weeks within the specified time interval.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- *
  * @param interval - The interval.
  * @param options - An object with options.
  *
@@ -36,4 +40,4 @@ export interface EachWeekOfIntervalOptions extends StepOptions, WeekOptions, Loc
  * //   Sun Nov 23 2014 00:00:00
  * // ]
  */
-export declare function eachWeekOfInterval<DateType extends Date>(interval: Interval<DateType>, options?: EachWeekOfIntervalOptions): DateType[];
+export declare function eachWeekOfInterval<IntervalType extends Interval, Options extends EachWeekOfIntervalOptions | undefined = undefined>(interval: IntervalType, options?: Options): EachWeekOfIntervalResult<IntervalType, Options>;

package/dist-types/date-fns/eachWeekendOfInterval/index.d.ts

@@ -1,4 +1,13 @@
-import type { Interval } from '../types';
+import type { ContextOptions, Interval } from '../types.ts';
+/**
+ * The {@link eachWeekendOfInterval} function options.
+ */
+export interface EachWeekendOfIntervalOptions<DateType extends Date = Date> extends ContextOptions<DateType> {
+}
+/**
+ * The {@link eachWeekendOfInterval} function result type.
+ */
+export type EachWeekendOfIntervalResult<IntervalType extends Interval, Options extends EachWeekendOfIntervalOptions | undefined> = Array<Options extends EachWeekendOfIntervalOptions<infer DateType> ? DateType : IntervalType['start'] extends Date ? IntervalType['start'] : IntervalType['end'] extends Date ? IntervalType['end'] : Date>;
 /**
  * @name eachWeekendOfInterval
  * @category Interval Helpers
@@ -7,9 +16,11 @@ import type { Interval } from '../types';
  * @description
  * Get all the Saturdays and Sundays in the given date interval.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam IntervalType - Interval type.
+ * @typeParam Options - Options type.
  *
  * @param interval - The given interval
+ * @param options - An object with options
  *
  * @returns An array containing all the Saturdays and Sundays
  *
@@ -26,4 +37,4 @@ import type { Interval } from '../types';
  * //   Sun Sep 30 2018 00:00:00
  * // ]
  */
-export declare function eachWeekendOfInterval<DateType extends Date>(interval: Interval<DateType>): DateType[];
+export declare function eachWeekendOfInterval<IntervalType extends Interval, Options extends EachWeekendOfIntervalOptions | undefined = undefined>(interval: IntervalType, options?: Options): EachWeekendOfIntervalResult<IntervalType, Options>;

package/dist-types/date-fns/eachWeekendOfMonth/index.d.ts

@@ -1,3 +1,9 @@
+import type { ContextOptions, DateArg } from '../types.ts';
+/**
+ * The {@link eachWeekendOfMonth} function options.
+ */
+export interface EachWeekendOfMonthOptions<DateType extends Date = Date> extends ContextOptions<DateType> {
+}
 /**
  * @name eachWeekendOfMonth
  * @category Month Helpers
@@ -7,8 +13,10 @@
  * Get all the Saturdays and Sundays in the given month.
  *
  * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
  *
  * @param date - The given month
+ * @param options - An object with options
  *
  * @returns An array containing all the Saturdays and Sundays
  *
@@ -26,4 +34,4 @@
  * //   Sun Feb 27 2022 00:00:00
  * // ]
  */
-export declare function eachWeekendOfMonth<DateType extends Date>(date: DateType): DateType[];
+export declare function eachWeekendOfMonth<DateType extends Date, ResultDate extends Date = DateType>(date: DateArg<DateType>, options?: EachWeekendOfMonthOptions<ResultDate>): ResultDate[];

package/dist-types/date-fns/eachWeekendOfYear/index.d.ts

@@ -1,3 +1,9 @@
+import type { ContextOptions, DateArg } from '../types.ts';
+/**
+ * The {@link eachWeekendOfYear} function options.
+ */
+export interface EachWeekendOfYearOptions<DateType extends Date = Date> extends ContextOptions<DateType> {
+}
 /**
  * @name eachWeekendOfYear
  * @category Year Helpers
@@ -7,8 +13,10 @@
  * Get all the Saturdays and Sundays in the year.
  *
  * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
  *
  * @param date - The given year
+ * @param options - An object with options
  *
  * @returns An array containing all the Saturdays and Sundays
  *
@@ -23,4 +31,4 @@
  * // ]
  * ]
  */
-export declare function eachWeekendOfYear<DateType extends Date>(date: DateType | number | string): DateType[];
+export declare function eachWeekendOfYear<DateType extends Date, ResultDate extends Date = DateType>(date: DateArg<DateType>, options?: EachWeekendOfYearOptions<ResultDate>): ResultDate[];