@sheetxl/sdk 0.7.27 → 0.7.28-beta.2

package/types/src/anchored/AnchoredMap.d.ts

@@ -0,0 +1,178 @@
+import { IRange } from '@sheetxl/primitives';
+import { ISpatialMap, ISpatialQuery } from '../collections';
+import { IAnchored } from './IAnchored';
+import { IAnchoredMap } from './IAnchoredMap';
+import { Anchored } from './Anchored';
+export declare class AnchoredMap<T extends IAnchored, J, P = any> implements IAnchoredMap<T, J>, ISpatialQuery<T> {
+    /**
+     * A map of models to spatial entries.
+     *
+     * @remarks
+     * A model may hold more than one range. The array is **always kept sorted by
+     * {@link Anchored.Entry2.order}** — that is the model's authored range order, and every read
+     * path (`toJSON`, `processAfterShift`, `search`) depends on it.
+     */
+    protected _mapModelToEntries: Map<T, ISpatialMap.Entry<Anchored.Entry2<T>>[]>;
+    protected _mapNameToModel: Map<string, T>;
+    protected _mapModelToMeta: Map<T, Anchored.EntryMeta<T>>;
+    protected _indexToModel: T[];
+    protected _spatial: ISpatialMap<Anchored.Entry2<T>>;
+    protected _options: IAnchoredMap.ConstructorOptions;
+    protected _isEmpty: boolean;
+    /**
+     * Monotonic order stamp allocator. Advances by {@link _ORDER_STEP} per entry created and is
+     * **never** reset — not on delete, not on clone.
+     *
+     * @remarks
+     * Carried by *both* {@link _shallowClone} and {@link clone}. A clone that restarted the counter
+     * would hand out ids that collide with the ones already stored, and the order sort would silently
+     * scramble a model's ranges. Reuse across an abandoned undo branch is harmless: ids only have to
+     * be ordered *within* one model.
+     */
+    protected _nextOrder: number;
+    /**
+     * The `createEntry` hook from the last {@link load}, so {@link setCoords} can mint replacement
+     * entries with the same custom value shape.
+     */
+    protected _createEntry: ((model: T, coords: IRange.Coords) => Anchored.Entry2<T>) | null;
+    /**
+     * Cache key for {@link search}. Always a private copy of the caller's range — never the caller's
+     * object. Callers may hand in a pooled coords that they mutate afterwards (e.g. `_ReuseSearchTable`
+     * in `Sheet._markColumnHeaderTableNames`, rewritten on every selection change); retaining that
+     * reference would let the key silently re-point at a *different* query while
+     * {@link _cacheSearchResults} still held the previous query's results.
+     * `_cacheSearchResults === null` means nothing is cached.
+     */
+    protected _cacheSearchRange: IRange.Coords;
+    protected _cacheSearchFullyContained: boolean;
+    protected _cacheSearchResults: ISpatialMap.Entry<T>[] | null;
+    constructor(options: IAnchoredMap.ConstructorOptions);
+    protected _init(options: IAnchoredMap.ConstructorOptions): void;
+    /**
+     * Allocates the next order stamp.
+     */
+    protected _allocateOrder(): number;
+    /**
+     * Creates a spatial entry for `model` at `coords`, stamped with the next order.
+     */
+    protected _createSpatialEntry(model: T, coords: Readonly<IRange.Coords>): ISpatialMap.Entry<Anchored.Entry2<T>>;
+    /**
+     * Returns a model's spatial entries in authored (order) sequence, or an empty array.
+     *
+     * @remarks
+     * The arrays in {@link _mapModelToEntries} are maintained sorted, so this is a lookup — every
+     * writer is responsible for re-sorting what it stores.
+     */
+    protected _entriesOf(model: T): ISpatialMap.Entry<Anchored.Entry2<T>>[];
+    /** {@inheritDoc IAnchoredMap.all} */
+    all(): readonly T[];
+    /**
+     * The single write point for the model order.
+     *
+     * @param indexToModel A private working array — never one already handed out.
+     *
+     * @remarks
+     * Freezes it, so {@link all} can hand out the live array and any accidental mutation throws
+     * (modules are strict) instead of silently corrupting this map and every clone sharing it. Every
+     * mutator already builds a fresh copy before editing, so this is copy-on-*write*.
+     */
+    protected _setIndexToModel(indexToModel: (T | null)[]): void;
+    /** {@inheritDoc IAnchoredMap.search} */
+    search(range: Readonly<IRange.Coords>, fullyContained?: boolean, _sort?: boolean, results?: ISpatialMap.Entry<T>[]): ISpatialMap.Entry<T>[];
+    /**
+     * The uncached body of {@link search}: one entry per matching **range**, its `value` unwrapped
+     * from the spatial entry to the model that owns it.
+     */
+    protected _searchModels(range: Readonly<IRange.Coords>, fullyContained: boolean): ISpatialMap.Entry<T>[];
+    /** {@inheritDoc IAnchoredMap.getByName} */
+    getByName(name: string): T | null;
+    /** {@inheritDoc IAnchoredMap.setName} */
+    setName(model: T, name: string): this;
+    /** {@inheritDoc IAnchoredMap.getByIndex} */
+    getByIndex(index: number): T | null;
+    /** {@inheritDoc IAnchoredMap.setName} */
+    setIndex(model: T, index: number): this;
+    /** {@inheritDoc IAnchoredMap.getIndex} */
+    getIndex(model: T): number;
+    /** {@inheritDoc IAnchoredMap.getCoords} */
+    getCoords(model: T): IRange.Coords[] | null;
+    /** {@inheritDoc IAnchoredMap.setCoords} */
+    setCoords(model: T, coords: readonly Readonly<IRange.Coords>[]): this;
+    /** {@inheritDoc IAnchoredMap.clone} */
+    clone(): this;
+    /** {@inheritDoc IAnchoredMap.size} */
+    size(): number;
+    /** {@inheritDoc IAnchoredMap.isEmpty} */
+    isEmpty(): boolean;
+    /** {@inheritDoc IAnchoredMap.has} */
+    has(range: Readonly<IRange.Coords>): boolean;
+    /** {@inheritDoc IAnchoredMap.shift} */
+    shift(options: IAnchoredMap.ShiftOptions): this;
+    /**
+     * Applies a per-model entry delta, then notifies each affected model **exactly once**.
+     *
+     * @param deltas The new entry list per model. An empty list deletes the model.
+     * @param originalEntries The pre-operation entries, for the `before` half of the notification.
+     * @param mapModelToEntries Cloned; mutated in place.
+     * @param mapModelToMeta Cloned; mutated in place.
+     * @param mapNameToModel Cloned; mutated in place.
+     * @param indexToModel Cloned; mutated in place, then compacted.
+     *
+     * @remarks
+     * Shared by {@link shift} and {@link deleteRanges} so they cannot drift apart on the two rules
+     * that are easy to get subtly wrong:
+     * * one `processAfterShift(before[], after[])` per model per operation — **not** one per range;
+     * * `processDelete()` only when the model's **last** range goes.
+     */
+    protected _applyEntryDeltas(deltas: Map<T, ISpatialMap.Entry<Anchored.Entry2<T>>[]>, originalEntries: Map<T, ISpatialMap.Entry<Anchored.Entry2<T>>[]>, mapModelToEntries: Map<T, ISpatialMap.Entry<Anchored.Entry2<T>>[]>, mapModelToMeta: Map<T, Anchored.EntryMeta<T>>, mapNameToModel: Map<string, T>, indexToModel: (T | null)[]): void;
+    /** {@inheritDoc IAnchoredMap.deleteRanges} */
+    deleteRanges(ranges: readonly Readonly<IRange.Coords>[], fullContained?: boolean): this;
+    /**
+     * Uses the _reIndexMeta after a remove
+     *
+     * Assumes index and mapModelToMeta are both cloned
+     * Assumes indexed as null records for removes
+     * Assumes mapModelToMeta has indexes remove to match indexed
+     */
+    protected _reIndexMeta(indexed: (T | null)[], mapModelToMeta: Map<T, Anchored.EntryMeta<T>>, from?: number, pruneNulls?: boolean): void;
+    /** {@inheritDoc IAnchoredMap.deleteModel} */
+    deleteModel(model: T): this;
+    /**
+     * A ref that cannot be loaded is user data about to disappear.
+     *
+     * @remarks
+     * Routed through {@link Notifier} rather than `console.*`, and never swallowed silently. Under
+     * {@link AnchoredMap.setStrictLoad} it throws instead: a dropped item is otherwise
+     * indistinguishable from one that was never authored, which is enough to let a round-trip suite
+     * compare an empty result against an empty result and pass.
+     */
+    protected _onLoadFailure(message: string, error: unknown): void;
+    /** {@inheritDoc IAnchoredMap.load} */
+    load(refs: IRange.JSONReference<J>[], createOptions: IAnchoredMap.CreateEntryOptions<T>): this;
+    /** {@inheritDoc IAnchoredMap.getBoundingRange} */
+    getBoundingRange(): IRange.Coords;
+    /** {@inheritDoc IAnchoredMap.toJSON} */
+    toJSON(): IRange.JSONReferenceEntry<J>[] | null;
+    /** {@insertDoc IAnchoredMap.processCallbacks} */
+    processCallbacks(handler: (model: T, callbacks: Anchored.ContainerCallbacks) => void): void;
+    /** {@insertDoc IAnchoredMap.close} */
+    close(): void;
+    protected _shallowClone(): this;
+}
+export declare namespace AnchoredMap {
+    /**
+     * Makes a failed {@link AnchoredMap.load} throw instead of warn.
+     *
+     * @remarks
+     * For tests, which turn it on globally in `config/vitest.setup.ts`. In an application a single
+     * unloadable item must not cost the user the rest of the workbook, so the default is to warn and
+     * carry on — but that same leniency makes a test suite blind to data loss, since a rule that
+     * failed to load looks exactly like a rule that was never authored.
+     */
+    function setStrictLoad(strict: boolean): void;
+    /**
+     * Whether a failed {@link AnchoredMap.load} throws. See {@link setStrictLoad}.
+     */
+    function isStrictLoad(): boolean;
+}
+//# sourceMappingURL=AnchoredMap.d.ts.map

