@dereekb/date 9.24.47 → 9.25.0

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

@@ -0,0 +1,357 @@
+import { IndexRef, Maybe, TimezoneString, Minutes, FractionalHour, TimezoneStringRef, ISO8601DayString } from '@dereekb/util';
+import { DateRange, DateRangeDayDistanceInput } from './date.range';
+import { DateDurationSpan } from './date.duration';
+import { DateTimezoneUtcNormalFunctionInput, DateTimezoneUtcNormalInstance } from './date.timezone';
+/**
+ * Index from 0 of which day this block represents.
+ */
+export declare type DateCellIndex = number;
+/**
+ * Returns true if the index is a non-negative integer.
+ *
+ * @param input
+ */
+export declare function isValidDateCellIndex(input: DateCellIndex): boolean;
+/**
+ * Input type that is either a Date or a DateCellIndex.
+ */
+export declare type DateOrDateCellIndex = Date | DateCellIndex;
+/**
+ * A duration-span block.
+ */
+export interface DateCell extends IndexRef {
+    i: DateCellIndex;
+}
+export declare class DateCell {
+    i: DateCellIndex;
+    constructor(template?: DateCell);
+}
+/**
+ * Converts the input number or DateCell to a DateCell.
+ *
+ * @param dateCellOrIndex
+ * @returns
+ */
+export declare function dateCell(dateCellOrIndex: DateCellIndex | DateCell): DateCell;
+/**
+ * An array of DateCell-like values.
+ */
+export declare type DateCellArray<B extends DateCell = DateCell> = B[];
+/**
+ * Reference to a DateCellArray
+ */
+export declare type DateCellArrayRef<B extends DateCell = DateCell> = {
+    blocks: DateCellArray<B>;
+};
+/**
+ * The DateCellTimingStartsAt and startsAt times and timezone.
+ *
+ * Used to derive the indexes for the days.
+ */
+export declare type DateCellTimingStartsAt = Pick<DateCellTiming, 'startsAt' | 'timezone'>;
+/**
+ * Input for dateCellTimingStartsAtForStartOfDay()
+ */
+export interface DateCellTimingStartsAtForStartOfDayInput {
+    /**
+     * "Now" date in the system timezone normal.
+     */
+    readonly now?: Date | ISO8601DayString;
+    /**
+     * Timezone string
+     */
+    readonly timezone?: TimezoneString;
+}
+/**
+ * Creates a new DateCellTimingStartsAt for the given time and timezone.
+ *
+ * @param now
+ * @returns
+ */
+export declare function dateCellTimingStartsAtForStartOfDay(input?: DateCellTimingStartsAtForStartOfDayInput): DateCellTimingStartsAt;
+/**
+ * The DateCellTimingEnd and endsAt times and timezone.
+ */
+export declare type DateCellTimingEnd = Pick<DateCellTiming, 'end'>;
+/**
+ * Is combination of DateRange and DateDurationSpan. The DateRange captures a range of days that a DateCell takes up, and the DateDurationSpan
+ * captures the Dates at which the Job occurs at.
+ *
+ * NOTES:
+ * - The startsAt time is the time of the first event.
+ * - The end time is the ending date/time of the final end duration.
+ * - The timezone is required to properly handle daylight savings and timezone differences.
+ */
+export interface DateCellTiming extends DateDurationSpan, TimezoneStringRef, Pick<DateRange, 'end'> {
+}
+/**
+ * Corresponds to the range of dates in a DateCellTiming.
+ *
+ * NOTES:
+ * - The start time is midnight in the given timezone of the first day of the range.
+ * - The end time is the ending date/time of the final end duration.
+ * - The timezone is required to properly handle daylight savings and timezone differences.
+ */
+export interface DateCellTimingDateRange extends DateRange, TimezoneStringRef {
+}
+/**
+ * A DateCellTimingDateRange, but the start time is the startsAt time for the first event.
+ */
+export declare type DateCellTimingEventRange = DateCellTimingDateRange;
+export declare class DateCellTiming extends DateDurationSpan {
+    end: Date;
+    timezone: TimezoneString;
+    constructor(template?: DateCellTiming);
+}
+/**
+ * Reference to a DateCellTiming
+ */
+export interface DateCellTimingRef {
+    timing: DateCellTiming;
+}
+/**
+ * An object that implements DateCellTimingRef and DateCellArrayRef
+ */
+export interface DateCellCollection<B extends DateCell = DateCell> extends DateCellTimingRef, DateCellArrayRef<B> {
+}
+/**
+ * An expanded DateCell that implements DateDurationSpan and contains the DateCell values.
+ */
+export declare type DateCellDurationSpan<B extends DateCell = DateCell> = DateDurationSpan & B;
+/**
+ * The DateRange input for dateCellTiming()
+ */
+export declare type DateCellTimingRangeInput = Pick<DateRangeDayDistanceInput, 'distance'> | DateRange | number;
+/**
+ * Can use any timezone instance that has a timezone configured, or is using the
+ */
+export declare type DateCellTimingTimezoneInput = Omit<DateTimezoneUtcNormalFunctionInput, 'number'>;
+/**
+ * Creates a DateTimezoneUtcNormalInstance from the input. Asserts and gurantees that a timezone string is provided.
+ *
+ * If null/undefined is passed, returns a normal for the system time.
+ *
+ * @param timezoneInput
+ * @returns
+ */
+export declare function dateCellTimingTimezoneNormalInstance(timezoneInput?: DateCellTimingTimezoneInput): DateTimezoneUtcNormalInstance;
+/**
+ * A DateCellTiming that also implements DateCellTimingDateRange.
+ */
+export interface FullDateCellTiming extends DateCellTiming, DateCellTimingDateRange {
+}
+/**
+ * The start date within a FullDateCellTiming.
+ */
+export declare type FullDateCellTimingStart = Pick<FullDateCellTiming, 'start'>;
+/**
+ * Creates a FullDateCellTiming from the input timing.
+ *
+ * @param timing
+ * @returns
+ */
+export declare function fullDateCellTiming(timing: DateCellTiming): FullDateCellTiming;
+export interface FullDateCellTimingTimezonePair {
+    readonly fullTiming: FullDateCellTiming;
+    readonly normalInstance: DateTimezoneUtcNormalInstance;
+}
+/**
+ * Creates a FullDateCellTimingTimezonePair from the input timing.
+ *
+ * @param timing
+ * @returns
+ */
+export declare function fullDateCellTimingTimezonePair(timing: DateCellTiming): FullDateCellTimingTimezonePair;
+/**
+ * Returns true if the start date has no minutes/seconds/milliseconds. It should be midnight for it's target timezone.
+ *
+ * @param date
+ * @returns
+ */
+export declare function isValidDateCellTimingStartDate(date: Date): boolean;
+/**
+ * Creates a valid DateCell timing from the DateDurationSpan and range input.
+ *
+ * The duration is first considered, then the date range is applied to it.
+ *
+ * If a number is passed as the input range, then the duration's startsAt date will be used and the input number used as the distance.
+ * The input range's date takes priority over the duration's startsAt start date, meaning the input date range will be adapted
+ * to fit the startsAt time.
+ *
+ * The input range date is used as the start and end date ranges, meaning they will be used as the expected date offset (have only hours, no minutes/seconds/milliseconds) and be validated as such.
+ * The end date is used just to determine the number of days, but a minimum of 1 day is always enforced as a DateCellTiming must contain atleast 1 day.
+ *
+ * The start date from the inputDate is considered to to have the offset noted in DateCell, and will be retained.
+ */
+export declare function dateCellTiming(durationInput: DateDurationSpan, inputRange: DateCellTimingRangeInput, timezoneInput?: DateCellTimingTimezoneInput): FullDateCellTiming;
+export interface DateCellTimingStartPair {
+    readonly start: Date;
+    readonly normalInstance: DateTimezoneUtcNormalInstance;
+}
+/**
+ * Convenience function of dateCellTimingStart() that also returns the DateTimezoneUtcNormalInstance.
+ *
+ * @param timing
+ * @returns
+ */
+export declare function dateCellTimingStartPair(timing: DateCellTimingStartsAt): DateCellTimingStartPair;
+/**
+ * Start date value for a DateCellTiming.
+ *
+ * This is the midnight date instance for the timezone.
+ */
+export declare function dateCellTimingStart(timing: DateCellTimingStartsAt): Date;
+/**
+ * The DateRange component and timezone for a DateCellTiming. The start date is a DateCellTimingStartsAt.
+ */
+export declare type DateCellTimingStartsAtEndRange = Pick<DateCellTiming, 'startsAt' | 'end' | 'timezone'>;
+/**
+ * The startsAt time of the event.
+ */
+export declare type DateCellTimingEventStartsAt = Pick<DateCellTiming, 'startsAt'>;
+/**
+ * A startsAt time and duration that represents a single event.
+ */
+export declare type DateCellTimingEvent = Pick<DateCellTiming, 'startsAt' | 'duration'>;
+/**
+ * Returns true if the two DateCellTimingStartsAtEndRange values are the same.
+ *
+ * @param a
+ * @param b
+ */
+export declare function isSameDateCellTimingEventStartsAtEndRange(a: Maybe<DateCellTimingStartsAtEndRange>, b: Maybe<DateCellTimingStartsAtEndRange>): boolean;
+/**
+ * Returns true if the two timings are equivalent.
+ *
+ * @param a
+ * @param b
+ */
+export declare function isSameDateCellTiming(a: Maybe<DateCellTiming>, b: Maybe<DateCellTiming>): boolean;
+/**
+ * Returns true if all variables in the input FullDateCellTimings are exact.
+ *
+ * In most cases this comparison is unnecessary, as the start date is derived from the startsAt time.
+ *
+ * @param a
+ * @param b
+ * @returns
+ */
+export declare function isSameFullDateCellTiming(a: Maybe<FullDateCellTiming>, b: Maybe<FullDateCellTiming>): boolean;
+/**
+ * Returns true if the input is a DateCellTiming.
+ *
+ * Does not check if it is a valid DateCellTiming.
+ *
+ * @param input
+ */
+export declare function isDateCellTiming(input: unknown): input is DateCellTiming;
+/**
+ * Returns true if the input is possibly a FullDateCellTiming.
+ *
+ * Does not check if it is a valid FullDateCellTiming.
+ *
+ * @param input
+ */
+export declare function isFullDateCellTiming(input: unknown): input is FullDateCellTiming;
+/**
+ * Creates a DateCellTimingDateRange from the input timing.
+ *
+ * @param timing
+ * @returns
+ */
+export declare function dateCellTimingDateRange(timing: DateCellTimingStartsAtEndRange): DateCellTimingDateRange;
+/**
+ * Returns the date range from the start of the first event to the end time of the last event.
+ *
+ * @param timing
+ * @returns
+ */
+export declare function dateCellTimingEventRange(timing: Pick<DateCellTiming, 'startsAt' | 'end' | 'timezone'>): DateCellTimingEventRange;
+/**
+ * Returns the total minutes between the start of the first event and the end of the last event.
+ *
+ * @param timing
+ * @returns
+ */
+export declare function getDateCellTimingFirstEventDateRange(timing: DateCellTimingStartsAtEndRange): DateRange;
+/**
+ * Returns the number of hours in a DateCellTiming's duration.
+ *
+ * @param timing
+ */
+export declare function getDateCellTimingHoursInEvent(timing: Pick<DateCellTiming, 'duration'>): FractionalHour;
+/**
+ * Returns a copy of the input timing adjusted for the input timezone and all FullDateCellTiming values updated to reflect the changes.
+ *
+ * @param timing
+ */
+export declare type ChangeDateCellTimingToTimezoneFunction = (<T extends DateCellTimingStartsAtEndRange>(timing: T) => T & FullDateCellTiming) & {
+    readonly _normalInstance: DateTimezoneUtcNormalInstance;
+};
+/**
+ * Creates a ChangeDateCellTimingToTimezoneFunction from the input.
+ *
+ * @param input
+ * @returns
+ */
+export declare function changeDateCellTimingToTimezoneFunction(timezoneInput: DateCellTimingTimezoneInput): ChangeDateCellTimingToTimezoneFunction;
+/**
+ * Convenience function for calling changeDateCellTimingToTimezone() with the system timezone.
+ *
+ * @param timing
+ * @returns
+ */
+export declare function changeDateCellTimingToSystemTimezone<T extends DateCellTimingStartsAtEndRange>(timing: T): T;
+/**
+ * Convenience function for calling changeDateCellTimingToTimezoneFunction() and passing the timing.
+ *
+ * @param timing
+ * @param timezone
+ * @returns
+ */
+export declare function changeDateCellTimingToTimezone<T extends DateCellTimingStartsAtEndRange>(timing: T, timezone: DateCellTimingTimezoneInput): T;
+export interface CalculateExpectedDateCellTimingDurationPair {
+    readonly duration: Minutes;
+    readonly expectedFinalStartsAt: Date;
+}
+/**
+ * Returns the expected duration from the input.
+ *
+ * @param timing
+ * @returns
+ */
+export declare function calculateExpectedDateCellTimingDurationPair(timing: DateCellTimingStartsAtEndRange): CalculateExpectedDateCellTimingDurationPair;
+export declare function calculateExpectedDateCellTimingDuration(timing: DateCellTimingStartsAtEndRange): Minutes;
+/**
+ * Returns the final StartsAt time.
+ *
+ * @param timing
+ * @returns
+ */
+export declare function dateCellTimingFinalStartsAtEvent(timing: DateCellTimingStartsAtEndRange): DateCellTimingEvent;
+export interface IsValidDateCellTimingInfo {
+    readonly isValid: boolean;
+    readonly startsAtHasZeroSeconds: boolean;
+    readonly endIsAfterTheStartsAtTime: boolean;
+    readonly durationGreaterThanZero: boolean;
+    readonly durationLessThan24Hours: boolean;
+    readonly isExpectedValidEnd: boolean;
+    readonly normalInstance: DateTimezoneUtcNormalInstance;
+}
+export declare function isValidDateCellTimingInfo(timing: DateCellTiming): IsValidDateCellTimingInfo;
+/**
+ * Convenience function for checking whether or not DateCellTiming is valid.
+ *
+ * @param timing
+ * @returns
+ */
+export declare function isValidDateCellTiming(timing: DateCellTiming): boolean;
+export interface IsValidFullDateCellTimingInfo extends IsValidDateCellTimingInfo {
+    readonly isStartRoundedToSeconds: boolean;
+    readonly startIsAtMidnight: boolean;
+    readonly startHasZeroSeconds: boolean;
+    readonly startsAtIsAfterStart: boolean;
+    readonly startsAtIsLessThan24HoursAfterStart: boolean;
+}
+export declare function isValidFullDateCellTimingInfo(timing: FullDateCellTiming): IsValidFullDateCellTimingInfo;
+export declare function isValidFullDateCellTiming(timing: FullDateCellTiming): boolean;

