@sheetxl/sdk 0.7.27 → 0.7.28-beta.1

package/types/src/dataValidation/DataValidation.d.ts

@@ -0,0 +1,121 @@
+import { ReferenceableClipboard } from '@sheetxl/utils';
+import { IListener } from '../listener';
+import { ITransaction } from '../transaction';
+import { IGrid } from '../collections';
+import { ICellRange } from '../cellRange';
+import { AnchoredConditional } from '../condition/AnchoredConditional';
+import { IDataValidation } from './IDataValidation';
+/**
+ * Implementation of {@link IDataValidation}.
+ */
+export declare class DataValidation extends AnchoredConditional<State, CommitView, IDataValidation.Events> implements IDataValidation {
+    /**
+     * Cache of failing cells for quick reads in {@link getAlertAt} — a plain field, NOT transactional
+     * state, mirroring ConditionalFormat's `_matches`.
+     *
+     * @remarks
+     * Results are DERIVED from values + condition, so they need no undo snapshot: undo/restore
+     * re-fires the non-transactional range listeners and the cache re-derives. Holding them in state
+     * meant every re-evaluation (each calc delivery, for every validation it reached) pushed a
+     * commit onto the undo stack for a change no user made.
+     */
+    protected _results: IGrid<boolean> | null;
+    /**
+     * Which evaluation round is current. Bumped once per {@link _processValueUpdates}; a round
+     * writes its results only if it is still the newest when it finishes. Same shape and reason as
+     * ConditionalFormat's `_prepareGeneration`.
+     */
+    protected _evalGeneration: number;
+    /** @internal */
+    protected _getType(): string;
+    /** @internal */
+    protected _getActionDescription(action: 'delete' | 'initialize' | 'updateListener'): string | null;
+    /** @internal */
+    protected _getDefaultState(options: DataValidation.ConstructorOptions): Readonly<State>;
+    /** @internal */
+    protected _processValueUpdates(_range?: ICellRange | null): void;
+    /** {@inheritDoc IDataValidation.getAlertAt} */
+    getAlertAt(rowIndex: number, columnIndex: number): boolean;
+    /** {@inheritDoc IDataValidation.getAlertEntries} */
+    getAlertEntries(options?: ICellRange.IteratorOptions): IGrid.EntryIterator<boolean>;
+    /** {@inheritDoc IDataValidation.getAlertCount} */
+    getAlertCount(): number;
+    /** {@inheritDoc IDataValidation.setHideDropdown} */
+    setHideDropdown(hide: boolean, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IDataValidation.isHideDropdown} */
+    isHideDropdown(): boolean;
+    /** {@inheritDoc IDataValidation.setPromptMessage} */
+    setPromptMessage(message: string, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IDataValidation.getPromptMessage} */
+    getPromptMessage(): string;
+    /** {@inheritDoc IDataValidation.setPromptTitle} */
+    setPromptTitle(title: string, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IDataValidation.getPromptTitle} */
+    getPromptTitle(): string;
+    /** {@inheritDoc IDataValidation.setShowPromptMessage} */
+    setShowPromptMessage(show: boolean, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IDataValidation.isShowPromptMessage} */
+    isShowPromptMessage(): boolean;
+    /** {@inheritDoc IDataValidation.setAlertMessage} */
+    setAlertMessage(message: string, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IDataValidation.getAlertMessage} */
+    getAlertMessage(): string;
+    /** {@inheritDoc IDataValidation.setAlertTitle} */
+    setAlertTitle(title: string, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IDataValidation.getAlertTitle} */
+    getAlertTitle(): string;
+    /** {@inheritDoc IDataValidation.setShowAlertMessage} */
+    setShowAlertMessage(show: boolean, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IDataValidation.isShowAlertMessage} */
+    isShowAlertMessage(): boolean;
+    /** {@inheritDoc IDataValidation.setAlertStyle} */
+    setAlertStyle(alertStyle: IDataValidation.AlertStyle, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IDataValidation.getAlertStyle} */
+    getAlertStyle(): IDataValidation.AlertStyle;
+    /** {@inheritDoc IDataValidation.setIncludeBlanks} */
+    setIncludeBlanks(include: boolean, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IDataValidation.isIncludeBlanks} */
+    isIncludeBlanks(): boolean;
+    /** {@inheritDoc IDataValidation.getRenderHints} */
+    getRenderHints(): readonly string[];
+    /** {@inheritDoc IDataValidation.update} */
+    update(update: Partial<IDataValidation.Properties> | IDataValidation, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IDataValidation.getSnapshot} */
+    getSnapshot(options?: ReferenceableClipboard.CopyOptions): IDataValidation.ISnapshot;
+    /** {@inheritDoc IListener.ISource.addListeners} */
+    addListeners(listeners: IDataValidation.IListeners, options?: IListener.Options): IListener.Remove;
+    /** {@inheritDoc IDataValidation.toJSON} */
+    toJSON(): IDataValidation.JSON | null;
+    /** @internal */
+    protected _fromJSON(json: IDataValidation.JSON, options?: ITransaction.OperationOptions): void;
+    /** {@inheritDoc IDataValidation.isIDataValidation} */
+    get isIDataValidation(): true;
+}
+/**
+ * Tables are designed to be instantiated as both standalone and anchored items that represent a table of data on a sheet.
+ */
+export declare namespace DataValidation {
+    interface ConstructorOptions extends AnchoredConditional.ConstructorOptions<IDataValidation.JSON> {
+    }
+}
+/** @internal */
+interface State extends AnchoredConditional.State {
+    prompt: string;
+    promptTitle: string;
+    showPromptMessage: boolean;
+    alert: string;
+    alertTitle: string;
+    showAlertMessage: boolean;
+    alertStyle: IDataValidation.AlertStyle;
+    /** Suppresses the in-cell dropdown arrow of a list validation. Rendering only. */
+    hideDropdown: boolean;
+    /** Opaque IME hint. Carried, never interpreted. */
+    imeMode: string | null;
+    /** Opaque third-party payload. Carried, never interpreted. */
+    ext: Record<string, unknown> | null;
+}
+/** @internal */
+interface CommitView extends AnchoredConditional.CommitView {
+}
+export {};
+//# sourceMappingURL=DataValidation.d.ts.map