package/types/src/anchored/IAnchored.d.ts

@@ -0,0 +1,118 @@
+import { IRange } from '@sheetxl/primitives';
+import { IListener } from '../listener';
+import { ICellRange, ICellRanges } from '../cellRange';
+/**
+ * `IAnchored` objects are anchored to one or more ranges.
+ */
+export interface IAnchored {
+    /**
+     * Returns the ranges this object is anchored to, in authored order.
+     *
+     * @remarks
+     * * **Never `null`.** An item whose last range was removed by a row/column delete returns an
+     *   *invalid* ranges — ask {@link ICellRanges.isInvalid}, the same contract as
+     *   `ITable.getDataRange`.
+     * * This is the general accessor. Most anchored types hold exactly one range and declare their
+     *   own `getRange()` for it, but data validations, conditional formats and protected ranges are
+     *   authored as several, and *any* single range can become several when a delete splits it.
+     */
+    getRanges(options?: ICellRange.GetRangeOptions): ICellRanges;
+    /**
+     * The name of the anchor or `null` if it has none.
+     */
+    getName?(): string | null;
+    /**
+     * Returns how the anchorBounds adjust when inserting/removing rows/columns.
+     *
+     * @defaultValue IAnchored.Type.TwoCell
+     */
+    getAnchorType?(): IAnchored.Type;
+    /**
+     * If the anchor is unable to be modified.
+     */
+    isProtected(): boolean;
+    /**
+     * Add Listeners.
+     *
+     * @see
+     * {@link IListener.ISource.addListeners}
+     */
+    addListeners(listeners: IAnchored.IListeners, options?: IListener.Options): IListener.Remove;
+    /**
+     * Deletes the anchored item.
+     */
+    delete(): void;
+    /**
+     * Returns if the model has been deleted
+     */
+    isDeleted(): boolean;
+    /**
+     * Similar to delete but cleans resources and can't be undone.
+     */
+    close(): void;
+    /**
+     * Returns if the model has been closed
+     */
+    isClosed(): boolean;
+    /**
+     * For runtime type checking.
+     */
+    readonly isIAnchored: true;
+}
+/**
+ * {@inheritDoc IAnchored}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IAnchored}
+ */
+export declare namespace IAnchored {
+    interface Events<T extends IAnchored = IAnchored> {
+        /**
+         * Called when the anchor bounds are updated.
+         */
+        onAnchorCoordsChange?(source: T, prev: IRange.Coords): void;
+        /**
+         * Called when the anchor protection is updated.
+         */
+        onProtectedChange?(source: T): void;
+        /**
+         * Called when the anchor is removed.
+         */
+        onDelete?(source: T): void;
+        /**
+         * Called when the state has been updated due to a undo/redo and a rerender is required.
+         */
+        onInvalidated?(source: T): void;
+        /**
+         * Called when the state has been updated for any reason.
+         */
+        onAnyChange?(source: T): void;
+        /**
+         * Called when the anchor transaction is closed.
+         */
+        onClose?(source: T): void;
+    }
+    interface IListeners extends IListener.Callbacks<IAnchored, IAnchored.Events> {
+    }
+    /**
+     * Describes how an anchored items bounds will adjust if
+     * rows/columns are inserted/removed.
+     */
+    const Type: {
+        /**
+         * Doesn't move when anchors moves.
+         */
+        readonly Absolute: "absolute";
+        /**
+         * Only moves the top left
+         */
+        readonly OneCell: "oneCell";
+        /**
+         * Moves both the top left and the bottom right
+         */
+        readonly TwoCell: "twoCell";
+    };
+    type Type = typeof Type[keyof typeof Type];
+}
+//# sourceMappingURL=IAnchored.d.ts.map