package/src/lib/date/date.cell.factory.d.ts

@@ -0,0 +1,337 @@
+import { Maybe, ArrayOrValue, FilterFunction, IndexRange, ISO8601DayString } from '@dereekb/util';
+import { DateCell, DateCellIndex, DateOrDateCellIndex, DateCellTiming, DateCellArrayRef, DateCellArray, DateCellTimingRangeInput, DateCellCollection, DateCellDurationSpan, DateCellTimingStartsAt, DateCellTimingEvent, DateCellTimingStartsAtEndRange, FullDateCellTiming } from './date.cell';
+import { DateCellRange, DateCellRangeWithRange, DateOrDateRangeOrDateCellIndexOrDateCellRange } from './date.cell.index';
+import { DateRange, DateRangeStart } from './date.range';
+import { DateTimezoneConversionConfigUseSystemTimezone, DateTimezoneUtcNormalInstance } from './date.timezone';
+/**
+ * IndexRange used with DateCells.
+ *
+ * It has an exclusive max range. It is similar to a DateCellRange.
+ */
+export declare type DateCellIndexRange = IndexRange;
+export declare function dateCellRangeToDateCellIndexRange(range: DateCellRange): DateCellIndexRange;
+export declare function dateCellIndexRangeToDateCellRange(range: DateCellIndexRange): DateCellRangeWithRange;
+/**
+ * Generates a DateCellIndexRange based on the input timing.
+ *
+ * An arbitrary limit can also be applied.
+ *
+ * @param timing
+ * @param limit
+ * @param fitToTimingRange
+ */
+export declare function dateCellIndexRange(timing: DateCellTiming, limit?: DateCellTimingRangeInput, fitToTimingRange?: boolean): DateCellIndexRange;
+/**
+ * Convenience function for calling expandDateCells() with the input DateCellCollection.
+ *
+ * @param collection
+ * @returns
+ */
+export declare function expandDateCellCollection<B extends DateCell = DateCell>(collection: DateCellCollection<B>): DateCellDurationSpan<B>[];
+/**
+ * Convenience function for calling dateCellTimingExpansionFactory() then passing the blocks.
+ *
+ * @param blocks
+ * @param timing
+ * @returns
+ */
+export declare function expandDateCellTiming<B extends DateCell = DateCell>(timing: DateCellTiming, blocks: B[]): DateCellDurationSpan<B>[];
+export declare type DateCellTimingExpansionFactoryInput<B extends DateCell | DateCellRange = DateCell> = DateCellArrayRef<B> | DateCellArray<B>;
+/**
+ * Used to convert the input DateCellTimingExpansionFactoryInput into an array of DateCellDurationSpan values
+ */
+export declare type DateCellTimingExpansionFactory<B extends DateCell | DateCellRange = DateCell> = (input: DateCellTimingExpansionFactoryInput<B>) => DateCellDurationSpan<B>[];
+export interface DateCellTimingExpansionFactoryConfig<B extends DateCell | DateCellRange = DateCell> {
+    /**
+     * Timing to use in the configuration.
+     */
+    timing: DateCellTiming;
+    /**
+     * Range to limit duration span output to.
+     *
+     * If not provided, uses the input timing's range.
+     * If false, the timing's range is ignored too, and only the DateCellIndex values are considered.
+     */
+    rangeLimit?: DateCellTimingRangeInput | false;
+    /**
+     * Additional filter function to filter potential blocks in/out.
+     */
+    filter?: FilterFunction<B>;
+    /**
+     * (Optional) Additional filter function based on the calcualted DateCellDurationSpan.
+     */
+    durationSpanFilter?: FilterFunction<DateCellDurationSpan<B>>;
+    /**
+     * (Optional) Max number of blocks to evaluate.
+     */
+    blocksEvaluationLimit?: number;
+    /**
+     * (Optional) Max number of DateCellDurationSpan values to return.
+     */
+    maxDateCellsToReturn?: number;
+}
+/**
+ * Creates a DateCellTimingExpansionFactory
+ *
+ * @param config
+ * @returns
+ */
+export declare function dateCellTimingExpansionFactory<B extends DateCell | DateCellRange = DateCell>(config: DateCellTimingExpansionFactoryConfig): DateCellTimingExpansionFactory<B>;
+export declare type DateCellDayTimingInfoFactoryConfig = Pick<DateCellTimingExpansionFactoryConfig, 'timing' | 'rangeLimit'>;
+export interface DateCellDayTimingInfo {
+    /**
+     * Input date or calculated date if provided a dayIndex.
+     */
+    date: Date;
+    /**
+     * Index for the day for the input date.
+     */
+    dayIndex: DateCellIndex;
+    /**
+     * Index for the previous index/current index depending on the TimingInfo's daily execution.
+     *
+     * If the index is currently in progress given the timing, this will return the dayIndex.
+     */
+    currentIndex: DateCellIndex;
+    /**
+     * Index for the next execution. Does not check if it is in range.
+     *
+     * If the index is currently in progress given the timing, this will return the dayIndex + 1.
+     */
+    nextIndex: DateCellIndex;
+    /**
+     * Index for the next execution, if in the range, otherwise undefined.
+     *
+     * If the index is currently in progress given the timing, this will return the dayIndex + 1.
+     */
+    nextIndexInRange: Maybe<DateCellIndex>;
+    /**
+     * Whether or not there are any inProgress or upcoming executions.
+     *
+     * True if nextIndexInRange is undefined and isInProgress is false.
+     */
+    isComplete: boolean;
+    /**
+     * Whether or not today's timing has already occured in it's entirety.
+     */
+    hasOccuredToday: boolean;
+    /**
+     * Whether or not today's timing is currently in progress.
+     */
+    isInProgress: boolean;
+    /**
+     * Whether or not the block is within the configured range.
+     */
+    isInRange: boolean;
+    /**
+     * Time the timing starts on the input day.
+     */
+    startsAtOnDay: Date;
+    /**
+     * Time the timing ends on the input day.
+     */
+    endsAtOnDay: Date;
+    /**
+     * "now" value used for considering current progress.
+     */
+    now: Date;
+}
+/**
+ * Generates DateCellDayTimingInfo about the input date relative to the input timing and range limit.
+ *
+ * The date may not exist within the range, but will still compute values using the input date and timing configuration.
+ *
+ * Can optionally specify a now that is used for checking the inProgress functionality.
+ */
+export declare type DateCellDayTimingInfoFactory = (date: DateOrDateCellIndex, now?: Date) => DateCellDayTimingInfo;
+export declare function dateCellDayTimingInfoFactory(config: DateCellDayTimingInfoFactoryConfig): DateCellDayTimingInfoFactory;
+/**
+ * DateCellTimingRelativeIndexFactory input. Can be a Date, DateCellIndex, or ISO8601DayString
+ */
+export declare type DateCellTimingRelativeIndexFactoryInput = DateOrDateCellIndex | ISO8601DayString;
+/**
+ * Returns the DateCellIndex of the input date relative to the configured Date.
+ *
+ * Input dates should be in system time zone and not normalized to a different timezone.
+ */
+export declare type DateCellTimingRelativeIndexFactory<T extends DateCellTimingStartsAt = DateCellTimingStartsAt> = ((input: DateCellTimingRelativeIndexFactoryInput) => DateCellIndex) & {
+    readonly _timing: T;
+    readonly _normalInstance: DateTimezoneUtcNormalInstance;
+};
+/**
+ * Returns true if the input is a DateCellTimingRelativeIndexFactory.
+ *
+ * @param input
+ * @returns
+ */
+export declare function isDateCellTimingRelativeIndexFactory<T extends DateCellTimingStartsAt = DateCellTimingStartsAt>(input: unknown): input is DateCellTimingRelativeIndexFactory<T>;
+/**
+ * Creates a DateCellTimingRelativeIndexFactory from the input.
+ *
+ * @param input
+ * @returns
+ */
+export declare function dateCellTimingRelativeIndexFactory<T extends DateCellTimingStartsAt = DateCellTimingStartsAt>(input: T | DateCellTimingRelativeIndexFactory<T>): DateCellTimingRelativeIndexFactory<T>;
+/**
+ * Function that wraps a DateCellTimingRelativeIndexFactory and converts multuple Date/DateCellIndex/DateCellRange values into an array of DateCellIndex values.
+ */
+export declare type DateCellTimingRelativeIndexArrayFactory<T extends DateCellTimingStartsAt = DateCellTimingStartsAt> = ((input: ArrayOrValue<DateOrDateRangeOrDateCellIndexOrDateCellRange>) => DateCellIndex[]) & {
+    readonly _indexFactory: DateCellTimingRelativeIndexFactory<T>;
+};
+/**
+ * Creates a DateCellTimingRelativeIndexArrayFactory from the input DateCellTimingRelativeIndexFactory.
+ *
+ * @param indexFactory
+ */
+export declare function dateCellTimingRelativeIndexArrayFactory<T extends DateCellTimingStartsAt = DateCellTimingStartsAt>(indexFactory: DateCellTimingRelativeIndexFactory<T>): DateCellTimingRelativeIndexArrayFactory<T>;
+/**
+ * Gets the relative index of the input date compared to the input timing.
+ *
+ * @param timing
+ * @param date
+ */
+export declare function getRelativeIndexForDateCellTiming(timing: DateCellTimingStartsAt, date?: DateOrDateCellIndex): DateCellIndex;
+/**
+ * Similar to the DateCellTimingRelativeIndexFactory, but returns a date instead of an index for the input.
+ *
+ * Returns a date with the hours and minutes for "now" for the given date returned if an index is input.
+ */
+export declare type DateCellTimingDateFactory<T extends DateCellTimingStartsAt = DateCellTimingStartsAt> = ((input: DateOrDateCellIndex) => Date) & {
+    readonly _timing: T;
+};
+/**
+ * Creates a DateCellTimingDateFactory.
+ *
+ * @param timing
+ * @returns
+ */
+export declare function dateCellTimingDateFactory<T extends DateCellTimingStartsAt = DateCellTimingStartsAt>(timing: T): DateCellTimingDateFactory<T>;
+/**
+ * Returns the start time of the input date or index.
+ */
+export declare type DateCellTimingStartDateFactory<T extends DateCellTimingStartsAt = DateCellTimingStartsAt> = ((input: DateCellTimingRelativeIndexFactoryInput) => Date) & {
+    readonly _indexFactory: DateCellTimingRelativeIndexFactory<T>;
+};
+export declare type DateCellTimingUseSystemAndIgnoreEnforcement = DateTimezoneConversionConfigUseSystemTimezone & {
+    /**
+     * Skips the assertion that the timezone matches. This defaults to true if not provided.
+     */
+    assertTimingMatchesTimezone: false;
+};
+/**
+ * Creates a DateCellTimingDateFactory.
+ *
+ * @param timing
+ * @returns
+ */
+export declare function dateCellTimingStartDateFactory<T extends DateCellTimingStartsAt = DateCellTimingStartsAt>(input: T | DateCellTimingRelativeIndexFactory<T>): DateCellTimingStartDateFactory<T>;
+/**
+ * Returns the startsAt time of the input date or index.
+ */
+export declare type DateCellTimingStartsAtDateFactory<T extends DateCellTimingStartsAt = DateCellTimingStartsAt> = ((input: DateCellTimingRelativeIndexFactoryInput) => Date) & {
+    readonly _indexFactory: DateCellTimingRelativeIndexFactory<T>;
+};
+/**
+ * Creates a DateCellTimingStartsAtDateFactory.
+ *
+ * @param timing
+ * @returns
+ */
+export declare function dateCellTimingStartsAtDateFactory<T extends DateCellTimingStartsAt = DateCellTimingStartsAt>(input: T | DateCellTimingRelativeIndexFactory<T>): DateCellTimingStartsAtDateFactory<T>;
+/**
+ * Returns the startsAt time of the input date or index.
+ */
+export declare type DateCellTimingEndDateFactory<T extends DateCellTiming = DateCellTiming> = ((input: DateCellTimingRelativeIndexFactoryInput) => Date) & {
+    readonly _startsAtDateFactory: DateCellTimingStartsAtDateFactory<T>;
+};
+/**
+ * Creates a DateCellTimingStartsAtDateFactory.
+ *
+ * @param timing
+ * @returns
+ */
+export declare function dateCellTimingEndDateFactory<T extends DateCellTiming = DateCellTiming>(input: T | DateCellTimingRelativeIndexFactory<T>): DateCellTimingEndDateFactory<T>;
+/**
+ * Returns the date of the input index.
+ *
+ * @param timing
+ * @param date
+ */
+export declare function getRelativeDateForDateCellTiming(timing: DateCellTimingStartsAt, input: DateOrDateCellIndex): Date;
+/**
+ * Converts a DateCellTimingStartsAtEndRange to a DateCellTiming by calculating the difference in hours from the last startsAt timing and the end.
+ *
+ * @param dateCellTimingStartEndRange
+ * @param event
+ * @param timezone
+ * @returns
+ */
+export declare function dateCellTimingFromDateCellTimingStartsAtEndRange(dateCellTimingStartsAtEndRange: DateCellTimingStartsAtEndRange): DateCellTiming;
+export interface UpdateDateCellTimingWithDateCellTimingEventInput {
+    /**
+     * Target timing to update.
+     */
+    readonly timing: DateCellTimingStartsAtEndRange;
+    /**
+     * Event used to update the timing.
+     */
+    readonly event: DateCellTimingEvent;
+    /**
+     * Custom start date day to use instead of the event's start date.
+     *
+     * It is generated relative to the timing's current startsAt, and not the event's starts at, so index 0 is the first day of the Timing, not the event.
+     *
+     * Ignored if replaceStartDay is not true.
+     */
+    readonly startDayDate?: DateCellTimingRelativeIndexFactoryInput;
+    /**
+     * Replaces the start date but keeps the startsAt time as-is.
+     *
+     * Can be combined with replaceStartsAt.
+     */
+    readonly replaceStartDay?: boolean;
+    /**
+     * Replaces the startsAt time, but keeps the initial start date.
+     *
+     * Can be combined with replaceStartDay
+     */
+    readonly replaceStartsAt?: boolean;
+    /**
+     * Replaces the end day but keeps the same time.
+     */
+    readonly endOnEvent?: boolean;
+    /**
+     * Replaces the duration but keeps the end day intact.
+     */
+    readonly replaceDuration?: boolean;
+}
+/**
+ * Creates a new DateCellTiming from the input configuration.
+ *
+ * @param dateCellTimingStartEndRange
+ * @param event
+ * @param timezone
+ * @returns
+ */
+export declare function updateDateCellTimingWithDateCellTimingEvent(input: UpdateDateCellTimingWithDateCellTimingEventInput): FullDateCellTiming;
+/**
+ * Input for a IsDateWithinDateCellRangeFunction
+ */
+export declare type IsDateWithinDateCellRangeInput = DateOrDateCellIndex | DateRangeStart | DateRange | DateCell | DateCellRange;
+/**
+ * Function that returns true if the input range is equal or falls within the configured DateCellRange.
+ */
+export declare type IsDateWithinDateCellRangeFunction = (input: IsDateWithinDateCellRangeInput) => boolean;
+export interface IsDateWithinDateCellRangeConfig {
+    /**
+     * Optional DateCellTimingStartsAt to make the indexes relative to when converting date values.
+     *
+     * If not provided, defaults to the index in the range if a date is provided with the system timezone, or throws an exception if a date range is input.
+     */
+    startsAt?: DateCellTimingStartsAt;
+    /**
+     * Range to compare the input to.
+     */
+    range: IsDateWithinDateCellRangeInput;
+}
+export declare function isDateWithinDateCellRangeFunction(config: IsDateWithinDateCellRangeConfig): IsDateWithinDateCellRangeFunction;