package/types/src/dataValidation/DataValidationCollection.d.ts

@@ -0,0 +1,20 @@
+import { ICellRanges } from '../cellRange';
+import { IDataValidationCollection } from './IDataValidationCollection';
+import { IDataValidation } from './IDataValidation';
+export declare class DataValidationCollection implements IDataValidationCollection {
+    private _add;
+    private _get;
+    private _createItem;
+    constructor(add: (address: ICellRanges.Address | IDataValidation, options?: IDataValidationCollection.AddOptions) => IDataValidation, get: (address: ICellRanges.Address | null | undefined, ignoreHidden?: boolean, fullyContained?: boolean) => IDataValidation[], createItem: (template?: IDataValidation | null) => IDataValidation);
+    /** {@inheritDoc IDataValidationCollection.add} */
+    add(address: ICellRanges.Address | IDataValidation, options?: IDataValidationCollection.AddOptions): IDataValidation;
+    /** {@inheritDoc ICollection.[Symbol.iterator]} */
+    [Symbol.iterator](): IterableIterator<IDataValidation>;
+    /** {@inheritDoc IDataValidationCollection.getItems} */
+    getItems(options?: IDataValidationCollection.GetItemsOptions): IDataValidation[];
+    /** {@inheritDoc IDataValidationCollection.getCount} */
+    getCount(): number;
+    /** {@inheritDoc IDataValidationCollection.getCount} */
+    createItem(template?: IDataValidation | null): IDataValidation;
+}
+//# sourceMappingURL=DataValidationCollection.d.ts.map

package/types/src/dataValidation/IDataValidation.d.ts