package/types/src/anchored/IAnchoredMap.d.ts

@@ -0,0 +1,207 @@
+import { IRange } from '@sheetxl/primitives';
+import { CoordUtils } from '@sheetxl/utils';
+import { ITransaction } from '../transaction';
+import { IListener } from '../listener';
+import { ISpatialMap, ISpatialQuery } from '../collections';
+import { ICellRange, ICellRanges } from '../cellRange';
+import { IAnchored } from './IAnchored';
+import { Anchored } from './Anchored';
+/**
+ * This is a map that wraps anchored entries into spatial maps.
+ *
+ * An anchored map has a set of capabilities:
+ *
+ * * These all support the .clone design
+ * * Shift entries in a spatial and route to IAnchored
+ * * Support deletion
+ * * Maintain order
+ *
+ * *? Return an ICollection
+ *
+ * * Query by:
+ * *   a. Range
+ * *   b. Model
+ * *   c. Name
+ */
+/**
+ * Returns as an ICollection
+ */
+export interface IAnchoredMap<T extends IAnchored, J = any> extends ISpatialQuery<T> {
+    /**
+     * Returns all models within the search range — **one entry per matching range**, each entry's
+     * `value` the model that owns it, ordered by model index then by authored range order.
+     *
+     * @param range The range to search
+     * @param fullyContained Only search for ranges that are completely contained with the search range. DefaultValue `false`.
+     * @param sort Ignored. Results are always ordered by model index.
+     * @param results Optional array to append the results to.
+     *
+     * @remarks
+     * * A model anchored to several ranges appears **once per range that intersects** `range`, so
+     *   every entry's coords are truthful — which is what anything painting or measuring needs.
+     *   Collapsing to one hit per model would have to pick a single range's coords and misreport
+     *   where the rest are; callers wanting one hit per model dedupe on the value (see
+     *   `_SheetStateReader.getRangedEntries`, whose contract is a single instance per item).
+     * * The returned array (when `results` is not supplied) is borrowed from an internal cache:
+     *   read-only, copy before mutating.
+     */
+    search(range: Readonly<IRange.Coords>, fullyContained?: boolean, sort?: boolean, results?: ISpatialMap.Entry<T>[]): ISpatialMap.Entry<T>[];
+    /**
+     * Returns if the map is empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * Returns `true` if any anchored range intersects `range`.
+     *
+     * @remarks
+     * The cheap existence test behind `_SheetStateReader.hasRangedEntries` — it hits the spatial
+     * index and never materializes entries or models.
+     */
+    has(range: Readonly<IRange.Coords>): boolean;
+    /**
+     * Returns the model with the given name.
+     */
+    getByName(name: string): T | null;
+    /**
+     * Sets the name and return a clone.
+     */
+    setName(model: T, name: string): this;
+    /**
+     * Returns the model with the given index.
+     */
+    getByIndex(index: number): T | null;
+    /**
+     * Sets the index and return a clone.
+     */
+    setIndex(model: T, index: number): this;
+    /**
+     * Returns the index for the model
+     */
+    getIndex(model: T): number;
+    /**
+     * Returns the model's ranges in authored order, or `null` if the model is not in the map.
+     */
+    getCoords(model: T): IRange.Coords[] | null;
+    /**
+     * Replaces the model's ranges and returns a clone.
+     *
+     * @param model The model to re-anchor.
+     * @param coords The new ranges, in authored order. An empty array deletes the model.
+     *
+     * @remarks
+     * This is a **replace**, not a merge: the previous ranges are dropped wholesale, so there is no
+     * old-to-new correspondence and the array given here becomes the model's authored order.
+     */
+    setCoords(model: T, coords: readonly Readonly<IRange.Coords>[]): this;
+    /**
+     * Returns all models, in model order.
+     *
+     * @remarks
+     * The map's live, **frozen** model order — not a copy, because this is read on the render path.
+     * Copy before sorting or filtering.
+     */
+    all(): readonly T[];
+    /**
+     * Returns the number of models.
+     */
+    size(): number;
+    /**
+     * Shifts all ranges in a given direction.
+     *
+     * @param options The options for the shift.
+     */
+    shift(options: IAnchoredMap.ShiftOptions): this;
+    /**
+     * Remove all models at range.
+     */
+    deleteRanges(range: Readonly<IRange.Coords[]>): this;
+    /**
+     * Remove item.
+     */
+    deleteModel(model: T): this;
+    /**
+     * Load from a set of references.
+     * @param refs
+     */
+    load(refs: IRange.JSONReference<J>[], createOptions: IAnchoredMap.CreateEntryOptions<T>): this;
+    /**
+     * Escape value to manually process callbacks. Most area handled automatically.
+     *
+     * @remarks
+     * This is being used on protection updated.
+     */
+    processCallbacks(handler: (model: T, callbacks: Anchored.ContainerCallbacks) => void): void;
+    /**
+     * Returns a copy
+     */
+    clone(): this;
+    /**
+     * Serializes to a set of references or `null` if the map is empty.
+     */
+    toJSON(): IRange.JSONReference<J>[] | null;
+    /**
+     * Closes the anchored map and its entries.
+     */
+    close(): void;
+}
+export declare namespace IAnchoredMap {
+    interface ConstructorOptions {
+        /**
+         * Returns a ranges from an address
+         * @returns
+         */
+        getRanges: (address: ICellRanges.Address) => ICellRanges;
+        /**
+         * Get the entire range of the current model.
+         */
+        getEntireRange: () => ICellRange;
+    }
+    interface CreateEntryOptions<T extends IAnchored> {
+        /**
+         * Required to create the model.
+         */
+        createModel: (options: Anchored.ConstructorOptions) => T;
+        /**
+         * If provided then will allow for custom Anchored.Entry.
+         *
+         * @remarks
+         * Useful when the entries have custom merge/split or other spatial logic..
+         */
+        createEntry?: (model: T, coords: IRange.Coords) => Anchored.Entry2<T>;
+        /**
+         * Called once after model creation. Any remove function will be called after delete
+         */
+        addListeners: (model: T) => IListener.Remove;
+        setContainerCoords?: (model: T, coords: readonly Readonly<IRange.Coords>[], options?: ITransaction.OperationOptions) => void;
+        setContainerName?: (model: T, name: string, options?: ITransaction.OperationOptions) => void;
+        setContainerIndex?: (model: T, index: number, options?: ITransaction.OperationOptions) => void;
+        getContainerIndex?: (model: T) => number | undefined;
+        deleteFromContainer?: (model: T, options?: ITransaction.OperationOptions) => void;
+        /**
+         * Notify that an anchor item wants to invalidate a range.
+         */
+        invalidate?: (coords?: IRange.Coords) => void;
+    }
+    /**
+     * Options for the shift method on the Index.
+     */
+    interface ShiftOptions {
+        /**
+         * The range to shift.
+         */
+        ranges: IRange.Coords[];
+        /**
+         * The direction to shift.
+         */
+        direction: IRange.Direction;
+        /**
+         * Allows for a a validation of the range after the shift amount is determined
+         * but before this shift is performed.
+         *
+         * @remarks
+         * * Useful when performing inserts that may fall outside of the bounds.
+         */
+        coordValidator?: CoordUtils.CoordValidator;
+    }
+}
+//# sourceMappingURL=IAnchoredMap.d.ts.map

package/types/src/anchored/_AnchorMessages.d.ts

@@ -0,0 +1,3 @@
+export declare const MODEL_CLOSED = "Item has been closed. No further operations are allowed.";
+export declare const ERROR_PROTECTED: (description?: string) => string;
+//# sourceMappingURL=_AnchorMessages.d.ts.map

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

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

package/types/src/autoFill/AutoFill.d.ts

@@ -0,0 +1,161 @@
+import { DateUnit } from '../date/_DateUtils';
+import { IAutoFill } from './IAutoFill';
+type JavaScriptDate = Date;
+export declare namespace AutoFill {
+    /**
+     * DateFill implements IAutoFill.Filler to work with Dates.
+     */
+    class Date implements IAutoFill.Filler<JavaScriptDate> {
+        private _options;
+        constructor(options?: DateOptions);
+        /**
+         * Returns `true` if the value is a valid `Date`.
+         * @see
+         * {@link IAutoFill.Filler.canFill}
+         */
+        canFill(value: any, _prev: JavaScriptDate): boolean;
+        /** {@inheritDoc IAutoFill.Filler.createFillAt} */
+        createFillAt(values: readonly JavaScriptDate[], options?: DateOptions): IAutoFill.FillAt<JavaScriptDate> | null;
+    }
+    /**
+     * Adds additional fill options for Dates.
+     */
+    interface DateOptions extends IAutoFill.Options {
+        /**
+         * If not provided the filler will attempt to determine.
+         * @defaultValue `The largest date unit found or day if one is not found.`
+         * // TODO - This doesn't support 'WeekDay'
+         */
+        unit?: DateUnit;
+    }
+    /**
+     * LinearFill implements IAutoFill.Filler to work with numbers.
+     * TODO - implements stepValue/stepTo
+     */
+    class Linear implements IAutoFill.Filler<number> {
+        private _options;
+        constructor(options?: IAutoFill.Options);
+        /**
+         * Returns `true` if the value is a valid number.
+         * @see
+         * {@link IAutoFill.Filler.canFill}
+         */
+        canFill(value: any, _prev: number): boolean;
+        /** {@inheritDoc IAutoFill.Filler.createFillAt} */
+        createFillAt(values: readonly number[], options?: IAutoFill.Options): IAutoFill.FillAt<number> | null;
+    }
+    /**
+     * Ordinal implements IAutoFill.Filler to handles Strings that have a Integer value.
+     */
+    class Ordinal implements IAutoFill.Filler<string> {
+        private _template;
+        /**
+         * Returns `true` if the value is a String that contains an Integer.
+         * @see
+         * {@link IAutoFill.Filler.canFill}
+         */
+        canFill(value: any, prev: string): boolean;
+        /** {@inheritDoc IAutoFill.Filler.createFillAt} */
+        createFillAt(values: readonly string[], options?: IAutoFill.Options): IAutoFill.FillAt<string> | null;
+    }
+    /**
+     * The Copy Filler 'copies' values in a repeating pattern.
+     *
+     * @remarks
+     * This the default Filler when non is specified or no filler accepts the values
+     * being provided.
+     */
+    class Copy implements IAutoFill.Filler<any> {
+        /**
+         * Always returns `true`.
+         * @see
+         * {@link IAutoFill.Filler.canFill}
+         */
+        canFill(_value: any, _prev: any): boolean;
+        /** {@inheritDoc IAutoFill.Filler.createFillAt} */
+        createFillAt(values: readonly number[], _options?: IAutoFill.Options): IAutoFill.FillAt<number>;
+    }
+    /**
+     * ListFill implements IAutoFill.Filler to work with lists.
+     */
+    interface ListOptions extends IAutoFill.Options {
+        /**
+         * A custom set of lists
+         */
+        customLists?: readonly string[][];
+    }
+    /**
+     * The List Filler uses a list of strings in a repeating pattern.
+     *
+     * @remarks
+     * This the default Filler when non is specified or no filler accepts the values
+     * being provided.
+     */
+    class List implements IAutoFill.Filler<string> {
+        private _lists;
+        private _map;
+        constructor(options?: ListOptions);
+        /**
+         * Always returns `true`.
+         * @see
+         * {@link IAutoFill.Filler.canFill}
+         */
+        canFill(value: string, _prev: any): boolean;
+        /** {@inheritDoc IAutoFill.Filler.createFillAt} */
+        createFillAt(values: readonly string[], options?: IAutoFill.Options): IAutoFill.FillAt<string> | null;
+    }
+    /**
+     * A specialized `Filler` that aggregates multiple `Filler` instances to handle various data types
+     * during autofill operations.
+     *
+     * It delegates the filling process to the first `Filler` in its collection whose `canFill` method
+     * returns `true` for the given value, enabling seamless autofill functionality for mixed data types within a range.
+     *
+     * @remarks
+     * This filler will also handle blanks.
+     */
+    class Composite<T = any> implements IAutoFill.Filler<T> {
+        private _fillers;
+        constructor(fillers: IAutoFill.Filler | IAutoFill.Filler[]);
+        /**
+         * Always returns `true`.
+         * @see
+         * {@link IAutoFill.Filler.canFill}
+         */
+        canFill(_value: T, _prev: T): boolean;
+        /** {@inheritDoc IAutoFill.Filler.createFillAt} */
+        createFillAt(values: readonly T[], options?: IAutoFill.Options): IAutoFill.FillAt<T>;
+    }
+    /**
+     * Available Builtin Types.
+     */
+    const Types: {
+        /**
+         * Default Fills.
+         * This attempts to fill use `Dates`, `Linear`, `Ordinal`, then `List`.
+         */
+        readonly Series: Composite<any>;
+        /**
+         * Fills using individual days.
+         */
+        readonly DateDays: Date;
+        /**
+         * Fills using months.
+         */
+        readonly DateMonths: Date;
+        /**
+         * Fills using years.
+         */
+        readonly DateYears: Date;
+        /**
+         * Fills with a repeating values.
+         */
+        readonly Copy: Copy;
+    };
+    /**
+     * Simple methods that builds an array from a Filler.
+     */
+    const fillTo: <T>(filler: IAutoFill.Filler, values: T[], to: number, options?: IAutoFill.Options) => T[];
+}
+export {};
+//# sourceMappingURL=AutoFill.d.ts.map