@@ -0,0 +1,327 @@
+import { IRange } from '@sheetxl/primitives';
+import { ReferenceableClipboard } from '@sheetxl/utils';
+import { ITransaction } from '../transaction';
+import { IHistory } from '../history';
+import { IAnchored } from '../anchored';
+import { IListener } from '../listener';
+import { IGrid } from '../collections';
+import { ICondition } from '../condition';
+import { ICellRange, ICellRanges } from '../cellRange';
+import { IDataValidationCollection } from './IDataValidationCollection';
+/**
+ * Represents a data validation range.
+ *
+ * @remarks
+ * Used for modifying the type and rules of a data validation entry.
+ */
+export interface IDataValidation extends IAnchored, ICondition.Stateful {
+    /** @inheritdoc ICondition.Stateful.getCondition */
+    getCondition(): ICondition | null;
+    /**
+     * Set the condition.
+     */
+    setCondition(condition: ICondition.Input | null, options?: ITransaction.OperationOptions): this;
+    /**
+     * Creates a default condition for the data validation based on its range and the data.
+     */
+    createDefaultCondition(): ICondition;
+    /**
+     * Returns the validation results at the specified cell coordinates.
+     *
+     * @remarks
+     * If there are multiple validations this will return the first one to fail.
+     */
+    getAlertAt(rowIndex: number, columnIndex: number): boolean;
+    /**
+     * Returns an iterator that allows you to iterate over the individual alert entries within the range,
+     * yielding pairs of `IteratorContext` and a `Value`.
+     *
+     * @returns An iterator that yields `ICellRange.Entry<IDataValidation.Results>` tuples for each value within the range.
+     */
+    getAlertEntries(options?: ICellRange.IteratorOptions): IGrid.EntryIterator<boolean>;
+    /**
+     * Returns the count of alert entries within the range.
+     */
+    getAlertCount(): number;
+    /**
+     * Set whether to suppress the in-cell dropdown arrow for a list validation.
+     *
+     * @param hide `true` to hide the dropdown arrow.
+     *
+     * @remarks
+     * A rendering flag only — it never affects whether input is validated. Meaningful only for
+     * list validations, matching Excel's *In-cell dropdown* checkbox (inverted: the checkbox ON
+     * means `false` here).
+     */
+    setHideDropdown(hide: boolean, options?: ITransaction.OperationOptions): this;
+    /**
+     * @see {@link IDataValidation.setHideDropdown}
+     */
+    isHideDropdown(): boolean;
+    /**
+     * Message for a user prompt.
+     *
+     * @remarks
+     * This may be a tooltip or other indicator depending on the client.
+     */
+    setPromptMessage(message: string, options?: ITransaction.OperationOptions): this;
+    /**
+     * @see {@link IDataValidation.setPromptMessage}
+     */
+    getPromptMessage(): string;
+    /**
+     * Title text of the prompt.
+     *
+     * @param title The title text of the prompt.
+     */
+    setPromptTitle(title: string, options?: ITransaction.OperationOptions): this;
+    /**
+     * @see {@link IDataValidation.setPromptTitle}
+     */
+    getPromptTitle(): string;
+    /**
+     * Sets whether to show the prompt message when the cell is selected.
+     */
+    setShowPromptMessage(show: boolean, options?: ITransaction.OperationOptions): this;
+    /**
+     * @see {@link IDataValidation.setShowPromptMessage}
+     */
+    isShowPromptMessage(): boolean;
+    /**
+     * Message text of the alert.
+     */
+    setAlertMessage(message: string, options?: ITransaction.OperationOptions): this;
+    /**
+     * @see {@link IDataValidation.setAlertMessage}
+     */
+    getAlertMessage(): string;
+    /**
+     * Title text of the alert.
+     *
+     * @param title The title text of the alert.
+     */
+    setAlertTitle(title: string, options?: ITransaction.OperationOptions): this;
+    /**
+     * @see {@link IDataValidation.setAlertTitle}
+     */
+    getAlertTitle(): string;
+    /**
+     * Sets whether to show the alert message when the cell is selected.
+     */
+    setShowAlertMessage(show: boolean, options?: ITransaction.OperationOptions): this;
+    /**
+     * @see {@link IDataValidation.setShowAlertMessage}
+     */
+    isShowAlertMessage(): boolean;
+    /**
+     * Sets the style of the alert shown when validation fails.
+     *
+     * @remarks
+     * This controls whether alert values are blocked (`Stop`),
+     * allowed with a warning (`Warning`), or allowed with an informational
+     * message (`Information`).
+     */
+    setAlertStyle(alertStyle: IDataValidation.AlertStyle, options?: ITransaction.OperationOptions): this;
+    /**
+     * @see {@link IDataValidation.setAlertStyle}
+     */
+    getAlertStyle(): IDataValidation.AlertStyle;
+    /**
+     * If the cell has custom rendering.
+     *
+     * @remarks
+     * This could be a list or a checkbox or a custom editor
+     */
+    getRenderHints(): readonly string[];
+    /**
+     * Sets whether blanks are included in validation.
+     *
+     * @remarks
+     * Reads and writes through to the condition — blanks-pass-or-fail is a property of the predicate,
+     * and this is Excel's *Ignore blank* checkbox. A validation with no condition has nothing to set.
+     *
+     * @see {@link ICondition.isIncludeBlanks}
+     */
+    setIncludeBlanks(include: boolean, options?: ITransaction.OperationOptions): this;
+    /**
+     * If true, blanks are included in validation.
+     *
+     * @see {@link IDataValidation.setIncludeBlanks}
+     */
+    isIncludeBlanks(): boolean;
+    /**
+     * Updates multiple properties of the data validation.
+     */
+    update(update: Partial<IDataValidation.Properties> | IDataValidation, options?: ITransaction.OperationOptions): this;
+    /**
+     * Returns the index of this data validation within its container.
+     */
+    getIndex(): number;
+    /**
+     * Sets the index of this data validation within its container.
+     * @param index The new index to set.
+     */
+    setIndex(index: number): this;
+    /**
+     * Re-anchors this rule to `address`, REPLACING every range it currently covers.
+     *
+     * @param address The range or ranges to cover — anything `ISheet.getRanges` accepts
+     *   (`'A1:C20'`, `'A1:A5, C1:C5'`, coords). Resolved against this rule's own sheet.
+     * @param options Transaction options; `description` names the entry in undo history.
+     *
+     * @remarks
+     * A REPLACE, not an add: the ranges named become the whole anchor. An address that names
+     * nothing throws rather than leaving the rule unanchored — clearing is
+     * {@link IAnchored.delete}.
+     *
+     * Undoable, and refused on a protected sheet. A rule spans several ranges as readily as
+     * one; Excel writes them as one `sqref`, and so do we.
+     */
+    setRanges(address: ICellRanges.Address, options?: ITransaction.OperationOptions): this;
+    /**
+     * Returns a snapshot of the data validation that can be used for copying and archiving.
+     */
+    getSnapshot(options?: ReferenceableClipboard.CopyOptions): IDataValidation.ISnapshot;
+    /**
+     * Add Listeners.
+     *
+     * @see
+     * {@link IListener.ISource.addListeners}
+     */
+    addListeners(listeners: IDataValidation.IListeners, options?: IListener.Options): IListener.Remove;
+    /**
+     * @returns The current state as a JSON object, or `null` if there is no state.
+     */
+    toJSON(): IDataValidation.JSON | null;
+    /**
+     * For runtime type checking.
+     */
+    readonly isIDataValidation: true;
+}
+/**
+ * Capabilities for working with conditional styling ranges.
+ *
+ * @see
+ * ### **Interface**
+ *
+ * {@link IDataValidation}
+ *
+ * **Additional Interfaces**
+ * * {@link IDataValidationCollection}
+ */
+export declare namespace IDataValidation {
+    /**
+     * The style of data validation error.
+     */
+    const AlertStyle: {
+        /**
+         * Stops the user from entering alert data.
+         */
+        readonly Stop: "stop";
+        /**
+         * Shows a warning message when the user enters alert data.
+         */
+        readonly Warning: "warning";
+        /**
+         * Shows an information message when the user enters alert data.
+         */
+        readonly Information: "information";
+    };
+    type AlertStyle = typeof AlertStyle[keyof typeof AlertStyle];
+    /**
+     * A set of values that can be set on a IDataValidation.
+     *
+     * @see
+     * {@link IDataValidation}
+     */
+    interface Properties {
+        prompt?: string;
+        promptTitle?: string;
+        showPromptMessage?: boolean;
+        alert?: string;
+        alertTitle?: string;
+        showAlertMessage?: boolean;
+        alertStyle?: IDataValidation.AlertStyle;
+        /**
+         * The predicate a value must satisfy to be valid.
+         *
+         * @remarks
+         * Whether blanks pass is part of the predicate and lives here as
+         * {@link ICondition.Properties.includeBlanks} — {@link IDataValidation.isIncludeBlanks} reads
+         * through to it.
+         */
+        condition?: ICondition.Properties;
+        /**
+         * Suppresses the in-cell dropdown arrow of a list validation. Rendering only; validation is
+         * unaffected.
+         *
+         * @defaultValue false
+         */
+        hideDropdown?: boolean;
+        /**
+         * Input Method Editor mode for East Asian text entry.
+         *
+         * @remarks
+         * An **opaque passthrough**. The model carries the value so it survives a round trip and never
+         * interprets it; nothing in SheetXL reads it.
+         */
+        imeMode?: string;
+    }
+    /**
+     * JSON representation of the IDataValidation.
+     */
+    interface JSON extends IDataValidation.Properties {
+        /**
+         * Payload from a rule this build does not understand.
+         *
+         * @remarks
+         * Namespaced by producer. Survives the sxl round-trip; **dropped with a warning on xlsx
+         * write** until a carrier is chosen. Reserved so that adding one later does not change the
+         * persisted shape.
+         */
+        ext?: Record<string, unknown>;
+    }
+    /**
+     * Provides destination details for the Snapshot when using {@link IHistory.ISnapshot.copyTo}.
+     */
+    interface SnapshotDestination {
+        validations: IDataValidationCollection;
+        /** The first pasted area. `ranges` carries the rest when the paste tiles. */
+        range: IRange.Coords;
+        /** Every pasted image of the validation's marked areas — tiled, transposed, clipped. */
+        ranges?: IRange.Coords[];
+        /**
+         * Extend the live source validation instead of cloning — the same-sheet paste. Falls
+         * back to a clone when the source is gone or its definition changed since the mark.
+         */
+        extend?: boolean;
+        /** Insert position for a cloned validation. Pastes land at top priority. */
+        index?: number;
+    }
+    interface ISnapshot extends IHistory.ISnapshot<IDataValidation.SnapshotDestination, IDataValidation, IRange.Coords> {
+    }
+    /**
+     * IListener for {@link IDataValidation} events.
+     */
+    interface Events extends IAnchored.Events {
+        /**
+         * Called when any property changes.
+         */
+        onAnyChange?(source: IDataValidation): void;
+        /**
+         * Called when the condition changes.
+         */
+        onConditionChange?(source: IDataValidation): void;
+        /**
+         * Called when the configuration changes.
+         */
+        onConfigChange?(source: IDataValidation): void;
+        /**
+         * Called when the alerts entries change.
+         */
+        onAlertsChange?(source: IDataValidation): void;
+    }
+    interface IListeners extends IListener.Callbacks<IDataValidation, IDataValidation.Events> {
+    }
+}
+//# sourceMappingURL=IDataValidation.d.ts.map

package/types/src/dataValidation/IDataValidationCollection.d.ts

@@ -0,0 +1,63 @@
+import { ITransaction } from '../transaction';
+import { ICollection } from '../type';
+import { ICellRange, ICellRanges } from '../cellRange';
+import { IDataValidation } from './IDataValidation';
+/**
+ * Holds a collection of {@link IDataValidation}s.
+ */
+export interface IDataValidationCollection extends ICollection<IDataValidation> {
+    /**
+     * Returns items that match the filter criteria.
+     *
+     * If no filter criteria is provided, all items will be returned.
+     *
+     * @param options {@link IDataValidationCollection.GetItemsOptions}
+     */
+    getItems(options?: IDataValidationCollection.GetItemsOptions): IDataValidation[];
+    /**
+     * Add an `IDataValidation` to the container.
+     *
+     * @param address The address of the item. May name several discontiguous ranges.
+     * @param options Additional options available when adding a table or a `boolean` that indicates if the table has headers.
+     */
+    add(address: ICellRanges.Address | IDataValidation, options?: IDataValidationCollection.AddOptions): IDataValidation;
+    /**
+     * Create a temporary item that can be interacted with but is not added to the collection.
+     *
+     * @param template A template to use for the temporary item.
+     */
+    createItem(template?: IDataValidation): IDataValidation;
+}
+/**
+ * {@inheritDoc IDataValidationCollection}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IDataValidationCollection}
+ */
+export declare namespace IDataValidationCollection {
+    /**
+     * Options for adding a data validation to the collection.
+     */
+    interface AddOptions extends IDataValidation.Properties, ITransaction.OperationOptions {
+    }
+    interface GetItemsOptions {
+        /**
+         * If provided, the filter will be limited to items that intersect the range.
+        */
+        address?: ICellRange.Address;
+        /**
+         * Indicate if items that are in hidden headers or marked as hidden should be returned.
+         *
+         * @defaultValue false
+         */
+        ignoreHidden?: boolean;
+        /**
+         * Only return items that are completely contained with the search bounds.
+         *
+         * @defaultValue false
+         */
+        fullyContained?: boolean;
+    }
+}
+//# sourceMappingURL=IDataValidationCollection.d.ts.map

package/types/src/dataValidation/_DataValidationMessages.d.ts

@@ -0,0 +1,2 @@
+export declare const ERROR_INVALID_CRITERIA = "The criteria provided is invalid or not supported.";
+//# sourceMappingURL=_DataValidationMessages.d.ts.map

package/types/src/dataValidation/_Utils.d.ts

@@ -0,0 +1,10 @@
+declare class ValidationMask {
+    private readonly bytes;
+    readonly length: number;
+    constructor(length: number);
+    setInvalid(index: number): void;
+    clearInvalid(index: number): void;
+    isInvalid(index: number): boolean;
+    clearAll(): void;
+}
+//# sourceMappingURL=_Utils.d.ts.map

package/types/src/dataValidation/index.d.ts

@@ -0,0 +1,3 @@
+export * from './IDataValidation';
+export * from './IDataValidationCollection';
+//# sourceMappingURL=index.d.ts.map

package/types/src/date/DateUtils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns Date.now() rounded to a nearest time.
+ *
+ * @param precision The precision of time. Set to 1 if exact.
+ * @defaultValue The nearest minute.
+ */
+export declare function nowWithPrecision(precision?: number): Date;
+//# sourceMappingURL=DateUtils.d.ts.map

package/types/src/date/_DateUtils.d.ts

@@ -0,0 +1,122 @@
+import { NumberFormatRef } from '../numFmt/BuiltInFormats';
+import { IRuntime } from '@sheetxl/primitives';
+export declare const MAX_SERIAL_DATE = 2958465;
+export declare function isValidDate(d: any, jsDateOnly?: boolean): boolean;
+export declare function minutesSinceMidnight(date: Date): number;
+export declare function dayDiff(d1: Date, d2: Date): number;
+export declare function monthDiff(startDate: Date, endDate: Date): number;
+export declare function yearDiff(d1: Date, d2: Date): number;
+export declare function dateUnitDiff(d1: Date, d2: Date, unit: DateUnit | string): number | undefined;
+export declare const DateUnit: {
+    readonly Day: "d";
+    readonly Month: "m";
+    readonly Year: "y";
+};
+export type DateUnit = typeof DateUnit[keyof typeof DateUnit];
+export declare function addDateUnit(date: Date, count: number, unit: DateUnit | string): Date | null;
+export declare function stringToLocalDate(value: string): Date | null;
+export declare function isISODateString(value: string): boolean;
+export declare function toUTCDate(utc: Date): Date;
+export declare function toLocalDate(utc: Date): Date;
+export declare function toISODateString(date: Date): string;
+export declare function toMidnight(date: Date | number): Date;
+export declare function today(): Date;
+export declare function largestDateUnit(datesOrig: readonly Date[], sorted?: boolean, _date1904?: boolean): DateUnit;
+export interface ParsedDateTime {
+    /** year */
+    year: number;
+    /** month. 1 based. 1 = Jan, 12 = Dec  */
+    month: number;
+    /** day of month. 1 based */
+    day: number;
+    /** hour. a 24 hour clock */
+    hour: number;
+    /** minute. a 0 based */
+    minute: number;
+    /** second. 0 based */
+    second: number;
+    /** millis-second. 0 based */
+    millis: number;
+    /** day of week. 1 based from Monday. 1 = Mon, 2 = Tue, ..., 7 = Sun */
+    dow: number;
+    /** date component without the time */
+    /** data and time component */
+    serial: number;
+}
+/**
+ * Splits a serial date into its calendar and clock fields.
+ *
+ * @param reuseParts Avoids allocating a fresh `ParsedDateTime`:
+ * - An object: the fields are written into THIS object, which is returned. The caller owns the
+ *   buffer's lifetime — do not hold onto a previous result across a reused call, each call
+ *   overwrites it in place. For an operator that calls this once per cell over a large range.
+ * - `true`: the fields are written into a shared module-level scratch object and returned —
+ *   for a one-off caller (a single-value formula function like `YEAR`/`MONTH`/`DAY`) that just
+ *   wants to avoid the allocation without owning a buffer itself. The result must be consumed
+ *   immediately (read a field, done) — a second `true` call anywhere overwrites it.
+ */
+export declare function parseSerialDate(serialDate: number, date1904?: boolean, reuseParts?: ParsedDateTime | boolean): ParsedDateTime | null;
+/**
+ * Serial date from parsed date/time fields.
+ *
+ * Computed directly from the fields (see {@link serialFromFields}) rather than
+ * by building a JS `Date` and converting it — that round trip was both lossy
+ * (~1e-12, catastrophic for bare times) and unable to express Excel's phantom
+ * `1900-02-29`, which a `Date` normalizes away.
+ */
+export declare function serialDateFromParsed(parsed: ParsedDateTime, date1904?: boolean): number | null;
+export declare function fromSerialDate(serialDate: number, date1904?: boolean): Date | null;
+/**
+ * Encode date to oa date (ole automation, used by Excel)
+ * @param {Date} date
+ * @param {boolean} [date1904] Whether to use the 1904 Date System. See https://bettersolutions.com/excel/dates-times/1904-date-system.htm
+ *
+ * http://markitondemand.github.io/moment-msdate/
+ *
+ * https://docs.microsoft.com/en-US/office/troubleshoot/excel/wrongly-assumes-1900-is-leap-year
+ * https://docs.microsoft.com/en-us/dotnet/api/system.datetime.tooadate?redirectedfrom=MSDN&view=net-5.0#System_DateTime_ToSerialDate
+ * https://bettersolutions.com/excel/dates-times/1904-date-system.htm
+ */
+export declare function toSerialDate(date: Date, date1904?: boolean): number | null;
+export interface DateNumberInput {
+    numberFormat: string;
+    asSerialDate: number;
+    asJSDate: Date;
+}
+export interface ParsedDateTimeInput {
+    numberFormat: string;
+    parsed: Partial<ParsedDateTime>;
+    leadingText: string;
+    /**
+     * Text after the time that is not part of it (`10:00 AM 2024-01-01` ->
+     * `2024-01-01`). Only ever non-empty when the caller opted in via
+     * `allowTrailingText`; without the opt-in such input fails to parse.
+     */
+    trailingText: string;
+}
+export declare function parseAsTimeInput(runtime: IRuntime, strValue: string, allowLeadingText?: boolean, allowTrailingText?: boolean): ParsedDateTimeInput | null;
+/**
+ * Adjusts a date parsed by date-fns to ensure consistent UTC interpretation
+ * while preserving the time component
+ */
+export declare function adjustDateForTimezone(parsedDate: Date): Date;
+/**
+ * Returns a DateNumberInput or null.
+ *
+ * @param strValue
+ * @returns DateNumberInput is parsable as a date or null if not
+ */
+export declare const parseAsDateInput: (runtime: IRuntime, strValue: string, currentTime?: number | null, 
+/** Internal: set on the one retry with digit<->letter boundaries spaced out, to stop recursion. */
+isBoundarySplit?: boolean, 
+/**
+ * Also accept the shapes Excel refuses that a clipboard paste produces — currently
+ * the weekday-prefixed long date (`Sunday, July 20, 1969`). Cell input passes
+ * `true`; the formula path leaves it `false` so `DATEVALUE` answers exactly what
+ * Excel answers. See {@link _buildDateInputFormats}.
+ */
+allowPasteShapes?: boolean) => DateNumberInput | null;
+export declare function isDateFormatter(fmt: NumberFormatRef): boolean;
+export declare function isTimeFormatter(fmt: NumberFormatRef): boolean;
+export declare function parseAsDateAndTimeInput(runtime: IRuntime, dateText: string, requireDate?: boolean): number | null;
+//# sourceMappingURL=_DateUtils.d.ts.map