declare module "listener/IListener" {
    /**
     * Namespace used for listeners to events.
     */
    export namespace IListener {
        /**
         * A callback for the listener.
         */
        interface Callback<S> {
            (source: S, params?: any): any;
        }
        /**
         * The listener objects
         */
        type Callbacks<SOURCE, EVENTS = any> = Partial<{
            [Property in keyof EVENTS]: IListener.Callback<SOURCE>;
        }>;
        /**
         * Additional options for a listener.
         */
        interface Options {
            /**
             * If true, the listener will be removed after the first time it is called.
             *
             * @defaultValue false;
             */
            once?: boolean;
            /**
             * Determines if the listeners is part of the transaction.
             *
             * @defaultValue If the listener is added during a transaction this will be true.
             *
             * @remarks
             * There are subtle differences between a transactional listener and a non-transactional listener.
             *
             * A transactional listener:
             * * Will not be fire during undo/redo.
             * * Will be reverted to it's original add/remove state during an undo/redo.
             *
             * A non-transactional listener:
              * Will not be fire on any change.
             */
            transactional?: boolean;
        }
        interface Remove {
            (): void;
        }
        interface ISource<SOURCE, EVENTS = any> {
            /**
             * Add a set of callbacks to receive notification.
             *
             * @param listeners The callbacks object.
             * @param options Options
             * @returns A function that can be called to remove the listener.
             *
             * @remarks
             * Listeners are fired in the order that they are added.
             *
             */
            addListeners(listeners: IListener.Callbacks<SOURCE, EVENTS>, options?: IListener.Options): IListener.Remove;
        }
    }
}
declare module "listener/index" {
    export * from "listener/IListener";
}
declare module "i18n/i18n" {
    export const FLOAT_SEP_STR = ".";
    export const REGEX_FLOAT_STR = "\\s*([-]?[0-9e]*[.]?[0-9]+)";
    export const REGEX_SIMPLE_FLOAT_STR = "\\s*([-]?[0-9e]*[.]?[0-9]+)";
}
declare module "i18n/index" {
    export * as i18n from "i18n/i18n";
}
declare module "color/_ColorUtils" {
    export const RegExRGB: RegExp;
    export const RegExRGBA: RegExp;
    export const RegExLRGB: RegExp;
    export const RegExLRGBA: RegExp;
    export const RegExHSL: RegExp;
    export const RegExHSLA: RegExp;
    export const RegExHEX: RegExp;
    export const RegExHEXA: RegExp;
    export const RegExIndex: RegExp;
    export const parseParts: (partR: string | number, partG: string | number, partB: string | number) => number[];
    export const divideRGB: (input: number[], divisor?: number) => number[];
    export const multiplyRGB: (input: number[], factor?: number) => number[];
    export const roundRGB: (input: number[], sigFigs?: number) => number[];
    export const clampRGB: (rgb: number[], linear?: boolean) => number[];
    export const clampAlpha: (number: number) => number;
    export const clampHue: (hue: number) => number;
    export const srgb2lin: (rgb: number[]) => number[];
    export const lin2srgb: (rgb: number[]) => number[];
    /**
     *  Convert HSL values to a RGB Color.
     *  An array with:
     * * H - Hue is specified as degrees in the range 0 - 360.
     * * S - Saturation is specified as a percentage in the range 1 - 100.
     * * L - Luminance is specified as a percentage in the range 1 - 100.
     *  @param hsl Array with [h, s, l]
     *  @returns An array containing the 3 RGB values.
     */
    export const hsl2rgb: (hsl: number[]) => number[];
    export const hue2rgb: (p: number, q: number, h: number) => number;
    /**
     * Convert a RGB Color to it corresponding HSL values.
     *
     * @returns an array containing the 3 HSL values.
     */
    export const rgb2hsl: (rgb: number[]) => number[];
    export const HSLComponent: {
        readonly HUE: 0;
        readonly SATURATION: 1;
        readonly LUMINANCE: 2;
    };
    export type HSLComponent = typeof HSLComponent[keyof typeof HSLComponent];
    export const RGBAComponent: {
        readonly RED: 0;
        readonly GREEN: 1;
        readonly BLUE: 2;
        readonly ALPHA: 3;
    };
    export type RGBAComponent = typeof RGBAComponent[keyof typeof RGBAComponent];
    export const ColorShiftType: {
        readonly SET: 0;
        readonly OFF: 1;
        readonly MOD: 2;
    };
    export type ColorShiftType = typeof ColorShiftType[keyof typeof ColorShiftType];
    export class ColorAdjustment {
        _private: {
            name: string;
            amount: number;
        };
        constructor(name: string, amount: number);
        get name(): string;
        get amount(): number;
    }
    type CompTransform = (comp: number, lrgb: number[]) => number;
    export const applyLRGBTransform: (srgb: number[], compTransform: CompTransform) => number[];
    export const applyShade: (srgb: number[], val: number) => number[];
    export const applyETint: (srgb: number[], val: number) => number[];
    export const applyTint: (srgb: number[], val: number) => number[];
    export const applyHSL: (space: HSLComponent, srgb: number[], val: number) => number[];
    export const applyHSLOff: (space: HSLComponent, srgb: number[], val: number) => number[];
    export const applyHSLMod: (space: HSLComponent, srgb: number[], val: number) => number[];
    export const applyRGB: (space: RGBAComponent, srgb: number[], val: number, type: ColorShiftType) => number[];
    export const applyGray: (srgb: number[]) => number[];
    export const applyComplement: (srgb: number[]) => number[];
    export const applyInverse: (rgb: number[], linear?: boolean) => number[];
    export const applyGamma: (srgb: number[]) => number[];
    export const applyInverseGamma: (srgb: number[]) => number[];
    /**
     * Returns the hex value without the leading '#'.
     *
     * @param r Red as a value between 0 and 255.
     * @param g Green as a value between 0 and 255.
     * @param b Blue as a value between 0 and 255.
     */
    export const rgbToHex: (r: number, g: number, b: number, a?: number) => string;
    /**
     * This rotates Hue using the same algo that CSS uses.
     *
     * This was copied from https://hg.mozilla.org/mozilla-central/file/390d478480f9/gfx/src/FilterSupport.cpp
     */
    export const rotateHueCss: (srgb: number[], angle: number) => number[];
}
declare module "color/ColorSpace" {
    /**
     * Color definitions available in various ColorSpaces.
     */
    export namespace ColorSpace {
        /**
         * A color in the Red, Green, Blue color space.
         */
        class RGBA {
            protected _private: {
                red: number;
                green: number;
                blue: number;
                alpha: number;
            };
            constructor(red: number, green: number, blue: number, alpha?: number);
            get red(): number;
            get green(): number;
            get blue(): number;
            get alpha(): number;
            toString(alpha?: boolean): string;
            isEqual(other: ColorSpace.RGBA): boolean;
            isAlmostEqual(other: ColorSpace.RGBA): boolean;
        }
        /**
         * A color in the Hue, Saturation, Luminosity color space.
         */
        class HSLA {
            private _private;
            constructor(hue: number, sat: number, lum: number, alpha: number);
            get hue(): number;
            get sat(): number;
            get lum(): number;
            get alpha(): number;
            toString(alpha?: boolean): string;
            isEqual(other: ColorSpace.HSLA): boolean;
            isAlmostEqual(other: ColorSpace.HSLA): boolean;
        }
        /**
         * A color (Red, Green, Blue) encoded in hexadecimal.
         */
        class HEX extends ColorSpace.RGBA {
            toString(alpha?: boolean): string;
        }
    }
}
declare module "color/IColor" {
    import { ColorSpace } from "color/ColorSpace";
    /**
     * Represents a color with optional adjustments applied.
     *
     * An `IColor` consists of:
     * - `baseColor`: The underlying color, which can be a scheme color (e.g., Accent1), a built-in color (e.g., 'red', 'blue'),
     *   or defined using various color models (RGB, Hex, HSL).
     * - `adjustments` (optional): An ordered list of color adjustments that modify the `baseColor`.
     *   These adjustments can include effects like grayscale, inversion, or modifications to specific color components (red, alpha, etc.).
     * @see
     * {@link AdjustmentType}
     */
    export interface IColor {
        /**
         * The base value for the color before adjustments.
         */
        getVal(): string;
        /**
         * Return the color adjustments.
         */
        getAdjustments(): readonly IColor.Adjustment[];
        /**
         * Return as RGBA with adjustments applied.
         * @param darkMode
         */
        toRGBA(darkMode?: boolean): IColor.ISpace.RGBA;
        /**
         * Return as HSLA with adjustments applied.
         * @param darkMode
         */
        toHSLA(darkMode?: boolean): IColor.ISpace.HSLA;
        /**
         * Return a HEX with adjustments applied.
         * @param darkMode
         */
        toHex(darkMode?: boolean): IColor.ISpace.HEX;
        /**
         * Return a string usable with CSS color properties.
         *
         * @param darkMode If `true` dark colors will be used.
         * @param alpha If `true` alpha will be applied.
         */
        toCSS(darkMode?: boolean, alpha?: boolean): string;
        /**
         * Returns a new color that is derived from this color with the adjustments applied.
         * @param adjustments An array of Adjustments
         */
        adjust(adjustments: readonly IColor.Adjustment[]): IColor;
        /**
         * Returns the color as either 'black or white' depending on the luminance.
         * @param threshold The threshold to determine if the color is dark or light. @defaultValue '186'
         */
        toBlackOrWhite(darkMode?: boolean, threshold?: number): IColor;
        /**
         * Return the color as a string.
         * @remarks
         */
        toString(): string;
        /**
         * Return the type of color value used (e.g., scheme, named, index, hsl, rgb, hex).
         */
        getType(): IColor.Type;
        /**
         * Returns true if the other color will resolve to the same rgb values as this color.
         * @param other The other color to compare.
         */
        isEqual(other: any): boolean;
        /**
         * For runtime type checking.
         */
        readonly isIColor: true;
    }
    /**
     * {@inheritDoc IColor}
     * @see
     * ### **Interface**
     *
     * {@link IColor}
     *
     * ### **Implementation**
     *
     * {@link IColor}
     */
    export namespace IColor {
        /**
         * Represents a color space.
         */
        namespace ISpace {
            /**
             * A color in the Red, Green, Blue color space.
             */
            type RGBA = ColorSpace.RGBA;
            /**
             * A color in the Hue, Saturation, Luminosity color space.
             */
            type HSLA = ColorSpace.HSLA;
            /**
             * A color (Red, Green, Blue) encoded in hexadecimal.
             */
            type HEX = ColorSpace.HEX;
        }
        /**
         * Represents various adjustment types for color properties, allowing fine-tuned control over
         * attributes such as transparency, hue, saturation, luminance, and RGB components.
         *
         * The adjusts are based on the DrawML OOXML specification, with an additional adjustment type (`ETint`)
         * based on the Excel tint shading algorithm.
         *
         * * Adjustments can be chained to achieve complex color transformations.
         */
        const AdjustmentType: {
            /**
             * Adjusts the transparency level of a color.
             */
            readonly Alpha: "alpha";
            /**
             * Adjusts the transparency offset of a color.
             */
            readonly AlphaOff: "alphaOff";
            /**
             * Modifies the transparency of a color by a multiplier.
             */
            readonly AlphaMod: "alphaMod";
            /**
             * Adjusts the hue of a color.
             */
            readonly Hue: "hue";
            /**
             * Adjusts the saturation of a color.
             */
            readonly Sat: "sat";
            /**
             * Adjusts the luminance (brightness) of a color.
             */
            readonly Lum: "lum";
            /**
             * Applies an offset to the hue of a color.
             */
            readonly HueOff: "hueOff";
            /**
             * Applies an offset to the saturation of a color.
             */
            readonly SatOff: "satOff";
            /**
             * Applies an offset to the luminance of a color.
             */
            readonly LumOff: "lumOff";
            /**
             * Modifies the hue of a color by a multiplier.
             */
            readonly HueMod: "hueMod";
            /**
             * Modifies the saturation of a color by a multiplier.
             */
            readonly SatMod: "satMod";
            /**
             * Modifies the luminance of a color by a multiplier.
             */
            readonly LumMod: "lumMod";
            /**
             * Adjusts the red component of a color.
             */
            readonly Red: "red";
            /**
             * Adjusts the green component of a color.
             */
            readonly Green: "green";
            /**
             * Adjusts the blue component of a color.
             */
            readonly Blue: "blue";
            /**
             * Applies an offset to the red component of a color.
             */
            readonly RedOff: "redOff";
            /**
             * Applies an offset to the green component of a color.
             */
            readonly GreenOff: "greenOff";
            /**
             * Applies an offset to the blue component of a color.
             */
            readonly BlueOff: "blueOff";
            /**
             * Modifies the red component of a color by a multiplier.
             */
            readonly RedMod: "redMod";
            /**
             * Modifies the green component of a color by a multiplier.
             */
            readonly GreenMod: "greenMod";
            /**
             * Modifies the blue component of a color by a multiplier.
             */
            readonly BlueMod: "blueMod";
            /**
             * Shades a color, making it darker by reducing its luminance.
             */
            readonly Shade: "shade";
            /**
             * Tints a color, making it lighter by increasing its luminance.
             */
            readonly Tint: "tint";
            /**
             * Tints a color based on Excel's specific tint shading algorithm.
             */
            readonly ETint: "eTint";
            /**
             * Converts a color to grayscale.
             */
            readonly Gray: "gray";
            /**
             * Creates a complementary color.
             */
            readonly Comp: "comp";
            /**
             * Inverts a color.
             */
            readonly Inv: "inv";
            /**
             * Applies gamma correction to a color.
             */
            readonly Gamma: "gamma";
            /**
             * Inverts the gamma correction of a color.
             */
            readonly InvGamma: "invGamma";
        };
        type AdjustmentType = typeof AdjustmentType[keyof typeof AdjustmentType];
        /**
         * Represents a color adjustment.
         *
         * @remarks
         * All percentages are expresses as 0-100 except alpha which is 0-1.
         */
        type Adjustment = {
            [key in IColor.AdjustmentType]?: boolean | number;
        };
        /**
         * Represents a value and adjustment.
         */
        interface Definition {
            val: string;
            adjs?: readonly IColor.Adjustment[];
        }
        /**
         * Associate a color definition with a human-readable label.
         * @remarks
         * Useful for displaying color options in a UI.
         */
        interface DefinitionWithLabel {
            description: string;
            definition: IColor.Definition;
        }
        type Serializable = string | IColor | (string | IColor);
        /**
         * Lookup a color by the Schema key. This should consult a DocTheme if available.
         */
        type SchemeLookup = (key: IColor.Scheme) => ColorSpace.RGBA;
        /**
         * Lookup a color by the Indexed value.
         * @see
         * {@link https://github.com/closedxml/closedxml/wiki/Excel-Indexed-Colors | Excel Indexed Colors}
         */
        type IndexedLookup = (index: number) => ColorSpace.RGBA;
        /**
         * Named (builtin) colors defined in DrawingML aka known/system colors
         *
         * This enum provides a comprehensive list of named colors, including system-defined colors,
         * standard HTML colors, and additional named colors. Each color is represented as a string
         * corresponding to its name.
         *
         * @see
         * * {@link https://msdn.microsoft.com/library/system.drawing.knowncolor.aspx | KnownColor Enumeration}
         * * {@link https://msdn.microsoft.com/library/system.windows.media.colors.aspx | Colors Class}
         */
        const Named: {
            /**
             * The system-defined color of the active window's border.
             */
            readonly ActiveBorder: "activeBorder";
            /**
             * The system-defined color of the active window's caption.
             */
            readonly ActiveCaption: "activeCaption";
            /**
             * The system-defined color of the text in the active window's caption.
             */
            readonly CaptionText: "captionText";
            /**
             * The system-defined color of the application workspace.
             */
            readonly AppWorkspace: "appWorkspace";
            /**
             * The system-defined color of the face of a button.
             */
            readonly BtnFace: "btnFace";
            /**
             * The system-defined color of the shadow of a button.
             */
            readonly BtnShadow: "btnShadow";
            /**
             * The system-defined color of a 3D dark shadow.
             */
            readonly DkShadow3d: "3dDkShadow";
            /**
             * The system-defined color of the highlight of a button.
             */
            readonly BtnHighlight: "btnHighlight";
            /**
             * The system-defined color of a 3D light.
             */
            readonly Light3d: "3dLight";
            /**
             * The system-defined color of the text on a button.
             */
            readonly BtnText: "btnText";
            /**
             * The system-defined color of the background.
             */
            readonly Background: "background";
            /**
             * The system-defined color of gray text.
             */
            readonly GrayText: "grayText";
            /**
             * The system-defined color of the highlight.
             */
            readonly Highlight: "highlight";
            /**
             * The system-defined color of the text in the highlight.
             */
            readonly HighlightText: "highlightText";
            /**
             * The system-defined color of a hot light.
             */
            readonly HotLight: "hotLight";
            /**
             * The system-defined color of the inactive window's border.
             */
            readonly InactiveBorder: "inactiveBorder";
            /**
             * The system-defined color of the inactive window's caption.
             */
            readonly InactiveCaption: "inactiveCaption";
            /**
             * The system-defined color of the text in the inactive window's caption.
             */
            readonly InactiveCaptionText: "inactiveCaptionText";
            /**
             * The system-defined color of the background of an information tooltip.
             */
            readonly InfoBk: "infoBk";
            /**
             * The system-defined color of the text in an information tooltip.
             */
            readonly InfoText: "infoText";
            /**
             * The system-defined color of a menu.
             */
            readonly Menu: "menu";
            /**
             * The system-defined color of the text in a menu.
             */
            readonly MenuText: "menuText";
            /**
             * The system-defined color of a scroll bar.
             */
            readonly ScrollBar: "scrollBar";
            /**
             * The system-defined color of a window.
             */
            readonly Window: "window";
            /**
             * The system-defined color of a window frame.
             */
            readonly WindowFrame: "windowFrame";
            /**
             * The system-defined color of the text in a window.
             */
            readonly WindowText: "windowText";
            /**
             * The system-defined color of transparency.
             */
            readonly Transparent: "transparent";
            /**
             * The color AliceBlue.
             */
            readonly AliceBlue: "aliceBlue";
            /**
             * The color AntiqueWhite.
             */
            readonly AntiqueWhite: "antiqueWhite";
            /**
             * The color Aqua.
             */
            readonly Aqua: "aqua";
            /**
             * The color Aquamarine.
             */
            readonly Aquamarine: "aquamarine";
            /**
             * The color Azure.
             */
            readonly Azure: "azure";
            /**
             * The color Beige.
             */
            readonly Beige: "beige";
            /**
             * The color Bisque.
             */
            readonly Bisque: "bisque";
            /**
             * The color Black.
             */
            readonly Black: "black";
            /**
             * The color BlanchedAlmond.
             */
            readonly BlanchedAlmond: "blanchedAlmond";
            /**
             * The color Blue.
             */
            readonly Blue: "blue";
            /**
             * The color BlueViolet.
             */
            readonly BlueViolet: "blueViolet";
            /**
             * The color Brown.
             */
            readonly Brown: "brown";
            /**
             * The color BurlyWood.
             */
            readonly BurlyWood: "burlyWood";
            /**
             * The color CadetBlue.
             */
            readonly CadetBlue: "cadetBlue";
            /**
             * The color Chartreuse.
             */
            readonly Chartreuse: "chartreuse";
            /**
             * The color Chocolate.
             */
            readonly Chocolate: "chocolate";
            /**
             * The color Coral.
             */
            readonly Coral: "coral";
            /**
             * The color CornflowerBlue.
             */
            readonly CornflowerBlue: "cornflowerBlue";
            /**
             * The color Cornsilk.
             */
            readonly Cornsilk: "cornsilk";
            /**
             * The color Crimson.
             */
            readonly Crimson: "crimson";
            /**
             * The color Cyan.
             */
            readonly Cyan: "cyan";
            /**
             * The color DarkBlue.
             */
            readonly DkBlue: "dkBlue";
            /**
             * The color DarkCyan.
             */
            readonly DkCyan: "dkCyan";
            /**
             * The color DarkGoldenrod.
             */
            readonly DkGoldenrod: "dkGoldenrod";
            /**
             * The color DarkGray.
             */
            readonly DkGray: "dkGray";
            /**
             * The color DarkGreen.
             */
            readonly DkGreen: "dkGreen";
            /**
             * The color DarkKhaki.
             */
            readonly DkKhaki: "dkKhaki";
            /**
             * The color DarkMagenta.
             */
            readonly DkMagenta: "dkMagenta";
            /**
             * The color DarkOliveGreen.
             */
            readonly DkOliveGreen: "dkOliveGreen";
            /**
             * The color DarkOrange.
             */
            readonly DkOrange: "dkOrange";
            /**
             * The color DarkOrchid.
             */
            readonly DkOrchid: "dkOrchid";
            /**
             * The color DarkRed.
             */
            readonly DkRed: "dkRed";
            /**
             * The color DarkSalmon.
             */
            readonly DkSalmon: "dkSalmon";
            /**
             * The color DarkSeaGreen.
             */
            readonly DkSeaGreen: "dkSeaGreen";
            /**
             * The color DarkSlateBlue.
             */
            readonly DkSlateBlue: "dkSlateBlue";
            /**
             * The color DarkSlateGray.
             */
            readonly DkSlateGray: "dkSlateGray";
            /**
             * The color DarkTurquoise.
             */
            readonly DkTurquoise: "dkTurquoise";
            /**
             * The color DarkViolet.
             */
            readonly DkViolet: "dkViolet";
            /**
             * The color DeepPink.
             */
            readonly DeepPink: "deepPink";
            /**
             * The color DeepSkyBlue.
             */
            readonly DeepSkyBlue: "deepSkyBlue";
            /**
             * The color DimGray.
             */
            readonly DimGray: "dimGray";
            /**
             * The color DodgerBlue.
             */
            readonly DodgerBlue: "dodgerBlue";
            /**
             * The color Firebrick.
             */
            readonly Firebrick: "firebrick";
            /**
             * The color FloralWhite.
             */
            readonly FloralWhite: "floralWhite";
            /**
             * The color ForestGreen.
             */
            readonly ForestGreen: "forestGreen";
            /**
             * The color Fuchsia.
             */
            readonly Fuchsia: "fuchsia";
            /**
             * The color Gainsboro.
             */
            readonly Gainsboro: "gainsboro";
            /**
             * The color GhostWhite.
             */
            readonly GhostWhite: "ghostWhite";
            /**
             * The color Gold.
             */
            readonly Gold: "gold";
            /**
             * The color Goldenrod.
             */
            readonly Goldenrod: "goldenrod";
            /**
             * The color Gray.
             */
            readonly Gray: "gray";
            /**
             * The color Green.
             */
            readonly Green: "green";
            /**
             * The color GreenYellow.
             */
            readonly GreenYellow: "greenYellow";
            /**
             * The color Honeydew.
             */
            readonly Honeydew: "honeydew";
            /**
             * The color HotPink.
             */
            readonly HotPink: "hotPink";
            /**
             * The color IndianRed.
             */
            readonly IndianRed: "indianRed";
            /**
             * The color Indigo.
             */
            readonly Indigo: "indigo";
            /**
             * The color Ivory.
             */
            readonly Ivory: "ivory";
            /**
             * The color Khaki.
             */
            readonly Khaki: "khaki";
            /**
             * The color Lavender.
             */
            readonly Lavender: "lavender";
            /**
             * The color LavenderBlush.
             */
            readonly LavenderBlush: "lavenderBlush";
            /**
             * The color LawnGreen.
             */
            readonly LawnGreen: "lawnGreen";
            /**
             * The color LemonChiffon.
             */
            readonly LemonChiffon: "lemonChiffon";
            /**
             * The color LightBlue.
             */
            readonly LtBlue: "ltBlue";
            /**
             * The color LightCoral.
             */
            readonly LtCoral: "ltCoral";
            /**
             * The color LightCyan.
             */
            readonly LtCyan: "ltCyan";
            /**
             * The color LightGoldenrodYellow.
             */
            readonly LtGoldenrodYellow: "ltGoldenrodYellow";
            /**
             * The color LightGray.
             */
            readonly LtGray: "ltGray";
            /**
             * The color LightGreen.
             */
            readonly LtGreen: "ltGreen";
            /**
             * The color LightPink.
             */
            readonly LtPink: "ltPink";
            /**
             * The color LightSalmon.
             */
            readonly LtSalmon: "ltSalmon";
            /**
             * The color LightSeaGreen.
             */
            readonly LtSeaGreen: "ltSeaGreen";
            /**
             * The color LightSkyBlue.
             */
            readonly LtSkyBlue: "ltSkyBlue";
            /**
             * The color LightSlateGray.
             */
            readonly LtSlateGray: "ltSlateGray";
            /**
             * The color LightSteelBlue.
             */
            readonly LtSteelBlue: "ltSteelBlue";
            /**
             * The color LightYellow.
             */
            readonly LtYellow: "ltYellow";
            /**
             * The color Lime.
             */
            readonly Lime: "lime";
            /**
             * The color LimeGreen.
             */
            readonly LimeGreen: "limeGreen";
            /**
             * The color Linen.
             */
            readonly Linen: "linen";
            /**
             * The color Magenta.
             */
            readonly Magenta: "magenta";
            /**
             * The color Maroon.
             */
            readonly Maroon: "maroon";
            /**
             * The color MediumAquamarine.
             */
            readonly MedAquamarine: "medAquamarine";
            /**
             * The color MediumBlue.
             */
            readonly MedBlue: "medBlue";
            /**
             * The color MediumOrchid.
             */
            readonly MedOrchid: "medOrchid";
            /**
             * The color MediumPurple.
             */
            readonly MedPurple: "medPurple";
            /**
             * The color MediumSeaGreen.
             */
            readonly MedSeaGreen: "medSeaGreen";
            /**
             * The color MediumSlateBlue.
             */
            readonly MedSlateBlue: "medSlateBlue";
            /**
             * The color MediumSpringGreen.
             */
            readonly MedSpringGreen: "medSpringGreen";
            /**
             * The color MediumTurquoise.
             */
            readonly MedTurquoise: "medTurquoise";
            /**
             * The color MediumVioletRed.
             */
            readonly MedVioletRed: "medVioletRed";
            /**
             * The color MidnightBlue.
             */
            readonly MidnightBlue: "midnightBlue";
            /**
             * The color MintCream.
             */
            readonly MintCream: "mintCream";
            /**
             * The color MistyRose.
             */
            readonly MistyRose: "mistyRose";
            /**
             * The color Moccasin.
             */
            readonly Moccasin: "moccasin";
            /**
             * The color NavajoWhite.
             */
            readonly NavajoWhite: "navajoWhite";
            /**
             * The color Navy.
             */
            readonly Navy: "navy";
            /**
             * The color OldLace.
             */
            readonly OldLace: "oldLace";
            /**
             * The color Olive.
             */
            readonly Olive: "olive";
            /**
             * The color OliveDrab.
             */
            readonly OliveDrab: "oliveDrab";
            /**
             * The color Orange.
             */
            readonly Orange: "orange";
            /**
             * The color OrangeRed.
             */
            readonly OrangeRed: "orangeRed";
            /**
             * The color Orchid.
             */
            readonly Orchid: "orchid";
            /**
             * The color PaleGoldenrod.
             */
            readonly PaleGoldenrod: "paleGoldenrod";
            /**
             * The color PaleGreen.
             */
            readonly PaleGreen: "paleGreen";
            /**
             * The color PaleTurquoise.
             */
            readonly PaleTurquoise: "paleTurquoise";
            /**
             * The color PaleVioletRed.
             */
            readonly PaleVioletRed: "paleVioletRed";
            /**
             * The color PapayaWhip.
             */
            readonly PapayaWhip: "papayaWhip";
            /**
             * The color PeachPuff.
             */
            readonly PeachPuff: "peachPuff";
            /**
             * The color Peru.
             */
            readonly Peru: "peru";
            /**
             * The color Pink.
             */
            readonly Pink: "pink";
            /**
             * The color Plum.
             */
            readonly Plum: "plum";
            /**
             * The color PowderBlue.
             */
            readonly PowderBlue: "powderBlue";
            /**
             * The color Purple.
             */
            readonly Purple: "purple";
            /**
             * The color Red.
             */
            readonly Red: "red";
            /**
             * The color RosyBrown.
             */
            readonly RosyBrown: "rosyBrown";
            /**
             * The color RoyalBlue.
             */
            readonly RoyalBlue: "royalBlue";
            /**
             * The color SaddleBrown.
             */
            readonly SaddleBrown: "saddleBrown";
            /**
             * The color Salmon.
             */
            readonly Salmon: "salmon";
            /**
             * The color SandyBrown.
             */
            readonly SandyBrown: "sandyBrown";
            /**
             * The color SeaGreen.
             */
            readonly SeaGreen: "seaGreen";
            /**
             * The color SeaShell.
             */
            readonly SeaShell: "seaShell";
            /**
             * The color Sienna.
             */
            readonly Sienna: "sienna";
            /**
             * The color Silver.
             */
            readonly Silver: "silver";
            /**
             * The color SkyBlue.
             */
            readonly SkyBlue: "skyBlue";
            /**
             * The color SlateBlue.
             */
            readonly SlateBlue: "slateBlue";
            /**
             * The color SlateGray.
             */
            readonly SlateGray: "slateGray";
            /**
             * The color Snow.
             */
            readonly Snow: "snow";
            /**
             * The color SpringGreen.
             */
            readonly SpringGreen: "springGreen";
            /**
             * The color SteelBlue.
             */
            readonly SteelBlue: "steelBlue";
            /**
             * The color Tan.
             */
            readonly Tan: "tan";
            /**
             * The color Teal.
             */
            readonly Teal: "teal";
            /**
             * The color Thistle.
             */
            readonly Thistle: "thistle";
            /**
             * The color Tomato.
             */
            readonly Tomato: "tomato";
            /**
             * The color Turquoise.
             */
            readonly Turquoise: "turquoise";
            /**
             * The color Violet.
             */
            readonly Violet: "violet";
            /**
             * The color Wheat.
             */
            readonly Wheat: "wheat";
            /**
             * The color White.
             */
            readonly White: "white";
            /**
             * The color WhiteSmoke.
             */
            readonly WhiteSmoke: "whiteSmoke";
            /**
             * The color Yellow.
             */
            readonly Yellow: "yellow";
            /**
             * The color YellowGreen.
             */
            readonly YellowGreen: "yellowGreen";
            /**
             * The system-defined color of the face of a button.
             */
            readonly ButtonFace: "buttonFace";
            /**
             * The system-defined color of the highlight of a button.
             */
            readonly ButtonHighlight: "buttonHighlight";
            /**
             * The system-defined color of the shadow of a button.
             */
            readonly ButtonShadow: "buttonShadow";
            /**
             * The system-defined color of the gradient active caption.
             */
            readonly GradientActiveCaption: "gradientActiveCaption";
            /**
             * The system-defined color of the gradient inactive caption.
             */
            readonly GradientInactiveCaption: "gradientInactiveCaption";
            /**
             * The system-defined color of the menu bar.
             */
            readonly MenuBar: "menuBar";
            /**
             * The system-defined color of the menu highlight.
             */
            readonly MenuHighlight: "menuHighlight";
        };
        type Named = typeof Named[keyof typeof Named];
        /**
         * Represents predefined colors from a color scheme, used in document themes.
         */
        const Scheme: {
            /**
             * Background color 1.
             */
            readonly Bg1: "bg1";
            /**
             * Background color 2.
             */
            readonly Bg2: "bg2";
            /**
             * Text color 1.
             */
            readonly Tx1: "tx1";
            /**
             * Text color 2.
             */
            readonly Tx2: "tx2";
            /**
             * Accent color 1.
             */
            readonly Accent1: "accent1";
            /**
             * Accent color 2.
             */
            readonly Accent2: "accent2";
            /**
             * Accent color 3.
             */
            readonly Accent3: "accent3";
            /**
             * Accent color 4.
             */
            readonly Accent4: "accent4";
            /**
             * Accent color 5.
             */
            readonly Accent5: "accent5";
            /**
             * Accent color 6.
             */
            readonly Accent6: "accent6";
            /**
             * Hyperlink color.
             */
            readonly Hlink: "hlink";
            /**
             * Followed hyperlink color.
             */
            readonly FolHlink: "folHlink";
        };
        type Scheme = typeof Scheme[keyof typeof Scheme];
        /**
         * Indicates the Color Type used.
         */
        const Type: {
            readonly Scheme: "scheme";
            readonly Named: "named";
            readonly Index: "index";
            readonly HSL: "hsl";
            readonly RGB: "rgb";
            readonly LRGB: "lrgb";
            readonly Hex: "hex";
        };
        type Type = typeof Type[keyof typeof Type];
    }
}
declare module "color/_BuiltInIndexDefs" {
    import { ColorSpace } from "color/ColorSpace";
    /** @internal */
    export const _BuiltInIndexDefs: (index: number) => ColorSpace.RGBA;
}
declare module "color/_BuiltInNamedDefs" {
    /**
     * Preset colors defined in DrawingML aka known/system colors
     *
     * @see
     * * {@link https://msdn.microsoft.com/library/system.drawing.knowncolor.aspx | KnownColor Enumeration}
     * * {@link https://msdn.microsoft.com/library/system.windows.media.colors.aspx | Colors Class}
     */
    type RGBA = {
        r: number;
        g: number;
        b: number;
        a?: number;
    };
    type ColorMapping = {
        id: number;
        name: string;
        rgbaColor: RGBA;
        system: boolean;
    };
    class NamedDefLookup {
        _lookupByName: Map<string, ColorMapping>;
        constructor();
        valueOfName(name: string): ColorMapping;
    }
    export const _BuiltInNamedDefs: NamedDefLookup;
}
declare module "color/_BuiltInSchemeDefs" {
    import { IColor } from "color/IColor";
    export type SchemeDef = {
        scheme: string | IColor.Scheme;
        description: string;
    };
    export const _BuiltInSchemeDefs: (scheme: string) => SchemeDef | null;
}
declare module "color/Color" {
    import { ColorSpace } from "color/ColorSpace";
    import { IColor } from "color/IColor";
    /**
     * Capabilities for working with {@link IColor | colors}.
     *
     * Advanced color customization and compatibility with CSS and Office color schemes.
     *
     * Key features include:
     * - Accessing a collection of built-in colors (Named, Scheme, Index).
     * - Creating customized colors with color adjustments.
     * - Defining and and converting between different color models (RGB, HEX, HSL).
     *
     * @see
     * {@link IColor}
     */
    export class Color implements IColor {
        private _private;
        constructor(value: string | IColor | IColor.Definition, schemeLookup?: IColor.SchemeLookup, indexedLookup?: IColor.IndexedLookup, last?: ColorSpace.RGBA);
        private _parse;
        private _forceDark;
        private _resolve;
        /**
         * @hidden
         * TODO - Rationalize this. Do we want a constructor a static parse?
         */
        static parse(input: string | IColor, schemeLookup?: IColor.SchemeLookup, indexedLookup?: IColor.IndexedLookup, last?: ColorSpace.RGBA): IColor | null;
        /**
         * Returns the default color scheme lookup that Colors will use if none is provided.
         */
        static getDefaultSchemeLookup(): IColor.SchemeLookup;
        /** {@inheritDoc IColor.isEqual} */
        isEqual(other: any): boolean;
        /** {@inheritDoc IColor.getVal} */
        getVal(): string;
        /** {@inheritDoc IColor.getAdjustments} */
        getAdjustments(): readonly IColor.Adjustment[];
        /** {@inheritDoc IColor.adjust} */
        adjust(adjustments: IColor.Adjustment[]): IColor;
        /** {@inheritDoc IColor.getType} */
        getType(): IColor.Type;
        /** {@inheritDoc IColor.toCSS} */
        toCSS(darkMode?: boolean, alpha?: boolean): string;
        /** {@inheritDoc IColor.toRGBA} */
        toRGBA(darkMode?: boolean): IColor.ISpace.RGBA;
        /** {@inheritDoc IColor.toHSLA} */
        toHSLA(darkMode?: boolean): IColor.ISpace.HSLA;
        /** {@inheritDoc IColor.toHex} */
        toHex(darkMode?: boolean): IColor.ISpace.HEX;
        /** {@inheritDoc IColor.toBlackOrWhite} */
        toBlackOrWhite(darkMode?: boolean, threshold?: number): IColor;
        get [Symbol.toStringTag](): string;
        /** {@inheritDoc IColor.toString} */
        toString(): string;
        /** {@inheritDoc IColor.isIColor} */
        get isIColor(): true;
    }
}
declare module "color/index" {
    export * from "color/IColor";
    export * from "color/Color";
}
declare module "type/ITypes" {
    import type { RunCoords, Bounds, RangeCoords } from '@sheetxl/utils';
    /**
     * A collection of types.
     */
    export namespace ITypes {
        /**
         * Associate an optional value with a {@link RangeCoords}.
         */
        interface RangeCoordValue<T = any> extends RangeCoords {
            value?: T;
        }
        /**
         * Associate an option value with a {@link RunCoords}.
         */
        interface RunCoordValue<T> extends RunCoords {
            value?: T;
        }
        /**
         * Associate an option value with a {@link Bounds}.
         */
        interface BoundsValue<T = any> extends Bounds {
            value?: T;
        }
        /**
         * Options for controlling selection behavior, including scrolling and focus.
         */
        interface SelectOptions {
            /**
             * If `true` or if a valid `ScrollIntoViewOptions` object is provided,
             * the selected element will be scrolled into view.
             *
             * @remarks
             * - If a `ScrollIntoViewOptions` object is provided, it will control the exact scrolling behavior.
             * - If `false` (or omitted), the selected element will not be scrolled into view.
             *
             * @defaultValue false
             */
            scrollIntoView?: boolean | globalThis.ScrollIntoViewOptions;
            /**
             * If `true`, the selected element will automatically receive focus after being selected.
             *
             * @remarks
             * - If `false` (or omitted), the element will not automatically receive focus.
             *
             * @defaultValue false
             */
            autoFocus?: boolean;
        }
    }
}
declare module "type/IProperties" {
    import type { Scalar, IRange } from '@sheetxl/primitives';
    /**
     * Contains interfaces for working with properties.
     */
    export namespace IProperties {
        /**
         * Represents an interface for ranged items with customizable properties,
         * supporting operations such as retrieving properties at a given coordinate,
         * cloning with updates, splitting, and merging.
         *
         * @typeParam P - The type representing the properties associated with the range.
         * @typeParam J - The type representing the JSON-serializable representation of the range.
         */
        interface ICellRanged<P> {
            /**
             * Retrieves the coordinates for the range.
             *
             * @returns The range's coordinates.
             *
             * @remarks
             * The coordinates are not the coordinates where this is contained but the coordinates for access getPropertiesAt.
             */
            getCoords(): Readonly<IRange.Coords>;
            /**
             * Retrieves the properties associated with a specified cell within the range.
             *
             * @param rowIndex The row index within the range.
             * @param colIndex The column index within the range.
             * @param value The value at the coordinates.
             * @returns The properties associated with the specified cell as a read-only object.
             */
            getPropertiesAt(rowIndex: number, colIndex: number, value: Scalar): Readonly<P>;
            /**
             * Creates a new instance of the range with specified updates applied.
             *
             * @param updates The updates to apply to the range's properties.
             * @returns A new `ICellRanged` instance with the applied updates.
             */
            cloneWithUpdate?(updates: IProperties.ResolvableProperties<P>): this;
        }
        /**
         * Recursively converts a type into a derived type where any field can be a string or a function that takes the old value.
         */
        type ResolvableProperties<T> = Partial<{
            [Property in keyof T]: T[Property] | string | null | ResolvableProperties<T[Property]>;
        }>;
    }
}
declare module "type/ICollection" {
    import type { JSONSerializableAsync } from '@sheetxl/utils';
    import type { IListener } from "listener/index";
    /**
     * Interface used for all ICollections.
     */
    export interface ICollection<T, O = ICollection.GetItemsOptions> {
        /**
         * Returns the items in the collection.
         */
        getItems(options?: ICollection.GetItemsOptions): T[];
        /**
         * Returns the total items available.
         *
         * @remarks
         * Useful as a quick escape for getItems.
         */
        getCount(): number;
    }
    /**
     * {@inheritDoc ICollection}
     * @see
     * ### **Interface**
     *
     * {@link ICollection}
     */
    export namespace ICollection {
        /**
         * Options for getting items from the collection.
         *
         * @remarks
         * This placeholder is extended by implementations of ICollection
         */
        interface GetItemsOptions {
        }
        /**
         * Collection that can be persisted.
         */
        interface IPersistable<J = any> {
            /**
             * Used for saving items. Returns a handler that will allow for writing JSON records
             * only save the items that were accessed within the persist scope.
             */
            beginPersist(): ICollection.IPersistScope<J>;
        }
        /**
         * A transient scope for items to ids that can be used for references.
         *
         * @see
         * {@link IPersistable.beginPersist}
         */
        interface IPersistScope<J = any> {
            /**
             * For a shared string this will return a number that can be used to reference the item in the persisted json.
             * @param item The to return an identifier for.
             */
            add(item: JSONSerializableAsync<J> | J): number | null;
            /**
             * For a given persist id this will return the item.
             *
             * @param id
             */
            at(id: number): JSONSerializableAsync<J> | J | null;
            /**
             * Called when done persisting.
             */
            endPersist(): void;
            /**
             * Loads the json.
             *
             * @param json
             */
            fromJSON(json: J[]): void;
            /**
             * Return a array of resources that have been added via `add`.
             *
             * @remarks
             * This can be called multiple times..
             */
            toJSONAsync(): Promise<J[]>;
        }
        /**
         * Collection Events.
         */
        interface Events {
            /**
             * Called when collections have changes.
             */
            onCollectionChange?(source: ICollection<any>): void;
            /**
             * Called when the collection has been updated due to a undo/redo and a rerender is required.
             */
            onInvalidated?(source: ICollection<any>): void;
        }
        interface IListeners extends IListener.Callbacks<ICollection<any>, ICollection.Events> {
        }
    }
}
declare module "type/index" {
    export * from "type/ITypes";
    export * from "type/IProperties";
    export * from "type/ICollection";
}
declare module "transaction/ITransaction" {
    import { ITypes } from "type/index";
    import { IListener } from "listener/index";
    /**
     * Objects that implement this interface have ACID properties.
     */
    export interface ITransaction {
        /**
         * Begin a transaction with self contained, non-eventing updates.
         *
         * @remarks
         * `description` is useful for debugging and logging.
         *
         * Transactions are treated as a stack so with fifo remove. When the final commit is applied
         * to global only the final transaction will be maintained.
         *
         * @param options The description of the transaction or options.
         * @param onClose A callback for when the transaction is closed (due to either a commit or rollback).
         */
        beginTransaction(options?: ITransaction.StoreOperationOptions, onClose?: ITransaction.CloseCallback): ITransaction;
        /**
         * Commit the transaction and all children transactions to the parent transaction.
         *
         * @param options A final description or options to apply on commit.
         */
        commit<View = any, P = any>(options?: ITransaction.StoreOperationOptions<View, P>): ITransaction;
        /**
         * Discard all changes and children transaction changes.
         */
        rollback(): ITransaction;
        /**
         * If root transaction will return self.
         */
        getParent(): ITransaction;
        /**
         * A unique id for this transaction. This will be the same id for all sub transactions.
         */
        getId(): string;
        /**
         * Describes the current transaction.
         */
        getDescription(): string;
        /**
         * 0-Based depth of the current transaction. If 0 then it's globally available.
         */
        getDepth(): number;
        /**
         * Returns the state associated to a record for the current transaction or globally if there are no open transactions.
         *
         * @param model The `ITransactional` object.
         */
        getState<STATE = any>(model: any): Readonly<STATE>;
        /**
         * Update the state for a record.
         *
         * @param model
         * @param state
         */
        updateState<STATE = any>(model: any, state: (Readonly<Partial<STATE>> | ((prev: Readonly<STATE>) => Readonly<STATE>))): STATE;
        /**
         * All states in the current transaction.
         */
        getStates(): Map<any, any>;
        /**
         * Returns the view associated with this transaction.
         */
        getView(): Record<string, any> | null;
    }
    /**
     * {@inheritDoc ITransaction}
     * @see
     * ### **Interface**
     *
     * {@link ITransaction}
     */
    export namespace ITransaction {
        /**
         * Objects that implement this interface allow for batch operations.
         */
        interface ITransactional {
            /**
             * A unique identifier for the record. This will never change.
             *
             * @remarks
             * This enables the record to be identified across transactions and users in a collaborative environment.
             */
            getUUID?(): string;
            /**
             * Provides a mechanism to perform a set of operations in a batch.
             *
             * @param callback A callback that performs multiple operations all within the same transaction.
             * @param options Description of the operation or additional options. Used for tracking undo/redo and history. Default Value `User Operation`.
             */
            doBatch<R = any>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ITransaction.OperationOptions): R | Promise<R>;
            /**
             * Batches all 'transactional' changes until they have all be committed or rolled back.
             *
             * @remarks
             * Any changes that are made to this object will be reflected in the local record but
             * not committed to the transactional store until the batch is popped.
             *
             * Useful for operations that are longer running but generally not recommended
             * as it keeps a transaction open. {@link doBatch} is the preferred option.
             *
             * @param options Description of the operation or additional options. Used for tracking undo/redo and history. Default Value `User Operation`.
             */
            beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
            /**
             * Close the record and cleans resources. Can't be undone.
             */
            close(): void;
            /**
             * Returns `true` if no more operations are allowed.
             */
            isClosed(): boolean;
        }
        interface ICommit {
            /**
             * Returns the unique identifier for the commit.
             */
            getId(): string;
            /**
             * A human readable description of the commit.
             */
            getDescription(): string;
            /**
             * Additional meta information set during open and close.
             */
            getMeta(): Readonly<Record<string, string>>;
            /**
             * The author of the commit.
             */
            getAuthor(): any;
            /**
             * The time the commit was created.
             */
            getTimestamp(): number;
            /**
             * Returns the operation that was used to create the commit.
             *
             * @remarks
             * It is possible that a batch operation was used to create the commit.
             */
            getOperation(): Readonly<Operation>;
        }
        /**
         * When the first transaction this will contain the name of parameters of the input
         */
        interface Operation<PARAMS = any> {
            /**
             * The name of the operations.
             *
             * @remarks
             * This name should be unique per model type. This is used for audit and collaboration.
             */
            name: string;
            /**
             * The parameters for the operation.
             */
            params?: PARAMS;
        }
        interface RestoreOptions {
            /**
             * If provided restore will only select if the view matches the id.
             *
             * @defaultValue undefined - Any view will be selected.
             *
             * @remarks
             * This is used for collaboration.
             */
            viewId?: string;
            /**
             * If true will force the restore even if there are open transactions.
             *
             * @defaultValue false
             */
            force?: boolean;
        }
        interface StoreConstructorOptions {
            /**
             * The creator of the transactions.
             */
            author?: string;
            /**
             * If true will try to default to synchronous eventing.
             *
             * @defaultValue 'setDefaultSync'
             */
            sync?: boolean;
            /**
             * If true will not track changes for restoring.
             * @defaultValue false
             *
             * @remarks
             * Useful for creating temporary models that don't need to be tracked.
             */
            transient?: boolean;
        }
        interface IStore {
            /**
             * Add a listener to listen for changes.
             */
            addListener(listener: ITransaction.IListeners): IListener.Remove;
            /**
             * Add a listener for state changes to a specific model.
             *
             * @param model
             * @param listener
             */
            addStateListener<STATE = any, VIEW = any>(model: any, listener: ITransaction.IStateListener<STATE, VIEW>): IListener.Remove;
            /**
             * Returns the last commits of commits.
             * @param commitId The commit id to start from.
             * @param max - The maximum number of commits to return. *default* `100`.
             */
            getLog(commitId: string, max?: number): ITransaction.ICommit[];
            /**
             * Returns the total number of commits.
             */
            getCommitCount(): number;
            /**
             * Returns the current commit.
             *
             * @remarks
             * Returns either the last completed commit or the current pending.
             */
            getCurrentCommit(): ITransaction.ICommit;
            /**
             * Returns true if there is an open transaction.
             */
            isOpenTransaction(): boolean;
            /**
             * Returns the current view associated with the entire commit.
             *
             * @remarks
             * Will return `null` if there is no open transaction.
             */
            getPendingView(): Record<string, any> | null;
            /**
             * Returns the current state associated to a model for the current transaction or globally if there are no open transactions.
             *
             * @param model The `ITransactional` object.
             */
            getState<STATE = any>(model: any): Readonly<STATE>;
            /**
             * Begin a transaction using the current commit.
             * @param options
             * @param onClose
             */
            beginCommit(options?: ITransaction.StoreOperationOptions, onClose?: ITransaction.CloseCallback): ITransaction;
            /**
             * Used by `ITransactional` objects. Both to expose `doBatch` and to implement
             * their own internal transactions.
             */
            doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: ITransaction.StoreOperationOptions, onClose?: ITransaction.CloseCallback): Promise<R> | R;
            /**
             * Remove model from the commit.
             *
             * @param model The model to remove.
             * @returns A flag indicating if anything was removed.
             *
             * @remarks
             * Fires remove event.
             */
            remove(model: any): boolean;
            /**
             * Set the state to a previous history point.
             *
             * @param commitId
             * @param options
             *
             * @remarks
             * Can be any previous restore point available in before the current commit
             * or after the current commit.
             */
            restore(commitId: string, options?: ITransaction.RestoreOptions): ITransaction.ICommit;
            /**
             * Revert is similar to restore in that it moves the state but it applies view
             * updates in reverse order.
             *
             * @param commitId
             * @param options
             *
             * @remarks
             * Can be any previous restore point available in before the current commit
             * or after the current commit.
             */
            revert(commitId: string, options?: ITransaction.RestoreOptions): ITransaction.ICommit;
        }
        /**
         * Listener interface for TransactionStore
         */
        interface IListeners {
            /**
             * Called when a commit is started.
             *
             * @param commit The commit handle.
             *
             * @remarks
             * This allows for additional transactional changes to be made such as transaction listeners.
             */
            onCommitStart?(commit: ITransaction.ICommit): void;
            /**
             * Called after a successful commit.
             *
             * @param commit
             *
             * @remarks
             * * A rollback will not trigger this event.
             * * A restore/revert will trigger this event.
             */
            onCommitEnd?(commit: ITransaction.ICommit): void;
            /**
             * Called if the commit changes for any reason.
             *
             * @param commit
             */
            onCommitChange?(commit: ITransaction.ICommit): void;
        }
        interface IStateListener<STATE = any, VIEW = any> {
            /**
             * Called synchronously at the beginning of a transaction before a record is changed.
             *
             * @remarks
             * If this throws an exception then all records within the transaction will not
             * be applied.
             */
            onBeforeCommitStart?(state: STATE, view: VIEW, commit: ITransaction.ICommit): void;
            /**
             * Called during a transaction.
             *
             * @remarks
             * This is when changes should be applied. The view will only be provided if restore is used.
             */
            onBeforeCommitEnd?(state: STATE, view: VIEW, commit: ITransaction.ICommit): void;
            /**
             * Called after the transaction. This is generally used for cleanup or ui notification.
             */
            onAfterStateChange?(state: STATE, view: VIEW, commit: ITransaction.ICommit, isRevert: boolean, isRestore: boolean): void;
            /**
             * Called if the restore or revert is called. This is called asynchronously As should only have passive actions.
             */
            onRestoreOrRevert?(state: STATE, view: VIEW, commit: ITransaction.ICommit, isUndo: boolean): void;
            /**
             * Called when a model is removed from the transaction.
             */
            onClose?(commit: ITransaction.ICommit): void;
        }
        /**
         * Called when a transaction is closed.
         */
        interface CloseCallback {
            (transaction: ITransaction, isRollback: boolean, options: ITransaction.OperationOptions): void;
        }
        /**
         * Options for Operations that change the state.
         */
        interface OperationOptions {
            /**
             * A human description.
             *
             * @defaultValue 'determined by the set operation and locale'
             */
            description?: string;
            /**
             * If `true` or set then this will select the affect item after the transaction is complete.
             *
             * @remarks
             * If this is set to `true` then any restore will also select.
             */
            autoSelect?: boolean | ITypes.SelectOptions;
        }
        /**
         * Options for operations with the store.
         */
        interface StoreOperationOptions<VIEW = any, PARAMS = any> extends OperationOptions {
            /**
             * If set to `true`, prevents further transactions from being pushed onto the stack
             * until the current transaction is complete. Once the current transaction is either
             * committed or rolled back, this restriction is automatically lifted.
             *
             * @defaultValue false
             */
            preventFurtherTransactions?: boolean;
            /**
             * If set to `true`, The commit will not create a new snapshot but instead merge with the existing.
             *
             * @defaultValue false
             *
             * @remarks
             * * Ths is used for internal listeners and historical corrections.
             * * This is only read for the top transaction.
             * * This should generally be avoided as the audits and history are lost.
             */
            forceAmend?: boolean;
            /**
             * Stored with the commit.
             */
            meta?: Record<string, string>;
            /**
             * Used to record audit points.
             */
            operation?: ITransaction.Operation<PARAMS>;
            viewAfter?: VIEW | ((prev: VIEW) => VIEW);
            viewBefore?: VIEW | ((prev: VIEW) => VIEW);
        }
    }
}
declare module "transaction/Transaction" {
    import { IListener } from "listener/index";
    import { ITransaction } from "transaction/ITransaction";
    interface CommitRecord {
        id?: string;
        description?: string;
        meta?: Record<string, string>;
        timestamp: number;
        author?: any;
        states?: Map<any, any>;
        operation?: ITransaction.Operation<any>;
        viewBefore?: Record<string, any>;
        viewAfter?: Record<string, any>;
        previousId?: string;
        version: number;
    }
    interface CommitContainer {
        record: CommitRecord;
        commit: ITransaction.ICommit;
    }
    /**
     * Events are never fired on sub transactions. Only when making changes to the root
     * either directly or through a final commit. Any models that want to fire non transactional
     * events should do this directly.
     */
    export class TransactionStore implements ITransaction.IStore {
        protected _listeners: Set<ITransaction.IListeners>;
        protected _listenersState: Map<any, Set<ITransaction.IStateListener>>;
        protected _commits: Map<string, CommitContainer>;
        protected _transactionStack: AbstractTransaction[];
        protected _transactionOpen: boolean;
        protected _locked: boolean;
        protected _isSync: boolean;
        protected _isTransient: boolean;
        protected _author: any;
        protected _current: CommitContainer;
        protected _pending: CommitContainer;
        protected _cacheModel: any;
        protected _cacheState: any;
        protected _states: Map<any, any>;
        constructor(options?: ITransaction.StoreConstructorOptions);
        /**
         * Sets the transaction store to be synchronous or asynchronous.
         *
         * @param sync
         *
         * @remarks
         * This is used for unit tests only.
         */
        static setDefaultSync: (sync: boolean) => void;
        /** {@inheritDoc ITransaction.IStore.getLog} */
        getLog(commitId: string, max?: number): ITransaction.ICommit[];
        /** {@inheritDoc ITransaction.IStore.getCommitCount} */
        getCommitCount(): number;
        /** {@inheritDoc ITransaction.IStore.isOpenTransaction} */
        isOpenTransaction(): boolean;
        /** {@inheritDoc ITransaction.IStore.getView} */
        getPendingView(): Record<string, any> | null;
        /** {@inheritDoc ITransaction.IStore.getState} */
        getState<STATE = any>(model: any): Readonly<STATE>;
        /** {@inheritDoc ITransaction.IStore.getCurrentCommit} */
        getCurrentCommit(): ITransaction.ICommit;
        /** {@inheritDoc ITransaction.IStore.restore} */
        restore(commitId: string, options?: ITransaction.RestoreOptions): ITransaction.ICommit;
        /** {@inheritDoc ITransaction.IStore.revert} */
        revert(commitId: string, options?: ITransaction.RestoreOptions): ITransaction.ICommit;
        protected _getCommitContainer(commitId: string, options?: ITransaction.RestoreOptions): CommitContainer;
        protected _pruneForwards(_commitId: string): void;
        /** {@inheritDoc ITransaction.IStore.beginCommit} */
        beginCommit(options?: ITransaction.StoreOperationOptions, onClose?: ITransaction.CloseCallback): ITransaction;
        /** {@inheritDoc ITransaction.IStore.doBatch} */
        doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: ITransaction.StoreOperationOptions, onClose?: ITransaction.CloseCallback): Promise<R> | R;
        /** {@inheritDoc ITransaction.IStore.remove} */
        remove(model: any): boolean;
        /** {@inheritDoc ITransaction.IStore.addListener} */
        addListener(listener: ITransaction.IListeners): IListener.Remove;
        /** {@inheritDoc ITransaction.IStore.addStateListener} */
        addStateListener<State = any, View = any>(model: any, listener: ITransaction.IStateListener<State, View>): IListener.Remove;
        protected dispatchEvents(dispatcher: () => void, async?: boolean): void;
        protected _commitRecord(container: CommitContainer, states: Map<any, any>, forceAmend: boolean): void;
        _notifyStates(event: keyof ITransaction.IStateListener, container: CommitContainer, states: Map<any, any>, view?: Record<string, any>, isRevert?: boolean, isRestore?: boolean, async?: boolean): void;
        _notify(event: keyof ITransaction.IListeners, commit: ITransaction.ICommit, async?: boolean): void;
    }
    abstract class AbstractTransaction implements ITransaction {
        protected _states: Map<any, any>;
        protected _description: string;
        protected _meta: Record<string, string>;
        protected _children: Set<AbstractTransaction>;
        protected _depth: number;
        protected _descriptions: string[];
        protected _container: CommitContainer;
        protected _closed: boolean;
        constructor(container: CommitContainer, options: ITransaction.StoreOperationOptions);
        /** {@inheritDoc ITransaction.getView} */
        getView(): Record<any, string>;
        /** {@inheritDoc ITransaction.getState} */
        abstract getState<STATE = any>(model: any): STATE;
        /** {@inheritDoc ITransaction.rollback} */
        abstract rollback(): ITransaction;
        /** {@inheritDoc ITransaction.getParent} */
        abstract getParent(): ITransaction;
        /** {@inheritDoc ITransaction.getId} */
        abstract getId(): string;
        /** {@inheritDoc ITransaction.getDepth} */
        getDepth(): number;
        /** {@inheritDoc ITransaction.getDescription} */
        getDescription(): string;
        /** {@inheritDoc ITransaction.getStates} */
        getStates(): Map<any, any>;
        /** {@inheritDoc ITransaction.beginTransaction} */
        beginTransaction(options?: ITransaction.StoreOperationOptions, onClose?: ITransaction.CloseCallback): ITransaction;
        /** {@inheritDoc ITransaction.updateState} */
        updateState<STATE = any>(model: any, state: Readonly<Partial<STATE>> | ((prev: Readonly<STATE>) => Readonly<STATE>)): STATE;
        /** {@inheritDoc ITransaction.commit} */
        commit(options?: ITransaction.StoreOperationOptions): ITransaction;
        /** {@inheritDoc ITransaction.isClose} */
        isClose(): boolean;
        protected _ensureOpen(): void;
        _removeChild(child: AbstractTransaction): void;
        protected _mergeStates(statesChild: Map<any, any>): Map<any, any>;
    }
}
declare module "transaction/TransactionUndoManager" {
    import { UndoManager } from '@sheetxl/utils';
    import { ITransaction } from "transaction/index";
    /**
     * UndoManager that wraps transaction commits and restores these.
     */
    export class TransactionUndoManager extends UndoManager {
        private _transactions;
        private _removeLister;
        constructor(transactions?: ITransaction.IStore, maxStack?: number);
        clear(): void;
        /**
         * Close the undo manager and remove the listener.
         */
        close(): void;
    }
}
declare module "transaction/index" {
    export * from "transaction/ITransaction";
    export * from "transaction/Transaction";
    export * from "transaction/TransactionUndoManager";
}
declare module "resource/IResource" {
    import type { JSONSerializableAsync } from '@sheetxl/utils';
    /**
     * A resource is an item referenced elsewhere with the application.
     * This will track when a resource is no longer being used and can be removed.
     */
    export interface IResource extends JSONSerializableAsync<IResource.JSON> {
        /**
         * Returns the resource as a Promise to array buffer.
         */
        toBuffer(): Promise<ArrayBuffer>;
        /**
         * The mimetype of the resource.
         */
        getType(): Promise<string>;
        /**
         * An optional name for the resource.
         */
        getName(): string | null;
        /**
         * For saving to json resources.
         */
        toJSONAsync(): Promise<IResource.JSON>;
        /**
         * Add a reference to the resource.
         * @param ref The object to strongly hold the resource.
         */
        addReference(ref: any): void;
        /**
         * Delete a reference to the resource.
         * @param ref
         */
        deleteReference(ref: any): void;
        /**
         * This does not follow the standard listener pattern and is only called once.
         * @param listener
         */
        addUnloadListener(listener: IResource.IUnloadListener): void;
        /**
         * `true` if the resource if all references have been deleted.
         */
        isClosed(): boolean;
        /**
         * For runtime type checking.
         */
        readonly isIResource: true;
    }
    /**
     * {@inheritDoc IResource}
     * @see
     * ### **Interface**
     *
     * {@link IResource}
     */
    export namespace IResource {
        interface IUnloadListener {
            onUnload: (ref: IResource) => void;
        }
        interface JSON {
            /**
             * A type for the data.
             */
            type?: string;
            /**
             * A base64 encoded string of the data.
             */
            base64: string;
            /**
             * The name of the resource.
             * This is optional but if provided then resource lookup will use this as a cache key.
             */
            name?: string;
        }
    }
}
declare module "resource/IResourceCollection" {
    import type { JSONSerializableAsync, FetchArgs } from '@sheetxl/utils';
    import type { ICollection } from "type/index";
    import type { IResource } from "resource/IResource";
    /**
     * Collections of {@link IResource}.
     */
    export interface IResourceCollection extends ICollection<IResource> {
        /**
         * Add a resource to a collection with an initial reference.
         * @param resource
         * @remarks
         * Resources are not removed from the the collection. They are autoGCed when there are no references.
         */
        add(resource: string | IResource | IResourceCollection.AddOptions): IResource;
        /**
         * Returns a list of all resources in the collection.
         * @param options
         */
        getItems(options?: ICollection.GetItemsOptions): IResource[];
        /**
         * Used for saving resource. Returns a visitor that will allow for a toJSON that
         * will only save the resource that were accessed within the persist scope.
         */
        beginPersist(): IResourceCollection.IPersistScope<IResource.JSON>;
    }
    /**
     * {@inheritDoc IResourceCollection}
     * @see
     * ### **Interface**
     *
     * {@link IResourceCollection}
     */
    export namespace IResourceCollection {
        /**
         * When adding a shared source there are a number of ways to create it
         * Either from a base64 string, a buffer, a fetch, or a custom resolve function.
         */
        interface AddOptions {
            /**
             * An encoding for the resource. One and only of these should be provided
             */
            base64?: string | Promise<string>;
            fetch?: string | FetchArgs;
            buffer?: ArrayBuffer | Promise<ArrayBuffer> | (() => ArrayBuffer | Promise<ArrayBuffer>);
            file?: File | Promise<File>;
            /**
             * Type type of the resource.
             *
             * @remarks
             * This must be a known type
             */
            type?: string;
            /**
             * The name of the resource.
             * This is optional and purely for human consumption and is not used by the system.
             */
            name?: string;
        }
        interface GetItemsOptions extends ICollection.GetItemsOptions {
        }
        interface IPersistScope<J extends IResource.JSON> {
            /**
             * For a resource this will return a number that can be used to reference the resource in the persisted json.
             * @param resource
             */
            toResourceId(resource: JSONSerializableAsync<J>): number | null;
            /**
             * For a given resourceId this will return the resource.
             * @param resourceId
             */
            fromResourceId(resourceId: number): JSONSerializableAsync<J> | null;
            /**
             * Called when done persisting.
             */
            endPersist(): void;
            /**
             * Loads the json.
             * @param json
             */
            fromJSON(json: J[]): void;
            /**
             * This can be called multiple times.
             */
            toJSONAsync(): Promise<J[]>;
        }
    }
}
declare module "resource/_ResourceMessages" {
    export const ERROR_DUPLICATE_DATA_VALUES: string;
    export const ERROR_NO_DATA_VALUES: string;
    export const CLOSED_MODEL: string;
}
declare module "resource/Resource" {
    import { IResource } from "resource/IResource";
    import { IResourceCollection } from "resource/IResourceCollection";
    export class Resource implements IResource {
        private _name;
        private _refs;
        private _listeners;
        private _isClosed;
        private _asArrayBufferResolve;
        private _asArrayBuffer;
        private _type;
        constructor(options: IResourceCollection.AddOptions);
        /** {@inheritDoc IResource.getName} */
        getName(): string;
        /** {@inheritDoc IResource.toJSONAsync} */
        toJSONAsync(): Promise<IResource.JSON>;
        /** {@inheritDoc IResource.toBuffer} */
        toBuffer(): Promise<ArrayBuffer>;
        /** {@inheritDoc IResource.getType} */
        getType(): Promise<string>;
        /** {@inheritDoc IResource.addReference} */
        addReference(ref: any): void;
        /** {@inheritDoc IResource.deleteReference} */
        deleteReference(ref: any): void;
        /** {@inheritDoc IResource.addUnloadListener} */
        addUnloadListener(listener: IResource.IUnloadListener): void;
        /** {@inheritDoc IResource.isIResource} */
        get isIResource(): true;
        /** {@inheritDoc IResource.isClosed} */
        isClosed(): boolean;
    }
}
declare module "resource/ResourceCollection" {
    import { IResource } from "resource/IResource";
    import { IResourceCollection } from "resource/IResourceCollection";
    export class ResourceCollection implements IResourceCollection {
        private _resources;
        private _persistOpen;
        constructor();
        /** {@inheritDoc IResourceCollection.add} */
        add(res: string | IResource | IResourceCollection.AddOptions): IResource;
        /** {@inheritDoc IResourceCollection.getItems} */
        getItems(options?: IResourceCollection.GetItemsOptions): IResource[];
        /** {@inheritDoc IResourceCollection.getCount} */
        getCount(): number;
        /** {@inheritDoc IResourceCollection.beginPersist} */
        beginPersist(): IResourceCollection.IPersistScope<IResource.JSON>;
    }
}
declare module "resource/index" {
    export * from "resource/IResource";
    export * from "resource/Resource";
    export * from "resource/IResourceCollection";
    export * from "resource/ResourceCollection";
}
declare module "model/IModel" {
    import type { ITransaction } from "transaction/index";
    import type { IListener } from "listener/index";
    /**
     * A model interface is a interface that has:
     *
     * 1. Eventing
     * 2. Transactional
     * 3. Potentially delete
     * 4. Potentially readonly
     */
    export interface IModel<L extends IModel.IListeners = IModel.IListeners> extends ITransaction.ITransactional {
        /**
         * Add Listeners.
         *
         * @see
         * {@link IListener.ISource.addListeners}
         */
        addListeners(listeners: L, options?: IListener.Options): IListener.Remove;
        /**
         * Delete the item.
         *
         * @remarks
         * Not all objects can be deleted.
         */
        delete?(options?: ITransaction.OperationOptions): void;
        /**
         * If the model unable to be modified.
         */
        isReadOnly(): boolean;
        /**
         * If the model unable to be modified.
         */
        isDeleted(): boolean;
        /**
         * Returns an immutable type string.
         */
        getType(): string;
        /**
         * For runtime type checking.
         */
        readonly isIModel: true;
    }
    /**
     * {@inheritDoc IModel}
     * @see
     * ### **Interface**
     *
     * {@link IModel}
     */
    export namespace IModel {
        /**
         * IListener for {@link IModel} events.
         */
        interface Events {
            /**
             * Called when any state has been modified.
             */
            onAnyChange?(source: IModel): void;
            /**
             * Called when the readOnly status is updated.
             */
            onReadOnlyChange?(source: IModel): void;
            /**
             * Called when the model has been deleted.
             */
            onDelete?(source: IModel): void;
            /**
             * Called when the transaction is closed.
             */
            onClose?(source: IModel): void;
            /**
             * Called when the state has been updated due to a undo/redo and a rerender is required.
             */
            onInvalidated?(source: IModel): void;
        }
        interface IListeners extends IListener.Callbacks<IModel, IModel.Events> {
        }
        type DeletedCallback = () => void;
        type ReadOnlyCallback = () => void;
        interface ConstructorOptions<J> {
            /**
             * Use for the creation transaction description.
             */
            createDescription?: string;
            /**
             * The type of the model.
             */
            type?: string;
            /**
             * If the item is readonly.
             */
            isReadOnly?(): boolean;
            /**
             * Notify if the readonly has been updated from the container.
             * @param callback
             */
            setContainerReadOnlyCallback?(callback: IModel.ReadOnlyCallback): void;
            /**
             * Delete from the container.
             */
            deleteFromContainer?(options?: ITransaction.OperationOptions): void;
            /**
             * A transaction store that can be used to undo/redo changes to the model.
             */
            transactions?: ITransaction.IStore;
            /**
             * JSON state to load.
             */
            json?: J;
        }
    }
}
declare module "model/_ModelMessages" {
    export const MODEL_CLOSED = "Model has been closed. No further operations are allowed.";
    export const ERROR_READONLY = "We can't update. The item is read only.";
    export const CREATE_DESCRIPTION = "Create Model";
    export const NAME_REQUIRED = "Name is required";
    export const MODEL_DELETED = "Model has been deleted.";
}
declare module "listener/ListenerEmitter" {
    import { type ITransaction } from "transaction/index";
    import type { IListener } from "listener/IListener";
    interface Entry<SOURCE, EVENTS> {
        remove?: IListener.Remove;
        listeners: IListener.Callbacks<SOURCE, EVENTS>;
    }
    type EntrySet<SOURCE = any, EVENTS = any> = Set<Entry<SOURCE, EVENTS>>;
    interface Pending<T, SOURCE> {
        commitId: string;
        listeners: IListener.Callback<SOURCE>[];
        removes: IListener.Remove[];
        options: NotifyOptions<T>;
    }
    interface NotifyOptions<T = any> {
        params?: T | null;
        source?: any;
        async?: boolean;
        transactional?: boolean;
    }
    /**
     * Manages Listeners
     *
     * @remarks
     * A few rules to know:
     *
     * * non-transactional listeners are fired after the commit end and are conflated.
     */
    export class ListenerEmitter<SOURCE, EVENTS> {
        protected _transactions: ITransaction.IStore;
        protected _transactionsRemoveListener: IListener.Remove;
        protected _src: SOURCE;
        protected _listeners: EntrySet<SOURCE, EVENTS>;
        protected _pending: Pending<any, SOURCE>[];
        constructor(src: SOURCE, transactions?: ITransaction.IStore);
        /** {@inheritDoc IListener.ISource.addListeners} */
        addListeners(listeners: IListener.Callbacks<SOURCE, EVENTS>, options?: IListener.Options): IListener.Remove;
        protected _doNotify<T = unknown>(listeners: IListener.Callback<SOURCE>[], removes?: IListener.Remove[], options?: NotifyOptions<T>, fired?: Set<IListener.Callback<SOURCE>>): Promise<any>;
        /**
         * Notify listeners.
         */
        notify<T = unknown>(key: keyof EVENTS, options?: NotifyOptions<T>): void | Promise<any>;
        close(): void;
    }
}
declare module "model/AbstractModel" {
    import { ITransaction } from "transaction/index";
    import { IListener } from "listener/index";
    import { IModel } from "model/IModel";
    import { ListenerEmitter } from "listener/ListenerEmitter";
    /**
     * Abstract implement of `IModel`.
     */
    export abstract class AbstractModel<STATE extends AbstractModel.State = AbstractModel.State, JSON extends any = any, VIEW extends AbstractModel.CommitView = AbstractModel.CommitView, EVENTS extends IModel.Events = IModel.Events> implements IModel {
        protected _emitter: ListenerEmitter<AbstractModel, EVENTS>;
        protected _options: IModel.ConstructorOptions<JSON>;
        protected _transactions: ITransaction.IStore;
        protected _transactionsRemoveListener: IListener.Remove;
        protected _closed: boolean;
        constructor(options: IModel.ConstructorOptions<JSON>);
        /** @internal */
        protected _fromJSON(_json: JSON): void;
        isReadOnly(): boolean;
        isDeleted(): boolean;
        getType(): string;
        get isIModel(): true;
        /** @internal */
        protected _processTransactionDone(_transaction: ITransaction): void;
        /** @internal */
        protected _getDescription(): string;
        /** @internal */
        protected _getState(): Readonly<STATE>;
        /** @internal */
        protected _beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
        /** @internal */
        protected _getTransactions(): ITransaction.IStore;
        /** @internal */
        protected _updateState(updateState?: Partial<STATE>, //(prevState: STATE) => STATE,
        options?: ITransaction.OperationOptions, events?: (keyof EVENTS)[]): this;
        /** @internal */
        protected _getEmitter<SOURCE, E extends EVENTS>(): ListenerEmitter<SOURCE, E>;
        /** @internal */
        protected _processInit(): void;
        /** @internal */
        protected _processStateChange(_state: STATE, _view: VIEW, _commit: ITransaction.ICommit): void;
        /** @internal */
        protected _processRestoreOrRevert(_state: STATE, _view: VIEW, _commit: ITransaction.ICommit): void;
        delete(options?: ITransaction.OperationOptions): void;
        /** @internal */
        protected _delete(): void;
        /** @internal */
        protected _processOnContainerDeleted(): void;
        /** @internal */
        protected _processDelete(): void;
        /** @internal */
        protected _processOnContainerReadOnly(): void;
        /** {@inheritDoc IListener.ISource.addListeners} */
        addListeners(listeners: IListener.Callbacks<IModel, EVENTS>, options?: IListener.Options): IListener.Remove;
        /** {@inheritDoc ITransaction.ITransactional.beginCommit} */
        beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
        /** {@inheritDoc ITransaction.ITransactional.doBatch} */
        doBatch<R>(callback: (commit: ITransaction.ICommit) => Promise<R> | R, options?: string | ITransaction.OperationOptions): Promise<R> | R;
        /** {@inheritDoc ITransaction.ITransactional.isClosed} */
        isClosed(): boolean;
        /** {@inheritDoc ITransaction.ITransactional.close} */
        close(): void;
    }
    /**
     * Interfaces for creating `IAnchored`.
     *
     * @see
     * ### **Interface**
     *
     * {@link AbstractModel}
     */
    export namespace AbstractModel {
        interface State {
            isDeleted: boolean;
        }
        interface CommitView {
        }
    }
}
declare module "model/index" {
    export * from "model/IModel";
    export * from "model/AbstractModel";
}
declare module "history/IHistory" {
    import type { ReferenceableClipboard } from '@sheetxl/utils';
    /**
     * Encapsulates functionalities crucial for maintaining a comprehensive version history
     * and audit trail within the spreadsheet application. It provides mechanisms to capture, store,
     * and manage snapshots of the spreadsheet's state at various points in time.
     *
     * The primary motivations behind this namespace are:
     *
     * - **Versioning and Undo/Redo**: Maintain a detailed history of changes, allowing for easy rollback or review.
     * - **Copy/Paste**: Create transferable references.
     * - **Auditing/Change logs**: Enable accountability by tracking who made changes and when they occurred.
     * - **Snapshot Management**: Efficiently capture and restore spreadsheet states for backup,
     *   analysis, or reuse.
     *
     * By offering robust versioning and auditing capabilities, this namespace contributes to a more
     * reliable, transparent, and user-friendly spreadsheet experience.
     */
    export namespace IHistory {
        /**
         * Represents an immutable reference to an `Record`, capturing its content and metadata.
         * @template D The type of the destination for `copyTo`.
         * @template S The type of the source for `getSource``.
         * @template C The type of the coordinates the snapshot is bound to.
         * @template J The type of the JSON for `toJSON`.
         */
        interface ISnapshot<D = any, S = any, C = any, J = any> {
            /**
             * Copies the snapshot to the specified range.
             *
             * @param destination The destination `Snapshot source` where the snapshot will be copied.
             * @param options {@link IHistory.CopyToOptions}
             *
             * @returns A promise that resolves when the copy is complete, or `void` if no asynchronous operation is required.
             */
            copyTo(destination: D, options?: IHistory.CopyToOptions): Promise<C> | C;
            /**
             * The source that created the snapshot.
             * This is used to quickly do comparisons.
             */
            getSource(): S;
            /**
             * Retrieves the coordinates that bound the current snapshot.
             *
             * @remarks
             * Different types of snapshots may have different coordinate systems.
             */
            getCoords?(): Readonly<C>;
            /**
             * Converts the snapshot to a plain text representation.
             *
             * @returns A string or promise resolving to the text representation of the snapshot.
             */
            toText?(): Promise<string> | string;
            /**
             * Converts the snapshot to an HTML representation.
             *
             * @returns A string or promise resolving to the HTML representation of the snapshot.
             */
            toHtml?(): Promise<string> | string;
            /**
             * Converts the snapshot to an image blob.
             *
             * @returns A `Blob` or promise resolving to the image representation of the snapshot.
             */
            toImage?(): Promise<Blob> | Blob;
            /**
             * Converts the snapshot to a JSON object.
             *
             * @returns A JSON object or promise resolving to the JSON representation of the snapshot.
             */
            toJSON?(): Promise<J> | J;
            /**
             * A user friendly name of a the snapshot item.
             */
            getName?(): string;
            /**
             * Return the options used when creating.
             * @remarks
             * This is done so that we can create a copy.
             */
            getMarkOptions(): ReferenceableClipboard.CopyOptions;
            /**
             * For runtime type checking.
             */
            readonly isISnapshot: true;
        }
        /**
         * Options for creating {@link IHistory.ISnapshot}.
         * **PLACEHOLDER**
         */
        interface GetSnapshotOptions {
        }
        /**
         * Copy options for {@link IHistory.ISnapshot}.
         * **PLACEHOLDER**
         */
        interface CopyToOptions extends GetSnapshotOptions {
        }
        /**
         * Interface for objects that supports returning ISnapshot.
         */
        interface ISnapshotSource<D = any, S = any, C = any, J = any> {
            /**
             * Represents an immutable reference to an `ICellRange`, capturing its content and metadata.
             * It may include complex objects such as tables, shapes, images, listeners, or other items.
             */
            getSnapshot(options?: ReferenceableClipboard.CopyOptions): IHistory.ISnapshot<D, S, C, J>;
        }
    }
}
declare module "history/index" {
    export * from "history/IHistory";
}
declare module "hyperlink/IHyperlink" {
    /**
     * Represents a hyperlink for linking to either a URL or a cell address.
     */
    export interface IHyperlink {
        /**
         * Open the hyperlink.
         *
         * @param target Specifies where to open the linked document. DefaultValue `getTarget()`.
         * @param features Passed to the window open context for external resource.
         *
         * @see
         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/open)
         */
        open(target?: '_self' | '_blank', features?: string): Promise<boolean>;
        /**
         * This is either the address or the cell value.
         */
        getDisplayText(): string;
        /**
         * This can be a url or a cell address.
         *
         * @remarks
         * A sheet address needs to start with a #.
         */
        getAddress(): string;
        /**
         * Tet for showing addition information about the link that will be
         * displayed as a tooltip.
         *
         * @remarks
         * Excel has an undocumented tooltip length limit of 255 characters.
         */
        getTooltip(): string;
        /**
         * Specified the target frame when opening this Hyperlink.
         * @defaultValue `newWindow`
         */
        getTarget(): string;
        /**
         * For runtime type checking.
         */
        readonly isIHyperlink: true;
    }
    /**
     * {@inheritDoc IHyperlink}
     * @see
     * ### **Interface**
     *
     * {@link IHyperlink}
     */
    export namespace IHyperlink {
        /**
         * Modifiers describe a partial list of properties that can be set with values or shorthand strings.
         */
        type Modifiers = Partial<IHyperlink.Properties>;
        /**
         * Used when updating the the value.
         * @see
         * `ICellRange.setHyperlink`
         */
        type Update = IHyperlink.Modifiers | IHyperlink | string | null;
        /**
         * Properties available to `IHyperlinks`.
         */
        interface Properties {
            /** {@inheritDoc IHyperlink.getDisplayText} */
            displayText?: string;
            /** {@inheritDoc IHyperlink.getAddress} */
            address: string;
            /** {@inheritDoc IHyperlink.getTooltip} */
            tooltip?: string;
            /** {@inheritDoc IHyperlink.getTarget} */
            target?: string;
        }
        /**
         * A JSON representation useful for persistence.
         */
        type JSON = Partial<Omit<IHyperlink.Properties, 'displayText'>> | string;
    }
}
declare module "hyperlink/index" {
    export * from "hyperlink/IHyperlink";
}
declare module "comment/IComment" {
    import type { ICellRange } from "cellRange/index";
    /**
     * TODO - Implement IComment.
     * TODO - how to make this threaded?
     * TODO - rationalize this with notes?
     * -Each Comment will have a unique id and a parent that it is a reply to.
     *
     * ? How to add root range.addComment(content) ? (only allows for 1 root)
    
     * https://learn.microsoft.com/en-us/javascript/api/office-scripts/excelscript/excelscript.contenttype?view=office-scripts
     *
     * Excel has a resolved/done status
     * Excel has mentions?
     */
    export interface IComment {
        getContent(): string;
        setContent(content: string): void;
        getUserId(): string;
        delete(): void;
        getCreationDate(): Date;
    }
    /**
     * {@inheritDoc IComment}
     * @see
     * ### **Interface**
     *
     * {@link IComment}
     */
    export namespace IComment {
        interface Properties {
            /**
             * The content of the comment.
             */
            content?: any;
            asNote?: boolean;
        }
        /**
         * For persisting.
         */
        interface JSON extends IComment.Properties {
            /**
             * Required for referencing in replies.
             */
            id: string;
            /**
             * The id for author or the comment the comment.
             */
            personId: string;
            /**
             * The reference for the comment.
             */
            ref?: ICellRange.RefJSON;
            /**
             * If this is a reply, the id of the parent comment.
             */
            parentId?: string;
            /**
             * An unordered list of mention ids.
             * @remarks
             * These are not order dependent.
             */
            mentionsIds?: string[];
            /**
             * The date the comment was created.
             */
            dt?: Date | string;
            /**
             * The comment has been marked as done.
             */
            done?: boolean;
        }
        interface MentionJSON {
            /**
             * The id for the mention.
             */
            id: string;
            /**
             * The id for author or the comment the comment.
             */
            personId: string;
            /**
             * The start of the mention.
             */
            startIndex?: number;
            /**
             * The length of the mention.
             */
            length?: number;
        }
        /**
         * Represents a reference to person. Either in a comment, protection clause or mention.
         */
        interface PersonJSON {
            /**
             * A human readable string for the name.
             */
            displayName: string;
            /**
             * A unique identifier.
             */
            id: string;
            /**
             * The id for authorizing against the providerId.
             */
            userId?: string;
            /**
             * The system that provided the person.
             */
            providerId?: string;
        }
    }
}
declare module "comment/index" {
    export * from "comment/IComment";
}
declare module "fill/IFill" {
    import type { Properties as CSSProperties } from 'csstype';
    import type { Rectangle, Bounds } from '@sheetxl/utils';
    import { IColor } from "color/index";
    import { IStyle } from "style/index";
    /**
     * Defines how an area or shape is filled with color or a pattern.
     */
    export interface IFill {
        /**
         * Returns the type of fill used.
         */
        getType(): IFill.Type;
        /**
         * Returns the fill as a set of css string that are suitable for css.
         * @remarks
         *
         * Not all fill styles will offer an exact css equivalent.
         * Additionally due to the nature of css having different properties for the same logic value
         * (for example color, backgroundColor)
         */
        toCSS(darkMode?: boolean, bounds?: Bounds): CSSProperties;
        /**
         * Returns the fill as a JSON object.
         */
        toJSON(): IFill.JSON;
        /**
         * For type checking.
         */
        readonly isIFill: true;
    }
    /**
     * {@inheritDoc IFill}
     * @see
     * ### **Interface**
     *
     * {@link IFill}
     */
    export namespace IFill {
        /**
         * Types of fill styles used for painting surfaces.
         */
        const Type: {
            /**
             * No fill.
             */
            readonly None: "none";
            /**
             * A solid color.
             */
            readonly Solid: "solid";
            /**
             * A gradient
             */
            readonly Gradient: "gradient";
            /**
             * A pattern.
             */
            readonly Pattern: "pattern";
            /**
             * An Image.
             * @remarks
             * * Not support in cells. This is currently only support in drawML (charts, shapes, powerpoint).
             */
            readonly Image: "pattern";
            /**
             * An Image.
             * @remarks
             * * Not support in cells. This is currently only support in drawML (charts, shapes, powerpoint).
             */
            readonly Background: "background";
            /**
             * Inherit the fill from the group.
             * @remarks
             * * This has no effect if not in a group.
             * * Not support in cells. This is currently only support in drawML (charts, shapes, powerpoint).
             */
            readonly Group: "group";
            /**
             * For allowing custom types.
             * @remarks
             * Placeholder and not yet implemented. This will have a function callback.
             */
            readonly Custom: "custom";
        };
        type Type = typeof Type[keyof typeof Type];
        /**
         * Represents the types of gradients that can be applied to shapes or other elements.
         */
        const GradientType: {
            /**
             * A linear gradient, where colors transition along a straight line.
             */
            readonly Linear: "linear";
            /**
             * A path-based gradient, where colors transition along a defined path.
             *
             * @remarks
             * * Currently not directly supported by the rendering engine.
             */
            readonly Path: "path";
            /**
             * A circular gradient, where colors transition radially from a central point.
             *
             * @remarks
             * Not supported by Excel.
             */
            readonly Circular: "circular";
            /**
             * A rectangular gradient, where colors transition within a rectangular shape.
             *
             * @remarks
             * Not supported by Excel or SheetXL rendering engine.
             */
            readonly Rect: "rect";
        };
        type GradientType = typeof GradientType[keyof typeof GradientType];
        /**
         * Specifies how a tile is mirrored or flipped when filling a shape or container.
         */
        const TileMirror: {
            /**
             * No mirroring is applied.
             */
            readonly None: "none";
            /**
             * The tile is mirrored vertically (flipped along the y-axis).
             */
            readonly Vertical: "v";
            /**
             * The tile is mirrored horizontally (flipped along the x-axis).
             */
            readonly Horizontal: "h";
            /**
             * The tile is mirrored both vertically and horizontally.
             */
            readonly Both: "b";
        };
        type TileMirror = typeof TileMirror[keyof typeof TileMirror];
        /**
         * Contains the built-in pattern types.
         *
         * @remarks
         * **TODO** - Rationalize with full drawML list.
         */
        const BuiltInSheetPattern: {
            /**
             * 'None' style
             *
             * @remarks
             * Acts like a none fill
             */
            readonly None: "none";
            /**
             * 'None' style
             *
             * @remarks
             * Acts like a solid fill
             */
            readonly Solid: "solid";
            /**
             * 'Dark Gary' style
             */
            readonly DarkGray: "darkGray";
            /**
             * 'Medium Gray' style
             */
            readonly MediumGray: "mediumGray";
            /**
             * 'Light Gray' style
             */
            readonly LightGray: "lightGray";
            /**
             * 'Gray 0.0625' style
             */
            readonly Gray0625: "gray0625";
            /**
             * 'Gray 0.125' style
             */
            readonly Gray125: "gray125";
            /**
             * 'Dark Horizontal' style
             */
            readonly DarkHorizontal: "darkHorizontal";
            /**
             * 'Dark Vertical' style
             */
            readonly DarkVertical: "darkVertical";
            /**
             * 'Dark Down' style
             */
            readonly DarkDown: "darkDown";
            /**
             * 'Dark Up' style
             */
            readonly DarkUp: "darkUp";
            /**
             * 'Dark Grid' style
             */
            readonly DarkGrid: "darkGrid";
            /**
             * 'Dark Trellis' style
             */
            readonly DarkTrellis: "darkTrellis";
            /**
             * 'Light Horizontal' style
             */
            readonly LightHorizontal: "lightHorizontal";
            /**
             * 'Light Vertical' style
             */
            readonly LightVertical: "lightVertical";
            /**
             * 'Light Down' style
             */
            readonly LightDown: "lightDown";
            /**
             * 'Light Up' style
             */
            readonly LightUp: "lightUp";
            /**
             * 'Light Grid' style
             */
            readonly LightGrid: "lightGrid";
            /**
             * 'Light Trellis' style
             */
            readonly LightTrellis: "lightTrellis";
            /**
             * 'Custom' style
             * @remarks
             * Then a pattern must be provided.
             *
             * **Not yet implemented**
             */
            readonly Custom: "custom";
        };
        type BuiltInSheetPattern = typeof BuiltInSheetPattern[keyof typeof BuiltInSheetPattern];
        interface Properties {
            /**
             * @see
             * {@link IFill.getType}
             */
            type: IFill.Type;
        }
        /**
         * Modifiers describe a partial list of properties that can be set with values or shorthand strings.
         */
        type Modifiers = Partial<IFill.Properties>;
        /**
         * Options for updating a fill.
         */
        type Update = IFill | Modifiers | string | null;
        /**
         * A JSON representation useful for persistence.
         */
        interface JSON extends Properties {
        }
        /**
         * No fill is applied; the area is transparent.
         */
        interface INone extends IFill {
            /**
             * Fill type is always {@link IFill.Type.None}.
             */
            getType(): typeof IFill.Type.None;
            toJSON(): NoneJSON;
        }
        interface NoneProperties extends IFill.Properties {
            /**
             * @see
             * {@link IFill.ISolid.getColor}
             */
            type: typeof IFill.Type.None;
        }
        interface NoneJSON extends NoneProperties {
        }
        /**
         * A single color fill.
         */
        interface ISolid extends IFill {
            /**
             * Fill type is always {@link IFill.Type.Solid}.
             */
            getType(): typeof IFill.Type.Solid;
            /**
             * Returns the color of the fill.
             */
            getColor(): IColor;
            /**
             * Sets the stroke color.
             *
             * @param color The stroke color.
             */
            setColor(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IFill.ISolid;
        }
        interface SolidProperties<C = IColor.Serializable> extends IFill.Properties {
            /**
             * @see
             * {@link IFill.ISolid.getColor}
             */
            color: C;
            /**
             * @see
             * {@link IFill.ISolid.getType}
             */
            type: typeof IFill.Type.Solid;
        }
        interface SolidJSON extends SolidProperties<string> {
        }
        interface TileProperties {
            /**
             * @see
             * {@link IFill.ITile.getAlign}
             */
            align?: string;
            /**
             * @see
             * {@link IFill.ITile.getMirror}
             */
            mirror?: IFill.TileMirror;
            /**
             * @see
             * {@link IFill.ITile.getBounds}
             */
            bounds?: Rectangle;
            /**
             * Create blur noise at the edges of the tile.
             *
             * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stitchTiles}
             */
            stitch?: boolean;
        }
        /**
         * Represents a tile used for filling shapes or other elements with a repeating pattern.
         */
        interface ITile {
            /**
             *  Specifies the alignment of the tile within its container.
             *
             *  @remarks
             *  - Possible values: 'tl', 't', 'tr', 'l', 'c', 'r', 'bl', 'b', 'br' (representing top-left, top, top-right, etc.)
             */
            getAlign(): string;
            /**
             *  Determines how the tile is mirrored or flipped when filling the container.
             */
            getMirror(): IFill.TileMirror;
            /**
             *  Defines the rectangular bounds of the tile pattern.
             */
            getBounds(): Rectangle;
        }
        interface GradientStopProperties<C = IColor.Serializable> {
            /**
             * @see
             * {@link IFill.IGradientStop.getOffset}
             */
            offset?: number;
            /**
             * @see
             * {@link IFill.IGradientStop.getColor}
             */
            color: C;
        }
        /**
         * Indicates a color change occurs.
         */
        interface IGradientStop {
            /**
             * If not specified then the offsets will be equally weighted based off of the number of stops.
             */
            getOffset(): number;
            /**
             * The color of the stop.
             */
            getColor(): IColor;
        }
        interface GradientProperties<C = IColor.Serializable> extends IFill.Properties {
            /**
             * @see
             * {@link IFill.IGradient.getType}
             */
            type: typeof IFill.Type.Gradient;
            /**
             * @see
             * {@link IFill.IGradient.getStops}
             */
            stops?: (GradientStopProperties<C> | C)[];
            /**
             * @see
             * {@link IFill.IGradient.getGradientType}
             */
            gradientType?: IFill.GradientType;
            /**
             * @see
             * {@link IFill.IGradient.getAngle}
             */
            angle?: number;
            /**
             * @see
             * {@link IFill.IGradient.getFillTo}
             */
            fillTo?: Rectangle;
        }
        /**
         * A gradient fill, where colors transition across the area.
         */
        interface IGradient extends IFill {
            /**
             * Fill type is always {@link IFill.Type.Gradient}.
             */
            getType(): typeof IFill.Type.Gradient;
            /**
             * The stops for the gradient.
             *
             * @remarks
             * * This must be at least two stops.
             */
            getStops(): IGradientStop[];
            /**
             * Sets the gradient stops.
             *
             * @param stops The gradient stops.
             */
            setStops(stops: (IGradientStop | IColor.Serializable | null)[], options?: IStyle.UpdateOptions): IFill.IGradient;
            /**
             * The type of gradient.
             * @defaultValue GradientType.Linear
             */
            getGradientType(): IFill.GradientType;
            /**
             * Sets the gradient type.
             *
             * @param type The gradient type.
             */
            setGradientType(type: IFill.GradientType | null, options?: IStyle.UpdateOptions): IFill.IGradient;
            /**
             * The angle of the gradient in degrees if gradient type is linear.
             */
            getAngle(): number;
            /**
             * Sets the rotation
             *
             * @param angle The angle
             */
            setAngle(angle: number | null, options?: IStyle.UpdateOptions): IFill.IGradient;
            /**
             * Used for path and circular gradients.
             */
            getFillTo(): Rectangle;
            /**
             * Sets the fill area for the gradient.
             *
             * @param fillTo The fill area.
             */
            setFillTo(fillTo: Rectangle | null, options?: IStyle.UpdateOptions): IFill.IGradient;
            /**
             * Converts the gradient fill to a JSON representation.
             */
            toJSON(): GradientJSON;
        }
        interface GradientJSON extends GradientProperties<string> {
        }
        /**
         * A pattern fill, using a repeating pattern to fill the area.
         */
        interface IPattern extends IFill {
            /**
             * Fill type is always {@link IFill.Type.Pattern}.
             */
            getType(): typeof IFill.Type.Pattern;
            /**
             * The foreground color for the pattern.
             */
            getForeground(): IColor;
            /**
             * Sets the foreground color.
             *
             * @param color The foreground color.
             */
            setForeground(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IFill.IPattern;
            /**
             * The background color for the pattern.
             */
            getBackground(): IColor;
            /**
             * Sets the background color.
             *
             * @param color The background color.
             */
            setBackground(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IFill.IPattern;
            /**
             * The type of pattern used.
             */
            getPatternType(): IFill.BuiltInSheetPattern;
            /**
             * Sets the pattern type.
             *
             * @param type The pattern type.
             */
            setPatternType(type: IFill.BuiltInSheetPattern | null, options?: IStyle.UpdateOptions): IFill.IPattern;
            /**
             * Converts the pattern fill to a JSON representation.
             */
            toJSON(): PatternJSON;
        }
        interface PatternProperties<C = IColor.Serializable> extends IFill.Properties {
            /**
             * @see
             * {@link IFill.IPattern.getType}
             */
            type: typeof IFill.Type.Pattern;
            /**
             * @see
             * {@link IFill.IPattern.getForeground}
             */
            foreground?: C;
            /**
             * @see
             * {@link IFill.IPattern.getBackground}
             */
            background?: C;
            /**
             * @see
             * {@link IFill.IPattern.getPatternType}
             */
            patternType?: IFill.BuiltInSheetPattern;
        }
        interface PatternJSON extends PatternProperties<string> {
        }
    }
}
declare module "fill/index" {
    export * from "fill/IFill";
}
declare module "text/AutoNumberingScheme" {
    export enum AutoNumberingSchemeType {
        /**
         * Lowercase alphabetic character enclosed in parentheses. Example: (a), (b),
         * (c), ...
         */
        alphaLcParenBoth = 0,
        /**
         * Uppercase alphabetic character enclosed in parentheses. Example: (A), (B),
         * (C), ...
         */
        alphaUcParenBoth = 1,
        /**
         * Lowercase alphabetic character followed by a closing parenthesis. Example:
         * a), b), c), ...
         */
        alphaLcParenRight = 2,
        /**
         * Uppercase alphabetic character followed by a closing parenthesis. Example:
         * A), B), C), ...
         */
        alphaUcParenRight = 3,
        /**
         * Lowercase Latin character followed by a period. Example: a., b., c., ...
         */
        alphaLcPeriod = 4,
        /**
         * Uppercase Latin character followed by a period. Example: A., B., C., ...
         */
        alphaUcPeriod = 5,
        /**
         * Arabic numeral enclosed in parentheses. Example: (1), (2), (3), ...
         */
        arabicParenBoth = 6,
        /**
         * Arabic numeral followed by a closing parenthesis. Example: 1), 2), 3), ...
         */
        arabicParenRight = 7,
        /**
         * Arabic numeral followed by a period. Example: 1., 2., 3., ...
         */
        arabicPeriod = 8,
        /**
         * Arabic numeral. Example: 1, 2, 3, ...
         */
        arabicPlain = 9,
        /**
         * Lowercase Roman numeral enclosed in parentheses. Example: (i), (ii), (iii),
         * ...
         */
        romanLcParenBoth = 10,
        /**
         * Uppercase Roman numeral enclosed in parentheses. Example: (I), (II), (III),
         * ...
         */
        romanUcParenBoth = 11,
        /**
         * Lowercase Roman numeral followed by a closing parenthesis. Example: i), ii),
         * iii), ...
         */
        romanLcParenRight = 12,
        /**
         * Uppercase Roman numeral followed by a closing parenthesis. Example: I), II),
         * III), ....
         */
        romanUcParenRight = 13,
        /**
         * Lowercase Roman numeral followed by a period. Example: i., ii., iii., ...
         */
        romanLcPeriod = 14,
        /**
         * Uppercase Roman numeral followed by a period. Example: I., II., III., ...
         */
        romanUcPeriod = 15,
        /**
         * Double byte circle numbers.
         */
        circleNumDbPlain = 16,
        /**
         * Wingdings black circle numbers.
         */
        circleNumWdBlackPlain = 17,
        /**
         * Wingdings white circle numbers.
         */
        circleNumWdWhitePlain = 18,
        /**
         * Double-byte Arabic numbers with double-byte period.
         */
        arabicDbPeriod = 19,
        /**
         * Double-byte Arabic numbers.
         */
        arabicDbPlain = 20,
        /**
         * Simplified Chinese with single-byte period.
         */
        ea1ChsPeriod = 21,
        /**
         * Simplified Chinese.
         */
        ea1ChsPlain = 22,
        /**
         * Traditional Chinese with single-byte period.
         */
        ea1ChtPeriod = 23,
        /**
         * Traditional Chinese.
         */
        ea1ChtPlain = 24,
        /**
         * Japanese with double-byte period.
         */
        ea1JpnChsDbPeriod = 25,
        /**
         * Japanese/Korean.
         */
        ea1JpnKorPlain = 26,
        /**
         * Japanese/Korean with single-byte period.
         */
        ea1JpnKorPeriod = 27,
        /**
         * Bidi Arabic 1 (AraAlpha) with ANSI minus symbol.
         */
        arabic1Minus = 28,
        /**
         * Bidi Arabic 2 (AraAbjad) with ANSI minus symbol.
         */
        arabic2Minus = 29,
        /**
         * Bidi Hebrew 2 with ANSI minus symbol.
         */
        hebrew2Minus = 30,
        /**
         * Thai alphabetic character followed by a period.
         */
        thaiAlphaPeriod = 31,
        /**
         * Thai alphabetic character followed by a closing parenthesis.
         */
        thaiAlphaParenRight = 32,
        /**
         * Thai alphabetic character enclosed by parentheses.
         */
        thaiAlphaParenBoth = 33,
        /**
         * Thai numeral followed by a period.
         */
        thaiNumPeriod = 34,
        /**
         * Thai numeral followed by a closing parenthesis.
         */
        thaiNumParenRight = 35,
        /**
         * Thai numeral enclosed in parentheses.
         */
        thaiNumParenBoth = 36,
        /**
         * Hindi alphabetic character followed by a period.
         */
        hindiAlphaPeriod = 37,
        /**
         * Hindi numeric character followed by a period.
         */
        hindiNumPeriod = 38,
        /**
         * Hindi numeric character followed by a closing parenthesis.
         */
        hindiNumParenRight = 39,
        /**
         * Hindi alphabetic character followed by a period.
         */
        hindiAlpha1Period = 40
    }
}
declare module "text/Bullet" {
    import { Bounds } from '@sheetxl/utils';
    import { AutoNumberingSchemeType } from "text/AutoNumberingScheme";
    export interface IBullet {
        readonly fontName: string;
        readonly fontSize: number;
        readonly autoNumberScheme: AutoNumberingSchemeType;
        readonly startAt: number;
        readonly character: string;
        readonly imageScale: number;
        readonly imageNaturalWidth: number;
        readonly imageNaturalHeight: number;
        readonly bounds?: Bounds;
    }
    export class DefaultBullet implements IBullet {
        private _fontName;
        private _fontSize;
        private _autoNumberScheme;
        private _startAt;
        private _character;
        private _imageScale;
        private _imageNaturalWidth;
        private _imageNaturalHeight;
        private _bounds?;
        get fontName(): string;
        get fontSize(): number;
        get autoNumberScheme(): AutoNumberingSchemeType;
        get startAt(): number;
        get character(): string;
        get imageScale(): number;
        get imageNaturalWidth(): number;
        get imageNaturalHeight(): number;
        get bounds(): Bounds;
    }
}
declare module "text/TextBoxAlignment" {
    import { ITextFrame } from "text/ITextFrame";
    import { IStyle } from "style/index";
    /**
     * Provided options for aligned text within a bounding box.
     */
    export interface ITextBoxAlignment {
        /**
         * Types of horizontal alignment.
         */
        getHorizontal(): ITextFrame.HorizontalAlignment;
        /**
         * Sets the horizontal alignment
         *
         * @param horizontal The horizontal alignment
         */
        setHorizontal(horizontal: ITextFrame.HorizontalAlignment | null, options?: IStyle.UpdateOptions): ITextBoxAlignment;
        /**
         * Types of horizontal alignment.
         */
        getVertical(): ITextFrame.VerticalAlignment;
        /**
         * Sets the vertical alignment
         *
         * @param vertical The vertical alignment
         */
        setVertical(vertical: ITextFrame.VerticalAlignment | null, options?: IStyle.UpdateOptions): ITextBoxAlignment;
        /**
         * An integer value, where an increment of 1 represents 3 spaces.
         * Indicates the number of spaces (of the normal style font) of indentation for text in a cell.
         *
         * @remarks
         * This is only applied for alignments: left, right, and distributed.
         */
        getIndent(): number;
        /**
         * Sets the indentation
         *
         * @param indent The indentation
         */
        setIndent(indent: number | null, options?: IStyle.UpdateOptions): ITextBoxAlignment;
        /**
         * Indicates additional number of spaces of indentation to adjust for text in a cell.
         */
        getRelativeIndent(): number;
        /**
         * Sets the relative indentation
         *
         * @param relativeIndent The relative indentation
         */
        setRelativeIndent(relativeIndent: number | null, options?: IStyle.UpdateOptions): ITextBoxAlignment;
        /**
         * The behavior for text that does not fit with the cell bounds.
         * @see
         * {@link ITextFrame.Overflow}
         */
        getOverflow(): ITextFrame.Overflow;
        /**
         * Sets the overflow behavior
         *
         * @param overflow The overflow behavior
         */
        setOverflow(overflow: ITextFrame.Overflow | null, options?: IStyle.UpdateOptions): ITextBoxAlignment;
        /**
         * Rotation of the text.
         * @defaultValue 0
         */
        getRotation(): number;
        /**
         * Sets the rotation
         *
         * @param rotation The rotation
         */
        setRotation(rotation: number | null, options?: IStyle.UpdateOptions): ITextBoxAlignment;
        /**
         * If the text should stack vertically instead of horizontally.
         */
        getStacked(): boolean;
        /**
         * Sets the stacked
         *
         * @param stacked The stacked
         */
        setStacked(stacked: boolean | null, options?: IStyle.UpdateOptions): ITextBoxAlignment;
        /**
         * If the cells justified or distributed alignment should be used on the last line of text.
         * (This is typical for East Asian alignments but not typical in other contexts.)
         */
        getJustifyLastLine(): boolean;
        /**
         * Sets the justified last line
         *
         * @param justifyLastLine The justified last line
         */
        setJustifyLastLine(justifyLastLine: boolean | null, options?: IStyle.UpdateOptions): ITextBoxAlignment;
        /**
         * The direction the cell is being read.
         */
        getReadingDirection(): ITextFrame.ReadingDirection;
        /**
         * Sets the reading direction
         *
         * @param readingDirection The reading direction
         */
        setReadingDirection(readingDirection: ITextFrame.ReadingDirection | null, options?: IStyle.UpdateOptions): ITextBoxAlignment;
        toJSON(): ITextBoxAlignment.JSON;
        /**
         * For runtime type checking.
         */
        readonly isITextBoxAlignment: true;
    }
    /**
     * Provided options for aligned text within a bounding box.
     */
    export namespace ITextBoxAlignment {
        /**
         * Text alignment rules for when text is placed in a bounding box.
         * (for example a TableCell or a Shape).
         */
        interface Properties {
            horizontal?: ITextFrame.HorizontalAlignment;
            vertical?: ITextFrame.VerticalAlignment;
            indent?: number;
            relativeIndent?: number;
            overflow?: ITextFrame.Overflow;
            rotation?: number;
            stacked?: boolean;
            justifyLastLine?: boolean;
            readingDirection?: ITextFrame.ReadingDirection;
        }
        interface JSON extends Properties {
        }
        /**
         * Modifiers describe a partial list of properties that can be set with values or shorthand strings.
         */
        type Modifiers = Partial<ITextBoxAlignment.Properties>;
        /**
         * Options for updating an ITextBoxAlignment.
         */
        type Update = ITextBoxAlignment | Modifiers | string | null;
    }
}
declare module "text/ITextFrame" {
    import { TextAlign as CSSTextAlign } from 'csstype';
    import type { Size, Bounds, Rectangle } from '@sheetxl/utils';
    import { TextVisitor } from "text/TextVisitor";
    import { ITextLine } from "text/TextLine";
    import { ITextParagraph } from "text/TextParagraph";
    import { ITextBoxAlignment as _IAlignment } from "text/TextBoxAlignment";
    /**
     * Represents a rectangular container for text and its formatting within a document.
     *
     * A TextFrame allows precise control over the positioning, size (width and height),
     * layout, and appearance of text content.
     */
    export interface ITextFrame {
        readonly wrapped: boolean;
        readonly insets: Rectangle;
        readonly orientation: ITextFrame.Orientation;
        readonly autoFit: ITextFrame.Autofit;
        readonly fontScale: number;
        readonly vertical: boolean;
        readonly columnCount: number;
        readonly columnSpacing: number;
        readonly verticalAlignment: ITextFrame.VerticalAlignment;
        /**
         * This is different then center aligned text.
         */
        readonly horizontalCentered: boolean;
        readonly lineReduction: number;
        readonly isSpaceFirstLastPara: boolean;
        /**
         * Returns the presetTextWarp.
         * TODO - implement this.
        */
        readonly presetTextWarp: string;
        readonly paragraphs: ITextParagraph[];
        visitParas(visitor: TextVisitor): void;
        visitLines(visitor: TextVisitor): void;
        /**
         * Before using the bounds of a textFrame the layout must be called.
         * This will then return a a clone of this ITextFrame that can be
         * placed and rendered.
         *
         * @param dimensions will cause the text to wrap. If bounds are not specified or only a dimension then it will not wrap.
         */
        layout(dimensions?: Partial<Size>): ITextFrame;
        /**
         * This is the bound of a textfield include any whitespace
         */
        readonly bounds: Readonly<Bounds>;
        /**
         * This is the bound of a text not include whitespace
         */
        readonly textBounds: Readonly<Bounds>;
        readonly lines: ITextLine[];
        /**
         * Creates a simple text frame that can be used for rendering and/or measuring.
         * @param text The text to use
         * @param allowWrap If `true` then will try to wrap on natural breaks. Defaults the the current settings.
         */
        createTemporaryTextFrame(text: string, allowWrap?: boolean): ITextFrame;
    }
    /**
     * {@inheritDoc ITextFrame}
     * @see
     * ### **Interface**
     *
     * {@link ITextFrame}
     */
    export namespace ITextFrame {
        namespace IAlignment {
            type Properties = _IAlignment.Properties;
            type JSON = _IAlignment.JSON;
            /**
             * Modifiers describe a partial list of properties that can be set with values or shorthand strings.
             */
            type Modifiers = _IAlignment.Modifiers;
            /**
             * Options for updating an IAlignment.
             */
            type Update = _IAlignment.Update;
        }
        type IAlignment = _IAlignment;
        /**
         * Represents a tab stop within a text frame or paragraph.
         */
        class TabStop {
            /**
             * The position (offset) of the tab stop relative to the left margin of the container, measured in points.
             */
            offset: number;
            /**
             * The alignment of text at the tab stop.
             */
            align: ITextFrame.TabStopAlignment;
        }
        /**
         * Horizontal alignment of text within a cell.
         */
        const HorizontalAlignment: {
            /**
             * Aligned based on the data value.
             * Text data is left-aligned. Numbers, dates, and times are right-aligned. Boolean types are centered.
             */
            readonly General: "general";
            /**
             * Aligned to the left.
             */
            readonly Left: "left";
            /**
             * Aligned in the center.
             */
            readonly Center: "center";
            /**
             * Aligned to the right.
             */
            readonly Right: "right";
            /**
             * Aligned to the left and right margins.
             * Spacing will be inserted between 'words
          .   */
            readonly Justify: "justify";
            /**
             * Each 'word' in each line of text inside the cell is evenly distributed
             * across the width of the cell, with flush right and left margins.
             *
             * When there is also an indent value to apply, both the left and right side
             * of the cell are padded by the indent value.
             * A 'word' is a set of characters with no space character in them.
             * Two lines inside a cell are separated by a carriage return.
             */
            readonly Distributed: "distributed";
            /**
             * The horizontal alignment is centered across multiple cells.
             * The number of cells is determined by the number of consecutive blank cells
             * that also have an alignment of CenterContinuous.
             */
            readonly CenterContinuous: "centerContinuous";
            /**
             * The value of the cell should be repeated across the entire width of the cell.
             * If blank cells to the right also have the fill alignment, they are also filled
             * with the value, using a convention similar to centerContinuous.
             */
            readonly Fill: "fill";
        };
        type HorizontalAlignment = typeof HorizontalAlignment[keyof typeof HorizontalAlignment];
        /**
         * Specifies the vertical alignment of text within a text frame.
         */
        const VerticalAlignment: {
            /**
             * Aligned to the top.
             */
            readonly Top: "top";
            /**
             * Aligned to the center.
             */
            readonly Center: "center";
            /**
             * Aligned to the bottom.
             */
            readonly Bottom: "bottom";
            /**
             * The vertical alignment of lines of text is distributed vertically,
             * where each line of text inside the cell is evenly distributed across the height of the cell,
             * with flush top and bottom margins.
             */
            readonly Justify: "justify";
            /**
             * Just like Justify, expect that all lines with a single word are centered and the last line is also distributed.
             */
            readonly Distributed: "distributed";
        };
        type VerticalAlignment = typeof VerticalAlignment[keyof typeof VerticalAlignment];
        /**
         * Specifies the orientation in which text is displayed.
         */
        const Orientation: {
            /**
             * Horizontal text. This is the default.
             */
            readonly Horizontal: "horizontal";
            /**
             * Vertical orientation.
             *
             * @remarks
             * Each line is 90 degrees rotated clockwise, so it goes from top to bottom; each next line is to the left from
             * the previous one.
             */
            readonly Vertical: "90";
            /**
             * Vertical orientation.
             *
             * @remarks
             * Each line is 270 degrees rotated clockwise, so it goes from bottom to top; each next line is to the right from
             * the previous one.
             */
            readonly Vertical270: "270";
            /**
              * Determines if all of the text is vertical; ('one letter on top of another').
              *
              * **Not Supported**
              */
            readonly Stacked: "stacked";
        };
        type Orientation = typeof Orientation[keyof typeof Orientation];
        /**
         * Specifies the reading order of text within a text frame.
         */
        const ReadingDirection: {
            /**
             * The reading direction is automatically determined based on the text content.
             */
            readonly Auto: "auto";
            /**
             * The reading direction is from left to right.
             */
            readonly LeftToRight: "ltr";
            /**
             * The reading direction is from right to left.
             */
            readonly RightToLeft: "rtl";
        };
        type ReadingDirection = typeof ReadingDirection[keyof typeof ReadingDirection];
        /**
         * The behavior of the text when it exceeds the size of the bounding box.
         */
        const Overflow: {
            /**
             * Visible means that the text will attempt to be visible on overflow.
             * It can still be obscured (either z-index, or another blocking element) or fall out of the viewport.
             */
            readonly Visible: "visible";
            /**
             * Wrap text to keep within the left right margins but may overflow vertically.
             */
            readonly Wrap: "wrap";
            /**
             *  Note - This is not part of the OOXML spec
             */
            readonly Clip: "clip";
            /**
             * Shrinks text to fit within the bounding area
             */
            readonly Shrink: "shrink";
            /** Not OOXML spec - Not support */
            readonly Ellipsis: "ellipsis";
        };
        type Overflow = typeof Overflow[keyof typeof Overflow];
        /**
         * How the text should fit within the bounding area.
         */
        const Autofit: {
            /**
             * Specifies that text within the text body should not be auto-fit to the bounding box.
             * Auto-fitting is when text within a text box is scaled in order to remain inside
             * the text box.
             */
            readonly None: "none";
            /**
             * Specifies that text within the text body should be normally auto-fit to the bounding box.
             * AutoFitting is when text within a text box is scaled in order to remain inside the text box.
             *
             * <p>
             * <em>Example:</em> Consider the situation where a user is building a diagram and needs
             * to have the text for each shape that they are using stay within the bounds of the shape.
             * An easy way this might be done is by using NORMAL autofit
             * </p>
             */
            readonly Normal: "normal";
            /**
             * Specifies that a shape should be auto-fit to fully contain the text described within it.
             * Auto-fitting is when text within a shape is scaled in order to contain all the text inside.
             *
             * <p>
             * <em>Example:</em> Consider the situation where a user is building a diagram and needs to have
             * the text for each shape that they are using stay within the bounds of the shape.
             * An easy way this might be done is by using SHAPE autofit
             * </p>
             */
            readonly Shape: "shape";
        };
        type Autofit = typeof Autofit[keyof typeof Autofit];
        /**
         * Specifies the alignment of a tab stop within a text frame or paragraph.
         */
        const TabStopAlignment: {
            /**
             * The default tab stop alignment, typically left-aligned for left-to-right text and right-aligned for right-to-left text.
             */
            readonly Default: "default";
            /**
             * Aligns text at the tab stop to the left.
             */
            readonly Left: "left";
            /**
             * Aligns text at the tab stop to the right.
             */
            readonly Right: "right";
            /**
             * Centers text at the tab stop.
             */
            readonly Center: "center";
        };
        type TabStopAlignment = typeof TabStopAlignment[keyof typeof TabStopAlignment];
        interface CloneableTextFrame extends ITextFrame {
            clone(visitor?: TextVisitor): ITextFrame;
            equals(other: ITextFrame): boolean;
        }
        /**
         * Returns a css equivalent of the horizontal text alignment.
         */
        const toCSSHorizontalTextAlign: (align: ITextFrame.HorizontalAlignment) => CSSTextAlign;
    }
}
declare module "text/impl/WordWrapUtils" {
    export class WordWrapUtils {
        static NL: string;
        static DefaultLineSpacing: number;
        static DefaultTabWidth: number;
    }
}
declare module "text/TextParagraph" {
    import { Bounds } from '@sheetxl/utils';
    import { ITextFrame } from "text/ITextFrame";
    import { TextVisitor } from "text/TextVisitor";
    import { IBullet } from "text/Bullet";
    import { ITextRun, PlacedTextRun } from "text/TextRun";
    /**
     * Represents a collection of runs with specific information about white spacing before/after.
     */
    export interface ITextParagraph {
        /**
         * This is used if the run doesn't have a font or in the case where there is no run (Empty line)
         */
        readonly defaultFontSize: number;
        readonly defaultTabSize: number;
        readonly tabOverrides: ITextFrame.TabStop[];
        readonly spacingBefore: number;
        readonly spacingAfter: number;
        readonly lineSpacing: number;
        readonly align: ITextFrame.HorizontalAlignment;
        readonly endParagraphSize: number;
        readonly indentLevel: number;
        readonly leadingIndent: number;
        readonly hangingIndent: number;
        readonly rightMargin: number;
        readonly bullet: IBullet;
        readonly runs: ITextRun[];
    }
    export interface PlacedTextParagraph extends ITextParagraph {
        /**
         * Bounds is not copied during clone.
         */
        readonly bounds?: Bounds;
        readonly runs: PlacedTextRun[];
    }
    export interface CloneableTextParagraph extends ITextParagraph {
        clone(visitor?: TextVisitor): ITextParagraph;
        equals(other: ITextParagraph): boolean;
    }
    export class DefaultTextParagraph implements ITextParagraph, PlacedTextParagraph, CloneableTextParagraph {
        private _private;
        private _bounds;
        constructor(overrides: Partial<ITextParagraph>);
        clone(visitor?: TextVisitor): ITextParagraph;
        equals(other: ITextParagraph): boolean;
        get bounds(): Bounds;
        get defaultFontSize(): number;
        get defaultTabSize(): number;
        get tabOverrides(): ITextFrame.TabStop[];
        get spacingBefore(): number;
        get spacingAfter(): number;
        get lineSpacing(): number;
        get align(): ITextFrame.HorizontalAlignment;
        get endParagraphSize(): number;
        get indentLevel(): number;
        get leadingIndent(): number;
        get hangingIndent(): number;
        get rightMargin(): number;
        get bullet(): IBullet;
        get runs(): ITextRun[];
    }
}
declare module "text/TextVisitor" {
    import { ITextRun } from "text/TextRun";
    import { ITextParagraph } from "text/TextParagraph";
    import { ITextLine } from "text/TextLine";
    import { ITextFrame } from "text/ITextFrame";
    export interface TextVisitor {
        visitTextRun?: (run: ITextRun, index: number, count: number) => Partial<ITextRun> | void;
        visitTextParagraph?: (paragraph: ITextParagraph, index: number, count: number) => Partial<ITextParagraph> | void;
        visitTextLine?: (line: ITextLine, index: number, count: number) => Partial<ITextLine> | void;
        visitTextFrame?: (frame: ITextFrame) => Partial<ITextFrame> | void;
    }
}
declare module "text/TextRun" {
    import { Bounds } from '@sheetxl/utils';
    import { IText } from "text/IText";
    import { TextVisitor } from "text/TextVisitor";
    /**
     * Represents a contiguous span of characters within a text frame that share the same formatting.
     */
    export interface ITextRun {
        /**
         * The actual text content of the run.
         */
        readonly text: string;
        /**
         * The font name applied to the text run.
         * If not specified, it inherits the font name from its parent paragraph.
         */
        readonly fontName: string;
        /**
         * The font size applied to the text run.
         * If not specified, it inherits the font size from its parent paragraph.
         */
        readonly fontSize: number;
        /**
         * Indicates whether the text is bold.
         */
        readonly bold: boolean;
        /**
         * Indicates whether the text is italicized.
         */
        readonly italic: boolean;
        readonly superSub: boolean;
        /**
         * Specifies the additional spacing between characters (in ems).
         */
        readonly letterSpacing: number;
        /**
         * Specifies the minimum font size (in points) at which character kerning will be applied.
         * If omitted, kerning will be applied for all font sizes down to 0 points.
         */
        readonly kerningMin: number;
        /**
         * Specifies the capitalization style to be applied to the text during layout and rendering.
         * This does not affect the actual stored text content.
         */
        readonly smallCaps: IText.SmallCaps;
        /**
         * Vertical offset of the text (as a percentage of font height),
         * shifting it up (positive values) or down (negative values).
         * This does not affect the line height.
         */
        readonly offset: number;
        /**
         * Specifies the strikethrough style applied to the text.
         */
        readonly strikeStyle: IText.StrikeStyle;
    }
    export interface PlacedTextRun extends ITextRun {
        /**
         * Bounds is not copied during clone.
         */
        readonly bounds?: Bounds;
    }
    export interface CloneableTextRun extends ITextRun {
        clone(visitor?: TextVisitor): ITextRun;
        equals(other: TextVisitor): boolean;
    }
    export class DefaultTextRun implements ITextRun, PlacedTextRun, CloneableTextRun {
        private _private;
        private _bounds?;
        constructor(overrides: Partial<ITextRun>, bounds?: Bounds);
        clone(visitor?: TextVisitor): ITextRun;
        equals(other: TextVisitor): boolean;
        get bounds(): Bounds;
        get text(): string;
        get fontName(): string;
        get bold(): boolean;
        get italic(): boolean;
        get fontSize(): number;
        get superSub(): boolean;
        get letterSpacing(): number;
        get kerningMin(): number;
        get smallCaps(): IText.SmallCaps;
        get offset(): number;
        get strikeStyle(): IText.StrikeStyle;
    }
}
declare module "text/TextLine" {
    import { Bounds } from '@sheetxl/utils';
    import { IBullet } from "text/Bullet";
    import { ITextRun } from "text/TextRun";
    /**
     * Represents a single line with an ITextFrame
     */
    export interface ITextLine {
        readonly bullet: IBullet;
        readonly runs: ITextRun[];
        readonly bounds: Bounds;
        readonly baseline: number;
    }
    /**
     * A default text line.
     */
    export class DefaultTextLine implements ITextLine {
        _private: any;
        constructor(bounds: Bounds, baseline: number, runs: ITextRun[]);
        get bounds(): any;
        get baseline(): any;
        get runs(): any;
        get bullet(): any;
    }
}
declare module "text/IText" {
    import { ITextLine as _ITextLine } from "text/TextLine";
    import { ITextParagraph as _ITextParagraph } from "text/TextParagraph";
    import { ITextRun as _ITextRun } from "text/TextRun";
    import { IBullet as _IBullet } from "text/Bullet";
    /**
     * Capabilities for working with text.
     */
    export namespace IText {
        type ITextLine = _ITextLine;
        type ITextParagraph = _ITextParagraph;
        type ITextRun = _ITextRun;
        type IBullet = _IBullet;
        /**
         * Specifies capitalization options for text within a text frame.
         */
        const SmallCaps: {
            /**
             * Normal capitalization.
             */
            readonly None: "none";
            /**
             * Capitalize every letter but reduce the the size of all but the first letter.
             *
             * @see
            {@link https://developer.mozilla.org/en-US/docs/Web/CSS/font-variant-caps}
            */
            readonly Small: "small";
            /**
             * Convert all text to uppercase.
             */
            readonly All: "all";
        };
        type SmallCaps = typeof SmallCaps[keyof typeof SmallCaps];
        /**
         * Indicate how and if a line will be drawing horizontally through the middle of the text.
         */
        const StrikeStyle: {
            /**
             * No strike-through
             */
            readonly None: "none";
            /**
             * A single line.
             */
            readonly Single: "single";
            /**
             * A double line.
             */
            readonly Double: "double";
        };
        type StrikeStyle = typeof StrikeStyle[keyof typeof StrikeStyle];
    }
}
declare module "font/_FontUtils" {
    import { IFont } from "font/IFont";
    export const DefaultMinFontSize: number;
    export const DefaultMaxFontSize: number;
    export const DefaultMaxFontPrecision: number;
    export const DefaultLineHeightMultiplier: number;
    export const defaultHorizontalPadding: (fontSize: number) => number;
    export const defaultVerticalPadding: (_fontSize: number) => number;
    /**
     * The size to scale a font for super/sub text.
     * @remarks
     * **NOT IMPLEMENTED** This should read from the font but is currently hardcoded to `0.6`.
     * * This will be moved to 'Measurer'
     */
    export const superSubScale: (_fontFamily: string, _fontSize?: number, _verticalAlign?: IFont.VerticalAlignment) => number;
    /**
     * The distance in pixels to shift a font for super/sub text.
     * @remarks
     * **NOT IMPLEMENTED** This should read from the font but is currently hardcoded to `+1/5 -1/5`.
     * * This will be moved to 'Measurer'
     */
    export const superSubShift: (fontFamily: string, fontSize?: number, verticalAlign?: IFont.VerticalAlignment) => number;
}
declare module "font/SimpleFontMeasurer" {
    import { IFont } from "font/IFont";
    export const getInstance: () => IFont.Measurer;
    export const getDeviceScale: () => number;
}
declare module "font/FontKitFontMeasurer" {
    import { IFont } from "font/IFont";
    export const setFontFolder: (path: string) => void;
    /**
     * TODO - use fs selection to determine:
     * 1. panose
     * 2. if bold, italic
     */
    export const FontKitFontMeasurer: IFont.Measurer;
    export const getInstance: () => IFont.Measurer;
    export const getDeviceScale: () => number;
}
declare module "font/IFont" {
    /**
     * Namespace for fonts
     *
     * {@link IFont}
     */
    export namespace IFont {
        /**
         * Specifies the style of the font (normal, italic).
         */
        const Style: {
            /**
             * The standard, non-italicized font style.
             */
            readonly Normal: "normal";
            /**
             * The italicized font style.
             */
            readonly Italic: "italic";
        };
        type Style = typeof Style[keyof typeof Style];
        /**
         * Specifies the font scheme, indicating its role in the document's typography.
         */
        const Scheme: {
            /**
             * The primary font used for headings and major text elements.
             */
            readonly Major: "major";
            /**
             * The secondary font used for body text and less prominent elements.
             */
            readonly Minor: "minor";
            /**
             * No specific font scheme is assigned.
             */
            readonly None: "none";
        };
        type Scheme = typeof Scheme[keyof typeof Scheme];
        /**
         * Specifies the style of underline applied to text.
         */
        const UnderlineStyle: {
            /**
             * No underline.
             */
            readonly None: "none";
            /**
             * A double underline.
             */
            readonly Double: "double";
            /**
             * A double underline used in accounting contexts (typically thicker and below the descenders).
             */
            readonly DoubleAccounting: "doubleAccounting";
            /**
             * A single underline.
             */
            readonly Single: "single";
            /**
             * A single underline used in accounting contexts (typically below the descenders).
             */
            readonly SingleAccounting: "singleAccounting";
        };
        type UnderlineStyle = typeof UnderlineStyle[keyof typeof UnderlineStyle];
        /**
         * Vertical alignment of text within a line.
         * @see
         * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/vertical-align}
         */
        const VerticalAlignment: {
            /**
             * Aligns the baseline of the cell with the baseline of all other cells in the row that are baseline-aligned.
             */
            readonly Baseline: "baseline";
            /**
             * Aligns the baseline of the element with the subscript-baseline of its parent.
             */
            readonly Sub: "sub";
            /**
             * Aligns the baseline of the element with the superscript-baseline of its parent.
             */
            readonly Super: "super";
        };
        type VerticalAlignment = typeof VerticalAlignment[keyof typeof VerticalAlignment];
        /**
         * Advanced text metrics.
         */
        interface ExtendedMetrics extends Partial<TextMetrics>, Partial<IFont.Metrics> {
            /**
             * This is the lineHeight and includes the lineGap
             */
            readonly lineHeight: number;
        }
        interface Metrics {
            readonly underlinePosition?: number;
            readonly underlineThickness?: number;
            readonly strikePosition?: number;
            readonly strikeThickness?: number;
            readonly italicAngle?: number;
            readonly lineHeight: number;
            readonly baseline: number;
            readonly lineGap: number;
        }
        interface MetricOptions {
            isBold?: boolean;
            isItalic?: boolean;
            letterSpacing?: number;
        }
        interface Measurer {
            (text: string, size: number, family: string, options?: IFont.MetricOptions): IFont.ExtendedMetrics;
        }
        /**
         * Override the default mechanism for measuring text.
         *
         * @param measurer {@link IFont.Measurer}
         */
        const setSharedMeasurer: (measurer: IFont.Measurer) => void;
        /**
         * Returns the {@link IFont.Measurer} used for measuring text.
         *
         * @see
         * {@link setSharedMeasurer}
         */
        const getSharedMeasurer: () => IFont.Measurer;
        /**
         * Returns scaling to use for the current device.
         */
        const getDeviceScale: () => number;
        /**
         * Provides a font-family fallback based on the PANOSE hex string.
         *
         * @param hexPanose The PANOSE string.
         * @returns a font-family fallback.
         */
        const getPanoseFallback: (hexPanose: string) => string;
        /**
         * Represents a font face, encapsulating information about a specific typeface.
         */
        interface IFontFace {
            /**
             * Serializes the font face information into a JSON-compatible object.
             *
             * @returns A plain JavaScript object representing the font face data.
             */
            toJSON(): any;
            /**
             * The name of the font face (e.g., 'Arial', 'Times New Roman').
             */
            getFamily(): string;
            /**
             * The pitch (or classification) of the font face (e.g., 'variable', 'fixed').
             */
            getPitch(): string;
            /**
             * The Panose classification string for the font face, providing information about its visual characteristics.
             * @returns `null` if unable to generate.
             */
            getPanose(): string | null;
            /**
             * Returns a string representation of the font face.
             */
            toString(): string;
            /**
             * A flag indicating that this object is an `IFont` instance.
             * Useful for runtime type checking.
             */
            readonly isIFont: true;
        }
        /**
         * Font families supported by all/most browsers/platforms.
         */
        const GenericName: {
            readonly Serif: "serif";
            readonly SanSerif: "sans-serif";
            readonly MonoSpace: "monospace";
            readonly Cursive: "cursive";
            readonly Fantasy: "fantasy";
            readonly SystemUI: "system-ui";
            readonly UISystem: "ui-system";
            readonly UISerif: "ui-serif";
            readonly UISanSerif: "ui-sans-serif";
            readonly UIMonoSpace: "ui-monospace";
            readonly UIRounded: "ui-rounded";
            readonly Math: "math";
            readonly Emoji: "emoji";
            readonly Fangsong: "fangsong";
        };
        type GenericName = typeof GenericName[keyof typeof GenericName];
    }
}
declare module "font/Font" {
    import { IFont } from "font/IFont";
    /**
     * read only font face
     * @hidden
     */
    export class SimpleFontFace implements IFont.IFontFace {
        _private: any;
        constructor(input: any);
        toJSON(): any;
        /** {@inheritDoc IFont.getFamily} */
        getFamily(): string;
        /** {@inheritDoc IFont.getPitch} */
        getPitch(): string;
        /** {@inheritDoc IFont.getPanose} */
        getPanose(): string | undefined;
        toString(): any;
        get isIFont(): true;
    }
}
declare module "font/IFontCollection" {
    import { IFont } from "font/IFont";
    export interface FontHandle {
        fontRef: IFont.IFontFace;
        loaded: boolean;
    }
    export function setFontList(fontList: IFont.IFontFace[] | string[]): void;
    export function getFontList(): readonly FontHandle[];
    export interface FindBestMatchOptions {
        /**
         * Defaults to false
         */
        bold?: boolean;
        /**
         * Defaults to false
         */
        italic?: boolean;
        /**
         * A list of font names or generic font family
         */
        fallbacks?: string[];
        panose?: string;
    }
    /**
     * Tries to find a font that match the fontName exactly. If this is not found then it will use the fallback
     * options if provided. If there is no font and no font fallback it will return null.
     * @param fontName The font name to find
     * @returns The FontHandle
     */
    export const findBestMatch: (fontName: string, options?: FindBestMatchOptions) => FontHandle;
}
declare module "font/FontUtils" {
    /**
     * A list of font sizes for showing in drop downs.
     */
    export const DefaultFontSizes: readonly number[];
    /**
     * Searches an array of numbers for the next value.
     */
    export const findNextFontSize: (size: number, increase?: boolean, steps?: readonly number[]) => number;
}
declare module "font/index" {
    export * as IFontCollection from "font/IFontCollection";
    export * from "font/IFont";
    export * from "font/Font";
    export * as FontUtils from "font/FontUtils";
}
declare module "text/richtext/IStyledFont" {
    import { Properties as CSSProperties } from 'csstype';
    import { IColor } from "color/index";
    import { IFont } from "font/index";
    import { IStyle } from "style/index";
    /**
     * Represents a font with styling color.
     */
    export interface IStyledFont {
        /**
         * This can be set as a string using html values such as 'Arial 11pt' but will be resolved to a single font. Fallbacks and fontSize will be
         * marshalled into their correct property.
         */
        getFamily(): string;
        /**
         * @see {@link IStyledFont.getFamily}
         */
        setFamily(family: string | null, options?: IStyle.UpdateOptions): IStyledFont;
        /**
         * A list of fonts and their fallbacks. These can also be provided in the fontFamily attribute but will
         * be normalized to here.
         */
        getFallbacks(): string[];
        /**
         * @see {@link IStyledFont.setFallbacks}
         */
        setFallbacks(fallbacks: string[] | null, options?: IStyle.UpdateOptions): IStyledFont;
        /**
         * Font size is either a number in points or a string that can be converted such as '14px', '1.5em'.
         */
        getSize(): number;
        /**
         * @see {@link IStyledFont.setSize}
         */
        setSize(size: number | null, options?: IStyle.UpdateOptions): IStyledFont;
        /**
         * The weight of the characters.
         */
        getWeight(): number;
        /**
         * @see {@link IStyledFont.setWeight}
         */
        setWeight(weight: number | null, options?: IStyle.UpdateOptions): IStyledFont;
        /**
         * @default `IFont.Style.Normal`
         */
        getStyle(): IFont.Style;
        /**
         * @see {@link IStyledFont.setStyle}
         */
        setStyle(style: IFont.Style | null, options?: IStyle.UpdateOptions): IStyledFont;
        /**
         * The text color.
         *
         * @remarks
         * Currently only solid fill is supported but this will be expanded to allow all fill types similar to DrawML.
         */
        getFill(): IColor;
        /**
         * @see {@link IStyledFont.setFill}
         */
        setFill(fill: IColor | null, options?: IStyle.UpdateOptions): IStyledFont;
        /**
         * Adds or removes additional spacing between the characters.
         */
        getLetterSpacing(): number;
        /**
         * @see {@link IStyledFont.setLetterSpacing}
         */
        setLetterSpacing(letterSpacing: number | null, options?: IStyle.UpdateOptions): IStyledFont;
        /**
         * Sets the underline style. If true defaults to single. If false or null defaults to none.
         *
         * @default `IFont.UnderlineStyle.None`
         */
        getUnderline(): IFont.UnderlineStyle;
        /**
         * @see {@link IStyledFont.setUnderline}
         */
        setUnderline(underline: IFont.UnderlineStyle | null, options?: IStyle.UpdateOptions): IStyledFont;
        /**
         * The effect draws the text with a line through it.
         */
        getStrike(): boolean;
        /**
         * @see {@link IStyledFont.setStrike}
         */
        setStrike(strike: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
        /**
         * Defines the font scheme to use.
         * @default `IFont.Scheme.Minor`
         */
        getScheme(): IFont.Scheme;
        /**
         * @see {@link IStyledFont.setScheme}
         */
        setScheme(scheme: IFont.Scheme | null, options?: IStyle.UpdateOptions): IStyledFont;
        /**
         * Returns the vertical alignment of the text within a text line.
         *
         * @remarks
         * If the IFont.VerticalAlignment is superscript or subscript then the font size should also render smaller.
         */
        getVerticalAlignment(): IFont.VerticalAlignment;
        /**
         * @see {@link IStyledFont.setVerticalAlignment}
         */
        setVerticalAlignment(verticalAlignment: IFont.VerticalAlignment | null, options?: IStyle.UpdateOptions): IStyledFont;
        /**
         * The effect draws a shadow around the text.
         *
         * @remarks
         * Not rendered by Excel or SheetXL.
         */
        getShadow(): boolean;
        /**
         * @see {@link IStyledFont.setShadow}
         */
        setShadow(shadow: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
        /**
         * The effect draws the text as an outline.
         *
         * @remarks
         * Not rendered by Excel or SheetXL.
         */
        getOutline(): boolean;
        /**
         * @see {@link IStyledFont.setOutline}
         */
        setOutline(outline: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
        /**
         * The effect extends or stretches out the text.
         *
         * @remarks
         * Not rendered by Excel or SheetXL.
         */
        getExtend(): boolean;
        /**
         * @see {@link IStyledFont.setExtend}
         */
        setExtend(extend: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
        /**
         * Returns `true` if the font is either a superscript or a subscript.
         */
        isSuperSub(): boolean;
        /**
         * Returns the size to scale the font for super/sub text.
         */
        getSuperSubScale(): number;
        /**
         * Returns the number of pixels to shift the font for super/sub text.
         */
        getSuperSubShift(): number;
        /**
         * Compare against another font to see if they will have the same font measure
         * This is used to optimize updates by not re-calcing the width/height
         *
         * @param other The other style font
         */
        isEqualMeasure(other: IStyledFont): boolean;
        /**
         * Returns the font styles as a set of css string that are suitable for css.
         *
         * @remarks
         * Not all fill styles will offer an exact css equivalent.
         * Additionally due to the nature of css having different properties for the same logic value
         * (for example color, backgroundColor)
         */
        toCSS(darkMode?: boolean, zoom?: number, ignoreNormal?: boolean): CSSProperties;
        /**
         * Serializes to a JSON object.
         */
        toJSON(): IStyledFont.JSON;
        /**
         * For runtime type checking.
         */
        readonly isIStyledFont: true;
    }
    /**
     * {@inheritDoc IStyledFont}
     * @see
     * ### **Interface**
     *
     * {@link IStyledFont}
     */
    export namespace IStyledFont {
        /**
         * Represents a font with color.
         */
        interface Properties<C = IColor.Serializable> {
            family?: string;
            fallbacks?: string[];
            size?: number;
            weight?: number | string;
            style?: IFont.Style;
            fill?: C;
            letterSpacing?: number;
            underline?: boolean | IFont.UnderlineStyle | null;
            strike?: boolean;
            scheme?: IFont.Scheme;
            verticalAlign?: IFont.VerticalAlignment;
            shadow?: boolean;
            outline?: boolean;
            extend?: boolean;
        }
        /**
         * Modifiers describe a partial list of properties that can be set with values or shorthand strings.
         */
        type Modifiers<C = IColor.Serializable> = Partial<IStyledFont.Properties<C>>;
        /**
         * Options for updating a font.
         */
        type Update<C = IColor.Serializable> = IStyledFont | Modifiers<C> | string | null;
        interface JSON extends Properties<string> {
        }
    }
}
declare module "text/richtext/index" {
    export * from "text/richtext/IStyledFont";
}
declare module "text/TextUtils" {
    /**
     * Will try to find a valid text value from a template by incrementing a last number.
     *
     * @param template The string to use for a baseline for generating new text values.
     * @param isValidName A callback for validating the current text.
     * @returns A string for the first valid text.
     */
    export const findValidTextValue: (template: string, isValidName: (candidate: string) => boolean, maxIncrement?: number) => string;
    /**
     * Capitalizes the first character of a string and optionally lowercases the rest of the string.
     *
     * @param str The input string to be processed.
     * @param lowerCaseRest A boolean flag indicating whether to convert the rest of the string to lowercase.
     *                         If `true`, the remaining characters (after the first) will be converted to lowercase.
     *                         If `false`, the remaining characters will remain unchanged.
     *
     * @returns A new string with the first character capitalized and the rest lowercased if the `lowerCaseRest` flag is `true`.
     *          If the `lowerCaseRest` flag is `false`, only the first character is capitalized, and the rest of the string remains unchanged.
     *
     * @example
     * ```
     * capitalize("hello");           // Returns "Hello"
     * capitalize("hello", true);     // Returns "Hello"
     * capitalize("HELLO", true);     // Returns "Hello"
     * capitalize("123abc", true);    // Returns "123abc"
     * capitalize("", true);          // Returns ""
     * ```
     */
    export const capitalize: (str: string, lowerCaseRest?: boolean) => string;
    /**
     * Extracts the file extension from a file path.
     *
     * @param path The file path from which to extract the file extension.
     *
     * @returns The file extension in lowercase. Returns an empty string if the path is invalid or has no extension.
     *
     * @example
     * ```
     * getFileNameExtension("example.txt");       // Returns "txt"
     * getFileNameExtension("/path/to/file.jpg"); // Returns "jpg"
     * getFileNameExtension("no_extension");      // Returns ""
     * getFileNameExtension("");                  // Returns ""
     * ```
     */
    export const getFileNameExtension: (path: string) => string;
    /**
     * Extracts the base name (file name without extension) from a file path.
     *
     * @param path The file path from which to extract the base name.
     * @param shouldCapitalize A boolean flag indicating whether to capitalize the base name. Defaults to `false`.
     *
     * @returns The base name of the file. The base name will be capitalized if `shouldCapitalize` is `true`.
     *
     * @example
     * ```
     * getBaseName("example.txt");       // Returns "Example"
     * getBaseName("/path/to/file.jpg"); // Returns "File"
     * getBaseName("file_without_extension", false); // Returns "file_without_extension"
     * getBaseName("", false);          // Returns ""
     * ```
     */
    export const getBaseName: (path: string, shouldCapitalize?: boolean) => string;
    /**
     * Converts a snake_case or kebab-case string to camelCase.
     *
     * @param str The snake_case or kebab-case string to convert.
     * @returns The string converted to camelCase.
     *
     * @example
     * ```ts
     * snakeToCamel('snake_case_string'); // Returns 'snakeCaseString'
     * snakeToCamel('kebab-case-string'); // Returns 'kebabCaseString'
     * ```
     */
    export const snakeToCamel: (str: string) => string;
    /**
     * Converts a camelCase string to snake_case.
     *
     * @param str The camelCase string to convert.
     * @returns The string converted to snake_case.
     *
     * @example
     * ```ts
     * camelToSnake('camelCaseString'); // Returns 'camel_case_string'
     * ```
     */
    export const camelToSnake: (str: string) => string;
    /**
     * Trims a string to a specified maximum length and adds an ellipsis (`…`) if the string exceeds the limit.
     *
     * @param str The string to trim.
     * @param maxLength The maximum length of the string before truncation (default is 36).
     * @returns The truncated string with an ellipsis if it exceeds the specified length.
     *
     * @example
     * ```ts
     * clampString('This is a long string', 10); // Returns 'This is a …'
     * ```
     */
    export const clampString: (str: string, maxLength?: number) => string;
    /**
     * Counts the number of decimal places in a numeric string.
     *
     * @param input The string representation of a number.
     * @returns The number of decimal places. Returns 0 if there are no decimal places.
     *
     * @example
     * ```ts
     * countDecimals('123.456'); // Returns 3
     * countDecimals('123');     // Returns 0
     * ```
     */
    export const countDecimals: (input: string) => number;
    export const DefaultUnQuoteRegEx: RegExp;
    /**
     * Checks if a string is enclosed in matching quotes.
     *
     * @param str The string to check.
     * @returns `true` if the string is quoted with matching characters, `false` otherwise.
     */
    export const isQuoted: (str: string) => boolean;
    /**
     * Removes the enclosing quotes from a string.
     *
     * @param str The string to unquote.
     * @returns The unquoted string.
     */
    export const unquote: (str: string) => string;
    /**
     * Encloses a string in the specified quote character.
     *
     * @param str The string to quote.
     * @param char The quote character to use (default is a single quote `'`).
     * @returns The quoted string.
     */
    export const quote: (str: string, char?: string) => string;
    /**
     * Splits a string by a delimiter, ignoring any quoted sections.
     *
     * @param str The string to split.
     * @param delimiter The delimiter to split by (default is undefined).
     * @param quote The quote character used to ignore splits inside quoted sections (default is undefined).
     * @returns An array of strings split by the delimiter, ignoring quoted sections.
     */
    export const splitUnquoted: (str: string, delimiter?: string, quote?: string) => string[];
    /**
     * Validates if a string is a valid HTTP or HTTPS URL.
     *
     * @param value The string to check.
     * @returns `true` if the string is a valid HTTP or HTTPS URL, `false` otherwise.
     */
    export const isValidHttpUrl: (value: string) => boolean;
    /**
     * Validates if a string is a valid email.
     *
     * @param text The string to check.
     * @returns `true` if the string is a valid email, `false` otherwise.
     */
    export const isValidEmail: (text: string) => boolean;
    /**
     * Converts a number to alphabet.
     * @param i The number to stringify
     */
    export const numberToAlphabet: (i: number) => string;
}
declare module "text/index" {
    export * from "text/IText";
    export * from "text/ITextFrame";
    export * from "text/richtext/index";
    export * from "text/TextBoxAlignment";
    export * as TextUtils from "text/TextUtils";
}
declare module "border/IBorder" {
    import { IProperties } from "type/index";
    import type { IColor } from "color/index";
    import { IStyle } from "style/index";
    export namespace IBorder {
        /**
         * @remarks
         * This is a limited implementation of border that matches OOXMl and Excel.
         * TODO - Review and rationalize with css.
         * * Excel online breaks weight and styling into two properties but... (I )
         * * Excel only supports the enums as they are defined in OOXML.
         *
         * @see
         * {@link https://learn.microsoft.com/en-us/javascript/api/excel/excel.cellborder?view=excel-js-preview#excel-excel-cellborder-style-member}
         */
        const StrokeStyle: {
            readonly None: "none";
            readonly DashDot: "dashDot";
            readonly MediumDashDot: "mediumDashDot";
            readonly Dotted: "dotted";
            readonly Hair: "hair";
            readonly Thin: "thin";
            readonly Medium: "medium";
            readonly Thick: "thick";
            readonly MediumDashDotDot: "mediumDashDotDot";
            readonly DashDotDot: "dashDotDot";
            readonly Dashed: "dashed";
            readonly MediumDashed: "mediumDashed";
            readonly SlantDashDot: "slantDashDot";
            readonly Double: "double";
        };
        type StrokeStyle = typeof StrokeStyle[keyof typeof StrokeStyle];
        const Edge: {
            readonly Left: "left";
            readonly Top: "top";
            readonly Right: "right";
            readonly Bottom: "bottom";
            /**
             * @remarks
             * `horizontal` and `vertical` properties are supported for setting values but get converted top/left/bottom/right for individual cells.
             * These will always be null in the IStyle.
             */
            readonly Horizontal: "horizontal";
            /**
             * @inheritdoc Edge.Horizontal
             */
            readonly Vertical: "vertical";
            readonly DiagonalUp: "diagonalUp";
            readonly DiagonalDown: "diagonalDown";
        };
        type Edge = typeof Edge[keyof typeof Edge];
        /**
         * Used for look ups and drop drowns.
         */
        interface Definition {
            style: StrokeStyle;
            description: string;
            width: number;
            pattern: number[];
        }
        interface IStroke {
            getStyle(): StrokeStyle;
            /**
             * Sets the stroke style.
             *
             * @param style The stroke style.
             */
            setStyle(style: IBorder.StrokeStyle | string | null, options?: IStyle.UpdateOptions): IBorder.IStroke;
            getColor(): IColor;
            /**
             * Sets the stroke color.
             *
             * @param color The stroke color.
             */
            setColor(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IBorder.IStroke;
            /**
             * Returns all the set properties and their values for the border.
             */
            getProperties(): IBorder.StrokeProperties;
            /**
             * Returns a set of CSSStyleDeclaration that approximate the stroke.
             */
            toCSS(): Partial<CSSStyleDeclaration>;
            /**
             * @returns `true` StrokeStyle is `None`.
             */
            isNone(): boolean;
            /**
             * For runtime type checking.
             */
            readonly isIStroke: true;
        }
        interface StrokeProperties<C = IColor.Serializable> {
            style?: IBorder.StrokeStyle;
            color?: C;
        }
        interface StrokeJSON {
            style?: IBorder.StrokeStyle;
            color?: string;
        }
        type Properties = {
            [key in IBorder.Edge]?: IBorder.StrokeProperties;
        };
        /**
         * Modifiers describe a partial list of properties that can be set with values or shorthand strings.
         */
        type Modifiers = Partial<IBorder.Properties>;
        /**
         * Options for updating a border.
         */
        type Update = IBorder | Modifiers | string | null;
        /**
         * JSON representation of a border.
         */
        type JSON = {
            [key in IBorder.Edge]?: IBorder.StrokeJSON;
        };
    }
    /**
     * Provides information for describing a border around a shape.
     */
    export interface IBorder {
        /**
         * @returns The left border.
         */
        getLeft(): IBorder.IStroke;
        /**
         * Sets the left border.
         *
         * @param edge The border edge.
         */
        setLeft(edge: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.Properties> | string | null, options?: IStyle.UpdateOptions): IBorder;
        /**
         * @returns The top border.
         */
        getTop(): IBorder.IStroke;
        /**
         * Sets the top border.
         *
         * @param edge The border edge.
         */
        setTop(edge: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.Properties> | string | null, options?: IStyle.UpdateOptions): IBorder;
        /**
         * @returns The right border.
         */
        getRight(): IBorder.IStroke;
        /**
         * Sets the right border.
         *
         * @param edge The border edge.
         */
        setRight(edge: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.Properties> | string | null, options?: IStyle.UpdateOptions): IBorder;
        /**
         * @returns The bottom border.
         */
        getBottom(): IBorder.IStroke;
        /**
         * Sets the bottom border.
         *
         * @param edge The border edge.
         */
        setBottom(edge: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.Properties> | string | null, options?: IStyle.UpdateOptions): IBorder;
        /**
         * @returns The diagonalUp border.
         */
        getDiagonalUp(): IBorder.IStroke;
        /**
         * Sets the diagonalUp border.
         *
         * @param edge The border edge.
         */
        setDiagonalUp(edge: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.Properties> | string | null, options?: IStyle.UpdateOptions): IBorder;
        /**
         * @returns The diagonalDown border.
         */
        getDiagonalDown(): IBorder.IStroke;
        /**
         * Sets the diagonalDown border.
         *
         * @param edge The border edge.
         */
        setDiagonalDown(edge: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
        /**
         * If there are any borders that are not none.
         */
        isEmpty(): boolean;
        toJSON(): IBorder.JSON;
        /**
         * Returns all the set properties and their values for the border.
         */
        getProperties(): IBorder.Properties;
        /**
         * List of customizations modifiers for the border.
         */
        /**
         * For runtime type checking.
         */
        readonly isIBorder: true;
    }
    /**
     * {@inheritDoc IBorder}
     * @see
     * ### **Interface**
     *
     * {@link IBorder}
     */
    export namespace IBorder {
        /**
         * Compare two strokes for logical equality.
         */
        const isEqualStrokes: (a: IBorder.IStroke, b: IBorder.IStroke) => boolean;
        /**
         * Returns the opposite border edge. This only works for Left,Right,Top,Bottom
         * all other edges return themselves.
         * @param edge The edge.
         * @returns The opposite edge or the input value.
         */
        const oppositeEdge: (edge: Edge) => Edge;
        /**
         * List of Border definitions. This provides an order for display purposes.
         */
        const BuiltInDefinitionsArray: Definition[];
        /**
         * Provides a quick way to access border definitions by StrokeStyle.
         */
        const BuiltInDefinitions: Map<StrokeStyle, Definition>;
    }
}
declare module "border/index" {
    export * from "border/IBorder";
}
declare module "numFmt/NumberFormatType" {
    /**
     * Represents the built-in categorization of a number format, or 'Custom' if the format is not recognized as a built-in type.
     *
     * Excel has the following:
     * @see
     * {@link https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.numberingformats?view=openxml-2.8.1}
     */
    export const Type: {
        /**
         * The default format, displays numbers as entered.
         */
        readonly General: "General";
        /**
         * Displays numbers with a thousands separator and two decimal places.
         */
        readonly Number: "Number";
        /**
         * Formats numbers as currency with a currency symbol and two decimal places.
         */
        readonly Currency: "Currency";
        /**
         * Formats numbers as currency, aligning currency symbols and decimal points in a column.
         */
        readonly Accounting: "Accounting";
        /**
         * Displays dates in a short format (e.g., "M/d/yyyy").
         */
        readonly ShortDate: "Short Date";
        /**
         * Displays dates in a long format (e.g., "dddd, MMMM d, yyyy").
         */
        readonly LongDate: "Long Date";
        /**
         * Displays dates in a medium format (e.g., "d-mmm-yy").
         */
        readonly MediumDate: "Medium Date";
        /**
         * Displays times in a short format (e.g., "h:mm AM/PM").
         */
        readonly ShortTime: "Short Time";
        /**
         * Displays times in a medium format (e.g., "h:mm:ss AM/PM").
         */
        readonly MediumTime: "Medium Time";
        /**
         * Displays times in a long format (e.g., "h:mm:ss.000 AM/PM").
         */
        readonly LongTime: "Long Time";
        /**
         * Displays numbers with a thousands separator.
         */
        readonly Comma: "Comma";
        /**
         * Displays numbers as percentages with a percent symbol.
         */
        readonly Percentage: "Percentage";
        /**
         * Displays numbers as fractions.
         */
        readonly Fraction: "Fraction";
        /**
         * Displays numbers in scientific notation.
         */
        readonly Scientific: "Scientific";
        /**
         * Treats the cell content as text, even if it appears to be a number.
         */
        readonly Text: "Text";
        /**
         * A placeholder for special or custom number formats.
         */
        readonly Special: "Special";
        /**
         * Indicates a user-defined or custom number format.
         */
        readonly Custom: "Custom";
    };
    export type Type = typeof Type[keyof typeof Type];
}
declare module "date/date-fns/constants/index" {
    /**
     * @module constants
     * @summary Useful constants
     * @description
     * Collection of useful date constants.
     *
     * The constants could be imported from `date-fns/constants`:
     *
     * ```ts
     * import { maxTime, minTime } from 'date-fns/constants';
     *
     * function isAllowedTime(time) {
     *   return time <= maxTime && time >= minTime;
     * }
     * ```
     */
    /**
     * @constant
     * @name millisecondsInMinute
     * @summary Milliseconds in 1 minute
     */
    export const millisecondsInMinute = 60000;
    /**
     * @constant
     * @name millisecondsInHour
     * @summary Milliseconds in 1 hour
     */
    export const millisecondsInHour = 3600000;
    /**
     * @constant
     * @name millisecondsInSecond
     * @summary Milliseconds in 1 second
     */
    export const millisecondsInSecond = 1000;
    /**
     * @constant
     * @name constructFromSymbol
     * @summary Symbol enabling Date extensions to inherit properties from the reference date.
     *
     * The symbol is used to enable the `constructFrom` function to construct a date
     * using a reference date and a value. It allows to transfer extra properties
     * from the reference date to the new date. It's useful for extensions like
     * [`TZDate`](https://github.com/date-fns/tz) that accept a time zone as
     * a constructor argument.
     */
    export const constructFromSymbol: unique symbol;
}
declare module "date/date-fns/types" {
    import { type constructFromSymbol } from "date/date-fns/constants/index";
    import type { Locale } from "date/date-fns/locale/types";
    export type * from "date/date-fns/locale/types";
    /**
     * The argument type.
     */
    export type DateArg<DateType extends Date> = DateType | number | string;
    /**
     * Date extension interface that allows to transfer extra properties from
     * the reference date to the new date. It's useful for extensions like [`TZDate`](https://github.com/date-fns/tz)
     * that accept a time zone as a constructor argument.
     */
    export interface ConstructableDate extends Date {
        [constructFromSymbol]: <DateType extends Date = Date>(value: DateArg<Date> & {}) => DateType;
    }
    /**
     * The generic date constructor. Replicates the Date constructor. Used to build
     * generic functions.
     *
     * @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).
     */
    export interface GenericDateConstructor<DateType extends Date = Date> {
        /**
         * The date constructor. Creates date with the current date and time.
         *
         * @returns The date instance
         */
        new (): DateType;
        /**
         * The date constructor. Creates date with the passed date, number of
         * milliseconds or string to parse.
         *
         * @param value - The date, number of milliseconds or string to parse
         *
         * @returns The date instance
         */
        new (value: DateArg<Date> & {}): DateType;
        /**
         * The date constructor. Creates date with the passed date values (year,
         * month, etc.) Note that the month is 0-indexed.
         *
         * @param year - The year
         * @param month - The month. Note that the month is 0-indexed.
         * @param date - The day of the month
         * @param hours - The hours
         * @param minutes - The minutes
         * @param seconds - The seconds
         * @param ms - The milliseconds
         *
         * @returns The date instance
         */
        new (year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): DateType;
    }
    /**
     * The duration object. Contains the duration in the units specified by the
     * object.
     */
    export interface Duration {
        /** The number of years in the duration */
        years?: number;
        /** The number of months in the duration */
        months?: number;
        /** The number of weeks in the duration */
        weeks?: number;
        /** The number of days in the duration */
        days?: number;
        /** The number of hours in the duration */
        hours?: number;
        /** The number of minutes in the duration */
        minutes?: number;
        /** The number of seconds in the duration */
        seconds?: number;
    }
    /**
     * The duration unit type alias.
     */
    export type DurationUnit = keyof Duration;
    /**
     * An object that combines two dates to represent the time interval.
     *
     * @typeParam StartDate - The start `Date` type.
     * @typeParam EndDate - The end `Date` type.
     */
    export interface Interval<StartType extends DateArg<Date> = DateArg<Date>, EndType extends DateArg<Date> = DateArg<Date>> {
        /** The start of the interval. */
        start: StartType;
        /** The end of the interval. */
        end: EndType;
    }
    /**
     * A version of {@link Interval} that has both start and end resolved to Date.
     */
    export type NormalizedInterval<DateType extends Date = Date> = Interval<DateType, DateType>;
    /**
     * The era. Can be either 0 (AD - Anno Domini) or 1 (BC - Before Christ).
     */
    export type Era = 0 | 1;
    /**
     * The year quarter. Goes from 1 to 4.
     */
    export type Quarter = 1 | 2 | 3 | 4;
    /**
     * The day of the week type alias. Unlike the date (the number of days since
     * the beginning of the month), which begins with 1 and is dynamic (can go up to
     * 28, 30, or 31), the day starts with 0 and static (always ends at 6). Look at
     * it as an index in an array where Sunday is the first element and Saturday
     * is the last.
     */
    export type Day = 0 | 1 | 2 | 3 | 4 | 5 | 6;
    /**
     * The month type alias. Goes from 0 to 11, where 0 is January and 11 is
     * December.
     */
    export type Month = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
    /**
     * FirstWeekContainsDate is used to determine which week is the first week of
     * the year, based on what day the January, 1 is in that week.
     *
     * The day in that week can only be 1 (Monday) or 4 (Thursday).
     *
     * Please see https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system for more information.
     */
    export type FirstWeekContainsDate = 1 | 4;
    /**
     * The date values, used to set or get date object values.
     */
    export interface DateValues {
        /** The year */
        year?: number;
        /** The month */
        month?: number;
        /** The day of the month */
        date?: number;
        /** The hours */
        hours?: number;
        /** The minutes */
        minutes?: number;
        /** The seconds */
        seconds?: number;
        /** The milliseconds */
        milliseconds?: number;
    }
    /**
     * The number rounding method.
     */
    export type RoundingMethod = "ceil" | "floor" | "round" | "trunc";
    /**
     * The ISO string format.
     *
     * - basic: Minimal number of separators
     * - extended: With separators added to enhance human readability
     */
    export type ISOStringFormat = "extended" | "basic";
    /**
     * The ISO date representation. Represents which component the string includes,
     * date, time or both.
     */
    export type ISOStringRepresentation = "complete" | "date" | "time";
    /**
     * The step function options. Used to build function options.
     */
    export interface StepOptions {
        /** The step to use when iterating */
        step?: number;
    }
    /**
     * The week function options. Used to build function options.
     */
    export interface WeekOptions {
        /** Which day the week starts on. */
        weekStartsOn?: Day;
    }
    /**
     * The first week contains date options. Used to build function options.
     */
    export interface FirstWeekContainsDateOptions {
        /** See {@link FirstWeekContainsDate} for more details. */
        firstWeekContainsDate?: FirstWeekContainsDate;
    }
    /**
     * The localized function options. Used to build function options.
     *
     * @typeParam LocaleFields - The locale fields used in the relevant function. Defines the minimum set of locale fields that must be provided.
     */
    export interface LocalizedOptions<LocaleFields extends keyof Locale> {
        /** The locale to use in the function. */
        locale?: Pick<Locale, LocaleFields>;
    }
    /**
     * The ISO format function options. Used to build function options.
     */
    export interface ISOFormatOptions {
        /** The format to use: basic with minimal number of separators or extended
         * with separators added to enhance human readability */
        format?: ISOStringFormat;
        /** The date representation - what component to format: date, time\
         * or both (complete) */
        representation?: ISOStringRepresentation;
    }
    /**
     * The rounding options. Used to build function options.
     */
    export interface RoundingOptions {
        /** The rounding method to use */
        roundingMethod?: RoundingMethod;
    }
    /**
     * Additional tokens options. Used to build function options.
     */
    export interface AdditionalTokensOptions {
        /** If true, allows usage of the week-numbering year tokens `YY` and `YYYY`.
         * See: https://date-fns.org/docs/Unicode-Tokens */
        useAdditionalWeekYearTokens?: boolean;
        /** If true, allows usage of the day of year tokens `D` and `DD`.
         * See: https://date-fns.org/docs/Unicode-Tokens */
        useAdditionalDayOfYearTokens?: boolean;
    }
    /**
     * Nearest minute type. Goes from 1 to 30, where 1 is the nearest minute and 30
     * is nearest half an hour.
     */
    export type NearestMinutes = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30;
    /**
     * Nearest hour type. Goes from 1 to 12, where 1 is the nearest hour and 12
     * is nearest half a day.
     */
    export type NearestHours = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
    /**
     * The nearest minutes function options. Used to build function options.
     *
     * @deprecated Use {@link NearestToUnitOptions} instead.
     */
    export type NearestMinutesOptions = NearestToUnitOptions<NearestMinutes>;
    /**
     * The nearest unit function options. Used to build function options.
     */
    export interface NearestToUnitOptions<Unit extends number> {
        /** The nearest unit to round to. E.g. for minutes `15` to round to quarter
         * hours. */
        nearestTo?: Unit;
    }
    /**
     * The context options. Used to build function options.
     */
    export interface ContextOptions<DateType extends Date> {
        /**
         * The context to use in the function. It allows to normalize the arguments
         * to a specific date instance, which is useful for extensions like [`TZDate`](https://github.com/date-fns/tz).
         */
        in?: ContextFn<DateType> | undefined;
    }
    /**
      /**
       * The context function type. It's used to normalize the input arguments to
       * a specific date instance, which is useful for extensions like [`TZDate`](https://github.com/date-fns/tz).
       */
    export type ContextFn<DateType extends Date> = (value: DateArg<Date> & {}) => DateType;
    /**
     * Resolves passed type or array of types.
     */
    export type MaybeArray<Type> = Type | Type[];
}
declare module "date/date-fns/locale/types" {
    import type { DateArg, Day, Era, FirstWeekContainsDateOptions, LocalizedOptions, Month, Quarter, WeekOptions } from "date/date-fns/types";
    /**
     * The locale object with all functions and data needed to parse and format
     * dates. This is what each locale implements and exports.
     */
    export interface Locale {
        /** The locale code (ISO 639-1 + optional country code) */
        code: string;
        /** The function to format distance */
        formatDistance: FormatDistanceFn;
        /** The function to relative time */
        formatRelative: FormatRelativeFn;
        /** The object with functions used to localize various values */
        localize: Localize;
        /** The object with functions that return localized formats */
        formatLong: FormatLong;
        /** The object with functions used to match and parse various localized values */
        match: Match;
        /** An object with locale options */
        options?: LocaleOptions;
    }
    /**
     * The locale options.
     */
    export interface LocaleOptions extends WeekOptions, FirstWeekContainsDateOptions {
    }
    /**
     * The function that takes a token (i.e. halfAMinute) passed by `formatDistance`
     * or `formatDistanceStrict` and payload, and returns localized distance.
     *
     * @param token - The token to localize
     * @param count - The distance number
     * @param options - The object with options
     *
     * @returns The localized distance in words
     */
    export type FormatDistanceFn = (token: FormatDistanceToken, count: number, options?: FormatDistanceFnOptions) => string;
    /**
     * The {@link FormatDistanceFn} function options.
     */
    export interface FormatDistanceFnOptions {
        /** Add "X ago"/"in X" in the locale language */
        addSuffix?: boolean;
        /** The distance vector. -1 represents past and 1 future. Tells which suffix
         * to use. */
        comparison?: -1 | 0 | 1;
    }
    /**
     * The function used inside the {@link FormatDistanceFn} function, implementing
     * formatting for a particular token.
     */
    export type FormatDistanceTokenFn = (
    /** The distance as number to format */
    count: number, 
    /** The object with options */
    options?: FormatDistanceFnOptions) => string;
    /**
     * The tokens map to string templates used in the format distance function.
     * It looks like this:
     *
     *   const formatDistanceLocale: FormatDistanceLocale<FormatDistanceTokenValue> = {
     *     lessThanXSeconds: 'តិចជាង {{count}} វិនាទី',
     *     xSeconds: '{{count}} វិនាទី',
     *     // ...
     *   }
     *
     * @typeParam Template - The property value type.
     */
    export type FormatDistanceLocale<Template> = {
        [Token in FormatDistanceToken]: Template;
    };
    /**
     * The token used in the format distance function. Represents the distance unit
     * with prespecified precision.
     */
    export type FormatDistanceToken = "lessThanXSeconds" | "xSeconds" | "halfAMinute" | "lessThanXMinutes" | "xMinutes" | "aboutXHours" | "xHours" | "xDays" | "aboutXWeeks" | "xWeeks" | "aboutXMonths" | "xMonths" | "aboutXYears" | "xYears" | "overXYears" | "almostXYears";
    /**
     * The locale function that does the work for the `formatRelative` function.
     *
     * @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 token - The token to localize
     * @param date - The date to format
     * @param baseDate - The date to compare with
     * @param options - The object with options
     *
     * @returns The localized relative date format
     */
    export type FormatRelativeFn = <DateType extends Date>(token: FormatRelativeToken, date: DateType, baseDate: DateType, options?: FormatRelativeFnOptions) => string;
    /**
     * The {@link FormatRelativeFn} function options.
     */
    export interface FormatRelativeFnOptions extends WeekOptions, LocalizedOptions<"options" | "formatRelative"> {
    }
    /**
     * The locale function used inside the {@link FormatRelativeFn} function
     * implementing formatting for a particular token.
     *
     * @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 date - The date to format
     * @param baseDate - The date to compare with
     * @param options - The object with options
     */
    export type FormatRelativeTokenFn = <DateType extends Date>(date: DateArg<DateType>, baseDate: DateArg<DateType>, options?: FormatRelativeTokenFnOptions) => string;
    /**
     * The {@link FormatRelativeTokenFn} function options.
     */
    export interface FormatRelativeTokenFnOptions extends WeekOptions {
    }
    /**
     * The token used in format relative function. Represents the time unit.
     */
    export type FormatRelativeToken = "lastWeek" | "yesterday" | "today" | "tomorrow" | "nextWeek" | "other";
    /**
     * A format part that represents a token or string literal, used by format parser/tokenizer
     */
    export interface FormatPart {
        /** If the part is a format token. */
        isToken: boolean;
        /** The format part value (i.e. `"do"`). */
        value: string;
    }
    /**
     * The object with functions used to localize various values. Part of the public
     * locale API.
     */
    export interface Localize {
        /** The function that localizes an ordinal number */
        ordinalNumber: LocalizeFn<number>;
        /** The function that localized the era */
        era: LocalizeFn<Era>;
        /** The function that localizes the quarter */
        quarter: LocalizeFn<Quarter>;
        /** The function that localizes the month */
        month: LocalizeFn<Month>;
        /** The function that localizes the day of the week */
        day: LocalizeFn<Day>;
        /** The function that localizes the day period */
        dayPeriod: LocalizeFn<LocaleDayPeriod>;
        /** The function that can preprocess parts/tokens **/
        preprocessor?: <DateType extends Date>(date: DateType, parts: FormatPart[]) => FormatPart[];
    }
    /**
     * Individual localize function. Part of {@link Localize}.
     *
     * @typeParam Value - The value type to localize.
     *
     * @param value - The value to localize
     * @param options - The object with options
     *
     * @returns The localized string
     */
    export type LocalizeFn<Value extends LocaleUnitValue | number> = (value: Value, options?: LocalizeFnOptions) => string;
    /**
     * The {@link LocalizeFn} function options.
     */
    export interface LocalizeFnOptions {
        /** The width to use formatting the value, defines how short or long
         * the formatted string might be. */
        width?: LocaleWidth;
        /** The context where the formatted value is used - standalone: the result
         * should make grammatical sense as is and formatting: the result is a part
         * of the formatted string. See: https://date-fns.org/docs/I18n-Contribution-Guide */
        context?: "formatting" | "standalone";
        /** The unit to format */
        unit?: LocaleUnit;
    }
    /**
     * The object with functions used to match and parse various localized values.
     */
    export interface Match {
        /** The function that parses a localized ordinal number. */
        ordinalNumber: MatchFn<number, {
            unit: LocaleUnit;
        }>;
        /** The function that parses a localized era. */
        era: MatchFn<Era>;
        /** The function that parses a localized quarter. */
        quarter: MatchFn<Quarter>;
        /** The function that parses a localized month. */
        month: MatchFn<Month>;
        /** The function that parses a localized day of the week. */
        day: MatchFn<Day>;
        /** The function that parses a localized time of the day. */
        dayPeriod: MatchFn<LocaleDayPeriod>;
    }
    /**
     * The match function. Part of {@link Match}. Implements matcher for particular
     * unit type.
     *
     * @typeParam Result - The matched value type.
     * @typeParam ExtraOptions - The the extra options type.
     *
     * @param str - The string to match
     * @param options - The object with options
     *
     * @returns The match result or null if match failed
     */
    export type MatchFn<Result, ExtraOptions = Record<string, unknown>> = (str: string, options?: MatchFnOptions<Result> & ExtraOptions) => MatchFnResult<Result> | null;
    /**
     * The {@link MatchFn} function options.
     *
     * @typeParam Result - The matched value type.
     */
    export interface MatchFnOptions<Result> {
        /** The width to use matching the value, defines how short or long
         * the matched string might be. */
        width?: LocaleWidth;
        /**
         * @deprecated Map the value manually instead.
         * @example
         * const matchResult = locale.match.ordinalNumber('1st')
         * if (matchResult) {
         *   matchResult.value = valueCallback(matchResult.value)
         * }
         */
        valueCallback?: MatchValueCallback<string, Result>;
    }
    /**
     * The function that allows to map the matched value to the actual type.
     *
     * @typeParam Arg - The argument type.
     * @typeParam Result - The matched value type.
     *
     * @param arg - The value to match
     *
     * @returns The matched value
     */
    export type MatchValueCallback<Arg, Result> = (value: Arg) => Result;
    /**
     * The {@link MatchFn} function result.
     *
     * @typeParam Result - The matched value type.
     */
    export interface MatchFnResult<Result> {
        /** The matched value parsed as the corresponding unit type */
        value: Result;
        /** The remaining string after parsing */
        rest: string;
    }
    /**
     * The object with functions that return localized formats. Long stands for
     * sequence of tokens (i.e. PPpp) that allows to define how format both date
     * and time at once. Part of the public locale API.
     */
    export interface FormatLong {
        /** The function that returns a localized long date format */
        date: FormatLongFn;
        /** The function that returns a localized long time format */
        time: FormatLongFn;
        /** The function that returns a localized format of date and time combined */
        dateTime: FormatLongFn;
    }
    /**
     * The format long function. Formats date, time or both.
     *
     * @param options - The object with options
     *
     * @returns The localized string
     */
    export type FormatLongFn = (options: FormatLongFnOptions) => string;
    /**
     * The {@link FormatLongFn} function options.
     */
    export interface FormatLongFnOptions {
        /** Format width to set */
        width?: FormatLongWidth;
    }
    /**
     * The format long width token, defines how short or long the formnatted value
     * might be. The actual result length is defined by the locale.
     */
    export type FormatLongWidth = "full" | "long" | "medium" | "short" | "any";
    /**
     * The formatting unit value, represents the raw value that can be formatted.
     */
    export type LocaleUnitValue = Era | Quarter | Month | Day | LocaleDayPeriod;
    /**
     * The format width. Defines how short or long the formatted string might be.
     * The actual result length depends on the locale.
     */
    export type LocaleWidth = "narrow" | "short" | "abbreviated" | "wide" | "any";
    /**
     * Token representing particular period of the day.
     */
    export type LocaleDayPeriod = "am" | "pm" | "midnight" | "noon" | "morning" | "afternoon" | "evening" | "night";
    /**
     * The units commonly used in the date formatting or parsing.
     */
    export type LocaleUnit = "second" | "minute" | "hour" | "day" | "dayOfYear" | "date" | "week" | "month" | "quarter" | "year";
}
declare module "date/date-fns/locale/en-US/_lib/formatDistance/index" {
    import type { FormatDistanceFn } from "date/date-fns/locale/types";
    export const formatDistance: FormatDistanceFn;
}
declare module "date/date-fns/locale/_lib/buildFormatLongFn/index" {
    import type { FormatLongFn, FormatLongWidth } from "date/date-fns/locale/types";
    export interface BuildFormatLongFnArgs<DefaultMatchWidth extends FormatLongWidth> {
        formats: Partial<{
            [format in FormatLongWidth]: string;
        }> & {
            [format in DefaultMatchWidth]: string;
        };
        defaultWidth: DefaultMatchWidth;
    }
    export function buildFormatLongFn<DefaultMatchWidth extends FormatLongWidth>(args: BuildFormatLongFnArgs<DefaultMatchWidth>): FormatLongFn;
}
declare module "date/date-fns/locale/en-US/_lib/formatLong/index" {
    import type { FormatLong } from "date/date-fns/locale/types";
    export const formatLong: FormatLong;
}
declare module "date/date-fns/locale/en-US/_lib/formatRelative/index" {
    import type { FormatRelativeFn } from "date/date-fns/locale/types";
    export const formatRelative: FormatRelativeFn;
}
declare module "date/date-fns/locale/_lib/buildLocalizeFn/index" {
    import type { Day, Era, Month, Quarter } from "date/date-fns/types";
    import type { LocaleDayPeriod, LocaleUnitValue, LocaleWidth, LocalizeFn } from "date/date-fns/locale/types";
    export type BuildLocalizeFnArgs<Value extends LocaleUnitValue, ArgCallback extends LocalizeFnArgCallback<Value> | undefined> = {
        values: LocalizePeriodValuesMap<Value>;
        defaultWidth: LocaleWidth;
        formattingValues?: LocalizePeriodValuesMap<Value>;
        defaultFormattingWidth?: LocaleWidth;
    } & (ArgCallback extends undefined ? {
        argumentCallback?: undefined;
    } : {
        argumentCallback?: LocalizeFnArgCallback<Value>;
    });
    /**
     * The localize function argument callback which allows to convert raw value to
     * the actual type.
     *
     * @param value - The value to convert
     *
     * @returns The converted value
     */
    export type LocalizeFnArgCallback<Value extends LocaleUnitValue | number> = (value: Value) => LocalizeUnitIndex<Value>;
    /**
     * The map of localized values for each width.
     */
    export type LocalizePeriodValuesMap<Value extends LocaleUnitValue> = {
        [Pattern in LocaleWidth]?: LocalizeValues<Value>;
    };
    /**
     * The index type of the locale unit value. It types conversion of units of
     * values that don't start at 0 (i.e. quarters).
     */
    export type LocalizeUnitIndex<Value extends LocaleUnitValue | number> = Value extends LocaleUnitValue ? keyof LocalizeValues<Value> : number;
    /**
     * Converts the unit value to the tuple of values.
     */
    export type LocalizeValues<Value extends LocaleUnitValue> = Value extends LocaleDayPeriod ? Record<LocaleDayPeriod, string> : Value extends Era ? LocalizeEraValues : Value extends Quarter ? LocalizeQuarterValues : Value extends Day ? LocalizeDayValues : Value extends Month ? LocalizeMonthValues : never;
    /**
     * The tuple of localized era values. The first element represents BC,
     * the second element represents AD.
     */
    export type LocalizeEraValues = readonly [string, string];
    /**
     * The tuple of localized quarter values. The first element represents Q1.
     */
    export type LocalizeQuarterValues = readonly [string, string, string, string];
    /**
     * The tuple of localized day values. The first element represents Sunday.
     */
    export type LocalizeDayValues = readonly [
        string,
        string,
        string,
        string,
        string,
        string,
        string
    ];
    /**
     * The tuple of localized month values. The first element represents January.
     */
    export type LocalizeMonthValues = readonly [
        string,
        string,
        string,
        string,
        string,
        string,
        string,
        string,
        string,
        string,
        string,
        string
    ];
    export function buildLocalizeFn<Value extends LocaleUnitValue, ArgCallback extends LocalizeFnArgCallback<Value> | undefined>(args: BuildLocalizeFnArgs<Value, ArgCallback>): LocalizeFn<Value>;
}
declare module "date/date-fns/locale/en-US/_lib/localize/index" {
    import type { Localize } from "date/date-fns/locale/types";
    export const localize: Localize;
}
declare module "date/date-fns/locale/_lib/buildMatchFn/index" {
    import type { Quarter, Era, Day, Month } from "date/date-fns/types";
    import type { LocaleUnitValue, LocaleWidth, LocaleDayPeriod, MatchFn, MatchValueCallback } from "date/date-fns/locale/types";
    export interface BuildMatchFnArgs<Result extends LocaleUnitValue, DefaultMatchWidth extends LocaleWidth, DefaultParseWidth extends LocaleWidth> {
        matchPatterns: BuildMatchFnMatchPatterns<DefaultMatchWidth>;
        defaultMatchWidth: DefaultMatchWidth;
        parsePatterns: BuildMatchFnParsePatterns<Result, DefaultParseWidth>;
        defaultParseWidth: DefaultParseWidth;
        valueCallback?: MatchValueCallback<Result extends LocaleDayPeriod ? string : number, Result>;
    }
    export type BuildMatchFnMatchPatterns<DefaultWidth extends LocaleWidth> = {
        [Width in LocaleWidth]?: RegExp;
    } & {
        [Width in DefaultWidth]: RegExp;
    };
    export type BuildMatchFnParsePatterns<Value extends LocaleUnitValue, DefaultWidth extends LocaleWidth> = {
        [Width in LocaleWidth]?: ParsePattern<Value>;
    } & {
        [Width in DefaultWidth]: ParsePattern<Value>;
    };
    export type ParsePattern<Value extends LocaleUnitValue> = Value extends LocaleDayPeriod ? Record<LocaleDayPeriod, RegExp> : Value extends Quarter ? readonly [RegExp, RegExp, RegExp, RegExp] : Value extends Era ? readonly [RegExp, RegExp] : Value extends Day ? readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp] : Value extends Month ? readonly [
        RegExp,
        RegExp,
        RegExp,
        RegExp,
        RegExp,
        RegExp,
        RegExp,
        RegExp,
        RegExp,
        RegExp,
        RegExp,
        RegExp
    ] : never;
    export function buildMatchFn<Value extends LocaleUnitValue, DefaultMatchWidth extends LocaleWidth, DefaultParseWidth extends LocaleWidth>(args: BuildMatchFnArgs<Value, DefaultMatchWidth, DefaultParseWidth>): MatchFn<Value>;
}
declare module "date/date-fns/locale/_lib/buildMatchPatternFn/index" {
    import type { MatchFn, MatchValueCallback } from "date/date-fns/locale/types";
    export interface BuildMatchPatternFnArgs<Result> {
        matchPattern: RegExp;
        parsePattern: RegExp;
        valueCallback?: MatchValueCallback<string, Result>;
    }
    export function buildMatchPatternFn<Result>(args: BuildMatchPatternFnArgs<Result>): MatchFn<Result>;
}
declare module "date/date-fns/locale/en-US/_lib/match/index" {
    import type { Match } from "date/date-fns/locale/types";
    export const match: Match;
}
declare module "date/date-fns/locale/en-US/index" {
    import type { Locale } from "date/date-fns/locale/types";
    /**
     * @category Locales
     * @summary English locale (United States).
     * @language English
     * @iso-639-2 eng
     * @author Sasha Koss [@kossnocorp](https://github.com/kossnocorp)
     * @author Lesha Koss [@leshakoss](https://github.com/leshakoss)
     */
    export const enUS: Locale;
}
declare module "date/date-fns/_lib/defaultLocale/index" {
    export { enUS as defaultLocale } from "date/date-fns/locale/en-US/index";
}
declare module "date/date-fns/_lib/format/longFormatters/index" {
    import type { FormatLong } from "date/date-fns/locale/types";
    type LongFormatter = (pattern: string, formatLong: FormatLong) => string;
    export const longFormatters: Record<string, LongFormatter>;
}
declare module "date/date-fns/_lib/protectedTokens/index" {
    export function isProtectedDayOfYearToken(token: string): boolean;
    export function isProtectedWeekYearToken(token: string): boolean;
    export function warnOrThrowProtectedError(token: string, format: string, input: string): void;
}
declare module "date/date-fns/constructFrom/index" {
    import type { ConstructableDate, ContextFn, DateArg } from "date/date-fns/types";
    /**
     * @name constructFrom
     * @category Generic Helpers
     * @summary Constructs a date using the reference date and the value
     *
     * @description
     * The function constructs a new date using the constructor from the reference
     * date and the given value. It helps to build generic functions that accept
     * date extensions.
     *
     * It defaults to `Date` if the passed reference date is a number or a string.
     *
     * Starting from v3.7.0, it allows to construct a date using `[Symbol.for("constructDateFrom")]`
     * enabling to transfer extra properties from the reference date to the new date.
     * It's useful for extensions like [`TZDate`](https://github.com/date-fns/tz)
     * that accept a time zone as a constructor argument.
     *
     * @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 date - The reference date to take constructor from
     * @param value - The value to create the date
     *
     * @returns Date initialized using the given date and value
     *
     * @example
     * import { constructFrom } from 'date-fns';
     *
     * // A function that clones a date preserving the original type
     * function cloneDate<DateType extends Date>(date: DateType): DateType {
     *   return constructFrom(
     *     date, // Use constructor from the given date
     *     date.getTime() // Use the date value to create a new date
     *   );
     * }
     */
    export function constructFrom<DateType extends Date | ConstructableDate, ResultDate extends Date = DateType>(date: DateArg<DateType> | ContextFn<ResultDate> | undefined, value: DateArg<Date> & {}): ResultDate;
}
declare module "date/date-fns/_lib/defaultOptions/index" {
    import type { FirstWeekContainsDateOptions, Locale, LocalizedOptions, WeekOptions } from "date/date-fns/types";
    export type DefaultOptions = LocalizedOptions<keyof Locale> & WeekOptions & FirstWeekContainsDateOptions;
    export function getDefaultOptions(): DefaultOptions;
    export function setDefaultOptions(newOptions: DefaultOptions): void;
}
declare module "date/date-fns/getDefaultOptions/index" {
    import type { DefaultOptions } from "date/date-fns/_lib/defaultOptions/index";
    /**
     * @name getDefaultOptions
     * @category Common Helpers
     * @summary Get default options.
     * @pure false
     *
     * @description
     * Returns an object that contains defaults for
     * `options.locale`, `options.weekStartsOn` and `options.firstWeekContainsDate`
     * arguments for all functions.
     *
     * You can change these with [setDefaultOptions](https://date-fns.org/docs/setDefaultOptions).
     *
     * @returns The default options
     *
     * @example
     * const result = getDefaultOptions()
     * //=> {}
     *
     * @example
     * setDefaultOptions({ weekStarsOn: 1, firstWeekContainsDate: 4 })
     * const result = getDefaultOptions()
     * //=> { weekStarsOn: 1, firstWeekContainsDate: 4 }
     */
    export function getDefaultOptions(): DefaultOptions;
}
declare module "date/date-fns/toDate/index" {
    import type { ConstructableDate, ContextFn, DateArg } from "date/date-fns/types";
    /**
     * @name toDate
     * @category Common Helpers
     * @summary Convert the given argument to an instance of Date.
     *
     * @description
     * Convert the given argument to an instance of Date.
     *
     * If the argument is an instance of Date, the function returns its clone.
     *
     * If the argument is a number, it is treated as a timestamp.
     *
     * If the argument is none of the above, the function returns Invalid Date.
     *
     * Starting from v3.7.0, it clones a date using `[Symbol.for("constructDateFrom")]`
     * enabling to transfer extra properties from the reference date to the new date.
     * It's useful for extensions like [`TZDate`](https://github.com/date-fns/tz)
     * that accept a time zone as a constructor argument.
     *
     * **Note**: *all* Date arguments passed to any *date-fns* function is processed by `toDate`.
     *
     * @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 argument - The value to convert
     *
     * @returns The parsed date in the local time zone
     *
     * @example
     * // Clone the date:
     * const result = toDate(new Date(2014, 1, 11, 11, 30, 30))
     * //=> Tue Feb 11 2014 11:30:30
     *
     * @example
     * // Convert the timestamp to date:
     * const result = toDate(1392098430000)
     * //=> Tue Feb 11 2014 11:30:30
     */
    export function toDate<DateType extends Date | ConstructableDate, ResultDate extends Date = DateType>(argument: DateArg<DateType>, context?: ContextFn<ResultDate> | undefined): ResultDate;
}
declare module "date/date-fns/transpose/index" {
    import type { ContextFn, GenericDateConstructor } from "date/date-fns/types";
    /**
     * @name transpose
     * @category Generic Helpers
     * @summary Transpose the date to the given constructor.
     *
     * @description
     * The function transposes the date to the given constructor. It helps you
     * to transpose the date in the system time zone to say `UTCDate` or any other
     * date extension.
     *
     * @typeParam InputDate - The input `Date` type derived from the passed argument.
     * @typeParam ResultDate - The result `Date` type derived from the passed constructor.
     *
     * @param date - The date to use values from
     * @param constructor - The date constructor to use
     *
     * @returns Date transposed to the given constructor
     *
     * @example
     * // Create July 10, 2022 00:00 in locale time zone
     * const date = new Date(2022, 6, 10)
     * //=> 'Sun Jul 10 2022 00:00:00 GMT+0800 (Singapore Standard Time)'
     *
     * @example
     * // Transpose the date to July 10, 2022 00:00 in UTC
     * transpose(date, UTCDate)
     * //=> 'Sun Jul 10 2022 00:00:00 GMT+0000 (Coordinated Universal Time)'
     */
    export function transpose<InputDate extends Date, ResultDate extends Date>(date: InputDate, constructor: ResultDate | GenericDateConstructor<ResultDate> | ContextFn<ResultDate>): ResultDate;
}
declare module "date/date-fns/parse/_lib/types" {
    import type { LocalizedOptions, FirstWeekContainsDateOptions, WeekOptions } from "date/date-fns/types";
    export interface ParseFlags {
        timestampIsSet?: boolean;
        era?: number;
    }
    export type ParserOptions = Required<LocalizedOptions<"options"> & FirstWeekContainsDateOptions & WeekOptions>;
    export type ParseResult<TValue> = {
        value: TValue;
        rest: string;
    } | null;
}
declare module "date/date-fns/parse/_lib/Setter" {
    import type { ContextFn, DateArg } from "date/date-fns/types";
    import type { ParseFlags, ParserOptions } from "date/date-fns/parse/_lib/types";
    export abstract class Setter {
        abstract priority: number;
        subPriority: number;
        validate<DateType extends Date>(_utcDate: DateType, _options?: ParserOptions): boolean;
        abstract set<DateType extends Date>(date: DateType, flags: ParseFlags, options: ParserOptions): DateType | [DateType, ParseFlags];
    }
    export class ValueSetter<Value> extends Setter {
        private value;
        private validateValue;
        private setValue;
        priority: number;
        constructor(value: Value, validateValue: <DateType extends Date>(date: DateType, value: Value, options: ParserOptions) => boolean, setValue: <DateType extends Date>(date: DateType, flags: ParseFlags, value: Value, options: ParserOptions) => DateType | [DateType, ParseFlags], priority: number, subPriority?: number);
        validate<DateType extends Date>(date: DateType, options: ParserOptions): boolean;
        set<DateType extends Date>(date: DateType, flags: ParseFlags, options: ParserOptions): DateType | [DateType, ParseFlags];
    }
    export class DateTimezoneSetter extends Setter {
        priority: number;
        subPriority: number;
        context: ContextFn<Date>;
        constructor(context: ContextFn<Date> | undefined, reference: DateArg<Date> & {});
        set<DateType extends Date>(date: DateType, flags: ParseFlags): DateType;
    }
}
declare module "date/date-fns/parse/_lib/Parser" {
    import type { Match } from "date/date-fns/locale/types";
    import { ValueSetter } from "date/date-fns/parse/_lib/Setter";
    import type { ParseFlags, ParseResult, ParserOptions } from "date/date-fns/parse/_lib/types";
    export abstract class Parser<Value> {
        abstract incompatibleTokens: string[] | "*";
        abstract priority: number;
        subPriority?: number;
        run(dateString: string, token: string, match: Match, options: ParserOptions): {
            setter: ValueSetter<Value>;
            rest: string;
        } | null;
        protected abstract parse(dateString: string, token: string, match: Match, options: ParserOptions): ParseResult<Value>;
        protected validate<DateType extends Date>(_utcDate: DateType, _value: Value, _options: ParserOptions): boolean;
        protected abstract set<DateType extends Date>(date: DateType, flags: ParseFlags, value: Value, options: ParserOptions): DateType | [DateType, ParseFlags];
    }
}
declare module "date/date-fns/parse/_lib/constants" {
    export const numericPatterns: {
        month: RegExp;
        date: RegExp;
        singleDigit: RegExp;
        twoDigits: RegExp;
        threeDigits: RegExp;
        fourDigits: RegExp;
        anyDigitsSigned: RegExp;
        singleDigitSigned: RegExp;
        twoDigitsSigned: RegExp;
        threeDigitsSigned: RegExp;
        fourDigitsSigned: RegExp;
    };
}
declare module "date/date-fns/parse/_lib/utils" {
    import type { ParseResult } from "date/date-fns/parse/_lib/types";
    export function mapValue<TInput, TResult>(parseFnResult: ParseResult<TInput>, mapFn: (value: TInput) => TResult): ParseResult<TResult>;
    export function parseNumericPattern(pattern: RegExp, dateString: string): ParseResult<number>;
    export function parseTimezonePattern(pattern: RegExp, dateString: string): ParseResult<number>;
    export function parseAnyDigitsSigned(dateString: string): ParseResult<number>;
    export function parseNDigits(n: number, dateString: string): ParseResult<number>;
    export function parseNDigitsSigned(n: number, dateString: string): ParseResult<number>;
    export function normalizeTwoDigitYear(twoDigitYear: number, currentYear: number): number;
    export function isLeapYearIndex(year: number): boolean;
}
declare module "date/date-fns/parse/_lib/parsers/YearParser" {
    import type { Match } from "date/date-fns/locale/types";
    import { Parser } from "date/date-fns/parse/_lib/Parser";
    import type { ParseFlags, ParseResult } from "date/date-fns/parse/_lib/types";
    export interface YearParserValue {
        year: number;
        isTwoDigitYear: boolean;
    }
    export class YearParser extends Parser<YearParserValue> {
        priority: number;
        incompatibleTokens: string[];
        parse(dateString: string, token: string, match: Match): ParseResult<YearParserValue>;
        validate<DateType extends Date>(_date: DateType, value: YearParserValue): boolean;
        set<DateType extends Date>(date: DateType, flags: ParseFlags, value: YearParserValue): DateType;
    }
}
declare module "date/date-fns/parse/_lib/parsers/MonthParser" {
    import type { Match } from "date/date-fns/locale/types";
    import { Parser } from "date/date-fns/parse/_lib/Parser";
    import type { ParseFlags, ParseResult } from "date/date-fns/parse/_lib/types";
    export class MonthParser extends Parser<number> {
        incompatibleTokens: string[];
        priority: number;
        parse(dateString: string, token: string, match: Match): ParseResult<number>;
        validate<DateType extends Date>(_date: DateType, value: number): boolean;
        set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType;
    }
}
declare module "date/date-fns/parse/_lib/parsers/DateParser" {
    import type { Match } from "date/date-fns/locale/types";
    import { Parser } from "date/date-fns/parse/_lib/Parser";
    import type { ParseFlags, ParseResult } from "date/date-fns/parse/_lib/types";
    export class DateParser extends Parser<number> {
        priority: number;
        subPriority: number;
        parse(dateString: string, token: string, match: Match): ParseResult<number>;
        validate<DateType extends Date>(date: DateType, value: number): boolean;
        set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType;
        incompatibleTokens: string[];
    }
}
declare module "date/date-fns/addDays/index" {
    import type { ContextOptions, DateArg } from "date/date-fns/types";
    /**
     * The {@link addDays} function options.
     */
    export interface AddDaysOptions<DateType extends Date = Date> extends ContextOptions<DateType> {
    }
    /**
     * @name addDays
     * @category Day Helpers
     * @summary Add the specified number of days to the given date.
     *
     * @description
     * Add the specified number of days to the given 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).
     * @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 date to be changed
     * @param amount - The amount of days to be added.
     * @param options - An object with options
     *
     * @returns The new date with the days added
     *
     * @example
     * // Add 10 days to 1 September 2014:
     * const result = addDays(new Date(2014, 8, 1), 10)
     * //=> Thu Sep 11 2014 00:00:00
     */
    export function addDays<DateType extends Date, ResultDate extends Date = DateType>(date: DateArg<DateType>, amount: number, options?: AddDaysOptions<ResultDate> | undefined): ResultDate;
}
declare module "date/date-fns/setDay/index" {
    import type { ContextOptions, DateArg, LocalizedOptions, WeekOptions } from "date/date-fns/types";
    /**
     * The {@link setDay} function options.
     */
    export interface SetDayOptions<DateType extends Date = Date> extends LocalizedOptions<"options">, WeekOptions, ContextOptions<DateType> {
    }
    /**
     * @name setDay
     * @category Weekday Helpers
     * @summary Set the day of the week to the given date.
     *
     * @description
     * Set the day of the week to the given 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).
     * @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 date to be changed
     * @param day - The day of the week of the new date
     * @param options - An object with options.
     *
     * @returns The new date with the day of the week set
     *
     * @example
     * // Set week day to Sunday, with the default weekStartsOn of Sunday:
     * const result = setDay(new Date(2014, 8, 1), 0)
     * //=> Sun Aug 31 2014 00:00:00
     *
     * @example
     * // Set week day to Sunday, with a weekStartsOn of Monday:
     * const result = setDay(new Date(2014, 8, 1), 0, { weekStartsOn: 1 })
     * //=> Sun Sep 07 2014 00:00:00
     */
    export function setDay<DateType extends Date, ResultDate extends Date = DateType>(date: DateArg<DateType>, day: number, options?: SetDayOptions<ResultDate>): ResultDate;
}
declare module "date/date-fns/parse/_lib/parsers/DayParser" {
    import type { Match } from "date/date-fns/locale/types";
    import { Parser } from "date/date-fns/parse/_lib/Parser";
    import type { ParseFlags, ParseResult, ParserOptions } from "date/date-fns/parse/_lib/types";
    export class DayParser extends Parser<number> {
        priority: number;
        parse(dateString: string, token: string, match: Match): ParseResult<number>;
        validate<DateType extends Date>(_date: DateType, value: number): boolean;
        set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number, options: ParserOptions): DateType;
        incompatibleTokens: string[];
    }
}
declare module "date/date-fns/parse/_lib/parsers/index" {
    import type { Parser } from "date/date-fns/parse/_lib/Parser";
    export const parsers: Record<string, Parser<any>>;
}
declare module "date/date-fns/parse/index" {
    import { longFormatters } from "date/date-fns/_lib/format/longFormatters/index";
    import type { AdditionalTokensOptions, ContextOptions, DateArg, FirstWeekContainsDateOptions, LocalizedOptions, WeekOptions } from "date/date-fns/types";
    import { parsers } from "date/date-fns/parse/_lib/parsers/index";
    export { longFormatters, parsers };
    /**
     * The {@link parse} function options.
     */
    export interface ParseOptions<DateType extends Date = Date> extends LocalizedOptions<"options" | "match" | "formatLong">, FirstWeekContainsDateOptions, WeekOptions, AdditionalTokensOptions, ContextOptions<DateType> {
    }
    /**
     * @name parse
     * @category Common Helpers
     * @summary Parse the date.
     *
     * @description
     * Return the date parsed from string using the given format string.
     *
     * > ⚠️ Please note that the `format` tokens differ from Moment.js and other libraries.
     * > See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
     *
     * The characters in the format string wrapped between two single quotes characters (') are escaped.
     * Two single quotes in a row, whether inside or outside a quoted sequence, represent a 'real' single quote.
     *
     * Format of the format string is based on Unicode Technical Standard #35:
     * https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
     * with a few additions (see note 5 below the table).
     *
     * Not all tokens are compatible. Combinations that don't make sense or could lead to bugs are prohibited
     * and will throw `RangeError`. For example usage of 24-hour format token with AM/PM token will throw an exception:
     *
     * ```javascript
     * parse('23 AM', 'HH a', new Date())
     * //=> RangeError: The format string mustn't contain `HH` and `a` at the same time
     * ```
     *
     * See the compatibility table: https://docs.google.com/spreadsheets/d/e/2PACX-1vQOPU3xUhplll6dyoMmVUXHKl_8CRDs6_ueLmex3SoqwhuolkuN3O05l4rqx5h1dKX8eb46Ul-CCSrq/pubhtml?gid=0&single=true
     *
     * Accepted format string patterns:
     * | Unit                            |Prior| Pattern | Result examples                   | Notes |
     * |---------------------------------|-----|---------|-----------------------------------|-------|
     * | Era                             | 140 | G..GGG  | AD, BC                            |       |
     * |                                 |     | GGGG    | Anno Domini, Before Christ        | 2     |
     * |                                 |     | GGGGG   | A, B                              |       |
     * | Calendar year                   | 130 | y       | 44, 1, 1900, 2017, 9999           | 4     |
     * |                                 |     | yo      | 44th, 1st, 1900th, 9999999th      | 4,5   |
     * |                                 |     | yy      | 44, 01, 00, 17                    | 4     |
     * |                                 |     | yyy     | 044, 001, 123, 999                | 4     |
     * |                                 |     | yyyy    | 0044, 0001, 1900, 2017            | 4     |
     * |                                 |     | yyyyy   | ...                               | 2,4   |
     * | Local week-numbering year       | 130 | Y       | 44, 1, 1900, 2017, 9000           | 4     |
     * |                                 |     | Yo      | 44th, 1st, 1900th, 9999999th      | 4,5   |
     * |                                 |     | YY      | 44, 01, 00, 17                    | 4,6   |
     * |                                 |     | YYY     | 044, 001, 123, 999                | 4     |
     * |                                 |     | YYYY    | 0044, 0001, 1900, 2017            | 4,6   |
     * |                                 |     | YYYYY   | ...                               | 2,4   |
     * | ISO week-numbering year         | 130 | R       | -43, 1, 1900, 2017, 9999, -9999   | 4,5   |
     * |                                 |     | RR      | -43, 01, 00, 17                   | 4,5   |
     * |                                 |     | RRR     | -043, 001, 123, 999, -999         | 4,5   |
     * |                                 |     | RRRR    | -0043, 0001, 2017, 9999, -9999    | 4,5   |
     * |                                 |     | RRRRR   | ...                               | 2,4,5 |
     * | Extended year                   | 130 | u       | -43, 1, 1900, 2017, 9999, -999    | 4     |
     * |                                 |     | uu      | -43, 01, 99, -99                  | 4     |
     * |                                 |     | uuu     | -043, 001, 123, 999, -999         | 4     |
     * |                                 |     | uuuu    | -0043, 0001, 2017, 9999, -9999    | 4     |
     * |                                 |     | uuuuu   | ...                               | 2,4   |
     * | Quarter (formatting)            | 120 | Q       | 1, 2, 3, 4                        |       |
     * |                                 |     | Qo      | 1st, 2nd, 3rd, 4th                | 5     |
     * |                                 |     | QQ      | 01, 02, 03, 04                    |       |
     * |                                 |     | QQQ     | Q1, Q2, Q3, Q4                    |       |
     * |                                 |     | QQQQ    | 1st quarter, 2nd quarter, ...     | 2     |
     * |                                 |     | QQQQQ   | 1, 2, 3, 4                        | 4     |
     * | Quarter (stand-alone)           | 120 | q       | 1, 2, 3, 4                        |       |
     * |                                 |     | qo      | 1st, 2nd, 3rd, 4th                | 5     |
     * |                                 |     | qq      | 01, 02, 03, 04                    |       |
     * |                                 |     | qqq     | Q1, Q2, Q3, Q4                    |       |
     * |                                 |     | qqqq    | 1st quarter, 2nd quarter, ...     | 2     |
     * |                                 |     | qqqqq   | 1, 2, 3, 4                        | 3     |
     * | Month (formatting)              | 110 | M       | 1, 2, ..., 12                     |       |
     * |                                 |     | Mo      | 1st, 2nd, ..., 12th               | 5     |
     * |                                 |     | MM      | 01, 02, ..., 12                   |       |
     * |                                 |     | MMM     | Jan, Feb, ..., Dec                |       |
     * |                                 |     | MMMM    | January, February, ..., December  | 2     |
     * |                                 |     | MMMMM   | J, F, ..., D                      |       |
     * | Month (stand-alone)             | 110 | L       | 1, 2, ..., 12                     |       |
     * |                                 |     | Lo      | 1st, 2nd, ..., 12th               | 5     |
     * |                                 |     | LL      | 01, 02, ..., 12                   |       |
     * |                                 |     | LLL     | Jan, Feb, ..., Dec                |       |
     * |                                 |     | LLLL    | January, February, ..., December  | 2     |
     * |                                 |     | LLLLL   | J, F, ..., D                      |       |
     * | Local week of year              | 100 | w       | 1, 2, ..., 53                     |       |
     * |                                 |     | wo      | 1st, 2nd, ..., 53th               | 5     |
     * |                                 |     | ww      | 01, 02, ..., 53                   |       |
     * | ISO week of year                | 100 | I       | 1, 2, ..., 53                     | 5     |
     * |                                 |     | Io      | 1st, 2nd, ..., 53th               | 5     |
     * |                                 |     | II      | 01, 02, ..., 53                   | 5     |
     * | Day of month                    |  90 | d       | 1, 2, ..., 31                     |       |
     * |                                 |     | do      | 1st, 2nd, ..., 31st               | 5     |
     * |                                 |     | dd      | 01, 02, ..., 31                   |       |
     * | Day of year                     |  90 | D       | 1, 2, ..., 365, 366               | 7     |
     * |                                 |     | Do      | 1st, 2nd, ..., 365th, 366th       | 5     |
     * |                                 |     | DD      | 01, 02, ..., 365, 366             | 7     |
     * |                                 |     | DDD     | 001, 002, ..., 365, 366           |       |
     * |                                 |     | DDDD    | ...                               | 2     |
     * | Day of week (formatting)        |  90 | E..EEE  | Mon, Tue, Wed, ..., Sun           |       |
     * |                                 |     | EEEE    | Monday, Tuesday, ..., Sunday      | 2     |
     * |                                 |     | EEEEE   | M, T, W, T, F, S, S               |       |
     * |                                 |     | EEEEEE  | Mo, Tu, We, Th, Fr, Sa, Su        |       |
     * | ISO day of week (formatting)    |  90 | i       | 1, 2, 3, ..., 7                   | 5     |
     * |                                 |     | io      | 1st, 2nd, ..., 7th                | 5     |
     * |                                 |     | ii      | 01, 02, ..., 07                   | 5     |
     * |                                 |     | iii     | Mon, Tue, Wed, ..., Sun           | 5     |
     * |                                 |     | iiii    | Monday, Tuesday, ..., Sunday      | 2,5   |
     * |                                 |     | iiiii   | M, T, W, T, F, S, S               | 5     |
     * |                                 |     | iiiiii  | Mo, Tu, We, Th, Fr, Sa, Su        | 5     |
     * | Local day of week (formatting)  |  90 | e       | 2, 3, 4, ..., 1                   |       |
     * |                                 |     | eo      | 2nd, 3rd, ..., 1st                | 5     |
     * |                                 |     | ee      | 02, 03, ..., 01                   |       |
     * |                                 |     | eee     | Mon, Tue, Wed, ..., Sun           |       |
     * |                                 |     | eeee    | Monday, Tuesday, ..., Sunday      | 2     |
     * |                                 |     | eeeee   | M, T, W, T, F, S, S               |       |
     * |                                 |     | eeeeee  | Mo, Tu, We, Th, Fr, Sa, Su        |       |
     * | Local day of week (stand-alone) |  90 | c       | 2, 3, 4, ..., 1                   |       |
     * |                                 |     | co      | 2nd, 3rd, ..., 1st                | 5     |
     * |                                 |     | cc      | 02, 03, ..., 01                   |       |
     * |                                 |     | ccc     | Mon, Tue, Wed, ..., Sun           |       |
     * |                                 |     | cccc    | Monday, Tuesday, ..., Sunday      | 2     |
     * |                                 |     | ccccc   | M, T, W, T, F, S, S               |       |
     * |                                 |     | cccccc  | Mo, Tu, We, Th, Fr, Sa, Su        |       |
     * | AM, PM                          |  80 | a..aaa  | AM, PM                            |       |
     * |                                 |     | aaaa    | a.m., p.m.                        | 2     |
     * |                                 |     | aaaaa   | a, p                              |       |
     * | AM, PM, noon, midnight          |  80 | b..bbb  | AM, PM, noon, midnight            |       |
     * |                                 |     | bbbb    | a.m., p.m., noon, midnight        | 2     |
     * |                                 |     | bbbbb   | a, p, n, mi                       |       |
     * | Flexible day period             |  80 | B..BBB  | at night, in the morning, ...     |       |
     * |                                 |     | BBBB    | at night, in the morning, ...     | 2     |
     * |                                 |     | BBBBB   | at night, in the morning, ...     |       |
     * | Hour [1-12]                     |  70 | h       | 1, 2, ..., 11, 12                 |       |
     * |                                 |     | ho      | 1st, 2nd, ..., 11th, 12th         | 5     |
     * |                                 |     | hh      | 01, 02, ..., 11, 12               |       |
     * | Hour [0-23]                     |  70 | H       | 0, 1, 2, ..., 23                  |       |
     * |                                 |     | Ho      | 0th, 1st, 2nd, ..., 23rd          | 5     |
     * |                                 |     | HH      | 00, 01, 02, ..., 23               |       |
     * | Hour [0-11]                     |  70 | K       | 1, 2, ..., 11, 0                  |       |
     * |                                 |     | Ko      | 1st, 2nd, ..., 11th, 0th          | 5     |
     * |                                 |     | KK      | 01, 02, ..., 11, 00               |       |
     * | Hour [1-24]                     |  70 | k       | 24, 1, 2, ..., 23                 |       |
     * |                                 |     | ko      | 24th, 1st, 2nd, ..., 23rd         | 5     |
     * |                                 |     | kk      | 24, 01, 02, ..., 23               |       |
     * | Minute                          |  60 | m       | 0, 1, ..., 59                     |       |
     * |                                 |     | mo      | 0th, 1st, ..., 59th               | 5     |
     * |                                 |     | mm      | 00, 01, ..., 59                   |       |
     * | Second                          |  50 | s       | 0, 1, ..., 59                     |       |
     * |                                 |     | so      | 0th, 1st, ..., 59th               | 5     |
     * |                                 |     | ss      | 00, 01, ..., 59                   |       |
     * | Seconds timestamp               |  40 | t       | 512969520                         |       |
     * |                                 |     | tt      | ...                               | 2     |
     * | Fraction of second              |  30 | S       | 0, 1, ..., 9                      |       |
     * |                                 |     | SS      | 00, 01, ..., 99                   |       |
     * |                                 |     | SSS     | 000, 001, ..., 999                |       |
     * |                                 |     | SSSS    | ...                               | 2     |
     * | Milliseconds timestamp          |  20 | T       | 512969520900                      |       |
     * |                                 |     | TT      | ...                               | 2     |
     * | Timezone (ISO-8601 w/ Z)        |  10 | X       | -08, +0530, Z                     |       |
     * |                                 |     | XX      | -0800, +0530, Z                   |       |
     * |                                 |     | XXX     | -08:00, +05:30, Z                 |       |
     * |                                 |     | XXXX    | -0800, +0530, Z, +123456          | 2     |
     * |                                 |     | XXXXX   | -08:00, +05:30, Z, +12:34:56      |       |
     * | Timezone (ISO-8601 w/o Z)       |  10 | x       | -08, +0530, +00                   |       |
     * |                                 |     | xx      | -0800, +0530, +0000               |       |
     * |                                 |     | xxx     | -08:00, +05:30, +00:00            | 2     |
     * |                                 |     | xxxx    | -0800, +0530, +0000, +123456      |       |
     * |                                 |     | xxxxx   | -08:00, +05:30, +00:00, +12:34:56 |       |
     * | Long localized date             |  NA | P       | 05/29/1453                        | 5,8   |
     * |                                 |     | PP      | May 29, 1453                      |       |
     * |                                 |     | PPP     | May 29th, 1453                    |       |
     * |                                 |     | PPPP    | Sunday, May 29th, 1453            | 2,5,8 |
     * | Long localized time             |  NA | p       | 12:00 AM                          | 5,8   |
     * |                                 |     | pp      | 12:00:00 AM                       |       |
     * | Combination of date and time    |  NA | Pp      | 05/29/1453, 12:00 AM              |       |
     * |                                 |     | PPpp    | May 29, 1453, 12:00:00 AM         |       |
     * |                                 |     | PPPpp   | May 29th, 1453 at ...             |       |
     * |                                 |     | PPPPpp  | Sunday, May 29th, 1453 at ...     | 2,5,8 |
     * Notes:
     * 1. "Formatting" units (e.g. formatting quarter) in the default en-US locale
     *    are the same as "stand-alone" units, but are different in some languages.
     *    "Formatting" units are declined according to the rules of the language
     *    in the context of a date. "Stand-alone" units are always nominative singular.
     *    In `format` function, they will produce different result:
     *
     *    `format(new Date(2017, 10, 6), 'do LLLL', {locale: cs}) //=> '6. listopad'`
     *
     *    `format(new Date(2017, 10, 6), 'do MMMM', {locale: cs}) //=> '6. listopadu'`
     *
     *    `parse` will try to match both formatting and stand-alone units interchangeably.
     *
     * 2. Any sequence of the identical letters is a pattern, unless it is escaped by
     *    the single quote characters (see below).
     *    If the sequence is longer than listed in table:
     *    - for numerical units (`yyyyyyyy`) `parse` will try to match a number
     *      as wide as the sequence
     *    - for text units (`MMMMMMMM`) `parse` will try to match the widest variation of the unit.
     *      These variations are marked with "2" in the last column of the table.
     *
     * 3. `QQQQQ` and `qqqqq` could be not strictly numerical in some locales.
     *    These tokens represent the shortest form of the quarter.
     *
     * 4. The main difference between `y` and `u` patterns are B.C. years:
     *
     *    | Year | `y` | `u` |
     *    |------|-----|-----|
     *    | AC 1 |   1 |   1 |
     *    | BC 1 |   1 |   0 |
     *    | BC 2 |   2 |  -1 |
     *
     *    Also `yy` will try to guess the century of two digit year by proximity with `referenceDate`:
     *
     *    `parse('50', 'yy', new Date(2018, 0, 1)) //=> Sat Jan 01 2050 00:00:00`
     *
     *    `parse('75', 'yy', new Date(2018, 0, 1)) //=> Wed Jan 01 1975 00:00:00`
     *
     *    while `uu` will just assign the year as is:
     *
     *    `parse('50', 'uu', new Date(2018, 0, 1)) //=> Sat Jan 01 0050 00:00:00`
     *
     *    `parse('75', 'uu', new Date(2018, 0, 1)) //=> Tue Jan 01 0075 00:00:00`
     *
     *    The same difference is true for local and ISO week-numbering years (`Y` and `R`),
     *    except local week-numbering years are dependent on `options.weekStartsOn`
     *    and `options.firstWeekContainsDate` (compare [setISOWeekYear](https://date-fns.org/docs/setISOWeekYear)
     *    and [setWeekYear](https://date-fns.org/docs/setWeekYear)).
     *
     * 5. These patterns are not in the Unicode Technical Standard #35:
     *    - `i`: ISO day of week
     *    - `I`: ISO week of year
     *    - `R`: ISO week-numbering year
     *    - `o`: ordinal number modifier
     *    - `P`: long localized date
     *    - `p`: long localized time
     *
     * 6. `YY` and `YYYY` tokens represent week-numbering years but they are often confused with years.
     *    You should enable `options.useAdditionalWeekYearTokens` to use them. See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
     *
     * 7. `D` and `DD` tokens represent days of the year but they are often confused with days of the month.
     *    You should enable `options.useAdditionalDayOfYearTokens` to use them. See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
     *
     * 8. `P+` tokens do not have a defined priority since they are merely aliases to other tokens based
     *    on the given locale.
     *
     *    using `en-US` locale: `P` => `MM/dd/yyyy`
     *    using `en-US` locale: `p` => `hh:mm a`
     *    using `pt-BR` locale: `P` => `dd/MM/yyyy`
     *    using `pt-BR` locale: `p` => `HH:mm`
     *
     * Values will be assigned to the date in the descending order of its unit's priority.
     * Units of an equal priority overwrite each other in the order of appearance.
     *
     * If no values of higher priority are parsed (e.g. when parsing string 'January 1st' without a year),
     * the values will be taken from 3rd argument `referenceDate` which works as a context of parsing.
     *
     * `referenceDate` must be passed for correct work of the function.
     * If you're not sure which `referenceDate` to supply, create a new instance of Date:
     * `parse('02/11/2014', 'MM/dd/yyyy', new Date())`
     * In this case parsing will be done in the context of the current date.
     * If `referenceDate` is `Invalid Date` or a value not convertible to valid `Date`,
     * then `Invalid Date` will be returned.
     *
     * The result may vary by locale.
     *
     * If `formatString` matches with `dateString` but does not provides tokens, `referenceDate` will be returned.
     *
     * If parsing failed, `Invalid Date` will be returned.
     * Invalid Date is a Date, whose time value is NaN.
     * Time value of Date: http://es5.github.io/#x15.9.1.1
     *
     * @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 dateStr - The string to parse
     * @param formatStr - The string of tokens
     * @param referenceDate - defines values missing from the parsed dateString
     * @param options - An object with options.
     *   see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
     *   see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
     *
     * @returns The parsed date
     *
     * @throws `options.locale` must contain `match` property
     * @throws use `yyyy` instead of `YYYY` for formatting years using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
     * @throws use `yy` instead of `YY` for formatting years using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
     * @throws use `d` instead of `D` for formatting days of the month using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
     * @throws use `dd` instead of `DD` for formatting days of the month using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
     * @throws format string contains an unescaped latin alphabet character
     *
     * @example
     * // Parse 11 February 2014 from middle-endian format:
     * var result = parse('02/11/2014', 'MM/dd/yyyy', new Date())
     * //=> Tue Feb 11 2014 00:00:00
     *
     * @example
     * // Parse 28th of February in Esperanto locale in the context of 2010 year:
     * import eo from 'date-fns/locale/eo'
     * var result = parse('28-a de februaro', "do 'de' MMMM", new Date(2010, 0, 1), {
     *   locale: eo
     * })
     * //=> Sun Feb 28 2010 00:00:00
     */
    export function parse<DateType extends Date, ResultDate extends Date = DateType>(dateStr: string, formatStr: string, referenceDate: DateArg<DateType>, options?: ParseOptions<ResultDate>): ResultDate;
}
declare module "date/_StrictMonthParser" {
    import type { Match } from "date/date-fns/locale/types";
    import type { ParseResult } from "date/date-fns/parse/_lib/types";
    import { MonthParser } from "date/date-fns/parse/_lib/parsers/MonthParser";
    /**
     * Modified version of the MonthParser that only tries the format that was provided without falling back.
     */
    export class _StrictMonthParser extends MonthParser {
        parse(dateString: string, token: string, match: Match): ParseResult<number>;
    }
}
declare module "date/_DateUtils" {
    /**
     * Test if a type is a date.
     * @remarks
     * Dates across frame boundaries loose instanceof and new Date('test') is an invalid date.
     * @param d across frame boundary
     * @returns A flag indicating if the value is a date object.
     */
    export const isValidDate: (d: any) => boolean;
    export const minutesSinceMidnight: (date: Date) => number;
    export const dayDiff: (d1: Date, d2: Date) => number;
    export const monthDiff: (startDate: Date, endDate: Date) => number;
    export const yearDiff: (d1: Date, d2: Date) => number;
    export const dateUnitDiff: (d1: Date, d2: Date, unit: string) => number;
    export const DateUnit: {
        readonly Day: "d";
        readonly Month: "m";
        readonly Year: "y";
    };
    export type DateUnit = typeof DateUnit[keyof typeof DateUnit];
    export const addDateUnit: (date: Date, count: number, unit: string) => Date;
    export const stringToLocalDate: (value: string) => Date;
    export const isISODateString: (value: string) => boolean;
    export const toUTCDate: (utc: Date) => Date;
    export const toLocalDate: (utc: Date) => Date;
    export const toISODateString: (date: Date) => string;
    export const toMidnight: (date: Date | number) => Date;
    export const today: () => Date;
    export const 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;
        /** second. 0 based */
        millis: number;
        /** second. 1 based from Monday. 1 = Mon, 2 = Tue, ..., 7 = Sun */
        dow: number;
        /** date component without the time */
        /** data and time component */
        oaDateTime: number;
    }
    export const parseOADate: (oaDate: number, date1904?: boolean) => ParsedDateTime;
    /**
     * Note - This function currently only supports the leap year bug for hours.
     */
    export const oaDateFromParsed: (parsed: ParsedDateTime, date1904?: boolean) => number;
    export const fromOADate: (oaDate: number, date1904?: boolean) => Date;
    /**
     * 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_ToOADate
     * https://bettersolutions.com/excel/dates-times/1904-date-system.htm
     */
    export const toOADate: (date: Date, date1904?: boolean) => number;
    export interface DateNumberInput {
        numberFormat: string;
        asOADate: number;
        asJSDate: Date;
    }
    export interface ParsedDateTimeInput {
        numberFormat: string;
        parsed: Partial<ParsedDateTime>;
        leadingText: string;
    }
    export const parseAsTimeInput: (strValue: string, date1904?: boolean, allowLeadingText?: boolean) => ParsedDateTimeInput | null;
    /**
     * Adjusts a date parsed by date-fns to ensure consistent UTC interpretation
     * while preserving the time component
     */
    export const adjustDateForTimezone: (parsedDate: Date) => Date;
    /**
     * Returns a DateNumberInput or null.
     * @param strValue
     * @returns DateNumberInput is parsable as a date or null if not
     */
    export const parseAsDateInput: (strValue: string, date1904?: boolean, currentTime?: number) => DateNumberInput | null;
    export function isDateFormatter(fmt: string): boolean;
    export function isTimeFormatter(fmt: string): boolean;
    export function parseAsDateAndTimeInput(dateText: string, date1904?: boolean, requireDate?: boolean): number | null;
}
declare module "numFmt/_NumFmtUtils" {
    import { ParserOptions } from "numFmt/NumberFormatParser";
    import { Type } from "numFmt/NumberFormatType";
    export const defaultLocale: () => string;
    export const regExpLocaleRule: RegExp;
    export const regExHex: RegExp;
    export const splitFmt: any;
    export const format: any;
    export const formatValue: (format: string, value: string | number, options?: ParserOptions) => string;
    export const toLocaleValue: (format: string, value: number, options: ParserOptions) => {
        fmt: string;
        date: Date;
    } | null;
    export const XMLFormatMap: Readonly<{
        "General Number": "General";
        "General Date": "m/d/yyyy h:mm";
        "Medium Date": any;
        "Medium Time": any;
        "Short Time": any;
        Currency: "\"$\"#,##0.00_);[Red]\\(\"$\"#,##0.00\\)";
        Fixed: any;
        Standard: any;
        Percent: any;
        Scientific: any;
        "Yes/No": "\"Yes\";\"Yes\";\"No\";@";
        "True/False": "\"True\";\"True\";\"False\";@";
        "On/Off": "\"Yes\";\"Yes\";\"No\";@";
    }>;
    /**
     * Returns a legacy color as an rgb value
     */
    export const convertToLegacyColor: (color: string) => string;
    /**
     * Colors, spacing, column width adjustments (turning a long number into scientific notation)
     *
     * https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.numberingformats?view=openxml-2.8.1
     *
     * Rules to accommodate.
     * 1. Defaults Formatting rules (based on # of parts 1 - 4)
     *    a. (4) >0;<0;=0; text
     *    b. (3) >0;<0;=0; (General for text)
     *    c. (2) >=0;<0; (General for text)
     *    d. (1) Value is not considered
     * 2. Custom formatting rules specified with brackets []
     *    If custom formatting rules are applied then only 1 -3 parts
          a. 1-2 parts can contain custom rules. last part (if 3rd part can be a default format.
          b. If a custom eval is used no default and value doesn't match then returns overflow ([Red][<=100]General;[Blue][>100]General)
      * 3. Color rules
      *    a. color definition
      *       i.  8 standard colors [Black],[Blue],[Cyan],[Green],[Magenta],[Red],[White],[Yellow]
      *       ii. and legacy colors codes - default legacy color palette values are listed in §18.8.27
      * 4. Adjusting for width
      *    a. padding should only add the number of characters viewable
      *    b. Overflow (support for drawing ### when column width is too small)
    */
    const Operator: {
        readonly Equal: "=";
        readonly NotEqual: "<>";
        readonly GreaterThan: ">";
        readonly LessThan: "<";
        readonly GreaterThanOrEqual: ">=";
        readonly LessThanOrEqual: "<=";
    };
    export type Operator = typeof Operator[keyof typeof Operator];
    export const getConditionalColor: (format: string, value: string | number) => string;
    export const isFraction: (fmt: string) => boolean;
    /**
     * Compares the number format types to determine which has a higher priority for default during formula entry.
     * Excel typically prioritizes formats in this order:
     * 1. Date/Time formats (highest)
     * 2. Percentage
     * 3. Currency/Accounting
     * 4. Number formats with decimals
     * 5. General/other formats (lowest)
     */
    export const compareFormatPriorities: (a: Type, b: Type) => number;
}
declare module "numFmt/NumberFormatParser" {
    import { IColor } from "color/index";
    /**
     * Options for parsing a NumberFormat.
     */
    export interface ParserOptions {
        /**
         * Is date 1904
         */
        date1904?: boolean;
        /**
         * Parse a string of m/d/yy as date. We don't use as we do this using localization
         */
        dateNF?: boolean;
        /**
         * Call when a repeat char
         */
        onRepeatChar?: (offset: number, character: string) => void;
        /**
         * The character to add to the formatted string when a spacing character is
         * introduced.
         *
         * @defaultValue ' '
         */
        spacingCharacter?: string;
        /**
         * When '_' is encountered this is called.
         */
        onSpacingChar?: (offset: number, character: string) => void;
        /**
         * When '?' this encountered this is called.
         * @defaultValue ' '
         */
        digitCharacter?: string;
        onDigitChar?: (offset: number) => void;
        locale?: string;
        table?: any;
    }
    export interface ParsedCharPlaceHolder {
        offset: number;
        char: string;
    }
    export const ParseRunType: {
        /**
         * Contains text.
         */
        readonly Text: "text";
        /**
         * Indicates the text at this run should repeat.
         */
        readonly Repeat: "repeat";
        /**
         * Indicates the text at this run should not be displayed but used for measuring white-space.
         */
        readonly Spacing: "spacing";
    };
    export type ParseRunType = typeof ParseRunType[keyof typeof ParseRunType];
    export interface ParsedRun {
        type: ParseRunType;
        width: number;
        text: string;
    }
    export interface ParsedRuns {
        runs: readonly ParsedRun[];
        readonly length: number;
        readonly width: number;
        readonly lastRepeatIndex: number;
    }
    /**
     * This interface returns rendering information about the formatted text based on the numberFormat.
     *
     *  @see
     *  * {@link https://customformats.com/}
     *  * {@link https://exceljet.net/custom-number-formats}
     *  * {@link https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.numberingformats?view=openxml-2.8.1}
     */
    export interface Parsed {
        /**
         * @remarks
         * Never null
         */
        readonly displayText: string;
        /**
         * If there is a conditional color then this is the color to use.
         */
        readonly conditionalColor: IColor | null;
        /**
         * From the '*' formatChar.
         * A single character (usually a ' ' but can be anything)
         *
         * Repeats the next character in the format enough times to fill the column to its current width.
         * There shall not be more than one asterisk in one section of the format. If more than one asterisk
         * appears in one section of the format, all but the last asterisk shall be ignored.
         * [Example: if the number format is 0*x, and the value 3 is in the cell, the value 3xxxxxx is displayed.
         * The number of x characters that are displayed in the cell varies based on the width of the column. end example]
         */
        readonly repeatChars: ParsedCharPlaceHolder[];
        /**
         * If this is not null then the character should be displayed this many times.
         * This is is used if the text does not fit or if the value doesn't render against
         * the type correctly (for example a negative date)
         * @remarks
         * This is different then repeatChars in that it will only display the value
         * and not any additional .
         */
        readonly repeatPlaceholder: string | null;
        /**
         * From the '_' formatChar.
         * An array of single characters.
         *
         * Skips the width of the next character.
         * Useful for lining up negative and positive values in different cells of the same column.
         * [Example: The number format _(0.0_);(0.0) aligns the numbers 2.3 and the column even though the
         * negative number is enclosed by parentheses. end example]
         */
        readonly spacingChars: ParsedCharPlaceHolder[];
        /**
         * The displayText broken down into runs. Useful for more complex layouts.
         */
        readonly formattedRuns: ParsedRuns;
        /**
         * If true then the text could wrap if it doesn't fit.
         */
        readonly canWrap: boolean;
        /**
         * Returns the value as a javascript date if possible. Will
         * return null if not possible.
         */
        readonly asDate: Date | null;
        /**
         * If the format is a date format then this is true.
         */
        readonly isDateFormat: boolean;
        /**
         * If the format is a time format then this is true.
         */
        readonly isTimeFormat: boolean;
        /**
         * Indicates if the 1904 date convention was used during parsing.
         */
        readonly isDate1904: boolean;
    }
    export const Parser: Readonly<{
        /**
         * Language Code Identifier (LCIDs) are 'embedded' within numberFormat.
         *
         * There is the original (being deprecated) format and the new 'locale names' format.
         * The original format (most widely used at time of writing but being deprecated). Is an 8 digit hex number (xxyyzzzz). If the number is less than this then it is assumed to have
         * leading 0s. The hex is broken down into 3 parts.
         * xx - appearance of the number (see)
         *
         * Also modern Excel 365 now allows this syntax: [$-lg-CN,xxyy] where lg-CN is the language and country of the locale (replacing zzzz), and xxyy are as defined in the prior answer. Leading zeros are not needed and the whole ,xxyy part is optional.
         * In addition, a gannen suffix -x-gannen is allowed on Japanese locale codes, which replaces a 1 value (first year of emperor reign) for e formats with 元. For example:
         */
        formatValue: (format: string, value: string | number, options?: ParserOptions) => string;
        /**
         * Returns true if the format contains fraction formatting.
         */
        isFractionFormat: (format: string) => boolean;
        /**
         * Adjust the decimal in a format by an amount.
         *
         * @param format The format string.
         * @param amount The number of decimals to adjust by.
         */
        adjustDecimalPlaces: (format: string, amount: number) => string;
    }>;
}
declare module "numFmt/_BuiltInNumberFormats" {
    /**
     * Find the default number format string for a format id as defined in OOXML.
     */
    export const _BuiltInNumberFormats: (fmtId: number) => string;
}
declare module "numFmt/NumberFormatStyles" {
    import { Type } from "numFmt/NumberFormatType";
    /**
     * These are only returned if all segments have the same values.
     */
    export interface StyleConfig {
        separator?: boolean;
        decimalPlaces?: number;
        currencySymbol?: string;
    }
    /**
     * Returns meta data about the number format.
     */
    export interface Style {
        numberFormat: string;
        /**
         * Category of format/
         */
        formatType: Type;
        /**
         * If used in a menu it's the sort oder.
         * TODO - enrich this since excel and drawMl (charts are slightly different. Union these?)
         */
        primary?: number;
        args?: StyleConfig;
        regMatch?: RegExp;
    }
    export class Styles {
        /**
         * Find the style for a numberFormat.
         */
        lookupStyle(numberFormat: string | number): Style;
        /**
         * Returns an ordered list of a select set of the builtIn FormatCodes.
         */
        lookupPrimary(): Style[];
        lookupDefault(numberFormatKey: string | Type): string | null;
    }
}
declare module "numFmt/index" {
    import { Type as _Type } from "numFmt/NumberFormatType";
    import { Parsed as _Parsed, ParserOptions as _ParserOptions, ParsedCharPlaceHolder as _ParsedCharPlaceHolder, ParsedRun as _ParsedRun, ParsedRuns as _ParsedRuns } from "numFmt/NumberFormatParser";
    import { Style as _Style, Styles as _Styles, StyleConfig as _StyleConfig } from "numFmt/NumberFormatStyles";
    /**
     * Capabilities for defining and applying number formats to cells.
     *
     * Number formats control how numeric values are displayed in a spreadsheet,
     * enabling users to present data in various ways such as currency, percentages, dates, and more.
     *
     * Key features include:
     * - Applying built-in number formats (e.g., currency, date, percentage).
     * - Creating custom number formats using format codes.
     * - Setting and retrieving number formats for cells or ranges.
     */
    export namespace NumberFormat {
        type Parsed = _Parsed;
        /**
         * Represents the built-in categorization of a number format, or 'Custom' if the format is not recognized as a built-in type.
         *
         * Excel has the following:
         * @see
         * {@link https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.numberingformats?view=openxml-2.8.1}
         */
        type Type = typeof _Type[keyof typeof _Type];
        const Type: {
            readonly General: "General";
            readonly Number: "Number";
            readonly Currency: "Currency";
            readonly Accounting: "Accounting";
            readonly ShortDate: "Short Date";
            readonly LongDate: "Long Date";
            readonly MediumDate: "Medium Date";
            readonly ShortTime: "Short Time";
            readonly MediumTime: "Medium Time";
            readonly LongTime: "Long Time";
            readonly Comma: "Comma";
            readonly Percentage: "Percentage";
            readonly Fraction: "Fraction";
            readonly Scientific: "Scientific";
            readonly Text: "Text";
            readonly Special: "Special";
            readonly Custom: "Custom";
        };
        /**
         * This interface returns rendering information about the formatted text based on the numberFormat.
         *
         *  https://customformats.com/
         *  https://exceljet.net/custom-number-formats
         *  https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.numberingformats?view=openxml-2.8.1
         */
        const Parser: Readonly<{
            formatValue: (format: string, value: string | number, options?: _ParserOptions) => string;
            isFractionFormat: (format: string) => boolean;
            adjustDecimalPlaces: (format: string, amount: number) => string;
        }>;
        type ParserOptions = _ParserOptions;
        const Styles: _Styles;
        type Styles = _Styles;
        type ParsedCharPlaceHolder = _ParsedCharPlaceHolder;
        const ParseRunType: {
            readonly Text: "text";
            readonly Repeat: "repeat";
            readonly Spacing: "spacing";
        };
        type ParsedRun = _ParsedRun;
        type ParsedRuns = _ParsedRuns;
        type Style = _Style;
        type StyleConfig = _StyleConfig;
    }
}
declare module "style/IStyle" {
    import type { Size, Rectangle } from '@sheetxl/utils';
    import { IProperties } from "type/index";
    import { ITransaction } from "transaction/index";
    import { ICellRange } from "cellRange/index";
    import { IColor } from "color/index";
    import { IFill } from "fill/index";
    import { ITextFrame } from "text/index";
    import { IStyledFont } from "text/index";
    import { IFont } from "font/index";
    import { IBorder } from "border/index";
    import { NumberFormat } from "numFmt/index";
    /**
     * The `IStyle` interface combines user-applied styles with dynamic styles, such as those from tables or conditional
     * formatting, to deliver the current appearance.
     */
    export interface IStyle {
        /**
         * Format used for Number formatting:
         * * {@link https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.spreadsheet.numberingformats?view=openxml-2.8.1}
         * * {@link https://customformats.com/}
         *
         * @remarks
         * * If a number provided the builtIn numFmtId as defined in OOXML will be used.
         * * {@link NumberFormat.Type}
         */
        getNumberFormat(): string;
        /**
         * @see {@link IStyle.getNumberFormat}
         */
        setNumberFormat(numFmt: string | null, options?: IStyle.UpdateOptions): IStyle;
        /**
         * A boolean value indicating whether the text string in a cell should be prefixed by a single quote mark (e.g., 'text).
         * In these cases, the quote is not stored in the Shared Strings Part.
         */
        getQuotePrefix(): boolean;
        /**
         * @see {@link IStyle.getQuotePrefix}
         */
        setQuotePrefix(quotePrefix: boolean | null, options?: IStyle.UpdateOptions): IStyle;
        /**
         * Returns the border style.
         */
        getBorder(): IBorder;
        /**
         * Sets the border style.
         *
         * This method allows updating borders using an {@link IBorder} or a shorthand property object.
         *
         * @param border The border object or a shorthand property object to apply. Pass `null` to clear.
         * @param options Optional configuration for the update.
         * @returns The `IBorder` object for further modifications.
         */
        setBorder(border: IBorder.Update, options?: IStyle.UpdateOptions): IStyle;
        /**
         * Fill properties for the background.
         */
        getFill(): IFill.ISolid | IFill.IGradient | IFill.IPattern | IFill.INone;
        /**
         * Sets the fill style.
         *
         * This method allows updating fill using an {@link IFill} or a shorthand property object.
         *
         * @param fill The fill object or a shorthand property object to apply. Pass `null` to clear.
         * @param options Optional configuration for the update.
         * @returns The `IFill` object for further modifications.
         */
        setFill(fill: IFill.Update, options?: IStyle.UpdateOptions): IStyle;
        /**
         * Returns the alignment for the style.
         */
        getAlignment(): ITextFrame.IAlignment;
        /**
         * Sets the alignment style.
         *
         * This method allows updating alignments using an {@link ITextFrame.IAlignment.Update} or a shorthand property object.
         *
         * @param alignment The alignment object or a shorthand property object to apply. Pass `null` to clear.
         * @param options Optional configuration for the update.
         * @returns The `ITextFrame.IAlignment` object for further modifications.
         */
        setAlignment(alignment: ITextFrame.IAlignment.Update, options?: IStyle.UpdateOptions): IStyle;
        /**
         * Returns the font for the style.
         */
        getFont(): IStyledFont;
        /**
         * Sets the font style.
         *
         * This method allows updating fill using an {@link IStyledFont} or a shorthand property object.
         *
         * @param font The font object or a shorthand property object to apply. Pass `null` to clear.
         * @param options Optional configuration for the update.
         * @returns The `IStyledFont` object for further modifications.
         */
        setFont(font: IStyledFont.Update, options?: IStyle.UpdateOptions): IStyle;
        /**
         * Returns an instance of the named style that this is derived from.
         */
        getNamed(): IStyle.INamed;
        /**
         * Sets the named style that this is derived from.
         *
         * @param named The named style to set.
         */
        setNamed(named: string | IStyle.INamed | null, options?: IStyle.UpdateOptions): IStyle;
        /**
         * Update many style properties at once.
         *
         * @param update {@link IStyle.Update}
         * @param options {@link IStyle.UpdateOptions}
         * @returns The `IStyle` for further modifications.
         */
        update(update: IStyle.Update, options?: IStyle.UpdateOptions): IStyle;
        /**
         * Measure the text using the styling properties
         *
         * @param text The text to measure.
         * @param size Size @defaultValue 'to the cell font.size'
         * @param family Family @defaultValue 'to the cell font.family'
         * @param options Options for the measurement.
         */
        measureText(text: string, size?: number, family?: string, options?: IFont.MetricOptions): IFont.ExtendedMetrics;
        /**
         * Creates a simple text frame that can be used for rendering and/or measuring.
         *
         * @param text
         * @param allowWrap If true then will try to wrap on natural breaks.
         */
        createTemporaryTextFrame(text: string, allowWrap?: boolean): ITextFrame;
        /**
         * Returns the best fit size assuming no content.
         */
        getBestFit(): Partial<Size> | null;
        /**
         * Returns insets used for content. This does not taking into account indent because
         * this is alignment and type specific.
         */
        getInsets(): Rectangle;
        /**
         * This is used to determine if the style has rendering
         * artifacts even if there is no content. (For example borders or background)
         */
        hasVisibleStyling(): boolean;
        /**
         * Allows for a non managed style. Useful for tooltips or other transient styles.
         *
         * @param update Adjustments to the style.
         */
        createTemporaryStyle(update: IStyle.Update): IStyle;
        /**
         * Returns `true` if the CellStyle is the normal style
         */
        isNormal(): boolean;
        /**
         * Returns a JSON representation of the style.
         */
        toJSON(): IStyle.JSON | null;
        /**
         * For runtime type checking.
         */
        readonly isIStyle: true;
    }
    /**
     * {@inheritDoc IStyle}
     * @see
     * ### **Interface**
     *
     * {@link IStyle}
     */
    export namespace IStyle {
        /**
         * The properties for IStyle.
         */
        interface Properties<C = IColor.Serializable> {
            /**
             * Font properties.
             *
             * @see
             * {@link IStyle.getFont}
             */
            font?: IStyledFont.Properties<C>;
            /**
             * Fill properties.
             *
             * @see
             * {@link IStyle.getFill}
             */
            fill?: C | IFill.SolidProperties<C> | IFill.GradientProperties<C> | IFill.PatternProperties<C> | IFill.NoneProperties;
            /**
             * Number Format properties.
             *
             * @see
             * {@link IStyle.getNumberFormat()}
             */
            numberFormat?: string | NumberFormat.Type | number;
            /**
             * Alignment properties.
             *
             * @see
             * {@link IStyle.getAlignment}
             */
            alignment?: ITextFrame.IAlignment.Properties;
            /**
             * Border properties.
             *
             * @see
             * {@link IStyle.getBorder}
             */
            border?: IBorder.Properties;
            /**
             * Quote Prefix property.
             *
             * @see
             * {@link IStyle.getQuotePrefix}
             */
            quotePrefix?: boolean;
            /**
             * Named style property.
             *
             * @see
             * {@link IStyle.getNamed}
             */
            named?: IStyle.BuiltInName | string;
            /**
             * Custom indentation insets.
             */
            insets?: Partial<Rectangle>;
        }
        /**
         * Enable properties to be set using string shorthands.
         */
        type Modifiers = IProperties.ResolvableProperties<IStyle.Properties>;
        interface ModifierCallback {
            (original: IStyle): IStyle.Modifiers;
        }
        /**
         * Options for updating a style.
         */
        type Update = IStyle | IStyle.Modifiers | IStyle.ModifierCallback | null;
        /**
         * Options for Updates.
         */
        interface UpdateOptions extends ITransaction.OperationOptions {
            /**
             * Convenience method that calls autoFit after the setValues.
             * @defaultValue `none` - No autofit.
             *
             * @remarks
             * If set to `true` then autoFit will mimic the UI with the following options:
        ```
        {
          skipCustomSize: true,
          expandOnly: true,
          minContent: true
        }
        ```
             */
            autoFit?: boolean | ICellRange.AutoFitOptions;
        }
        interface JSON extends Properties<string> {
        }
        /**
         * Represents a named cell style that can be selected and applied across multiple cells.
         * Named styles provide a convenient way to apply predefined or custom styling
         * options available within the application's UI. Commonly used for both built-in
         * and user-defined styles in spreadsheet applications.
         */
        interface INamed {
            /**
             * Returns the name for the style.
             */
            getName(): string;
            /**
             * Returns the style customizations.
             */
            getRanged(): IProperties.ICellRanged<IStyle.Properties>;
            /**
             * If 'true' do not show this style in the application UI.
             */
            isHidden(): boolean;
            /**
             * Specifies if this style is applied to outline levels in the application.
             *
             * @returns The outline level if this style applies to outlines, or `null`
             * if it is not associated with any outline levels.
             *
             * @remarks
             * * Outline styles allow automatic application of the style to cells at a
             * specific outline level.
             * * Returns `null` if outline does not affect styles.
             */
            getILevel(): number | null;
            /**
             * Identifies the built-in ID for predefined styles, if applicable.
             *
             * @returns The built-in ID number if the style is a predefined one, or `null`
             * if the style is custom.
             */
            getBuiltInID(): number | null;
            /**
             * Deletes the style.
             *
             * @remarks
             * For built-in styles, this method will hide.
             */
            delete(): void;
            /**
             * For Persisting.
             */
            toJSON(): IStyle.NamedJSON;
            /**
             * For runtime type checking.
             */
            readonly isINamed: true;
        }
        /**
         * Properties associated with an {@link INamed} style.
         *
         * @remarks
         * Used for performing updates and saving to JSON.
         */
        interface NamedProperties<C = IColor.Serializable> {
            /**
             * @see
             * {@link INamed.getName}
             */
            name: string;
            /**
             * @see
             * {@link INamed.isHidden}
             */
            hidden?: boolean;
            /**
             * @see
             * {@link INamed.getILevel}
             */
            iLevel?: number | null;
            /**
             * The cell style properties.
             */
            style: IStyle.Properties<C>;
        }
        /**
         * For persisting.
         */
        interface NamedJSON extends NamedProperties<string> {
        }
        /**
         * Extends the NamedProperties with the ability to use a callback on the style.
         */
        interface NamedUpdate extends Omit<IProperties.ResolvableProperties<NamedProperties>, 'style'> {
            /**
             * Allows for style modifications.
             */
            style: IStyle.Update;
        }
        /**
         * List of BuiltIn CellStyles.
         */
        const BuiltInName: {
            readonly Normal: "Normal";
            readonly RowLevel: "RowLevel_#";
            readonly ColLevel: "ColLevel_#";
            readonly Comma: "Comma";
            readonly Currency: "Currency";
            readonly Percent: "Percent";
            readonly Comma0: "Comma [0]";
            readonly Currency0: "Currency [0]";
            readonly Hyperlink: "Hyperlink";
            readonly FollowedHyperlink: "Followed Hyperlink";
            readonly Note: "Note";
            readonly WarningText: "Warning Text";
            readonly Unknown12: "??-12";
            readonly Unknown13: "??-13";
            readonly Unknown14: "??-14";
            readonly Title: "Title";
            readonly Heading1: "Heading 1";
            readonly Heading2: "Heading 2";
            readonly Heading3: "Heading 3";
            readonly Heading4: "Heading 4";
            readonly Input: "Input";
            readonly Output: "Output";
            readonly Calculation: "Calculation";
            readonly CheckCell: "Check Cell";
            readonly LinkedCell: "Linked Cell";
            readonly Total: "Total";
            readonly Good: "Good";
            readonly Bad: "Bad";
            readonly Neutral: "Neutral";
            readonly Accent1: "Accent1";
            readonly Accent1_20: "20% - Accent1";
            readonly Accent1_40: "40% - Accent1";
            readonly Accent1_60: "60% - Accent1";
            readonly Accent2: "Accent2";
            readonly Accent2_20: "20% - Accent2";
            readonly Accent2_40: "40% - Accent2";
            readonly Accent2_60: "60% - Accent2";
            readonly Accent3: "Accent3";
            readonly Accent3_20: "20% - Accent3";
            readonly Accent3_40: "40% - Accent3";
            readonly Accent3_60: "60% - Accent3";
            readonly Accent4: "Accent4";
            readonly Accent4_20: "20% - Accent4";
            readonly Accent4_40: "40% - Accent4";
            readonly Accent4_60: "60% - Accent4";
            readonly Accent5: "Accent5";
            readonly Accent5_20: "20% - Accent5";
            readonly Accent5_40: "40% - Accent5";
            readonly Accent5_60: "60% - Accent5";
            readonly Accent6: "Accent6";
            readonly Accent6_20: "20% - Accent6";
            readonly Accent6_40: "40% - Accent6";
            readonly Accent6_60: "60% - Accent6";
            readonly ExplanatoryText: "Explanatory Text";
        };
        type BuiltInName = typeof BuiltInName[keyof typeof BuiltInName];
        /**
         * BuiltIn IconSets used for conditional formatting.
         */
        const IconSet: {
            readonly Arrows3: "3Arrows";
            readonly ArrowsGray3: "3ArrowsGray";
            readonly Flags3: "3Flags";
            readonly Signs3: "3Signs";
            readonly Symbols3: "3Symbols";
            readonly Symbols3_2: "3Symbols2";
            readonly TrafficLights3: "3TrafficLights1";
            readonly TrafficLights3_2: "3TrafficLights2";
            readonly Arrows4: "4Arrows";
            readonly ArrowsGray4: "4ArrowsGray";
            readonly Rating4: "4Rating";
            readonly RedToBlack4: "4RedToBlack";
            readonly TrafficLights4: "4TrafficLights";
            readonly Arrows5: "5Arrows";
            readonly ArrowsGray5: "5ArrowsGray";
            readonly Quarters5: "5Quarters";
            readonly Rating5: "5Rating";
        };
        type IconSet = typeof IconSet[keyof typeof IconSet];
    }
}
declare module "theme/_ThemeUtils" {
    import { IColor } from "color/index";
    export const buildPalette: (colors: IColor.DefinitionWithLabel[], schemeLookup: IColor.SchemeLookup, map: Map<string, IColor>, mapRGB: Map<string, IColor>) => IColor.DefinitionWithLabel[];
}
declare module "theme/ITheme" {
    import { IColor } from "color/index";
    /**
     * Defines and manages themes associated to a specific document or spreadsheet.
     *
     * These themes are saved and shared with the document, ensuring a consistent look and feel across different views or users.
     *
     * `ITheme` focuses on styling the content within the document itself, such as:
     * - Applying schema colors (Accent1, Accent2, etc.) to elements like charts, shapes, and tables.
     * - Controlling font styles and colors used within the document.
     * - Customizing other visual aspects specific to the document's content.
     *
     * This is distinct from an `AppTheme`, which controls the styling of the application's user interface (UI) itself,
     * such as the toolbar, menus, and overall color scheme, and can be specific to the application or individual user preferences.
     */
    export interface ITheme {
        /**
         * Human readable text describing the theme.
         */
        getName(): string;
        /**
         * A set of colors that are used in a document.
         */
        getColorScheme(): ITheme.IColorScheme;
        /**
         * A set of fonts that are used in a document.
         */
        getFontScheme(): ITheme.IFontScheme;
        /**
         * This is available for functions that want to resolve themed colors
         *
         * @remarks
         * In most instances the scheme lookup from the style should be used unless specifically
         * rendering for a theme (for example a theme chooser).
         */
        schemeLookup(): IColor.SchemeLookup;
        /**
         * If a custom theme or built in theme.
         */
        isCustom(): boolean;
        /**
         * Parses the color using the current Theme schema (if required)
         * @param str The string to parse
         * @throws `Error` If the string does not parse to a valid color.
         *
         * @remarks
         * In most instances the scheme lookup from the style should be used unless specifically
         * rendering for a theme.
         */
        parseColor(str: string): IColor;
        /**
         * Creates a persistable version of Themes.
         * @param includeInherited If true then the inherited properties will be included.
         */
        toJSON(includeInherited?: boolean): ITheme.JSON;
    }
    /**
     * {@inheritDoc ITheme}
     * @see
     * ### **Interface**
     *
     * {@link ITheme}
     */
    export namespace ITheme {
        interface ColorSchemeJSON extends Partial<ColorSchemeProperties<string>> {
        }
        /**
         * Built a set of colors from the theme.
         * @remarks
         * This api will undergo cleanup.
         */
        const buildPalette: (colors: IColor.DefinitionWithLabel[], schemeLookup: IColor.SchemeLookup, map: Map<string, IColor>, mapRGB: Map<string, IColor>) => IColor.DefinitionWithLabel[];
        interface ColorSchemeProperties<C = IColor.Serializable> {
            dk1: C;
            lt1: C;
            dk2: C;
            lt2: C;
            accent1: C;
            accent2: C;
            accent3: C;
            accent4: C;
            accent5: C;
            accent6: C;
            hlink: C;
            folHlink: C;
            name: string;
        }
        /**
         * Represents a color scheme interface that extends the properties of ColorSchemeProperties.
         *
         * @template C - The type of the color, defaults to IColor.Serializable.
         */
        interface IColorScheme {
            /**
             * Gets the first dark color in the scheme.
             *
             * @returns {IColor} The first dark color.
             */
            getDk1(): IColor;
            /**
             * Gets the first light color in the scheme.
             *
             * @returns {IColor} The first light color.
             */
            getLt1(): IColor;
            /**
             * Gets the second dark color in the scheme.
             *
             * @returns {IColor} The second dark color.
             */
            getDk2(): IColor;
            /**
             * Gets the second light color in the scheme.
             *
             * @returns {IColor} The second light color.
             */
            getLt2(): IColor;
            /**
             * Gets the first accent color in the scheme.
             *
             * @returns {IColor} The first accent color.
             */
            getAccent1(): IColor;
            /**
             * Gets the second accent color in the scheme.
             *
             * @returns {IColor} The second accent color.
             */
            getAccent2(): IColor;
            /**
             * Gets the third accent color in the scheme.
             *
             * @returns {IColor} The third accent color.
             */
            getAccent3(): IColor;
            /**
             * Gets the fourth accent color in the scheme.
             *
             * @returns {IColor} The fourth accent color.
             */
            getAccent4(): IColor;
            /**
             * Gets the fifth accent color in the scheme.
             *
             * @returns {IColor} The fifth accent color.
             */
            getAccent5(): IColor;
            /**
             * Gets the sixth accent color in the scheme.
             *
             * @returns {IColor} The sixth accent color.
             */
            getAccent6(): IColor;
            /**
             * Gets the hyperlink color in the scheme.
             *
             * @returns {IColor} The hyperlink color.
             */
            getHlink(): IColor;
            /**
             * Gets the followed hyperlink color in the scheme.
             *
             * @returns {IColor} The followed hyperlink color.
             */
            getFolHlink(): IColor;
        }
        /**
         * Interface representing a font scheme.
         */
        interface IFontScheme {
            /**
             * Gets the name of the font scheme.
             * @returns The name of the font scheme.
             */
            getName(): string;
            /**
             * Gets the major font of the font scheme.
             * @returns The major font of the font scheme.
             */
            getMajorFont(): string;
            /**
             * Gets the fallback fonts for the major font.
             * @returns An array of fallback fonts for the major font.
             */
            getMajorFallbacks(): readonly string[];
            /**
             * Gets the minor font of the font scheme.
             * @returns The minor font of the font scheme.
             */
            getMinorFont(): string;
            /**
             * Gets the fallback fonts for the minor font.
             * @returns An array of fallback fonts for the minor font.
             */
            getMinorFallbacks(): readonly string[];
        }
        interface FontSchemeProperties {
            majorFont: string;
            majorFallbacks: string[];
            minorFont: string;
            minorFallbacks: string[];
            name: string;
        }
        interface FontSchemeJSON extends Partial<FontSchemeProperties> {
        }
        interface JSON {
            name: string;
            fonts?: ITheme.FontSchemeJSON;
            colors?: ITheme.ColorSchemeJSON;
            darkColors?: ITheme.ColorSchemeJSON;
        }
    }
}
declare module "theme/IThemeCollection" {
    import { ICollection } from "type/index";
    import { ITheme } from "theme/ITheme";
    /**
     * A collection of themes.
     */
    export interface IThemeCollection extends ICollection<ITheme> {
        /**
         * Add or update a theme.
         *
         * @param theme The new theme.
         * @returns The original theme
         *
         * @remarks
         * Case insensitive; for duplicate detection purposes.
         */
        setCustomTheme(theme: ITheme): ITheme | null;
        /**
         * Returns the theme for the given name.
         *
         * @remarks
         * Will try to return:
         * 1. The custom theme for the name
         * 2. The builtin theme for the name.
         * 3. nul if it doesn't exist.
         */
        getByName(name: string): ITheme | null;
        /**
         * Returns all themes that match the filter criteria.
         *
         * @param options {@link IThemeCollection.GetItemsOptions}
         *
         * @remarks
         * * If no filter criteria is provided, all items will be returned.
         * * Generates a new array so this can be mutated without affecting the internal state.
         */
        getItems(options?: IThemeCollection.GetItemsOptions): ITheme[];
        /**
         * Remove a custom theme.
         *
         * @param theme A {@link Theme} or string.
         * @returns `true` if the Theme was removed.
         */
        deleteCustomTheme(theme: ITheme | string): ITheme | null;
        /**
         * Returns the name of the default Theme.
         *
         * @returns A theme that has been set as the Default using {@link setDefaultTheme}.
         */
        getDefaultTheme: () => ITheme;
        /**
         * Set the new default theme.
         *
         * @returns The previous default theme.
         */
        setDefaultTheme: (theme: ITheme) => ITheme;
    }
    /**
     * {@inheritDoc IThemeCollection}
     *
     * @see
     * ### **Interface**
     *
     * {@link IThemeCollection}
     */
    export namespace IThemeCollection {
        type JSON = ITheme.JSON[];
        interface GetItemsOptions extends ICollection.GetItemsOptions {
            /**
             * @defaultValue `IThemeCollection.BuiltInFilterType.All`
             */
            type?: BuiltInFilterType;
            /**
             * Allows for the filter to return a specific theme even if not in the list.
             */
            selected?: ITheme;
        }
        const BuiltInFilterType: {
            readonly BuiltIn: "builtIn";
            readonly All: "all";
            readonly Custom: "custom";
        };
        type BuiltInFilterType = typeof BuiltInFilterType[keyof typeof BuiltInFilterType];
    }
}
declare module "theme/_BuiltInColorSchemes" {
    const _BuiltInColorSchemes: string[][];
    export default _BuiltInColorSchemes;
}
declare module "theme/_BuiltInFontSchemes" {
    const _BuiltInFontSchemes: string[][];
    export default _BuiltInFontSchemes;
}
declare module "theme/_BuiltInThemeDefs" {
    const _BuiltInThemeDefs: string[][];
    export default _BuiltInThemeDefs;
}
declare module "theme/_ThemeMessages" {
    export const ERROR_READONLY = "Themes is readonly. To make modifications create a new DocsThemes instance.";
    export const ERROR_THEME_IS_NULL = "Theme cannot be null.";
}
declare module "theme/ThemeCollection" {
    import { IColor } from "color/index";
    import { ITheme } from "theme/ITheme";
    import { IThemeCollection } from "theme/IThemeCollection";
    export class Theme implements ITheme {
        private _name;
        private _colors;
        private _fonts;
        private _schemeLookup;
        private _colorMap;
        private _builtInID;
        private _delegate;
        private _cacheColors;
        constructor(json: ITheme.JSON, delegate?: ITheme, builtIn?: number | null);
        get builtInID(): number | null;
        /** {@inheritDoc ITheme.getName} */
        getName(): string;
        /** {@inheritDoc ITheme.isCustom} */
        isCustom(): boolean;
        /** {@inheritDoc ITheme.getColorScheme} */
        getColorScheme(): ITheme.IColorScheme;
        /** {@inheritDoc ITheme.getFontScheme} */
        getFontScheme(): ITheme.IFontScheme;
        /** {@inheritDoc ITheme.schemeLookup} */
        schemeLookup(): IColor.SchemeLookup;
        /** {@inheritDoc ITheme.parseColor} */
        parseColor(str: string): IColor;
        /** {@inheritDoc ITheme.toJSON} */
        toJSON(): ITheme.JSON;
    }
    /**
     * Collection of themes
     */
    export class ThemeCollection implements IThemeCollection {
        private _customMap;
        private _defaultTheme;
        private _isReadOnly;
        constructor(_json?: IThemeCollection.JSON, isReadOnly?: boolean);
        /** {@inheritDoc IThemeCollection.getDefaultTheme} */
        getDefaultTheme(): ITheme;
        /** {@inheritDoc IThemeCollection.setDefaultTheme} */
        setDefaultTheme(theme: ITheme): ITheme;
        /** {@inheritDoc IThemeCollection.getByName} */
        getByName(name: string): ITheme | null;
        /** {@inheritDoc IThemeCollection.getByName} */
        getItems(options?: IThemeCollection.GetItemsOptions): ITheme[];
        /** {@inheritDoc IThemeCollection.getCount} */
        getCount(): number;
        /** {@inheritDoc IThemeCollection.setCustomTheme} */
        setCustomTheme(theme: ITheme): ITheme | null;
        /** {@inheritDoc IThemeCollection.deleteCustomTheme} */
        deleteCustomTheme(theme: ITheme | string): ITheme | null;
    }
}
declare module "theme/index" {
    export * from "theme/ITheme";
    export * from "theme/IThemeCollection";
    export * from "theme/ThemeCollection";
}
declare module "filter/IAutoFilter" {
    import type { Scalar, IRange } from '@sheetxl/primitives';
    import type { IStyle } from "style/index";
    import type { IAutoSort, ISort } from "sort/index";
    /**
     * Capabilities for applying and managing filters.
     *
     * AutoFilters enable dynamic filtering of data based on criteria specified per column,
     * allowing users to quickly focus on relevant information.
     *
     * Key features include:
     * - Applying filters to specific columns within a range.
     * - Defining filter criteria using various operators (e.g., equals, greater than, contains).
     * - Hiding rows that don't match the filter criteria.
     * - Clearing or modifying filters.
     */
    export interface IAutoFilter {
        /**
         * Returns the coords that filter is applied to.
         *
         * @remarks
         * Returns null if not enabled.
         */
        getCoords(): IRange.Coords | null;
        /**
         * The criteria for the filer
         */
        getFieldAt(offset: number): IAutoFilter.Field;
        /**
         * Set the criteria at the given offset.
         *
         * @remarks
         * Changing the filter will reapply.
         */
        setFieldAt(offset: number, field: IAutoFilter.Field): IAutoFilter;
        /**
         * Set all field fields.
         */
        apply(fields: IAutoFilter.IndexedField[]): IAutoFilter;
        /**
         * Reapply criteria and sort to the range.
         */
        reapply(): IAutoFilter;
        /**
         * Remove both the filer and sort criteria but leave the range in place.
         */
        clear(): IAutoFilter;
        /**
         * Delete this filter.
         */
        delete(): void;
        /**
         * Returns true unless any Field has hiddenButton set to true.
         */
        getShowFilterButton(): boolean;
        /**
         * If false sets all filterColumns to have a hiddenButton of true
         * If true set hidden button to false
         * @param show
         */
        setShowFilterButton(show: boolean): IAutoFilter;
        /**
         * Only one sort per table is supported so this will
         * return the same instance if it has already been created.
         */
        insertSort(): IAutoSort;
        /**
         * Returns a sort for the filter. If the filter does not support sorting this should
         * return null.
         */
        getSort(): IAutoSort;
        /**
         * Save a persistable version of  AutoFilter
         */
        toJSON(): IAutoFilter.JSON;
    }
    /**
     * {@inheritDoc IAutoFilter}
     * @see
     * ### **Interface**
     *
     * {@link IAutoFilter}
     */
    export namespace IAutoFilter {
        const NumberFilterOperatorType: {
            readonly Equal: "equal";
            readonly GreaterThan: "greaterThan";
            readonly GreaterThanOrEqual: "greaterThanOrEqual";
            readonly LessThan: "lessThan";
            readonly LessThanOrEqual: "lessThanOrEqual";
            readonly NotEqual: "notEqual";
        };
        type NumberFilterOperatorType = typeof NumberFilterOperatorType[keyof typeof NumberFilterOperatorType];
        const Type: {
            readonly Color: "color";
            readonly Custom: "custom";
            readonly Dynamic: "dynamic";
            readonly Items: "items";
            readonly Icon: "icon";
            readonly Top10: "top10";
        };
        type Type = typeof Type[keyof typeof Type];
        const DynamicType: {
            readonly AboveAverage: "aboveAverage";
            readonly BelowAverage: "belowAverage";
            readonly LastMonth: "lastMonth";
            readonly LastQuarter: "lastQuarter";
            readonly LastWeek: "lastWeek";
            readonly LastYear: "lastYear";
            readonly M1: "M1";
            readonly M2: "M2";
            readonly M3: "M3";
            readonly M4: "M4";
            readonly M5: "M5";
            readonly M6: "M6";
            readonly M7: "M7";
            readonly M8: "M8";
            readonly M9: "M9";
            readonly M10: "M10";
            readonly M11: "M11";
            readonly M12: "M12";
            readonly NextMonth: "nextMonth";
            readonly NextQuarter: "nextQuarter";
            readonly NextWeek: "nextWeek";
            readonly Null: "null";
            readonly Q1: "Q1";
            readonly Q2: "Q2";
            readonly Q3: "Q3";
            readonly Q4: "Q4";
            readonly ThisMonth: "thisMonth";
            readonly ThisQuarter: "thisQuarter";
            readonly ThisWeek: "thisWeek";
            readonly Today: "today";
            readonly Tomorrow: "tomorrow";
            readonly YearToDate: "yearToDate";
            readonly Yesterday: "yesterday";
        };
        type DynamicType = typeof DynamicType[keyof typeof DynamicType];
        const DateItemGroupingType: {
            readonly Day: "day";
            readonly Hour: "hour";
            readonly Minute: "minute";
            readonly Month: "month";
            readonly Second: "Second";
            readonly Year: "year";
        };
        type DateItemGroupingType = typeof DateItemGroupingType[keyof typeof DateItemGroupingType];
        interface Criterian {
            /**
             * The type of criterian used in a filter.
             */
            type: Type;
        }
        interface ColorCriterian extends Criterian {
            /**
             * Type must be color;
             */
            type: typeof Type.Color;
            /**
             * Indicated whether to filter by cell's fill color.
             * @defaultValue true
             */
            cellColor?: boolean;
            /**
             * If filtered then the id
             */
            styleId?: number;
        }
        interface CustomFilter {
            /**
             * The type of operator the custom filter will use
             * @defaultValue 'match'.
             */
            operator?: NumberFilterOperatorType;
            /**
             * The value to compare against.
             */
            value: Scalar;
        }
        interface CustomCriterian extends Criterian {
            /**
             * Type must be custom;
             */
            type: typeof Type.Custom;
            /**
             * Indicated whether to filters are groups as an and or an 'or'.
             * @defaultValue false
             */
            and?: boolean;
            /**
             * A list of filters
             */
            filters: CustomFilter[];
        }
        interface DynamicCriterian extends Criterian {
            /**
             * Type must be Dynamic;
             */
            type: typeof Type.Dynamic;
            /**
             * The type of dynamic filter
             */
            dynamicType?: DynamicType;
            /**
             * The minimum value for the dynamic filter.
             * @see maxVal
             */
            val?: number;
            /**
             * The maximum value for the dynamic filter.
             * This is required for:
             * today, yesterday, tomorrow, nextWeek, thisWeek, lastWeek, nextMonth, thisMonth,
             * lastMonth, nextQuarter, thisQuarter, lastQuarter, nextYear, thisYear,
             * lastYear, and yearToDate.
             *
             * @see maxVal
             */
            maxVal?: number;
        }
        interface DateGroupItem {
            /**
             * Grouping level.
             */
            group?: DateItemGroupingType;
            /**
             * Day 1 - 31.
             */
            day?: number;
            /**
             * Hour 0-23.
             */
            hour?: number;
            /**
             * Minute 0-59.
             */
            minute?: number;
            /**
             * Month 1-12.
             */
            month?: number;
            /**
             * Minute 0-59.
             */
            second?: number;
            /**
             * 4 Digits.
             */
            year?: number;
        }
        interface FilterItemCriterian extends Criterian {
            /**
             * Type must be Items;
             */
            type: typeof Type.Items;
            /**
             * If true this filter by blank.
             */
            blank?: boolean;
            /**
             * List of item filters
             */
            items?: Scalar[];
            /**
             * List of date group filters.
             */
            dateGroups?: DateGroupItem[];
            /**
             * Calendar type for date group items.
             */
            calendarType?: string;
        }
        interface IconCriterian extends Criterian {
            /**
             * 0-based index of an icon from an icon set. If missing then
             * no icon.
             */
            iconId?: number;
            /**
             * Specifies which icon set to use.
             */
            iconSet?: IStyle.IconSet;
        }
        interface Top10Criterian extends Criterian {
            /**
             * The actual cell value in the range which is used to perform the comparison for this filter.
             */
            filterVal?: number;
            /**
             * Flag indicating whether or not to filter by percent value of the column. A false value filters by number of items.
             */
            percent?: boolean;
            /**
             * Flag indicating whether or not to filter by top order. A false value filters by bottom order.
             */
            top?: boolean;
            /**
             * Top or bottom value to use as the filter criteria. For example "Filter by Top 10 Percent" or "Filter by Top 5 Items".
             */
            val?: number;
        }
        interface Field {
            /**
             * If the button is hidden.
             *
             * @remarks
             * The button may be hidden for other reasons like there is no filter
             */
            hiddenButton?: boolean;
            /**
             * On ooxml but not sure what it is used for.
             */
            showButton?: boolean;
            /**
             * The criterial for the filter field. If this is empty or null then
             * this is treated as not having any criteria.
             */
            criteria?: Criterian[];
        }
        interface IndexedField extends IAutoFilter.Field {
            /**
             * Is either a key to find the index or a 0 based offset.
             */
            offset: number;
        }
        interface IColumn {
            /**
             * Returns the name of the column.
             */
            getName(): string;
            /**
             * Returns a filter criteria for the column is one has been set.
             */
            getField(): IAutoFilter.Field | null;
            /**
             * Set a filter criteria for the column.
             *
             * @param field The field to set for the column.
             *
             * @remarks
             * This will not affect any other filter fields
             */
            setField(field: IAutoFilter.Field): IColumn;
            /**
             * Returns a sort field for the column is one has been set.
             */
            getSortField(): ISort.Criteria | null;
            /**
             * Set a sort field for the column.
             *
             * @param field The field to set for the column.
             *
             * @remarks
             * This will not affect any other sort fields
             */
            setSortField(field: ISort.Criteria): IColumn;
            /**
             * Reapply criteria and sort to the range.
             */
            reapply(): IColumn;
            /**
             * Remove both the filer and sort criteria but leave the range in place.
             */
            clear(): IColumn;
            /**
             * If the filter button is hidden.
             */
            hasHiddenButton(): boolean;
        }
        interface JSON {
            /**
             * The reference. The filter is applied to.
             *
             * @remarks
             * This may be blank is it can be defined by the filter container.
             */
            ref?: string | IRange.Coords;
            /**
             * fields that define how values are filtered
             */
            fields?: IAutoFilter.IndexedField[];
            /**
             * AutoFilters can have SortFields.
             */
            sort?: IAutoSort.JSON;
        }
    }
}
declare module "filter/index" {
    export * from "filter/IAutoFilter";
}
declare module "named/INamed" {
    import type { IRange } from '@sheetxl/primitives';
    import type { ITypes } from "type/index";
    import type { ITransaction } from "transaction/index";
    import type { IListener } from "listener/index";
    import type { ICellRanges } from "cellRange/index";
    import type { IModel } from "model/index";
    /**
     * Defined names are descriptive texts that are used to represents a cell, range of cells, formula, or constant value.
     */
    export interface INamed<T = any> extends IModel {
        /**
         * A string to identify the type of named item.
         *
         * @remarks Immutable
         */
        getType(): string;
        /**
         * The underlying item that is being referenced.
         *
         * @remarks Immutable
         */
        getValue(): T;
        /**
         * Selects the current item.
         *
         * @returns An async `INamed`.
         */
        select(options?: ITypes.SelectOptions): Promise<this>;
        /**
         * The comment for the defined name.
         *
         * @remarks
         * If null then no comment
         */
        setComment(comment: string | null, options?: ITransaction.OperationOptions): this;
        /**
         * {@link setComment}
         */
        getComment(): string;
        /**
         * Return the ranges that are associated with the named item or null if no ranges are available.
         *
         * @remarks
         * * Optional
         */
        getRanges?(): ICellRanges | null;
        /**
         * If true then the name is not visible.
         *
         * @defaultValue false
         *
         * @remarks
         * * Optional
         * * This does not affect the item itself
         */
        setHidden?(hidden: boolean, options?: ITransaction.OperationOptions): this;
        /**
         * A string identifying the scope. This is normally a sheet name
         * If null then this will be treated as a global scope.
         *
         * @defaultValue `null` - Indicating global
         *
         * @remarks
         * * Optional
         */
        setScope?(scope: string | null, options?: ITransaction.OperationOptions): this;
        /**
         * {@link setHidden}
         */
        isHidden(): boolean;
        /**
         * This is the name that identifies the item.
         *
         * @param name The name.
         */
        setName(name: string, options?: ITransaction.OperationOptions): this;
        /**
         * {@link setName}
         */
        getName(): string;
        /**
         * A string identifying the scope. This is normally a sheet name.
         * @remarks
         * If `null` then this will be treated as a global scope.
         */
        getScope(): string | null;
        /**
         * Add Listeners.
         *
         * @see
         * {@link IListener.ISource.addListeners}
         */
        addListeners(listeners: INamed.IListeners, options?: IListener.Options): IListener.Remove;
        /**
         * Return a JSON if this can be serialize.
         */
        toJSON?(): INamed.JSON | null;
        /**
         * For runtime type checking.
         */
        readonly isINamed: true;
    }
    /**
     * {@inheritDoc INamed}
     * @see
     * ### **Interface**
     *
     * {@link INamed}
     */
    export namespace INamed {
        /**
         * IListener for {@link INamed} events.
         */
        interface Events<T = any> extends IModel.Events {
            /**
             * Called when the range is updated.
             */
            onRangesChange?(source: INamed<T>): void;
        }
        interface IListeners extends IListener.Callbacks<INamed, INamed.Events> {
        }
        /**
         * A named type used for ranges or formulas.
         */
        interface IReference extends INamed<ICellRanges> {
            /**
             * A string to identify the type of named item.
             *
             * @remarks Immutable
             */
            getType(): 'reference';
            /**
             * The underlying item that is being referenced.
             *
             * @remarks Immutable
             */
            getValue(): ICellRanges;
            /**
             * Allows for ranges or formulas to be added.
             */
            setReference(ref: string | ICellRanges.Address): this;
        }
        interface ConstructorOptions<T> extends Omit<IModel.ConstructorOptions<INamed.JSON>, "type"> {
            value?: T | null;
            /**
             * Required to resolve ranges.
             */
            addressToRanges?: (address: ICellRanges.Address) => ICellRanges;
        }
        /**
         * Defined names are descriptive text that is used to represents a cell, range of cells, formula, or constant value.
         */
        interface Properties<R extends IRange.Coords = IRange.Coords> {
            /**
             * The name of the defined name.
             * @remarks
             * This is the name that is used in formulas.
             */
            name: string;
            /**
             * We track named items based on the reference.
             *
             * @remarks
             * If the name is used in a formula this is what will be returned.
             */
            ref: R[];
            /**
             * The comment for the defined name.
             */
            comment?: string;
            /**
             * If true not shown in the ui.
             *
             * @defaultValue false
             */
            hidden?: boolean;
            /**
             * If scope this will be the sheetName.
             */
            scope?: string;
            /**
             * The type of named range item
             */
            type?: string;
        }
        interface JSON {
            name: string;
            comment?: string;
            hidden?: boolean;
            scope?: string;
            /**
             * This is interpreted by the named item
             */
            ref?: string;
        }
    }
}
declare module "named/INamedCollection" {
    import type { ICollection } from "type/index";
    import type { ITransaction } from "transaction/index";
    import type { IListener } from "listener/index";
    import type { ICellRanges } from "cellRange/index";
    import type { INamed } from "named/INamed";
    /**
     * A collection of `INamed` items.
     */
    export interface INamedCollection extends ICollection<INamed> {
        /**
         * Add a named reference.
         *
         * @param name The name of the range.
         * @param reference An address or formula
         * @param replaceExisting If `true` will replace existing ranges if one already exists. *default* `false`.
         *
         * @remarks
         * This is case insensitive, must be unique, and must not have any spaces.
         * This will throw an error if the name is invalid or already exists.
         */
        addReference(name: string, reference: ICellRanges.Address, replaceExisting?: boolean): INamed.IReference;
        /**
         * Add a item to the collection.
         *
         * @param named The item to add.
         *
         * @remarks
         * This will throw an error if `getNamed()` is invalid or am item with the same name already exists.
         */
        add(named: INamed): INamed;
        /**
         * Return the named items.
         * These are sorted by type then by name.
         */
        getItems(options?: INamedCollection.GetItemsOptions): INamed[];
        /**
         * Lookup a named range with a given name.
         *
         * @param name Case insensitive name to lookup
         * @param global If `true` then will search all scopes. *default* `false`
         */
        getByName(name: string, global?: boolean): INamed | null;
        /**
         * Lookup a named range by WorkbookRangeCoords. This will only
         * return a match if all the ranges are exact matches.
         *
         * @deprecated Use getItems({ address }) instead.
         */
        lookupByRanges(ranges: ICellRanges.Address): INamed[] | null;
        /**
         * Returns a new valid name given the name return a valid name that closely matches.
         * This function works by incrementing either the last number or append a number.
         *
         * @param template The range to used as a template.
         * @param scope The scope of the range. If null then this will look for a globally scoped. *default* `null`.
         * @param ignoreExisting If true then won't check to see if the name is already used. *default* `false`.
         * @throws `Error` If the template name is invalid.
         * @returns A valid name. If the name used is valid then will return the same name.
         */
        findValidName(template: string, scope?: string, ignoreExisting?: boolean): string;
        /**
         * Validates a name is valid. This is a convenience method That calls `findValidName`
         * and throws an error if the name returned is not the same.
         *
         * @throws `Error` If `findValidName` does not return the same value as the name checking.
         *
         * @see
         * {@link INamedCollection.findValidName}
         */
        validateName(name: string, scope?: string, ignoreExisting?: boolean): void;
        /**
         * Return ranges for a given address globally scoped.
         *
         * @param address The address to resolve.
         */
        getRanges(address: ICellRanges.Address): ICellRanges;
        /**
         * Add Listeners.
         *
         * @see
         * {@link IListener.ISource.addListeners}
         */
        addListeners(listeners: INamedCollection.IListeners, options?: IListener.Options): IListener.Remove;
        /**
         * Serialize the state.
         */
        toJSON(): INamedCollection.JSON | null;
        /**
         * Loads value from JSON, this will clear any existing state
         *
         * @param json
         */
        fromJSON(json: INamedCollection.JSON): void;
        /** {@inheritDoc ITransaction.ITransactional.isClosed} */
        isClosed(): boolean;
        /** {@inheritDoc ITransaction.ITransactional.close} */
        close(): void;
        /**
         * Used for runtime reflection.
         */
        isNamedCollection: true;
    }
    /**
     * {@inheritDoc INamedCollection}
     * @see
     * ### **Interface**
     *
     * {@link INamedCollection}
     */
    export namespace INamedCollection {
        type JSON = INamed.JSON[];
        interface Events {
            /**
             * Called when the collection changes.
             *
             * @remarks
             * This is not used to capture individual item changes.
             */
            onCollectionChange?(source: INamedCollection): void;
            /**
             * Transaction items have a close event.
             */
            onClose?(source: INamedCollection): void;
        }
        interface IListeners extends IListener.Callbacks<INamedCollection, INamedCollection.Events> {
        }
        interface GetItemsOptions extends ICollection.GetItemsOptions {
            /**
             * A string indicating the type.
             */
            type?: string;
            /**
             * Scope specified will return only scope and global ranges.
             * If not specified then will return only global ranges.
             *
             * @remarks
             * Special case if scope === 'all' then all items will be returned.
             */
            scope?: string | 'all';
            /**
             * The search area.
             *
             * @defaultValue Search the global scope of the NamedCollection.
             */
            address?: ICellRanges.Address;
            /**
             * If true return any Named that is in the bounds even if only partially bounded.
             *
             * @defaultValue false
             */
            allowExtrudes?: boolean;
        }
        interface ConstructorOptions {
            /**
             * Required to resolve ranges.
             */
            addressToRanges: (address: ICellRanges.Address) => ICellRanges;
            /**
             * Returns the current scope.
             */
            getCurrentScope?: () => string;
            /**
             * A transaction store that can be used to undo/redo changes to the names.
             */
            transactions?: ITransaction.IStore;
            /**
             * If the collection is readonly.
             */
            isReadOnly?: () => boolean;
            /**
             * JSON state to load.
             */
            json?: INamedCollection.JSON;
        }
    }
}
declare module "named/index" {
    export * from "named/INamed";
    export * from "named/INamedCollection";
}
declare module "table/ITableCollection" {
    import type { ITransaction } from "transaction/index";
    import type { ICollection } from "type/index";
    import type { ICellRange } from "cellRange/index";
    import type { ITable } from "table/ITable";
    /**
     * Holds a collection of {@link ITable}s.
     */
    export interface ITableCollection extends ICollection<ITable> {
        /**
         * Add an `ITable` to the container.
         *
         * @param address The address of the table.
         * @param options Additional options available when adding a table.
         */
        add(address: ICellRange.Address, options?: ITableCollection.AddOptions): ITable;
        /**
         * Returns items that match the filter criteria.
         *
         * If no filter criteria is provided, all items will be returned.
         *
         * @param options {@link ITableCollection.GetItemsOptions}
         */
        getItems(options?: ITableCollection.GetItemsOptions): ITable[];
        /**
         * Convenience method for filter by name. This is
         * functionally equivalent to getItems({ name });
         *
         * @param name The name to filter for This is case insensitive.
         */
        getByName(name: string): ITable | null;
    }
    /**
     * {@inheritDoc ITableCollection}
     * @see
     * ### **Interface**
     *
     * {@link ITableCollection}
     */
    export namespace ITableCollection {
        /**
         * Options for adding a table to the collection.
         */
        interface AddOptions extends ITransaction.OperationOptions {
            /**
             * If not specified then the header status will be determined from the range data.
             *
             * @defaultValue 'based on initial data set'
             */
            hasHeader?: boolean;
            /**
             * The default style to use. If null than it will not be set
             * If undefined or not provided it will use the.
             *
             * @defaultValue uses the default table style
             */
            styleName?: string;
            /**
             * If the add should clear any previous formatting.
             * @defaultValue false
             */
            clearFormatting?: boolean;
            /**
             * JSON state to load.
             */
            json?: ITable.JSON;
            /**
             * If the table is being loaded. This is used
             * to indicate to the table that it should not create
             * default values.
             * @defaultValue false;
             */
            isLoad?: boolean;
        }
        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 filter bounds.
             *
             * @defaultValue false
             */
            fullyContained?: boolean;
            /**
             * Filter with the given name. This is case insensitive.
             */
            name?: string;
        }
    }
}
declare module "table/ITableStyle" {
    import type { IProperties } from "type/index";
    import type { IStyle } from "style/index";
    import type { ITable } from "table/ITable";
    export namespace ITableStyle {
        /**
         * Options used for when calling getStyleProperties.
         */
        interface StyleOptions {
            /**
             * A string representing the name of the table style to use with this table.
             * If the style name isn't valid then the spreadsheet application should use default style.
             * If the name is missing then no formatting will be applied.
             */
            name?: string;
            /**
             * A Boolean indicating whether row stripe formatting is applied. True when style row stripe formatting is applied.
             * @defaultValue true
             */
            showRowStripes?: boolean;
            /**
             * A Boolean indicating whether column stripe formatting is applied. True when style column stripe formatting is applied.
             * @defaultValue false
             */
            showColumnStripes?: boolean;
            /**
             * A Boolean indicating whether the first column in the table should have the style applied. True if the first column has the style applied.
             * @defaultValue false
             */
            showFirstColumn?: boolean;
            /**
             * A Boolean indicating whether the last column in the table should have the style applied. True if the last column has the style applied.
             * @defaultValue false
             */
            showLastColumn?: boolean;
        }
        /**
         * The Type of element to style.
         */
        const ElementType: {
            /**
             * The entire table.
             */
            readonly WholeTable: "wholeTable";
            readonly FirstColumnStripe: "firstColumnStripe";
            readonly SecondColumnStripe: "secondColumnStripe";
            readonly FirstRowStripe: "firstRowStripe";
            readonly SecondRowStripe: "secondRowStripe";
            readonly LastColumn: "lastColumn";
            readonly FirstColumn: "firstColumn";
            readonly HeaderRow: "headerRow";
            readonly TotalRow: "totalRow";
            readonly FirstHeaderCell: "firstHeaderCell";
            readonly LastHeaderCell: "lastHeaderCell";
            readonly FirstTotalCell: "firstTotalCell";
            readonly LastTotalCell: "lastTotalCell";
        };
        type ElementType = typeof ElementType[keyof typeof ElementType];
        /**
         * Extends {@link IStyle.Properties} to include a size.
         *
         * @remarks
         * This is used to allow for different styles depending on the number of stripes
         * (rows or columns used for the style).
         */
        interface SizeBasedProperties extends IStyle.Properties {
            /**
             * The size is available for the following table elements:
             * * firstRowStripe
             * * secondRowStripe
             * * firstColumnStripe
             * * secondColumnStripe
             *
             * @defaultValue 1
             */
            size?: number;
        }
        /**
         * A table style is a collection of cell styles that are applied to a table.
         * These are applied in a specific order and merged to create a single cell style.
         *
         * The order is:
         * Whole Table
         * * First Column Stripe
         * * Second Column Stripe
         * * First Row Stripe
         * * Second Row Stripe
         * * Last Column
         * * First Column
         * * Header Row
         * * Total Row
         * * First Header Cell
         * * Last Header Cell
         * * First Total Cell
         * * Last Total Cell
         */
        interface Properties {
            /**
             * The name of the table style. This is the name that is shown in the UI.
             */
            name: string;
            /**
             * If this table style should be shown as an available table style.
             * @remarks
             * table and pivot can not both be true. If both false then hidden
             * @defaultValue true
             */
            table?: boolean;
            /**
             * 'True' if this table style should be shown as an available pivot table style.
             * @remarks
             * table and pivot can not both be true. If both false then hidden
             * @defaultValue false
             */
            pivot?: boolean;
            /**
             * Properties for the whole table.
             */
            wholeTable?: IStyle.Properties;
            /**
             * Properties for the first set of alternating columns.
             */
            firstColumnStripe?: ITableStyle.SizeBasedProperties;
            /**
             * Properties for the second set of alternating columns.
             */
            secondColumnStripe?: ITableStyle.SizeBasedProperties;
            /**
             * Properties for the first set of alternating rows.
             */
            firstRowStripe?: ITableStyle.SizeBasedProperties;
            /**
             * Properties for the second set of alternating rows.
             */
            secondRowStripe?: ITableStyle.SizeBasedProperties;
            /**
             * For the last column.
             */
            lastColumn?: IStyle.Properties;
            /**
             * For the first column.
             */
            firstColumn?: IStyle.Properties;
            /**
             * For the header row.
             */
            headerRow?: IStyle.Properties;
            /**
             * For the first header cell. To be applied
             * both the header and first column must be selected.
             */
            firstHeaderCell?: IStyle.Properties;
            /**
             * For the last header cell. To be applied
             * both the header and last column must be selected.
             */
            lastHeaderCell?: IStyle.Properties;
            /**
             * For the total row.
             */
            totalRow?: IStyle.Properties;
            /**
             * For the first total cell. To be applied
             * both the total and first column must be selected.
             */
            firstTotalCell?: IStyle.Properties;
            /**
             * For the last total cell. To be applied
             * both the total and last column must be selected.
             */
            lastTotalCell?: IStyle.Properties;
        }
        type ResolvableProperties = IProperties.ResolvableProperties<ITableStyle.Properties>;
        interface JSON extends ITableStyle.Properties {
        }
        /**
         * JSON definition for a list of TableStyles.
         */
        interface JSONS {
            defaultTableStyle?: string;
            defaultPivotStyle?: string;
            styles?: Record<string, ITableStyle.JSON>;
        }
        /**
         * Properties for a pivot table style.
         *
         * @remarks
         * **NOT IMPLEMENTED**
         */
        interface PivotProperties {
            name?: string;
            wholeTable?: IStyle.Properties;
            firstColumnStripe?: ITableStyle.SizeBasedProperties;
            secondColumnStripe?: ITableStyle.SizeBasedProperties;
            firstRowStripe?: ITableStyle.SizeBasedProperties;
            secondRowStripe?: ITableStyle.SizeBasedProperties;
            firstColumn?: IStyle.Properties;
            headerRow?: IStyle.Properties;
            firstHeaderCell?: IStyle.Properties;
            pageFieldLabels?: IStyle.Properties;
            pageFieldValues?: IStyle.Properties;
            subtotalColumn1?: IStyle.Properties;
            subtotalColumn2?: IStyle.Properties;
            subtotalColumn3?: IStyle.Properties;
            blankRow?: IStyle.Properties;
            subtotalRow1?: IStyle.Properties;
            subtotalRow2?: IStyle.Properties;
            subtotalRow3?: IStyle.Properties;
            columnSubheading1?: IStyle.Properties;
            columnSubheading2?: IStyle.Properties;
            columnSubheading3?: IStyle.Properties;
            rowSubheading1?: IStyle.Properties;
            rowSubheading2?: IStyle.Properties;
            rowSubheading3?: IStyle.Properties;
            grandTotalColumn?: IStyle.Properties;
            grandTotalRow?: IStyle.Properties;
        }
    }
    /**
     * Represents a style applied to tables, with methods for retrieving style
     * properties, checking its usage in different contexts, and identifying built-in styles.
     */
    export interface ITableStyle {
        /**
         * Returns the name of the table style.
         *
         * @returns The name of the table style as a string.
         */
        getName(): string;
        /**
         * Indicates whether this style appears in the list of table styles
         * available for selection.
         *
         * @returns `true` if the style is shown in the table styles list; otherwise, `false`.
         */
        isShownInTableStyles(): boolean;
        /**
         * Indicates whether this style appears in the list of pivot table styles
         * available for selection.
         *
         * @returns `true` if the style is shown in the pivot table styles list; otherwise, `false`.
         */
        isShownInPivotStyles(): boolean;
        /**
         * Returns a ranged interface for applying this style to a specific table.
         *
         * @param table The target `ITable` to which this style will be applied.
         * @returns An `ICellRanged` interface containing properties for `IStyle`.
         */
        getRanged(table: ITable): IProperties.ICellRanged<IStyle.Properties>;
        /**
         * Indicates whether this style is a built-in, predefined style.
         *
         * @returns `true` if the style is a built-in style; otherwise, `false`.
         */
        isBuiltIn(): boolean;
        /**
         * Delete the style from the collection.
         *
         * @remarks
         * This will only remove if the style is not a built-in style.
         * @see
         * {@link ITableStyle.isBuiltIn}
         */
        delete(): void;
        /**
         * Returns the readonly list of properties for the style.
         *
         * @remarks
         * This are unresolved properties.
         */
        getProperties(): Readonly<ITableStyle.Properties>;
        /**
         * Serializes the table style to JSON format.
         *
         * @returns A `ITableStyle.JSON` representation of the style.
         */
        toJSON(): ITableStyle.JSON;
        /**
         * For runtime type checking.
         */
        readonly isITableStyle: true;
    }
    /**
     * {@inheritDoc ITableStyle}
     * @see
     * ### **Interface**
     *
     * {@link ITableStyle}
     */
    export namespace ITableStyle {
        /**
         * Special table style that doesn't style anything. This is used
         * for tables that have their format's cleared.
         */
        class Empty implements ITableStyle {
            private _normalStyle;
            constructor(normalStyle: IStyle);
            /** {@inheritDoc ITableStyle.getName} */
            getName(): string;
            /** {@inheritDoc ITableStyle.isShownInTableStyles} */
            isShownInTableStyles(): boolean;
            /** {@inheritDoc ITableStyle.isShownInPivotStyles} */
            isShownInPivotStyles(): boolean;
            /** {@inheritDoc ITableStyle.getRanged} */
            getRanged(_table: ITable): IProperties.ICellRanged<IStyle.Properties>;
            /** {@inheritDoc ITableStyle.getProperties} */
            getProperties(): Readonly<ITableStyle.Properties>;
            /** {@inheritDoc ITableStyle.isBuiltIn} */
            isBuiltIn(): true;
            /** {@inheritDoc ITableStyle.delete} */
            delete(): void;
            /** {@inheritDoc ITableStyle.toJSON} */
            toJSON(): ITableStyle.JSON;
            /** {@inheritDoc ITableStyle.isITableStyle} */
            get isITableStyle(): true;
        }
    }
}
declare module "table/ITable" {
    import type { IRange } from '@sheetxl/primitives';
    import type { ReferenceableClipboard } from '@sheetxl/utils';
    import type { IListener } from "listener/index";
    import type { IHistory } from "history/index";
    import type { ICellRange } from "cellRange/index";
    import type { IAutoSort } from "sort/index";
    import type { IAutoFilter } from "filter/index";
    import type { IAnchored } from "anchored/index";
    import type { IStyle, IStyleCollection } from "style/index";
    import type { INamedCollection } from "named/index";
    import type { ISheet } from "sheet/index";
    import type { ITableCollection } from "table/ITableCollection";
    import type { ITableStyle } from "table/ITableStyle";
    /**
     * Capabilities for working with embedded tables.
     *
     * Tables offer structured data management and enhanced analysis features.
     *
     * Key features including:
     * - Operating on data with named and typed columns.
     * - Automatic filtering and sorting options.
     * - Creating calculated columns with dynamic formulas.
     * - Utilizing structured references for easier formula creation.
     * - Applying table styles for visual organization and improved readability.
     *
     * @see
     * ### **Interface**
     *
     * {@link ITable}
     *
     * **Additional Interfaces**
     * * {@link ITableStyle}
     * * {@link ITableCollection}
     */
    export namespace ITable {
        /**
         * Element representing a single column for a table.
         */
        interface Column {
            /**
             * A string representing the unique caption of the table column.
             * This is what shall be displayed in the header row in the UI, and is referenced through functions.
             * This name shall be unique per table.
             */
            name: string;
        }
        /**
         * A set of values that can be set on a ITable.
         *
         * @see
         * {@link ITable}
         */
        interface Properties {
            /**
             * The unique name of the table
             */
            name?: string;
            /**
             * A string representing the name of the table. This is the name that shall be used in formula references,
             * and displayed in the UI to the spreadsheet user.
             * This name shall not have any spaces in it, and it must be unique amongst all other displayNames and
             * definedNames in the names. The character lengths and restrictions are the same as for definedNames.
             *
             * See SpreadsheetML Reference - Workbook definedNames section for details.
             */
            description?: string;
            /**
             * An integer representing the number of header rows showing at the top of the table.
             * 0 means that the header row is not shown
             * @defaultValue 1
             */
            headerRowCount?: number;
            /**
             * An integer representing the number of totals rows that shall be shown at the bottom of the table.
             *
             * @defaultValue 0
             */
            totalsRowCount?: number;
            /**
             * If not specified then the default table style is used
             * If the style name isn't valid then uses a 'none' style.
             */
            styleOptions?: ITableStyle.StyleOptions;
        }
        /**
         * Provides destination details for the Snapshot when using {@link IHistory.ISnapshot.copyTo}.
         */
        interface SnapshotDestination {
            tables: ITableCollection;
            range: IRange.Coords;
        }
        interface ISnapshot extends IHistory.ISnapshot<ITable.SnapshotDestination, ITable, IRange.Coords> {
            /**
             * Called when the table is copied to a new collection.
             */
            copyTo(destination: ITable.SnapshotDestination, options?: ReferenceableClipboard.CopyOptions): Promise<IRange.Coords>;
        }
        /**
         * A JSON representation useful for persistence.
         */
        interface JSON extends Properties {
            /**
             * An A1 representation of a range that is the bounding area
             * for the table.
             *
             * @remarks
             * The reference shall include the totals row if it is shown
             */
            ref: IRange.Coords | string;
            /**
             * Table column definitions.
             */
            columns?: ITable.Column[];
            /**
             * If missing than no auto filter enabled
             */
            filter?: IAutoFilter.JSON;
            /**
             * This is available on both the filter and the table so that the sort state
             * can be restored if the filter was removed and re-added.
             */
            sort?: IAutoSort.JSON;
        }
        /**
         * IListener for {@link ITable} events.
         */
        interface Events extends IAnchored.Events {
            /**
             * Called when any property changes.
             */
            onAnyChange?(source: ITable): void;
            /**
             * Called when the table is changed.
             */
            onStyleChange?(source: ITable): void;
        }
        interface IListeners extends IListener.Callbacks<ITable, ITable.Events> {
        }
        interface ConstructorOptions extends IAnchored.ConstructorOptions {
            sheet?: ISheet;
            /**
             * Required if there is no sheet. For example when showing table Preview.
             */
            styles?: IStyleCollection;
            names?: INamedCollection;
            /**
             * JSON state to load.
             */
            json?: ITable.JSON;
            readSheetHeader?: boolean;
            processTableUpdate?: () => void;
            /**
             * Notify the container that a named change is required.
             * @param name The name to change to
             */
            setNameOnContainer?: (name: string) => void;
        }
    }
    /**
     * A Table is an embedded table that allows for advanced capabilities.
     *
     * 1. Filtering
     * 2. Dynamic Styling
     * 3. External data
     * 4. Structured formulas
     */
    export interface ITable extends IAnchored {
        /**
         * Selects the current table.
         *
         * @returns An async boolean indicating the table was selected.
         */
        select(options?: ICellRange.SelectOptions): Promise<ICellRange>;
        /**
         * Add a number of rows to a table
         * @remarks
         * Not implemented
         *
         * @param offset
         * @param count
         */
        addRows(offset: number, count?: number): ITable;
        /**
         * Delete the rows from the table.
         * @remarks
         * Not implemented
         *
         * @param index The index to clear from
         * @param count
         */
        deleteRowsAt(index: number, count?: number): ITable;
        /**
         * Add a single column.
         * @remarks
         * Not implemented
         * To remove columns use the resize
         */
        addColumn(index: number, name?: string): ITable.Column;
        /**
         * Returns the columns for this table.
         */
        getColumns(): ITable.Column[];
        /**
         * Returns an column for the given offset.
         * @param offset
         */
        getColumnFilter(offset: number): IAutoFilter.IColumn;
        /**
         * Returns the AutoFilter used for this table.
         */
        getFilter(): IAutoFilter;
        /**
         * Convert the existing table to a range.
         * This will remove the table but preserve the original
         * data and formatting.
         * @param maxCells The maximum number of convert.
         * @remarks
         * This can be an expensive operation.
         */
        convertToRange(maxCells?: number): ICellRange;
        /**
         * Resize the table.
         * @param address The new size of the table.
         *
         * @remarks
         * This will throw an exception if:
         * 1. The top row changes.
         * 2. If doesn't overlap with the original table.
         * 3. If overlaps with another non-overlapping object (e.g. another table or a merge).
         */
        resize(address: ICellRange.Address): ICellRange;
        /**
         * @see {@link setName}
         */
        getName(): string;
        /**
         * Set the name for a table object.
         *
         * @param name A unique name.
         */
        setName(name: string): ITable;
        /**
         * @see {@link setDescription}
         */
        getDescription(): string;
        /**
         * This is the alternative text use for assistive technologies.
         *
         * @param description A short human readable text. Default value `null`.
         */
        setDescription(description: string | null): ITable;
        /**
         * Returns the range for the entire table.
         */
        getRange(): ICellRange;
        /**
         * Get the range between the header and the total.
         */
        getUsedRange(): ICellRange;
        /**
         * Get the header range.
         */
        getHeaderRange(): ICellRange;
        /**
         * Get the total range.
         */
        getTotalRange(): ICellRange;
        /**
         * Get the style info.
         */
        getStyleOptions(): ITableStyle.StyleOptions;
        /**
         * Updates the table StyleInfo.
         *
         * @param options Style options unique to the table.
         *
         * @remarks
         * This will merge with the existing values.
         */
        updateStyleOptions(options: ITableStyle.StyleOptions): ITable;
        /**
         * Returns the current `ITableStyle` used.
         */
        getStyle(): ITableStyle;
        /**
         * Returns a cell style for the given coords.
         * @param coords The absolute coords.
         * @remarks
         * This will return a CellStyle rendered with the table styling but not any other styling.
         *
         * * This is used by the preview.
         */
        getStyleAt(coords: IRange.CellCoords): IStyle;
        /**
         * Specifies if totals are being shown for the table.
         */
        getShowTotals(): boolean;
        /**
         * Specifies if totals are being shown for the table.
         */
        setShowTotals(showTotals: boolean): ITable;
        /**
         * Specifies if headers are being shown for the table.
         */
        getShowHeaders(): boolean;
        /**
         * Specifies if headers are being shown for the table.
         */
        setShowHeaders(showHeaders: boolean): ITable;
        /**
         * Specifies if filter buttons are being shown.
         */
        getShowFilterButton(): boolean;
        /**
         * Specifies if filter buttons are being shown.
         * @remarks
         * If the autoFilter is not enabled this will have no effect.
         */
        setShowFilterButton(showFilterButton: boolean): ITable;
        /**
         * Enabled and returns an IAutoFilter.
         * Only one AutoFilter per table is supported so this will
         * return the same instance if it has already been created.
         */
        insertFilter(): IAutoFilter;
        /**
         * Returns an IAutoFilter associated with this Table.
         */
        getFilter(): IAutoFilter | null;
        /**
         * Only one sort per table is supported so this will.
         * return the same instance if it has already been created.
         */
        insertSort(): IAutoSort;
        /**
         * Returns the current sort or null if there is no IAutoSort.
         * @see
         * {@link insertSort}
         */
        getSort(): IAutoSort | null;
        /**
         * Returns the bounds for the ref accounting for hidden headers.
         *
         * @remarks
         * This is used for borders and drag areas that are based on visible edges.
         * excluding hidden rows/columns (headers).
         */
        getVisibleRefRangeCoords(): IRange.Coords;
        /**
         * Returns the coords after any hidden values are applied.
         * @param coords The absolute coords
         */
        getVisibleCellCoords(coords: IRange.CellCoords): IRange.CellCoords;
        /**
         * Returns a flag indicating if the header is visible due to hidden headers.
         */
        isHeaderVisible(): boolean;
        /**
         * Returns a flag indicating if the footer is visible due to hidden headers.
         */
        isTotalVisible(): boolean;
        /**
         * Returns a flag indicating if the first column is visible due to hidden headers.
         */
        isFirstColumnVisible(): boolean;
        /**
         * Returns a flag indicating if the first column is visible due to hidden headers.
         */
        isLastColumnVisible(): boolean;
        /**
         * Returns a snapshot of the table that can be used for copying and archiving.
         */
        getSnapshot(options?: ReferenceableClipboard.CopyOptions): ITable.ISnapshot;
        /**
         * Add Listeners.
         *
         * @see
         * {@link IListener.ISource.addListeners}
         */
        addListeners(listeners: ITable.IListeners, options?: IListener.Options): IListener.Remove;
        /**
         * @returns The current state as a JSON object.
         */
        toJSON(): ITable.JSON;
        /**
         * For runtime type checking.
         */
        readonly isITable: true;
    }
}
declare module "string/IStringCollection" {
    import type { ICollection } from "type/index";
    /**
     * Contains a collection of interned strings.
     */
    export interface IStringCollection extends ICollection<string>, ICollection.IPersistable {
        /**
         * Add a string to the collection.
         *
         * @param shared A string
         *
         * @remarks
         * Resources are not removed from the the collection. They are autoGCed when there are no references.
         */
        add(shared: string): number;
        /**
         * Add multiple string to the collection.
         *
         * @param shared An array of strings
         * @param conflateDuplicates If the same string is in the list it will be conflated. Default value `false`.
         *
         * @remarks
         * There are instances where Excel may have duplicate strings so by default this is false.
         */
        addMultiple(shared: string[], conflateDuplicates?: boolean): void;
        /**
         * Returns the string for the given id.
         *
         * @param id The id
         */
        getById(id: number): string;
        /** {@inheritDoc ICollection.IPersistScope} */
        beginPersist(): ICollection.IPersistScope<IStringCollection.JSON>;
    }
    /**
     * {@inheritDoc IStringCollection}
     * @see
     * ### **Interface**
     *
     * {@link IStringCollection}
     */
    export namespace IStringCollection {
        interface GetItemsOptions extends ICollection.GetItemsOptions {
            id?: number;
        }
        /**
         * Alias for persist type of `string`.
         */
        type JSON = string;
    }
}
declare module "string/StringCollection" {
    import { ICollection } from "type/index";
    import { IStringCollection } from "string/IStringCollection";
    export class StringCollection implements IStringCollection {
        private _persistOpen;
        private _stringsByText;
        private _stringsById;
        private _nextId;
        private _lastReadId;
        private _lastReadValue;
        constructor();
        /** {@inheritDoc IStringCollection.addMultiple} */
        addMultiple(shared: string[], conflateDuplicates?: boolean): void;
        /** {@inheritDoc IStringCollection.add} */
        add(shared: string): number;
        /** {@inheritDoc IStringCollection.getItems} */
        getItems(options?: IStringCollection.GetItemsOptions): string[];
        /** {@inheritDoc IStringCollection.getById} */
        getById(id: number): string;
        /** {@inheritDoc ICollection.getCount} */
        getCount(): number;
        /** {@inheritDoc ICollection.IPersistable.beginPersist} */
        beginPersist(): ICollection.IPersistScope<IStringCollection.JSON>;
    }
}
declare module "string/index" {
    export * from "string/IStringCollection";
    export * from "string/StringCollection";
}
declare module "script/IFunctionCollection" {
    import type { IFunction } from '@sheetxl/primitives';
    import type { ICollection } from "type/index";
    import type { IListener } from "listener/index";
    /**
     * Collections of {@link IFunction}.
     */
    export interface IFunctionCollection extends ICollection<IFunction> {
        /**
         * Add a custom function to a collection.
         *
         * @param options
         */
        add(options: IFunction | IFunctionCollection.AddOptions): IFunction;
        /**
         * Returns functions that match the filter criteria.
         *
         * If no filter criteria is provided, all items will be returned.
         *
         * @param options {@link IFunctionCollection.SearchOptions}
         */
        search(options?: IFunctionCollection.SearchOptions): Promise<IFunction[]>;
        /**
         * Convenience method for filter by name.
         * This is functionally equivalent to getItems({ name });
         *
         * @param name The name to search for This is case insensitive.
         */
        getByName(name: string): IFunction | null;
    }
    /**
     * {@inheritDoc IFunctionCollection}
     * @see
     * ### **Interface**
     *
     * {@link IFunctionCollection}
     */
    export namespace IFunctionCollection {
        /**
         * Options for searching a function in the collection.
         */
        interface SearchOptions {
            /**
             * Search with the given name. This is case insensitive.
             */
            name?: string;
            /**
             * Search all function descriptors for the given text. This is case insensitive.
             *
             * @remarks
             * If this is specified this will also search the name.
             */
            text?: string;
            /**
             * Search with the given name. This is case insensitive.
             */
            category?: string;
            type?: string;
        }
        interface Events {
            /**
             * Called when the collection changes.
             *
             * @remarks
             * This is not used to capture individual item changes.
             */
            onCollectionChange?(source: IFunctionCollection): void;
            /**
             * Transaction items have a close event.
             */
            onClose?(source: IFunctionCollection): void;
        }
        interface IListeners extends IListener.Callbacks<IFunctionCollection, IFunctionCollection.Events> {
        }
        /**
         * Add a custom function.
         */
        interface AddOptions {
            /**
             * Required.
             *
             * @param args
             * @returns the value of the function.
             */
            execute: (args: any[]) => any;
            /**
             * Required.
             */
            declaration: IFunction.DeclarationJSON;
            /**
             * Configuration for UI descriptor.
             * @param locale
             * @returns
             */
            descriptor?: IFunction.DescriptorJSON | ((locale?: string) => Promise<IFunction.DescriptorJSON>);
        }
    }
}
declare module "script/IModule" {
    import type { CompileOptions as _CompileOptions, CompileResults as _CompileResults, CompiledModule } from '@sheetxl/scripting';
    import type { IListener } from "listener/index";
    import type { IFunctionCollection } from "script/IFunctionCollection";
    /**
     * Represents a collection of functions. This is analogous to a file.
     */
    export interface IModule {
        /**
         * Returns the functions in the module.
         *
         * @remarks
         * This maybe be empty even if there is source. It is possible that a script might contain only comments or other non-executable code.
         */
        getFunctions(): IFunctionCollection;
        /**
         * The human-readable source code of the script.
         *
         * @remarks
         * If this property is null, the module may still have compiled functions.
         */
        getSource(): string | null;
        /**
         * The language the function is written in.
         */
        getLanguage(): string;
        getErrors(): any[];
        /**
         * The name of the module.
         */
        getName(): string;
        /**
         * Remove the module from the collection.
         */
        delete(): void;
        /**
         * Returns a JSON representation of the module.
         */
        toJSON(): IModule.JSON;
        addListeners(listeners: IModule.IListeners, options?: IListener.Options): IListener.Remove;
    }
    /**
     * {@inheritDoc IModule}
     * @see
     * ### **Interface**
     *
     * {@link IModule}
     */
    export namespace IModule {
        /**
         * Results for compiling a module.
         */
        type CompileResult = _CompileResults;
        /**
         * Options for compiling a module.
         */
        type CompileOptions = _CompileOptions;
        /**
         * Used to serialize a module.
         */
        type JSON = CompiledModule;
        interface Events {
            /**
             * When delete is called
             */
            onDelete?(source: IModule): void;
        }
        interface IListeners extends IListener.Callbacks<IModule, IModule.Events> {
        }
    }
}
declare module "script/IModuleCollection" {
    import { ICollection } from "type/index";
    import { IListener } from "listener/index";
    import { IModule } from "script/IModule";
    /**
     * Represents a collection of functions. This is analogous to a file.
     */
    export interface IModuleCollection extends ICollection<IModule> {
        /**
         * Adds the module to the collection.
         *
         * @param uid A unique identifier for the module. This can be either a name, a fully qualified path, or a url (e.g., a file name, a Git url with commit ID).
         * @param module The module to add. This will generally come from IScript.createModule.
         * @param options The options for adding the module.
         */
        add(uid: string, module: IModule, options?: IModuleCollection.AddOptions): void;
        /**
         * Returns functions that match the filter criteria.
         *
         * If no filter criteria is provided, all items will be returned.
         *
         * @param options {@link IModuleCollection.GetItemsOptions}
         */
        getItems(options?: IModuleCollection.GetItemsOptions): IModule[];
        /**
         * Convenience method for filtering by name.
         * This is functionally equivalent to getItems({ name });
         *
         * @param name The name to search for This is case insensitive.
         */
        getByName(name: string): IModule | null;
        /**
         * Add Listeners.
         *
         * @see
         * {@link IListener.ISource.addListeners}
         */
        addListeners(listeners: IModuleCollection.IListeners, options?: IListener.Options): IListener.Remove;
        /**
         * Returns a JSON representation of the module collection.
         */
        toJSON(): Record<string, IModule.JSON>;
    }
    export namespace IModuleCollection {
        interface AddOptions {
            /**
             * If true, the module will be added to the collection even if it already exists.
             */
            replace?: boolean;
            /**
             * If true, the module will be added to the collection even if it has errors.
             */
            ignoreErrors?: boolean;
        }
        /**
       * Options for filtering a function in the collection.
       */
        interface GetItemsOptions extends ICollection.GetItemsOptions {
            /**
             * Search with the given name. This is case insensitive.
             */
            name?: string;
        }
        interface Events {
            /**
             * Called when the collection changes.
             *
             * @remarks
             * This is not used to capture individual item changes.
             */
            onCollectionChange?(source: IModuleCollection): void;
            /**
             * Transaction items have a close event.
             */
            onClose?(source: IModuleCollection): void;
        }
        interface IListeners extends IListener.Callbacks<IModuleCollection, IModuleCollection.Events> {
        }
    }
}
declare module "script/IScript" {
    import type { IFunction } from '@sheetxl/primitives';
    import type { IListener } from "listener/index";
    import type { IFunctionCollection } from "script/IFunctionCollection";
    import type { IModule } from "script/IModule";
    import type { IModuleCollection } from "script/IModuleCollection";
    /**
     * Contains interfaces for working with scripts.
     *
     * @remarks
     * Scripts are collections of modules that contain functions.
     *
     * Modules are analogous to files, and functions are the executable code within those modules.
     */
    export interface IScript {
        /**
         * Returns a collection of modules.
         */
        getModules(): IModuleCollection;
        /**
         * Creates a module from the source code.
         *
         * @param options
         */
        createModule(options?: IModule.CompileOptions): Promise<IModule>;
        /**
         * Adds a module to the script.
         * @param uid
         * @param module
         * @param options
         */
        addModule(uid: string, module: IModule, options?: IModuleCollection.AddOptions): void;
        /**
         * Executes a macro function.
         *
         * @param functionName The name of the function to execute.
         * @param moduleId The ID of the module containing the function.
         */
        executeMacro(functionName: string, moduleId?: string): Promise<IScript.MacroResults>;
        /**
         * Will start scripting engine and autoRun scripts.
         */
        start(): Promise<void>;
        /**
         * Returns if the script is readonly.
         */
        isReadOnly(): boolean;
        /**
         * Convenience method for creating a module from a file.
         *
         * @remarks
         * equivalent to `getModules().search( { type: 'macro', name } )`
         */
        searchFunctions(options?: IScript.SearchOptions): Promise<IFunction[]>;
        /**
         * Add Listeners.
         *
         * @see
         * {@link IListener.ISource.addListeners}
         */
        addListeners(listeners: IScript.IListeners, options?: IListener.Options): IListener.Remove;
        /**
         * Returns a JSON representation of the script.
         */
        toJSON(): Record<string, IModule.JSON>;
    }
    /**
     * {@inheritDoc IFunctionCollection}
     * @see
     * ### **Interface**
     *
     * {@link IFunctionCollection}
     */
    export namespace IScript {
        /**
         * Events for {@link ISheet}.
         */
        interface Events {
            /**
             * Called before search.
             */
            onBeforeSearch?(source: IScript): Promise<void> | void;
            /**
             * Called after load.
             */
            onChange?(source: IScript): void;
            /**
             * Called before load. If any exception is thrown this
             * exception will be returned to the client and delete will be aborted.
             */
            onBeforeSave?(source: IScript): Promise<void> | void;
            /**
             * Called after save.
             */
            onSave?(source: IScript): void;
        }
        interface IListeners extends IListener.Callbacks<IScript, IScript.Events> {
        }
        /**
         * The results from a macro script
         */
        interface MacroResults {
            params: any[];
            results: any;
        }
        interface SearchOptions extends IFunctionCollection.SearchOptions {
            moduleName?: string;
            includeBuiltIn?: boolean;
        }
    }
}
declare module "script/index" {
    export * from "script/IScript";
    export * from "script/IModule";
    export * from "script/IFunctionCollection";
}
declare module "calculation/ICalculation" {
    import { IRange, Scalar, IFunction, IRuntime, FormulaError } from '@sheetxl/primitives';
    import type { IListener } from "listener/index";
    import type { IModel } from "model/index";
    import type { IStringCollection } from "string/index";
    import type { IFunctionCollection } from "script/index";
    /**
     * Calculation is the process of computing formulas and then displaying the results
     * as values in the cells that contain the formulas.
     */
    export interface ICalculation extends IModel {
        /**
         * Starts the ICalculation engine.
         *
         * @remarks
         * * This is required to be called before any calculations can be performed.
         * * This will initialize the calculation engine and prepare it for use.
         * * Will fire events and return a promise when the calculation is started. (or errors);
         */
        start: () => Promise<void>;
        /**
         * Stops the ICalculation engine.
         */
        stop: () => Promise<void>;
        /**
         * Returns the current status of the calculation engine.
         */
        getStatus(): ICalculation.Status;
        /**
         * Returns the functions available for the calculation engine.
         */
        getFunctions(): IFunctionCollection;
        /** @inheritdoc IFormulaContext.getRuntime */
        getRuntime(): IRuntime;
        /**
         * Returns when all calculations are complete and there are no pending calculations.
         *
         * @remarks
         * * This is useful when needing to ensure that the values in the calculation cycle are up-to-date.
         * * For streaming functions still will return the current value.
         */
        ready(): Promise<void>;
        /**
         * Add Listeners.
         *
         * @see
         * {@link IListener.ISource.addListeners}
         */
        addListeners(listeners: ICalculation.IListeners, options?: IListener.Options): IListener.Remove;
    }
    /**
     * {@inheritDoc ICalculation}
     * @see
     * ### **Interface**
     *
     * {@link ICalculation}
     */
    export namespace ICalculation {
        /**
         * Options for when calculating.
         */
        interface CalculateOptions {
            /**
             * If true a full calc will be done not just invalid values
             */
            full?: boolean;
        }
        /**
         * Represents a formula that can be evaluated.
         */
        interface IFormula {
            /**
             * Return the formula as an array of tokenized values.
             *
             * @param evalIndex Allows for a partial evaluation based on a token index.
             *
             * @remarks
             * These can be used by advanced editors.
             *
             * @see ICalculation.FormulaToken.evalIndex
             */
            getTokens(evalIndex?: number): readonly ICalculation.FormulaToken[];
            /**
             * Return the value for a formula.
             *
             * @param evalIndex Allows for a partial evaluation based on a token index.
             *
             * @remarks
             * The index is the {@link ICalculation.FormulaToken.evalIndex}. If not provided this will return
             * the value of the entire formula.
             *
             * @see ICalculation.FormulaToken.evalIndex
             */
            evaluate(evalIndex?: number): Promise<Scalar | IRange>;
            /**
             * Return the formula string.
             *
             * @param r1c1 If `true` then the formula will be returned in R1C1 format.
             */
            toText(r1c1?: boolean): string;
            /**
             * Returns the ranges that provide data to a formula.
             *
             * @remarks
             * * `[]` if no precedents are present; either because it has no formula or a formula with no inputs.
             * * Precedents are the logical ranges and may different the inputs into the formula.
             */
            getDirectPrecedents(): readonly (IRange.FixableCoords | FormulaError.Known)[];
            /**
             * Returns the references that are used in the formula.
             *
             * @remarks
             * This is different than the direct precedents as it includes references before the range
             * operators. This is useful for indicating to the users the static inputs and allow.
             */
            getReferences(): readonly (IRange.FixableCoords | string | FormulaError.Known)[];
            /**
             * Sets the reference at the given index.
             *
             * @param index The index of the reference to set.
             * @param reference The reference to set at the index.
             *
             * @remarks
             * The index must align with the getReferences() array. Will throw an error if the
             * index not with the reference array.
             */
            setReferenceAt(index: number, reference: IRange.FixableCoords | null): this;
        }
        /**
         * Provides the function context for formulas that are arguments.
         */
        interface FormulaTokenContext {
            /**
             * The name of the function
             */
            name: string;
            /**
             * If the token is part of a function this will be the index location.
             *
             * @remarks
             * For parens this will be `-1`.
             */
            argIndex: number;
        }
        /**
         * Represents a portion of a formula for rendering typical in an editor.
         */
        interface FormulaToken {
            /**
             * The type of token.
             */
            type: string;
            /**
             * This is either a string or a range coordinates.
             *
             * @remarks
             * If this is a IRange.Coords then is it relative.
             */
            value: string | IRange.FixableCoords | any;
            /**
             * If the token is part of a a function this will be set. This will be the 'closest' function if nested.
             */
            ctx?: ICalculation.FormulaTokenContext;
            /**
             * Allows for partial formula evaluation for tooltips or formula writing.
             * Only available for tokens types that can be evaluated.
             *
             * @remarks
             * To determine the 'token span' for the evaluation you can can tokens left and right
             * until you reach a token that has a larger evalIndex or there are no more tokens.
             */
            evalIndex?: number;
            /**
             * Indicates that the token is part of a reference.
             *
             * @remarks
             * * Multiple tokens can be part of the same reference.
             * * The refIndex will be the offset of the range in the {@link ICalculation.IFormula.getReferences} array.
             */
            refIndex?: number;
        }
        interface Result {
        }
        interface Events extends IModel.Events {
            /**
             * Called when the calculation has been updated and
             * a calculation has not been started.
             */
            onStale?(source: ICalculation): void;
            /**
             * Called when a calculation is starting.
             */
            onStarting?(source: ICalculation): void;
            /**
             * Called when a calculation is stopping.
             */
            onStopping?(source: ICalculation): void;
            /**
             * Called when the calculation status has changed.
             */
            onStatusChange?(source: ICalculation): void;
            /**
             * Called when a calculation is started.
             */
            onComplete?(source: ICalculation, results: ICalculation.Result): void;
            /**
             * Called when the calculation engine is unable to calc.
             *
             * @param source
             *
             * @remarks
             * This is not when a specific function fails, but when the calculation engine is unable to complete the calculation.
             */
            onError?(source: ICalculation): void;
            /**
             * Called when the ICalculation has been loaded and is ready to calc.
             */
            onReady?(source: ICalculation): void;
            /**
             * Called when the ICalculation has been loaded and is ready to calc.
             */
            onStop?(source: ICalculation): void;
        }
        /**
         * Represents the calculation engine's overall status.
         */
        const Status: {
            /**
             * The calculation engine is in manual mode and will only update cell values when a calculation is explicitly triggered.
             */
            readonly Ready: "ready";
            /**
             * The calculation engine has encountered an error and is unable to perform calculations.
             * This status represents engine-level errors, separate from cell-level errors (which are represented as Scalar.Error values).
             */
            readonly Error: "error";
            /**
             * The calculation engine is starting up and initializing its internal state.
             */
            readonly Starting: "starting";
            /**
             * The calculation engine is stopping and cleaning up its internal state.
             */
            readonly Stopping: "stopping";
            /**
             * The calculation engine is disabled.
             */
            readonly Off: "off";
        };
        type Status = typeof Status[keyof typeof Status];
        interface JSON {
            /**
             * Indicates whether the workbook has completed its last calculation cycle.
             *
             * @remarks
             * If `true`, the workbook is up to date with calculations.
             */
            calcCompleted?: boolean;
            /**
             * Defines the calculation mode for the workbook.
             *
             * @remarks
             * Possible values could include 'auto', 'manual', or 'semi-automatic'.
             */
            calcMode?: string;
            /**
             * Specifies whether calculations should be performed when the workbook is saved.
             *
             * @remarks
             * If `true`, the workbook recalculates all formulas before saving.
             */
            calcOnSave?: boolean;
            /**
             * Specifies whether calculations should be performed concurrently across multiple threads.
             *
             * @remarks
             * If `true`, the workbook uses multi-threading for calculations.
             */
            concurrentCalc?: boolean;
            /**
             * Specifies whether concurrent calculations are allowed in manual calculation mode.
             *
             * @remarks
             * If `true`, manual calculations can utilize multiple threads.
             */
            concurrentManualCount?: boolean;
            /**
             * Specifies whether the workbook forces a full recalculation of all formulas.
             *
             * @remarks
             * If `true`, all formulas will be recalculated from scratch regardless of dependencies.
             */
            forceFullCalc?: boolean;
            /**
             * Specifies whether a full recalculation should be performed when the workbook is loaded.
             *
             * @remarks
             * If `true`, the workbook recalculates all formulas upon loading.
             */
            fullCalcOnLoad?: boolean;
            /**
             * Indicates whether calculations should be performed using full precision.
             *
             * @remarks
             * If `true`, all calculations are performed with the maximum precision available.
             */
            fullPrecision?: boolean;
            /**
             * Specifies whether the workbook should iterate calculations when circular references are present.
             *
             * @remarks
             * If `true`, the workbook allows iterative calculations to resolve circular references.
             */
            iterate?: boolean;
            /**
             * Defines the maximum number of iterations allowed when performing iterative calculations.
             *
             * @defaultValue `100`
             *
             * @remarks
             * This value is only used if `iterate` is set to `true`.
             */
            maxIterations?: number;
            /**
             * Defines the maximum change between iterations that must be reached before the iterative calculation stops.
             *
             * @defaultValue `0.001`
             *
             * @remarks
             * A smaller delta will make the iterative calculation more precise but may take longer to complete.
             *
             */
            maxIterateChange?: number;
            /**
             * Specifies the reference mode for calculations.
             *
             * @remarks
             * Possible values could include 'A1' or 'R1C1', representing different reference styles.
             */
            refMode?: string;
        }
        interface IListeners extends IListener.Callbacks<ICalculation, ICalculation.Events> {
        }
        /**
         * Options available when creating a Calculation Service.
         */
        interface ConstructorOptions {
            /**
             * Hook to provide custom functions.
             *
             * @param name name of the function
             * @returns IFunction
             *
             * @remarks
             * Names will always be passed as the user input them but are generally treated as case insensitive
             */
            getFunction?: (name: string) => IFunction | null;
            /**
             * Hook to provide custom names.
             *
             * @param name The name to resolve
             * @param scope The current scope
             *
             * @remarks
             * Names will always be passed as the user input them but are generally treated as case insensitive
             */
            getNamed?: (name: string, scope?: string) => IRange.FixableCoords[] | null;
            getSheetIndex?: (sheetName?: string) => number;
            getSheetCount?: () => number;
            /**
             * Callback that determines if dates are 1904.
             */
            isDate1904?: () => boolean;
            strings?: IStringCollection;
            errors?: IStringCollection;
            /**
             * The maximum number of iterations to perform when calculating.
             */
            maxIterations?: number;
            maxIterateChange?: number;
        }
    }
}
declare module "collections/IList" {
    /**
     * IListLike objects are orders collections of values.
     *
     * While similar to an {@link Array} they have different implementations
     * to allow for more efficient of large sets of data.
     */
    export interface IListLike<T = any> {
        /**
         * Return the max element index within the list.
         */
        readonly length: number;
        /**
         * Optimization.
         *
         * If this is implemented then Lists will attempt to 'compact' when the List is
         * below a certain size.
         *
         * Return unable to generate fromArray with the values.
         */
        fromArray?(arr: T[]): IListLike<T>;
        /**
         * Returns the value at a given index.
         *
         * @param index The index to retrieve.
         * @returns The value
         */
        at(index: number): T | undefined;
    }
    export interface IList<T = any> extends IListLike<T> {
        /**
         * Returns `true` if the object implements IList.
         *
         * @remarks
         * Required to differentiate from Arrays and strings.
         */
        readonly isIList: true;
    }
    /**
     * {@inheritDoc IList}
     * @see
     * ### **Interface**
     *
     * {@link IList}
     */
    export namespace IList {
        /**
         * Returns true if the object is {@link IList}.
         * @param arg Object to check.
         */
        const isList: (arg: any) => boolean;
        /**
         * Returns true if the object is {@link IListLike}.
         *
         * @param arg Object to check.
         *
         * @remarks
         * Similar to {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray | Array.isArray}.
         * Returns `true` for `string` and `Array`
         */
        const isListLike: (arg: any) => boolean;
        /**
         * Helper method that wraps a native Array into a IListLike.
         *
         * @param arr The array to wrap.
         * @param getAt Optional function to allow for altering the value before returning.
         *
         * @remarks
         * Useful for callbacks
         */
        const fromArray: <T, R = any>(arr: any[], getAt?: (value: R | undefined, index: number) => T | undefined, setAt?: (value: T | undefined, index: number) => R | undefined, internal?: any[]) => IList<T>;
        /**
         * Wraps a native Array into a IList.
         */
        class ArrayList<T = any> implements IList<T> {
            private a;
            private g;
            private s;
            constructor(a: any[], getAt?: (value: any | undefined, index: number) => T | undefined, setAt?: (value: T | undefined, index: number) => any | undefined, internal?: any[]);
            /** {@inheritDoc IListLike.at} */
            at(index: number): T | undefined;
            /** {@inheritDoc IListLike.fromArray} */
            fromArray?(arr: T[]): IListLike<T>;
            /** {@inheritDoc IListLike.length} */
            get length(): number;
            /** {@inheritDoc IList.isIList} */
            get isIList(): true;
        }
    }
}
declare module "collections/IReadableList" {
    import { RunCoords } from '@sheetxl/utils';
    import { IList, IListLike } from "collections/IList";
    /**
     * Add iteration and additional read operations to {@link IList} collections.
     *
     * Iterations have {@link IReadableList.IteratorOptions} for entries.
     */
    export interface IReadableList<T = any> extends IList<T> {
        /**
         * Creates an entries iterator that respects the provided {@link IReadableList.IteratorOptions}
         * and allows for optional random access through the `next` method.
         *
         * The `next` method can be used in two ways:
         *
         * **Sequential Iteration:**
         * ```typescript
         * const iterator = list.entries(options);
         * let result = iterator.next(); // Get the first entry
         * while (!result.done) {
         *   // Process result.value (the current entry)
         *   result = iterator.next();
         * }
         * ```
         *
         * **Random Access:**
         * ```typescript
         * const iterator = list.entries(options);
         * const entryAtIndex3 = iterator.next(3).value; // Get entry at index 3
         * // Note: The iterator is now positioned at index 4 for subsequent calls
         * ```
         *
         * @param options Configuration options for the iterator.
         * @returns An iterator yielding entries in the form of `[key, value]` pairs.
         */
        entries(options?: IReadableList.IteratorOptions): IReadableList.EntryIterator<T>;
        /**
         * Returns an iterable of value for the list.
         */
        [Symbol.iterator](): IterableIterator<T>;
        /**
         * Behaves like Array slice but doesn't perform a shallow copy.
         * @see
         * * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice}
         */
        slice(start: number, end?: number): IReadableList<T>;
        /**
         * Behaves like Array concat but doesn't perform a shallow copy.
         * @param list The IReadableList to concat.
         * @see
         * * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat}
         */
        concat(list: IListLike<T>): IReadableList<T>;
        /**
         * Return the List as an Array. This does a deep copy.
         * @param maxLength Maximum number of elements.
         */
        toArray(maxLength?: number): T[];
        /**
         * For runtime type checking.
         */
        readonly isIReadableList: true;
    }
    /**
     * {@inheritDoc IReadableList}
     * @see
     * ### **Interface**
     *
     * {@link IReadableList}
     */
    export namespace IReadableList {
        /**
         * Allow for iterating over a subset of values in a given direction.
         */
        interface IteratorOptions<T = any> {
            /**
             * If not specified or null then all values will be iterated.
             * @defaultValue null
             * @remarks
             * The min and max are always small to largest regardless of reverse flag.
             */
            bounds?: Partial<RunCoords>;
            /**
             * Iterate in reverse order.
             *
             * @defaultValue false
             */
            reverse?: boolean;
            /**
             * A callback function that allows customization of the iteration process by skipping specific indices.
             * @param index The next index that would normally be processed in the iteration.
             * @param reverse Indicates if the iteration is reversed. This defaults to the reverse option.
             * @returns A new index 'next index' to process, or the original `index` if no skipping is desired.
             *
             * @remarks
             * This callback is invoked before the iterator yields the value at the given `index`. By returning a different index, you can control the flow of the iteration and skip over certain elements.
             */
            processSkip?: (index: number, reverse: boolean) => number;
            /**
             * Provide an IteratorResult object to reuse.
             *
             * This is a performance optimization that will return the same iterator result and with with the values updated.
             * This reduces the temporary objects being created but care must be take to not the iterator result instance.
             * @defaultValue false
             */
            reuseResult?: IReadableList.EntryIteratorResult<T>;
        }
        /**
         * Entries iterators are arrays of fixed length 2.
         */
        type Entry<T = any> = [number, T];
        /**
         * Shorthand type.
         */
        type EntryIteratorResult<T = any> = IteratorResult<IReadableList.Entry<T>>;
        /**
         * Shorthand type.
         */
        type EntryIterator<T = any> = Iterator<IReadableList.Entry<T>, IReadableList.Entry<T>, number>;
    }
}
declare module "collections/IWritableList" {
    /**
     * Provides write operations to an ordered collection of items, similar to an {@link Array}
     * but with the option to set an array values and to clone.
     */
    export interface IWritableList<T = any> {
        /**
         * Sets a value at the given index.
         *
         * @param index The offset location for the values to be placed.
         * @param value The value.
         */
        setAt(index: number, value: T): boolean;
        /**
         * This acts similar to Array.splice but without the option to insert.
         *
         * To add items use {@link IReadableList.concat}.
         *
         * @param start The index to start.
         * @param amount If omitted then all items to the end of the list will be removed.
         * @see
         * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice}
         */
        delete(start: number, amount?: number): boolean;
        /**
         * Shift values in a given direction.
         *
         * @param index The start of the shift.
         * @param amount The amount to shift. A positive number is an insert and a negative number is a delete.
         * @returns true is data was shifted.
         */
        shift(index: number, amount: number): boolean;
        /**
         * Creates a logical copy of the current values.
         *
         * Undo and branching works by creating 'copies' and then rolling back or commit these later.
         * @remarks
         * If this is not available then undo does not work for values.
         */
        clone?(): this;
    }
}
declare module "collections/ISparseList" {
    import { RunCoords } from '@sheetxl/utils';
    import { IReadableList } from "collections/IReadableList";
    import { IWritableList } from "collections/IWritableList";
    /**
     * Extends {@link IReadableList} with specialized functionality for sparse lists.
     *
     * A sparse list is a list where many elements are undefined or null. This interface provides methods to efficiently
     * work with such lists, including:
     *
     * - Retrieving the minimum and maximum indices of populated elements.
     *
     * - Counting the total number of non-empty elements.
     *
     * - Getting the number of contiguous runs of non-empty elements.
     */
    export interface ISparseList<T = any> extends IReadableList<T>, IWritableList<T> {
        /**
         * Returns the max and min for the list or null if empty.
         */
        getCoords(): RunCoords | null;
        /**
         * Represents The maximum bounds.
         *
         * If this is null or undefined then it is assume to be unlimited in size.
         */
        getMaxCoords?(): RunCoords | null;
        /**
         * Returns the count of elements in the list that contain values (non-empty).
         *
         * @remarks
         * In a dense list, this count would be equal to the `length` property. However, since sparse lists can have gaps
         * where elements are undefined or null, `getCount` specifically counts the elements that hold actual values.
         */
        getCount(): number;
        /**
         * Sets a list of values at the given index.
         *
         * @param index The offset location for the values to be placed.
         * @param run An IReadableList containing values.
         * @remarks
         * For performance reasons the arrays and the values passed in are
         * accessed directly so these should be treated as immutable.
         */
        setRunAt(index: number, run: IReadableList<T>): boolean;
        /**
         * Return an iterator for iterating the runs.
         * @param options IteratorOptions
         * @remarks
         * When iterating runs with bounds any runs that intersect the bounds will be returned.
         */
        runs(options?: ISparseList.RunIteratorOptions): ISparseList.RunIterator<T>;
        /**
         * Returns the number of contiguous runs within the sparse list.
         *
         * A run is defined as a sequence of consecutive elements that are not undefined or null.
         *
         * @returns The total number of runs in the list.
         */
        getRunsCount(): number;
        /**
         * Clears all values.
         */
        clear(): void;
        /**
         * For runtime type checking.
         */
        readonly isISparseList: true;
    }
    /**
     * {@inheritDoc ISparseList}
     * @see
     * ### **Interface**
     *
     * {@link ISparseList}
     */
    export namespace ISparseList {
        type RunEntry<T = any> = [RunCoords, IReadableList<T>];
        /**
         * Shorthand type.
         */
        type RunIterator<T = any> = Iterator<ISparseList.RunEntry<T>, ISparseList.RunEntry<T>, number>;
        /**
         * Shorthand type.
         */
        type RunIteratorResult<T = any> = IteratorResult<ISparseList.RunEntry<T>>;
        /**
         * Run Iterator extends {@link IReadableList.IteratorOptions} but removes support for
         * processSkip and downcasts reuseResult.
         */
        interface RunIteratorOptions<T = any> extends Omit<IReadableList.IteratorOptions, 'reuseResult' | 'processSkip'> {
            reuseResult?: ISparseList.RunIteratorResult<T>;
            /**
             * If `true` will return the full range even if it is outside of the iteration bounds.
             *
             * @defaultValue `false`
             *
             * @remarks
             * This is used as a performance optimization for iterators that are reading gaps. (fillEmpty)
             */
            overflowRun?: boolean;
        }
    }
}
declare module "collections/ISortedMap" {
    /**
     * An interface for a sorted map (dictionary), not including functional/persistent methods.
     */
    export interface ISortedMap<K = any, V = any> extends IMap<K, V>, ISortedMapSource<K, V> {
        /**
        * Adds or overwrites a key-value pair in the collection.
        * @param key the key is used to determine the sort order of data in the tree.
        * @param value data to associate with the key
        * @param overwrite Whether to overwrite an existing key-value pair
        *        (default: true). If this is false and there is an existing
        *        key-value pair then the call to this method has no effect.
        * @returns `true` if a new key-value pair was added, false if the key
        *        already existed.
        */
        set(key: K, value: V, overwrite?: boolean | ISortedMap.SetPairCallback<K, V>): boolean;
        /**
        * Adds all pairs from a list of key-value pairs.
        * @param pairs Pairs to add to this tree. If there are duplicate keys,
        *        later pairs currently overwrite earlier ones (e.g. [[0,1],[0,7]]
        *        associates 0 with 7.)
        * @param overwrite Whether to overwrite pairs that already exist (if false,
        *        pairs[i] is ignored when the key pairs[i][0] already exists.)
        * @returns The number of pairs added to the collection.
        */
        setPairs(pairs: [K, V][], overwrite?: boolean | ISortedMap.SetPairCallback<K, V>): number;
        /**
        * Deletes a series of keys from the collection.
        */
        deleteKeys(keys: K[]): number;
        /**
        * Removes a range of key-value pairs from the collection.
        * @param low The first key deleted will be greater than or equal to `low`.
        * @param high Deleting stops when a key larger than this is reached.
        * @param includeHigh Specifies whether the `high` key, if present, is deleted.
        * @returns The number of key-value pairs that were deleted.
        */
        deleteRange(low: K, high: K, includeHigh: boolean): number;
        entries(firstKey?: K): IterableIterator<[K, V]>;
        keys(firstKey?: K): IterableIterator<K>;
        values(firstKey?: K): IterableIterator<V>;
    }
    /**
     * Read-only set interface (subinterface of IMapSource<K,any>).
     * The word "set" usually means that each item in the collection is unique
     * (appears only once, based on a definition of equality used by the
     * collection.) Objects conforming to this interface aren't guaranteed not
     * to contain duplicates, but as an example, SortedMap<K, V> implements this
     * interface and does not allow duplicates.
     */
    export interface ISetSource<K = any> {
        /** Returns the number of key/value pairs in the map object. */
        size: number;
        /** Returns a flag asserting whether the key exists in the map object or not. */
        has(key: K): boolean;
        /** Returns a new iterator for iterating the items in the set (the order is implementation-dependent). */
        keys(): IterableIterator<K>;
    }
    /**
     * Read-only map interface (i.e. a source of key-value pairs).
     */
    export interface IMapSource<K = any, V = any> extends ISetSource<K> {
        /** Returns the number of key/value pairs in the map object. */
        size: number;
        /** Returns the value associated to the key, or undefined if there is none. */
        get(key: K): V | undefined;
        /** Returns a flag asserting whether the key exists in the map object or not. */
        has(key: K): boolean;
        /**
         * Calls callbackFn once for each key-value pair present in the map object.
         * The ES6 Map class sends the value to the callback before the key, so
         * this interface must do likewise.
         */
        forEach(callbackFn: (v: V, k: K, map: IMapSource<K, V>) => void, thisArg: any): void;
        /** Returns an iterator that provides all key-value pairs from the collection (as arrays of length 2). */
        entries(): IterableIterator<[K, V]>;
        /** Returns a new iterator for iterating the keys of each pair. */
        keys(): IterableIterator<K>;
        /** Returns a new iterator for iterating the values of each pair. */
        values(): IterableIterator<V>;
    }
    /**
     * Write-only set interface (the set cannot be queried, but items can be added to it).
     * @remarks
     * SortedMap<K, V> does not officially implement this interface,
     * but SortedMap<K> can be used as an instance of ISetSink<K>.
     */
    export interface ISetSink<K = any> {
        /** Adds the specified item to the set, if it was not in the set already. */
        add(key: K): any;
        /** Returns true if an element in the map object existed and has been
         *  removed, or false if the element did not exist. */
        delete(key: K): boolean;
        /** Removes everything so that the set is empty. */
        clear(): void;
    }
    /**
     * Write-only map interface (i.e. a drain into which key-value pairs can be "sunk")
     */
    export interface IMapSink<K = any, V = any> {
        /** Returns true if an element in the map object existed and has been
         *  removed, or false if the element did not exist. */
        delete(key: K): boolean;
        /** Sets the value for the key in the map object (the return value is
         *  boolean in SortedMap but Map returns the Map itself.) */
        set(key: K, value: V): any;
        /** Removes all key/value pairs from the IMap object. */
        clear(): void;
    }
    /**
     * Set interface.
     * @remarks
     * SortedMap<K, V> does not officially implement this interface,
     * but SortedMap<K> can be used as an instance of ISet<K>.
     */
    export interface ISet<K = any> extends ISetSource<K>, ISetSink<K> {
    }
    /**
     * An interface compatible with ES6 Map and SortedMap. This interface does not
     * describe the complete interface of either class, but merely the common
     * interface shared by both.
     */
    export interface IMap<K = any, V = any> extends IMapSource<K, V>, IMapSink<K, V> {
    }
    /**
     * An data source that provides read-only access to a set of items called
     * "keys" in sorted order. This is a subinterface of ISortedMapSource.
     */
    export interface ISortedSetSource<K = any> extends ISetSource<K> {
        /** Gets the lowest key in the collection. */
        minKey(): K | undefined;
        /** Gets the highest key in the collection. */
        maxKey(): K | undefined;
        /**
         * Returns the next key larger than the specified key (or undefined if there is none).
         * Also, nextHigherKey(undefined) returns the lowest key.
         */
        nextHigherKey(key?: K): K | undefined;
        /**
         * Returns the next key smaller than the specified key (or undefined if there is none).
         * Also, nextLowerKey(undefined) returns the highest key.
         */
        nextLowerKey(key?: K): K | undefined;
        /**
         * Calls `callback` on the specified range of keys, in ascending order by key.
         * @param low The first key scanned will be greater than or equal to `low`.
         * @param high Scanning stops when a key larger than this is reached.
         * @param includeHigh If the `high` key is present in the map, `onFound` is called
         * for that final pair if and only if this parameter is true.
         * @param onFound A function that is called for each key pair. Because this
         * is a subinterface of ISortedMapSource, if there is a value
         * associated with the key, it is passed as the second parameter.
         * @param initialCounter Initial third argument of `onFound`. This value
         * increases by one each time `onFound` is called. Default: 0
         * @returns Number of pairs found and the number of times `onFound` was called.
         */
        forRange(low: K, high: K, includeHigh: boolean, onFound?: (k: K, v: any, counter: number) => void, initialCounter?: number): number;
        /**
         * Returns a new iterator for iterating the keys of each pair in ascending order.
         * @param firstKey -Minimum key to include in the output.
         */
        keys(firstKey?: K): IterableIterator<K>;
    }
    /**
     * An data source that provides read-only access to items in sorted order.
     */
    export interface ISortedMapSource<K = any, V = any> extends IMapSource<K, V>, ISortedSetSource<K> {
        /**
         * Returns the next pair whose key is larger than the specified key (or undefined
         * if there is none). If key === undefined, this function returns the lowest pair.
         */
        nextHigherPair(key?: K, reusedPair?: [K, V]): [K, V] | undefined;
        /**
         * Returns the next pair whose key is smaller than the specified key (or undefined
         * if there is none). If key === undefined, this function returns the highest pair.
         */
        nextLowerPair(key?: K, reusedPair?: [K, V]): [K, V] | undefined;
        /**
         * Builds an array of pairs from the specified range of keys, sorted by key.
         * Each returned pair is also an array: pair[0] is the key, pair[1] is the value.
         * @param low The first key in the array will be greater than or equal to `low`.
         * @param high This method returns when a key larger than this is reached.
         * @param includeHigh If the `high` key is present in the map, its pair will be
         *        included in the output if and only if this parameter is true. Note:
         *        if the `low` key is present, it is always included in the output.
         * @param maxLength Maximum length of the returned array (default: unlimited)
         * @description Computational complexity: O(result.length + log size)
         */
        getRange(low: K, high: K, includeHigh?: boolean, maxLength?: number): [K, V][];
        /** Calls `callback` on the specified range of keys, in ascending order by key.
         * @param low The first key scanned will be greater than or equal to `low`.
         * @param high Scanning stops when a key larger than this is reached.
         * @param includeHigh If the `high` key is present in the map, `onFound` is called
         *        for that final pair if and only if this parameter is true.
         * @param onFound A function that is called for each key-value pair.
         * @param initialCounter Initial third argument of onFound. This value
         *        increases by one each time `onFound` is called. Default: 0
         * @returns Number of pairs found and the number of times `callback` was called.
         */
        forRange(low: K, high: K, includeHigh: boolean, onFound?: (k: K, v: V, counter: number) => void, initialCounter?: number): number;
        /**
         * Returns an iterator that provides items in order by key.
         * @param firstKey Minimum key to include in the output.
         */
        entries(firstKey?: K, reusedPair?: [K, V]): IterableIterator<[K, V]>;
        /**
         * Returns a new iterator for iterating the keys of each pair in ascending order.
         * @param firstKey Minimum key to include in the output.
         */
        keys(firstKey?: K, reusedPair?: [K, V]): IterableIterator<K>;
        /**
         * Returns a new iterator for iterating the values of each pair in order by key.
         * @param firstKey Minimum key whose associated value is included in the output.
         */
        values(firstKey?: K, reusedPair?: [K, V]): IterableIterator<V>;
        /** Performs a reduce operation like the `reduce` method of `Array`.
         *  It is used to combine all pairs into a single value, or perform conversions. */
        reduce<R>(callback: (previous: R, currentPair: [K, V], counter: number, tree: IMapF<K, V>) => R, initialValue: R): R;
        /** Performs a reduce operation like the `reduce` method of `Array`.
         *  It is used to combine all pairs into a single value, or perform conversions. */
        reduce<R>(callback: (previous: R | undefined, currentPair: [K, V], counter: number, tree: IMapF<K, V>) => R): R | undefined;
    }
    /**
     * An interface for a set of keys (the combination of ISortedSetSource<K> and ISetSink<K>)
     */
    export interface ISortedSet<K = any> extends ISortedSetSource<K>, ISetSink<K> {
    }
    /**
     * An interface for a functional set, in which the set object could be read-only
     * but new versions of the set can be created by calling "with" or "without"
     * methods to add or remove keys. This is a subinterface of IMapF<K, V>,
     * so the items in the set may be referred to as "keys".
     */
    export interface ISetF<K = any> extends ISetSource<K> {
        /**
         * Returns a copy of the set with the specified key included.
         * @description You might wonder why this method accepts only one key
         * instead of `...keys: K[]`. The reason is that the derived interface
         * IMapF expects the second parameter to be a value. Therefore
         * withKeys() is provided to set multiple keys at once.
         */
        with(key: K): ISetF<K>;
        /**
         * Returns a copy of the set with the specified key removed.
         */
        without(key: K): ISetF<K>;
        /** Returns a copy of the tree with all the keys in the specified array present.
         *  @param keys The keys to add.
         *  @param returnThisIfUnchanged If true, the method returns `this` when
         *         all of the keys are already present in the collection. The
         *         default value may be true or false depending on the concrete
         *         implementation of the interface (in SortedMap, the default is false.) */
        withKeys(keys: K[], returnThisIfUnchanged?: boolean): ISetF<K>;
        /** Returns a copy of the tree with all the keys in the specified array removed. */
        withoutKeys(keys: K[], returnThisIfUnchanged?: boolean): ISetF<K>;
        /** Returns a copy of the tree with items removed whenever the callback
         *  function returns false.
         *  @param callback A function to call for each item in the set.
         *         The second parameter to `callback` exists because ISetF
         *         is a subinterface of IMapF. If the object is a map, v
         *         is the value associated with the key, otherwise v could be
         *         undefined or another copy of the third parameter (counter). */
        filter(callback: (k: K, v: any, counter: number) => boolean, returnThisIfUnchanged?: boolean): ISetF<K>;
    }
    /**
     * An interface for a functional map, in which the map object could be read-only
     * but new versions of the map can be created by calling "with" or "without"
     * methods to add or remove keys or key-value pairs.
     */
    export interface IMapF<K = any, V = any> extends IMapSource<K, V>, ISetF<K> {
        /** Returns a copy of the tree with the specified key set (the value is undefined). */
        with(key: K): IMapF<K, V | undefined>;
        /** Returns a copy of the tree with the specified key-value pair set. */
        with<V2>(key: K, value: V2, overwrite?: boolean): IMapF<K, V | V2>;
        /** Returns a copy of the tree with the specified key-value pairs set. */
        withPairs<V2>(pairs: [K, V | V2][], overwrite: boolean): IMapF<K, V | V2>;
        /** Returns a copy of the tree with all the keys in the specified array present.
         *  @param keys The keys to add. If a key is already present in the tree,
         *         neither the existing key nor the existing value is modified.
         *  @param returnThisIfUnchanged If true, the method returns `this` when
         *         all of the keys are already present in the collection. The
         *         default value may be true or false depending on the concrete
         *         implementation of the interface (in SortedMap, the default is false.) */
        withKeys(keys: K[], returnThisIfUnchanged?: boolean): IMapF<K, V | undefined>;
        /** Returns a copy of the tree with all values altered by a callback function. */
        mapValues<R>(callback: (v: V, k: K, counter: number) => R): IMapF<K, R>;
        /** Performs a reduce operation like the `reduce` method of `Array`.
         *  It is used to combine all pairs into a single value, or perform conversions. */
        reduce<R>(callback: (previous: R, currentPair: [K, V], counter: number, amp: IMapF<K, V>) => R, initialValue: R): R;
        /** Performs a reduce operation like the `reduce` method of `Array`.
         *  It is used to combine all pairs into a single value, or perform conversions. */
        reduce<R>(callback: (previous: R | undefined, currentPair: [K, V], counter: number, map: IMapF<K, V>) => R): R | undefined;
        without(key: K): IMapF<K, V>;
        withoutKeys(keys: K[], returnThisIfUnchanged?: boolean): IMapF<K, V>;
        /** Returns a copy of the tree with pairs removed whenever the callback
         *  function returns false. */
        filter(callback: (k: K, v: V, counter: number) => boolean, returnThisIfUnchanged?: boolean): IMapF<K, V>;
    }
    /**
     * An interface for a functional sorted set: a functional set in which the
     * keys (items) are sorted. This is a subinterface of ISortedMapF.
     */
    export interface ISortedSetF<K = any> extends ISetF<K>, ISortedSetSource<K> {
        keys(firstKey?: K): IterableIterator<K>;
    }
    export interface ISortedMapF<K = any, V = any> extends ISortedSetF<K>, IMapF<K, V>, ISortedMapSource<K, V> {
        /** Returns a copy of the tree with the specified range of keys removed. */
        withoutRange(low: K, high: K, includeHigh: boolean, returnThisIfUnchanged?: boolean): ISortedMapF<K, V>;
        entries(firstKey?: K): IterableIterator<[K, V]>;
        keys(firstKey?: K): IterableIterator<K>;
        values(firstKey?: K): IterableIterator<V>;
        forRange(low: K, high: K, includeHigh: boolean, onFound?: (k: K, v: V, counter: number) => void, initialCounter?: number): number;
        with(key: K): ISortedMapF<K, V | undefined>;
        with<V2>(key: K, value: V2, overwrite?: boolean): ISortedMapF<K, V | V2>;
        withKeys(keys: K[], returnThisIfUnchanged?: boolean): ISortedMapF<K, V | undefined>;
        withPairs<V2>(pairs: [K, V | V2][], overwrite: boolean): ISortedMapF<K, V | V2>;
        mapValues<R>(callback: (v: V, k: K, counter: number) => R): ISortedMapF<K, R>;
        without(key: K): ISortedMapF<K, V>;
        withoutKeys(keys: K[], returnThisIfUnchanged?: boolean): ISortedMapF<K, V>;
        filter(callback: (k: K, v: V, counter: number) => boolean, returnThisIfUnchanged?: boolean): ISortedMapF<K, V>;
    }
    /**
     * {@inheritDoc ISortedMap}
     * @see
     * ### **Interface**
     *
     * {@link ISortedMap}
     */
    export namespace ISortedMap {
        /**
         * A return type that allows for either a value or a break or a delete flag.
         */
        type EditRangeResult<V, B = number> = {
            value?: V;
            break?: B;
            delete?: boolean;
        };
        /**
         * Called when a tree node is SetPairCallback.
         *
         * * If the prev value is undefined then this is a new
         * * If the function returns a void this the value is unchanged.
         */
        type EditRangeCallback<K, V, R = number> = (k: K, v: V, counter: number) => EditRangeResult<V, R> | void;
        /**
         * Called when a tree node is SetPairCallback.
         * @remarks
         * SetPairs is different that EditRange in that it is an insert only operation.
         * * If the prev value is undefined then this is a new
         * * If the function returns a void then the value is unchanged.
         */
        type SetPairCallback<K, V> = (prev: V | undefined, key: K, value: V) => V | void;
    }
}
declare module "collections/SortedMap" {
    import { ISortedMap, ISortedMapF } from "collections/ISortedMap";
    /**
     * A reasonably fast collection of key-value pairs with a powerful API.
     * Largely compatible with the standard Map. SortedMap is a B+ tree data structure,
     * so the collection is sorted by key.
     *
     * B+ trees tend to use memory more efficiently than hashTables such as the
     * standard Map, especially when the collection contains a large number of
     * items. However, maintaining the sort order makes them modestly slower:
     * O(log size) rather than O(1). This B+ tree implementation supports O(1)
     * fast cloning. It also supports freeze(), which can be used to ensure that
     * a SortedMap is not changed accidentally.
     *
     * Confusingly, the ES6 Map.forEach(c) method calls c(value,key) instead of
     * c(key,value), in contrast to other methods such as set() and entries()
     * which put the key first. I can only assume that the order was reversed on
     * the theory that users would usually want to examine values and ignore keys.
     * SortedMap's forEach() therefore works the same way, but a second method
     * `.forEachPair((key,value)=>{...})` is provided which sends you the key
     * first and the value second; this method is slightly faster because it is
     * the "native" for-each method for this class.
     *
     * Out of the box, SortedMap supports keys that are numbers, strings, arrays of
     * numbers/strings, Date, and objects that have a valueOf() method returning a
     * number or string. Other data types, such as arrays of Date or custom
     * objects, require a custom comparator, which you must pass as the second
     * argument to the constructor (the first argument is an optional list of
     * initial items). Symbols cannot be used as keys because they are unordered
     * (one Symbol is never "greater" or "less" than another).
     *
     * @example
     * Given a {name: string, age: number} object, you can create a sorted map by
     * name and then by age like this:
     *
     *     let map = new SortedMap(undefined, (a, b) => {
     *       if (a.name > b.name)
     *         return 1; // Returns a number >0 when a > b
     *       else if (a.name < b.name)
     *         return -1; // Returns a number <0 when a < b
     *       else // names are equal (or incomparable)
     *         return a.age - b.age; // Returns >0 when a.age > b.age
     *     });
     *
     *     map.set({name:"Bill", age:17}, "happy");
     *     map.set({name:"Fran", age:40}, "busy & stressed");
     *     map.set({name:"Bill", age:55}, "recently laid off");
     *     map.forEachPair((k, v) => {
     *       console.log(`Name: ${k.name} Age: ${k.age} Status: ${v}`);
     *     });
     *
     * @remarks
     * The "range" methods (`forEach, forRange, editRange`) will return the number
     * of elements that were scanned. In addition, the callback can return {break: R}
     * to stop early and return R from the outer function.
     *
     * - TODO: Test performance of preallocating values array at max size
     * - TODO: Add fast initialization when a sorted array is provided to constructor
     *
     * For more documentation see https://github.com/qwertie/btree-typescript
     *
     * Are you a C# developer? You might like the similar data structures I made for C#:
     * BDictionary, BList, etc. See http://core.loyc.net/collections/
     *
     * @author David Piepgrass
     */
    export class SortedMap<K = any, V = any> implements ISortedMapF<K, V>, ISortedMap<K, V> {
        private _root;
        _size: number;
        _maxNodeSize: number;
        /**
         * Provides a total order over keys (and a strict partial order over the type K)
         * @returns A negative value if a < b, 0 if a === b and a positive value if a > b
         */
        _compare: (a: K, b: K) => number;
        /**
         * Initializes an SortedMap.
         * @param compare Custom function to compare pairs of elements in the map.
         * If not specified, defaultComparator will be used which is valid as long as K extends DefaultComparable.
         * @param entries A set of key-value pairs to initialize the map
         * @param maxNodeSize Branching factor (maximum items or children per node)
         * Must be in range 4..256. If undefined or <4 then 32 is used; if >256 then 256.
         */
        constructor(entries?: [K, V][], compare?: (a: K, b: K) => number, maxNodeSize?: number);
        /**
         * returns the number of key-value pairs in the map.
         */
        get size(): number;
        /**
         * Returns the number of key-value pairs in the map.
         * @remarks
         * This is the same as size.
         */
        get length(): number;
        /** Returns true iff the map contains no key-value pairs. */
        get isEmpty(): boolean;
        /** Releases the map so that its size is 0. */
        clear(): void;
        /**
         * Runs a function for each key-value pair, in order from smallest to largest key.
         * For compatibility with ES6 Map, the argument order to the callback is
         * backwards: value first, then key. Call forEachPair instead to receive the key
         * as the first argument.
         * @param thisArg If provided, this parameter is assigned as the `this`
         * value for each callback.
         * @returns The number of values that were sent to the callback,
         * or the R value if the callback returned {break: R}.
         */
        forEach<R = number>(callback: (v: V, k: K, map: SortedMap<K, V>) => {
            break?: R;
        } | void, thisArg?: any): R | number;
        /**
         * Runs a function for each key-value pair, in order from smallest to
         * largest key. The callback can return {break: R} (where R is any value
         * except undefined) to stop immediately and return R from forEachPair.
         * @param onFound A function that is called for each key-value pair. This
         * function can return {break: R} to stop early with result R.
         * The reason that you must return {break: R} instead of simply R
         * itself is for consistency with editRange(), which allows
         * multiple actions, not just breaking.
         * @param initialCounter This is the value of the third argument of
         * `onFound` the first time it is called. The counter increases
         * by one each time `onFound` is called. Default value: 0
         * @returns The number of pairs sent to the callback (plus initialCounter,
         * if you provided one). If the callback returned {break: R} then
         * the R value is returned instead.
         */
        forEachPair<R = number>(callback: (k: K, v: V, counter: number) => {
            break?: R;
        } | void, initialCounter?: number): R | number;
        /**
         * Finds a pair in the map and returns the associated value.
         * @param defaultValue a value to return if the key was not found.
         * @returns The value, or defaultValue if the key was not found.
         * @remarks
         * Computational complexity: O(log size)
         */
        get(key: K, defaultValue?: V): V | undefined;
        /**
         * Adds or overwrites a key-value pair in the collection.
         * @param key Key used to determine the sort order of data in the map.
         * @param value Value to associate with the key.
         * @param overwrite Whether to overwrite an existing key-value pair
         * (default: true). If this is false and there is an existing
         * key-value pair then this method has no effect.
         * @returns `true` if a new key-value pair was added.
         * @remarks
         * Computational complexity: O(log size)
         * Note: when overwriting a previous entry, the key is updated
         * as well as the value. This has no effect unless the new key
         * has data that does not affect its sort order.
         */
        set(key: K, value: V, overwrite?: boolean | ISortedMap.SetPairCallback<K, V>): boolean;
        /**
         * Returns true if the key exists in the collection, false if not.
         * Use get() for best performance; use has() if you need to
         * distinguish between "undefined value" and "key not present".
         * @param key Key to detect
         * @remarks
         * Computational complexity: O(log size)
         */
        has(key: K): boolean;
        /**
         * Removes a single key-value pair from the SortedMap.
         * @param key Key to find
         * @returns `true` if a pair was found and removed, false otherwise.
         * @remarks
         * Computational complexity: O(log size)
         */
        delete(key: K): boolean;
        /**
         * Returns a copy of the map with the specified key set (the value is undefined).
         */
        with(key: K): SortedMap<K, V | undefined>;
        /**
         * Returns a copy of the map with the specified key-value pair set.
         */
        with<V2>(key: K, value: V2, overwrite?: boolean): SortedMap<K, V | V2>;
        /**
         * Returns a copy of the map with the specified key-value pairs set.
         */
        withPairs<V2>(pairs: [K, V | V2][], overwrite: boolean): SortedMap<K, V | V2>;
        /**
         * Returns a copy of the map with the specified keys present.
         *  @param keys The keys to add. If a key is already present in the map,
         *  neither the existing key nor the existing value is modified.
         *  @param returnThisIfUnchanged if true, returns this if all keys already
         *  existed. Performance note: due to the architecture of this class, all
         *  node(s) leading to existing keys are cloned even if the collection is
         *  ultimately unchanged.
         */
        withKeys(keys: K[], returnThisIfUnchanged?: boolean): SortedMap<K, V | undefined>;
        /**
         * Returns a copy of the map with the specified key removed.
         * @param returnThisIfUnchanged if true, returns this if the key didn't exist.
         * Performance note: due to the architecture of this class, node(s) leading
         * to where the key would have been stored are cloned even when the key
         * turns out not to exist and the collection is unchanged.
         */
        without(key: K, returnThisIfUnchanged?: boolean): SortedMap<K, V>;
        /**
         * Returns a copy of the map with the specified keys removed.
         * @param returnThisIfUnchanged if true, returns this if none of the keys
         * existed. Performance note: due to the architecture of this class,
         * node(s) leading to where the key would have been stored are cloned
         * even when the key turns out not to exist.
         */
        withoutKeys(keys: K[], returnThisIfUnchanged?: boolean): SortedMap<K, V>;
        /**
         * Returns a copy of the map with the specified range of keys removed.
         */
        withoutRange(low: K, high: K, includeHigh: boolean, returnThisIfUnchanged?: boolean): SortedMap<K, V>;
        /**
         * Returns a copy of the map with pairs removed whenever the callback
         * function returns false. `where()` is a synonym for this method.
        */
        filter(callback: (k: K, v: V, counter: number) => boolean, returnThisIfUnchanged?: boolean): SortedMap<K, V>;
        /** Returns a copy of the map with all values altered by a callback function. */
        mapValues<R>(callback: (v: V, k: K, counter: number) => R): SortedMap<K, R>;
        /**
         *  Performs a reduce operation like the `reduce` method of `Array`.
         *  It is used to combine all pairs into a single value, or perform
         *  conversions. `reduce` is best understood by example. For example,
         *  `map.reduce((P, pair) => P * pair[0], 1)` multiplies all keys
         *  together. It means "start with P=1, and for each pair multiply
         *  it by the key in pair[0]". Another example would be converting
         *  the map to a Map (in this example, note that M.set returns M):
         *
         *  let M = map.reduce((M, pair) => M.set(pair[0],pair[1]), new Map())
         *
         *  **Note**: the same array is sent to the callback on every iteration.
         */
        reduce<R>(callback: (previous: R, currentPair: [K, V], counter: number, map: SortedMap<K, V>) => R, initialValue: R): R;
        reduce<R>(callback: (previous: R | undefined, currentPair: [K, V], counter: number, map: SortedMap<K, V>) => R): R | undefined;
        /**
         * Returns an iterator that provides items in order (ascending order if
         * the collection's comparator uses ascending order, as is the default.)
         *
         * @param lowestKey First key to be iterated, or undefined to start at
         *    minKey(). If the specified key doesn't exist then iteration
         *    starts at the next higher key (according to the comparator).
         * @param reusedResults Optional iterator results used repeatedly to store the iterator results,
         *    to avoid creating a new object on every iteration.
         */
        entries(lowestKey?: K, reusedResults?: IteratorResult<[K, V], any>): IterableIterator<[K, V]>;
        /**
         * Returns an iterator that provides items in reversed order.
         *
         * @param highestKey Key at which to start iterating, or undefined to
         *      start at maxKey(). If the specified key doesn't exist then iteration
         *      starts at the next lower key (according to the comparator).
         * @param reusedResults Optional iterator results used repeatedly to store the iterator results,
         *      to avoid creating a new object on every iteration.
         * @param skipHighest Iff this flag is true and the highestKey exists in the
         *      collection, the pair matching highestKey is skipped, not iterated.
         */
        entriesReversed(highestKey?: K, reusedResults?: IteratorResult<[K, V], any>, skipHighest?: boolean): IterableIterator<[K, V]>;
        private findPath;
        /**
         * Computes the differences between `this` and `other`.
         * For efficiency, the diff is returned via invocations of supplied handlers.
         * The computation is optimized for the case in which the two trees have large amounts
         * of shared data (obtained by calling the `clone` or `with` APIs) and will avoid
         * any iteration of shared state.
         * The handlers can cause computation to early exit by returning {break: R}.
         * Neither of the collections should be changed during the comparison process (in your callbacks), as this method assumes they will not be mutated.
         * @param other The map to compute a diff against.
         * @param onlyThis Callback invoked for all keys only present in `this`.
         * @param onlyOther Callback invoked for all keys only present in `other`.
         * @param different Callback invoked for all keys with differing values.
         */
        diffAgainst<R>(other: SortedMap<K, V>, onlyThis?: (k: K, v: V) => {
            break?: R;
        } | void, onlyOther?: (k: K, v: V) => {
            break?: R;
        } | void, different?: (k: K, vThis: V, vOther: V) => {
            break?: R;
        } | void): R | undefined;
        private static finishCursorWalk;
        private static stepToEnd;
        private static makeDiffCursor;
        /**
         * Advances the cursor to the next step in the walk of its map.
         * Cursors are walked backwards in sort order, as this allows them to leverage maxKey() in order to be compared in O(1).
         * @param cursor The cursor to step
         * @param stepToNode If true, the cursor will be advanced to the next node (skipping values)
         * @returns `true` if the step was completed and false if the step would have caused the cursor to move beyond the end of the map.
         */
        private static step;
        /**
         * Compares the two cursors. Returns a value indicating which cursor is ahead in a walk.
         * Note that cursors are advanced in reverse sorting order.
         */
        private static compare;
        /**
         * Returns a new iterator for iterating the keys of each pair in ascending order.
         *
         * @param firstKey Minimum key to include in the output.
         * @param reusedResults Optional iterator results used repeatedly to store the iterator results,
         *    to avoid creating a new object on every iteration.
         */
        keys(firstKey?: K, reusedResults?: IteratorResult<[K, V], any>): IterableIterator<K>;
        /**
         * Returns a new iterator for iterating the values of each pair in order by key.
         *
         * @param firstKey Minimum key whose associated value is included in the output.
         * @param reusedResults Optional iterator results used repeatedly to store the iterator results,
         *    to avoid creating a new object on every iteration.
         */
        values(firstKey?: K, reusedResults?: IteratorResult<[K, V], any>): IterableIterator<V>;
        /** Returns the maximum number of children/values before nodes will split. */
        get maxNodeSize(): number;
        /**
         * Gets the lowest key in the map. Complexity: O(log size)
         */
        minKey(): K | undefined;
        /**
         * Gets the highest key in the map. Complexity: O(1)
         */
        maxKey(): K | undefined;
        /**
         * Quickly clones the map by marking the root node as shared.
         * Both copies remain editable. When you modify either copy, any
         * nodes that are shared (or potentially shared) between the two
         * copies are cloned so that the changes do not affect other copies.
         * This is known as copy-on-write behavior, or "lazy copying".
         */
        clone(): SortedMap<K, V>;
        /**
         * Performs a greedy clone, immediately duplicating any nodes that are
         * not currently marked as shared, in order to avoid marking any
         * additional nodes as shared.
         *
         * @param force Clone all nodes, even shared ones.
         */
        greedyClone(force?: boolean): SortedMap<K, V>;
        /**
         * Gets an array filled with the contents of the map, sorted by key.
         */
        toArray(maxLength?: number): [K, V][];
        /**
         * Gets an array of all keys, sorted.
         */
        keysArray(): K[];
        /**
         * Gets an array of all values, sorted by key.
         */
        valuesArray(): V[];
        /**
         * Gets a string representing the map's data based on toArray().
         */
        toString(): string;
        /**
         * Stores a key-value pair only if the key doesn't already exist in the map.
         * @returns `true` if a new key was added
         */
        setIfNotPresent(key: K, value: V): boolean;
        /**
         * Returns the next pair whose key is larger than the specified key (or undefined if there is none).
         * If key === undefined, this function returns the lowest pair.
         * @param key The key to search for.
         * @param reusedPair Optional array used repeatedly to store key-value pairs, to
         * avoid creating a new array on every iteration.
         */
        nextHigherPair(key: K | undefined, reusedPair?: [K, V]): [K, V] | undefined;
        /**
         * Returns the next key larger than the specified key, or undefined if there is none.
         * Also, nextHigherKey(undefined) returns the lowest key.
         */
        nextHigherKey(key: K | undefined, reusedPair?: [K, V]): K | undefined;
        /**
         * Returns the next pair whose key is smaller than the specified key (or undefined if there is none).
         * If key === undefined, this function returns the highest pair.
         * @param key The key to search for.
         * @param reusedPair Optional array used repeatedly to store key-value pairs, to
         * avoid creating a new array each time you call this method.
         */
        nextLowerPair(key: K | undefined, reusedPair?: [K, V]): [K, V] | undefined;
        /**
         * Returns the next key smaller than the specified key, or undefined if there is none.
         * Also, nextLowerKey(undefined) returns the highest key.
         */
        nextLowerKey(key: K | undefined, reusedPair?: [K, V]): K | undefined;
        /**
         * Returns the key-value pair associated with the supplied key if it exists
         * or the pair associated with the next lower pair otherwise. If there is no
         * next lower pair, undefined is returned.
         * @param key The key to search for.
         * @param reusedPair Optional array used repeatedly to store key-value pairs, to
         * avoid creating a new array each time you call this method.
         */
        getPairOrNextLower(key: K, reusedPair?: [K, V]): [K, V] | undefined;
        /**
         * Returns the key-value pair associated with the supplied key if it exists
         * or the pair associated with the next lower pair otherwise. If there is no
         * next lower pair, undefined is returned.
         * @param key The key to search for.
         * @param reusedPair Optional array used repeatedly to store key-value pairs, to
         * avoid creating a new array each time you call this method.
         */
        getPairOrNextHigher(key: K, reusedPair?: [K, V]): [K, V] | undefined;
        /**
         * Edits the value associated with a key in the map, if it already exists.
         * @returns `true` if the key existed, false if not.
         */
        changeIfPresent(key: K, value: V): boolean;
        /**
         * Builds an array of pairs from the specified range of keys, sorted by key.
         * Each returned pair is also an array: pair[0] is the key, pair[1] is the value.
         *
         * @param low The first key in the array will be greater than or equal to `low`.
         * @param high This method returns when a key larger than this is reached.
         * @param includeHigh If the `high` key is present, its pair will be included
         *      in the output if and only if this parameter is true. Note: if the
         *      `low` key is present, it is always included in the output.
         * @param maxLength Length limit. getRange will stop scanning the map when
         *      the array reaches this size.
         *
         * @remarks
         * Computational complexity: O(result.length + log size)
         */
        getRange(low: K, high: K, includeHigh?: boolean, maxLength?: number): [K, V][];
        /**
         * Adds all pairs from a list of key-value pairs.
         *
         * @param pairs Pairs to add to this map. If there are duplicate keys,
         *        later pairs currently overwrite earlier ones (e.g. [[0,1],[0,7]]
         *        associates 0 with 7.)
         * @param overwrite Whether to overwrite pairs that already exist.
         *        if false pairs[i] is ignored when the key pairs[i][0] already exists.
         *        if SetPairCallback then this will be called on both inserts and updates.
         * @returns The number of pairs added to the collection.
         *
         * @remarks
         * Computational complexity: O(pairs.length * log(size + pairs.length))
         */
        setPairs(pairs: [K, V][], overwrite?: boolean | ISortedMap.SetPairCallback<K, V>): number;
        /**
         * Scans the specified range of keys, in ascending order by key.
         * Note: the callback `onFound` must not insert or remove items in the
         * collection. Doing so may cause incorrect data to be sent to the
         * callback afterward.
         *
         * @param low The first key scanned will be greater than or equal to `low`.
         * @param high Scanning stops when a key larger than this is reached.
         * @param includeHigh If the `high` key is present, `onFound` is called for
         *        that final pair if and only if this parameter is true.
         * @param onFound A function that is called for each key-value pair. This
         *        function can return {break: R} to stop early with result R.
         * @param initialCounter Initial third argument of onFound. This value
         *        increases by one each time `onFound` is called. Default: 0
         * @returns The number of values found, or R if the callback returned
         *        `{break: R}` to stop early.
         *
         * @remarks
         * Computational complexity: O(number of items scanned + log size)
         */
        forRange<R = number>(low: K, high: K, includeHigh: boolean, onFound?: ISortedMap.EditRangeCallback<K, V, R>, initialCounter?: number): R | number;
        /**
         * TODO - REMOVE - To allow for editMode to be passed to forRange.
         */
        forEditRange<R = number>(low: K, high: K, includeHigh: boolean, editMode: boolean, onFound?: ISortedMap.EditRangeCallback<K, V, R>, initialCounter?: number): ISortedMap.EditRangeResult<V, R> | number | number;
        /**
         * Scans and potentially modifies values for a subsequence of keys.
         * Note: the callback `onFound` should ideally be a pure function.
         *   Specifically, it must not insert items, call clone(), or change
         *   the collection except via return value; out-of-band editing may
         *   cause an exception or may cause incorrect data to be sent to
         *   the callback (duplicate or missed items). It must not cause a
         *   clone() of the collection, otherwise the clone could be modified
         *   by changes requested by the callback.
         *
         * @param low The first key scanned will be greater than or equal to `low`.
         * @param high Scanning stops when a key larger than this is reached.
         * @param includeHigh If the `high` key is present, `onFound` is called for
         *        that final pair if and only if this parameter is true.
         * @param onFound A function that is called for each key-value pair. This
         *        function can return `{value: v}` to change the value associated
         *        with the current key, `{delete:true}` to delete the current pair,
         *        `{break: R}` to stop early with result R, or it can return nothing
         *        (undefined or {}) to cause no effect and continue iterating.
         *        `{break: R}` can be combined with one of the other two commands.
         *        The third argument `counter` is the number of items iterated
         *        previously; it equals 0 when `onFound` is called the first time.
         * @returns The number of values scanned, or R if the callback returned
         *        `{break: R}` to stop early.
         *
         * @remarks
         *   Computational complexity: O(number of items scanned + log size)
         *   Note: if the map has been cloned with clone(), any shared
         *   nodes are copied before `onFound` is called. This takes O(n) time
         *   where n is proportional to the amount of shared data scanned.
         */
        editRange<R = V>(low: K, high: K, includeHigh: boolean, onFound: ISortedMap.EditRangeCallback<K, V, R>, initialCounter?: number): R | number;
        /**
         * Same as `editRange` except that the callback is called for all pairs.
         */
        editAll<R = V>(onFound: ISortedMap.EditRangeCallback<K, V, R>, initialCounter?: number): R | number;
        /**
         * Removes a range of key-value pairs from the collection.
         * @param low The first key scanned will be greater than or equal to `low`.
         * @param high Scanning stops when a key larger than this is reached.
         * @param includeHigh Specifies whether the `high` key, if present, is deleted.
         * @returns The number of key-value pairs that were deleted.
         * @remarks Computational complexity: O(log size + number of items deleted)
         */
        deleteRange(low: K, high: K, includeHigh: boolean): number;
        /** Deletes a series of keys from the collection. */
        deleteKeys(keys: K[]): number;
        /**
         * Gets the height of the tree: the number of internal nodes between the
         * SortedMap object and its leaf nodes (zero if there are no internal nodes).
        */
        get height(): number;
        /**
         * Makes the object read-only to ensure it is not accidentally modified.
         * Freezing does not have to be permanent; unfreeze() reverses the effect.
         * This is accomplished by replacing mutator functions with a function
         * that throws an Error. Compared to using a property (e.g. this.isFrozen)
         * this implementation gives better performance in non-frozen SortedMaps.
         */
        freeze(): void;
        /** Ensures mutations are allowed, reversing the effect of freeze(). */
        unfreeze(): void;
        /**
         * Returns true if the map appears to be frozen.
         */
        get isFrozen(): boolean;
        /**
         * Scans the tree for signs of serious bugs (e.g. this.size doesn't match
         * number of elements, internal nodes not caching max element properly...)
         * Computational complexity: O(number of nodes), i.e. O(size). This method
         * skips the most expensive test - whether all keys are sorted - but it
         * does check that maxKey() of the children of internal nodes are sorted.
        */
        checkValid(): void;
    }
    /**
     * {@inheritDoc SortedMap}
     * @see
     * ### **Interface**
     *
     * {@link SortedMap}
     */
    export namespace SortedMap {
        const DeleteValue: Readonly<{
            delete: true;
        }>;
        const Break: Readonly<{
            break: true;
        }>;
        const DeleteRange: () => Readonly<{
            delete: true;
        }>;
        /**
         * Types that SortedMap supports by default
         */
        type DefaultComparable = number | string | Date | boolean | null | undefined | (number | string)[] | {
            valueOf: () => number | string | Date | boolean | null | undefined | (number | string)[];
        };
        /** A SortedMap frozen in the empty state. */
        const EmptySortedMap: SortedMap<any, any>;
        /**
         * Compares DefaultComparables to form a strict partial ordering.
         *
         * Handles +/-0 and NaN like Map: NaN is equal to NaN, and -0 is equal to +0.
         *
         * Arrays are compared using '<' and '>', which may cause unexpected equality:
         * for example [1] will be considered equal to ['1'].
         *
         * Two objects with equal valueOf compare the same, but compare unequal to
         * primitives that have the same value.
         */
        function defaultComparator(a: DefaultComparable, b: DefaultComparable): number;
        /**
         * Compares items using the < and > operators. This function is probably slightly
         * faster than the defaultComparator for Dates and strings, but has not been benchmarked.
         * Unlike defaultComparator, this comparator doesn't support mixed types correctly,
         * i.e. use it with `SortedMap<string>` or `SortedMap<number>` but not `SortedMap<string|number>`.
         *
         * NaN is not supported.
         *
         * Note: null is treated like 0 when compared with numbers or Date, but in general
         *   null is not ordered with respect to strings (neither greater nor less), and
         *   undefined is not ordered with other types.
         */
        function simpleComparator(a: string, b: string): number;
        function simpleComparator(a: number | null, b: number | null): number;
        function simpleComparator(a: Date | null, b: Date | null): number;
        function simpleComparator(a: (number | string)[], b: (number | string)[]): number;
    }
}
declare module "collections/Tuple" {
    import { ChainedError } from '@sheetxl/utils';
    import { IList, IListLike } from "collections/index";
    /**
     * Namespace for tuples.
     */
    export namespace Tuple {
        /**
         * Represents a pair of values: a numeric index represents the starting offset and an array of elements.
         *
         * This provides a convenient shorthand for scenarios where you need to associate
         * a contiguous span of values with a specific index or position.
         * @remarks
         * The MinorTuple is types as an Array with 2 elements for performance reasons but can be logically
         * conceptualized as the following type.
         * ```
      type MinorTuple<T = any> = {
        minor: number;
        values: T[];
      };
         * ```
         */
        type MinorTuple<T = any> = [minor: number, runs: IListLike<T>];
        /**
         * Represents a tuple associated with a specific dimension (e.g., a row or a column in a grid).
         *
         * The first element is the major index, and the second element is a `MinorTuple` representing
         * the minor indices and values associated with that location.
         */
        type MajorTuple<T = any> = [major: number, minors: MinorTuple<T>[]];
        /**
         * Represents a collection of `MajorTuple`s, used to store data for a 2d collection of tuples.
         * **Validity Requirements:**
         * - The `major` values within a collection of `MajorTuple`s must be sorted in ascending order.
         * - The `minor` values within each `MinorTuple` of a `MajorTuple` must be sorted in ascending order.
         * - The `minors` (array of `MinorTuple`s) within a `MajorTuple` must not overlap; their ranges
         *   (defined by the `minor` values and the `length` of the `values` arrays) should be mutually exclusive.
         */
        type GridTuple<T = any> = MajorTuple<T>[];
        /**
         * Adds precomputed bounds for the `MajorTuple`s.
         *
         * @remarks
         * In some scenarios the maximum bounds of the tuples is required (e.g., during rendering or calculations),
         * providing precomputed bounds can improve performance by avoiding the need to scan the entire collection.
         */
        interface BoundedTuples<T = any> {
            /**
             * The bounded tuples.
             */
            tuples: Tuple.GridTuple<T>;
            /**
             * The precomputed bounds encompassing all the `MajorTuple`s.
             */
            bounds: Tuple.OrientatedCoords;
        }
        /**
         * RangeCoords expressed in relative coordinates.
         */
        interface OrientatedCoords {
            majorStart: number;
            minorStart: number;
            majorEnd: number;
            minorEnd: number;
        }
        /**
         * A builder for easily creating tuples that can be either contiguous or non-contiguous.
         * A builder maintains an ordered structure where major and minor values must always
         * increase, otherwise an error will be thrown.
         *
         * @template T - The type of values stored within the tuples.
         */
        interface IBuilder<T = any> {
            /**
             * Adds a single value associated with a specific major and minor index.
             *
             * @param major The major index.
             * @param minor The minor index.
             * @param value The value to be added.
             * @throws `Error` If the point is out of order compared to previously added points
             * (within the same row).
             *
             * @remarks
             * If the value is an Array, it will be treated as a discrete value. If you want to set
             * multiple values along the minor axis, then use {@link addValues}.
             */
            addValue(major: number, minor: number, value: T): IBuilder<T>;
            /**
             * Adds multiple values associated with a specific major and minor index.
             *
             * @param major The major index.
             * @param minor The minor index.
             * @param value An array of values to be added.
             * @throws `Error` If the point is out of order compared to previously added points
             * (within the same row).
             */
            addValues(major: number, minor: number, value: T[]): IBuilder<T>;
            /**
             * Constructs and returns the bounded tuples based on the added values.
             * This method can be called multiple times.
             *
             * @returns The built bounded tuples.
             */
            build(): Tuple.BoundedTuples<T>;
        }
        /**
         * Implementation of {@link IBuilder} that that adds in aligned order.
         */
        class Builder<T = any> implements IBuilder<T> {
            private _tuples;
            private _minors;
            private _values;
            private _minorMin;
            private _minorMax;
            private _majorIndex;
            private _minorIndex;
            private _createList;
            private _offsetMajor;
            private _offsetMinor;
            constructor(createList?: (arr: Array<T>) => IList<T>, offsetMajor?: number, offsetMinor?: number);
            /** {@inheritDoc IBuilder.addValues} */
            addValues(major: number, minor: number, value: T[]): IBuilder<T>;
            /** {@inheritDoc IBuilder.addValue} */
            addValue(major: number, minor: number, value: T): IBuilder<T>;
            /** {@inheritDoc IBuilder.build} */
            build(): Tuple.BoundedTuples<T>;
        }
        /**
         * Transposes cell coordinates within tuples to create `MajorTuple` representations
         * in the opposite orientation.
         *
         * This utility efficiently converts data organized by one orientation into the opposite.
         */
        class TransposedBuilder<T> implements IBuilder<T> {
            private _minors;
            /** the currentNode the node.minorIndex >= _minorIndex */
            private _current;
            private _first;
            private _majorMin;
            private _majorMax;
            private _majorIndex;
            private _minorIndex;
            private _createList;
            private _offsetMajor;
            private _offsetMinor;
            constructor(createList?: <T>(arr: Array<T>) => IListLike<T>, offsetMajor?: number, offsetMinor?: number);
            /** {@inheritDoc IBuilder.addValues} */
            addValues(major: number, minor: number, value: T[]): IBuilder<T>;
            /** {@inheritDoc IBuilder.addValue} */
            addValue(major: number, minor: number, value: T): IBuilder<T>;
            /** {@inheritDoc IBuilder.build} */
            build(): Tuple.BoundedTuples<T>;
        }
        /**
         * Thrown when a major minor is set out of order.
         */
        class OutOfOrderError extends ChainedError {
            constructor(message?: string, cause?: Error);
        }
    }
}
declare module "collections/IGrid" {
    import { CellCoords, RangeCoords, Direction, RangeOrientation } from '@sheetxl/utils';
    import { Tuple } from "collections/Tuple";
    /**
     * Primary interface for retrieving and setting values in a 2D space.
     *
     * To support infinite values IGrid uses an iterator to retrieve values.
     *
     * For read-only the minimum implementation required are:
     *
     * {@link entries} - Iterator of key/value.
     *
     * {@link getCoords} - The size and location of the data.
     *
     * For read-write the minimum addition is
     *
     * {@link setValues} - Set an IGrid.Tuple2D.
     *
     * @see `ArraysGrid` - Implementation using a 2D array. ({@link https://www.sheetxl.com | source}).
     * @see `GridMap` - Provides a `Map<CellCoords, T>` interface for an IGrid.
     */
    export interface IGrid<T = any> {
        /**
         * Sets values at specific coordinates within the grid using an array of `Tuple2D`.
         *
         * @param values @param values An array of `Tuple2D` objects containing the coordinates and values to set.
         *
         * @throws `Error` If the Tuple.GridTuple are invalid see {@link Tuple.GridTuple} or if any the provided
         * tuples extend beyond the 'maxCoords'.
         *
         * @remarks
         * * Clear values - Setting values to `undefined` or `null` are not treated special and will become
         *   managed values. To clear use delete.
         * * Immutability - For performance reasons all arrays and values passed in are
         *   accessed directly (zero-copy) so these should be treated as immutable.
         */
        setValues(values: Tuple.GridTuple<T>): this;
        /**
         * Returns an iterator for traversing entries in the IGrid.
         *
         * The entries must support all IteratorOptions.
         *
         * @remarks
         * Unlike map this is does not need to be an IterableIterator.
         */
        entries(options?: IGrid.IteratorOptions): IGrid.EntryIterator<T>;
        /**
         * Returns the bounds for all of the entries or empty if null.
         */
        getCoords(): RangeCoords | null;
        /**
         * Determine major axis for storing values.
         *
         * This is used to indicate which orientations the 2D array for values will be
         * interpreted as well as the default orientation for getValues.
         *
         * @remarks
         * This value is only read once and should never change.
         *
         * If not implemented the client should default to `RangeOrientation.Row`.
         */
        getOrientation?(): RangeOrientation;
        /**
         * Delete all values within a range.
         *
         * @param coords The range to delete.
         *
         * @remarks
         * If not implemented and setRange is then setRange will called with null values.
         */
        delete?(coords: RangeCoords | null): boolean;
        /**
         * Shift values in a given direction.
         *
         * @param coords The range that will shift.
         * @param direction The direction to shift.
         * @returns `true` if data was shifted.
         * @remarks
         * If this is not implemented shifting ranges will be attempted using
         * delete and setAt (if implemented).
         */
        shift?(coords: RangeCoords, direction: Direction): boolean;
        /**
         * Creates a logical copy of the current values.
         *
         * Undo and branching works by creating 'copies' and then rolling back or commit these later.
         *
         * @remarks
         * If this is not available then undo does not work for values.
         */
        clone?(cloneKey?: any): this;
        /**
         * Create a new grid but with no data.
         *
         * @remarks
         * Returns an empty grid with the same configuration as the original grid.
         */
        cloneEmpty?(cloneKey?: any): this;
        /**
         * Represents a max range or a max number.
         *
         * If this is null or undefined then it is assume to be unlimited in size.
         * @remarks
         * Coords must always be positive even if no bounds are set
         */
        getMaxCoords?(): RangeCoords | null;
        /**
         * Iterate keys.
         *
         * @remarks
         * This is not required unless retrieving keys is significantly less expensive than
         * entries. There are few internal use cases that use only keys.
         * @see
         * {@link IGrid.entries}
         */
        keys?(options?: IGrid.IteratorOptions): IGrid.KeyIterator;
        /**
         * Iterate values.
         *
         * @remarks
         * This is not required unless retrieving values is significantly less expensive than
         * entries. there are few internal uses cases that use only values.
         * @see
         * {@link IGrid.entries}
         * @param options {@link IGrid.IteratorOptions}
         */
        values?(options?: IGrid.IteratorOptions): IGrid.ValueIterator;
        /**
         * Returns the value at a specific row and column or `undefined` if not found.
         *
         * @param row
         * @param column
         *
         * @remarks
         * This ignores hiddens rows and columns.
         */
        getValueAt(row: number, column: number): T;
        /**
         * Sets a single value on the grid.
         *
         * @param row
         * @param column
         *
         * @remarks
         * Consider using a TupleBuilder. This is always less efficient than setValues.
         */
        setValueAt(row: number, column: number, value: T): void;
        /**
         * Copy values from another grid.
         *
         * @param destination The grid to copy to.
         * @param topLeft The coordinates of the destination grid.
         * @param from The bounds coordinates to copy from.
         */
        copyTo(destination: IGrid, topLeft: CellCoords, from: RangeCoords): void;
        /**
         * Returns the number of values.
         *
         * @remarks
         * If this is not implemented an approximation using getCoords will be assumed.
         */
        getCount?(): number;
        /**
         * Clears all values.
         */
        clear?(): void;
    }
    /**
     * {@inheritDoc IGrid}
     * @see
     * ### **Interface**
     *
     * {@link IGrid}
     */
    export namespace IGrid {
        /**
         * Allow for iterating over a subset of values in a given direction.
         */
        interface IteratorOptions<T = any> {
            /**
             * If `null' or `undefined` then all cells will be visited.
             * @defaultValue undefined
             */
            bounds?: Partial<RangeCoords>;
            /**
             * Determines the orientation that cells are visited.
             * @defaultValue The ICoordsMap orientation.
             */
            orientation?: RangeOrientation;
            /**
             * Iterate in reverse order.
             * @defaultValue false
             */
            reverse?: boolean;
            /**
             * A callback function that allows customization of the iteration process by skipping specific rows.
             * This is a row orientated implementation of {@link IReadableList.IteratorOptions.processSkip}.
             * @see
             * {@link IReadableList.IteratorOptions.processSkip}
             * {@link IGrid.IteratorOptions.processColumnSkip}
             */
            processRowSkip?: (index: number, reverse?: boolean) => number;
            /**
             * A callback function that allows customization of the iteration process by skipping specific columns.
             * This is a row orientated implementation of {@link IReadableList.IteratorOptions.processSkip}.
             * @see
             * {@link IReadableList.IteratorOptions.processSkip}
             * {@link IGrid.IteratorOptions.processRowSkip}
             */
            processColumnSkip?: (index: number, reverse?: boolean) => number;
            /**
             * This is a performance optimization.
             * To avoid a large amount of object creation a reusable Iterator result can be provided.
             * If set to true a global instance will be used.
             * If multiple iterators are being used simultaneously then the client can provide
             * their own reusable result.
             *
             * Additionally if the reuseResults has a CellCoords defined this will also get reused.
             * The `globalReuseResults` is as follows
             *
             * `-1` is use as placeholder to ensure monomorphic types.
             * If a simple javascript type is used for the value a typed placeholder value should be
             * used for it as well.
             * ```ts
        {
          done: false,
          value: [
            {
              colIndex: -1,
              rowIndex: -1
            },
            null
          ]
        }
             * ```
             * @defaultValue false
             */
            reuseResult?: boolean | IteratorResult<T>;
        }
        /**
         * Entries iterators are arrays of fixed length 2.
         */
        type Entry<T = any> = [CellCoords, T];
        /**
         * Shorthand type.
         */
        type EntryIteratorResult<T = any> = IteratorResult<IGrid.Entry<T>>;
        /**
         * Shorthand type.
         */
        type EntryIterator<T = any> = IterableIterator<IGrid.Entry<T>, IGrid.Entry<T>, CellCoords>;
        /**
         * Shorthand type.
         */
        type ValueIterator<T = any> = IterableIterator<T, T, CellCoords>;
        /**
         * Shorthand type.
         */
        type KeyIterator = IterableIterator<CellCoords, CellCoords, CellCoords>;
    }
}
declare module "collections/ISparseGrid" {
    import { RangeCoords } from '@sheetxl/utils';
    import { IGrid } from "collections/IGrid";
    import { IListLike } from "collections/IList";
    /**
     * Extends {@link IGrid} with specialized functionality for sparse grids.
     */
    export interface ISparseGrid<T = any> extends IGrid<T> {
        /**
         * Returns An iterator for iterating the runs.
         *
         * @remarks
         * Sparse grids are stored as virtual tuples of [major, minor, value].
         */
        getRuns(options?: ISparseGrid.RunIteratorOptions): ISparseGrid.RunIterableIterator<T>;
    }
    /**
     * {@inheritDoc ISparseGrid}
     * @see
     * ### **Interface**
     *
     * {@link ISparseGrid}
     */
    export namespace ISparseGrid {
        type RunEntry<T = any> = [number, number, IListLike<T>];
        /**
         * Shorthand type.
         */
        type RunIterableIterator<T = any> = IterableIterator<RunEntry<T>>;
        /**
         * Shorthand type.
         */
        type RunIteratorResult<T = any> = IteratorResult<ISparseGrid.RunEntry<T>>;
        /**
         * Run Iterator extends {@link IReadableList.IteratorOptions} but removes support for
         * processSkip and downcasts reuseResult.
         */
        interface RunIteratorOptions {
            /**
             * If not specified or `null` then all values will be iterated.
             *
             * @defaultValue unspecified
             *
             * @remarks
             * The min and max are always small to largest regardless of reverse flag.
             */
            bounds?: Partial<RangeCoords>;
            /**
             * If `true` will return the full range even if it is outside of the iteration bounds.
             *
             * @defaultValue `false`
             *
             * @remarks
             * This is used as a performance optimization for iterators that are reading gaps. (fillEmpty)
             */
            overflowRun?: boolean;
        }
    }
}
declare module "collections/ISpatialMap" {
    import { RangeCoords, Direction, CoordUtils, RangeOrientation } from '@sheetxl/utils';
    /**
     * Data structure that allows for querying 2d rectangles.
     */
    export interface ISpatialMap<T = any> {
        /**
         * Returns all items within the search range.
         *
         * @param range The range to search
         * @param fullyContained Only search for ranges that are completely contained with the search range. DefaultValue `false`.
         */
        search(range: Readonly<RangeCoords>, fullyContained?: boolean, results?: ISpatialMap.Entry<T>[]): ISpatialMap.Entry<T>[];
        /**
         * Returns `true` if there are any items within the range.
         *
         * @param range The range to search
         */
        has(range: Readonly<RangeCoords>): boolean;
        /**
         * Returns the smallest range that includes all ranges.
         */
        getBoundingCoords(): RangeCoords;
        /**
         * A quick search for all.
         */
        size(): number;
        /**
         * Just like `size === 0` but even quicker.
         */
        isEmpty(): boolean;
        /**
         * Just like `search(getBoundingCoords())` but slightly faster.
         */
        all(results?: ISpatialMap.Entry<T>[]): ISpatialMap.Entry<T>[];
        /**
         * Visit all items within a range.
         *
         * @param range The range to visit.
         * @param visitor The visitor function to call for each item.
         * @param sort If provided, the ranges will be sorted in either row or column order. Default value is no sort.
         */
        visitRanges(range: Readonly<RangeCoords>, visitor: ISpatialMap.Visitor<T>, sort?: Direction): void;
        /**
         * Insert a an entry.
         *
         * @param entry The item to insert
         * @remarks
         * * This does not prevent duplicates. A remove is required.
         * *
         */
        insert(entry: ISpatialMap.Entry): this;
        /**
         * Inserts a item but splits and merges all intersections to ensure no overlaps.
         *
         * @param entry The entry to add.
         * @param options Options for adding non overlapping options.
         *
         * @remarks
         * * This is much slower than a regular load so if the ranges are known to be non-overlapping
         *   then the `load` method should be used.
         */
        insertNonOverlapping(entry: ISpatialMap.Entry<T>, options?: ISpatialMap.InsertNonOverlappingOptions<T>): this;
        /**
         * TODO - doc this.
         *
         * @param entries the entries to manage together
         * @param uuid A unique identifier for the group.
         */
        insertGroup(entries: ISpatialMap.Entry[], uuid: string): this;
        /**
         * Returns a set of non overlapping inserts and removes that would represent a copy.
         *
         * @param from The range to copy from.
         * @param to The range to copy to
         *
         * @remarks
         * This doesn't actually make the copy but returns the entries that would reflect a copy.
         */
        createCopiedEntries(from: RangeCoords, to: RangeCoords, options?: ISpatialMap.CopyOptions, reuseInsert?: ISpatialMap.Entry<T>[], reuseRemove?: ISpatialMap.Entry[]): ISpatialMap.Updates<T>;
        /**
         * Optimized bulk insert. This should be used when possible.
         * @param entries A readonly list of RangeCoordValues
         */
        load(entries: ReadonlyArray<ISpatialMap.Entry>): this;
        /**
         * Shifts all ranges in a given direction.
         *
         * @param options The options for the shift.
         */
        shift(options: ISpatialMap.ShiftOptions<T>): this;
        /**
         * Remove item.
         *
         * @param entry The item to remove.
         * @param equals A custom equal check to determine if the item should be returned.
         */
        remove(entry: ISpatialMap.Entry, equals?: (a: ISpatialMap.Entry, b: ISpatialMap.Entry) => boolean): this;
        /**
         * Clear the tree.
         */
        clear(): this;
        /**
         * Returns a copy on write clone.
         *
         * @param cloneKey A performance optimization that will avoid cloning if the same key is used.
         *
         * @remarks
         * If the same clone key is used then the same instance will be returned.
         */
        clone(cloneKey?: any): this;
    }
    /**
     * {@inheritDoc ISpatialMap}
     * @see
     * ### **Interface**
     *
     * {@link ISpatialMap}
     */
    export namespace ISpatialMap {
        /**
         * A visitor function that is called for each item in a range.
         */
        type Visitor<T = any> = (entry: ISpatialMap.Entry<T>) => ISpatialMap.VisitorResults<T>;
        /**
         * Allows for the visitor to update the results.
         */
        type VisitorResults<T = any> = {
            update?: ISpatialMap.Entry<T>;
            delete?: boolean;
            break?: boolean;
        } | void;
        interface Entry<T = any> extends RangeCoords {
            value?: T;
            uuid?: string;
            /**
             * If the entry is the results of a split or a merge.
             */
            lastId?: string;
        }
        interface IUpdatableEntry<T extends IUpdatableEntry = any> {
            /**
             * Splits the range into multiple sub-ranges based on specified coordinates and orientation.
             *
             * @param destination The destination coordinates for the split.
             * @param orientation The orientation (horizontal/vertical) of the split.
             * @returns An array of the split ranges.
             * @throws Will throw an error if the split cannot be performed.
             *
             * @remarks
             * This method allows for dividing the range into smaller segments. If splitting
             * is not supported, an error will be thrown.
             */
            getSplit?(destination: readonly [RangeCoords, RangeCoords], orientation: RangeOrientation, offset: number): [T, T] | undefined;
            /**
             * Attempts to merge this range with another range, based on specified coordinates
             * and orientation. Returns a new merged range or `undefined` if merging is not possible.
             *
             * @param other The other range to merge with.
             * @param coords The coordinates of the merged range.
             * @param orientation The orientation (horizontal/vertical) for merging.
             * @returns A new merged range if successful, or `undefined` if merging is not possible.
             *
             * @remarks
             * This method always returns a merged range that is aligned to the left/top.
             */
            getMerged?(other: T, coords: RangeCoords, orientation: RangeOrientation): T | undefined;
            /**
             * Called when the range is shifted.
             *
             * @param options The details of the shift operation.
             * @returns The new shifted range entry, or `undefined` if shifting is not possible.
             *
             * @remarks
             * * Always happens in a direction. If not implemented, a shift will still occur.
             * * An insert will attempt to resize, then split, then error.
             * * A delete will attempt to resize, then split, then error.
             */
            getShifted?(options: ISpatialMap.ShiftDetails<T>): ISpatialMap.Entry<T> | undefined;
            /**
             * Called when the node is being removed.
             *
             * @param coords The coordinates of the range being removed.
             *
             * @remarks
             * This is not reliably called.
             */
            onRemove?(entry: ISpatialMap.Entry<T>): void;
            /**
             * Copies the range to a specified destination.
             *
             * @param destination The destination coordinates.
             * @param options Optional parameters for the copy operation.
             * @returns The copied range.
             *
             * @remarks
             * The destination is guaranteed to be a multiple of the RangeCoords.
             * Will tile if `canTileTo` returns `true`; otherwise, the size will always be the same.
             */
            copyTo?(destination: RangeCoords, options?: ISpatialMap.CopyOptions): T;
            /**
             * Returns a flag indicating whether the range can be tiled.
             *
             * @param destination The destination coordinates.
             * @param options Optional parameters for the tiling operation.
             * @returns `true` if the range can be tiled; otherwise, `false`.
             *
             * @remarks
             * If missing or not implemented, it is assumed that the range cannot be tiled.
             */
            canTile?(destination: RangeCoords, options?: ISpatialMap.CopyOptions): boolean | RangeOrientation;
        }
        /**
         * Provide a set of options to enabled Updating entries.
         */
        interface UpdateEntryOptions<T = any> {
            /**
             * This will be recursively called to break ranges into smaller parts to ensure there is no
             * overlap.
             *
             * @param from The entry that is being split
             * @param destination The default splits
             * @param orientation The orientation.
             * @param offset The offset. 0 is far left.
             * @throws - Error if the split cannot be performed.
             * @returns An array of 2 values that represent the values for the split.
             */
            getSplit?(from: ISpatialMap.Entry<T>, destination: [ISpatialMap.Entry<T>, ISpatialMap.Entry<T>], orientation: RangeOrientation, offset: number): [ISpatialMap.Entry<T>, ISpatialMap.Entry<T>] | null;
            /**
             * Attempts to merge two entries in an orientations. Returns a new merged entry or `undefined` if merging is not possible.
             *
             * @param from The other range to merge with.
             * @param destination The coordinates of the merged range.
             * @param orientation The orientation (horizontal/vertical) for merging.
             * @returns A new merged range if successful, or `undefined` if merging is not possible.
             *
             * @remarks
             * This method always returns a merged range that is aligned to the left/top.
             */
            getMerged?(from: [ISpatialMap.Entry<T>, ISpatialMap.Entry<T>], destination: ISpatialMap.Entry<T>, orientation: RangeOrientation): ISpatialMap.Entry<T> | null | undefined;
            /**
             * Return a shifted range.
             *
             * @param options The details of the shift operation.
             * @returns The new shifted range entry, or `undefined` if shifting is not possible.
             *
             * @remarks
             * * Always happens in a direction. If not implemented, a shift will still occur.
             * * An insert will attempt to resize, then split, then error.
             * * A delete will attempt to resize, then split, then error.
             */
            getShifted?(from: ISpatialMap.Entry<T>, destination: ISpatialMap.Entry<T>, options: ISpatialMap.ShiftDetails<T>): ISpatialMap.Entry<T> | undefined;
            /**
             * Called after all splitting for any ranges that intersect.
             *
             * @param orig A node with the original value.
             * @param adj A node with the adjusted value.
             * @returns The value for the intersected ranges.
             *
             * @remarks
             * * This can be called multiple times on a single inset with different bounds and values to due splits.
             */
            getIntersect?(orig: ISpatialMap.Entry<T>, adj: ISpatialMap.Entry<T>): ISpatialMap.Entry<T> | null;
            /**
             * Copies the entry to a specified destination.
             *
             * @param destination The destination coordinates.
             * @param options Optional parameters for the copy operation.
             * @returns A new entry.
             *
             * @remarks
             * The destination is guaranteed to be a multiple of the RangeCoords.
             * Will tile if `canTileTo` returns `true`; otherwise, the size will always be the same.
             */
            copyTo?(from: ISpatialMap.Entry<T>, destination: RangeCoords, options?: ISpatialMap.CopyOptions): ISpatialMap.Entry<T>;
            /**
             * Returns a flag indicating whether the range can be tiled.
             *
             * @param destination The destination coordinates.
             * @param options Optional parameters for the tiling operation.
             * @returns `true` if the range can be tiled; otherwise, `false`.
             *
             * @remarks
             * If missing or not implemented, it is assumed that the range cannot be tiled.
             */
            canTile?(orig: ISpatialMap.Entry<T>, destination: RangeCoords, options?: ISpatialMap.CopyOptions): boolean | RangeOrientation;
            /**
             * Called on all nodes that have been modified by either a split or an insert but not a shift.
             *
             * @param adj The adjust node.
             *
             * @remarks
             * * Provides a hook to track all changes.
             * * If `null` is return then this will be culled.
             */
            getUpdate?(adj: ISpatialMap.Entry<T>): ISpatialMap.Entry<T> | null | void;
            /**
             * Called for all nodes that are being shifted.
             */
            onShifted?(shifted: ISpatialMap.Entry<T>[]): void;
            /**
             * called when a range is removed. This can be due to
             * either a remove of the entry of a shift.
             *
             * @param removes
             */
            onRemoved?(removes: ISpatialMap.Entry<T>[]): void;
            /**
             * Called when a value is inserted or updated.
            */
            onUpdated?(updates: ISpatialMap.Entry<T>[]): void;
            onMerged?(onMerges: ISpatialMap.Entry<T>[]): void;
            /**
             * Called when a group is updated.
             *
             * @param entries All entries in the group.
             * @param uuid Any params argument passed a modification option.
             */
            onGroupUpdate?(entries: ISpatialMap.Entry<T>[], uuid?: string): void;
            /**
             * Called after structure has been updated with for any reason with all
             * inserts and removes.
             *
             * @param insert All new entries.
             * @param remove All removed entries.
             */
            onUpdates?(inserts: ISpatialMap.Entry<T>[], removes: ISpatialMap.Entry<T>[], spatial: ISpatialMap): void;
            /**
             * Indicates whether shifting should occur when an insert is made on the trailing row or column.
             *
             * @defaultValue `false`
             *
             * @remarks
             * Useful for ranges that shift the value immediately before on an insert (e.g., styles).
             */
            isTrailingEdge?: boolean;
            /**
             * Indicates if the entries should split when the range is expanding.
             *
             * @defaultValue `false`
             *
             * @remarks
             * Examples include formula, comments, and conditional formatting
             */
            isSplitOnExpand?: boolean;
            /**
             * If `true` then after shift any shift entries will attempt to be merged to their nearest neighbors.
             *
             * @defaultValue `false`
             *
             * @remarks
             * This will cause merge to fail it there are any overlapping ranges.
             * Examples include styles.
             */
            isMergeOnShift?: boolean;
            /**
             * Default for merge
             */
            noMerge?: boolean;
        }
        /**
         * Options for the shift method on the Index.
         */
        interface ShiftOptions<T> {
            /**
             * The range to shift.
             */
            range: RangeCoords;
            /**
             * The direction to shift.
             */
            direction: Direction;
            /**
             * If `true` the this will return a clone index if there are any modifications.
             *
             * @defaultValue false
             *
             * @remarks
             * This allows for a 0-1 clone on write.
             */
            cloneIfUpdate?: boolean;
            /**
             * 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;
            /**
             * If provided this will be called to update to ensure the location if valid.
             */
            onShift?: (options: ISpatialMap.ShiftDetails<T>) => void;
        }
        /**
         * Options for {@link ISpatialMap.insertNonOverlappingOptions}
         */
        interface InsertNonOverlappingOptions<T> {
            /**
             * Callback function that will be be called on insert.
             *
             * @remarks
             * If see this will be called for each new entry creation with the original entry.
             */
            onIntersect?: (orig: ISpatialMap.Entry<T>, adj: ISpatialMap.Entry<T>) => ISpatialMap.Entry<T>;
            onUpdates?(inserts: ISpatialMap.Entry<T>[], removes: ISpatialMap.Entry<T>[], spatial: ISpatialMap): void;
            /**
             * If `true` then insert will not attempt to merge fragmented entries.
             *
             * @remarks
             * Useful when you want to merge all entries at the end.
             */
            noMerge?: boolean;
        }
        /**
         * Pair of spatial updates when doing batch updates.
         */
        interface Updates<T = any> {
            inserts: ISpatialMap.Entry<T>[];
            removes: ISpatialMap.Entry[];
        }
        /**
         * Details about the shift operation.
         */
        interface ShiftDetails<T = any> {
            before: ISpatialMap.Entry<T>;
            after: ISpatialMap.Entry<T> | null;
            intersect: RangeCoords;
            isSplit: boolean;
            orientation: RangeOrientation;
            amount: number;
        }
        /** Options */
        interface ConstructorOptions<T = any> {
            /**
             * Options for managing updates,splits, and merges.
             */
            updateEntryOptions?: ISpatialMap.UpdateEntryOptions<T>;
            /**
             * @param maxEntries An optional argument to RBush defines the maximum number of entries in a tree node. Higher
             *                   value means faster insertion and slower search, and vice versa.
             * @defaultValue 9.
             */
            maxNodeEntries?: number;
        }
        interface CopyOptions {
            transpose?: boolean;
        }
    }
}
declare module "collections/_RunUtils" {
    import { RunCoords } from '@sheetxl/utils';
    import { ITypes } from "type/index";
    export interface ModifiedRuns<T> {
        preceding: ITypes.RunCoordValue<T>[];
        modified: ITypes.RunCoordValue<T>[];
        trailing: ITypes.RunCoordValue<T>[];
    }
    export const deepUpdate: (prevValue: any | null, newValue: any | null) => any | null;
    export const deepCull: (value: any, _min: number, _max: number) => boolean;
    export interface UpdateAndCompactOptions<T, U = T> {
        /**
         * Used when split two runs.
         * @remarks
         * Should always return an array with 2 values.
         */
        onSplit?: (value: ITypes.RunCoordValue<T>, offset: number) => T[];
        /**
         * Returns an updated value. If not specified a deep merge is done.
         *
         * IMPORTANT -
         * both prevValue and newValue should be treated as frozen object and not
         * mutated.
         * A new value should always be returned. If you want to augment a value
         * The deepUpdateMethod is offered
        */
        onUpdate?: (prevValue: T | null, newValue: U | null | undefined, run: ITypes.RunCoordValue<T>) => T | null | undefined;
        /**
         * Used when attempting to merge two runs.
         * Returns undefined if the values can't be merged
         */
        onMerge?: (a: T, b: T, sizeA: number, sizeB: number) => T | undefined;
        /**
         * Used to determine if a entry should removed. If value is null or undefined it will also be removed.
         * By default an empty object will not be.
         */
        isCull?: (value: T, min: number, max: number) => boolean;
        /**
         * By default merge will freeze object in place to prevent mutations.
         * Setting this to true will allow for special cases where objects are not immutable.
         *
         * @defaultValue false
         */
        inPlace?: boolean;
    }
    export const shiftRuns: <T>(runs: ITypes.RunCoordValue<T>[], index: number, amount?: number) => ModifiedRuns<T>;
    export function unshiftRuns<T>(runs: ITypes.RunCoordValue<T>[], index: number, amount?: number): ModifiedRuns<T>;
    export function unshiftAndMergeRuns<T>(runs: ITypes.RunCoordValue<T>[], index: number, amount?: number, options?: MergeRunOptions<T>): ModifiedRuns<T>;
    /**
     * Will take a list of runs and return the minimum set required.
     *
     * @param runs
     * @param update
     * @param options @UpdateAndCompactOptions
     */
    export function updateAndCompactRuns<T, U = T>(runs: ITypes.RunCoordValue<T>[], update: ITypes.RunCoordValue<U>, options?: UpdateAndCompactOptions<T, U>): ModifiedRuns<T>;
    export function concatModifiedRuns<T>(parts: ModifiedRuns<T>): ITypes.RunCoordValue<T>[];
    /**
     * Split/update algo used for formatted text.
     * This will split and update runs
    
     * All runs must be:
     * ** ordered
     * ** non-overlapping
     * Runs do not need to be contiguous.
     */
    export function splitAndUpdateRuns<T, U = T>(runs: ITypes.RunCoordValue<T>[], update: ITypes.RunCoordValue<U> | null, onSplit?: (run: ITypes.RunCoordValue<T>, offset: number) => T[], onUpdate?: (prevValue: T | null, newValue: U | null, run: ITypes.RunCoordValue<T>) => T | null, inPlace?: boolean): ModifiedRuns<T>;
    interface CullRunsOptions<T> {
        startOffset?: number;
        endOffset?: number;
        /**
         * Used to determine if a value should removed. If data is null or undefined it will also be removed.
         * By default an empty object will not be.
         */
        cull?(value: T, min: number, max: number): boolean;
    }
    export function cullRuns<T>(runs: ITypes.RunCoordValue<T>[], options?: CullRunsOptions<T>): ModifiedRuns<T>;
    export interface MergeRunOptions<T> {
        startOffset?: number;
        endOffset?: number;
        onMerge?: (a: T, b: T, sizeA: number, sizeB: number) => T | undefined | null;
    }
    /**
     * Merges runs. Runs must be sorted; {@link sortRuns}
     */
    export function mergeRuns<T>(runs: ITypes.RunCoordValue<T>[], options?: MergeRunOptions<T>): ModifiedRuns<T>;
    export function sortRuns<T>(a: ITypes.RunCoordValue<T>[]): ITypes.RunCoordValue<T>[];
    /**
     * Sorts twos runs by their min values.
     */
    export function sortTwoRuns<T>(a: ITypes.RunCoordValue<T>, b: ITypes.RunCoordValue<T>, forward?: boolean): ITypes.RunCoordValue<T>[];
    /**
     * Looks for a run going in a certain direction. If there isn't a run for this it will look for the next
     * run. If you only want the run if it is found then use {@link findRun}.
     *
     * @param runs An array of Run or RunCoords.
     * @param index The index that will be >= min && <= max.
     * @param findGreater - *`default`* `true` If true will search greater if false lesser.
     * @returns The index for the next run or -1 if no run was found.
     */
    export const findNextRunOffset: <T = any>(runs: ITypes.RunCoordValue<T>[], index: number, findGreater?: boolean) => number;
    export const findRun: <T>(runs: ITypes.RunCoordValue<T>[], index: number) => ITypes.RunCoordValue<T> | null;
    /**
     * Converts a list of indices into Runs (an array of RunCoords).
     *
     * @param indices A list of indices.
     * @param presorted If set to true will not sort. @defaultValue false
     */
    export const indicesToRuns: (indices: number[], presorted?: boolean) => RunCoords[];
    /**
     * Runs are an ordered list of RunCoords with no overlapping values.
     *
     * Examples:
     *
     * - Valid - [0, 3][4, 4][8,10] // valid runs of size 4, 1, 3
     *
     * - Invalid -  [0, 4][4, 6][8,10] // 4 overlaps
     *
     * - Invalid -  [0, 3][7, 6][8,10] // second run has incorrect min/max
     *
     * - Invalid -  [4, 6][0, 5][8,10] // second run is out of order
     *
     * - Valid  - [] // empty but valid
     * @param runs A list of RunCoords.
     */
    export const validateRuns: (runs: RunCoords[]) => boolean;
    /**
     * Finds the intersection of 2 runs.
     * @returns `null` if no intersection
     */
    export const intersectRuns: (a: RunCoords, b: RunCoords) => RunCoords;
    export interface RunVisitor<T> {
        (run: ITypes.RunCoordValue<T>): {
            break: any;
        } | void;
    }
    export interface CacheSearchRunData<T = any> {
        runs: readonly ITypes.RunCoordValue<T>[];
        run: ITypes.RunCoordValue<T | null>;
        index: number;
    }
    export const createSearchRunCache: <T = any>(runs: readonly ITypes.RunCoordValue<T>[]) => CacheSearchRunData<T>;
    /**
     * To minimize lookups we assume that the items are generally read in order.
     * This allows use to cache the last run and check adjacent before doing a binary search.
     *
     * If the runs are update the an new CacheSearchRunData is required. see {@link createSearchRunCache}
     * * We always return a run if one is found.
     * * If one isn't we return a run with a null value with min/max being the empty space boundaries.
     * * the runIndex is always the current run or the next run (or -1 if no runs).
     * * We reuse cache
     * @param index
     * @param cache
     */
    export const searchRunsWithCache: <T = any>(index: number, cache: CacheSearchRunData<T>) => T;
    /**
     * Scans all of the runs. It will scan each run exactly once.
     * In additional if there are gaps it will create an empty run.
     */
    export const scanRuns: <V, B = any>(runs: ITypes.RunCoordValue<V>[], visitor: RunVisitor<V>, start?: number, end?: number) => {
        break: B;
    } | void;
}
declare module "collections/IteratorUtils" {
    import { RunCoords } from '@sheetxl/utils';
    import { IReadableList } from "collections/IReadableList";
    export interface DisposableIterableIterator<T> extends IterableIterator<T>, Disposable {
        [Symbol.iterator](): DisposableIterableIterator<T>;
    }
    /**
     * Perform a forEach over an iterable. Honors {@link Iterator.return} and {@link Iterator.throw}.
     *
     * @param iterable The iterable to visit.
     * @param callbackfn The forEach function.
     * @param map The Map interface.
     * @param _thisArg If provided, this will bind `this` to the callback function.
     */
    export const doForEach: <K = any, V = any, M = any>(iterator: Iterator<[K, V]>, callbackfn: (value: V, key: K, map: M) => void, map?: M, _thisArg?: any) => void;
    /**
     * Wraps an iterator in an Iterable.
     *
     * @param iterator The iterator to wrap.
     * @see
     * * {@link https://patrickdesjardins.com/blog/understand-typeScript-iterator-and-iterable}
     * * {@link https://github.com/leebyron/iterall}
     */
    export const iteratorToIterable: <T, TReturn, TNext>(iterator: Iterator<T, TReturn, TNext>) => DisposableIterableIterator<T>;
    /**
     * Visits all iterators and adds to an array.
     */
    export const pushIteratorToArray: <T, TReturn, TNext>(iterator: Iterator<T, TReturn, TNext>, array: (T | TReturn)[]) => void;
    /**
     * Wrap entries iterator in an Iterable
     */
    export const entriesToIterable: <T>(iterator: Iterator<IReadableList.Entry<T>, IReadableList.Entry<T>, number>) => IterableIterator<T>;
    /**
     * Creates a processSkip callback from a valid set of RunCoords.
     *
     * @param skipRuns A valid set of RunCoords.
     * @returns A callback that can be used with {@link IReadableList.IteratorOptions.processSkip}.
     *
     * @remarks
     * * For performance reasons RunCoords are not validated; If validation is not certain use `RunUtils.validateRuns`.
     * * Returns a state function so createSkipProcessor should be called for each createIterator.
     */
    export const createSkipProcessor: (skipRuns: RunCoords[]) => ((index: number, reverse?: boolean) => number);
    /**
     * Sharable iterator used when the Iterator is complete.
     */
    export const DoneIteratorResult: IteratorResult<any, any>;
    /**
     * Sharable IterableIterator that return no results.
     */
    export const DoneIterator: IterableIterator<any>;
    /**
     * Sharable IteratorResult for not done.
     */
    export const ReusableResults: IteratorResult<any>;
    /**
     * A utility class that provides an iterable iterator for 2D arrays
     */
    export class Array2DIterator<T> implements IterableIterator<T> {
        private readonly array;
        private row;
        private col;
        private readonly rowEnd;
        private readonly colEnd;
        /**
         * Creates a new 2D array iterator
         *
         * @param array The 2D array to iterate
         * @param rowStart Starting row index (default: 0)
         * @param colStart Starting column index (default: 0)
         * @param rowEnd Ending row index (default: array.length)
         * @param colEnd Ending column index (default: max column length)
         */
        constructor(array: T[][], colStart?: number, rowStart?: number, colEnd?: number, rowEnd?: number);
        /**
         * Returns the iterator itself
         */
        [Symbol.iterator](): IterableIterator<T>;
        /**
         * Gets the next value in the iteration sequence
         */
        next(): IteratorResult<T>;
    }
    /**
     * Creates a new iterator that maps values from a source iterator through a callback function
     *
     * @param sourceIterator The source iterator to map values from
     * @param mapFn The mapping function to apply to each value
     * @returns A new iterator with mapped values
     */
    export function mapIterator<T, U>(sourceIterator: Iterator<T>, mapFn: (value: T) => U): IterableIterator<U>;
}
declare module "collections/ImmutableList" {
    import { IListLike } from "collections/IList";
    import { IReadableList } from "collections/IReadableList";
    /**
     * Wraps an {@link Array} to implement {@link IReadableList}.
    
     * This assumes all records are immutable.
     *
     * By assuming all objects are immutable we can make significant performance optimizations
     * using a similar strategy to SlicedStrings and only perform logical copies.
     *
     * @remarks
     * The full {@link Array} interface is not supported.
     *
     * @see
     * * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice}
     * * {@link https://stackoverflow.com/questions/72540410/time-complexity-of-slice-in-javascript-v8-runtime}
     */
    export class ImmutableList<T> implements IReadableList<T> {
        private _s;
        private _r;
        private _l;
        private _c;
        constructor(values?: T[] | IListLike<T>);
        /**
         * Returns the value at a given index.
         *
         * @param index The index to retrieve.
         * @returns The value
         */
        at(index: number): T | undefined;
        /** {@inheritDoc IReadableList.toArray} */
        toArray(maxLength?: number): T[];
        /** {@inheritDoc IReadableList.entries} */
        entries(options?: IReadableList.IteratorOptions): IReadableList.EntryIterator<T>;
        /** {@inheritDoc IReadableList.slice} */
        slice(start: number, end?: number): IReadableList<T>;
        /** {@inheritDoc IReadableList.concat} */
        concat(list: IListLike<T>): IReadableList<T>;
        /** {@inheritDoc IReadableList.length} */
        get length(): number;
        [Symbol.iterator](): IterableIterator<T>;
        /** {@inheritDoc IReadableList.isIReadableList} */
        get isIReadableList(): true;
        /** {@inheritDoc IList.isIList} */
        get isIList(): true;
        get [Symbol.toStringTag](): string;
        toString(): string;
    }
}
declare module "collections/OverlappingRangeIterator" {
    import { CellCoords, RangeOrientation, RangeCoords } from '@sheetxl/utils';
    import { ITypes } from "type/index";
    /**
     * Iterate over a collection of overlapping RangeCoord.
     *
     * This will iterator over CellCoords or RangeCoords.
     */
    type ESIterator<T, TReturn = any, TNext = undefined> = Iterator<T, TReturn, TNext>;
    export namespace OverlappingRange {
        interface IteratorOptions {
            /**
             * The direction of the scan.
             * @defaultValue RangeOrientation.Row
             */
            orientation?: RangeOrientation;
            /**
             * Set iterator to increment by cells within an intersection.
             *
             * @defaultValue false
             *
             * @remarks
             * Depending on the range intersect it is possible that some scan lines will be duplicated.
             * This is desired as it makes merging ranges easier/possible.
             */
            byCell?: boolean;
            /**
             * Iterate in reverse order.
             * @defaultValue false
             */
            reverse?: boolean;
            /**
             * If provided then iterator results will reuse the return results.
             *
             * @defaultValue `undefined` (Creates new instances for each iterator)
             *
             * @remarks
             * - **Performance:** Setting this to `true` can drastically improve performance for large ranges,
             *   but it will modify the original range data.
             * - **Safety:**  If you need to preserve the original range data, set this to `false`.
             */
            reuseIterator?: boolean | IteratorResult<OverlappingRange.Intersection>;
        }
        /**
         * When iterating a cursor is used to track the
         * current location. The coords will always move forward.
         */
        interface Intersection {
            /**
             * The current coords.
             */
            cell: CellCoords;
            /**
             * This is a non-overlapping virtual range.
             *
             * @remarks
             * This is not guaranteed to be the smallest packing size.
             */
            range: RangeCoords;
            /**
             * All ranges at the intersection. This may be a single range.
             */
            overlaps: ITypes.RangeCoordValue[];
        }
        type Iterator = ESIterator<Intersection, Intersection, CellCoords>;
        class IteratorInstance implements Iterator, IterableIterator<Intersection> {
            private _isColumn;
            private _isByCell;
            private _isReverse;
            private _cursor;
            private _reuse;
            private _localReuse;
            private _eventsMajor;
            private _eventMajorIndex;
            private _majorStart;
            private _majorEnd;
            private _eventsMinor;
            private _eventsMinorIterator;
            private _eventMinorPeek;
            private _minorStart;
            private _minorEnd;
            constructor(ranges: readonly ITypes.RangeCoordValue[], options?: IteratorOptions);
            /**
             * Returns the next Intersection as a IteratorResult.
             */
            next(nextCell?: CellCoords): IteratorResult<Intersection>;
            return(_value?: Intersection): IteratorResult<Intersection>;
            throw(_e?: any): IteratorResult<Intersection>;
            [Symbol.iterator](): IterableIterator<Intersection>;
        }
    }
}
declare module "collections/_CollectionUtils" {
    import { RangeCoords, Direction, RunCoords } from '@sheetxl/utils';
    /**
     * Sorts ranges in 2 directions but weighted to direction.
     *
     * @remarks
     * * Mutates the ranges array.
     * * Will also sort nulls to the end.
     * * Only uses the colStart and rowStart. It does not account for colEnd and rowEnd.
     *
     * @param ranges The ranges to sort
     * @param direction defaultValue Direction.Right
     */
    export const sortRanges: (ranges: RangeCoords[], direction?: Direction, additionalSort?: ((a: RangeCoords, b: RangeCoords) => number)) => RangeCoords[];
    /**
     * Specialize Comparator. We only create RunCoords with a -1 max for search operations.
     * We look for a RunCoord that has a missing edge.
     *
     * We only have to check the second argument because all of our search operations guarantee the
     * key will be the second argument.
     *
     * @param a The first RunCoords.
     * @param b The second RunCoords or the search key in the case where max is `Number.MAX_SAFE_INTEGER`.
     */
    export const runCoordsAndPivotComparator: (a: RunCoords, b: RunCoords) => number;
}
declare module "collections/SparseList" {
    import { RunCoords } from '@sheetxl/utils';
    import { IListLike } from "collections/IList";
    import { IReadableList } from "collections/IReadableList";
    import { ISparseList } from "collections/ISparseList";
    /**
     * A SparseList implemented using a SortedMap of contiguous ReadableLists/WritableLists.
     */
    export class SparseList<T = any> implements ISparseList<T> {
        private _options;
        private _runs;
        private _dataCoords;
        private _count;
        private _length;
        private _maxCoords;
        private _reuseRunsIterator;
        private _reuseRunsEntry;
        private _lastRunsRead;
        private _lastListRead;
        constructor(options?: SparseList.ConstructorOptions);
        private _validateBounds;
        /** {@inheritDoc IReadableList.entries} */
        entries(options?: IReadableList.IteratorOptions): IReadableList.EntryIterator<T>;
        /** {@inheritDoc ISparseList.runs} */
        runs(options?: ISparseList.RunIteratorOptions): ISparseList.RunIterator<T>;
        /** {@inheritDoc IReadableList.slice} */
        slice(start: number, end?: number): ISparseList<T>;
        /** {@inheritDoc IReadableList.concat} */
        concat(list: IListLike<T>): ISparseList<T>;
        /** {@inheritDoc IReadableList.toArray} */
        toArray(maxLength?: number, includeEmpty?: boolean): T[];
        /** {@inheritDoc IReadableList.isIReadableList} */
        get isIReadableList(): true;
        /** {@inheritDoc IListLike.length} */
        get length(): number;
        /** {@inheritDoc ISparseList.clear} */
        getCoords(): RunCoords | null;
        /** {@inheritDoc ISparseList.clear} */
        clear(): void;
        /** {@inheritDoc ISparseList.isISparseList} */
        get isISparseList(): true;
        /** {@inheritDoc IList.isIList} */
        get isIList(): true;
        private _updateCount;
        private _update;
        /** {@inheritDoc IWritableList.setAt} */
        setAt(index: number, value: T): boolean;
        /** {@inheritDoc ISparseList.setRunAt} */
        setRunAt(index: number, list: IReadableList<T>): boolean;
        /** {@inheritDoc IWritableList.delete} */
        delete(start: number, amount?: number): boolean;
        /** {@inheritDoc IWritableList.shift} */
        shift(index: number, amount: number): boolean;
        /** {@inheritDoc IListLike.at} */
        at(index: number): T | undefined;
        [Symbol.iterator](): IterableIterator<T>;
        /** {@inheritDoc IWritableList.clone} */
        clone(): this;
        /** {@inheritDoc ISparseList.getMaxCoords} */
        getMaxCoords(): RunCoords | null;
        /** {@inheritDoc ISparseList.getCount} */
        getCount(): number;
        /** {@inheritDoc ISparseList.getRunsCount} */
        getRunsCount(): number;
        get [Symbol.toStringTag](): string;
    }
    /**
     * {@inheritDoc SparseList}
     * @see
     * ### **Interface**
     *
     * {@link SparseList}
     */
    export namespace SparseList {
        /**
         * For constructing a SparseList.
         */
        interface ConstructorOptions {
            /**
             * If not specified then unlimited bounds.
             *
             * @defaultValue undefined
             */
            maxCoords?: RunCoords;
            /**
             * @defaultValue 4
             */
            nodeSize?: number;
        }
    }
}
declare module "collections/RBush" {
    /**
     * * RBush, QuickSelect
     * * Copied from https://github.com/mourner/rbush
     * * MIT License
     * * Copyright (c) 2024 Volodymyr Agafonkin
     */
    export interface BBox {
        minX: number;
        minY: number;
        maxX: number;
        maxY: number;
    }
    export class RBush<T = BBox> {
        protected _maxEntries: number;
        protected _minEntries: number;
        protected data: any;
        /**
         * Constructs an `RBush`, a high-performance 2D spatial index for points and
         * rectangles. Based on an optimized __R-tree__ data structure with
         * __bulk-insertion__ support.
         *
         * @param maxEntries An optional argument to RBush defines the maximum
         *                   number of entries in a tree node. `9` (used by default)
         *                   is a reasonable choice for most applications. Higher
         *                   value means faster insertion and slower search, and
         *                   vice versa.
         */
        constructor(maxEntries?: number);
        /**
         * Returns all items contained in the tree.
         */
        all(result?: T[]): T[];
        isEmpty(): boolean;
        /**
         * Returns an array of data items (points or rectangles) that the given
         * bounding box intersects.
         *
         * Note that the search method accepts a bounding box in `{minX, minY, maxX,
         * maxY}` format regardless of the data format.
         *
         * @param box The bounding box in which to search.
         */
        search(box: BBox, results?: T[]): T[];
        /**
         * Returns `true` if there are any items intersecting the given bounding
         * box, otherwise `false`.
         *
         * @param box The bounding box in which to search.
         */
        collides(box: BBox): boolean;
        /**
         * Bulk-inserts the given items into the tree.
         *
         * Bulk insertion is usually ~2-3 times faster than inserting items one by
         * one. After bulk loading (bulk insertion into an empty tree), subsequent
         * query performance is also ~20-30% better.
         *
         * Note that when you do bulk insertion into an existing tree, it bulk-loads
         * the given data into a separate tree and inserts the smaller tree into the
         * larger tree. This means that bulk insertion works very well for clustered
         * data (where items in one update are close to each other), but makes query
         * performance worse if the data is scattered.
         *
         * @param items The items to load.
         */
        load(items: readonly T[]): RBush<T>;
        /**
         * Inserts an item. To insert many items at once, use `load()`.
         *
         * @param item The item to insert.
         */
        insert(item: T): RBush<T>;
        /**
         * Removes all items.
         */
        clear(): RBush<T>;
        /**
         * Removes a previously inserted item, comparing by reference.
         *
         * To remove all items, use `clear()`.
         *
         * @param item The item to remove.
         * @param equals A custom function that allows comparing by value instead.
         *               Useful when you have only a copy of the object you need
         *               removed (e.g. loaded from server).
         */
        remove(item: T, equals?: (a: T, b: T) => boolean): RBush<T>;
        /**
         * Returns the bounding box for the provided item.
         *
         * By default, `RBush` assumes the format of data points to be an object
         * with `minX`, `minY`, `maxX`, and `maxY`. However, you can specify a
         * custom item format by overriding `toBBox()`, `compareMinX()`, and
         * `compareMinY()`.
         *
         * @example
         * class MyRBush<T> extends RBush<T> {
         *   toBBox([x, y]) { return { minX: x, minY: y, maxX: x, maxY: y }; }
         *   compareMinX(a, b) { return a.x - b.x; }
         *   compareMinY(a, b) { return a.y - b.y; }
         * }
         * const tree = new MyRBush<[number, number]>();
         * tree.insert([20, 50]); // accepts [x, y] points
         *
         * @param item The item whose bounding box should be returned.
         */
        toBBox(item: T): BBox;
        /**
         * Compares the minimum x coordinate of two items. Returns -1 if `a`'s
         * x-coordinate is smaller, 1 if `b`'s x coordinate is smaller, or 0 if
         * they're equal.
         *
         * By default, `RBush` assumes the format of data points to be an object
         * with `minX`, `minY`, `maxX`, and `maxY`. However, you can specify a
         * custom item format by overriding `toBBox()`, `compareMinX()`, and
         * `compareMinY()`.
         *
         * @example
         * class MyRBush<T> extends RBush<T> {
         *   toBBox([x, y]) { return { minX: x, minY: y, maxX: x, maxY: y }; }
         *   compareMinX(a, b) { return a.x - b.x; }
         *   compareMinY(a, b) { return a.y - b.y; }
         * }
         * const tree = new MyRBush<[number, number]>();
         * tree.insert([20, 50]); // accepts [x, y] points
         *
         * @param a The first item to compare.
         * @param b The second item to compare.
         */
        compareMinX(a: T, b: T): number;
        /**
         * Compares the minimum y coordinate of two items. Returns -1 if `a`'s
         * x-coordinate is smaller, 1 if `b`'s x coordinate is smaller, or 0 if
         * they're equal.
         *
         * By default, `RBush` assumes the format of data points to be an object
         * with `minX`, `minY`, `maxX`, and `maxY`. However, you can specify a
         * custom item format by overriding `toBBox()`, `compareMinX()`, and
         * `compareMinY()`.
         *
         * @example
         * class MyRBush<T> extends RBush<T> {
         *   toBBox([x, y]) { return { minX: x, minY: y, maxX: x, maxY: y }; }
         *   compareMinX(a, b) { return a.x - b.x; }
         *   compareMinY(a, b) { return a.y - b.y; }
         * }
         * const tree = new MyRBush<[number, number]>();
         * tree.insert([20, 50]); // accepts [x, y] points
         *
         * @param a The first item to compare.
         * @param b The second item to compare.
         */
        compareMinY(a: T, b: T): number;
        /**
         * Exports the tree's contents as a JSON object.
         *
         * Importing and exporting as JSON allows you to use RBush on both the
         * server (using Node.js) and the browser combined, e.g. first indexing the
         * data on the server and and then importing the resulting tree data on the
         * client for searching.
         *
         * Note that the `maxEntries` option from the constructor must be the same
         * in both trees for export/import to work properly.
         */
        toJSON(): any;
        /**
         * Imports previously exported data into the tree (i.e., data that was
         * emitted by `toJSON()`).
         *
         * Importing and exporting as JSON allows you to use RBush on both the
         * server (using Node.js) and the browser combined, e.g. first indexing the
         * data on the server and and then importing the resulting tree data on the
         * client for searching.
         *
         * Note that the `maxEntries` option from the constructor must be the same
         * in both trees for export/import to work properly.
         *
         * @param data The previously exported JSON data.
         */
        fromJSON(data: any): RBush<T>;
        protected _all(node: any, result: any[]): any[];
        protected _build<T>(items: T[], left: number, right: number, height: number): any;
        protected _chooseSubtree(bBox: BBox, node: any, level: number, path: any[]): any;
        protected _insert(item: T, level: number, isNode?: boolean): void;
        protected _split(insertPath: any[], level: number): void;
        protected _splitRoot(node: any, newNode: any): void;
        protected _chooseSplitIndex(node: any, m: number, M: number): number;
        protected _chooseSplitAxis(node: any, m: number, M: number): void;
        protected _allDistMargin(node: any, m: number, M: number, compare: (a: any, b: any) => number): number;
        protected _adjustParentBBoxes(bBox: BBox, path: any[], level: number): void;
        protected _condense(path: any[]): void;
    }
    /**
     * Rearranges items so that all items in the [left, k] are the smallest.
     * The k-th element will have the (k - left + 1)-th smallest value in [left, right].
     *
     * @template T
     * @param {T[]} arr the array to partially sort (in place)
     * @param {number} k middle index for partial sorting (as defined above)
     * @param {number} [left=0] left index of the range to sort
     * @param {number} [right=arr.length-1] right index
     * @param {(a: T, b: T) => number} [compare = (a, b) => a b] compare function
     */
    export function quickSelect<T>(arr: T[], k: number, left?: number | undefined, right?: number | undefined, compare?: ((a: T, b: T) => number) | undefined): void;
}
declare module "collections/SpatialMap" {
    import { RangeCoords, Direction } from '@sheetxl/utils';
    import { ISpatialMap } from "collections/ISpatialMap";
    interface Group<T = any> {
        entries?: InternalEntry<T>[];
        uuid?: string;
        offset?: number;
    }
    interface InternalEntry<T = any> extends ISpatialMap.Entry<T> {
        group?: Group<T>;
        timeStamp?: number;
    }
    /**
     * The default implementation for {@link ISpatialMap}
     */
    export class SpatialMap<T = any> implements ISpatialMap<T> {
        private _shared;
        private _rTree;
        private _cloneKey;
        private _options;
        private _lastMiss;
        private _lastSingle;
        private _lastSingleResult;
        constructor(options?: ISpatialMap.ConstructorOptions<T>);
        /** {@inheritDoc ISpatialMap.visitRanges} */
        visitRanges(range: RangeCoords, visitor: ISpatialMap.Visitor<T>, sort?: Direction): void;
        /** {@inheritDoc ISpatialMap.getBoundingCoords} */
        getBoundingCoords(): RangeCoords;
        /** {@inheritDoc ISpatialMap.size} */
        size(): number;
        /** {@inheritDoc ISpatialMap.isEmpty} */
        isEmpty(): boolean;
        /** {@inheritDoc ISpatialMap.search} */
        search(range: RangeCoords, fullyContained?: boolean, results?: ISpatialMap.Entry<T>[]): ISpatialMap.Entry<T>[];
        /** {@inheritDoc ISpatialMap.has} */
        has(range: RangeCoords): boolean;
        /** {@inheritDoc ISpatialMap.all} */
        all(results?: ISpatialMap.Entry<T>[]): ISpatialMap.Entry<T>[];
        /** {@inheritDoc ISpatialMap.shift} */
        shift(options: ISpatialMap.ShiftOptions<T>): this;
        /** {@inheritDoc ISpatialMap.insertNonOverlapping} */
        insertNonOverlapping(range: ISpatialMap.Entry<T>, options?: ISpatialMap.InsertNonOverlappingOptions<T>): this;
        /** {@inheritDoc ISpatialMap.insertGroup} */
        insertGroup(entries: ISpatialMap.Entry<T>[], groupId?: string): this;
        /** {@inheritDoc ISpatialMap.createCopiedEntries} */
        createCopiedEntries(from: RangeCoords, to: RangeCoords, options?: ISpatialMap.CopyOptions, reuseInserts?: ISpatialMap.Entry<T>[], reuseRemoves?: ISpatialMap.Entry<T>[]): ISpatialMap.Updates;
        /**
         * Insert and removes nodes that contained with a group.
         *
         * @param groupsByGroupId Groups by the id of the group
         * @param entriesByEntryId Amendments by the original id
         *
         * @remarks
         * * This logic visits all group entries and ensures all entries are update and removed so that all group entries items are the same instance.
         */
        protected _updateGroupedEntries(groupsByGroupId: Map<string, Group>, entriesByEntryId: Map<string, ISpatialMap.Entry<T>[] | null>): void;
        private _copy;
        private _updateNodes;
        private _mergeNodes;
        private _getReadTree;
        private _ensureWritable;
        /**
         * entries is a special performance optimization to allow a single bulk load.
         */
        private _getWritableTree;
        /** {@inheritDoc ISpatialMap.remove} */
        remove(item: ISpatialMap.Entry<T>, equals?: (a: ISpatialMap.Entry<T>, b: ISpatialMap.Entry<T>) => boolean): this;
        /** {@inheritDoc ISpatialMap.insert} */
        insert(item: ISpatialMap.Entry<T>): this;
        /** {@inheritDoc ISpatialMap.load} */
        load(items: ReadonlyArray<ISpatialMap.Entry<T>>): this;
        /** {@inheritDoc ISpatialMap.clear} */
        clear(): this;
        /** {@inheritDoc ISpatialMap.clone} */
        clone(cloneKey?: any): this;
        fromJSON(json: any): ISpatialMap<T>;
    }
}
declare module "collections/_SpatialUtils" {
    import { RangeCoords, RangeOrientation, RangeOrientations } from '@sheetxl/utils';
    import { ISpatialMap } from "collections/ISpatialMap";
    /**
     * Expands the range size in each direction.
     */
    export const expandRange: (range: RangeCoords, maxRange?: RangeCoords, colAmount?: number, rowAmount?: number) => RangeCoords;
    /**
     * Returns the original range split by the intersecting range.
     *
     * @param orig The original RangeCoordValue node.
     * @param inter The intersecting range.
     *
     * @remark
     * * The last value is always the intersecting range.
     * * If there is no intersect then null is returned. If it is completely contained it will return a 1 value.
     * * All range coords values contain the values from the original splits
     */
    export function splitIntersect<T = any>(orig: ISpatialMap.Entry<T>, inter: RangeCoords, getSplit?: (orig: ISpatialMap.Entry<T>, coords: [RangeCoords, RangeCoords], orientation: RangeOrientation, offset: number) => [ISpatialMap.Entry<T>, ISpatialMap.Entry<T>], updateLastId?: boolean): ISpatialMap.Entry<T>[];
    /**
     * Create a set of non overlapping ranges from a set of existing ranges.
     *
     * * **IMPORTANT** - The original nodes also split during insertion.
     *
     * @remarks
     * - The original entries are assume to already not have overlapping ranges but are not
     *   required to be aligned.
     * - Will create equal size rectangles to allow for intersecting.
     * - Does not make an effort to return the fewest nodes possible.
     * - Does not merge splits; use {@link removeOverlapsAndMerge} or {@link fastMerge}.
     *
     * The steps to do this are:
     * 1. Splits original nodes by the insert node.
     * 2. Splits the insert node by the split original nodes. (it may split into smaller nodes that the split originals)
     * 3. Tries to intersect.
     * 3.  a. the the intersect is not the same size then the original is too large so we split the original again
     *        and intersect just the parts that match.
    
     */
    export function convertToNonOverlappingRanges<T>(original: ISpatialMap.Entry<T>[], insert: ISpatialMap.Entry<T>, options: ISpatialMap.UpdateEntryOptions<T>): ISpatialMap.Entry<T>[];
    /**
     * Attempts to merge ranges that are guaranteed to not overlap. For overlapping ranges use {@link removeOverlapsAndMerge}.
     *
     *
     * @defaultValue '2'.
     *
     * @remarks
     * * Setting to '0' will remove overlaps but not attempt to merge.
     * * Setting to '1' will remove overlaps in the initial orientation.
     * * Setting to '2' will remove most overlaps but may miss overlaps that resulted from the previous iterations.
     * * Setting to 'Number.MAX_SAFE_INTEGER' will run until no more ranges can be merged.
     */
    export function fastMerge(ranges: RangeCoords[], orientation?: RangeOrientation, iterations?: number, getMerge?: (from: [RangeCoords, b: RangeCoords], destination: RangeCoords, orientation: RangeOrientation) => RangeCoords | null | undefined, reuseArray?: [null, null]): RangeCoords[];
    /**
     * Simplifies ranges that overlap and merges them.
     *
     * This algorithm will continue merging until no more merges can be made. For large data this can be slow
     *
     * Useful for operations like count where you don't want to double count selections.
     */
    export const removeOverlapsAndMerge: (ranges: readonly RangeCoords[], iterations?: number, orientation?: RangeOrientation, getMerge?: (from: [RangeCoords, b: RangeCoords], destination: RangeCoords, orientation: RangeOrientation) => RangeCoords | null | undefined, onOverlap?: (intersection: RangeCoords, overlaps: RangeCoords[]) => void, reuseArray?: [null, null]) => RangeCoords[];
    export function delegatingNodeSplitter<T>(from: ISpatialMap.Entry<T>, destination: [ISpatialMap.Entry<T>, ISpatialMap.Entry<T>], orientation: RangeOrientation, offset: number): [ISpatialMap.Entry<T>, ISpatialMap.Entry<T>];
    export function delegatingNodeMerger<T>(from: [ISpatialMap.Entry<T>, ISpatialMap.Entry<T>], destination: ISpatialMap.Entry<T>, orientation: RangeOrientation): ISpatialMap.Entry<T> | undefined;
    /**
     * If the two rectangles overlap in a way that would required them to be split.
     *
     * @remarks
     * This can be used for a single direction.
     * @param a
     * @param b
     */
    export const isSplitIntersect: (a: RangeCoords, b: RangeCoords, orientation?: RangeOrientations) => boolean;
    /**
     * Default implementation for {@link RangeShiftProcessor}.
     *
     * @param optionsProcess RangeShiftOptions
     * @param splitExpand Used to tell the ranges not to shift but instead to split when shifting.
     * @returns Either new RangeNodes or null if the shifted resulted in a delete. (left/up more than size of before)
     *
     * @remarks
     * * Will shift a range in a given direction.
     * * May result in either 0, 1, 2, or 3. Nodes.
     */
    export function defaultShiftProcessor<T>(before: ISpatialMap.Entry<T>, after: ISpatialMap.Entry<T>, optionsProcess: ISpatialMap.ShiftDetails<T>, getShifted: (orig: ISpatialMap.Entry<T>, after: ISpatialMap.Entry<T>, options: ISpatialMap.ShiftDetails<T>) => ISpatialMap.Entry<T> | undefined, getSplit: (orig: ISpatialMap.Entry<T>, coords: [RangeCoords, RangeCoords], orientation: RangeOrientation, offset: number) => [ISpatialMap.Entry<T>, ISpatialMap.Entry<T>], onShift: (options: ISpatialMap.ShiftDetails<T>) => void, splitExpand: boolean): ISpatialMap.Entry<T>[] | null;
    export const createCopiedSpatialEntries: <T = any>(spatial: ISpatialMap, coordsFrom: RangeCoords, coordsTo: RangeCoords, options?: ISpatialMap.CopyOptions, reuseInserts?: ISpatialMap.Entry<T>[], reuseRemoves?: ISpatialMap.Entry<T>[], onSplit?: (from: ISpatialMap.Entry<T>, destination: [ISpatialMap.Entry<T>, ISpatialMap.Entry<T>], orientation: RangeOrientation, offset: number) => [ISpatialMap.Entry<T>, ISpatialMap.Entry<T>] | null) => ISpatialMap.Updates;
    /**
     * Use to remove spills.
     *
     * @param spatial
     * @param range
     * @param cloneOnUpdate
     * @returns The original map or the cloned map if it removed any entries.
     */
    export const removeTopLeftEntries: <T = any>(spatial: ISpatialMap<T>, range: RangeCoords, cloneOnUpdate?: boolean) => ISpatialMap<T>;
}
declare module "collections/_GridUtils" {
    import { CellCoords, RangeCoords, RangeOrientation } from '@sheetxl/utils';
    import { Tuple } from "collections/Tuple";
    import { IGrid } from "collections/IGrid";
    import { ISpatialMap } from "collections/ISpatialMap";
    /**
     * Return a range as an in the correct major/minor orientation.
     *
     * If maxRange is provided then this will also validate
     * and throw an `OutOfBoundsError`.
     *
     * @remarks
     * This reuses the same OrientationBounds.
     */
    export const orientAndValidateReused: (colStart: number, rowStart: number, colEnd: number, rowEnd: number, isColumn: boolean, maxRange?: RangeCoords, dataRange?: RangeCoords) => Tuple.OrientatedCoords;
    export const unOrientCoords: (oriented: Tuple.OrientatedCoords, isColumn: boolean, reuseCoords?: RangeCoords) => RangeCoords;
    /**
     * Creates an iterator results.
     *
     * @param majorIndex The index for major value.
     * @param minorIndex The index for minor value.
     * @param value -The Value.
     * @param isColumn The results are in absolute orientation so we need to convert back
     * @param reuseResult If provided this will not create a new object.
     * @returns an {@link IGrid.EntryIteratorResult} that can be provide to the client.
     * @see
     * {@link IGrid.IteratorOptions.reuseResult}
     */
    export const createEntryIteratorResults: <T>(majorIndex: number, minorIndex: number, value: T, isColumn: boolean, reuseResult?: IGrid.EntryIteratorResult<T>) => IGrid.EntryIteratorResult<T>;
    /**
     * Simple util that converts a boolean to a the global value or undefined.
     * @param reuseResult The client provided input
     */
    export const toReusableEntryResult: <T>(reuseResult: boolean | IGrid.EntryIteratorResult<T>) => IGrid.EntryIteratorResult<T>;
    /**
     * Sort by first index.
     */
    export const validateTupleOffsets: <T>(tuples: [number, T][]) => void;
    /**
     * Sort by first index.
     */
    export const sortTupleOffset: <T>(a: [number, T], b: [number, T]) => number;
    /**
     * Iterator Options.
     */
    export interface EmptyIteratorOptions extends Omit<IGrid.IteratorOptions, 'bounds'> {
        /**
         * Required for the iterator to work correctly.
         */
        bounds: RangeCoords;
        /**
         * Setting skipMajors to `true` will have the EmptyIterator only visit empty minors.
         * @remarks
         * We don't have a skipMinors then empty majors would have to be skipped as well and then
         * the EmptyIterator should not be used.
         */
        skipMajors?: boolean;
    }
    /**
     * Visits an iterator and creates additional iterations for any missing gaps.
     * Accounts for hidden and reverse.
     * @remarks
     * It is VERY important that the delegate iterator increments in the same order (not reversed).
     *
     * Unlike IGridIterator options Bounds is required.
     *
     */
    export class EmptyIterator<T = any, TReturn = any> implements Iterator<T, TReturn, CellCoords> {
        private _delegate;
        private _isColumn;
        private _isReverse;
        private _skipMajors;
        private _majorMin;
        private _majorMax;
        private _minorMin;
        private _minorMax;
        private _majorIndex;
        private _minorIndex;
        private _delegateResult;
        private _delegateMajorIndex;
        private _delegateMinorIndex;
        private _processMajorSkip;
        private _processMinorSkip;
        constructor(delegate: Iterator<T, TReturn, CellCoords>, options: EmptyIteratorOptions);
        private _initialize;
        /**
         * Returns the next iterator.
         */
        next(cell?: CellCoords): IteratorResult<T>;
        return(_value?: TReturn): IteratorResult<T, TReturn>;
        throw(_e?: any): IteratorResult<T, TReturn>;
        [Symbol.iterator](): IterableIterator<T>;
    }
    /**
     * Options for RepeatingIterator.
     */
    export type RepeatIteratorOptions<T = any, TReturn = any> = {
        /**
         * The delegate.
         */
        delegate: Iterator<[CellCoords, T], TReturn, CellCoords>;
        /**
         * Required - This must match the bounds of the Delegate iterator.
         */
        bounds: RangeCoords;
        /**
         * Required - This much be larger than the bounds.
         */
        dims: {
            major: number;
            minor: number;
        };
        /**
         * Optional
         * @remarks
         * This can be different than the delegate but then the bounds and dim need to be manually
         * transposed by the caller.
         */
        orientation?: RangeOrientation;
        /**
         * @see
         * {@link IGrid.IteratorOptions.reuseResult}
         */
        reuseResult?: boolean | IGrid.EntryIteratorResult<T>;
    };
    /**
     * Visits an iterator and will creates additional iterations to fill the new bounding area.
     * @remarks
     * This iterator creates a temporary copy of the first values to repeat.
     *
     * * delegate iterator bounds must not be larger than dimension.
     * * reverse is currently not implemented.
     */
    export class RepeatingIterator<T = any, TReturn = any> implements Iterator<[CellCoords, T], TReturn, CellCoords> {
        private _isColumn;
        private _majorSize;
        private _minorSize;
        private _majorMin;
        private _majorMax;
        private _minorMin;
        private _minorMax;
        private _delegate;
        private _nextDelegateResult;
        private _nextResult;
        private _majorIndex;
        private _minorIndex;
        private _minorSpan;
        private _minorOffset;
        private _minorRepeat;
        private _majorOffset;
        private _majorRepeat;
        private _pattern;
        constructor(options: RepeatIteratorOptions);
        private _initialize;
        /**
         * Returns the next iterator.
         */
        next(cell?: CellCoords): IteratorResult<[CellCoords, T]>;
        return(_value?: TReturn): IteratorResult<[CellCoords, T], TReturn>;
        throw(_e?: any): IteratorResult<[CellCoords, T], TReturn>;
        [Symbol.iterator](): IterableIterator<[CellCoords, T]>;
    }
    /**
     * Takes 2 iterators and returns the first one. In the event there is a 'tie' the first value will be returned.
     */
    export class RacingIterator<T = any, TReturn = any> implements Iterator<[CellCoords, T], TReturn, CellCoords> {
        private _iterator1;
        private _nextResult1;
        private _iterator2;
        private _nextResult2;
        private _onEqual;
        private _comparator;
        constructor(options: IGrid.IteratorOptions, iterator1: IGrid.EntryIterator<T>, iterator2: IGrid.EntryIterator<T>, onEqual?: (a: [CellCoords, T], b: [CellCoords, T]) => number);
        /**
         * Returns the next iterator.
         */
        next(cell?: CellCoords): IteratorResult<[CellCoords, T]>;
        return(_value?: TReturn): IteratorResult<[CellCoords, T], TReturn>;
        throw(_e?: any): IteratorResult<[CellCoords, T], TReturn>;
        [Symbol.iterator](): IterableIterator<[CellCoords, T]>;
    }
    /**
     * Takes 2 iterators and returns the them both in order. In the event there is a 'tie' they will be be returned.
     */
    export class RacingIterator2<T = any, TReturn = any> implements Iterator<[CellCoords, T, CellCoords, T], TReturn, CellCoords> {
        private _iterator1;
        private _nextResult1;
        private _iterator2;
        private _nextResult2;
        private _comparator;
        private _reuseResult;
        constructor(options: RacingIterator2Options, iterator1: IGrid.EntryIterator<T>, iterator2: IGrid.EntryIterator<T>);
        /**
         * Returns the next iterator.
         */
        next(cell?: CellCoords): IteratorResult<[CellCoords, T, CellCoords, T]>;
        return(_value?: TReturn): IteratorResult<[CellCoords, T, CellCoords, T], TReturn>;
        throw(_e?: any): IteratorResult<[CellCoords, T, CellCoords, T], TReturn>;
        [Symbol.iterator](): IterableIterator<[CellCoords, T, CellCoords, T]>;
    }
    export interface RacingIterator2Options extends IGrid.IteratorOptions {
        /**
         * A custom comparator.
         */
        comparator?: (a: CellCoords, b: CellCoords) => number;
    }
    export const MESSAGE_ERROR_REQUIRE_INT = "Tuple indices must be integers.";
    /**
     * Creates a tuple 2D tuple from a single value.
     *
     * @internal
     */
    export const valueToTuples: <T>(value: T | ((row: number, column: number) => T | null), ranges: Tuple.OrientatedCoords, isColumn: boolean) => Tuple.BoundedTuples<T>;
    /**
     * This is for the edge case where were have a GridTuple but need a bounds.
     * This will iterator through all majors comparing the first and last minor
     * to determine the bounds.
     *
     * @remarks
     * We do not use this.
     */
    export const calcTupleBounds: (gridTuples: Tuple.GridTuple) => Tuple.OrientatedCoords;
    /**
     * Creates an array of Tuple.GridTuple from a 2D array using {@link ITuple.IBuilder}.
     * This adds supports for max bounds and offsetting the indices.
     *
     * @remarks
     * For performance reasons this will not visit ths minor axis but will remove empty major axises.
     */
    export const array2DToTuples: <T>(array2d: T[][], transpose?: boolean, ranges?: Partial<Tuple.OrientatedCoords> | null, removeEmpty?: boolean) => Tuple.BoundedTuples<T>;
    export interface IConflatingRanges<T = any> {
        append: (major: number, minor: number, value?: T) => void;
        done: (merge?: boolean) => ISpatialMap.Entry<T>[];
    }
    /**
     * Returns api for incrementally building ranges against minor and optionally major.
     *
     * @remarks
     * * Assumes ordered writes.
     * * Allows for reusable ranges.
     */
    export const createConflatingRangeValue: <T = any>(isColumn?: boolean, canMerge?: (a: T, b: T, isColumn: boolean) => T) => IConflatingRanges;
}
declare module "collections/SparseGrid" {
    import { CellCoords, RangeCoords, Direction, RangeOrientation } from '@sheetxl/utils';
    import { Tuple } from "collections/Tuple";
    import { IReadableList } from "collections/IReadableList";
    import { IGrid } from "collections/IGrid";
    import { ISparseGrid } from "collections/ISparseGrid";
    /**
     * Implementation of {@link IGrid} that uses a ISparseList of ISparseList.
     */
    export class SparseGrid<T = any> implements ISparseGrid<T> {
        private _major;
        private _dataCoords;
        private _count;
        private _isColumn;
        private _lastMajor;
        private _lastMinorSpan;
        private _maxCoords;
        private _options;
        private _optionsMinor;
        private _isShared;
        private _createRun;
        constructor(options?: SparseGrid.ConstructorOptions);
        /**
         * Returns an IterableIterator over all the runs in the sparse grid.
         * Each run is a contiguous list of values in the grid.
         *
         * @returns An iterator that yields [majorIndex, minorIndex, IReadableList] entries
         */
        /** {@inheritDoc ISparseGrid.getMaxCoords} */
        getRuns(options?: ISparseGrid.RunIteratorOptions): ISparseGrid.RunIterableIterator<T>;
        /** {@inheritDoc IGrid.getOrientation} */
        getOrientation(): RangeOrientation;
        /** {@inheritDoc IGrid.entries} */
        entries(options?: IGrid.IteratorOptions): IGrid.EntryIterator<T>;
        /** {@inheritDoc IGrid.values} */
        values(options?: IGrid.IteratorOptions): IGrid.ValueIterator;
        /** {@inheritDoc IGrid.keys} */
        keys(options?: IGrid.IteratorOptions): IGrid.KeyIterator;
        private _updateMajorSpan;
        /** {@inheritDoc IGrid.setValues} */
        setValues(values: Tuple.GridTuple<T>): this;
        private _updateCountAndCoords;
        /** {@inheritDoc IGrid.clear} */
        clear(): void;
        /** {@inheritDoc IGrid.delete} */
        delete(range: RangeCoords | null): boolean;
        /** {@inheritDoc IGrid.shift} */
        shift(range: RangeCoords, direction: Direction): boolean;
        /** {@inheritDoc IGrid.getCount} */
        getCount(): number;
        /** {@inheritDoc IGrid.getValueAt} */
        getValueAt(row: number, column: number): T;
        /** {@inheritDoc IGrid.setValueAt} */
        setValueAt(row: number, column: number, value: T): void;
        /** {@inheritDoc IGrid.copyTo} */
        copyTo(destination: IGrid, topLeft: CellCoords, from: RangeCoords): void;
        /** {@inheritDoc IGrid.getCoords} */
        getCoords(): RangeCoords | null;
        /** {@inheritDoc IGrid.clone} */
        clone(cloneKey?: string): this;
        /** {@inheritDoc IGrid.cloneEmpty} */
        cloneEmpty(cloneKey?: string): this;
        /** {@inheritDoc IGrid.getMaxCoords} */
        getMaxCoords(): RangeCoords | null;
        get [Symbol.toStringTag](): string;
    }
    /**
     * {@inheritDoc SparseGrid}
     * @see
     * ### **Interface**
     *
     * {@link SparseGrid}
     */
    export namespace SparseGrid {
        /**
         * For constructing a SparseGrid.
         */
        interface ConstructorOptions<T = any> {
            /**
             * If not specified then unlimited bounds.
             * @defaultValue undefined
             */
            maxCoords?: Partial<RangeCoords>;
            /**
             * Determines the orientation that cells are visited.
             *
             * @defaultValue RangeOrientation.Column
             */
            orientation?: RangeOrientation;
            /**
             * Hook to allow for custom storing of contiguous values.
             *
             * @param values The values to wrap in a List.
             */
            createRun?: (values: T[]) => IReadableList<T>;
        }
    }
}
declare module "collections/MixedTypedArrayList" {
    import { IListLike } from "collections/IList";
    /**
     * Stores mixed value types in an ArrayBuffer or a SharedArrayBuffer.
     *
     * Enable more efficient storage of mixed types in a single array.
     * Supports fully shared between threads without copy.
     *
     * @remarks
     * * Implements {@link IListLike} so expects all values to be immutable.
     * * The currently implementation works only with numbers.
     * * Strings and SerializableJSON must save a reference. StringPool is recommended.
     */
    export class MixedTypedArrayList<T = any> implements IListLike<T> {
        private _l;
        private _at;
        private _dt;
        private _a32;
        private _a64;
        private _cv;
        private _vt;
        private _vi32;
        private _vi64;
        private _vf32;
        private _vf64;
        constructor(options: MixTypedArrayListConstructorOptions);
        /**
         * Returns constructor options that can used to recreate the MixedTypedArrayList.
         */
        getConstructorOptions(): MixTypedArrayListConstructorOptions;
        /** {@inheritDoc IListLike.at} */
        at(index: number): T | undefined;
        /** {@inheritDoc IListLike.toArray} */
        toArray(maxLength: number): T[];
        /** {@inheritDoc IListLike.length} */
        get length(): number;
        get [Symbol.toStringTag](): string;
        toString(): string;
        protected static _createArrayBuffer(length: number): ArrayBufferLike;
        /**
         * Creates a MixedTypedArrayList from an array.
         *
         * @param array The array to convert.
         * @param getCoercedKey A function that returns a key for a complex value.
         * @param getCoercedValue A function that returns a coerced value for a given key.
         * @param getCoerceType A function that returns a type for a given value.
         * @returns A MixedTypedArrayList.
         *
         * @remarks
         * - `getCoercedKey` will generally be a map id.
         */
        static fromArray<T = any>(array: T[], getCoercedKey?: (type: number, value: T) => number, getCoercedValue?: (type: number, key: number) => T, getCoerceType?: (value: T) => number, threshold64?: number): MixedTypedArrayList;
    }
    export interface MixTypedArrayListConstructorOptions<T = any> {
        /**
         * The length of the array.
         */
        length: number;
        /**
          * The array used for storing types.
          *
          * @remarks
          * This is the default type if types is not provided.
          */
        type: number;
        /**
         * The array used for storing types.
         *
         * @remarks
         * This must be a Uint8Array. This or type must be provided.
         */
        types?: ArrayBufferLike;
        /**
         * Stores 32bit values.
         *
         * @remarks
         * If this is not provided then all values stored in values64.
         * * Must be 32bit aligned
         */
        values32?: ArrayBufferLike;
        /**
         * Stores 64 bit overflow values or all 64 bit values if is64Bit is `true`.
         *
         * @remarks
         * * This behave different depending on if the values32 is provided.
         * * * values32 is provided - This stores 32 bit values and 32 bit references to 64 bit values.
         * * * values32 is NOT provided - Then this is used for all values and values32 is not used.
         * * Must be 64bit aligned
         */
        values64?: ArrayBufferLike;
        /**
         *
         * Returns a value for a given type The default implementation auto coerces ints/floats/boolean and 'null'.
         *
         * @param type An 8bit number. Will always be between 0 and 255.
         * @param key The key as either a 32bit or 64bit integer.
         * @returns Returns a coerced value.
         *
         * @remarks
         * This is used for returning string lookup, error lookup, or custom.
         */
        getCoercedValue?: (type: number, key: number) => T;
    }
    /**
     * Defines the list of Known valid type codes for a MixedTypedArrayList.
     *
     * @remarks
     * MixedTypedArray stores a type using an Uint8Array. The first
     * 127 bits are reserved for known types. The last 128-255 are
     * reserved for custom types.
     *
     * @see
     * {@link MixTypedArrayListConstructorOptions.coerceType}
     */
    export const KnownType: {
        readonly Null: 13;
        readonly Integer: 1;
        readonly Float: 2;
        readonly Boolean: 3;
        readonly Integer64: 4;
        readonly Float64: 5;
        readonly String: 6;
        readonly Error: 7;
        readonly PosInfinity: 8;
        readonly NegInfinity: 9;
        readonly NaN: 10;
        readonly MaxSafeInteger: 11;
        readonly MinSafeInteger: 12;
        readonly Undefined: 14;
        readonly Unknown: 127;
    };
    /**
     * Return a 8 bit int that represents the type to using in the type array.
     *
     * @param value The value of the type. Only the type is used
     * @param custom If provided this will be called if the type is not well known. Must return a value between '128' and '255'.
     * @returns a number representing a type between '0' and '255'.
     */
    export const getBuiltinCoerceType: <T = any>(value: T, custom?: (T: any) => number) => number;
}
declare module "collections/index" {
    export * from "collections/IReadableList";
    export * from "collections/IWritableList";
    export * from "collections/ISparseList";
    export * from "collections/ISortedMap";
    export * from "collections/IGrid";
    export * from "collections/ISparseGrid";
    export * from "collections/ISpatialMap";
    export * as IteratorUtils from "collections/IteratorUtils";
    export * from "collections/ImmutableList";
    export * from "collections/IList";
    export * from "collections/OverlappingRangeIterator";
    export * from "collections/SortedMap";
    export * from "collections/SparseGrid";
    export * from "collections/SparseList";
    export * from "collections/SpatialMap";
    export * from "collections/Tuple";
    export * from "collections/MixedTypedArrayList";
}
declare module "calculation/formula/IFormulaParser" {
    import type { IRange, Scalar, IFormulaContext } from '@sheetxl/primitives';
    import type { ICalcGraph } from "calculation/graph/index";
    /**
     * This interface defines how to create IFormulaBlocks.
     * Additionally, it provides a way to evaluate a formula
     */
    export interface IFormulaParser {
        /**
         * Parse a formula string. This generates a sharable formula.
         *
         * @param context The context use to evaluate
         * @param textA1 The formula text in A1 notation.
         */
        parse(context: IFormulaContext, textA1: string): ICalcGraph.IFormulaBlock;
        /**
         * Evaluate the formula using a given row and column.
         *
         * @param context The context use to evaluate
         * @param textA1 The formula text in A1 notation.
         *
         * @remarks
         * This is a convenience method that calls parse(textA1).evaluate(context).
         */
        eval(context: IFormulaContext, textA1: string): IRange | Scalar;
    }
}
declare module "utils/_RangeCoordUtils" {
    import { IRange } from '@sheetxl/primitives';
    /**
     * This is a more advanced use case of ranges that takes an array of ranges and uses an r-tree algo to
     * determine if the ranges intersects.
     *
     * @param ranges
     * @returns A flag indicating if any of the ranges intersect.
     */
    export const rangesArrayIntersect: (ranges: readonly IRange.Coords[]) => boolean;
    /**
     * Rolls a potential 2d array into a single array.
     * @param array
     *
     * @remarks
     * This is not recursive and only handles arrays of 2 levels deep.
     */
    export function flatten2DArray<T = any>(array: readonly T[]): T[];
    /**
     * converts a list of values into a 2D array.
     * Additional this takes an onVisit callback.
     */
    export const build2DArray: <T>(values: T[], width: number, onVisit?: (val: T) => T) => T[][];
    export const removeRangesWithOffsets: (ranges: IRange.Coords[], set: Set<number>) => IRange.Coords[];
    /**
     * Returns true if the outer span intersects the inner span.
     * @remarks
     * Assumes End is always greater than or equal to start.
     */
    export const isSplitSpan: (outerStart: number, outerEnd: number, innerStart: number, innerEnd: number) => boolean;
    /**
     * Returns true if the outer span encloses the inner span.
     * @remarks
     * Assumes isSplitSpan is false
     */
    export const isWithinSpan: (outerStart: number, outerEnd: number, innerStart: number, innerEnd: number) => boolean;
    /**
     * Returns true if the range intersections in an orientation.
     */
    export const isSplitRangeSpan: (outerRange: IRange.Coords, innerRange: IRange.Coords, isColumn: boolean) => boolean;
    /**
     * Subtract Range b from from a.
     *
     * @param range The range.
     * @param rangeToRemove The range to remove
     * @param orientation Determines the priority of the ranges
     *
     * @remarks
     * Will always return either 0 - 4 ranges.
     * * If no interaction then b will be returned.
     * * If beforeSplit === rangeToRemove then empty array is returned.
     */
    export const subtractRange: (beforeSplit: IRange.Coords, rangeToRemove: IRange.Coords, orientation?: IRange.Orientation) => IRange.Coords[];
    /**
     * Visit ranges looking to see if range intersects. If so then onOverlap will be called.
     * @param range
     * @param ranges
     * @param onOverlap
     */
    export const visitRangeIntersects: (ranges: IRange.Coords[], range: IRange.Coords, onOverlap: (range: IRange.Coords, isSplit: boolean, index: number) => void) => void;
    /**
     * Returns a CellCoords that is the top left.
     * @param range A RangeCoord to check.
     */
    export const topLeft: (range: IRange.Coords | undefined) => IRange.CellCoords;
    export const createColOffsetComparator: (aRange: IRange.Coords, bRange: IRange.Coords) => ((a: IRange.CellCoords, b: IRange.CellCoords) => number);
    export const createRowOffsetComparator: (aRange: IRange.Coords, bRange: IRange.Coords) => ((a: IRange.CellCoords, b: IRange.CellCoords) => number);
    /**
     * Determines the copy coordinates trying to find the lcm.
     */
    export const coordsLCM: (dest: IRange.Coords, // destination (for top,left)
    size: IRange.Coords, // source (for sizing)
    fit?: boolean, transpose?: boolean) => IRange.Coords;
}
declare module "collections/RepeatingList" {
    import { IList, IListLike } from "collections/IList";
    /**
     * Implements a virtual list {@link IListLike} by repeating the values of an underlying list.
     *
     * This is done to allow for compressions of values in memory.
     */
    export class RepeatingList<T> implements IList<T> {
        private _u;
        private _l;
        constructor(underlyingList: IListLike<T>, virtualLength: number);
        /** {@inheritDoc IListLike.at} */
        at(index: number): T | undefined;
        toArray(maxLength?: number): T[];
        /** {@inheritDoc IListLike.length} */
        get length(): number;
        get [Symbol.toStringTag](): string;
        /** {@inheritDoc IList.isIList} */
        get isIList(): true;
    }
}
declare module "address/AddressUtils" {
    import { IRange } from '@sheetxl/primitives';
    import { ICell } from "cell/index";
    import { ICellRanges } from "cellRange/index";
    /**
     * A string value that represents an invalid reference.
     */
    export const InvalidRef: string;
    export const rowToString: (row: number) => string;
    export const colToString: (col: number) => string;
    export const cellToString: CellToString;
    export const sheetCellToString: CellToString<IRange.FixableCellCoords>;
    export const sheetNameToString: (sheetName: string, defaultName?: string) => string;
    export const sheetAndRangeToString: (sheetName: string, rangeStr: string) => string;
    export const rangeToString: RangeToString<IRange.Coords, IRange.CellCoords>;
    export const fixableRangeToString2: (cell: Readonly<IRange.FixableCoords>, defaultSheetName: string, r1c1?: boolean) => string;
    export const fixableCellToString: (cell: Readonly<IRange.FixableCellCoords>, defaultSheetName: string, r1c1?: boolean) => string;
    /**
     * Duplicated rangeToString.
     * If we used the from/to range type we wouldn't have to.
     */
    export const fixableCellToA1: (cell: Readonly<IRange.FixableCellCoords>, defaultSheetName: string, toCellString?: CellToString<IRange.FixableCellCoords>) => string;
    /**
     * Duplicated rangeToString.
     * If we used the from/to range type we wouldn't have to.
     */
    export const sheetRangeToString: RangeToString<IRange.FixableCoords, IRange.FixableCellCoords>;
    /**
     * Convert a fixable cell to A1 format.
     *
     * @param fixable
     * @param defaultRange
     * @param toRangeString
     * @returns a string
     */
    export const sheetRangesToString: (fixable: readonly Partial<Readonly<IRange.FixableCoords>>[], defaultRange?: Readonly<IRange.Coords>, toRangeString?: RangeToString<IRange.FixableCoords, IRange.FixableCellCoords>) => string;
    /**
     * Workbook range still used IRange.FixableCellCoords.
     */
    export const fixableRangeToString: RangeToString<IRange.FixableCoords, IRange.FixableCellCoords>;
    export type CellToString<C extends IRange.CellCoords = IRange.CellCoords> = (cell: C) => string;
    export type RangeToString<R extends IRange.Coords = IRange.Coords, C extends IRange.CellCoords = IRange.CellCoords> = (range: Partial<R>, defaultRange?: R, toCellString?: CellToString<C>) => string;
    export type StringToCell = (str: string, allow1D?: boolean) => Partial<IRange.CellCoords>;
    export type StringToRange = (str: string, defaultRange?: IRange.Coords, allowR1C1?: boolean) => Partial<IRange.Coords>;
    /**
     * @param allow1D When parsing ranges that are row or columns we allow a single dimension.
     */
    export const stringToCell: StringToCell;
    /**
     * Decodes a cell address into a row and column index
     * @param str The string to parse
     * @param allow1D When parsing ranges that are row or columns we allow a single dimension.
     */
    export const stringToSheetCell: StringToCell;
    export const stringToFixableCell: StringToCell;
    export const stringToSheetRange: StringToRange;
    /**
     * This doesn't fail but will return null if unable to parse.
     */
    export const stringToWorkbookRange: StringToRange;
    /**
     * Parse a string into an array of coords.
     *
     * @param str The string to parse.
     * @param defaultRange The range to default from.
     * @param allow1D If R1C1 is allows **NOT IMPLEMENTED**
     */
    export const stringToCoordsArray: (str: string, defaultRange: Readonly<IRange.Coords>, allowR1C1: boolean, toRange?: StringToRange, toCell?: StringToCell) => (Partial<IRange.CellCoords | IRange.Coords> | string)[];
    /**
     * This is only used to persist arrays so the toStringRange does not use workbook.
     */
    export const coordsArrayToStringArray: (coords: readonly (Partial<IRange.Coords | IRange.CellCoords> | string)[], defaultRange?: Readonly<IRange.Coords>, toStringRange?: RangeToString, //fixableRangeToString,
    toStringCell?: CellToString) => string[];
    export const coordsArrayToString: (coords: readonly (Partial<IRange.Coords | IRange.CellCoords> | string)[], defaultRange?: Readonly<IRange.Coords>, toStringRange?: RangeToString, toStringCell?: CellToString) => string;
    export const rangesAddressToRangesCoords: <R extends IRange.Coords = IRange.Coords, C extends IRange.CellCoords = IRange.CellCoords>(address: ICellRanges.Address | ICell.Address, defaultRange: Readonly<R>, toRange?: StringToRange, onNoParse?: (coord: Partial<C | R> | string) => readonly R[], allowR1C1?: boolean) => R[];
    /** `Fast` just scans through each character. */
    export const fastStringToCell: (address: string, reuse?: IRange.CellCoords) => IRange.CellCoords;
    /**
     * `Creates a coords from a string with R1C1 notion.
     *
     * @remarks
     * This is 1 based and will return Number.MIN_SAFE_INTEGER if the row or col is not specified.
     */
    export const stringToSheetCellR1C1: (str: string, allow1D?: boolean, reuseCoord?: IRange.FixableCellCoords) => IRange.FixableCellCoords;
    /**
     * `Fast` just scans through each character.
     *
     * @remarks
     * This is 1 based and will return -1 if the row or col is not specified.
     */
    export const fasterStringToCell: (address: string, _reuse: IRange.FixableCellCoords) => IRange.FixableCellCoords;
    /** `Fast` just scans through each character. */
    export const fastStringToCol: (address: string) => number;
    /**
     * `Fast` decode ranges but has no error checking.
     * If does not support fixed cells, sheets, or partials. Useful
     * for reading from save strings.
     */
    export const fastStringToRange: (address: string, _reuse?: IRange.Coords) => IRange.Coords;
    /**
     *
     * @param cstr
     * @returns
     */
    /** Matches just the cell portion of a range */
    export const matchRangeString: (range: string, isR1C1?: boolean) => RegExpMatchArray;
    /**
     * Returns `true` is the string is a valid format for a cell address.
     *
     * @param address The address as a string.
     * @param maxRow The maximum row index.
     * @param maxCol The maximum column index.
     * @param isR1C1 If the address is in R1C1 format.
     */
    export const validateCellString: (address: string, maxRow?: number, maxCol?: number, isR1C1?: boolean) => boolean;
    export const resolveRelativeToA1: (tokens: (string | IRange.CellCoords)[], rowIndex: number, colIndex: number) => string;
    export const fixableCellToR1C1: (fixable: IRange.FixableCellCoords, defaultSheetName?: string) => string;
    export const toAbsoluteCellString: (fixable: IRange.FixableCellCoords, positionRow: number, positionCol: number) => string;
    /**
     * Returns absolute range
     */
    export const toAbsoluteRange: (fixable: IRange.FixableCoords, positionRow: number, positionCol: number, reuseRange?: IRange.FixableCoords) => IRange.FixableCoords;
    /**
     * Returns absolute cell
     */
    export const toAbsoluteCell: (fixable: IRange.FixableCellCoords, positionRow: number, positionCol: number, reuseRange?: IRange.FixableCellCoords) => IRange.FixableCellCoords;
    /**
     * Returns fixable ranges
     */
    export function adjustRelationalRange(fixable: IRange.FixableCoords, positionRow: number, positionCol: number, reuseRange?: IRange.FixableCoords): IRange.FixableCoords;
    /**
     * Creates a string that can be shared by replacing all addresses with '#REF#' with a single value.
     *
     * @param formula A formula string.
     * @param rowIndex The current row.
     * @param colIndex The current column.
     * @param normalize Uppercase and remove whitespace.
     *
     * @remarks
     * This is use for quick identification of formula blocks
     */
    export const normalizeA1ToR1C1: (formula: string, rowIndex: number, colIndex: number, tokens?: (string | IRange.FixableCellCoords)[]) => string;
}
declare module "primitives/Range" {
    import { IRange, Scalar, ScalarType } from '@sheetxl/primitives';
    import { Tuple, IGrid, ISparseGrid } from "collections/index";
    export class Range<T extends Scalar = Scalar> implements IRange<T> {
        protected _values: ISparseGrid<Scalar>;
        protected _coords: IRange.Coords;
        protected _type: ScalarType;
        protected _isLiteral: boolean;
        constructor(values: ISparseGrid<Scalar>, coords: IRange.Coords, type?: ScalarType, isLiteral?: boolean);
        /** @inheritdoc IRange.getValueAt */
        getValueAt<TS extends Scalar = T>(rowIndex: number, colIndex: number, options?: IRange.ValueOptions): TS;
        protected _applyBuilder(values: ISparseGrid<Scalar>, builder: Tuple.IBuilder, clone?: boolean): ISparseGrid<Scalar>;
        protected _cloneFromBuilder(builder: Tuple.IBuilder, options?: IRange.IteratorOptions, width?: number, height?: number): this;
        /** @inheritdoc IRange.forEach */
        forEach<TS extends Scalar = T, B = any>(callbackFn: (value: TS, coords: IRange.CellCoords, range: IRange<T>) => {
            break: B;
        } | void, options?: IRange.IteratorOptions): B | void;
        /** @inheritdoc IRange.reduce */
        reduce<TS extends Scalar = T>(callbackFn: (accumulator: TS, value: TS, coords: IRange.CellCoords, range: IRange<T>) => TS, initialValue: TS, options?: IRange.IteratorOptions): TS;
        /** @inheritdoc IRange.some */
        some<TS extends Scalar = T>(callbackFn: (value: TS, coords: IRange.CellCoords, range: IRange<T>) => boolean, options?: IRange.IteratorOptions): boolean;
        /** @inheritdoc IRange.every */
        every<TS extends Scalar = T>(callbackFn: (value: TS, coords: IRange.CellCoords, range: IRange<T>) => boolean, options?: IRange.IteratorOptions): boolean;
        /** @inheritdoc IRange.replace */
        replace<TS extends Scalar = T>(other: IRange | TS[][], coords?: IRange.CellCoords): this;
        /** @inheritdoc IRange.forEach */
        slice(coords: Partial<IRange.Coords>): this;
        /** @inheritdoc IRange.resize */
        resize(width: number, height: number, fillValue?: Scalar): this;
        protected _mergeIterators<T = Scalar>(that: Range, callbackFn?: (a: T, b: T, coords: IRange.CellCoords, range: IRange) => T, options?: IRange.IteratorOptions): Tuple.IBuilder;
        /** @inheritdoc IRange.intersect */
        intersect<TS extends Scalar = T>(other: IRange<T>, callbackFn?: (a: TS, b: TS, coords: IRange.CellCoords, range: IRange<T>) => TS, options?: IRange.IteratorOptions): this;
        /** @inheritdoc IRange.startIncrementalUpdates */
        startIncrementalUpdates<TS extends Scalar = T>(options?: IRange.StartUpdateOptions): IRange.IncrementalUpdater<TS>;
        /** @inheritdoc IRange.map */
        map<TS extends Scalar = T>(callbackFn: (value: TS, coords: IRange.CellCoords, range: IRange<T>) => TS, options?: IRange.IteratorOptions): this;
        /** @inheritdoc IRange.filter */
        filter<TS extends Scalar = T>(callbackFn: (value: TS, coords: IRange.CellCoords, range: IRange<T>) => boolean, options?: IRange.IteratorOptions): this;
        /** @inheritdoc IRange.broadcast */
        broadcast<TS extends Scalar = T>(other: IRange | TS, callbackFn: (a: TS, b: TS, coords: IRange.CellCoords, range: IRange<T>) => TS, options?: IRange.BroadcastOptions): this;
        protected _fill(values: IGrid, coords: IRange.Coords, value: Scalar): void;
        protected _validateCoords(coords: Partial<IRange.Coords>): void;
        /** @inheritdoc IRange.fill */
        fill(value: Scalar, coords?: Partial<IRange.Coords>): this;
        /** @inheritdoc IRange.empty */
        empty(): this;
        /** @inheritdoc IRange.flatten */
        flatten(options?: IRange.IteratorOptions): Scalar[];
        /** @inheritdoc IRange.fillEmpty */
        fillEmpty(value: Scalar, minWidth?: number, minHeight?: number): this;
        /** @inheritdoc IRange.transpose */
        transpose(): this;
        /** @inheritdoc IRange.values */
        values<T extends Scalar = Scalar>(options?: IRange.IteratorOptions): IterableIterator<T>;
        protected _createTupleBuilder(orientation?: IRange.Orientation): Tuple.IBuilder;
        /** @inheritdoc IRange.entries */
        entries<TS extends Scalar = T>(options?: IRange.IteratorOptions): IterableIterator<IRange.Entry<TS>>;
        protected _entries(options?: IRange.IteratorOptions & {
            reuseResult?: boolean;
        }): IGrid.EntryIterator<Scalar>;
        /** @inheritdoc IRange.getValues */
        getValues<TS extends Scalar = T>(options?: IRange.GetValuesOptions): TS[][];
        /** @inheritdoc IRange.toType */
        toType(type: ScalarType): this;
        /** @inheritdoc IRange.getWidth */
        getWidth(): number;
        /** @inheritdoc IRange.getHeight */
        getHeight(): number;
        /** @inheritdoc IRange.size */
        get size(): number;
        /** {@inheritDoc IRange.isLiteral} */
        isLiteral(): boolean;
        /** {@inheritDoc IRange.getScalarType} */
        getScalarType(): ScalarType;
        /** {@inheritDoc IRange[Symbol.iterator]} */
        [Symbol.iterator](): IterableIterator<Scalar>;
        get [Symbol.toStringTag](): string;
        /** {@inheritDoc IRange.toString} */
        toString(): string;
        /** @inheritdoc IRange.isIRange */
        get isIRange(): true;
    }
}
declare module "protection/IProtection" {
    import type { IListener } from "listener/index";
    /**
     * Interface representing the base protection functionality for both workbook and sheet protection.
     * This interface provides methods for locking, unlocking, and managing the protection state.
     */
    export interface IProtection<T, P extends IProtection.Properties, J extends IProtection.JSON> {
        /**
         * Locks the object (workbook or sheet or range) with the specified options and password.
         *
         * @param password The password required to unlock the object.
         * @param properties The properties to allow to remain unlocked.
         * @param algorithm The algorithm for encrypting the password.
         * @param spinCount The spin count for encrypting the password.
         * @returns The `IProtection` instance for method chaining.
         *
         * @remarks
         * By default all properties are locked but you can specify which properties to remain unlocked.
         */
        lock(properties?: Partial<P>, password?: string, algorithm?: string, spinCount?: number): Promise<IProtection<T, P, J>>;
        /**
         * Unlocks the object (workbook or sheet) using the provided password.
         *
         * @param password The password required to unlock the object.
         * @returns The `IProtection` instance for method chaining.
         *
         * @remarks
         * If the correct password is provided, protection is removed from the object.
         */
        unlock(password?: string): Promise<IProtection<T, P, J>>;
        /**
         * Temporarily disables protection with the provided password.
         *
         * @param password The password required to pause protection.
         * @returns The `IProtection` instance for method chaining.
         *
         * @remarks
         * This method allows temporarily pausing protection without permanently unlocking the object.
         * Use {@link resume} to restore protection.
         */
        pause(password?: string): Promise<IProtection<T, P, J>>;
        /**
         * Checks if the object is currently locked.
         *
         * @returns `true` if the object is locked, `false` otherwise.
         *
         * @remarks
         * This method returns `true` If the lock is active.
         */
        isLocked(): boolean;
        /**
         * Verifies if the provided password matches the current protection password.
         *
         * @param password The password to check against the current protection.
         * @returns `true` if the password is correct, `false` otherwise.
         *
         * @remarks
         * Use this method to validate the password before unlocking or modifying the protection settings.
         */
        checkPassword(password?: string): Promise<boolean>;
        /**
         * Returns true if the protection has a password.
         */
        hasPassword(): boolean;
        /**
         * Resumes protection that was previously paused.
         *
         * @returns The `IProtection` instance for method chaining.
         *
         * @remarks
         * This method restores protection after it was paused using the {@link pause} method.
         */
        resume(): IProtection<T, P, J>;
        /**
         * Checks if the object has a locked but is paused.
         *
         * @returns `true` if the object is locked but paused, `false` otherwise.
         */
        isPaused(): boolean;
        /**
         * If the element is protected as readonly.
         *
         * @remarks
         * Readonly is set cannot be changed.
         */
        isReadOnly(): boolean;
        /**
         * Add Listeners.
         *
         * @see
         * {@link IListener.ISource.addListeners}
         */
        addListeners(listeners: IProtection.IListeners, options?: IListener.Options): IListener.Remove;
        toJSON(): IProtection.JSON;
    }
    /**
     * {@inheritDoc IProtection}
     * @see
     * ### **Interface**
     *
     * {@link IProtection}
     */
    export namespace IProtection {
        interface Events<T, P, J> {
            /**
             * Called when the protection has changed collections has changed have changed.
             */
            onChange?(source: IProtection<T, P, J>): void;
            /**
             * Called when the protection has changed collections has changed have changed.
             */
            onLockChange?(source: IProtection<T, P, J>): void;
        }
        interface IListeners extends IListener.Callbacks<IProtection<any, any, any>, IProtection.Events<any, any, any>> {
        }
        interface Properties {
        }
        interface JSON extends Properties {
            /**
             * If this is specified then a password will be requested to unlock.
             * If this is an empty object this indicates the object has been locked but without a password
             */
            password?: Partial<IProtection.EncryptedPassword>;
            identities?: IProtection.IdentityProvider[];
        }
        /**
         * Represents a locally stored encrypted password.
         *
         * @see
         * * {@link https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.presentation.modificationverifier?view=openxml-2.8.1}
         */
        interface EncryptedPassword {
            /**
             * The hashed value that was generated during the protection process.
             * This value is typically derived from the combination of a password and a salt.
             */
            hash: string;
            /**
             * The salt value that was used during the protection process.
             * The salt is combined with the password to produce the hash, adding an additional layer of security.
             */
            salt: string;
            /**
             * The name of the hash algorithm to be used.
             * Common values include `SHA-256`, `SHA-384`, and `SHA-512`.
             *
             * @defaultValue `SHA-512`
             */
            algorithm?: string;
            /**
             * The number of iterations (also known as spin count) used during the hash computation process.
             * A higher number increases the security by making brute-force attacks more difficult but also increases computation time.
             *
             * @defaultValue `100000`.
             */
            spinCount?: number;
        }
        /**
         * **PLACEHOLDER** - Will integrate into the user identity system.
         */
        interface IdentityProvider {
            /**
             * Optional setting to specify the relative security descriptor.
             *
             * The descriptor defines user accounts who may edit this range without providing a password to access the range. Removing this attribute shall
             * remove all permissions granted or denied to users for this range.
             */
            descriptor: string;
        }
    }
}
declare module "workbook/protection/IWorkbookProtection" {
    import { IProtection } from "protection/IProtection";
    /**
     * Interface representing protection settings for a workbook.
     * This interface allows for getting and setting passwords,
     * managing structure and window locks, and handling revision protection.
     */
    export interface IWorkbookProtection extends IProtection<IWorkbookProtection, IWorkbookProtection.Properties, IWorkbookProtection.JSON> {
        /**
         * Checks if the workbook structure is locked.
         * Locking the structure prevents changes like adding or deleting sheets.
         *
         * @returns `true` if the structure is locked, `false` otherwise.
         */
        isStructureAllowed(): boolean;
        /**
         * Checks if workbook windows are locked.
         * Locking the windows prevents changes to window position and size.
         *
         * @returns `true` if windows are locked, `false` otherwise.
         */
        isWindowsAllowed(): boolean;
        /**
         * Checks if workbook revisions are locked.
         * Locking revisions prevents changes to the workbook without the revision password.
         *
         * @returns `true` if revisions are locked, `false` otherwise.
         */
        isRevisionAllowed(): boolean;
    }
    /**
     * {@inheritDoc IWorkbookProtection}
     * @see
     * ### **Interface**
     *
     * {@link IWorkbookProtection}
     */
    export namespace IWorkbookProtection {
        interface IListener {
            /**
             * Called when the protection has changed collections has changed have changed.
             */
            onChange?(source: IWorkbookProtection): void;
        }
        interface Properties extends IProtection.JSON {
            revisionsPassword?: string;
            structure?: boolean;
            windows?: boolean;
            revision?: boolean;
        }
        interface JSON extends IProtection.JSON {
        }
    }
}
declare module "workbook/protection/index" {
    export * from "workbook/protection/IWorkbookProtection";
}
declare module "workbook/view/IWorkbookView" {
    import { IListener } from "listener/index";
    /**
     * View settings for a single workbook.
     *
     */
    export interface IWorkbookView {
        /**
         * Shows the visibility of the formula bar.
         */
        setShowFormulaBar(newValue: boolean): this;
        /**
         * @see {@link IWorkbookView.setShowFormulaBar}
         */
        isShowFormulaBar(): boolean;
        /**
         * Shows the workbook tabs.
         *
         * @defaultValue true;
        */
        setShowTabs(newValue: boolean): this;
        /**
         * @see {@link IWorkbookView.setShowTabs}
         */
        isShowTabs(): boolean;
        /**
         * Specifies ratio between the workbook tabs and the horizontal scroll bar.
         *
         * @defaultValue 600
         *
         * @remarks
         * This is expressed as a percent * 1000.
         */
        setTabRatio(newValue: number): this;
        /**
         * @see {@link IWorkbookView.setTabRatio}
         */
        getTabRatio(): number;
        /**
         * show the horizontal scrollbar.
         *
         * @defaultValue true
         */
        setShowHorizontalScrollbar(newValue: boolean): this;
        /**
         * @see {@link IWorkbookView.setShowHorizontalScrollbar}
         */
        isShowHorizontalScrollbar(): boolean;
        /**
         * Show the vertical scrollbar.
         *
         * @defaultValue true
         */
        setShowVerticalScrollbar(newValue: boolean): this;
        /**
         * @see {@link IWorkbookView.setShowVerticalScrollbar}
         */
        isShowVerticalScrollbar(): boolean;
        /**
         * Show the status bar.
         * @defaultValue true
         */
        setShowStatusBar(newValue: boolean): this;
        /**
         * @see {@link IWorkbookView.setShowStatusBar}
         */
        isShowStatusBar(): boolean;
        /**
         * The id of of the activeSheet.
         *
         * @remarks
         * This is NOT the index of the sheet but instead the id (1 based)
         * If the sheets have been reordered then these won't match.
         */
        setActiveSheetId(newValue: number | null): this;
        /**
         * @see {@link IWorkbookView.setActiveSheetId}
         */
        getActiveSheetId(): number | null;
        /**
         * Add Listeners.
         *
         * @see
         * {@link IListener.ISource.addListeners}
         */
        addListeners(listeners: IWorkbookView.IListeners, options?: IListener.Options): IListener.Remove;
        /**
         * Saves the current state to JSON.
         */
        toJSON(): IWorkbookView.JSON | null;
    }
    /**
     * {@inheritDoc IWorkbookView}
     * @see
     * ### **Interface**
     *
     * {@link IWorkbookView}
     */
    export namespace IWorkbookView {
        interface Events {
            /**
             * Called when the workbookView changes.
             *
             * @param source {@link IWorkbookView}
             */
            onViewChange?(source: IWorkbookView): void;
        }
        interface IListeners extends IListener.Callbacks<IWorkbookView, IWorkbookView.Events> {
        }
        interface ConstructorOptions {
            /**
             * The state to load
             */
            json?: IWorkbookView.JSON;
        }
        interface Properties {
            /** {@inheritDoc IWorkbookView.setShowFormulaBar} */
            showFormulaBar?: boolean;
            /** {@inheritDoc IWorkbookView.setShowTabs} */
            showTabs?: boolean;
            /** {@inheritDoc IWorkbookView.setTabRatio} */
            tabRatio?: number;
            /** {@inheritDoc IWorkbookView.setShowHorizontalScrollbar} */
            showHorizontalScrollbar?: boolean;
            /** {@inheritDoc IWorkbookView.setShowVerticalScrollbar} */
            showVerticalScrollbar?: boolean;
            /** {@inheritDoc IWorkbookView.setShowStatusBar} */
            showStatusBar?: boolean;
            /** {@inheritDoc IWorkbookView.setActiveSheetId} */
            activeSheetId?: number | null;
        }
        interface JSON extends Properties {
        }
    }
}
declare module "workbook/view/WorkbookView" {
    import { IListener } from "listener/index";
    import { IWorkbookView } from "workbook/view/IWorkbookView";
    import { ListenerEmitter } from "listener/ListenerEmitter";
    /**
     * Default Workbook View.
     */
    export class WorkbookView implements IWorkbookView {
        private _state;
        protected _emitter: ListenerEmitter<IWorkbookView, IWorkbookView.IListeners>;
        constructor(options?: IWorkbookView.ConstructorOptions);
        isShowFormulaBar(): boolean;
        setShowFormulaBar(newValue: boolean): this;
        isShowTabs(): boolean;
        setShowTabs(newValue: boolean): this;
        getTabRatio(): number;
        setTabRatio(newValue: number): this;
        isShowHorizontalScrollbar(): boolean;
        setShowHorizontalScrollbar(newValue: boolean): this;
        isShowVerticalScrollbar(): boolean;
        setShowVerticalScrollbar(newValue: boolean): this;
        isShowStatusBar(): boolean;
        setShowStatusBar(newValue: boolean): this;
        getActiveSheetId(): number;
        setActiveSheetId(newValue: number): this;
        /** {@inheritDoc IWorkbookView.addListeners} */
        addListeners(listeners: IWorkbookView.IListeners, options?: IListener.Options): IListener.Remove;
        toJSON(): IWorkbookView.JSON;
        protected _fromJSON(json: IWorkbookView.JSON, notify?: boolean): void;
        update(view: Partial<IWorkbookView.Properties>, notify?: boolean): void;
    }
}
declare module "workbook/view/index" {
    export * from "workbook/view/IWorkbookView";
    export * from "workbook/view/WorkbookView";
}
declare module "workbook/IWorkbook" {
    import type { IRange } from '@sheetxl/primitives';
    import type { ITransaction } from "transaction/index";
    import type { IListener } from "listener/index";
    import type { IResourceCollection, IResource } from "resource/index";
    import type { IStringCollection } from "string/index";
    import type { ICalculation } from "calculation/index";
    import type { IScript, IModule } from "script/index";
    import type { ICell } from "cell/index";
    import type { ICellRange, ICellRanges } from "cellRange/index";
    import type { IComment } from "comment/index";
    import type { INamedCollection } from "named/index";
    import type { ITheme } from "theme/index";
    import type { IStyleCollection } from "style/index";
    import type { ISheet, ISheetCollection, ICellContainerOptions } from "sheet/index";
    import type { IWorkbookView } from "workbook/view/index";
    import type { IWorkbookProtection } from "workbook/protection/index";
    /**
     * An `IWorkbook` represents a collection of {@link ISheet | sheets}, along with shared resources.
     *
     * This interface provides methods for accessing its elements and event handling.
     *
     * @remarks
     * Most interactions with a {@link IWorkbook | workbook} or {@link ISheet | sheet} are done through a
     * {@link ICellRange | workbook range}.
     *
     * @see
     * * {@link getRange} - For interacting with cell values and formatting on a single {@link ISheet | sheet}.
     * * {@link getSheets} - For managing {@link ISheet | sheet}.
     * * {@link getNames} - For managing items with defined names.
     */
    export interface IWorkbook extends ITransaction.ITransactional, IListener.ISource<IWorkbook, IWorkbook.IListeners> {
        /**
         * Returns the collection of sheets within the workbook.
         */
        getSheets(): ISheetCollection;
        /**
         * Adds a new sheet to the workbook.
         *
         * @remarks
         * This is a convenience method that wraps `getSheets().add`.
         */
        addSheet(options?: ISheetCollection.AddOptions | string | number): ISheet;
        /**
         * Returns the sheet at the given offset.
         *
         * @param index A 0-based index of the sheet.
         * @param visibility The visibility of the sheet.
         */
        getSheetAt(index: number, visibility?: ISheet.Visibility): ISheet;
        /**
         * Returns the sheet for the given name.
         *
         * @param name The name of the sheet.
         * @param visibility The visibility of the sheet.
         */
        getSheet(name: string, visibility?: ISheet.Visibility): ISheet;
        /**
         * Returns the currently active sheet within the workbook.
         */
        getSelectedSheet(): ISheet;
        /**
         * Returns the currently active sheet index within the workbook.
         */
        getSelectedSheetIndex(): number;
        /**
         * Returns ranges scoped to a sheet.
         *
         * @param address Address of the ranges.
         * @param options {@link ICellRange.GetRangeOptions}
         *
         * @remarks
         * When accessing ranges from the `IWorkbook` ranges include a sheet name.
         * This enables cross-sheet references when working at the workbook level.
         *
         * Some examples of cross-sheet reference are:
         *
         * - Linking data and formulas across multiple sheets.
         *
         * - Consolidating data from different sheets for analysis or reporting.
         *
         * - Performing calculations or comparisons that involve values from multiple sheets.
         */
        getRange(address: ICellRange.Address, options?: ICellRange.GetRangeOptions): ICellRange;
        /**
         * Returns an a set of ranges including sheet names.
         *
         * @param address Address of the ranges.
         * @param options {@link ICellRange.GetRangeOptions}
         *
         * @remarks
         * @see {@link IWorkbook.getRange}
         */
        getRanges(address: ICellRanges.Address, options?: ICellRange.GetRangeOptions): ICellRanges;
        /**
         * Returns a range of cells for the current selection.
         */
        getSelectedRange(options?: ICellRange.GetRangeOptions): ICellRange;
        /**
         * Returns ranges of cells for the current selection.
         */
        getSelectedRanges(options?: ICellRange.GetRangeOptions): ICellRanges;
        /**
         * Returns the selected cell.
         */
        getSelectedCell(): ICell;
        /**
         * Search the entire Workbook.
         *
         * @param options The text to search for or {@link ICellRange.FindOptions}
         *
         * @remarks
         * Searches all sheets.
         *
         * @see
         * {@link ICellRange.find}
         */
        find(options: string | ICellRange.FindOptions): Iterator<ICell>;
        /**
         * Replace all items in the iterator
         *
         * @param cells An iterator of cells to replace.
         * @param replace The {@link ICell.Update} or a callback to replace with.
         * @param options {@link IWorkbook.ReplaceOptions}
         */
        replace(cells: Iterator<ICell>, replace: ICell.Update | ((original: ICell) => ICell.Update), options?: IWorkbook.ReplaceOptions): IWorkbook.ReplaceResults;
        /**
         * Returns the next sheet in the sheets collection. If the last one it will return the first.
         *
         * @remarks
         * If there is only 1 sheet this will return the current sheet.
         */
        getNextSheet(index: number): ISheet;
        /**
         * Returns the previous sheet in the sheets collection. If the first one it will return the last.
         *
         * @remarks
         * If there is only 1 sheet this will return the current sheet.
         */
        getPreviousSheet(index: number): ISheet;
        /**
         * Given the name return a valid name that closely matches.
         *
         * @param sheetName The string to validate.
         */
        findValidSheetName(sheetName: string): string;
        /**
         * Indicate if the current character is a valid character for a sheetName.
         *
         * @param character The string to validate.
         */
        isValidSheetNameCharacter(character: string): boolean;
        /**
         * Returns the current view settings.
         *
         * View settings determine how specific workbook level elements are displayed but does not affect the underlying data itself.
         */
        getView(): IWorkbookView;
        /**
         * Views have their own lifecycle because in a collaborative environment each user can have their own view.
         */
        setView(view: IWorkbookView): this;
        /**
         * Returns the current `IStyleCollection` associated with this Workbook.
         */
        getStyles(): IStyleCollection;
        /**
         * Returns the current shared resources.
         */
        getResources(): IResourceCollection;
        /**
         * Returns the current shared resources.
         */
        getStrings(): IStringCollection;
        /**
         * Returns the current shared resources.
         */
        getTransactions(): ITransaction.IStore;
        /**
         * Get the current theme.
         */
        getTheme(): ITheme;
        /**
         * Set the current theme.
         *
         * @remarks
         * * If `null` sets back to the default theme.
         * * Does not fire a theme updated event.
         */
        setTheme(theme: ITheme | null): ITheme;
        /**
         * Returns the display name for the workbook.
         *
         * @remarks
         * This may be null
         */
        getName(): string | null;
        /**
         * Set the name for the workbook.
         */
        setName(name: string | null): IWorkbook;
        /**
         * Is date resolution 1904 instead of 1900 based.
         *
         * @see
         * {@link https://support.microsoft.com/en-us/office/date-systems-in-excel-e7fe7167-48a9-4b96-bb53-5612a800b487}
         */
        isDate1904(): boolean;
        /**
         * Determine if dates should be 1904 instead of 1900 based.
         *
         * @param date1940 - default value `false`
         *
         * @see
         * {@link IWorkbook.isDate1904}
         */
        setDate1904(date1940: boolean): this;
        /**
         * Add Listeners.
         *
         * @see
         * {@link IListener.ISource.addListeners}
         */
        addListeners(listeners: IWorkbook.IListeners, options?: IListener.Options): IListener.Remove;
        /**
         * Returns the protection object for the workbook.
         */
        getProtection(): IWorkbookProtection;
        /**
         * Returns the named collection for the workbook.
         *
         * These are sorted/filtered by type then by name.
         */
        getNames(): INamedCollection;
        /**
         * Returns the {@link ICalculation} for the workbook.
         */
        getCalculation(): ICalculation;
        /**
         * Returns any user defined functions stored with the workbook.
         */
        getScripts(): IScript;
        /**
         * Serialize the workbook to a JSON.
         *
         * @param ignoreData If `true` only meta data about the workbook will be saved.
         */
        toJSON(ignoreData?: boolean): Promise<IWorkbook.JSON>;
        /**
         * Returns any custom workbook options that are provided in constructor.
         */
        readonly options: IWorkbook.ConstructorOptions;
        /**
         * Close the workbook and release any resources.
         *
         * @remarks
         * No further operations are allowed after a close.
         */
        close(): void;
        /**
         * Indicates if the model has been closed.
         */
        isClosed(): boolean;
        /**
         * For runtime type checking.
         */
        readonly isIWorkbook: true;
    }
    /**
     * {@inheritDoc IWorkbook}
     * @see
     * ### **Interface**
     *
     * {@link IWorkbook}
     */
    export namespace IWorkbook {
        /**
         * Represents the different ways to identify ranges within a workbook, including the sheet context.
         *
         * Accepts:
         * - `ICellRange`
         * - A parsable `string` representing a range address, optionally including the sheet name (e.g., "Sheet1!A1:B2").
         * - A partial `IRange.FixableCoords` object (specifying at least some of the range boundaries),
         *   which may include the `sheetName` property to identify the sheet.
         * - `IWorkbook.CellAddress` (representing a single cell within the workbook),
         *   which may includes the `sheetName` property to identify the sheet.
         *
         * @example
         * ```typescript
         * const address1: Address = "Sheet1!A1:B2"; // A1 notation with sheet name
         * ```
         *
         * @remarks
         * This leverages {@link ICellRange.Address} and adds the sheet name.
         */
        type RangeAddress = ICellRange | string | Partial<IRange.FixableCoords> | IWorkbook.CellAddress;
        /**
         * Represents the different ways to identify multiple ranges within a workbook,
         * including their sheet context.
         *
         * Accepts:
         * - `ICellRanges`
         * - A parsable `string` containing multiple range addresses, optionally including sheet names,
         *    separated by commas (e.g., "Sheet1!A1:B2,Sheet2!C3:D4").
         * - An array of `IWorkbook.RangeAddress` objects, each representing a single range within a workbook.
         *
         * @example
         * ```typescript
         * const address1: IWorkbook.RangesAddress = "Sheet1!A1:B2,Sheet2!C3:D4"; // String with multiple ranges and sheet names
         * ```
         *
         * @remarks
         * This extends {@link ICellRanges.Address} to support multiple values.
         */
        type RangesAddress = ICellRanges | string | IWorkbook.RangeAddress | readonly IWorkbook.RangeAddress[];
        /**
         * Represents a single cell a workbook.
         */
        type CellAddress = IRange.FixableCellCoords | string;
        /**
         * IListener interface for {@link IWorkbook} events.
         */
        interface Events {
            /**
             * Called when the sheet collections has changed have changed.
             */
            onSheetsChange?(source: IWorkbook): void;
            /**
             * Called when the workbook theme has changed.
             */
            onThemeChange?(source: IWorkbook): void;
            /**
             * Called when the workbook protection has changed.
             *
             * @remarks
             * This is different from the sheet protection.
             */
            onProtectionChange?(source: IWorkbook): void;
            /**
             * Called before load. If any exception is thrown this
             * exception will be returned to the client and delete will fail.
             */
            onBeforeLoad?(source: IWorkbook, json: IWorkbook.JSON): void;
            /**
             * Called after load.
             */
            onLoad?(source: IWorkbook): void;
            /**
             * Called before load. If any exception is thrown this
             * exception will be returned to the client and delete will be aborted.
             */
            onBeforeSave?(source: IWorkbook): Promise<void> | void;
            /**
             * Called after save.
             */
            onSave?(source: IWorkbook, json: IWorkbook.JSON): void;
            /**
             * Called when the workbookView changes.
             *
             * @param source {@link IWorkbook}
             */
            onViewChange?(source: IWorkbook): void;
            /**
             * Called when the name changes.
             */
            onNameChange?(source: IWorkbook): void;
            /**
             * Called when the scripts associated with the workbook have change.
             */
            onScriptsChange?(source: IWorkbook): void;
            /**
             * Request that the sheet become brought to the front.
             *
             * @returns A promise indicating that the sheet has been rendered.
             *
             * @remarks
             * This should only be handled by one consumer.
             */
            onRequestSelect?(source: IWorkbook, sheet: ISheet): Promise<boolean>;
            /**
             * Called when the selection has changed.
             *
             * @param source The workbook instance.
             */
            onSelectionChange?(source: IWorkbook): void;
            /**
             * Called when the workbook is closed.
             */
            onClose?(source: IWorkbook): void;
            /**
             * Called when the state has been updated due to a undo/redo and a rerender is required.
             */
            onInvalidated?(source: IWorkbook): void;
        }
        interface IListeners extends IListener.Callbacks<IWorkbook, IWorkbook.Events> {
        }
        /**
         * Options for the replace operation.
         */
        interface ReplaceOptions extends ITransaction.OperationOptions {
            /**
             * The maximum number of cells to replace.
             * @defaultValue false
             */
            maxCount?: number;
            /**
             * The orientation to replace.
             */
            orientation?: IRange.Orientation;
        }
        interface ReplaceResults {
            /**
             * The number of cell replaced.
             */
            count: number;
            /**
             * The last cell replaced.
             */
            last: ICell;
        }
        interface JSON {
            sheets: SheetRefJSON[];
            styles?: IStyleCollection.JSON;
            resources?: IResource.JSON[];
            strings?: string[];
            people?: IComment.PersonJSON[];
            view?: IWorkbookView.JSON;
            theme?: ITheme.JSON;
            names?: INamedCollection.JSON;
            scripts?: Record<string, IModule.JSON>;
            calc?: ICalculation.JSON;
            protection?: IWorkbookProtection.JSON;
            date1904?: boolean;
        }
        /**
         * Callback to allow for custom `ISheets`. The Workbook provides a default implementation.
         */
        interface CreateSheetCallback {
            (
            /**
             * Options used for creating the Sheet instance.
             */
            options: ISheet.ConstructorOptions, 
            /**
             * The name of the new  sheet.
             */
            name: string, 
            /**
             * The location of the sheet.
             */
            index: number, 
            /**
             * @defaultValue ISheet.Visibility.Visible
             */
            visibility: ISheet.Visibility): ISheet;
        }
        /**
         * Options available when creating an IWorkbook.
         */
        interface ConstructorOptions extends ICellContainerOptions {
            /**
             * Hook to allow for custom sheet creation.
             */
            createSheetCallback?: CreateSheetCallback;
            /**
             * Returns a human readable sheet name given a 0-based index.
             *
             * @defaultValue `Sheet${index+1}`
             */
            createSheetNameCallback?: (index: number) => string;
            /**
             * The initial name for the workbook.
             */
            name?: string | null;
            /**
             * Returns a valid name for the workbook.
             *
             * @param name The name to validate.
             * @returns The valid name. This may be different from the name provided.
             * @throws Error if the name is not valid.
             *
             * @remarks
             * This is not called if the name is null or for the initialName if provided.
             */
            validateWorkbookName?: (name: string) => string | null | void;
            /**
             * A theme for the workbook.
             */
            theme?: ITheme;
            /**
             * Load from JSON.
             */
            json?: IWorkbook.JSON;
        }
        /**
         * Used for persisting metadata about a `ISheet`.
         */
        interface SheetRefJSON {
            /**
             * A unique name for the sheet.
             */
            name: string;
            /**
             * @defaultValue ISheet.Visibility.Visible
             */
            visibility?: ISheet.Visibility;
            /**
             * The actual sheet.
             */
            sheet?: ISheet.JSON;
        }
    }
}
declare module "script/_FunctionMessages" {
    export const ERROR_FUNCTION_REQUIRED = "Item must be specified.";
    export const ERROR_NO_FUNCTION_SCOPE = "No function scope.";
}
declare module "script/ModuleCollection" {
    import { type ITransaction } from "transaction/index";
    import type { IListener } from "listener/index";
    import { ListenerEmitter } from "listener/ListenerEmitter";
    import type { IModule } from "script/IModule";
    import { IModuleCollection } from "script/IModuleCollection";
    /**
     * Implementation for `IModuleCollection`.
     */
    export class ModuleCollection implements IModuleCollection {
        protected _emitter: ListenerEmitter<this, IModuleCollection.IListeners>;
        private _options;
        private _transactions;
        private _transactionsRemoveListener;
        private _closed;
        constructor(options: ModuleCollection.ConstructorOptions);
        /** {@inheritDoc IModuleCollection.add} */
        add(uid: string, module: IModule, options?: IModuleCollection.AddOptions): void;
        /** {@inheritDoc IModuleCollection.getItems} */
        getItems(options?: IModuleCollection.GetItemsOptions): IModule[];
        /** {@inheritDoc IModuleCollection.getByName} */
        getByName(name: string): IModule | null;
        /** {@inheritDoc ICollection.getCount} */
        getCount(): number;
        /** {@inheritDoc ITransaction.ITransactional.beginCommit} */
        beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
        private _getState;
        private _beginCommit;
        private _updateState;
        protected _initState(initial?: Record<string, IModule>): void;
        /** {@inheritDoc IListener.ISource.addListeners} */
        addListeners(listeners: IModuleCollection.IListeners, options?: IListener.Options): IListener.Remove;
        /** {@inheritDoc IModuleCollection.toJSON} */
        toJSON(): Record<string, IModule.JSON>;
        isClosed(): boolean;
        close(): void;
        get isFunctionCollection(): true;
    }
    export namespace ModuleCollection {
        interface ConstructorOptions {
            /**
             * A transaction store that can be used to undo/redo changes to the names.
             */
            transactions?: ITransaction.IStore;
            /**
             * The initial modules.
             */
            initial?: Record<string, IModule>;
            onRemove?: (moduleId: string, module: IModule) => void;
            onAdd?: (moduleId: string, module: IModule) => void;
        }
    }
}
declare module "script/ITypedFunction" {
    /**
     * Provides interfaces for defining and working with functions at runtime, including metadata for
     * function declarations and execution scripts.
     */
    export namespace ITypedFunction {
        /**
         * Describes the execution context required by the function.
         */
        const Context: {
            /**
             * The selected workbook.
             *
             * @remarks
             * `IWorkbook` will be passed as the first argument to `execute`.
             */
            readonly Workbook: "workbook";
            /**
             * The selected sheet.
             *
             * @remarks
             * `ISheet` will be passed as the first argument to `execute`.
             */
            readonly Sheet: "sheet";
            /**
             * The selected ranges.
             *
             * @remarks
             * `ICellRanges` will be passed as the first argument to `execute`.
             */
            readonly Ranges: "ranges";
            /**
             * The selected ranges.
             *
             * @remarks
             * `ICellRange` will be passed as the first argument to `execute`.
             */
            readonly Range: "range";
            /**
             * The calculation context.
             *
             * @remarks
             * `ICalculation.IContext` will be passed as the first argument to `execute`.
             */
            readonly Calculation: "calculation";
        };
        type Context = typeof Context[keyof typeof Context];
    }
}
declare module "primitives/_PrimitiveMessages" {
    export const ERROR_FUNCTION_REQUIRED = "Item must be specified.";
    export const ERROR_NO_FUNCTION_SCOPE = "FunctionContext can only be used in a function.";
}
declare module "primitives/_FormulaContext" {
    import { Scalar, IRange, IReferenceRange, IFunction, IFormulaContext, IRuntime } from '@sheetxl/primitives';
    /** @inheritdoc IFormulaContext */
    export class ScopedFormulaContext implements IFormulaContext {
        protected _scope: Partial<IFormulaContext>;
        /** @hidden */
        _setScope(scope: Partial<IFormulaContext>): void;
        _getScope(allowNull?: boolean): Partial<IFormulaContext>;
        /** @inheritdoc IFormulaContext.getNumberFormat */
        getNumberFormat(formatText: string, value: Scalar): string;
        /** @inheritdoc IFormulaContext.getEntireCoords */
        getEntireCoords(): IRange.Coords;
        /** @inheritdoc IFormulaContext.isValidDate */
        isValidDate(value: any): boolean;
        /** @inheritdoc IFormulaContext.parseAsDateTime */
        parseAsDateTime(text: string, requireDate?: boolean): number | null;
        /** @inheritdoc IFormulaContext.fromOADate */
        fromOADate(oaDate: number): Date;
        /** @inheritdoc IFormulaContext.toOADate */
        toOADate(date: Date): number;
        /** @inheritdoc IFormulaContext.getRange */
        getRange(value: Scalar | Scalar[][]): IRange;
        /** @inheritdoc IFormulaContext.getValueAt */
        getValueAt(row: number, column: number): Scalar | null;
        /** @inheritdoc IFormulaContext.getPosition */
        getPosition(): Readonly<IRange.CellCoords>;
        /** @inheritdoc IFormulaContext.getReference */
        getReference(coords: Readonly<IRange.Coords>, r1c1?: boolean): IReferenceRange;
        /** @inheritdoc IFormulaContext.getFormulaAt */
        getFormulaAt(row: number, column: number): string | null;
        /** @inheritdoc IFormulaContext.getSpillAt */
        getSpillAt(row: number, column: number): IReferenceRange | null;
        /** @inheritdoc IFormulaContext.getSheetIndex */
        getSheetIndex(sheetName?: string): number;
        /** @inheritdoc IFormulaContext.getSheetCount */
        getSheetCount(): number | null;
        /** @inheritdoc IFormulaContext.markVolatile */
        markVolatile(): void;
        /** @inheritdoc IFormulaContext.formatResults */
        formatResults(numFmt: string): void;
        /** @inheritdoc IFormulaContext.getFunction */
        getFunction(fnName: string): IFunction;
        /** @inheritdoc IFormulaContext.getAddress */
        getAddress(coords?: Readonly<IRange.FixableCoords | IRange.FixableCellCoords>, r1c1?: boolean): string;
        /** @inheritdoc IFormulaContext.getRuntime */
        getRuntime(): IRuntime;
        get [Symbol.toStringTag](): string;
        toString(): string;
    }
}
declare module "primitives/FormulaContext" {
    import { IFormulaContext } from '@sheetxl/primitives';
    /** @inheritdoc IFormulaContext*/
    export const FormulaContext: IFormulaContext;
}
declare module "script/_ScriptUtils" {
    import { IFormulaContext, IRange, FormulaError, Observable } from '@sheetxl/primitives';
    /**
     * Used for the global context variable.
     */
    export const GLOBAL_CONTEXT_VARIABLE = "__SHEETXL";
    export const _ReuseGlobalContext: {
        FormulaContext: IFormulaContext;
        ScalarType: {
            readonly Number: "n";
            readonly String: "s";
            readonly Boolean: "b";
            readonly Error: "e";
            readonly RichData: "r";
            readonly Null: "z";
        };
        IRange: typeof IRange;
        FormulaError: typeof FormulaError;
        Observable: typeof Observable;
    };
    export function setGlobalScope(scope: Partial<IFormulaContext>): void;
    export function clearGlobalScope(): void;
}
declare module "script/TypedFunction" {
    import { IFunction, IFormulaContext } from '@sheetxl/primitives';
    export class TypedFunction implements IFunction {
        protected _n: string;
        protected _d: IFunction.IDeclaration;
        protected _p: readonly IFunction.IParameterType[];
        protected _ct: string;
        protected _cf: () => IFormulaContext;
        protected _fn: (...args: any) => any;
        protected _descFn: (locale?: string) => Promise<IFunction.DescriptorJSON>;
        protected _desc: IFunction.IDescriptor;
        protected _builtIn: boolean;
        protected _broadcast: boolean;
        protected _json: IFunction.DeclarationJSON;
        protected _pj: IFunction.ParameterTypeJSON[] | null;
        constructor(json: IFunction.DeclarationJSON, fn: (...args: any) => any, getContext: () => IFormulaContext, desc?: IFunction.DescriptorJSON | ((locale?: string) => Promise<IFunction.DescriptorJSON>), builtIn?: boolean);
        /** @inheritdoc IFunction.execute */
        execute<T = any>(...args: any[]): T;
        /** @inheritdoc IFunction.getName */
        getName(): string;
        /** @inheritdoc IFunction.getDeclaration */
        getDeclaration(): IFunction.IDeclaration;
        /** @inheritdoc IFunction.getDescriptor */
        getDescriptor(locale?: string): Promise<IFunction.IDescriptor>;
        /** @inheritdoc IFunction.isBuiltIn */
        isBuiltIn(): boolean;
        /** @inheritdoc IFunction.getContext() */
        getContext(): string | null;
        get [Symbol.toStringTag](): string;
        toString(): string;
        /** @inheritdoc IFunction.isIFunction */
        get isIFunction(): true;
        /** @inheritdoc ITypedFunction.isITypedFunction */
        get isITypedFunction(): true;
    }
}
declare module "script/Runtime" {
    export const getRuntime: () => any;
    /**
     * Used for the global context variable.
     */
    export const GLOBAL_SCRIPT_VARIABLE = "SheetXL";
    export const _ReuseGlobalRuntime: any;
    export function setGlobalRuntime(): void;
    export function clearGlobalRuntime(): void;
}
declare module "script/MacroFunction" {
    import { IFunction, IFormulaContext } from '@sheetxl/primitives';
    import { TypedFunction } from "script/TypedFunction";
    export class MacroFunction extends TypedFunction {
        constructor(json: IFunction.DeclarationJSON, fn: (...args: any) => any, getContext: () => IFormulaContext, desc?: IFunction.DescriptorJSON | ((locale?: string) => Promise<IFunction.DescriptorJSON>), builtIn?: boolean);
        /** @inheritdoc IFunction.execute */
        execute<T = any>(...args: any[]): T;
    }
}
declare module "script/FunctionCollection" {
    import type { IFunction, IFormulaContext } from '@sheetxl/primitives';
    import { type ITransaction } from "transaction/index";
    import type { IListener } from "listener/index";
    import type { ICollection } from "type/index";
    import { ListenerEmitter } from "listener/ListenerEmitter";
    import type { IFunctionCollection } from "script/IFunctionCollection";
    /**
     * Implementation for `IFunctionCollection`.
     */
    export class FunctionCollection implements IFunctionCollection {
        protected _emitter: ListenerEmitter<this, IFunctionCollection.IListeners>;
        private _options;
        private _readonly;
        private _transactions;
        private _transactionsRemoveListener;
        private _closed;
        constructor(options: ConstructorOptions);
        /** {@inheritDoc IFunctionCollection.getItems} */
        getItems(options?: ICollection.GetItemsOptions): IFunction[];
        /** {@inheritDoc IFunctionCollection.getByName} */
        getByName(name: string): IFunction | null;
        /** {@inheritDoc IFunctionCollection.search} */
        search(options?: IFunctionCollection.SearchOptions): Promise<IFunction[]>;
        /** {@inheritDoc ICollection.getCount} */
        getCount(): number;
        /** {@inheritDoc IFunctionCollection.validateName} */
        validateName(named: string): void;
        _validateName(name: string, ignoreExisting?: boolean): void;
        /** {@inheritDoc IFunctionCollection.add} */
        add(udf: IFunction | IFunctionCollection.AddOptions): IFunction;
        /** {@inheritDoc ITransaction.ITransactional.beginCommit} */
        beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
        private _getState;
        private _beginCommit;
        private _updateState;
        protected _initState(): void;
        /** {@inheritDoc IListener.ISource.addListeners} */
        addListeners(listeners: IFunctionCollection.IListeners, options?: IListener.Options): IListener.Remove;
        isClosed(): boolean;
        close(): void;
        get isFunctionCollection(): true;
    }
    export interface ConstructorOptions {
        /**
         * A transaction store that can be used to undo/redo changes to the names.
         */
        transactions?: ITransaction.IStore;
        context?: IFormulaContext;
        readonlyFunctions?: ReadonlyMap<string, IFunction>;
    }
}
declare module "script/Module" {
    import type { IFunction } from '@sheetxl/primitives';
    import type { IListener } from "listener/index";
    import { ListenerEmitter } from "listener/ListenerEmitter";
    import type { IModule } from "script/IModule";
    import type { IFunctionCollection } from "script/IFunctionCollection";
    export class Module implements IModule {
        protected _json: IModule.JSON;
        protected _functions: IFunctionCollection;
        protected _emitter: ListenerEmitter<IModule, IModule.IListeners>;
        protected _name?: string;
        constructor(options: {
            json: IModule.JSON;
            readonlyFunctions: Map<string, IFunction>;
            name: string;
        });
        /** {@inheritDoc IModule.getName} */
        getName(): string;
        /** {@inheritDoc IModule.getFunctions} */
        getFunctions(): IFunctionCollection;
        /** {@inheritDoc IModule.getSource} */
        getSource(): string | null;
        /** {@inheritDoc IModule.getLanguage} */
        getLanguage(): string;
        /** {@inheritDoc IModule.getErrors} */
        getErrors(): any[];
        /** {@inheritDoc IModule.delete} */
        delete(): void;
        /** {@inheritDoc IModule.addListeners} */
        addListeners(listeners: IModule.IListeners, options?: IListener.Options): IListener.Remove;
        /** {@inheritDoc IModule.toJSON} */
        toJSON(): IModule.JSON;
    }
}
declare module "script/_ModuleUtils" {
    import { IModule } from "script/IModule";
    export const jsonToModule: (name: string, json: IModule.JSON, declarationsOnly?: boolean) => Promise<IModule>;
    export function runAsyncGenerator<T>(generator: AsyncGenerator<any, T, any>): Promise<T>;
}
declare module "script/Scripts" {
    import type { IFunction } from '@sheetxl/primitives';
    import { type IListener } from "listener/index";
    import { ListenerEmitter } from "listener/ListenerEmitter";
    import type { ITransaction } from "transaction/index";
    import type { IWorkbook } from "workbook/index";
    import type { IModule } from "script/IModule";
    import type { IModuleCollection } from "script/IModuleCollection";
    import type { IScript } from "script/IScript";
    import type { IFunctionCollection } from "script/IFunctionCollection";
    export class Scripts implements IScript {
        private _options;
        private _modules;
        protected _emitter: ListenerEmitter<IScript, IScript.IListeners>;
        constructor(options: Scripts.ConstructorOptions);
        protected _initState(): void;
        /** {@inheritDoc IScript.getModules} */
        getModules(): IModuleCollection;
        /** {@inheritDoc IScript.createModule} */
        createModule(options?: IModule.CompileOptions): Promise<IModule>;
        /** {@inheritDoc IScript.createModule} */
        addModule(uid: string, module: IModule, options?: IModuleCollection.AddOptions): void;
        /** {@inheritDoc IScript.search} */
        executeMacro(functionName: string, moduleId?: string): Promise<IScript.MacroResults>;
        /** {@inheritDoc IScript.searchFunctions} */
        searchFunctions(options?: IScript.SearchOptions): Promise<IFunction[]>;
        /** {@inheritDoc IScript.start} */
        start(): Promise<void>;
        /** {@inheritDoc IListener.ISource.addListeners} */
        addListeners(listeners: IScript.IListeners, options?: IListener.Options): IListener.Remove;
        /** {@inheritDoc IScript.isReadOnly} */
        isReadOnly(): boolean;
        /** {@inheritDoc IScript.toJSON} */
        toJSON(): Record<string, IModule.JSON>;
    }
    export namespace Scripts {
        interface ConstructorOptions {
            /**
             * A transaction store that can be used to undo/redo changes to the names.
             */
            transactions?: ITransaction.IStore;
            json?: Record<string, IModule.JSON>;
            workbook: IWorkbook;
            onRemove?: (moduleId: string, module: IModule) => void;
            onAdd?: (moduleId: string, module: IModule) => void;
            getBuiltInFunctions?(): IFunctionCollection;
        }
    }
}
declare module "address/_AddressMessages" {
    import { ICell } from "cell/index";
    import { ICellRanges } from "cellRange/index";
    export const ERROR_NO_COORDS = "Must specify a coords.";
    export const ERROR_NO_RANGE = "Must specify a range.";
    export const ERROR_NO_ADDRESS = "Must specify an address.";
    export const ERROR_SINGLE_RANGE_ONLY = "Only a single range is allowed for this operation.";
    export const ERROR_SINGLE_RANGE_ONLY_ALT = "Only a single range is allowed for this operation. Use 'getRanges' instead.";
    export const ERROR_SINGLE_CELL_ONLY = "Only a single cell is allowed.";
    export const ERROR_INVALID_ADDRESS: (address?: ICell.Address) => string;
    export const ERROR_INVALID_RANGE_INVERTED = "Invalid range. The Range must be specified as '{ TOP_LEFT:BOTTOM_RIGHT }'.";
    export const ERROR_INVALID_RANGE = "Invalid range. The Range must be at a size of at least 1x1'.";
    export const ERROR_INVALID_RANGE_HEADER = "Invalid header range.";
    export const ERROR_INVALID_RANGE_EMPTY = "Invalid range.";
    export const ERROR_INVALID_RANGE_CORDS = "Invalid range. All points must be valid integers.";
    export const ERROR_INVALID_RANGE_ADDRESS: (address: ICellRanges.Address) => string;
    export const ERROR_INVALID_RANGE_RELATIVE: (address: string) => string;
    export const ERROR_INVALID_CELL = "Invalid cell.";
    export const ERROR_INVALID_REF: () => never;
    export const ERROR_INVALID_ARGUMENTS = "Invalid arguments.";
}
declare module "named/AbstractNamed" {
    import { ITypes } from "type/index";
    import { ITransaction } from "transaction/index";
    import { ICellRanges } from "cellRange/index";
    import { INamed } from "named/INamed";
    import { IModel } from "model/index";
    import { AbstractModel } from "model/AbstractModel";
    export interface State extends AbstractModel.State {
        name: string;
        comment: string;
        hidden: boolean;
        scope: string;
    }
    /**
     * Abstract implementation of `INamed`.
     */
    export abstract class AbstractNamed<T, S extends State, VIEW extends AbstractModel.CommitView = AbstractModel.CommitView, EVENTS extends IModel.Events = INamed.Events> extends AbstractModel<S, INamed.JSON, VIEW, EVENTS> implements INamed<T> {
        /** {@inheritDoc INamed.select} */
        abstract select(options?: ITypes.SelectOptions): Promise<this>;
        /** {@inheritDoc INamed.getRanges} */
        abstract getRanges(): ICellRanges | null;
        /** {@inheritDoc INamed.getValue} */
        abstract getValue(): T;
        /** {@inheritDoc INamed.getType} */
        abstract getType(): string;
        protected _fromJSON(json: INamed.JSON): void;
        protected _toJSON(): INamed.JSON;
        /** {@inheritDoc INamed.getValue} */
        getName(): string;
        /** {@inheritDoc INamed.setName} */
        setName(name: string, options?: ITransaction.OperationOptions): this;
        /** {@inheritDoc INamed.getComment} */
        getComment(): string;
        /** {@inheritDoc INamed.setComment} */
        setComment(comment: string | null, options?: ITransaction.OperationOptions): this;
        /** {@inheritDoc INamed.isHidden} */
        isHidden(): boolean;
        /** {@inheritDoc INamed.getScope} */
        getScope(): string;
        get isINamed(): true;
    }
}
declare module "named/NamedReference" {
    import { ITransaction } from "transaction/index";
    import { IListener } from "listener/index";
    import { ICellRanges, ICellRange } from "cellRange/index";
    import { INamed } from "named/INamed";
    import { AbstractNamed, State as NamedState } from "named/AbstractNamed";
    export interface State extends NamedState {
        ranges: ICellRanges;
        removeListener: IListener.Remove;
    }
    export class NamedReference<T extends ICellRanges> extends AbstractNamed<T, State> implements INamed.IReference {
        protected _listener: (event: ICellRange.Event) => void;
        constructor(options: INamed.ConstructorOptions<T>);
        /** {@inheritDoc INamed.setReference} */
        setReference(ref: string | ICellRanges.Address): this;
        /** {@inheritDoc INamed.select} */
        select(options?: ICellRange.SelectOptions): Promise<this>;
        /** {@inheritDoc INamed.getRanges} */
        getRanges(): ICellRanges | null;
        /** {@inheritDoc INamed.setHidden} */
        setHidden(hidden?: boolean, options?: ITransaction.OperationOptions): this;
        /** {@inheritDoc INamed.setScope} */
        setScope(scope: string | null, options?: ITransaction.OperationOptions): this;
        /** {@inheritDoc INamed.IReference.getType} */
        getType(): 'reference';
        /** {@inheritDoc INamed.getValue} */
        getValue(): T | null;
        /** {@inheritDoc INamed.delete} */
        toJSON(): INamed.JSON | null;
        protected _getDescription(): string;
        protected _processDelete(): void;
        get [Symbol.toStringTag](): string;
        toString(): string;
    }
}
declare module "named/_NamedMessages" {
    export const ERROR_NAME_REQUIRED = "Item must be specified.";
    export const ERROR_NAME_EMPTY = "Name must be a non-empty string";
    export const ERROR_NAME_MAX_LENGTH = "Name must not exceed 255 characters.";
    export const ERROR_CONTAINS_SPACES = "Name must not contain any spaces.";
    export const ERROR_INVALID_ADD_PARAM = "Add must take a 'INamed' object. To add a string use 'addReference'.";
    export const ERROR_TEMPLATE_REQUIRED = "A template string must be specified.";
    export const ERROR_INVALID_FIRST_CHAR = "First letter must be either a letter, an underscore, or a backslash.";
    export const ERROR_INVALID_TRAILING_CHAR = "Name must be either letters, numbers, periods or underscores.";
    export const ERROR_INVALID_SPECIAL_R_C = "Name can not be 'r' or 'c'.";
    export const ERROR_INVALID_INVALID_CELL_ADDRESS = "Name can not be an address.";
    export const ERROR_NAME_EXISTS: (name: string, scope?: string) => string;
    export const ERROR_NAME_READONLY = "Names are read-only.";
    export const ERROR_NAME_DOES_NOT_EXIST: (name: string) => string;
}
declare module "named/NamedCollection" {
    import { ITransaction } from "transaction/index";
    import { IListener } from "listener/index";
    import { ICellRanges } from "cellRange/index";
    import { INamed, INamedCollection } from "named/index";
    import { ListenerEmitter } from "listener/ListenerEmitter";
    export const REGEX_INVALID_NAME_FIRST_CHARS: RegExp;
    export const REGEX_INVALID_NAME_TRAILING_CHARS: RegExp;
    /**
     * Implementation for `INamedCollection`.
     */
    export class NamedCollection implements INamedCollection {
        protected _emitter: ListenerEmitter<this, INamedCollection.IListeners>;
        private _options;
        private _transactions;
        private _transactionsRemoveListener;
        private _closed;
        private _lastLookup;
        private _lastLookupAddress;
        private _lastLookupScope;
        private _lastLookupType;
        private _allowExtrudes;
        constructor(options: INamedCollection.ConstructorOptions);
        /** {@inheritDoc INamedCollection.getItems} */
        getItems(options?: INamedCollection.GetItemsOptions): INamed[];
        /** {@inheritDoc INamedCollection.lookupByRanges} */
        lookupByRanges(address: ICellRanges.Address): INamed[] | null;
        /** {@inheritDoc INamedCollection.getByName} */
        getByName(name: string, global?: boolean): INamed | null;
        /** {@inheritDoc ICollection.getCount} */
        getCount(): number;
        /** {@inheritDoc ICollection.getRanges} */
        getRanges(address: ICellRanges.Address): ICellRanges;
        /** {@inheritDoc INamedCollection.findValidName} */
        findValidName(template: string, scope?: string, ignoreExisting?: boolean): string;
        /** {@inheritDoc INamedCollection.validateName} */
        validateName(named: string, scope?: string, ignoreExisting?: boolean): void;
        _validateName(name: string, scope: string, ignoreExisting?: boolean): void;
        /** {@inheritDoc INamedCollection.addReference} */
        addReference(name: string, reference: ICellRanges.Address, replaceExisting?: boolean): INamed.IReference;
        /** {@inheritDoc INamedCollection.add} */
        add(named: INamed): INamed;
        protected _toKey(named: INamed): string;
        protected _delete(named: INamed, options?: ITransaction.OperationOptions): INamed | null;
        private _cloneState;
        private _index;
        private _add;
        /** {@inheritDoc ITransaction.ITransactional.beginCommit} */
        beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
        private _getState;
        private _beginCommit;
        private _updateState;
        fromJSON(json: INamedCollection.JSON): void;
        protected _initState(): void;
        private _fromJSON;
        toJSON(): INamedCollection.JSON | null;
        /** {@inheritDoc IListener.ISource.addListeners} */
        addListeners(listeners: INamedCollection.IListeners, options?: IListener.Options): IListener.Remove;
        isClosed(): boolean;
        close(): void;
        get isNamedCollection(): true;
    }
}
declare module "lib/crypto/crypto.node" {
    export function getCrypto(): Promise<Crypto>;
}
declare module "protection/PasswordHasher" {
    export interface SaltAndHash {
        salt: string;
        hash: string;
    }
    export class PasswordHasher {
        static DefaultAlgo: string;
        static DefaultSpinCount: number;
        /**
         * Create a salt and hash from a password.
         *
         * @param password The password.
         * @param algorithm The hash algorithm. Default value `SHA-512`.
         * @param spinCount The spin count. Default value `100000`.
         *
         * @returns The encryption key as a base64 string.
         */
        static generateSaltAndHash(password: string, algorithm?: string, spinCount?: number): Promise<SaltAndHash>;
        /**
         * Verify a password again a hash a salt and hash from a password.
         *
         * @param password The encrypted password.
         * @param salt The salt returned when generating the hash
         * @param hash The hash used to encrypt the password.
         * @param algorithm The hash algorithm. Default value `SHA-512`.
         * @param spinCount The spin count. Default value `100000`.
         *
         * @returns The encryption key as a base64 string.
         */
        static verifyPassword(password: string, saltAndHash: SaltAndHash, algorithm?: string, spinCount?: number): Promise<boolean>;
        /**
         * For unit testing against existing salt and hash keys.
         */
        protected static _convertPasswordToHash(password: string, salt: string, algorithm: string, spinCount: number): Promise<string>;
    }
}
declare module "protection/DefaultProtection" {
    import { IListener } from "listener/index";
    import { IProtection } from "protection/IProtection";
    import { ListenerEmitter } from "listener/ListenerEmitter";
    export class DefaultProtection<T, P extends IProtection.Properties, J extends IProtection.JSON> implements IProtection<T, P, J> {
        protected _emitter: ListenerEmitter<this, IProtection.IListeners>;
        protected _isPaused: boolean;
        protected _password: Partial<IProtection.EncryptedPassword>;
        protected _identities: IProtection.IdentityProvider[];
        protected _properties: Partial<P>;
        protected _isReadOnly: boolean;
        constructor(json?: J, isReadOnly?: boolean);
        /** {@inheritDoc IProtection.lock} */
        lock(properties?: Partial<P>, password?: string, algorithm?: string, spinCount?: number): Promise<IProtection<T, P, J>>;
        /** {@inheritDoc IProtection.unlock} */
        unlock(password?: string): Promise<IProtection<T, P, J>>;
        /** {@inheritDoc IProtection.checkPassword} */
        checkPassword(password?: string): Promise<boolean>;
        /** {@inheritDoc IProtection.hasPassword} */
        hasPassword(): boolean;
        /** {@inheritDoc IProtection.pause} */
        pause(password?: string): Promise<IProtection<T, P, J>>;
        /** {@inheritDoc IProtection.resume} */
        resume(): IProtection<T, P, J>;
        /** {@inheritDoc IProtection.isPaused} */
        isPaused(): boolean;
        /** {@inheritDoc IProtection.isLocked} */
        isLocked(): boolean;
        /** {@inheritDoc IProtection.isReadOnly} */
        isReadOnly(): boolean;
        protected _validatePassword(password?: string): Promise<boolean>;
        getProperties(): Partial<P>;
        protected _isPropertyAllowed(property: keyof P): boolean;
        protected _updateProperties(properties: IProtection.Properties): void;
        protected _clearProperties(): void;
        /** {@inheritDoc IListener.ISource.addListeners} */
        addListeners(listeners: IProtection.IListeners, options?: IListener.Options): IListener.Remove;
        fromJSON(json: J): void;
        protected _fromJSON(_json: J | null): void;
        protected _toJSON(json: Partial<J>): Partial<J>;
        /** {@inheritDoc IWorkbookProtection.toJSON} */
        toJSON(): J;
    }
}
declare module "workbook/protection/WorkbookProtection" {
    import { DefaultProtection } from "protection/DefaultProtection";
    import { IWorkbookProtection } from "workbook/protection/IWorkbookProtection";
    export class WorkbookProtection extends DefaultProtection<IWorkbookProtection, IWorkbookProtection.Properties, IWorkbookProtection.JSON> implements IWorkbookProtection {
        /** {@inheritDoc IProtection.isWindowsAllowed} */
        isWindowsAllowed(): boolean;
        /** {@inheritDoc IProtection.isRevisionAllowed} */
        isRevisionAllowed(): boolean;
        /** {@inheritDoc IWorkbookProtection.isStructureAllowed} */
        isStructureAllowed(): boolean;
        protected _fromJSON(json: IWorkbookProtection.JSON | null): void;
        protected _toJSON(json: IWorkbookProtection.JSON): IWorkbookProtection.JSON;
    }
}
declare module "workbook/_WorkbookMessages" {
    export const ERROR_INVALID_ID: (id: number) => string;
    export const ERROR_INVALID_SHEET_KEY: (key: any) => string;
    export const ERROR_EMPTY_VIEW = "View can not be empty.";
    export const ERROR_NAME_TAKEN = "That name is already taken. Try a different one.";
    export const ERROR_NAME_DUPLICATE: (sheetName: string) => string;
    export const ERROR_SHEET_ONE = "A workbook must contain at least one visible worksheet.";
    export const ERROR_DELETE_KEY: (key: string) => string;
    export const ERROR_NO_VISIBLE_REFS = "Internal error no visible sheetRefs";
    export const MODEL_CLOSED = "Workbook has been closed. No further operations are allowed.";
    export const ERROR_SHEET_NAME_NOT_FOUND: (sheetName: string) => string;
    export const ERROR_SHEET_INDEX_NOT_FOUND: (index: number) => string;
    export const ERROR_INVALID_REPLACE_FIELD = "Can not replace values. Use formula instead";
    export const ERROR_NOT_SET_VALUE = "A value must be provided.";
    export const ERROR_PROTECTION = "This workbook structure is protected. To make a change, unprotect the workbook. You might be requested to enter a password.";
    export const SHEET_NAME = "A sheet name";
    export const ERROR_SHEET_NAME_BLANK = "A sheet name can not be blank.";
    export const ERROR_SHEET_NAME_INVALID_CHARS: (sheetName?: string) => string;
    export const ERROR_SHEET_NAME_TOO_LONG = "A sheet name can not be longer than 31 characters.";
    export const ERROR_SHEET_NAME_QUOTES = "A sheet name can not begin or end with a \"'\" (single quote).";
    export const ERROR_JSON_EMPTY = "No JSON specified.";
}
declare module "sheet/_SheetMessages" {
    export const ERROR_INVALID_ARGS = "The arguments are not valid.";
    export const ERROR_READONLY_SHEET: (description?: string) => string;
    export const ERROR_PROTECTED_SHEET = "This sheet is protected. To make a change, unprotect the sheet. You might be requested to enter a password.";
    export const ERROR_PROTECTED_FIELD: (description?: string) => string;
    export const ERROR_OOB_RANGE = "The range is outside of the bounds of the sheet.";
    export const ERROR_OOB_CELL = "The cell is outside of the bounds of the range.";
    export const ERROR_INVALID_SCOPED_RANGE_ADDRESS: (address: any, scope: string) => string;
    export const ERROR_LISTENER_NULL = "Listener can not be null";
    export const ERROR_UNSUPPORTED_FLOATING_TYPE: (type: string) => string;
    export const ERROR_NO_IMAGE_PROVIDED = "An image must be provided as a string or a resource option.";
    export const ERROR_INSERT_ITEM_PROTECTED = "We can't insert items. The sheet is protected.";
    export const ERROR_ITEM_OVERLAPPING: (type: string) => string;
    export const ERROR_PASTE_MATCHING_SIZE = "When pasting to multiple areas all of the paste sizes must match the copy size.";
    export const ERROR_PASTE_MERGE = "We can't paste over merged cells.";
    export const ERROR_PASTE_OOB = "We can't paste outside of the sheet bounds.";
    export const ERROR_PASTE: (message: string) => string;
    export const ERROR_MERGE_OVERLAPPING = "Overlapping ranges can not be merged.";
    export const ERROR_MERGE_MULTIPLE_VALUES = "Merging cells would cause some values to be discarded. Use 'discardMultipleValues' option if desired.";
    export const ERROR_MERGE_MAX_OP_SIZE = "We can't merge this many cells in a single operation.";
    export const ERROR_MERGE_OOB = "We can't merge outside of the maximum cell location.";
    export const ERROR_UNMERGE_OVERLAPPING = "We can't unmerge intersecting ranges.";
    export const ERROR_UNMERGE_PARTIAL = "We can't unmerge partial cells.";
    export const ERROR_INSERT_ITEM_OOB = "We can't insert cells because this would push items off the end of the worksheet.";
    export const ERROR_INSERT_OOB = "We can't insert cells because this would push values off the end of the worksheet. These cells may appear empty but they have some formatting or formulas. Delete enough rows or columns and try again.";
    export const ERROR_INSERT_OVERLAPPING = "We can't insert cells with overlapping selections.";
    export const ERROR_INSERT_PROTECTED = "We can't insert cells. The sheet is protected.";
    export const ERROR_INSERT_MERGE_THROUGH = "We can't insert through merges. Unmerge and try again.";
    export const ERROR_DELETE_OVERLAPPING = "We can't delete cells with overlapping selections.";
    export const ERROR_DELETE_PROTECTED = "We can't delete cells. The sheet is protected.";
    export const ERROR_DELETE_MERGE_THROUGH = "We can't delete through merges. Unmerge and try again.";
    export const ERROR_AUTOFILL_OVERLAP_MERGE = "Unable to partially fill over merged cells.";
    export const ERROR_AUTOFILL_INVALID_DESTINATION = "Autofill destination must be the same as the range for 3 of the 4 edges.";
    export const ERROR_AUTOFILL_MULTIPLE: (modulus: number) => string;
    export const ERROR_SORT_OVERLAP_MERGE = "Unable to partially sort over merged cells.";
    export const ERROR_SORT_MERGE_SIZE = "Unable to sort merged cells unless they are all the same size.";
    export const ERROR_SORT_OOB_RANGE = "The sort offset is outside of the bounds of the sort.";
    export const ERROR_TABLE_1_BY_1 = "A table must have a least two rows; one for the table header and one for data.";
    export const MODEL_CLOSED = "Sheet has been closed. No further operations are allowed.";
    export const ERROR_MODEL_DELETE = "Unable to delete.";
    export const ERROR_ITERATOR_CLOSED = "IteratorContext can only be used during visit.";
    export const ERROR_ITERATOR_NO_CELL_CONTEXT = "IteratorContext can only return a cell if the forEach ignoreCellDetails has not been set to false.";
    export const ERROR_INTERNAL_LISTENER_READ_ONLY = "To write the listener must be registered with the wrTable.IListener option.";
    export const ERROR_ADDRESS_INVALID_SCOPE = "When using addresses directly from the sheet do not include the sheet name.";
    export const ERROR_MAX_VALUES: (max: number) => string;
    export const ERROR_INVALID_CELL_TYPE = "Invalid cell type. See documentation for information on valid built in cell types and creating custom cell types.";
    export const ERROR_SET_VALUES_TYPE = "'setValues' expects a 2d array; when working with a single value use 'setValue'.";
    export const ERROR_SET_VALUE_TYPE = "'setValue' expects a single value; when working with an array use 'setValue'.";
    export const ERROR_SNAPSHOT_DONE = "Unable to use a snapshot multiple times.";
    export const ERROR_COPY_MULTIPLE_RANGES = "Multiple selection ranges can not be copied.";
    export const ERROR_INSERT_COPY_MULTIPLE_RANGES = "Only a single selection is supported when using 'Insert Copy'.";
    export const ERROR_COPY_MISSING_ARGS = "Both a source and a destination are required to copy.";
    export const ERROR_COPY_NO_SOURCE = "The source has no range.";
    export const ERROR_COPY_INVALID_SOURCE = "Unable to determine source.";
    export const ERROR_GET_BY_NAME = "Get by name must take a valid name.";
    export const ERROR_EMPTY_VIEW = "View can not be empty.";
    export const ERROR_UNIQUE_NAME: (name: string) => string;
    export const ERROR_INSERT_CUT_OVERLAP = "When pasting before or after the cut area both areas must align.";
    export const ERROR_INSERT_CUT_SAME_LOCATION = "Cutting and pasting to the same location.";
}
declare module "sheet/ISheetCollection" {
    import type { ICollection } from "type/index";
    import type { ITransaction } from "transaction/index";
    import type { ISheet } from "sheet/ISheet";
    /**
     * Holds a collection of {@link ISheet}s.
     */
    export interface ISheetCollection extends ICollection<ISheet> {
        /**
         * Add an `ISheet` to the collection.
         */
        add(options?: ISheetCollection.AddOptions | string | number): ISheet;
        /**
         * Returns sheets that match the filter criteria.
         *
         * If no filter criteria is provided, all sheets will be returned.
         *
         * @param options {@link ISheetCollection.GetItemsOptions}
         */
        getItems(options?: ISheetCollection.GetItemsOptions): ISheet[];
        /**
         * Returns the sheet at the given index.
         * @param index
         * @returns
         */
        /**
         * Convenience method for filtering by name. This is
         * functionally equivalent to getItems({ name });
         *
         * @param name The name to search for This is case insensitive.
         */
        getByName(name: string): ISheet | null;
    }
    /**
     * {@inheritDoc ISheetCollection}
     * @see
     * ### **Interface**
     *
     * {@link ISheetCollection}
     */
    export namespace ISheetCollection {
        /**
         * Options for adding a sheet to the collection.
         */
        interface AddOptions extends ITransaction.OperationOptions {
            /**
             * The name of the sheet.
             *
             * @defaultValue - A unique name as determined by {@link IWorkbook.ConstructorOptions.createSheetNameCallback}.
             */
            name?: string;
            /**
             *  Position for the sheet.
             * @defaultValue - After the currently active sheet.
             */
            index?: number;
        }
        interface GetItemsOptions extends ICollection.GetItemsOptions {
            /**
             * Indicate if items that are in hidden headers or marked as hidden should be returned.
             * @defaultValue false
             */
            visibility?: ISheet.Visibility;
            /**
             * Search with the given name. This is case insensitive.
             */
            name?: string;
        }
    }
}
declare module "sheet/SheetCollection" {
    import { ISheetCollection } from "sheet/ISheetCollection";
    import { ISheet } from "sheet/ISheet";
    export class SheetCollection implements ISheetCollection {
        private _add;
        private _get;
        constructor(add: (options: ISheetCollection.AddOptions) => ISheet, get: (name?: string, visibility?: ISheet.Visibility) => ISheet[]);
        /** {@inheritDoc ISheetCollection.add} */
        add(options?: ISheetCollection.AddOptions | string | number): ISheet;
        /** {@inheritDoc ISheetCollection.getItems} */
        getItems(options?: ISheetCollection.GetItemsOptions): ISheet[];
        /** {@inheritDoc ISheetCollection.getByName} */
        getByName(name: string): ISheet;
        /** {@inheritDoc ISheetCollection.getCount} */
        getCount(): number;
    }
}
declare module "workbook/_WorkbookUtils" {
    import { IRange } from '@sheetxl/primitives';
    import { ICellRange } from "cellRange/index";
    export const RegExInvalidSheetChars: RegExp;
    export const RegExAutoSheetName: RegExp;
    export const defaultCreateSheetName: (index: number) => string;
    export const createInvalidWorkbookRefRange: (address: Partial<IRange.FixableCoords>, defaultCoords?: IRange.FixableCoords) => ICellRange;
    /**
     * Validates sheet name.
     *
     * The character count **MUST** be greater than or equal to 1 and less than or equal to 31.
     * The string MUST NOT contain the any of the following characters:
     *
     * * 0x0000
     * * 0x0003
     * * colon (:)
     * * backslash (\)
     * * asterisk (*)
     * * question mark (?)
     * * forward slash (/)
     * * opening square bracket ([)
     * * closing square bracket (])
     *
     * The string MUST NOT begin or end with the single quote (') character.
     *
     * @param sheetName the name to validate
     * @throws IllegalArgumentException if validation fails
     * @internal
     */
    export const _validateNewSheetName: (sheetName: string, force?: boolean) => string;
    /**
     * Find a valid sheet name.
     * @internal
     */
    export const findValidSheetName: (str: string, validate: (validating: string) => string) => string;
}
declare module "selection/IRangeSelection" {
    import type { IRange } from '@sheetxl/primitives';
    import type { SelectionCoords as WellKnownSelectionCoords } from '@sheetxl/utils';
    import type { IListener } from "listener/index";
    import type { ISheet } from "sheet/index";
    /**
     * Interface representing a range selection within a sheet.
     */
    export interface IRangeSelection {
        /**
         * Navigates the entire sheet
         *
         * @param direction The direction to navigate.
         * @param select Whether to select the cell after navigating.
         * @param contentful Whether to navigate to contentful cells only.
         * @param incrementAmount The amount to increment.
         * @returns The current instance.
         */
        navigate(direction: IRange.Direction, select?: boolean, contentful?: boolean, incrementAmount?: number): this;
        /**
         * Checks if the entire range is selected.
         * @returns True if the entire range is selected, otherwise false.
         */
        isEntire(): boolean;
        /**
         * Returns the coordinates of the selection.
         * @returns The selection coordinates.
         */
        getCoords(): IRangeSelection.Coords;
        /**
         * Returns the selection as an array of IRange.Coords.
         *
         * @param coords Optional coordinates to convert. If not provided, uses the current selection.
         *
         * @remarks
         * The first element is always the active range.
         */
        getRangesCoords(coords?: Partial<IRangeSelection.Coords>): IRange.Coords[];
        /**
         * Updates the selection coordinates.
         *
         * @param coords The new coordinates.
         * @returns The current instance.
         */
        updateCoords(coords: IRangeSelection.Coords): this;
        /**
         * Traverses the selection, moving to the next cell based on the orientation.
         *
         * @param orientation The orientation to traverse. Default is `ICellRange.Orientation.Row`.
         * @param reverse Whether to traverse in reverse. Default is false.
         * @returns The current instance.
         * @remarks Useful for pressing tab or enter from the UI.
         */
        traverse(orientation?: IRange.Orientation, reverse?: boolean): this;
        /**
         * Updates the selection using a new start and end.
         *
         * @param start The start cell.
         * @param end The end cell. Default is the start cell.
         * @param anchor The anchor cell.
         */
        clearAndModify(start: Partial<IRange.CellCoords>, end?: Partial<IRange.CellCoords>, anchor?: Partial<IRange.CellCoords>): void;
        /**
         * Modifies the selection around the anchor.
         *
         * @param cellAnchor The anchor cell.
         * @param cellPivot The pivot cell.
         * @param resetAnchor Whether to reset the anchor. Default is false.
         */
        modify(cellAnchor: Partial<IRange.CellCoords>, cellPivot?: Partial<IRange.CellCoords>, resetAnchor?: boolean): void;
        /**
         * Clears the range selections.
         *
         * @remarks This does not affect the cell.
         */
        clear(): void;
        /**
         * Appends a selection to the current selection.
         *
         * @param start The start cell.
         * @param end The end cell. Default is the start cell.
         * @param anchor The anchor cell.
         * @remarks This is used to support the CMD key behavior in the UI.
         */
        append(start: IRange.CellCoords, end?: IRange.CellCoords, anchor?: Partial<IRange.CellCoords>): void;
        /**
         * A special range used during drag.
         * @param range The range or null.
         *
         * @remarks
         * This fires an event.
         */
        setAdjusting(range: IRangeSelection.Coords | null): void;
        /**
         * Returns the adjusting range.
         */
        getAdjusting(): IRangeSelection.Coords | null;
        /**
         * Adds listeners to the selection.
         * @param listeners The listeners to add.
         * @param options Options for the listeners.
         * @returns A function to remove the listeners.
         */
        addListeners(listeners: IRangeSelection.IListeners, options?: IListener.Options): IListener.Remove;
    }
    /**
     * {@inheritDoc IRangeSelection}
     * @see
     * ### **Interface**
     *
     * {@link IRangeSelection}
     */
    export namespace IRangeSelection {
        /**
       * Represents a selection of ranges with an active range and an active cell.
       */
        type Coords = WellKnownSelectionCoords;
        /**
         * Type representing different selection policies.
         */
        type SelectionPolicy = 'single' | 'range' | 'multiple';
        /**
         * Type representing different new selection modes.
         */
        type NewSelectionMode = 'clear' | 'modify' | 'append';
        /**
         * Events for {@link IRangeSelection}.
         */
        interface Events {
            /**
             * Called when the selection changes.
             *
             * @param source The source of the event.
             */
            onChange?(source: IRangeSelection): void;
            /**
             * Called when the selection is adjusting.
             *
             * @param source The source of the event.
             */
            onAdjustingChange?(source: IRangeSelection): void;
        }
        /**
         * Listeners for IRangeSelection events.
         */
        interface IListeners extends IListener.Callbacks<IRangeSelection, Events> {
        }
        /**
         * Options for constructing an IRangeSelection.
         */
        interface ConstructorOptions {
            /**
             * The sheet to which the selection belongs.
             */
            sheet: ISheet;
            /**
             * Selection policy.
             */
            selectionPolicy?: IRangeSelection.SelectionPolicy;
            /**
             * New selection mode.
             */
            newSelectionMode?: IRangeSelection.NewSelectionMode;
        }
    }
}
declare module "selection/_RangeSelectionUtils" {
    import { IRange } from '@sheetxl/primitives';
    import { IRangeSelection } from "selection/IRangeSelection";
    /**
     * Scans until finds a visible (non hidden) header.
     *
     * @param hiddenAt Callback
     * @param index The index to start from
     * @param direction The direction to scan
     */
    export const traverseHiddenHeaders: (hiddenAt: HiddenHeadersAt | undefined, index: number, direction: IRange.Direction) => number;
    export const getVisibleHeaders: (hiddenAt: HiddenHeadersAt | undefined, startIndex: number, stopIndex: number) => number[];
    export const EmptyCell: IRange.CellCoords;
    export const EmptyRanges: IRange.Coords[];
    /**
     * Frozen IRangeSelection.Coords for easy comparisons.
     */
    export const EmptySelection: IRangeSelection.Coords;
    export const mergeSelection: (selection: IRangeSelection.Coords, activeSelection: IRangeSelection.Coords, maxRangeCoords: IRange.Coords) => IRangeSelection.Coords;
    /**
     * Cycles active cell within selection range. This has slightly different semantics than regular traversal
     * * wraps
     * * visits each cell once (skipping merged cells after first step)
     * * jumps to next range if multiple ranges are selected
     *
     * @param selection
     * @param direction
     */
    export const findNextCellWithinSelection: (selection: IRangeSelection.Coords, direction: IRange.Direction, getCellCoordsAsRangeCoords: (coords: IRange.CellCoords) => IRange.Coords, hiddenRowsAt?: HiddenHeadersAt, hiddenColumnsAt?: HiddenHeadersAt, originalSelection?: IRangeSelection.Coords) => IRangeSelection.Coords | null;
    export interface HiddenHeadersAt {
        /**
         * A called back to traverse hidden headers
         */
        (index: number, reverse?: boolean): number;
    }
    export interface IsContentfulCell {
        (coords: IRange.CellCoords): boolean;
    }
    export type CellFinder = (activeCoords: IRange.CellCoords, isContentfulCell: IsContentfulCell | undefined, hiddenAt: HiddenHeadersAt | undefined, direction: IRange.Direction, first: boolean, limit: number) => number;
    /**
     * Returns the cells as an ordered list of ranges.  The first range is the active range.
     * If there are no ranges then the active coord will be returns as a range.
     *
     * @remarks
     * * Always return at least 1 range unless the selection is null.
     */
    export const selectionToRangesCoords: (selection: Partial<IRangeSelection.Coords>) => IRange.Coords[];
    /**
     * Creates a IRangeSelection.Coords from an array of ranges.
     *
     * @param ranges The ranges to include in the selection.
     * @param cell If provided will try to fit within the cell
     * @param rangeIndex *default* `ranges.length 1 unless this is a single cell then -1`.
     */
    export const rangesToSelectionCoords: (ranges: readonly IRange.Coords[], cell?: IRange.CellCoords, rangeIndex?: number) => IRangeSelection.Coords;
}
declare module "lib/utils/_Utils" {
    export const getBuildVersion: () => string;
    export const getBuildDate: () => string;
}
declare module "lib/utils/banner" {
    export const BANNER_IMAGE = "\n\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2557\n\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D \u255A\u2588\u2588\u2557\u2588\u2588\u2554\u255D\u2588\u2588\u2551\n\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557     \u2588\u2588\u2551     \u255A\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551\n\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u255D     \u2588\u2588\u2551     \u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\n\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2551    \u2588\u2588\u2554\u255D \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\n\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D   \u255A\u2550\u255D    \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D";
    export const BANNER_TEXT: string;
    export const sheetXLBlue = "#1976d2";
    export const sheetXLRed = "#E12929";
    export const sheetXLYellow = "#FFA726";
}
declare module "lib/utils/utils.node" {
    import { LicenseDetails } from "license/index";
    export const generateNodeId: () => Promise<string>;
    export const setKey: (key: string, force?: boolean) => Promise<void>;
    export const getKey: () => Promise<string>;
    export const printBanner: (isUser: boolean) => Promise<void>;
    export const printDetails: (details: LicenseDetails, isUser?: boolean, expanded?: boolean, ignoreExceptions?: boolean) => Promise<void>;
}
declare module "license/LicenseDetails" {
    /**
     * @hidden
     */
    export interface LicenseDetails {
        getLicensee(): string | null;
        getExpiration(): Date | null;
        getDomains(): string[];
        getCpuCount(): number;
        isEval(): boolean;
        isValidFor: (feature: string) => boolean;
        getDeveloperCount(): number;
        getType(): string;
        getExceptions(): string[];
        hasExceptions(): boolean;
        isValid(): boolean;
        getFeatures(): Readonly<Record<string, string>>;
        getKeyFrom(): string;
        getBuildVersion(): string;
        getBuildDate(): string;
    }
}
declare module "license/license-key" {
    import { type LicenseDetails } from "license/LicenseDetails";
    export interface Decoded {
        licensee: string | null;
        developerCount: number;
        cpuCount: number;
        type: string;
        features: string[];
        expiry: number;
        domains: string[];
        nodeId: string | null;
    }
    export interface LicenseAndKey {
        details: LicenseDetails;
        key: string;
    }
    export interface LicenseKeyDetails {
        licensee: string;
        domains?: string | string[];
        nodeId?: string | null;
        cpuCount?: number | null;
        expiration?: string;
        developerCount?: number;
        type?: string;
        features?: Record<string, any> | null;
        allowDomain?: boolean;
    }
    export const rot: (text: string, key: number, n?: number) => string;
    export const deobs: (str: string) => Decoded;
    export const encodeLicenseKey: (keyDetails: LicenseKeyDetails) => LicenseAndKey;
    export const validateDomain: (domain: string, allowDomain?: boolean) => boolean;
    export const validateNodeId: (nodeId: string | null) => boolean;
}
declare module "license/LicenseManager" {
    import { LicenseDetails } from "license/LicenseDetails";
    class LM {
        constructor();
        /**
         * Set the license key provided by SheetXL.
         * @remarks
         * The license key can also be provided via a file named `sheetxl.lic` in the root of the web server.
         *
         * @param licenseKey The license key as a string.
         * @param force If set to `true` will replace an existing key.
         *
         * @see
         * {@link https://www.sheetxl.com/docs/guides/getting-started/license-key | License Keys}
         */
        setLicenseKey(licenseKey: string, force?: boolean): Promise<LicenseDetails>;
        private _validate;
        private _printBanner;
        private _printDetails;
        private _doPrint;
        private _print;
        getDetails(): Promise<LicenseDetails>;
        /**
         * Print just the banner
         */
        print(expanded?: boolean): Promise<void>;
        wasPrinted(): boolean;
        /**
         * Disable printing of the banner for a period of time.
         *
         * @param The reason for suppressing the license
         *
         * @remarks
         * Call this to disable the license key watermark for a period of time.
         * This is useful for testing purposes.
         */
        suppressPrint(reason: string): void;
        /**
         * Print just the banner
         */
        printBanner(): Promise<void>;
        /**
         * Print the current license details.
         */
        printDetails(expanded?: boolean, ignoreExceptions?: boolean): Promise<LicenseDetails>;
        /**
         * Generate a unique node ID.
         * @returns The generated node ID.
         *
         * @remarks
         * This will return null in the browser.
         */
        getNodeId(): Promise<string>;
    }
    /**
     * LicenseManager is used to manage license keys at runtime.
     *
     * License keys can be generated by visiting {@link https://www.sheetxl.com/docs/guides/getting-started/license-key | License Keys}.
     */
    const LicenseManager: LM;
    export default LicenseManager;
    export { LicenseManager };
}
declare module "license/index" {
    export * from "license/LicenseManager";
    export * from "license/LicenseDetails";
}
declare module "autoFill/IAutoFill" {
    /**
     * The `IAutoFill` namespace provides capabilities for applying and managing auto-fill operations
     * within a spreadsheet. Auto-fill enables automatic generation of data based on patterns in existing data.
     *
     * ## Key Features:
     * - **Linear Fill**: Automatically generate sequential values for numbers or dates, continuing from existing patterns.
     * - **Ordinal Fill**: Fill data based on strings with numeric identifiers (e.g., Point 1, Point 2, Point 3).
     * - **List Fill**: Populate ranges with repeating values from predefined lists.
     * - **Custom Fill Handlers**: Extend auto-fill capabilities by providing custom logic for generating fill data.
     *
     * ## Motivation:
     * The `IAutoFill` namespace is designed to streamline the process of generating predictable data
     * patterns in a spreadsheet. By identifying existing patterns and applying them to empty ranges,
     * users can efficiently populate large datasets with minimal manual input.
     *
     * Auto-fill supports both built-in patterns, such as numbers and dates, and allows users or developers
     * to define their own custom fill rules to meet specific use cases.
     *
     * This namespace provides the necessary APIs to:
     * - Detect and extend patterns in existing data.
     * - Customize the fill behavior for specific types of data.
     * - Handle edge cases, such as non-contiguous ranges or mixed data types.
     *
     * Auto-fill reduces repetitive tasks, improving productivity and minimizing errors when working with large datasets.
     */
    export namespace IAutoFill {
        /**
         * Represents a filler capable of determining if it can fill a value and creating
         * an {@link IAutoFill.FillAt} function for generating filled values within a single dimension (row or column).
         */
        interface Filler<T = any> {
            /**
             * Determines if the Filler can add value to the current fill.
             *
             * @param value The value to test. Can be any type or `null`.
             * @param prev The previous value in the candidate set that is not a null. This is `undefined` for the first element.
             * @returns `true` if the value should be added.
             *
             * @remarks
             * * The fill array should be treated as readonly.
             * * The value may be any type and should return `false` if it's not supported.
             */
            canFill: (value: any, prev: any | undefined) => boolean;
            /**
             * Create a {@link IAutoFill.FillAt} function using the provided values and options.
             *
             * @remarks
             * * The first elements in the values is guaranteed to never be `null`.
             * * Return `null` if the autofill is unable to fill.
             */
            createFillAt: (values: readonly T[], options?: IAutoFill.Options) => FillAt<T> | null;
        }
        /**
         * Represents a callback function that provides the filled value at a given offset
         * within a one-dimensional sequence (either a row or a column).
         */
        interface FillAt<T = any> {
            /**
             * @param offset 0-based offset from first value.
             */
            (offset: number): T | null;
        }
        /**
         * Options used when calling {@link IAutoFill.Filler.createFillAt}.
         */
        interface Options {
            /**
             * Override the default increment or step value used when generating a fill.
             * * The default it to use the existing values to determine.
             *
             * @remarks
             * **NOT IMPLEMENTED**
             *
             * @example
             * For `AutoFill.LinearFill` customize the increment between consecutive numbers
             * in a series (e.g., 1, 3, 5 with `stepValue: 2`).
             */
            stepValue?: number;
            /**
             * The stopping value for autofill operations that generate a fill.
             *
             * @remarks
             * **NOT IMPLEMENTED**
             *
             * - Allow users to specify the maximum value up to which the autofill series should continue.
             */
            stopValue?: number;
            /**
             * Indicates whether there is adjacent span with a different fill type.
             *
             * @remarks
             * - **Purpose:** This flag allows Fillers to adjust their behavior based on the presence of adjacent fills.
             *   For instance, a numeric Filler might increment by 1 when there's an adjacent fill, but simply copy the value otherwise.
             */
            hasDifferentAdjacentFill?: boolean;
            /**
             * Indicates whether there is adjacent span with the same fill type.
             *
             * @see
             * {@link hasDifferentAdjacentFill}
             */
            hasSameTypeAdjacentFill?: boolean;
            /**
             * Indicates whether there is another fill operation being performed in the same series.
             */
            multiFill?: boolean;
            /**
             * Indicates whether the fill operation is in reverse order.
             *
             * @remarks
             * If in reverse order the createFill fill be given values in reverse order.
             * This flag is only needed if there is a single value.
             */
            reverse?: boolean;
        }
    }
}
declare module "text/TextFrame" {
    import { type Size, type Bounds, type Rectangle } from '@sheetxl/utils';
    import { TextVisitor } from "text/TextVisitor";
    import { ITextLine } from "text/TextLine";
    import { ITextParagraph } from "text/TextParagraph";
    import { ITextFrame } from "text/ITextFrame";
    import { ITextBoxAlignment } from "text/TextBoxAlignment";
    import { IStyledFont } from "text/richtext/index";
    export class TextFrame {
        private _private;
        private _bounds;
        private _textBounds;
        private _lines;
        private _lastLayoutSize;
        private _lastLayout;
        private _defaultFont;
        private _alignment;
        constructor(overrides: Partial<ITextFrame>, defaultFont: IStyledFont, alignment: ITextBoxAlignment, lines?: ITextLine[], bounds?: Bounds, textBounds?: Bounds);
        visitParas(visitor: TextVisitor): void;
        visitLines(visitor: TextVisitor): void;
        layout(size?: Partial<Size>): ITextFrame;
        clone(visitor?: TextVisitor): ITextFrame;
        equals(other: ITextParagraph): boolean;
        /** {@inheritDoc ITextFrame.createTemporaryTextFrame} */
        createTemporaryTextFrame(text: string, allowWrap?: boolean): ITextFrame;
        get bounds(): Bounds;
        get textBounds(): Bounds;
        get lines(): ITextLine[];
        get wrapped(): boolean;
        get insets(): Rectangle;
        get orientation(): ITextFrame.Orientation;
        get autoFit(): ITextFrame.Autofit;
        get fontScale(): number;
        get vertical(): boolean;
        get columnCount(): number;
        get columnSpacing(): number;
        get verticalAlignment(): ITextFrame.VerticalAlignment;
        get horizontalCentered(): boolean;
        get lineReduction(): number;
        get isSpaceFirstLastPara(): boolean;
        get presetTextWarp(): string;
        get paragraphs(): ITextParagraph[];
    }
}
declare module "text/TextWrapper" {
    import { IFont } from "font/index";
    /**
     * Simple Text Line Wrapper. Is not useful for Rich Text (yet). see TextLayout.
     */
    export interface TextWrapperOptions {
        fontName: string;
        fontSize: number;
        maxWidth?: number;
        maxHeight?: number;
        /**
         * defaults to 0
         */
        letterSpacing?: number;
        bold?: boolean;
        italic?: boolean;
        /**
         * If the text is a superscript or a subscript.
         * This affects the width but not the height of the line.
         */
        superSub?: boolean;
        indent?: number;
    }
    export interface TextWrapperResults {
        bounds: {
            x: number;
            y: number;
            width: number;
            widthWhitespace: number;
            height: number;
        };
        lines: Line[];
    }
    export interface Line {
        text: string;
        startPosition: number;
        x: number;
        y: number;
        width: number;
        widthWhitespace: number;
        height: number;
        baseline: number;
    }
    export interface onLine {
        (line: Line): boolean | void;
    }
    export const linesToText: (lines: Line[], trimTrailingSpace?: boolean) => string;
    /**
     * A simple text wrapper that uses a line breaker to break lines.
     *
     * *PERFORMANCE OPTIMIZATIONS*
     * - Binary search for wordBreak
     * - Reuse all of the objects. (this should support a reuse flag and it lines are not needed then they can also be internally reused)
     * - Have text measure for collapsed text just calc the difference between the two (just trailing whitespace, is there kerning?)
     */
    export class TextWrapper {
        private _textMeasurer;
        private _breaker;
        private _lastBreak;
        private _charactersRead;
        private _linesRead;
        private _maxXRead;
        private _maxXWhitespaceRead;
        private _maxYRead;
        private _fontName;
        private _fontSize;
        private _metricOptions;
        private _indent;
        private _isSuperSub;
        private _ellipsis;
        private _maxWidth;
        private _maxHeight;
        constructor(textMeasurer: IFont.Measurer);
        private _measureText;
        private _breakWord;
        private _breakWhiteSpace;
        wrap(text: string, options?: TextWrapperOptions): TextWrapperResults;
    }
}
declare module "text/_TextUtils" {
    import { type Size } from '@sheetxl/utils';
    import { IFont } from "font/index";
    import { ITextFrame } from "text/ITextFrame";
    import { ITextBoxAlignment } from "text/TextBoxAlignment";
    import { IStyledFont } from "text/richtext/IStyledFont";
    /**
     * This 'places' text which means that using all of the formatting rules it assign's locations and bounds to
     * all of the characters. It does not however actually render them. See @renderTextFrame for rendering.
     *
     * @param textFrame
     * @param dimensions
     * @param textMeasurer This defaults to a canvas context
     */
    export const layoutTextFrame: (textFrame: ITextFrame, defaultFont: IStyledFont, alignment: ITextBoxAlignment, dimensions?: Partial<Size>, textMeasurer?: IFont.Measurer) => ITextFrame;
    /**
     * Checks whether a string is entirely uppercase, lowercase, or mixed case.
     *
     * @param str The input string to be evaluated.
     * @returns `1` if the string is all uppercase, `-1` if the string is all lowercase, and `0` if the string contains both uppercase and lowercase characters.
     *
     * @example
     * ```
     * checkCase("HELLO");  // Returns 1
     * checkCase("hello");  // Returns -1
     * checkCase("Hello");  // Returns 0
     * ```
     */
    export const detectCapitalize: (str: string) => number;
    /**
     * Analyzes the casing of each character in the string and returns an array of numbers.
     *
     * @param str The input string to be evaluated.
     * @returns An array of numbers where:
     * - `1` indicates that the character is uppercase.
     * - `-1` indicates that the character is lowercase.
     * - `0` indicates that the character is non-alphabetic.
     *
     * @example
     * ```
     * analyzeCase("Hello123");  // Returns [1, -1, -1, -1, -1, 0, 0, 0]
     * analyzeCase("ALL_CAPS");  // Returns [1, 1, 1, 0, 1, 1, 1, 1]
     * analyzeCase("lowercase"); // Returns [-1, -1, -1, -1, -1, -1, -1, -1, -1]
     * ```
     */
    export const analyzeCase: (str: string) => readonly number[];
    /**
     * Converts a given string to match the casing specified by an array of numbers.
     *
     * @param str The input string to be converted.
     * @param caseArray An array of numbers representing the desired casing for each character.
     * - `1` indicates that the character should be uppercase.
     * - `-1` indicates that the character should be lowercase.
     * - `0` indicates that the character should remain unchanged.
     *
     * @returns A new string with characters converted to match the specified casing.
     *
     * @example
     * ```
     * const original = "Hello123";
     * const caseArray = analyzeCase(original); // [1, -1, -1, -1, -1, 0, 0, 0]
     * convertCase("WORLD456", caseArray); // Returns "World456"
     * ```
     */
    /**
     * Converts a given string to match the casing specified by an array of numbers.
     *
     * @param str The input string to be converted.
     * @param caseArray An array of numbers representing the desired casing for each character.
     * - `1` indicates that the character should be uppercase.
     * - `-1` indicates that the character should be lowercase.
     * - `0` indicates that the character should remain unchanged.
     *
     * @returns A new string with characters converted to match the specified casing.
     *
     * @example
     * ```
     * const original = "Hello123";
     * const caseArray = analyzeCase(original); // [1, -1, -1, -1, -1, 0, 0, 0]
     * convertCase("WORLD456", caseArray); // Returns "World456"
     * ```
     */
    export const convertCase: (str: string, caseArray: readonly number[]) => string;
    /**
     * Create a simple text frame.
     * TODO - Later we will make take frame take the style (and theme?) and have more operations on it.
     * TODO - abstract CellStyle
     * @internal
     */
    export const createTextFrameFromText: (text: string, defaultFont: IStyledFont, alignment: ITextBoxAlignment, allowWrap: boolean, disableCustomFormatting?: boolean) => ITextFrame;
}
declare module "utils/_GeomUtils" {
    import { Bounds } from '@sheetxl/utils';
    export const angleToPoints: (angleDeg: number, rectBounds: Bounds) => {
        x1: number;
        y1: number;
        x2: number;
        y2: number;
    };
    /**
     * Rotate a bound by a given degree using the center as the origin
     */
    export const rotateBounds: (bounds: Bounds, deg: number) => Bounds;
    /**
     * Adapted from https://medium.com/@sahirnambiar/linear-least-squares-a-javascript-implementation-and-a-definitional-question-e3fba55a6d4b
     * @internal @hidden
     */
    export const leastSquaresSlopeAndIntercept: (values: readonly number[]) => {
        m: number;
        b: number;
    };
}
declare module "autoFill/AutoFill" {
    import { DateUnit } from "date/_DateUtils";
    import { IAutoFill } from "autoFill/IAutoFill";
    type JavaScriptDate = Date;
    export 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: JavaScriptDate[], options?: DateOptions): IAutoFill.FillAt<JavaScriptDate>;
        }
        /**
         * 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>;
        }
        /**
         * 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>;
        }
        /**
         * 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[];
    }
}
declare module "autoFill/index" {
    export type * from "autoFill/IAutoFill";
    export * from "autoFill/AutoFill";
}
declare module "movable/IMovableCollection" {
    import { Bounds } from '@sheetxl/utils';
    import { ICollection } from "type/index";
    import { IAnchored } from "anchored/index";
    import { IResource, IResourceCollection } from "resource/index";
    import { IListener } from "listener/index";
    import { ICellRange } from "cellRange/index";
    import { IMovable } from "movable/IMovable";
    import { ITransaction } from "transaction/index";
    /**
     * Holds a collection of IMovables.
     */
    export interface IMovableCollection extends ICollection<IMovable>, IListener.ISource<IMovableCollection> {
        /**
         * Add a resource to the movable collection.
         *
         * @param options {@link IMovableCollection.AddOptions}
         * @returns A new {@link IMovable}.
         */
        add(options?: IMovableCollection.AddOptions): Promise<IMovable>;
        /**
         * Returns movables that match the filter criteria.
         *
         * @param options {@link IMovableCollection.GetItemsOptions}
         * @returns An Array of {@link IMovable}.
         *
         * @remarks
         * If no filter criteria is provided, all items will be returned.
         */
        getItems(options?: IMovableCollection.GetItemsOptions): IMovable[];
        /**
         * Update all of the selected movable in a single transaction
         */
        updateSelected(update: (movable: IMovable) => void, action?: string): void;
        /**
         * Add an image to the current sheet.
         * Returns an IMovableImage that can be used to manipulate the image or remove it.
         *
         * @param image This can be either string to a url, a Resource or an IResource.AddOptions
         * @param options {@link IMovableCollection.AddOptions}
         * @returns A Promise that will resolve to the new Movable.
         */
        addImage(image: string | IResource | IResourceCollection.AddOptions, options?: IMovableCollection.AddOptions): Promise<IMovable>;
        /**
         * Add Listeners.
         *
         * @see
         * {@link IListener.ISource.addListeners}
         */
        addListeners(listeners: ICollection.IListeners, options?: IListener.Options): IListener.Remove;
    }
    /**
     * {@inheritDoc IMovableCollection}
     * @see
     * ### **Interface**
     *
     * {@link IMovableCollection}
     */
    export namespace IMovableCollection {
        /**
         * Options for filtering a collection of movables.
         */
        interface GetItemsOptions extends ICollection.GetItemsOptions {
            /**
             * If provided, the search will be limited to items that intersect the range.
             * @remarks
            */
            address?: ICellRange.Address;
            /**
             * Indicate if items that are in hidden headers or marked as hidden should be returned.
             * @defaultValue false
             */
            ignoreHidden?: boolean;
            /**
             * The type to search for. If not provided all items will be returned.
            */
            type?: string;
            /**
             * Only find items in this bounds.
             * @defaultValue Search all
             */
            bounds?: Bounds;
            /**
             * Only return items that are completely contained with the search bounds.
             * @defaultValue false
             */
            fullyContained?: boolean;
        }
        /**
         * Options for adding a movable to the collection.
         */
        interface AddOptions<J = any> extends ITransaction.OperationOptions {
            /**
             * The type of movable to add.
             */
            type?: string;
            /**
             * Initial json value.
             */
            json?: J;
            /**
             * If a referenceId is provided then the movable will be linked to the resource.
             * @param resourceId
             * @returns IResource
             */
            fromResourceId?: (resourceId: number) => IResource;
            /**
             * The boundary for the movable object in pixels.
             */
            bounds?: Partial<Bounds>;
            /**
             * The behavior of how the movable resizes as the anchor/cells change.
             */
            anchorType?: IAnchored.Type;
            /**
             * If unspecified no selection will occur.
             *
             * @remarks
             * Overrides the default autoSelect to include {@link IMovable.SelectOptions} options.
             */
            autoSelect?: boolean | IMovable.SelectOptions;
        }
    }
}
declare module "anchored/_AnchorMessages" {
    export const MODEL_CLOSED = "Item has been closed. No further operations are allowed.";
    export const ERROR_PROTECTED = "Unable to update. The item is protected.";
}
declare module "anchored/AbstractAnchored" {
    import { IRange } from '@sheetxl/primitives';
    import { ITransaction } from "transaction/index";
    import { IListener } from "listener/index";
    import { IAnchored } from "anchored/IAnchored";
    import { ListenerEmitter } from "listener/ListenerEmitter";
    /**
     * Abstract implement of {@link IAnchorItem}.
     */
    export abstract class AbstractAnchored<STATE extends AbstractAnchored.State = AbstractAnchored.State, VIEW extends AbstractAnchored.CommitView = AbstractAnchored.CommitView, EVENTS extends IAnchored.Events = IAnchored.Events> implements IAnchored, IListener.ISource<IAnchored> {
        protected _emitter: ListenerEmitter<IAnchored, EVENTS>;
        protected _options: IAnchored.ConstructorOptions;
        private _transactions;
        private _transactionsRemoveListener;
        private _closed;
        constructor(options: IAnchored.ConstructorOptions);
        /** @internal */
        protected _getEmitter<SOURCE, E extends EVENTS>(): ListenerEmitter<SOURCE, E>;
        /** {@inheritDoc IAnchored.delete} */
        delete(options?: ITransaction.OperationOptions): void;
        /** {@inheritDoc IAnchored.getAnchorCoords} */
        getAnchorCoords(): IRange.Coords;
        /** {@inheritDoc IAnchored.getAnchorType} */
        getAnchorType(): IAnchored.Type;
        /** {@inheritDoc IAnchored.isProtected} */
        isProtected(): boolean;
        /** {@inheritDoc ITransaction.ITransactional.beginCommit} */
        beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
        protected _getState(): Readonly<STATE>;
        protected _beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
        protected _getTransactions(): ITransaction.IStore;
        protected _updateState(updateState?: Partial<STATE>, //(prevState: STATE) => STATE,
        options?: ITransaction.OperationOptions, events?: (keyof EVENTS)[]): this;
        /** @internal */
        protected _processContainerShift(options: IAnchored.ShiftOptions): IRange.Coords | void;
        /** @internal */
        protected _processBeforeCommitStart(_state: STATE, _view: VIEW, _commit: ITransaction.ICommit): void;
        /** @internal */
        protected _processStateChange(_state: STATE, _view: VIEW, _commit: ITransaction.ICommit): void;
        /** @internal */
        protected _processRestoreOrRevert(_state: STATE, _view: VIEW, _commit: ITransaction.ICommit): void;
        /** @internal */
        protected _processAnchorCoords(): void;
        /** @internal */
        protected _processContainerLayout(): void;
        /** @internal */
        protected _getDescription(): string;
        /** @internal */
        protected _delete(): void;
        /** @internal */
        protected _processContainerDelete(): void;
        /** @internal */
        protected _processDelete(): void;
        /** @internal */
        protected _processContainerProtection(): void;
        /** {@inheritDoc IListener.ISource.addListeners} */
        addListeners(listeners: IListener.Callbacks<IAnchored, EVENTS>, options?: IListener.Options): IListener.Remove;
        /** {@inheritDoc IAnchored.isClosed} */
        isClosed(): boolean;
        /** @internal */
        protected _processClose(): void;
        /** {@inheritDoc IAnchored.close} */
        close(): void;
        /** {@inheritDoc IAnchored.isIAnchored} */
        get isIAnchored(): true;
    }
    /**
     * Interfaces for creating `IAnchored`.
     *
     * @see
     * ### **Interface**
     *
     * {@link AbstractAnchored}
     * @internal
     */
    export namespace AbstractAnchored {
        interface State {
            anchor: IRange.Coords;
            anchorType: IAnchored.Type;
            isDeleted: boolean;
        }
        interface CommitView {
        }
    }
}
declare module "movable/Movable" {
    import { Bounds, Point, ReferenceableClipboard } from '@sheetxl/utils';
    import { IRange } from '@sheetxl/primitives';
    import { IResource, IResourceCollection } from "resource/index";
    import { ITransaction } from "transaction/index";
    import { IAnchored } from "anchored/index";
    import { IModel } from "model/index";
    import { IMovable } from "movable/IMovable";
    import { AbstractAnchored } from "anchored/AbstractAnchored";
    import { IHistory } from "history/index";
    import { IListener } from "listener/index";
    interface MovableOffsets {
        tl: Point;
        br: Point;
    }
    interface State extends AbstractAnchored.State {
        name?: string;
        description?: string;
        hidden?: boolean;
        rotation?: number;
        lockAspectRatio?: boolean;
        offsets?: MovableOffsets;
        bounds?: Bounds;
        contentListenerRemove: IListener.Remove;
    }
    interface CommitView extends AbstractAnchored.CommitView {
    }
    export class Movable<J extends IMovable.JSON = IMovable.JSON, STATE extends State = State, VIEW extends CommitView = CommitView> extends AbstractAnchored<STATE, VIEW, IMovable.Events> {
        static instanceCounter: number;
        private _uuid;
        protected _content: Movable.Content;
        private _optionsMovable;
        constructor(options: Movable.ConstructorOptions<J>);
        /** {@inheritDoc IMovable.getUUID} */
        getUUID(): string;
        getContent(): Movable.Content;
        protected _processStateChange(state: STATE, view: VIEW, commit: ITransaction.ICommit): void;
        protected _processZIndex(): void;
        protected _processContainerSelect(_selected: boolean, _first: boolean): IRange.Coords | void;
        /** {@inheritDoc IMovable.isSelected} */
        isSelected(): boolean;
        /** {@inheritDoc IMovable.isSelected} */
        scrollIntoView(options?: globalThis.ScrollIntoViewOptions | boolean): Promise<boolean>;
        /** {@inheritDoc IMovable.select} */
        select(options?: IMovable.SelectOptions): Promise<boolean>;
        /** {@inheritDoc IMovable.unselect} */
        unselect(): boolean;
        protected _clone(): Movable;
        /** {@inheritDoc IHistory.ISnapshotSource.getSnapshot} */
        getSnapshot(bounds: Bounds, options?: ReferenceableClipboard.CopyOptions): IHistory.ISnapshot<IMovable.SnapshotDestination, IMovable, Bounds>;
        protected _doCopy(destination: IMovable.SnapshotDestination, options?: IMovable.CopyOptions): Promise<void>;
        /** For easy overriding in subclass to implement ISnapshot */
        protected _toText(): Promise<string> | string;
        /** For easy overriding in subclass to implement ISnapshot */
        protected _toHtml(): Promise<string> | string;
        /** For easy overriding in subclass to implement ISnapshot */
        protected _toImage(): Promise<Blob> | Blob;
        /** {@inheritDoc IMovable.setName} */
        setName(name: string): this;
        /** {@inheritDoc IMovable.getName} */
        getName(): string;
        /** {@inheritDoc IMovable.setDescription} */
        setDescription(description: string): this;
        /** {@inheritDoc IMovable.getDescription} */
        getDescription(): string;
        /** {@inheritDoc IMovable.setHidden} */
        setHidden(hidden?: boolean): this;
        /** {@inheritDoc IMovable.isHidden} */
        isHidden(): boolean;
        /** {@inheritDoc IMovable.setLockAspectRatio} */
        setLockAspectRatio(lockAspectRatio: boolean): this;
        /** {@inheritDoc IMovable.isLockAspectRatio} */
        isLockAspectRatio(): boolean;
        /** {@inheritDoc IMovable.setRotation} */
        setRotation(rotation?: number): this;
        /** {@inheritDoc IMovable.getRotation} */
        getRotation(): number;
        /** {@inheritDoc IMovable.moveToBack} */
        moveToBack(): this;
        /** {@inheritDoc IMovable.moveBackward} */
        moveBackward(): this;
        /** {@inheritDoc IMovable.moveToFront} */
        moveToFront(): this;
        /** {@inheritDoc IMovable.moveForward} */
        moveForward(): this;
        /** {@inheritDoc IMovable.getZIndex} */
        getZIndex(): number;
        /** {@inheritDoc IMovable.setBounds} */
        setBounds(bounds: Partial<Bounds>, options?: ITransaction.OperationOptions): this;
        private _updateMovableLocation;
        private _calcAbsoluteBounds;
        /** {@inheritDoc IMovable.getBounds} */
        getBounds(): Bounds;
        /** {@inheritDoc IMovable.setAnchorType} */
        setAnchorType(type: IAnchored.Type): this;
        protected _processContainerShift(options: IAnchored.ShiftOptions): IRange.Coords | void;
        protected _invalidateBounds(): void;
        protected _processContainerDelete(): void;
        protected _processContainerLayout(): void;
        protected _processAnchorCoords(): void;
        protected _fromJSON(json: IMovable.JSON): void;
        toJSON(toResourceId?: (resource: IResource) => number): IMovable.JSON;
        /** {@inheritDoc IMovable.isIMovable} */
        get isIMovable(): true;
    }
    /**
     * Interfaces for creating `AnchoredMovable` items.
     *
     * @see
     * ### **Interface**
     *
     * {@link Movable}
     */
    export namespace Movable {
        interface Content<J = any> extends IModel {
            /**
             * A description for the type.
             */
            getTypeDescription(): string;
            /**
             * A description for the instance.
             */
            getDescription?(): string;
            /**
             * Create a json object.
             */
            toJSON(_toResourceId?: (resource: IResource) => number): J;
        }
        /**
         * Options for creating a movable object and adding to a movable container.
         */
        interface ConstructorOptions<J = any> extends IAnchored.ConstructorOptions {
            /**
             * The content of the movable.
             */
            content: Movable.Content<J>;
            /**
             * If provided the movable will be added to the resource manager.
             */
            /**
             * Returns an IResource from the resourceId or null if not found.
             */
            fromResourceId?: (resourceId: number) => IResource;
            /**
             * Useful for load/save/copying.
             */
            beginPersistResource: () => IResourceCollection.IPersistScope<IResource.JSON>;
            /**
             * The initial JSON to load the movable from.
             */
            json?: IMovable.JSON<J>;
            /**
             * Returns the maximum bounds of the container. If not defined the container will be unbounded.
             */
            getMaxBounds?: () => Bounds;
            /**
             * Returns the bounds of a range of cells.
             */
            getBoundsAtCoords: (coords: IRange.Coords) => Bounds;
            /**
             * Returns an anchor coords for the given bounds.
             */
            getCoordsAtBounds: (bounds: Bounds) => IRange.Coords;
            /**
             * Move movable to the back in the zIndex.
             */
            moveToBackOnContainer?: () => void;
            /**
             * Move movable backward one layer in the zIndex.
             */
            moveBackwardOnContainer?: () => void;
            /**
             * Move movable to the font in the zIndex.
             */
            moveToFrontOnContainer?: () => void;
            /**
             * Move movable forward one layer in the zIndex.
             */
            moveForwardOnContainer?: () => void;
            /**
             * Returns the z-index for the current Movable.
             */
            getZIndex?: () => number;
            /**
             * Notify movable it's zIndex has been updated from the container.
             */
            setContainerZIndexCallback?: (callback: () => void) => void;
            /**
             * Notify the movable that it's selection status change changed.
             */
            setContainerSelectionCallback?: (callback: (selected: boolean, first: boolean) => void) => void;
            /**
             * Returns a boolean indicating if the select was successful.
             * @see {@link IMovable.select}
             */
            select?: (options?: IMovable.SelectOptions) => Promise<boolean>;
            /**
             * @see {@link IMovable.unselect}
             */
            unselect?: () => boolean;
            /**
             * Scroll the movable into view.
             */
            scrollIntoView?: (options?: globalThis.ScrollIntoViewOptions | boolean) => Promise<boolean>;
            /**
             * Returns the a flag if the movable is selected.
             */
            isSelected?: () => boolean;
            /**
             * Allow for the default lock aspect ratio to be overwritten.
             */
            defaultLockAspectRatio?: boolean;
        }
    }
}
declare module "movable/MovableCollection" {
    import { ICollection } from "type/index";
    import { IListener } from "listener/index";
    import { IResource, IResourceCollection } from "resource/index";
    import { IMovable } from "movable/IMovable";
    import { IMovableCollection } from "movable/IMovableCollection";
    export class MovableCollection implements IMovableCollection {
        private _add;
        private _getItems;
        private _getCount;
        private _updateSelected;
        private _addListeners;
        private _addImage;
        constructor(add: (options?: IMovableCollection.AddOptions) => Promise<IMovable>, getItems: (options?: IMovableCollection.GetItemsOptions) => IMovable[], getCount: () => number, updateSelected: (update: (movable: IMovable) => void, action?: string) => void, addListeners: (listeners: ICollection.IListeners, options?: IListener.Options) => IListener.Remove, addImage: (image: string | IResource | IResourceCollection.AddOptions, options?: IMovableCollection.AddOptions) => Promise<IMovable>);
        /** {@inheritDoc IMovableCollection.add} */
        add(options?: IMovableCollection.AddOptions): Promise<IMovable>;
        /** {@inheritDoc IMovableCollection.getItems} */
        getItems(options?: IMovableCollection.GetItemsOptions): IMovable[];
        /** {@inheritDoc IMovableCollection.getCount} */
        getCount(): number;
        /** {@inheritDoc IMovableCollection.updateSelected} */
        updateSelected(update: (movable: IMovable) => void, action?: string): void;
        /** {@inheritDoc IMovableCollection.addListeners */
        addListeners(listeners: ICollection.IListeners, options?: IListener.Options): IListener.Remove;
        /** {@inheritDoc IMovableCollection.addImage */
        addImage(image: string | IResource | IResourceCollection.AddOptions, options?: IMovableCollection.AddOptions): Promise<IMovable>;
    }
}
declare module "picture/IPicture" {
    import type { Size } from '@sheetxl/utils';
    import type { IListener } from "listener/index";
    import type { IResource } from "resource/index";
    import type { IModel } from "model/index";
    /**
     * Interface for working with Pictures (both Images and SVG).
     */
    export interface IPicture extends IModel {
        toJSON(toResourceId?: (resource: IResource) => number): IPicture.JSON;
        /**
         * Returns an image blob.
         */
        toImage(): Promise<Blob>;
        /**
         * Return an html string.
         */
        toHtml(): Promise<string> | string;
        /**
         * Returns a local object URL for placing in an image tag.
         */
        getDetails(): Promise<IPicture.Details>;
    }
    /**
     * {@inheritDoc IPicture}
     * @see
     * ### **Interface**
     *
     * {@link IPicture}
     */
    export namespace IPicture {
        /**
         * A set of values that can be set on an IPicture.
         *
         * @see
         * {@link IPicture}
         */
        interface Properties {
        }
        interface JSON {
            resId?: number;
            effects?: string[];
        }
        interface Details {
            /**
             * The size of the image without any constraints. This info is determined by the file.
             */
            getNaturalSize(): Size;
            /**
             * As a url that can be attached to the dom.
             */
            asUrl(): string;
            /**
             * For SVG text.
             */
            asSVGText(): string | null;
        }
        interface Events extends IModel.Events {
        }
        interface IListeners extends IListener.Callbacks<IPicture, IPicture.Events> {
        }
    }
}
declare module "picture/Picture" {
    import { IResource, IResourceCollection } from "resource/index";
    import { IModel, AbstractModel } from "model/index";
    import { IPicture } from "picture/IPicture";
    interface State extends AbstractModel.State {
        effects?: string[];
    }
    /**
     * Implementation for {@link IPicture}.
     */
    export class Picture extends AbstractModel<State, IPicture.JSON> implements IPicture {
        private _resource;
        private _details;
        private _dataUrl;
        constructor(options: Picture.ConstructorOptions);
        /** {@inheritDoc IPicture.getType} */ getType(): string;
        toJSON(toResourceId?: (resource: IResource) => number): IPicture.JSON;
        getTypeDescription(): string;
        /** @internal */
        protected _asDataUrl(): Promise<string>;
        /** {@inheritDoc IPicture.toHtml} */
        toHtml(): Promise<string> | string;
        /** {@inheritDoc IPicture.toImage} */
        toImage(): Promise<Blob>;
        /** {@inheritDoc IPicture.getDetails} */
        getDetails(): Promise<IPicture.Details>;
        /** @internal */
        protected _fromDrawingJSON(json: IPicture.JSON, fromResourceId?: (id: number) => IResource): void;
        /** @internal */
        protected _toDrawingJSON(toResourceId?: (resource: IResource) => number): IPicture.JSON;
        /** @internal */
        protected _processDelete(): void;
    }
    /**
     * Interfaces for creating `Picture` items.
     *
     * @see
     * ### **Interface**
     *
     * {@link Picture}
     */
    export namespace Picture {
        /**
         * Options for creating an IPicture.
         */
        interface ConstructorOptions extends IModel.ConstructorOptions<IPicture.JSON> {
            /**
             * Returns an IResource from the resourceId or null if not found.
             */
            fromResourceId?: (resourceId: number) => IResource;
            /**
             * Useful for load/save/copying.
             */
            beginPersistResource: () => IResourceCollection.IPersistScope<IResource.JSON>;
            /**
             * Allow for the default lock aspect ratio to be overwritten.
             */
            defaultLockAspectRatio?: boolean;
        }
    }
}
declare module "picture/index" {
    export * from "picture/IPicture";
    export * from "picture/Picture";
}
declare module "chart/IChart" {
    import { IListener } from "listener/index";
    import { IResource } from "resource/index";
    import { IModel } from "model/index";
    /**
     * Interface for working with Charts.
     *
     * **PLACEHOLDER** - This is under development and not made public yet.
     */
    export interface IChart extends IModel {
        toJSON(toResourceId?: (resource: IResource) => number): IChart.JSON;
        getDescription(): string;
    }
    /**
     * {@inheritDoc IChart}
     * @see
     * ### **Interface**
     *
     * {@link IChart}
     */
    export namespace IChart {
        interface JSON {
        }
        interface Events extends IModel.Events {
        }
        interface IListeners extends IListener.Callbacks<IChart, IChart.Events> {
        }
    }
}
declare module "chart/Chart" {
    import { IResource, IResourceCollection } from "resource/index";
    import { IModel } from "model/index";
    import { AbstractModel } from "model/index";
    import { IChart } from "chart/IChart";
    interface State extends AbstractModel.State {
        data?: any;
    }
    /**
     * Implementation for {@link IChart}.
     */
    export class Chart extends AbstractModel<State, IChart.JSON> implements IChart {
        constructor(options: Chart.ConstructorOptions);
        /** {@inheritDoc IModel.getType} */
        getType(): string;
        /** {@inheritDoc Movable.Content.getDescription} */
        getDescription(): string;
        /** {@inheritDoc Movable.Content.toJSON} */
        toJSON(_toResourceId?: (resource: IResource) => number): IChart.JSON;
        /** {@inheritDoc Movable.Content.getTypeDescription} */
        getTypeDescription(): string;
    }
    /**
     * Interfaces for creating `Chart` items.
     *
     * @see
     * ### **Interface**
     *
     * {@link Chart}
     */
    export namespace Chart {
        /**
         * Options for creating a Chart.
         */
        interface ConstructorOptions extends IModel.ConstructorOptions<IChart.JSON> {
            /**
             * Returns an IResource from the resourceId or null if not found.
             */
            fromResourceId?: (resourceId: number) => IResource;
            /**
             * Useful for load/save/copying.
             */
            beginPersistResource: () => IResourceCollection.IPersistScope<IResource.JSON>;
            /**
             * Allow for the default lock aspect ratio to be overwritten.
             */
            defaultLockAspectRatio?: boolean;
        }
    }
}
declare module "fill/IStroke" {
    import { Properties as CSSProperties } from 'csstype';
    import { Bounds } from '@sheetxl/utils';
    import { IFill } from "fill/index";
    /**
     * *** **PLACEHOLDER** - Not yet implemented.
     *
     * Defines how a stroke is drawn around a shape.
     */
    export interface IStroke {
        /**
         * Fill properties for the stroke.
         */
        getFill(): IFill.ISolid | IFill.IGradient | IFill.IPattern | IFill.INone;
        /**
         * Returns the stroke as a set of css string that are suitable for css.
         *
         * @remarks
         * Not all fill styles will offer an exact css equivalent.
         * Additionally due to the nature of css having different properties for the same logic value
         * (for example color, backgroundColor)
         */
        toCSS(darkMode?: boolean, bounds?: Bounds): CSSProperties;
        /**
         * Returns the stroke as a json object.
         */
        toJSON(): IStroke.JSON;
    }
    /**
     * {@inheritDoc IStroke}
     * @see
     * ### **Interface**
     *
     * {@link IStroke}
     */
    export namespace IStroke {
        interface Properties {
            /**
             * Fill properties for the stroke.
             */
            fill: IFill.Properties;
            /**
             * The width of the stroke.
             *
             * @remarks
             * Indicates the thickness of the stroke in pixels.
             */
            width: number;
            /**
             * Defines the shape to be used at the corners of paths when they are stroked.
             */
            lineJoin: IStroke.LineJoin;
            /**
             * Defining the shape to be used at the end of open subpaths when they are stroked.
             *
             * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linecap}
             */
            lineCap: IStroke.LineCap;
            /**
             * Defining a limit on the ratio of the miter length to the stroke-width
             * used to draw a miter join. When the limit is exceeded, the join is converted
             * from a miter to a bevel.
             *
             * @defaultValue `10`.
             *
             * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-miterlimit}
             */
            miterLimit: number;
            /**
             * Defines the arrowhead or shape that will be drawn at the first vertex of the given shape.
             *
             * @defaultValue `null`.
             *
             * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/marker-start}
             *
             */
            markerStart: IStroke.IMarker;
            /**
             * Defines the arrowhead or shape that will be drawn at all interior vertices of the given shape.
             *
             * @defaultValue `null`.
             *
             * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/marker-mid}
             *
             */
            markerMid: IStroke.IMarker;
            /**
             * Defines the arrowhead or shape that will be drawn at final vertex for the given shape.
             *
             * @defaultValue `null`.
             *
             * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/marker-end}
             *
             */
            markerEnd: IStroke.IMarker;
            /**
             * Custom or preset for the stroke.
             */
            dash: number[] | string;
            /**
             * Indicates the type of compound stroke.
             *
             * @defaultValue IStroke.Compound.Single
             *
             * @remarks
             * Only single is supported for rendering.
             *
             */
            compound: IStroke.Compound;
            /**
             * Indicates the alignment of the stroke.
             *
             * * @defaultValue IStroke.Align.Center
             *
             * @remarks
             * Only center is supported for rendering.
             */
            align: IStroke.Align;
        }
        /**
         * A Marker is a custom placeholder for shapes along a stroke.
         *
         * @remarks
         * The Marker contains the positioning and shape of the marker.
         *
         * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Element/marker}
         */
        interface IMarker {
            width: number;
            height: number;
            orientation: number;
            shape: IStroke.PresetMarkerShape;
        }
        /**
         * Support stroke with multiple strokes.
         * ** PLACEHOLDER **
         */
        const Compound: {
            /**
             * Single line: one normal width
             */
            readonly Single: "none";
            /**
             * Double line: two parallel lines
             */
            readonly Double: "double";
            /**
             * Double lines: one thick, one thin
             */
            readonly ThickThin: "thickThin";
            /**
             * Three lines: thin, thick, thin
             */
            readonly ThinThick: "thickThin";
        };
        type Compound = typeof Compound[keyof typeof Compound];
        /**
         * Specific alignment for the stroke.
         */
        const Align: {
            /**
             * Single line: one normal width
             */
            readonly Center: "none";
            /**
             * inset line
             */
            readonly Inset: "inset";
            /**
             * outset line
             *
             * @remarks
             * Not support by ooxml
             */
            readonly Outset: "outset";
        };
        type Align = typeof Align[keyof typeof Align];
        /**
         * Indicates the shape of an end of a stroke.
         * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linecap}
         */
        const LineCap: {
            /**
             * Indicates that the stroke for each subpath does not extend beyond its two endpoints.
             * On a zero length subpath, the path will not be rendered at all
             */
            readonly Butt: "butt";
            /**
             * Indicates that at the end of each subpath the stroke will be extended by a half
             * circle with a diameter equal to the stroke width. On a zero length subpath, the stroke
             * consists of a full circle centered at the subpath's point.
             */
            readonly Round: "round";
            /**
             * Indicates that at the end of each subpath the stroke will be extended by a rectangle
             * with a width equal to half the width of the stroke and a height equal to the width of
             * the stroke. On a zero length subpath, the stroke consists of a square with its width
             * equal to the stroke width, centered at the subpath's point.
             */
            readonly Square: "square";
        };
        type LineCap = typeof LineCap[keyof typeof LineCap];
        /**
         * Indicates the shape to be used at the corners of paths when they are stroked.
         *
         * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linejoin}
         */
        const LineJoin: {
            /**
             * Indicates that a bevelled corner is to be used to join path segments.
             *
             * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linejoin#bevel}
             */
            readonly Bevel: "bevel";
            /**
             * Indicates that a sharp corner is to be used to join path segments. The corner is formed by extending
             * the outer edges of the stroke at the tangents of the path segments until they intersect.
             *
             * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linejoin#miter}
             *
             * @remarks
             * If the stroke-miterlimit is exceeded, the line join falls back to bevel.
             */
            readonly Miter: "miter";
            /**
             * Indicates that a round corner is to be used to join path segments.
             *
             * @see {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linejoin#round}
             */
            readonly Round: "round";
        };
        type LineJoin = typeof LineJoin[keyof typeof LineJoin];
        const PresetMarkerShape: {
            readonly Single: "none";
            readonly Double: "double";
            readonly ThickThin: "thickThin";
            readonly ThinThick: "thickThin";
        };
        type PresetMarkerShape = typeof PresetMarkerShape[keyof typeof PresetMarkerShape];
        const StrokeStyle: {
            readonly None: "none";
            readonly Dashed: "dashed";
            readonly Dotted: "dotted";
            readonly LargeDash: "lgDash";
            readonly LargeDashDot: "lgDashDot";
            readonly LargeDashDotDot: "lgDashDotDot";
            readonly Solid: "solid";
            readonly SysDash: "sysDash";
            readonly SysDashDot: "sysDashDot";
            readonly SysDashDotDot: "sysDashDotDot";
            readonly SysDot: "sysDot";
        };
        type StrokeStyle = typeof StrokeStyle[keyof typeof StrokeStyle];
        /**
         * A JSON representation useful for persistence.
         */
        interface JSON extends Properties {
            fill: IFill.JSON;
        }
    }
}
declare module "shape/IShape" {
    import type { Point, Rectangle } from '@sheetxl/utils';
    import type { IListener } from "listener/index";
    import type { IResource } from "resource/index";
    import type { IModel } from "model/index";
    import type { IHyperlink } from "hyperlink/index";
    import type { IFill } from "fill/index";
    import type { IStroke } from "fill/IStroke";
    /**
     * Interface for working with IShape.
     *
     * @remarks
     *
     * A shape does not position information
     * **PLACEHOLDER**
     */
    export interface IShape extends IModel {
        toJSON(toResourceId?: (resource: IResource) => number): IShape.JSON;
        getDescription(): string;
    }
    /**
     * {@inheritDoc IShape}
     * @see
     * ### **Interface**
     *
     * {@link IShape}
     */
    export namespace IShape {
        /**
         * A set of values that can be set on a IShape.
         *
         * @see
         * {@link IShape}
         */
        interface Properties {
            /**
             * The unique name of the table
             */
            name?: string;
            /**
             * The preset Geometry for the shape. This could also be custom.
             *
             * @defaultValue 'rect'
             */
            geometry?: PresetGeometry | GeometryProperties;
            /**
             * The fill.
             */
            fill?: IFill.ISolid | IFill.IGradient | IFill.IPattern | IFill.INone;
            /**
             * The stroke.
             */
            stroke?: IStroke;
            /**
             * A hyperlink for the entire shape.
             */
            hyperlink?: string | IHyperlink.JSON;
        }
        /**
         * A JSON representation useful for persistence.
         */
        interface JSON extends Omit<Properties, 'fill' | 'stroke' | 'geometry'> {
            fill?: IFill.SolidJSON | IFill.GradientJSON | IFill.PatternJSON | IFill.NoneJSON;
            stroke?: IStroke.JSON;
            geometry?: string | GeometryJSON;
        }
        interface GeometryProperties {
            geometry?: PresetGeometry;
            ah: (PolarAdjustmentHandle | XYAdjustmentHandle)[];
            av?: IShape.AdjustmentGuide[];
            connections?: IShape.ConnectionSite[];
            guides?: IShape.AdjustmentGuide[];
            paths?: IShape.Path[] | string[] | string;
            /**
             * Specifies the rectangular bounding box for text within the shape.
             * @defaultValue `null` - The bounds of the shape,
             */
            textBounds?: Rectangle;
        }
        interface Path {
            paths: string[];
            /**
             * Specifies that the use of 3D extrusions are possible on this path. This allows the generating application to know whether
             * 3D extrusion can be applied in any form.
             *
             * @defaultValue `false`
             */
            extrusionOk?: boolean;
            /**
             * Specifies how the corresponding path should be filled.
             *
             * @defaultValue `PathFill.Normal`
             */
            pathFill?: PathFill;
            /**
             * Specifies the height, or maximum y coordinate that should be used for within the path coordinate system. This value determines
             * the vertical placement of all points within the corresponding path as they will all be calculated using this height attribute
             * as the max y coordinate.
             *
             * @defaultValue `null`
             */
            h?: number;
            /**
             * Specifies if the corresponding path should have a path stroke shown. This is a boolean value that will effect on the outline of the path.
             *
             * @defaultValue `true`
             */
            stroke?: boolean;
            /**
             * Specifies the width, or maximum x coordinate that should be used for within the path coordinate system. This value determines
             * the horizontal placement of all points within the corresponding path as they will all be calculated using this width attribute
             * as the max x coordinate.
             *
             * @defaultValue `null`
             */
            w?: number;
        }
        /**
         * Specifies the manner in which a path should be filled. The lightening and darkening of a path allow for certain parts of the shape
         * to be colored lighter of darker depending on user preference.
         */
        const PathFill: {
            readonly Darken: "darken";
            readonly DarkenLess: "darkenLess";
            readonly Lighten: "lighten";
            readonly LightenLess: "lightenLess";
            readonly None: "none";
            readonly Normal: "normal";
        };
        type PathFill = typeof PathFill[keyof typeof PathFill];
        /**
         * Specifies the presence of a shape guide that will be used to govern the geometry of the specified shape.
         */
        interface AdjustmentGuide {
            /**
             * Specifies the name that will be used to reference to this guide. This name may be used just as a variable
             * would within an equation. That is this name may be substituted for literal values within other guides or
             * the specification of the shape path.
             */
            name: string;
            /**
             * Specifies the formula that will be used to calculate the value for a guide. Each formula has a certain
             * number of arguments and a specific set of operations to perform on these arguments in order to generate a
             * value for a guide. There are a total of 17 different formulas available. These are shown below with the usage
             * for each defined
             */
            fmla: string;
        }
        /**
         * These adjust handles will specify points within the geometric shape that can be used to perform certain
         * transform operations on the shape.
         */
        interface AdjustmentHandle {
            /**
             * The point of the adjustment
             */
            pos: Point;
        }
        interface PolarAdjustmentHandle extends AdjustmentHandle {
            type: 'polar';
            /**
             * Specifies the name of the guide that will be updated with the adjustment angle from this adjust handle.
             */
            gdRefAng: string;
            /**
             * Specifies the name of the guide that will be updated with the adjustment radius from this adjust handle.
             */
            gdRefR: string;
            /**
             * Specifies the maximum angle position that is allowed for this adjustment handle. If this attribute is omitted,
             * then it will be assumed that this adjust handle cannot move angularly.
             */
            maxAng: number;
            /**
             * Specifies the maximum radial position that is allowed for this adjustment handle. If this attribute is omitted,
             * then it will be assumed that this adjust handle cannot move radially.
             */
            maxR: number;
            /**
             * Specifies the minimum angle position that is allowed for this adjustment handle. If this attribute is omitted,
             * then it will be assumed that this adjust handle cannot move angularly.
             */
            minAng: number;
            /**
             * Specifies the minimum radial position that is allowed for this adjustment handle. If this attribute is omitted,
             * then it will be assumed that this adjust handle cannot move radially.
             */
            minR: number;
        }
        interface XYAdjustmentHandle extends AdjustmentHandle {
            type: 'xy';
            /**
             * Specifies the name of the guide that will be updated with the adjustment x position from this adjust handle.
             */
            gdRefX: string;
            /**
             * Specifies the name of the guide that will be updated with the adjustment y position from this adjust handle.
             */
            gdRefY: string;
            /**
             * Specifies the maximum horizontal position that is allowed for this adjustment handle. If this attribute is omitted,
             * then it will be assumed that this adjust handle cannot move in the x direction.
             */
            maxX: number;
            /**
             * Specifies the maximum vertical position that is allowed for this adjustment handle. If this attribute is omitted,
             * then it will be assumed that this adjust handle cannot move in the y direction.
             */
            maxY: number;
            /**
             * Specifies the minimum horizontal position that is allowed for this adjustment handle. If this attribute is omitted,
             * then it will be assumed that this adjust handle cannot move in the x direction.
             */
            minX: number;
            /**
             * Specifies the minimum vertical position that is allowed for this adjustment handle. If this attribute is omitted,
             * then it will be assumed that this adjust handle cannot move in the y direction.
             */
            minY: number;
        }
        /**
         * A connection site allows a `ConnectionShape` to be attached to this shape. This connection will be maintained
         * when the shape is repositioned. It should be noted that this connection is placed within the shape
         * bounding box using the transform coordinate system which is also called the shape coordinate system,
         * as it encompasses the entire shape.
         */
        interface ConnectionSite {
            /**
             * Specifies the incoming connector angle. This angle is the angle around the connection site that an
             * incoming connector will try to be routed to. This allows connectors to know where the shape is in
             * relation to the connection site and route connectors so as to avoid any overlap with the shape.
             */
            angle: string;
            /**
             * Specifies a position coordinate within the shape bounding box. It should be noted that this coordinate
             * is placed within the shape bounding box using the transform coordinate system which is also called the
             * shape coordinate system, as it encompasses the entire shape.
             */
            pos: Point;
        }
        interface GeometryJSON extends GeometryProperties {
        }
        interface Events extends IModel.Events {
        }
        interface IListeners extends IListener.Callbacks<IShape, IShape.Events> {
        }
        interface IConnection {
        }
        interface Connection extends IShape.JSON {
            cxnSp?: any;
        }
        /**
         * @see {@link https://c-rex.net/samples/ooxml/e1/Part4/OOXML_P4_DOCX_ST_ShapeType_topic_ID0EBTFOB.html#topic_ID0EBTFOB}
         */
        const PresetGeometry: {
            readonly Line: "line";
            readonly LineInv: "lineInv";
            readonly triangle: "triangle";
            readonly rtTriangle: "rtTriangle";
            readonly Rect: "rect";
        };
        type PresetGeometry = typeof PresetGeometry[keyof typeof PresetGeometry];
    }
}
declare module "shape/Shape" {
    import { IResource, IResourceCollection } from "resource/index";
    import { IModel } from "model/index";
    import { AbstractModel } from "model/index";
    import { IShape } from "shape/IShape";
    interface State extends AbstractModel.State {
        data?: any;
    }
    /**
     * Implementation for {@link IShape}.
     */
    export class Shape extends AbstractModel<State, IShape.JSON> implements IShape {
        constructor(options: Chart.ConstructorOptions);
        /** {@inheritDoc IModel.getType} */
        getType(): string;
        /** {@inheritDoc Movable.Content.getDescription} */
        getDescription(): string;
        /** {@inheritDoc Movable.Content.toJSON} */
        toJSON(_toResourceId?: (resource: IResource) => number): IShape.JSON;
        /** {@inheritDoc Movable.Content.getTypeDescription} */
        getTypeDescription(): string;
        get [Symbol.toStringTag](): string;
        toString(): string;
    }
    /**
     * Interfaces for creating `Chart` items.
     *
     * @see
     * ### **Interface**
     *
     * {@link Chart}
     */
    export namespace Chart {
        /**
         * Options for creating a chart.
         */
        interface ConstructorOptions extends IModel.ConstructorOptions<IShape.JSON> {
            /**
             * Returns an IResource from the resourceId or null if not found.
             */
            fromResourceId?: (resourceId: number) => IResource;
            /**
             * Useful for load/save/copying.
             */
            beginPersistResource: () => IResourceCollection.IPersistScope<IResource.JSON>;
            /**
             * Allow for the default lock aspect ratio to be overwritten.
             */
            defaultLockAspectRatio?: boolean;
        }
    }
}
declare module "movable/ICustomElement" {
    import type { IListener } from "listener/index";
    import type { IResource } from "resource/index";
    import type { IModel } from "model/index";
    /**
     * Interface for working with CustomMovables.
    
     * **PLACEHOLDER**
     */
    export interface ICustomElement extends IModel {
        toJSON(toResourceId?: (resource: IResource) => number): ICustomElement.JSON;
        getDescription(): string;
    }
    /**
     * {@inheritDoc ICustomElement}
     * @see
     * ### **Interface**
     *
     * {@link ICustomElement}
     */
    export namespace ICustomElement {
        interface JSON {
        }
        interface Events extends IModel.Events {
        }
        interface IListeners extends IListener.Callbacks<ICustomElement, ICustomElement.Events> {
        }
    }
}
declare module "movable/CustomElement" {
    import { IResource, IResourceCollection } from "resource/index";
    import { IModel } from "model/index";
    import { AbstractModel } from "model/index";
    import { ICustomElement } from "movable/ICustomElement";
    interface State extends AbstractModel.State {
        data?: any;
    }
    /**
     * Implementation for {@link ICustomElement}.
     */
    export class CustomElement extends AbstractModel<State, ICustomElement.JSON> implements ICustomElement {
        constructor(options: CustomElement.ConstructorOptions);
        getType(): string;
        getDescription(): string;
        toJSON(_toResourceId?: (resource: IResource) => number): ICustomElement.JSON;
        getTypeDescription(): string;
    }
    /**
     * Interfaces for creating `CustomElement` items.
     *
     * @see
     * ### **Interface**
     *
     * {@link CustomElement}
     */
    export namespace CustomElement {
        /**
         * Options for creating a Custom Element.
         */
        interface ConstructorOptions extends IModel.ConstructorOptions<ICustomElement.JSON> {
            /**
             * Returns an IResource from the resourceId or null if not found.
             */
            fromResourceId?: (resourceId: number) => IResource;
            /**
             * Useful for load/save/copying.
             */
            beginPersistResource: () => IResourceCollection.IPersistScope<IResource.JSON>;
        }
    }
}
declare module "selection/index" {
    export * from "selection/IRangeSelection";
}
declare module "conditional/IConditionalFormatCollection" {
    import type { ICellRange, ICellRanges } from "cellRange/index";
    import type { ICollection } from "type/index";
    import type { IConditionalFormat } from "conditional/IConditionalFormat";
    import type { ITransaction } from "transaction/index";
    /**
     * Holds a collection of {@link IConditionalFormat}s.
     */
    export interface IConditionalFormatCollection extends ICollection<IConditionalFormat> {
        /**
         * Add an `IConditional` to the container.
         *
         * @param address The address of the item.
         * @param options {@link IConditionalFormatCollection.AddOptions}
         */
        add(address: ICellRanges.Address, options: IConditionalFormatCollection.AddOptions): IConditionalFormat;
        /**
         * Returns items that match the filter criteria.
         *
         * If no filter criteria is provided, all items will be returned.
         *
         * @param options {@link IConditionalFormatCollection.GetItemsOptions}
         */
        getItems(options?: IConditionalFormatCollection.GetItemsOptions): IConditionalFormat[];
    }
    /**
     * {@inheritDoc IConditionalFormatCollection}
     * @see
     * ### **Interface**
     *
     * {@link IConditionalFormatCollection}
     */
    export namespace IConditionalFormatCollection {
        /**
         * Options for adding a {@link IConditionalFormat}.
         */
        interface AddOptions extends IConditionalFormat.Properties, ITransaction.OperationOptions {
        }
        /**
         * Options for searching for {@link IConditionalFormat}s.
         */
        interface GetItemsOptions extends ICollection.GetItemsOptions {
            /**
             * If provided, the search 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;
            /**
             * Search with the given name. This is case insensitive.
             */
            name?: string;
        }
    }
}
declare module "conditional/IConditionalFormat" {
    import type { IRange } from '@sheetxl/primitives';
    import type { ReferenceableClipboard } from '@sheetxl/utils';
    import type { IProperties } from "type/index";
    import type { ITransaction } from "transaction/index";
    import type { IListener } from "listener/index";
    import type { IHistory } from "history/index";
    import type { IModel } from "model/index";
    import type { ICellRanges } from "cellRange/index";
    import type { IStyle } from "style/index";
    import type { IConditionalFormatCollection } from "conditional/IConditionalFormatCollection";
    /**
     * Represents a conditional formatting rule for a range.
     *
     * @remarks
     * Used for modifying the type and rules of a conditional formatting entry.
     *
     * * Conditional formatting rules can be used to highlight, format, or modify
     *   cell appearance based on data conditions or criteria.
     *
     * * Conditional formatting help users identify patterns, trends, and exceptions
     *   in data by applying visual styles dynamically.
     */
    export interface IConditionalFormat extends IModel, IProperties.ICellRanged<IStyle.Properties> {
        /**
         * Returns the ranges for conditional formatting.
         */
        getRanges(): ICellRanges;
        /**
         * Set ranges for the conditional format.
         *
         * @param address The address.
         */
        setRanges(address: ICellRanges.Address, options?: ITransaction.OperationOptions): this;
        /**
         * Set the type of conditional format used.
         *
         * @param type The type of conditional format.
         */
        setType(type: IConditionalFormat.Type, options?: ITransaction.OperationOptions): this;
        /**
         * Returns the type of conditional format used.
         */
        getType(): IConditionalFormat.Type;
        /**
         * The priority of the conditional format rule as a number relative to other rules.
         *
         * @param priority A number that determines the order of the conditional format.
         *
         * @remarks
         * This must always be a positive number and will be unique. If this is the same as another conditional format
         * then that will will be adjusted to be greater than this one.
         */
        setPriority(priority: number, options?: ITransaction.OperationOptions): this;
        /**
         * @see {@link IConditionalFormat.setPriority}
         */
        getPriority(): number;
        /**
         * Sets whether to stop evaluating additional conditional formatting rules if this rule is true.
         *
         * @param stopIfTrue A boolean to indicate if this is a stop.
         *
         * @remarks
         * This will only affect formatting rules for the current range or cell.
         */
        setStopIfTrue(stopIfTrue: boolean, options?: ITransaction.OperationOptions): this;
        /**
         * @see {@link IConditionalFormat.setStopIfTrue}
         */
        getStopIfTrue(): boolean;
        /**
         * Returns the cell value associated with this conditional formatting.
         *
         * @remarks
         * This will be `null` unless {@link IConditionalFormat.getType} is `IConditionalFormat.Type.Scalar`.
         */
        getScalar(): any | null;
        /**
         * Returns the color scale settings for this conditional formatting.
         *
         * @remarks
         * This will be `null` unless {@link IConditionalFormat.getType} is `IConditionalFormat.Type.ColorScale`.
         */
        getColorScale(): IConditionalFormat.ColorScale | null;
        /**
         * Returns the contains texts settings for this conditional formatting.
         *
         * @remarks
         * This will be `null` unless {@link IConditionalFormat.getType} is `IConditionalFormat.Type.ContainsText`.
         */
        getContainsText(): any | null;
        /**
         * Returns the custom rule settings for this conditional formatting.
         *
         * @remarks
         * This will be `null` unless {@link IConditionalFormat.getType} is `IConditionalFormat.Type.Custom`.
         */
        getCustom(): any | null;
        /**
         * Returns the data bar settings for this conditional formatting.
         *
         * @remarks
         * This will be `null` unless {@link IConditionalFormat.getType} is `IConditionalFormat.Type.DataBar`.
         */
        getDataBar(): IConditionalFormat.DataBar | null;
        /**
         * Returns the icon set settings for this conditional formatting.
         *
         * @remarks
         * This will be `null` unless {@link IConditionalFormat.getType} is `IConditionalFormat.Type.IconSet`.
         */
        getIconSet(): IConditionalFormat.IconSet | null;
        /**
         * Returns the preset rule settings for this conditional formatting.
         *
         * @remarks
         * This will be `null` unless {@link IConditionalFormat.getType} is `IConditionalFormat.Type.PresetCriteria`.
         */
        getPresetCriteria(): IStyle.Properties | null;
        /**
         * Returns the top/bottom rule settings for this conditional formatting.
         *
         * @remarks
         * This will be `null` unless {@link IConditionalFormat.getType} is `IConditionalFormat.Type.TopBottom`.
         */
        getTopBottom(): any | null;
        /**
         * Set multiple properties at the same time.
         */
        update(properties: Partial<IConditionalFormat.Properties>, options?: ITransaction.OperationOptions): this;
        /**
         * Returns a snapshot of the conditional that can be used for copying and archiving.
         */
        getSnapshot(options?: ReferenceableClipboard.CopyOptions): IConditionalFormat.ISnapshot;
        /**
         * Add Listeners.
         *
         * @see
         * {@link IListener.ISource.addListeners}
         */
        addListeners(listeners: IConditionalFormat.IListeners, options?: IListener.Options): IListener.Remove;
        /**
         * @returns The current state as a JSON object.
         */
        toJSON(): IConditionalFormat.JSON;
        /**
         * For runtime type checking.
         */
        readonly isIConditionalFormat: true;
    }
    /**
     * Capabilities for working with conditional styling ranges.
     *
     * @see
     * ### **Interface**
     *
     * {@link IConditionalFormat}
     *
     * **Additional Interfaces**
     * * {@link IConditionalFormatCollection}
     */
    export namespace IConditionalFormat {
        /**
         * Represents the various types of built-in conditional formatting rules.
         *
         * @remarks
         * This enum is used to define different types of conditional formatting rules
         * that can be applied to cells in a spreadsheet. Each type corresponds to a
         * specific style of formatting that adjusts based on data or predefined conditions.
         * Conditional formatting visually highlights cells to make patterns, trends,
         * or exceptions in the data more noticeable.
         */
        const Type: {
            /**
             * This conditional formatting rule highlights cells that are above or below the average for all values in the range.
             */
            readonly AboveAverage: "aboveAverage";
            /**
             * This conditional formatting rule highlights cells in the range that begin with the given text.
             * Equivalent to using the LEFT() sheet function and comparing values.
             */
            readonly BeginsWith: "beginsWith";
            /**
             * This conditional formatting rule compares a cell value to a formula calculated result, using an operator.
             */
            readonly CellIs: "cellIs";
            /**
             * This conditional formatting rule creates a gradated color scale on the cells.
             *
             * @remarks
             * Applies a gradient of colors based on cell values within a range.
             */
            readonly ColorScale: "colorScale";
            /**
             * This conditional formatting rule highlights cells that are completely blank.
             * Equivalent of using LEN(TRIM()).
             * This means that if the cell contains only characters that TRIM() would remove, then it is considered blank.
             * An empty cell is also considered blank.
             */
            readonly ContainsBlanks: "containsBlanks";
            /**
             * This conditional formatting rule highlights cells with formula errors.
             * Equivalent to using ISERROR() sheet function to determine if there is a formula error.
             *
             * @remarks
             * Formats cells that contain error values, such as #DIV/0! or #N/A.
             */
            readonly ContainsErrors: "containsErrors";
            /**
             * This conditional formatting rule highlights cells containing given text.
             * Equivalent to using the SEARCH() sheet function to determine whether the cell contains the text.
             */
            readonly ContainsText: "containsText";
            /**
             * Conditional formatting based on data bars.
             *
             * @remarks
             * Displays a horizontal bar in cells proportional to their values.
             */
            readonly DataBar: "dataBar";
            /**
             * This conditional formatting rule highlights duplicated values.
             */
            readonly DuplicateValues: "duplicateValues";
            /**
             * This conditional formatting rule highlights cells ending with given text.
             * Equivalent to using the RIGHT() sheet function and comparing values.
             */
            readonly EndsWith: "endsWith";
            /**
             * This conditional formatting rule contains a formula to evaluate. When the formula result is true, the cell is highlighted.
             */
            readonly Expression: "expression";
            /**
             * Conditional formatting using icon sets.
             *
             * @remarks
             * Displays icons based on value ranges within cells.
             */
            readonly IconSet: "iconSet";
            /**
             * This conditional formatting rule highlights cells that are not blank. Equivalent of using LEN(TRIM()).
             * This means that if the cell contains only characters that TRIM() would remove, then it is considered blank.
             * An empty cell is also considered blank.
             */
            readonly NotContainsBlanks: "notContainsBlanks";
            /**
             * This conditional formatting rule highlights cells without formula errors.
             * Equivalent to using ISERROR() sheet function to determine if there is a formula error.
             */
            readonly NotContainsErrors: "notContainsErrors";
            /**
             * This conditional formatting rule highlights cells that do not contain given text.
             * Equivalent to using the SEARCH() sheet function.
             */
            readonly NotContainsText: "notContainsText";
            /**
             * This conditional formatting rule highlights cells containing dates in the specified time period.
             * The underlying value of the cell is evaluated, therefore the cell does not need to be formatted as a date to be evaluated.
             * For example, with a cell containing the value 38913 the conditional format shall be applied if the rule requires a value of 7/14/2006.
             */
            readonly TimePeriod: "timePeriod";
            /**
             * This conditional formatting rule highlights cells whose values fall in the top N or bottom N bracket, as specified.
             */
            readonly Top10: "top10";
            /**
             * This conditional formatting rule highlights unique values in the range.
             */
            readonly UniqueValues: "uniqueValues";
        };
        type Type = typeof Type[keyof typeof Type];
        /**
         * Used for conditional formatting rules that require an operator.
         */
        const OperatorType: {
            readonly BeginsWith: "beginsWith";
            readonly Between: "between";
            readonly ContainsText: "containsText";
            readonly EndsWith: "endsWith";
            readonly Equal: "equal";
            readonly GreaterThan: "greaterThan";
            readonly GreaterThanOrEqual: "greaterThanOrEqual";
            readonly LessThan: "lessThan";
            readonly LessThanOrEqual: "lessThanOrEqual";
            readonly NotBetween: "notBetween";
            readonly NotContains: "notContains";
            readonly NotEqual: "notEqual";
        };
        type OperatorType = typeof OperatorType[keyof typeof OperatorType];
        const TimePeriod: {
            readonly Last7Days: "last7Days";
            readonly LastMonth: "lastMonth";
            readonly LastWeek: "lastWeek";
            readonly NextMonth: "nextMonth";
            readonly NextWeek: "nextWeek";
            readonly ThisMonth: "thisMonth";
            readonly ThisWeek: "thisWeek";
            readonly Today: "today";
            readonly Tomorrow: "tomorrow";
            readonly Yesterday: "yesterday";
        };
        type TimePeriod = typeof TimePeriod[keyof typeof TimePeriod];
        const ConditionalBoundsType: {
            /**
             * The minimum/ midpoint / maximum value for the gradient is determined by a formula.
             */
            readonly Formula: "formula";
            /**
             * Indicates that the maximum value in the range shall be used as the maximum value for the gradient.
             */
            readonly Max: "max";
            /**
             * Indicates that the minimum value in the range shall be used as the minimum value for the gradient.
             */
            readonly Min: "min";
            /**
             * Indicates that the minimum / midpoint / maximum value for the gradient is specified by a constant numeric value.
             */
            readonly Num: "num";
            /**
             * Value indicates a percentage between the minimum and maximum values in the range shall be used as the minimum / midpoint / maximum value for the gradient.
             */
            readonly Percent: "percent";
            /**
             * Value indicates a percentile ranking in the range shall be used as the minimum / midpoint / maximum value for the gradient.
             */
            readonly Percentile: "percentile";
        };
        type ConditionalBoundsType = typeof ConditionalBoundsType[keyof typeof ConditionalBoundsType];
        interface Condition {
            type: ConditionalBoundsType;
            value?: number;
            /**
             * For icon sets, determines whether this threshold value uses the greater than or equal to operator.
             */
            gte?: boolean;
        }
        /**
         * A color scale must have either 2 or 3 conditions.
         */
        interface ColorScale {
            conditions: IConditionalFormat.Condition[];
            colors: string[];
        }
        /**
         * A color scale must have either 2 or 3 conditions.
         */
        interface DataBar {
            conditions: IConditionalFormat.Condition[];
            colors: string[];
            maxLength?: number;
            minLength?: number;
            /**
             * If true, the value will be shown in the cell.
             */
            showValue?: boolean;
        }
        /**
         *
         */
        interface IconSet {
            conditions: IConditionalFormat.Condition[];
            /**
             * Allows for individual icon overrides.
             */
            icon?: {
                set: IStyle.IconSet;
                id: number;
            }[];
            /**
             * The icon set to use
             */
            iconSet?: IStyle.IconSet;
            reverse?: boolean;
            /**
             * If true, the value will be shown in the cell.
             */
            showValue?: boolean;
        }
        /**
         * A set of values that can be set on a IConditionalFormat.
         *
         * @see
         * {@link IConditionalFormat}
         */
        interface Properties {
            /**
             * The type of conditional formatting rule.
             */
            type: IConditionalFormat.Type;
            /**
             * Default will be the order these are added.
             */
            priority?: number;
            /**
             * @defaultValue false
             */
            stopIfTrue?: boolean;
            aboveAverage?: boolean;
            equalAverage?: boolean;
            stdDev?: number;
            bottom?: boolean;
            percent?: boolean;
            rank?: number;
            operator?: IConditionalFormat.OperatorType;
            /**
             * Use for evaluating. The number of formula is operator dependent.
             */
            formulas?: string[];
            text?: string;
            timePeriod?: IConditionalFormat.TimePeriod;
            /**
             * A conditional format must have 1 only 1 of the following properties set.
             */
            style?: IStyle.Properties;
            colorScale?: IConditionalFormat.ColorScale;
            dataBar?: IConditionalFormat.DataBar;
            iconSet?: IConditionalFormat.IconSet;
        }
        /**
         * Provides destination details for the Snapshot when using {@link IHistory.ISnapshot.copyTo}.
         */
        interface SnapshotDestination {
            conditionals: IConditionalFormatCollection;
            range: IRange.Coords;
        }
        interface ISnapshot extends IHistory.ISnapshot<IConditionalFormat.SnapshotDestination, IConditionalFormat, IRange.Coords> {
        }
        /**
         * A JSON representation useful for persistence.
         */
        interface JSON extends Properties {
            /**
             * An A1 representation of a ranges that is the bounding area
             * for the conditionals.
             */
            ref: IRange.Coords | IRange.Coords[] | string;
            /**
             * If associated with a pivot.
             *
             * @defaultValue false
             */
            pivot?: boolean;
        }
        /**
         * IListener for {@link IConditionalFormat} events.
         */
        interface Events extends IModel.Events {
        }
        interface IListeners extends IListener.Callbacks<IConditionalFormat, IConditionalFormat.Events> {
        }
    }
}
declare module "conditional/index" {
    export * from "conditional/IConditionalFormat";
    export * from "conditional/IConditionalFormatCollection";
}
declare module "movable/_MovableUtils" {
    import { Point, Bounds } from '@sheetxl/utils';
    import { IMovableCollection } from "movable/IMovableCollection";
    export const nonOverlappingOffset: (movables: IMovableCollection, destination: Bounds, shiftX?: boolean, shiftY?: boolean) => Point;
}
declare module "table/_TableMessages" {
    export const MODEL_CLOSED = "Table has been closed. No further operations are allowed.";
    export const ERROR_TABLE_RESIZE_INVALID_BOUNDS = "The top of the table must not change and the new table location must overlap with the original table.";
    export const ERROR_TABLE_SPLIT = "We can not partially insert or remove cells as this would split a table.";
    export const ERROR_TABLE_NO_NAME = "Table must have a name.";
    export const ERROR_TABLE_NO_BODY = "A table must have a least one row for the data.";
    export const ERROR_TABLE_REMOVE_HEADER = "We can not remove rows that contain table headers. Remove the table header.";
    export const ERROR_GET_BY_NAME = "Get by name must take a valid name.";
}
declare module "table/TableCollection" {
    import { ICellRange, ICellRanges } from "cellRange/index";
    import { ITableCollection } from "table/ITableCollection";
    import { ITable } from "table/ITable";
    export class TableCollection implements ITableCollection {
        private _add;
        private _get;
        private _getByName;
        constructor(add: (address: ICellRange.Address, options: ITableCollection.AddOptions) => ITable, get: (address: ICellRanges.Address, ignoreHidden: boolean, fullyContained: boolean) => ITable[], getByName: (name: string) => ITable);
        /** {@inheritDoc ITableCollection.add} */
        add(address: ICellRange.Address, options?: ITableCollection.AddOptions): ITable;
        /** {@inheritDoc ITableCollection.getItems} */
        getItems(options?: ITableCollection.GetItemsOptions): ITable[];
        /** {@inheritDoc ITableCollection.getByName} */
        getByName(name: string): ITable;
        /** {@inheritDoc ITableCollection.getCount} */
        getCount(): number;
    }
}
declare module "filter/AutoFilter" {
    import { IRange } from '@sheetxl/primitives';
    import { ITransaction } from "transaction/index";
    import { IAutoSort } from "sort/index";
    import { IAutoFilter } from "filter/IAutoFilter";
    import { IAnchored } from "anchored/index";
    import { AbstractAnchored } from "anchored/AbstractAnchored";
    interface State extends AbstractAnchored.State {
        byOffset?: Map<number, IAutoFilter.Field>;
        sort?: IAutoSort;
        hiddenCount: number;
    }
    interface CommitView extends AbstractAnchored.CommitView {
    }
    /**
     * Filter capabilities.
     */
    export class AutoFilter extends AbstractAnchored<State, CommitView> implements IAutoFilter {
        private _apply;
        private _processUpdate;
        constructor(options: AutoFilter.ConstructorOptions);
        /** {@inheritDoc IAutoFilter.getCoords} */
        getCoords(): IRange.Coords;
        /** {@inheritDoc IAutoFilter.getFieldAt} */
        getFieldAt(offset: number): IAutoFilter.Field;
        /** {@inheritDoc IAutoFilter.insertSort} */
        insertSort(): IAutoSort;
        /** {@inheritDoc IAutoFilter.getSort} */
        getSort(): IAutoSort;
        /** {@inheritDoc IAutoFilter.apply} */
        apply(fields: IAutoFilter.IndexedField[]): IAutoFilter;
        /** {@inheritDoc IAutoFilter.setFieldAt} */
        setFieldAt(offset: number, filter: IAutoFilter.Field): IAutoFilter;
        /** {@inheritDoc IAutoFilter.getShowFilterButton} */
        getShowFilterButton(): boolean;
        /** {@inheritDoc IAutoFilter.setShowFilterButton} */
        setShowFilterButton(showFilterButton: boolean): IAutoFilter;
        protected _processStateChange(state: State, view: CommitView, commit: ITransaction.ICommit): void;
        protected _processContainerShift(options: IAnchored.ShiftOptions): IRange.Coords | void;
        /** {@inheritDoc IAutoFilter.reapply} */
        reapply(): IAutoFilter;
        /** {@inheritDoc IAutoFilter.clear} */
        clear(): IAutoFilter;
        protected _fromJSON(json: IAutoFilter.JSON): void;
        /** {@inheritDoc IAutoFilter.toJSON} */
        toJSON(): IAutoFilter.JSON;
    }
    /**
     * Interfaces for creating `AutoFilter`.
     *
     * @see
     * ### **Interface**
     *
     * {@link AutoFilter}
     */
    export namespace AutoFilter {
        interface ConstructorOptions extends IAnchored.ConstructorOptions {
            /**
             * JSON state to load.
             */
            json?: IAutoFilter.JSON;
            /**
             * Apply the filter
             */
            apply?: (fields: IAutoFilter.Field[]) => void;
            processUpdate: () => void;
            setFilterCoordsCallback?(callback: (anchor: IRange.Coords) => void): void;
        }
    }
}
declare module "address/index" {
    import { type RangeToString, type CellToString } from "address/AddressUtils";
    import { IRange } from '@sheetxl/primitives';
    /**
     * Collection of functions used for parsing Address string.
     *
     * Needed for OOXML import.
     * @hidden
     */
    export namespace AddressUtils {
        const fastStringToCol: (address: string) => number;
        const fastStringToCell: (address: string, reuse?: IRange.CellCoords) => IRange.CellCoords;
        const fastStringToRange: (address: string, _reuse?: IRange.Coords) => IRange.Coords;
        const rangeToString: RangeToString<IRange.Coords, IRange.CellCoords>;
        const cellToString: CellToString<IRange.CellCoords>;
        const normalizeA1ToR1C1: (formula: string, rowIndex: number, colIndex: number, tokens?: (string | IRange.FixableCellCoords)[]) => string;
        const resolveRelativeToA1: (tokens: (string | IRange.CellCoords)[], rowIndex: number, colIndex: number) => string;
    }
}
declare module "selection/RangeSelection" {
    import { IRange } from '@sheetxl/primitives';
    import { IListener } from "listener/index";
    import { ISheet } from "sheet/index";
    import { ListenerEmitter } from "listener/ListenerEmitter";
    import { HiddenHeadersAt, CellFinder } from "selection/_RangeSelectionUtils";
    import { IRangeSelection } from "selection/IRangeSelection";
    /**
     * TODO - Not in USE. meant to replace the mess that is useSelection
     */
    export class RangeSelection {
        protected _coords: IRangeSelection.Coords;
        protected _sheet: ISheet;
        protected _hiddenRowsAt: HiddenHeadersAt;
        protected _hiddenColumnsAt: HiddenHeadersAt;
        protected _getCellCoordsAsRangeCoords: (coords: IRange.CellCoords) => IRange.Coords;
        protected _canSelectionSpanMergedCells: (range: IRange.Coords) => boolean;
        protected _getMergedRanges: (range: IRange.Coords) => IRange.Coords[];
        protected _isContentfulCell?: (coords: IRange.CellCoords) => boolean;
        protected _contentfulCellFinder?: CellFinder;
        protected _scrollCellCoordsIntoView: (coords: Partial<IRange.Coords>, options?: globalThis.ScrollIntoViewOptions | boolean) => Promise<boolean>;
        protected _newSelectionMode: IRangeSelection.NewSelectionMode;
        protected _selectionPolicy: IRangeSelection.SelectionPolicy;
        protected _magicCell: IRange.CellCoords;
        protected _adjusting: IRangeSelection.Coords | null;
        protected _firstActiveCoords: IRange.CellCoords;
        protected _emitter: ListenerEmitter<RangeSelection, IRangeSelection.IListeners>;
        constructor(options: IRangeSelection.ConstructorOptions);
        /** {@inheritDoc IRangeSelection.navigate} */
        navigate(direction: IRange.Direction, select?: boolean, contentful?: boolean, incrementAmount?: number): this;
        /** {@inheritDoc IRangeSelection.getCoords} */
        getCoords(): IRangeSelection.Coords;
        /** {@inheritDoc IRangeSelection.getRangesCoords} */
        getRangesCoords(coord?: Partial<IRangeSelection.Coords>): IRange.Coords[];
        /** {@inheritDoc IRangeSelection.updateCoords} */
        updateCoords(coords: IRangeSelection.Coords): this;
        /** {@inheritDoc IRangeSelection.isEntire} */
        isEntire(): boolean;
        /** {@inheritDoc IRangeSelection.traverse} */
        traverse(orientation?: IRange.Orientation, reverse?: boolean): this;
        /** {@inheritDoc IRangeSelection.clear} */
        clear(): void;
        /** {@inheritDoc IRangeSelection.modify} */
        modify(cellAnchor: Partial<IRange.CellCoords>, cellPivot?: Partial<IRange.CellCoords>, resetAnchor?: boolean): void;
        /** {@inheritDoc IRangeSelection.append} */
        append(start: IRange.CellCoords, end?: IRange.CellCoords, anchor?: Partial<IRange.CellCoords>): void;
        /** {@inheritDoc IRangeSelection.clearAndModify} */
        clearAndModify(start: Partial<IRange.CellCoords>, end?: Partial<IRange.CellCoords>, anchor?: Partial<IRange.CellCoords>): void;
        /** {@inheritDoc IRangeSelection.setAdjusting} */
        setAdjusting(adjusting: IRangeSelection.Coords | null): void;
        /** {@inheritDoc IRangeSelection.getAdjusting} */
        getAdjusting(): IRangeSelection.Coords | null;
        /** {@inheritDoc IRangeSelection.addListeners} */
        addListeners(listeners: IRangeSelection.IListeners, options?: IListener.Options): IListener.Remove;
        protected _setSelectionRanges(ranges: readonly IRange.Coords[] | ((ranges: readonly IRange.Coords[]) => IRange.Coords[])): void;
        protected _setSelectionCell(activeCell: IRange.CellCoords | null): this;
        protected _isCellOutOfBounds(cell: IRange.CellCoords): boolean;
        protected _cellToRangeActual(start: IRange.CellCoords, end: IRange.CellCoords): IRange.Coords;
        protected _rangesFromCellOptional(selection: IRangeSelection.Coords, cell: Partial<IRange.CellCoords>, cellPivot: Partial<IRange.CellCoords>): IRange.Coords;
        protected _getMaxRange(): IRange.Coords;
        get [Symbol.toStringTag](): string;
        toString(): string;
    }
}
declare module "conditional/_ConditionalMessages" {
    export const MODEL_CLOSED = "Table has been closed. No further operations are allowed.";
}
declare module "conditional/ConditionalEntry" {
    import { Scalar, IRange } from '@sheetxl/primitives';
    import { IProperties } from "type/index";
    import { IStyle } from "style/index";
    import { ISpatialMap } from "collections/ISpatialMap";
    import { IConditionalFormat } from "conditional/IConditionalFormat";
    export class ConditionalEntry implements IProperties.ICellRanged<IStyle.Properties>, ISpatialMap.IUpdatableEntry {
        protected _c: IRange.Coords;
        protected _m: IConditionalFormat;
        constructor(coords: IRange.Coords, model: IConditionalFormat);
        getModel(): IConditionalFormat;
        /** {@inheritDoc IProperties.ICellRanged.getCoords} */
        getCoords(): IRange.Coords;
        /** {@inheritDoc IProperties.ICellRanged.getPropertiesAt} */
        getPropertiesAt(rowIndex: number, colIndex: number, value: Scalar): Readonly<IStyle.Properties>;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getSplit} */
        getSplit(coords: readonly [IRange.Coords, IRange.Coords]): [this, this] | undefined;
    }
}
declare module "conditional/ConditionalFormat" {
    import { Scalar, IRange } from '@sheetxl/primitives';
    import { ReferenceableClipboard } from '@sheetxl/utils';
    import { ITransaction } from "transaction/index";
    import { IListener } from "listener/index";
    import { ICellRanges } from "cellRange/index";
    import { IStyle, IStyleCollection } from "style/index";
    import { IAnchored } from "anchored/index";
    import { ISheet } from "sheet/index";
    import { IModel } from "model/index";
    import { AbstractAnchored } from "anchored/AbstractAnchored";
    import { AbstractModel } from "model/AbstractModel";
    import { IConditionalFormat } from "conditional/IConditionalFormat";
    import { ISpatialMap } from "collections/index";
    interface State extends AbstractAnchored.State {
        type: IConditionalFormat.Type;
        priority: number;
        stopIfTrue: boolean;
        aboveAverage?: boolean;
        equalAverage?: boolean;
        stdDev?: number;
        bottom?: boolean;
        percent?: boolean;
        rank?: number;
        operator?: IConditionalFormat.OperatorType;
        /**
         * Use for evaluating. The number of formula is operator dependent.
         */
        formulas?: string[];
        text?: string;
        timePeriod?: IConditionalFormat.TimePeriod;
        /**
         * A conditional format must have 1 only 1 of the following properties set.
         */
        style?: IStyle.Properties;
        colorScale?: IConditionalFormat.ColorScale;
        dataBar?: IConditionalFormat.DataBar;
        iconSet?: IConditionalFormat.IconSet;
        value?: any;
    }
    interface CommitView extends AbstractAnchored.CommitView {
    }
    /**
     * Implementation of {@link IConditionalFormat}.
     */
    export class ConditionalFormat extends AbstractModel<State, IConditionalFormat.JSON> implements IConditionalFormat {
        protected _sheet: ISheet;
        protected _styles: IStyleCollection;
        protected _stylesRemoveListener: IListener.Remove;
        protected _setContainerRanges: (address: ICellRanges.Address, options?: ITransaction.OperationOptions) => ICellRanges;
        protected _getContainerRanges: () => ICellRanges;
        protected _coordsCache: Readonly<IRange.Coords[]> | null;
        constructor(options: ConditionalFormat.ConstructorOptions);
        /** {@inheritDoc IConditionalFormat.getRanges} */
        getRanges(): ICellRanges;
        /** {@inheritDoc IConditionalFormat.setRanges} */
        setRanges(address: ICellRanges.Address, options?: ITransaction.OperationOptions): this;
        /** {@inheritDoc IConditionalFormat.setType} */
        setType(type: IConditionalFormat.Type, options?: ITransaction.OperationOptions): this;
        /** {@inheritDoc IConditionalFormat.getType} */
        getType(): IConditionalFormat.Type;
        /** {@inheritDoc IConditionalFormat.setPriority} */
        setPriority(priority: number, options?: ITransaction.OperationOptions): this;
        /** {@inheritDoc IConditionalFormat.getPriority} */
        getPriority(): number;
        /** {@inheritDoc IConditionalFormat.setStopIfTrue} */
        setStopIfTrue(stopIfTrue: boolean, options?: ITransaction.OperationOptions): this;
        /** {@inheritDoc IConditionalFormat.setStopIfTrue} */
        getStopIfTrue(): boolean;
        /** {@inheritDoc IConditionalFormat.getScalar} */
        getScalar(): any;
        /** {@inheritDoc IConditionalFormat.getColorScale} */
        getColorScale(): IConditionalFormat.ColorScale;
        /** {@inheritDoc IConditionalFormat.getContainsText} */
        getContainsText(): string;
        /** {@inheritDoc IConditionalFormat.getCustom} */
        getCustom(): string[];
        /** {@inheritDoc IConditionalFormat.getDataBar} */
        getDataBar(): IConditionalFormat.DataBar;
        /** {@inheritDoc IConditionalFormat.getIconSet} */
        getIconSet(): IConditionalFormat.IconSet;
        /** {@inheritDoc IConditionalFormat.getPresetCriteria} */
        getPresetCriteria(): IStyle.Properties;
        /** {@inheritDoc IConditionalFormat.getTopBottom} */
        getTopBottom(): any;
        /** {@inheritDoc IConditionalFormat.getSnapshot} */
        getSnapshot(options?: ReferenceableClipboard.CopyOptions): IConditionalFormat.ISnapshot;
        /** @internal */
        protected _processRestoreOrRevert(state: State, view: CommitView, commit: ITransaction.ICommit): void;
        /** @internal */
        protected _createSpatial(coords: IRange.Coords): ISpatialMap.IUpdatableEntry;
        /** @internal */
        protected _processCoordsChange(options: IAnchored.CoordsChangeOptions): void;
        /** {@inheritDoc IConditionalFormat.update} */
        update(properties: IConditionalFormat.Properties, options?: ITransaction.OperationOptions): this;
        /** @internal */
        protected _processDelete(): void;
        /** @internal */
        protected _processStateChange(state: State, view: CommitView, commit: ITransaction.ICommit): void;
        /** {@inheritDoc IConditionalFormat.toJSON} */
        toJSON(): IConditionalFormat.JSON | null;
        /** @internal */
        protected _fromJSON(json: IConditionalFormat.JSON): void;
        /** {@inheritDoc IConditionalFormat.close} */
        close(): void;
        /** {@inheritDoc IProperties.ICellRanged.getCoords} */
        getCoords(): Readonly<IRange.Coords>;
        /** {@inheritDoc IProperties.ICellRanged.getPropertiesAt} */
        getPropertiesAt(rowIndex: number, colIndex: number, _value: Scalar): Readonly<IStyle.Properties>;
        /** {@inheritDoc IConditionalFormat.isIConditionalFormat} */
        get isIConditionalFormat(): true;
    }
    export namespace ConditionalFormat {
        interface ConstructorOptions extends IModel.ConstructorOptions<IConditionalFormat.JSON> {
            sheet?: ISheet;
            /**
             * Must be called before container change apis can be used.
             */
            setCreateSpatial(callback: (coord: IRange.Coords) => ISpatialMap.IUpdatableEntry): void;
            /**
             * Update the coords used.
             *
             * @param address Set the anchor on the container.
             *
             * @remarks
             *
             * Setting this to null will remove the item.
             */
            setContainerRanges(address: ICellRanges.Address, options?: ITransaction.OperationOptions): ICellRanges;
            /**
             * Returns the current container ranges.
             */
            getContainerRanges(): ICellRanges;
            /**
             * Notify that the container changed the coords.
             *
             * @param callback
             *
             * @remarks
             * Coordinates can be changed by the container for a variety of reasons.
             * 1. Shift (ranges increase or decrease in size due to insert/remove of rows/columns
             * 2. Merge (2 ranges become 1 due to remove)
             * 3. Split (1 range becomes 2 due to insert)
             * 4. delete (range is removed due to clear or remove)
             * 5. Move Cells (update)
             */
            setOnContainerCoordsChange(callback: IAnchored.CoordsChangeCallback): void;
        }
    }
}
declare module "conditional/ConditionalFormatCollection" {
    import { ICellRange, ICellRanges } from "cellRange/index";
    import { IConditionalFormatCollection } from "conditional/IConditionalFormatCollection";
    import { IConditionalFormat } from "conditional/IConditionalFormat";
    export class ConditionalFormatCollection implements IConditionalFormatCollection {
        private _add;
        private _get;
        constructor(add: (address: ICellRange.Address, options: IConditionalFormatCollection.AddOptions) => IConditionalFormat, get: (address: ICellRanges.Address, ignoreHidden: boolean, fullyContained: boolean) => IConditionalFormat[]);
        /** {@inheritDoc IConditionalFormatCollection.add} */
        add(address: ICellRange.Address, options?: IConditionalFormatCollection.AddOptions): IConditionalFormat;
        /** {@inheritDoc IConditionalFormatCollection.getItems} */
        getItems(options?: IConditionalFormatCollection.GetItemsOptions): IConditionalFormat[];
        /** {@inheritDoc IConditionalFormatCollection.getCount} */
        getCount(): number;
    }
}
declare module "sheet/protection/ISheetProtection" {
    import { IProtection } from "protection/IProtection";
    /**
     * Interface representing the protection settings for a sheet.
     * Extends the base `IProtection` interface with additional sheet-specific protection options.
     */
    export interface ISheetProtection extends IProtection<ISheetProtection, ISheetProtection.Properties, ISheetProtection.JSON> {
        /**
         * Retrieves the protection properties for the sheet.
         *
         * @returns The {@link ISheetProtection.Properties} object representing the current protection settings.
         */
        getProperties(): ISheetProtection.Properties;
        /**
         * Checks if the AutoFilter functionality is protected on the sheet.
         *
         * @returns `true` if AutoFilter is locked, `false` otherwise.
         */
        isAutoFilterAllowed(): boolean;
        /**
         * Checks if deleting columns is protected on the sheet.
         *
         * @returns `true` if deleting columns is locked, `false` otherwise.
         */
        isDeleteColumnsAllowed(): boolean;
        /**
         * Checks if deleting rows is protected on the sheet.
         *
         * @returns `true` if deleting rows is locked, `false` otherwise.
         */
        isDeleteRowsAllowed(): boolean;
        /**
         * Checks if formatting cells is protected on the sheet.
         *
         * @returns `true` if formatting cells is locked, `false` otherwise.
         */
        isFormatCellsAllowed(): boolean;
        /**
         * Checks if formatting columns is protected on the sheet.
         *
         * @returns `true` if formatting columns is locked, `false` otherwise.
         */
        isFormatColumnsAllowed(): boolean;
        /**
         * Checks if formatting rows is protected on the sheet.
         *
         * @returns `true` if formatting rows is locked, `false` otherwise.
         */
        isFormatRowsAllowed(): boolean;
        /**
         * Checks if inserting columns is protected on the sheet.
         *
         * @returns `true` if inserting columns is locked, `false` otherwise.
         */
        isInsertColumnsAllowed(): boolean;
        /**
         * Checks if inserting hyperlinks is protected on the sheet.
         *
         * @returns `true` if inserting hyperlinks is locked, `false` otherwise.
         */
        isInsertHyperlinksAllowed(): boolean;
        /**
         * Checks if inserting rows is protected on the sheet.
         *
         * @returns `true` if inserting rows is locked, `false` otherwise.
         */
        isInsertRowsAllowed(): boolean;
        /**
         * Checks if objects (e.g., charts, shapes) are protected on the sheet.
         *
         * @returns `true` if objects are locked, `false` otherwise.
         */
        isObjectsAllowed(): boolean;
        /**
         * Checks if pivot tables are protected on the sheet.
         *
         * @returns `true` if pivot tables are locked, `false` otherwise.
         */
        isPivotTablesAllowed(): boolean;
        /**
         * Checks if scenarios are protected on the sheet.
         *
         * @returns `true` if scenarios are locked, `false` otherwise.
         */
        isScenariosAllowed(): boolean;
        /**
         * Checks if sorting is protected on the sheet.
         *
         * @returns `true` if sorting is locked, `false` otherwise.
         */
        isSortAllowed(): boolean;
        /**
         * Checks if selecting locked cells is protected on the sheet.
         *
         * @returns `true` if selecting locked cells is locked, `false` otherwise.
         */
        isSelectLockedCellsAllowed(): boolean;
        /**
         * Checks if selecting unlocked cells is protected on the sheet.
         *
         * @returns `true` if selecting unlocked cells is locked, `false` otherwise.
         */
        isSelectUnlockedCellsAllowed(): boolean;
    }
    /**
     * {@inheritDoc ISheetProtection}
     * @see
     * ### **Interface**
     *
     * {@link ISheetProtection}
     */
    export namespace ISheetProtection {
        interface Properties extends IProtection.Properties {
            /** {@inheritDoc ISheetProtection.isAutoFilterAllowed} */
            autoFilter?: boolean;
            /** {@inheritDoc ISheetProtection.isDeleteColumnsAllowed} */
            deleteColumns?: boolean;
            /** {@inheritDoc ISheetProtection.isDeleteRowsAllowed} */
            deleteRows?: boolean;
            /** {@inheritDoc ISheetProtection.isFormatCellsAllowed} */
            formatCells?: boolean;
            /** {@inheritDoc ISheetProtection.isFormatColumnsAllowed} */
            formatColumns?: boolean;
            /** {@inheritDoc ISheetProtection.isFormatRowsAllowed} */
            formatRows?: boolean;
            /** {@inheritDoc ISheetProtection.isInsertColumnsAllowed} */
            insertColumns?: boolean;
            /** {@inheritDoc ISheetProtection.isInsertHyperlinksAllowed} */
            insertHyperlinks?: boolean;
            /** {@inheritDoc ISheetProtection.isInsertRowsAllowed} */
            insertRows?: boolean;
            /** {@inheritDoc ISheetProtection.isObjectsAllowed} */
            objects?: boolean;
            /** {@inheritDoc ISheetProtection.isPivotTablesAllowed} */
            pivotTables?: boolean;
            /** {@inheritDoc ISheetProtection.isScenariosAllowed} */
            scenarios?: boolean;
            /** {@inheritDoc ISheetProtection.isSelectLockedCellsAllowed} */
            selectLockedCells?: boolean;
            /** {@inheritDoc ISheetProtection.isSelectUnlockedCellsAllowed} */
            selectUnlockedCells?: boolean;
            /** {@inheritDoc ISheetProtection.isSortAllowed} */
            sort?: boolean;
            sheet?: boolean;
        }
        interface JSON extends ISheetProtection.Properties, IProtection.JSON {
        }
        type PropertyKeys = (keyof ISheetProtection.Properties);
    }
}
declare module "sheet/protection/index" {
    export * from "sheet/protection/ISheetProtection";
}
declare module "utils/GeomUtils" {
    import type { Point, Size, Bounds } from '@sheetxl/utils';
    /**
     * Return the union of to 2 bounds.
     * @remarks
     * Not null same.
     */
    export const unionBounds: (a: Bounds, b: Bounds) => Bounds;
    /**
     * Return the absolute center of the bounds.
     */
    export const centerPoint: (bounds: Bounds) => Point;
    /**
     * Points are return tl, tr, br, bl
     *
     * @param bounds {@link Bounds}
     * @returns A array of points [tl, tr, br, bl]
     */
    export const boundsToPoints: (bounds: Bounds) => Point[];
    /**
     * Returns the minimum bounds for all the containing points.
     */
    export const minBoundingRect: (points: Point[]) => Bounds;
    /**
     * Rotate all points around.
     *
     * @param points The array of points.
     * @param deg A number in degrees.
     * @returns A array of points [tl, tr, br, bl].
     */
    export const rotatePoints: (points: Point[], deg: number, center?: Point) => Point[];
    /**
     * Takes an an inner un-rotated dimension and an outer un-rotated dimension and then will return
     * an un-rotated rectangle that if rotated will fit inside the outer rectangle.
     */
    export const clipToOuterRect: (dimInner: Size, dimOuter: Size, rotation?: number) => Size;
    export const findIntersectMath: (p1: Point, p2: Point, min: number, max: number) => {
        min: number;
        max: number;
    };
    export const angleToPoints: (angleDeg: number, rectBounds: Bounds) => {
        x1: number;
        y1: number;
        x2: number;
        y2: number;
    };
    /**
     * Adapted from https://medium.com/@sahirnambiar/linear-least-squares-a-javascript-implementation-and-a-definitional-question-e3fba55a6d4b
     * @internal @hidden
     */
    export const leastSquaresSlopeAndIntercept: (values: readonly number[]) => {
        m: number;
        b: number;
    };
}
declare module "utils/index" {
    export * as GeomUtils from "utils/GeomUtils";
}
declare module "sheet/clipboard/IHTMLParser" {
    import { IRange } from '@sheetxl/primitives';
    import { ICell, ICellHeader } from "cell/index";
    export namespace IHTMLParser {
        type GetCSSStyles = (node: Element) => Record<string, string>;
        interface TableParser {
            /**
             * This will be called after a valid table type has been found.
             */
            onStart?: (styles: Map<string, any>) => void;
            onTableStart?: (getStyles: GetCSSStyles, element: HTMLTableElement) => void;
            onColumn?: (colIndex: number, colSpan: number, getStyles: GetCSSStyles, element: HTMLTableColElement | null) => void;
            onRowStart?: (rowIndex: number, rowSpan: number, getStyles: GetCSSStyles, element: HTMLTableRowElement | null) => void;
            onCell: (coords: IRange.Coords, plainText: string, htmlText: string | null, getStyles: GetCSSStyles, element: Element | null) => void;
            onRowDow?: (rowIndex: number, rowSpan: number, getStyles: GetCSSStyles, element: HTMLTableRowElement | null) => void;
            onTableDone?: (getStyles: GetCSSStyles, element: HTMLTableElement) => void;
            /**
             * Called when a table isn't found.
             */
            onNoTable?: (strValue: string, getCSSStyles: GetCSSStyles, element: Element) => void;
            onDone?: () => void;
        }
        interface Writer {
            /**
             * inline indicates if is it stored as a style attribute. By default it is stored in the style tag
             */
            addStyle: (name: string, value: string) => void;
            /**
             * inline indicates if is it stored as a style attribute. By default it is stored in the style tag
             */
            addAttribute: (name: string, value: any) => void;
            /**
             * Adds style to a global style.
             * If the style is already declared this will add to the style.
             * Note - Some implementations may not support this and instead force everything to be inlined.
             */
            addSharedStyle: (name: string, styles: Record<string, string>) => void;
        }
        /**
         * Extends the write to support arbitrary values.
         * Both setPlainText and setHTMLText will be call so that rich values
         * and simple fallback values can be provided.
         */
        interface ValueWriter extends Writer {
            /**
             * Set the value as plain text.
             */
            setPlainText: (value: string) => void;
            /**
             * Set the value as HTML text.
             *
             * @remarks
             * If this is not set the the plain text is used. Generally the HTML text will be formatted.
             */
            setHTMLText: (value: string) => void;
        }
        /**
         * Used for writing tables.
         */
        interface TableWriter {
            /**
             * Called when the writer starts.
             */
            onStart?: () => void;
            /**
             * Called when a table is visited.
             */
            onTable?: (writer: Writer, coords: IRange.Coords) => void;
            /**
             * Called when a row is visited.
             *
             * @remarks
             * HTML rows don't span.
             */
            onRow?: (header: ICellHeader, index: number, span: number, writer: Writer) => void;
            /**
             * If returns a number representing the colspan.
             */
            onColumn?: (header: ICellHeader, index: number, span: number, writer: Writer) => void;
            /**
             * If returns `false` this cell will not be added.
             *
             * @remarks
             * Useful for spanning.
             */
            onCell: (cell: ICell, coords: ICell.Coords, writer: ValueWriter) => void | false;
            /**
             * Called when the write is finished to allow for any post processing.
             */
            onDone?: () => void;
        }
    }
}
declare module "sheet/clipboard/_ClipboardUtils" {
    import { type ICellRange } from "cellRange/index";
    import { IHTMLParser } from "sheet/clipboard/IHTMLParser";
    export const sheetToHTMLAndText: (writer: IHTMLParser.TableWriter, range: ICellRange) => [string, string];
    export const pasteTextOrCSV: (value: any, delimiter?: string) => Promise<string[][]>;
    /**
     * Parses clipboard for a table. It tried to force regardless of html.
     * An html table parser must be passed.
     */
    export const parseAsTable: (htmlDoc: Document, plainTextArray: string[][], parser: IHTMLParser.TableParser) => boolean;
}
declare module "utils/_CSSUtils" {
    import { TextDecoration as CSSTextDecoration } from 'csstype';
    import { Bounds } from '@sheetxl/utils';
    import { IColor } from "color/index";
    import { IFill } from "fill/index";
    import { IFont } from "font/index";
    import { ITextFrame } from "text/index";
    import { IBorder } from "border/index";
    export interface ParsedFont {
        family: string;
        size?: string;
        fallbacks?: string[];
    }
    export const fromMsoRotate: (value: number | string) => number;
    export const toMsoRotate: (value: number) => number;
    export const parseFont: (value: string) => ParsedFont;
    export const toRGB: (color: IColor, darkMode?: boolean) => string;
    export const toHex: (color: IColor, darkMode?: boolean) => string;
    export const toCSSColor: (color: IColor, darkMode?: boolean) => string;
    export const toCSSFontSize: (size: number) => string;
    export const toCSSTextDecoration: (underline: IFont.UnderlineStyle | boolean, strike: boolean) => CSSTextDecoration;
    export const toCSSTextUnderlineStyle: (underline: IFont.UnderlineStyle) => string;
    export const noDecoration: Readonly<{
        underline: "none";
        strike: false;
    }>;
    export const parseCSSTextDecoration: (decoration: string) => {
        underline: IFont.UnderlineStyle;
        strike: boolean;
    };
    export const parseCSSTextUnderlineStyle: (underline: string) => IFont.UnderlineStyle;
    /**
     * Not this does not support super and sub. This are in
     * @param align {@link ITextFrame.VerticalAlignment}
     * @returns A css string for 'vertical-align'.
     */
    export const toCSSVerticalAlign: (align: ITextFrame.VerticalAlignment) => string;
    export const toCSSWhiteSpace: (overflow: ITextFrame.Overflow) => string;
    export const toCSSFontFamily: (fontFamily: string, fallbacks: string[]) => string;
    export const toCSSNumberFormat: (numberFormat: string) => string;
    export const unicodeToChar: (text: string) => string;
    export const charToUnicode: (text: string) => string;
    /**
     * @see
     * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight}
     */
    export const FontWeightClass: {
        readonly Thin: "Thin";
        readonly Hairline: "Hairline";
        readonly ExtraLight: "Extra Light";
        readonly UltraLight: "Ultra Light";
        readonly Light: "Light";
        readonly Normal: "Normal";
        readonly Regular: "Regular";
        readonly Medium: "Medium";
        readonly SemiBold: "Semi Bold";
        readonly DemiBold: "Demi Bold";
        readonly Bold: "Bold";
        readonly ExtraBold: "Extra Bold";
        readonly UltraBold: "Ultra Bold";
        readonly Black: "Black";
        readonly Heavy: "Heavy";
        readonly ExtraBlack: "Extra Black";
        readonly UltraBlack: "Ultra Black";
    };
    export type FontWeightClass = typeof FontWeightClass[keyof typeof FontWeightClass];
    /**
     * @see
     * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight}
     */
    export const FontWeightNamed: {
        readonly Lighter: "lighter";
        readonly Normal: "normal";
        readonly Bold: "bold";
        readonly Bolder: "bolder";
    };
    export type FontWeightNamed = typeof FontWeightNamed[keyof typeof FontWeightNamed];
    /**
     * Returns as numbered weight
     * https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight
     * @param value
     */
    export const parseFontWeight: (value: string | number) => number;
    /**
     * @see
     * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight}
     */
    export const FontSizeClass: {
        readonly XXSmall: "xx-small";
        readonly XSmal: "x-small";
        readonly Small: "small";
        readonly Medium: "medium";
        readonly Large: "large";
        readonly XLarge: "x-large";
        readonly XXLarge: "xx-large";
        readonly XXXLarge: "xxx-large";
        readonly Smaller: "smaller";
        readonly Larger: "larger";
        readonly Math: "math";
    };
    export type FontSizeClass = typeof FontSizeClass[keyof typeof FontSizeClass];
    export const parseFontSize: (value: string, normalSize?: number, defaultUnit?: string) => number | null;
    /**
     * Looks for a color and then a supported pattern stye.
     *
     * @param value
     * @returns A `IFill.PatternProperties`.
     */
    export const parsePattern: (value: string) => Partial<IFill.PatternProperties>;
    export const toCSSGradient: (gradientFill: IFill.IGradient, darkMode?: boolean, _bounds?: Bounds) => string;
    export const toCSSPattern: (patternType: IFill.BuiltInSheetPattern) => string;
    export const toCSSBorderStroke: (stroke: IBorder.IStroke) => string;
    export const parseBorderStroke: (value: string, parseColor?: (str: string) => string) => IBorder.StrokeProperties;
    /**
     * @see
     * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/text-align}
     */
    export const TextAlignClass: {
        readonly Start: "start";
        readonly End: "end";
        readonly Left: "left";
        readonly Right: "right";
        readonly Center: "center";
        readonly Justify: "justify";
        readonly JustifyAll: "justify-all";
        readonly MatchParent: "match-parent";
    };
    export type TextAlignClass = typeof TextAlignClass[keyof typeof TextAlignClass];
    /**
     * @see
     * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/vertical-align}
     */
    export const VerticalAlignClass: {
        readonly Baseline: "baseline";
        readonly Top: "top";
        readonly Middle: "middle";
        readonly Bottom: "bottom";
        readonly Sub: "sub";
        readonly Super: "super";
        readonly TextTop: "text-top";
        readonly Justify: "justify";
        readonly Distributed: "distributed";
    };
    export type VerticalAlignClass = typeof VerticalAlignClass[keyof typeof VerticalAlignClass];
    export const parseCSSTextAlign: (value: string) => ITextFrame.HorizontalAlignment;
    export const parseCSSVerticalAlign: (value: string) => ITextFrame.VerticalAlignment;
}
declare module "sheet/clipboard/SheetHTMLTableWriter" {
    import { IRange } from '@sheetxl/primitives';
    import { ICell, ICellHeader } from "cell/index";
    import { ISheet } from "sheet/ISheet";
    import { IHTMLParser } from "sheet/clipboard/IHTMLParser";
    /**
     * Writes `ISheet` to html.
     */
    export class SheetHTMLTableWriter implements IHTMLParser.TableWriter {
        private _sheet;
        private _visitedStyles;
        private _lastStyleClassId;
        private _wroteTD;
        private _normalStyle;
        /**
         * The width/height can be embedded into each cell. We default this to value
         */
        private _includeSizeInCell;
        constructor(sheet: ISheet, includeSizeInCell?: boolean);
        private _createCSSStyle;
        private _createCSSNormalStyle;
        onCell(cell: ICell, coords: IRange.CellCoords, valueWriter: IHTMLParser.ValueWriter): void | false;
        onRow(header: ICellHeader, index: number, span: number, writer: IHTMLParser.Writer): void;
        onColumn(header: ICellHeader, index: number, span: number, writer: IHTMLParser.Writer): void;
    }
}
declare module "sheet/_CopyUtils" {
    import { IRange } from '@sheetxl/primitives';
    import { IMovable } from "movable/index";
    import { ICellRange, ICellHeaderRange } from "cellRange/index";
    import { ISheet } from "sheet/ISheet";
    import { Sheet } from "sheet/Sheet";
    /**
     * Converts a header snapshot to sheet.
     */
    export const headerToSheetSnapshot: (rangeMark: ICellHeaderRange, coordMark: IRange.Coords, optionsMark: ICellHeaderRange.CopyOptions) => Partial<ICellRange.ISnapshot>;
    /**
     * Wraps a copySheetTo function into a ISheet.ISnapshot.
     * * This will error if snapshot is a cut and called a second.
     * @internal
     */
    export const callbackToSheetSnapshot: (sheetFrom: ISheet, sheetMark: ISheet, coordsFrom: readonly IRange.Coords[], description: string, optionsMark: ICellRange.CopyOptions, copySheetTo: (sheetRange: ICellRange, options?: ICellRange.CopyOptions) => Promise<IRange.Coords> | IRange.Coords) => ICellRange.ISnapshot;
    /**
     * Converts an array of Snapshots into a single snapshot.
     */
    export const arrToSheetSnapshot: (snapshots: Partial<ICellRange.ISnapshot>[], sheet: ISheet, sheetMark: ISheet, coordsMark: IRange.Coords, optionsMark: ICellRange.CopyOptions, descriptionMark: string, snapshotNative?: ICellRange.ISnapshot) => ICellRange.ISnapshot;
    export const movablesToSheetSnapshot: (sheetMark: Sheet, coordsMark: readonly IRange.Coords[], movablesSelectionMark: readonly IMovable[], markOptions: ICellRange.CopyOptions) => ICellRange.ISnapshot<ISheet>;
}
declare module "sheet/header/_HeaderUtils" {
    import { RunCoords } from '@sheetxl/utils';
    import { IRange } from '@sheetxl/primitives';
    import { ITypes } from "type/index";
    import { IStyle } from "style/index";
    import { ICellHeaderRange, ICellHeaderRanges } from "cellRange/index";
    import { IRangeSelection } from "selection/index";
    import { ISheetHeader } from "sheet/header/ISheetHeader";
    /**
     * Note - By using optional keys as a way to detect default values we are creating mono polymorphic objects. (perform issue in V8).
     * Revisit and store all keys as a single type.
     * 1. Create a 'default' state. We will need an isEmpty method to compare all value for pruning. (Probably just )
     * 2. Only save values that are different than the default state
     */
    export interface CellHeaderState {
        sz?: number;
        csz?: boolean;
        h?: boolean;
        s?: IStyle;
        cs?: boolean;
    }
    /**
     * Use for tracking the accumulated sizes from the beginning of the headers.
     * @remarks
     * This is a run but doesn't conform to the Run interface.
     */
    export interface RunningHeaderSize {
        indexMin: number;
        indexMax: number;
        spanSize: number;
        runningOffsetMin: number;
        runningOffsetMax: number;
        /**
         * The running headers up to run.
         */
        runningHiddenRuns: number;
    }
    export interface HiddenRun extends ITypes.RunCoordValue<boolean> {
    }
    export interface IndexedHeaders {
        sizes: RunningHeaderSize[];
        hidden: HiddenRun[];
    }
    export const nocToPx: (noc: number, mdw: number) => number;
    /**
     * Builds a list of measurable spans. We don't allow any gaps to make search faster.
     * Note - These are saved as pixels so that we can render quickly.
     * We could be even smarter and only re-index from a given offset but optimization for later (if needed).
     */
    export const indexHeaderSizes: (runs: ITypes.RunCoordValue<CellHeaderState>[], defaultSize: number, scaleFactor: number) => IndexedHeaders;
    /**
     * These assume a results from {@link indexHeaderSizes} is used. No error handling is performed.
     * All size runs must be contiguous.
     * @param sizes
     * @param index
     * @returns The offset for the given index.
     */
    export const findOffset: (sizes: RunningHeaderSize[], index: number, defaultSize: number) => number;
    /**
     * These assume a results from {@link indexHeaderSizes} are used. No error handling is performed.
     * sizes.length > 0. All values must be contiguous. offset must be >= 0 && offset <= size[size.length].maxOffset.
     * @remarks
     * If the current index is hidden it will return the offset before the value
     * @param sizes
     * @param offset
     * @returns the index for the given offset.
     */
    export const findIndex: (sizes: RunningHeaderSize[], offset: number, defaultSize: number) => number;
    /**
     * Finds the visibleIndex for a given absolute index.
     * Returns a RunCoords. This can be used to determine if an index is hidden
     * If it's hidden it will return a range of 1 with a value before the offset and after.
     * If it's visible then it will return a range of 0 with the min and max that exactly match the offset.
     * @remarks
     * If this is on the edge of the bounds this will return a +/- 1 the max bounds.
     * @param index The absolute index
     */
    export const findRunningHiddenRuns: (sizes: RunningHeaderSize[], index: number, maxIndex?: number) => RunCoords;
    /**
     * Finds the total length between to points account for hidden spans.
     * No validation is done.
     */
    export const findRunningSpanLength: (runs: RunningHeaderSize[], from: number, to: number) => number;
    /**
     * Set a value on on a container unless.
     * 1. It's null then clears.
     * 2. It's undefined then ignores.
     */
    export function setOrClear<T = any>(container: Record<string, any>, key: string, newValue: T | null | undefined): void;
    /** @internal */
    export const parseHeaderRangesAddress: (address: ICellHeaderRanges.Address, isColumn: boolean, defaultRange?: IRange.FixableCoords) => RunCoords[];
    /** @internal */
    export const parseHeaderRangeAddress: (address: ICellHeaderRange.Address, isColumn: boolean, defaultRange?: IRange.FixableCoords) => RunCoords;
    /**
     * Create an invalid range.
     */
    export function createRangeInvalidRef(header: ISheetHeader): ICellHeaderRange;
    /**
     * Returns a union of all ranges in the selection.
     * @deprecated
     */
    export const rangeUnionFromSelection: (selection: IRangeSelection.Coords) => IRange.Coords;
    /**
     * Create runs from selection.
     */
    export const createRunsFromSelection: (header: ISheetHeader, selection: IRangeSelection.Coords, maxRange: IRange.Coords) => ITypes.RunCoordValue<ISheetHeader.SelectedRun>[];
    /**
     * Converts a set of RunCoords into a set of Ranges.
     */
    export const runCoordsToRangeCoords: (runs: readonly Readonly<Partial<RunCoords>>[], entireRange: IRange.Coords, isColumn: boolean) => Partial<IRange.FixableCoords>[];
    /**
     * Returns a list of merged and non-overlapping run coordinates.
     */
    export const removeOverlappingRuns: (runs: readonly Readonly<Partial<RunCoords>>[], merge?: boolean) => RunCoords[];
}
declare module "sheet/header/SheetCellHeader" {
    import { IRange } from '@sheetxl/primitives';
    import { IStyle, IStyleCollection } from "style/index";
    import { ICell, ICellHeader } from "cell/index";
    import { ISheetHeader } from "sheet/header/ISheetHeader";
    import * as _Utils from "sheet/header/_HeaderUtils";
    /**
     * Callback for creating custom headers.
     * Note - Not currently used. Formalize and make public or remove.
     * @internal
     */
    export interface CreateCellHeaderCallback {
        (headers: ISheetHeader, hs: _Utils.CellHeaderState, template?: ICell.Modifiers): ICellHeader;
    }
    /**
     * Note - Unlike SheetCell.resolveCellModifiers this returns a new State and not a ResolvedModifiers.
     * This is due to refactoring and simpler requirements, maybe change for consistency).
     * @internal
     */
    export const resolveCellHeaderModifiers: (sheetHeader: ISheetHeader, styles: IStyleCollection, prevHs: _Utils.CellHeaderState, update: ICellHeader.Update) => _Utils.CellHeaderState;
    export class SheetCellHeader implements ICellHeader {
        protected _sheetHeader: ISheetHeader;
        protected _styles: IStyleCollection;
        protected _headerState: _Utils.CellHeaderState;
        protected _template: ICell.Modifiers;
        private _cellTemplate;
        constructor(sheetHeader: ISheetHeader, headerState: _Utils.CellHeaderState, template: ICell.Modifiers);
        /** {@inheritDoc ICellHeader.getSize} */
        getSize(): number;
        /** {@inheritDoc ICellHeader.getDisplayText} */
        getDisplayText(): string;
        /** {@inheritDoc ICellHeader.getOrientation} */
        getOrientation(): IRange.Orientation;
        /** {@inheritDoc ICellHeader.isHidden} */
        isHidden(): boolean;
        /** {@inheritDoc ICellHeader.isCustomSize} */
        isCustomSize(): boolean;
        /** {@inheritDoc ICellHeader.getSheetHeader} */
        getSheetHeader(): ISheetHeader;
        /** {@inheritDoc ICellHeader.getStyle} */
        getStyle(): IStyle;
        /** {@inheritDoc ICellHeader.asCell} */
        asCell(): ICell;
        /** {@inheritDoc ICellHeader.getSizeRelative} */
        getSizeRelative(): number;
        /** {@inheritDoc ICellHeader.createTemporaryCellHeader} */
        createTemporaryCellHeader(update: ICellHeader.Modifiers): ICellHeader;
        /** {@inheritDoc ICellHeader.isEqual} */
        isEqual(other: ICellHeader): boolean;
        /** {@inheritDoc ICellHeader.isEmpty} */
        isEmpty(): boolean;
        get [Symbol.toStringTag](): string;
        toString(): string;
        /** {@inheritDoc ICellHeader.isICellHeader} */
        get isICellHeader(): true;
    }
}
declare module "sheet/header/_SheetHeaderMessage" {
    export const ERROR_PROTECTED_COLUMNS = "The columns are protected. To make a change, unprotect the sheet. You might be requested to enter a password.";
    export const ERROR_PROTECTED_ROWS = "The rows are protected. To make a change, unprotect the sheet. You might be requested to enter a password.";
    export const DESC_ROW: string;
    export const DESC_COL: string;
    export const DESC_ROWS: string;
    export const DESC_COLS: string;
    export const DESC_ROW_HEADERS: string;
    export const DESC_COL_HEADERS: string;
}
declare module "sheet/header/SheetCellHeaderRange" {
    import { IRange } from '@sheetxl/primitives';
    import { RunCoords } from '@sheetxl/utils';
    import { ITypes } from "type/index";
    import { ITransaction } from "transaction/index";
    import { ICellHeader } from "cell/index";
    import { ICellHeaderRange } from "cellRange/index";
    import { CreateCellHeaderCallback } from "sheet/header/SheetCellHeader";
    import * as _Utils from "sheet/header/_HeaderUtils";
    import { SheetHeader } from "sheet/header/SheetHeader";
    export class SheetCellHeaderRange implements ICellHeaderRange {
        protected _header: any;
        protected _coords: RunCoords;
        constructor(header: SheetHeader, coords: RunCoords);
        protected _forEachSpan<T = any>(callback: ICellHeaderRange.ForEachSpanCallback<T>, optionsVisitor: ICellHeaderRange.IteratorOptions, headersToScan: ITypes.RunCoordValue<_Utils.CellHeaderState>[], createCellHeader?: CreateCellHeaderCallback): T | void;
        /** {@inheritDoc ICellHeaderRange.forEachSpan} */
        forEachSpan<T = any>(callback: ICellHeaderRange.ForEachSpanCallback<T>, options?: ICellHeaderRange.IteratorOptions): T | void;
        /** {@inheritDoc ICellHeaderRange.forEachVisibleSpan} */
        forEachVisibleSpan<T = any>(callback: ICellHeaderRange.ForEachVisibleSpanCallback<T>, options?: ICellHeaderRange.ForEachVisibleSpanOptions): T | void;
        /** {@inheritDoc ICellHeaderRange.forEach} */
        forEach<T>(callback: ICellHeaderRange.ForEachCallback<T>, options?: ICellHeaderRange.IteratorOptions): T | void;
        /** {@inheritDoc ICellHeaderRange.updateHeaders} */
        updateHeaders(update: ICellHeader.Update, options?: ICellHeaderRange.UpdateHeadersOptions): this;
        /** {@inheritDoc ICellHeaderRange.getCoords} */
        getCoords(): RunCoords;
        /** {@inheritDoc ICellHeaderRange.setHidden} */
        setHidden(hidden?: boolean): this;
        /** {@inheritDoc ICellHeaderRange.getUsedRange} */
        getUsedRange(options?: ICellHeaderRange.GetRangeOptions): this;
        /** {@inheritDoc ICellHeaderRange.getCount} */
        getCount(): number;
        /** {@inheritDoc ICellHeaderRange.getHeaderCount} */
        getHeaderCount(): number;
        /** {@inheritDoc ICellHeaderRange.getVisibleCount} */
        getVisibleCount(): number;
        /** {@inheritDoc ICellHeaderRange.isEntireHeaders} */
        isEntireHeaders(): boolean;
        /** {@inheritDoc ICellHeaderRange.getSnapshot} */
        getSnapshot(options?: ICellHeaderRange.CopyOptions): ICellHeaderRange.ISnapshot;
        /** {@inheritDoc ICellHeaderRange.clear} */
        clear(): this;
        /** {@inheritDoc ICellHeaderRange.setSize} */
        setSize(size?: number | string, options?: ICellHeaderRange.SetSizeOptions): this;
        /** {@inheritDoc ICellHeaderRange.at} */
        at(index: number): ICellHeader;
        /** {@inheritDoc ICellHeaderRange.getOrientation} */
        getOrientation(): IRange.Orientation;
        /** {@inheritDoc ICellHeaderRange.doBatch} */
        doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ICellHeaderRange.UpdateHeadersOptions): R | Promise<R>;
        /** {@inheritDoc ICellHeaderRange.getSheetHeader} */
        getSheetHeader<S>(): S;
        /** {@inheritDoc ICellHeaderRange.getA1} */
        getA1(): string;
        get [Symbol.toStringTag](): string;
        toString(): string;
        /** {@inheritDoc ICellHeaderRange.isICellHeaderRange} */
        get isICellHeaderRange(): true;
    }
}
declare module "sheet/header/SheetCellHeaderRanges" {
    import { IRange } from '@sheetxl/primitives';
    import { RunCoords } from '@sheetxl/utils';
    import { ITransaction } from "transaction/index";
    import { ICellHeader } from "cell/index";
    import { ICellHeaderRange, ICellHeaderRanges } from "cellRange/index";
    import { SheetHeader } from "sheet/header/SheetHeader";
    export class SheetCellHeaderRanges implements ICellHeaderRanges {
        protected _header: any;
        protected _coords: RunCoords[];
        constructor(header: SheetHeader, coords: RunCoords[]);
        /** {@inheritDoc ICellHeaderRanges.updateHeaders} */
        updateHeaders(update: ICellHeader.Update, options?: ICellHeaderRange.UpdateHeadersOptions): this;
        /** {@inheritDoc ICellHeaderRanges.getCoords} */
        getCoords(): RunCoords[];
        /** {@inheritDoc ICellHeaderRanges.setHidden} */
        setHidden(hidden?: boolean): this;
        /** {@inheritDoc ICellHeaderRanges.getCount} */
        getCount(): number;
        /** {@inheritDoc ICellHeaderRanges.getHeaderCount} */
        getHeaderCount(): number;
        /** {@inheritDoc ICellHeaderRanges.getVisibleCount} */
        getVisibleCount(): number;
        /** {@inheritDoc ICellHeaderRanges.isEntireHeaders} */
        isEntireHeaders(): boolean;
        /** {@inheritDoc ICellHeaderRanges.isEntireHeaders} */
        isEntireHeadersAny(): boolean;
        /** {@inheritDoc ICellHeaderRanges.clear} */
        clear(): this;
        /** {@inheritDoc ICellHeaderRanges.setSize} */
        setSize(size?: number | string, options?: ICellHeaderRange.SetSizeOptions): this;
        /** {@inheritDoc ICellHeaderRanges.at} */
        at(index: number): ICellHeaderRange;
        /** {@inheritDoc ICellHeaderRanges.getOrientation} */
        getOrientation(): IRange.Orientation;
        /** {@inheritDoc ICellHeaderRanges.doBatch} */
        doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ICellHeaderRange.UpdateHeadersOptions): R | Promise<R>;
        /** {@inheritDoc ICellHeaderRanges.getSheetHeader} */
        getSheetHeader<S>(): S;
        /** {@inheritDoc ICellHeaderRanges.getA1} */
        getA1(): string;
        get [Symbol.toStringTag](): string;
        toString(): string;
        /** {@inheritDoc ICellHeaderRanges.isICellHeaderRanges} */
        get isICellHeaderRanges(): true;
    }
}
declare module "sheet/header/SheetHeader" {
    import { IRange } from '@sheetxl/primitives';
    import { RunCoords } from '@sheetxl/utils';
    import { ITypes } from "type/index";
    import { ITransaction } from "transaction/index";
    import { IListener } from "listener/index";
    import { ICellHeader } from "cell/index";
    import { ICellHeaderRange, ICellHeaderRanges } from "cellRange/index";
    import { IRangeSelection } from "selection/index";
    import { ISheet } from "sheet/index";
    import { ISheetHeader } from "sheet/header/ISheetHeader";
    import { ListenerEmitter } from "listener/ListenerEmitter";
    import * as RunUtils from "collections/_RunUtils";
    import { CreateCellHeaderCallback } from "sheet/header/SheetCellHeader";
    import * as _Utils from "sheet/header/_HeaderUtils";
    interface State {
        headers: ITypes.RunCoordValue<_Utils.CellHeaderState>[];
        defaultCustomSize: number;
        runs?: RunCoords[];
    }
    /**
     * For updating and working with headers (rows/columns).
     */
    export class SheetHeader implements ISheetHeader {
        protected _emitter: ListenerEmitter<ISheetHeader, ISheetHeader.IListeners>;
        protected _options: SheetHeader.ConstructorOptions;
        protected _sheetRemoveListener: IListener.Remove;
        protected _transactions: ITransaction.IStore;
        protected _transactionsRemoveListener: IListener.Remove;
        protected _closed: boolean;
        protected _emptyHeader: ICellHeader;
        protected _scaleFactor: number;
        protected _defaultSize: number;
        protected _defaultCustomSize: number;
        protected _defaultPxSize: number;
        protected _isColumn: boolean;
        protected _indexedSizes: _Utils.RunningHeaderSize[];
        protected _indexedHidden: _Utils.HiddenRun[];
        protected _headerRunCoords: RunCoords;
        protected _hasCustomFormats: boolean;
        protected _hasStyles: boolean;
        protected _hasHidden: boolean;
        protected _lastHeaderRead: {
            offset: number;
            header: ICellHeader;
        };
        protected _readCache: RunUtils.CacheSearchRunData<_Utils.CellHeaderState>;
        protected _lastHeaders: ITypes.RunCoordValue<_Utils.CellHeaderState>[];
        protected _lastVisibleRunsRead: number;
        protected _lastVisibleRunCoords: RunCoords;
        protected _maxDataIndex: number;
        protected _maxDataRange: ICellHeaderRange;
        protected _maxRunCoords: RunCoords;
        protected _maxRangeCoords: IRange.Coords;
        protected _selectionRuns: readonly ITypes.RunCoordValue<ISheetHeader.SelectedRun>[];
        protected _selection: IRangeSelection.Coords;
        protected _maxSheetCoords: IRange.Coords;
        constructor(options: SheetHeader.ConstructorOptions);
        /** {@inheritDoc IListener.ISource.addListeners} */
        addListeners(listeners: ISheetHeader.IListeners, options?: IListener.Options): IListener.Remove;
        protected _cacheMaxIndex(): void;
        protected _invalidSizes(force?: boolean): void;
        protected _onHeaderChange(): void;
        /** {@inheritDoc ISheetHeader.getSheet} */
        getSheet(): ISheet;
        /** {@inheritDoc ISheetHeader.getOrientation} */
        getOrientation(): IRange.Orientation;
        /** {@inheritDoc ISheetHeader.getTextAt} */
        getTextAt(index: number): string;
        protected _scanHeaders<T = any>(callback: ICellHeaderRange.ForEachSpanCallback<T>, headers: ITypes.RunCoordValue<_Utils.CellHeaderState>[], createCellHeader: CreateCellHeaderCallback, optionsRange: ICellHeaderRange.GetRangeOptions, asRun: RunCoords, options: ICellHeaderRange.IteratorOptions): {
            break: T;
        } | void;
        /** {@inheritDoc ISheetHeader.getRange} */
        getRange(address: ICellHeaderRange.Address, options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
        /** {@inheritDoc ISheetHeader.getRanges} */
        getRanges(address: ICellHeaderRanges.Address, options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
        /** {@inheritDoc ISheetHeader.getSelectedRange} */
        getSelectedRange(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
        /** {@inheritDoc ISheetHeader.getSelectedRanges} */
        getSelectedRanges(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
        /** {@inheritDoc ISheetHeader.getUsedRange} */
        getUsedRange(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
        /** {@inheritDoc ISheetHeader.getEntireRange} */
        getEntireRange(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
        /** {@inheritDoc ISheetHeader.at} */
        at(index: number): ICellHeader;
        /** {@inheritDoc ISheetHeader.updateHeaderPairs} */
        updateHeaderPairs(pairs: ICellHeaderRange.AddressUpdatePair[], options?: ICellHeaderRange.UpdateHeadersOptions): RunCoords[] | null;
        protected _parseHeaderRangeAddress(address: ICellHeaderRange.Address): RunCoords;
        protected _update(addresses: ICellHeaderRange.Address | ICellHeaderRange.Address[], update: ICellHeader.Update, options?: ICellHeaderRange.UpdateHeadersOptions): this;
        protected _setSize(address: ICellHeaderRange.Address | ICellHeaderRange.Address[], size?: number | string, options?: ICellHeaderRange.SetSizeOptions): this;
        protected _setHidden(address: ICellHeaderRange.Address | ICellHeaderRange.Address[], hidden?: boolean): this;
        protected _clear(coords: RunCoords, options?: ICellHeaderRange.UpdateHeadersOptions): void;
        protected _getSnapshot(coordsFrom?: RunCoords, optionsMark?: ICellHeaderRange.CopyOptions): ICellHeaderRange.ISnapshot;
        /** {@inheritDoc ISheetHeader.isProtected} */
        isProtected(): boolean;
        /** {@inheritDoc ISheetHeader.getScaleFactor} */
        getScaleFactor(): number;
        protected get _headers(): ITypes.RunCoordValue<_Utils.CellHeaderState>[];
        protected _updatePairsInternal(setters: ICellHeaderRange.AddressUpdatePair[], options?: ICellHeaderRange.UpdateHeadersOptions): RunCoords[] | null;
        /**
         * @deprecated
         */
        hasCustomFormats(): boolean;
        /**
         * @deprecated
         */
        hasCustomStyles(): boolean;
        /** {@inheritDoc ISheetHeader.hasHidden} */
        hasHidden(): boolean;
        /** {@inheritDoc ISheetHeader.getDefaultSize} */
        getDefaultSize(): number;
        /** {@inheritDoc ISheetHeader.getMaxSize} */
        getMaxSize(): number;
        /** {@inheritDoc ISheetHeader.getMinSize} */
        getMinSize(): number;
        /** {@inheritDoc ISheetHeader.findOffset} */
        findOffset(index: number): number;
        /** {@inheritDoc ISheetHeader.findIndex} */
        findIndex(offset: number): number;
        /** {@inheritDoc ISheetHeader.findVisibleIndex} */
        findVisibleIndex(index: number): RunCoords;
        /** {@inheritDoc ISheetHeader.getSpanSize} */
        getSpanSize(indexFrom: number, indexTo?: number): number;
        /** {@inheritDoc ISheetHeader.getVisibleCount} */
        getVisibleCount(indexFrom: number, indexTo: number): number;
        /** {@inheritDoc ISheetHeader.isSelectedAll} */
        isSelectedAll(index: number): boolean;
        /** {@inheritDoc ISheetHeader.isSelected} */
        isSelected(index: number): boolean;
        /** {@inheritDoc ISheetHeader.getSelectedRuns} */
        getSelectedRuns(): readonly ITypes.RunCoordValue<ISheetHeader.SelectedRun>[];
        /** {@inheritDoc ISheetHeader.hiddenHeadersAt} */
        hiddenHeadersAt(index: number, reverse?: boolean): number;
        protected _insertHeaders(index: number, amount: number): void;
        protected _deleteHeaders(index: number, amount: number): void;
        /** {@inheritDoc ITransaction.ITransactional.beginCommit} */
        beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
        /** {@inheritDoc ITransaction.ITransactional.doBatch} */
        doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ITransaction.OperationOptions): R | Promise<R>;
        /** {@inheritDoc ITransaction.ITransactional.isClosed} */
        isClosed(): boolean;
        /** {@inheritDoc ISheetHeader.close} */
        close(): void;
        protected _getState(): State;
        protected _beginCommit(options?: ITransaction.StoreOperationOptions): ITransaction;
        protected _updateState(updateState?: Partial<State>): void;
        /** {@inheritDoc ISheetHeader.fromJSON} */
        fromJSON(json: ISheetHeader.JSON): void;
        /** {@inheritDoc ISheetHeader.toJSON} */
        toJSON(): ISheetHeader.JSON;
        get [Symbol.toStringTag](): string;
        toString(): string;
    }
    /**
     * {@inheritDoc SheetHeader}
     * @see
     * ### **Interface**
     *
     * {@link SheetHeader}
     */
    export namespace SheetHeader {
        /**
         * Constructor Options for Sheet Header.
         * @remarks
         * Used by `Sheet`.
         */
        interface ConstructorOptions {
            /**
             * The {@link ISheet} containing the Headers.
             */
            sheet: ISheet;
            /**
             * The orientation of the data.
             *
             * @defaultValue IRange.Orientation.Column
             *
             * @remarks
             * This is the opposite of the orientation of the layout. For examples a header that manages
             * columns will be visibility orientated as a row.
             */
            orientation?: IRange.Orientation;
            /**
             * Returns the maximum range of the headers in both orientations.
             *
             * @defaultValue `{ colStart: 0, rowStart: 0, colEnd: Number.MAX_SAFE_INTEGER, rowEnd: Number.MAX_SAFE_INTEGER }`
             */
            createCellHeader?: CreateCellHeaderCallback;
            transactions?: ITransaction.IStore;
            getUpdateId?: () => number;
            /**
             * If true the Header will error if any updates are attempted.
             */
            isProtected?: () => boolean;
            /**
             * Return the display text at the given index.
             */
            getTextAt?: (index: number) => string;
            /**
             * The size of the header without any customizations.
             *
             * @defaultValue 100
             *
             * @remarks
             * Must be great than 0.
             */
            defaultSize?: () => number;
            /**
             * The minimum size of the header.
             *
             * @defaultValue 0
             *
             * @remarks
             * Must be great than or equal 0.
             */
            minSize?: () => number;
            maxSize?: () => number;
            /**
             * A callback to return the maximum index of the header.
             */
            maxSheetCoords: () => IRange.Coords;
            /**
             * A number that represents a scaling factor.
             */
            scaleFactor?: () => number;
            /**
             * A callback to tell the headers to shift.
             *
             * @param index
             * @param amount
             */
            setContainerShiftedCallback?: (callback: ShiftCallback) => void;
            /**
             * JSON state to load.
             */
            json?: ISheetHeader.JSON;
        }
        /**
         * `Sheet`s manage the insertion and deletion of headers. To notify that this
         * should occur the ShiftCallback is used.
         */
        interface ShiftCallback {
            (index: number, amount: number): void;
        }
    }
}
declare module "sheet/style/_Resolvers" {
    import { TypedObject } from '@sheetxl/utils';
    import { IColor } from "color/index";
    import { IFill } from "fill/index";
    import { ITextFrame, IStyledFont } from "text/index";
    import { IBorder } from "border/index";
    import { NumberFormat } from "numFmt/index";
    import { IStyle, IStyleCollection } from "style/index";
    export const COLOR: TypedObject<IColor.Serializable, IColor, IStyleCollection>;
    export const BORDER_STROKE: TypedObject<IBorder.StrokeProperties<IColor.Serializable>, IBorder.IStroke, IStyleCollection>;
    export const CELL_BORDER: TypedObject<IBorder.Properties, IBorder, IStyleCollection>;
    export const CELL_NUM_FMT: TypedObject<string | NumberFormat.Type | number, any, IStyleCollection>;
    export const CELL_FONT: TypedObject<IStyledFont.Properties, IStyledFont, IStyleCollection>;
    export const CELL_ALIGNMENT: TypedObject<ITextFrame.IAlignment.Properties, ITextFrame.IAlignment, IStyleCollection>;
    export const FILL_NONE: TypedObject<IFill.NoneProperties, IFill.INone, IStyleCollection>;
    export const FILL_SOLID: TypedObject<IFill.SolidProperties, IFill.ISolid, IStyleCollection>;
    export const GRADIENT_STOP: TypedObject<IFill.GradientStopProperties, IFill.IGradientStop, IStyleCollection>;
    export const GRADIENT_STOPS: TypedObject<(IFill.GradientStopProperties | IColor.Serializable)[], (IFill.IGradientStop | IColor.Serializable)[], IStyleCollection>;
    export const FILL_GRADIENT: TypedObject<IFill.GradientProperties, IFill.IGradient, IStyleCollection>;
    export const FILL_PATTERN: TypedObject<IFill.PatternProperties, IFill.IPattern, IStyleCollection>;
    export const FILL: TypedObject<IFill.Properties | IFill.SolidProperties | IFill.GradientProperties | IFill.PatternProperties | IFill.NoneProperties, IFill.ISolid | IFill.IGradient | IFill.IPattern | IFill.INone, IStyleCollection>;
    export const CELL_STYLE: TypedObject<IStyle.Properties, IStyle, IStyleCollection>;
    export const NAMED_CELL_STYLE: TypedObject<IStyle.NamedProperties, IStyle.INamed, IStyleCollection>;
}
declare module "sheet/style/_StyleUtils" {
    import { IBorder } from "border/index";
    export const isEqualStrokeProperties: (a: IBorder.StrokeProperties, b: IBorder.StrokeProperties) => boolean;
}
declare module "sheet/style/SheetDirectStyle" {
    import { Scalar, IRange } from '@sheetxl/primitives';
    import { IProperties } from "type/index";
    import { IBorder } from "border/index";
    import { IStyle, IStyleCollection } from "style/index";
    import { ISpatialMap } from "collections/ISpatialMap";
    /**
     * `SheetDirectStyle` represents a style that spans a range of cells.
     *
     * * It can generate a list of properties for each cell in the range.
     */
    export class SheetDirectStyle implements ISpatialMap.IUpdatableEntry, IProperties.ICellRanged<IStyle.Properties> {
        protected _c: IStyleCollection;
        protected _r: IRange.Coords;
        protected _p: IStyle.Properties;
        protected _t: IRange.Coords;
        protected _e: boolean;
        protected _o: IRange.Orientations;
        constructor(styles: IStyleCollection, range: IRange.Coords, properties?: IStyle.Properties, tile?: IRange.Coords, orientations?: IRange.Orientations);
        isEmpty(): boolean;
        getProperties(): IStyle.Properties;
        /** {@inheritDoc IProperties.ICellRanged.getCoords} */
        getCoords(): Readonly<IRange.Coords>;
        /** {@inheritDoc IProperties.ICellRanged.cloneWithUpdate} */
        cloneWithUpdate(updates: IStyle.Modifiers): this;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.copyTo} */
        copyTo(destination: IRange.Coords, options?: ISpatialMap.CopyOptions): this;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.canTile} */
        canTile(_destination: IRange.Coords, _options?: ISpatialMap.CopyOptions): boolean;
        protected _createShifted(coords: IRange.Coords): this;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getShifted} */
        getShifted(options: ISpatialMap.ShiftDetails<this>): ISpatialMap.Entry<this>;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getSplit} */
        getSplit(coords: [IRange.Coords, IRange.Coords], orientation: IRange.Orientation): [this, this];
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getSplit} */
        getMerged(other: this, destination: IRange.Coords, orientation: IRange.Orientation): this;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.hasTrailingEdge} */
        hasTrailingEdge(): boolean;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.isMergeOnShift} */
        isMergeOnShift(): boolean;
        protected _splitBorderRange(border: IBorder.Properties, range: IRange.Coords, rangeNew: IRange.Coords, isColumn: boolean): Partial<IBorder.Properties> | null | undefined;
        protected _localizeBorderRange(unscoped: Readonly<IBorder.Properties>, rangeUnscoped: IRange.Coords, range: IRange.Coords): Partial<IBorder.Properties> | null | undefined;
        /**
         * Localizes the border to the cell coords.
         * Returns border properties, null, or undefined.
         * * If undefined then there was no border to localize.
         * * `null` is localize to none.
         */
        protected _localizeBorder(unscoped: IBorder.Properties, range: IRange.Coords, rowIndex: number, colIndex: number): Partial<IBorder.Properties> | null | undefined;
        /** {@inheritDoc IProperties.ICellRanged.getPropertiesAt} */
        getPropertiesAt(rowIndex: number, colIndex: number, value: Scalar): Readonly<IStyle.Properties>;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.toJSON} */
        toJSON(): IStyle.JSON;
    }
}
declare module "style/_BuiltInStyleDefs" {
    import { ITextFrame } from "text/index";
    import { IBorder } from "border/index";
    import { IStyledFont } from "text/index";
    import { IStyle } from "style/IStyle";
    import { ICellProtection } from "cell/index";
    /**
     * To avoid duplicating values.
     */
    export const _EmptyFontProperties: IStyledFont.Properties;
    export const _EmptyBorderStrokeProperties: IBorder.StrokeProperties;
    export const _EmptyBorderProperties: IBorder.Properties;
    export const _EmptyAlignmentProperties: ITextFrame.IAlignment.Properties;
    export const _EmptyProtectionProperties: ICellProtection.Properties;
    /**
     * Because all cells derived from the empty cell this is also the default values.
     */
    export const _EmptyCellStyleProperties: IStyle.Properties<any>;
    export const _BuiltInStyleDefs: readonly IStyle.Properties[];
}
declare module "fill/_BuiltInPatterns" {
    import { Properties as CSSProperties } from 'csstype';
    import { IFill } from "fill/IFill";
    class BuiltInPatternLookup {
        private _svgImage;
        toCSS(pattern: IFill.BuiltInSheetPattern, foreground: string, background: string): CSSProperties;
    }
    export const _BuiltInPatterns: BuiltInPatternLookup;
}
declare module "sheet/style/SheetCellStyle" {
    import { Properties as CSSProperties } from 'csstype';
    import { IRange } from '@sheetxl/primitives';
    import { type Size, type Rectangle, type Bounds } from '@sheetxl/utils';
    import { IProperties } from "type/index";
    import { IColor } from "color/index";
    import { IFill } from "fill/index";
    import { IFont } from "font/index";
    import { ITextFrame, IStyledFont } from "text/index";
    import { IBorder } from "border/index";
    import { IStyle, IStyleCollection } from "style/index";
    export interface CreateCellStyleOptions {
        styles: IStyleCollection;
        /**
         * Does not include empty or normal style
         */
        properties: IStyle.Properties | IStyle.Properties[];
        /**
         * Used if clone is called.
         */
        direct: IProperties.ICellRanged<IStyle.Properties>;
        /**
         * A cell style is a specific coords
         */
        range: IRange.Coords;
        /**
         * For updating styles from accessors
         */
        updater: CellStyleUpdater;
    }
    export interface CellStyleUpdater {
        (update: IStyle.Update, options?: IStyle.UpdateOptions, range?: IRange.Coords): IStyle;
    }
    /**
     * This is for cell styles that don't have specific properties per row,column
     */
    export const resolveStyleUpdate: (styles: IStyleCollection, update: IStyle.Update, prev: (() => IStyle) | IStyle) => IStyle.Modifiers;
    class InheritableProperties<P, J> {
        protected _p: readonly Readonly<P>[];
        constructor(properties: Readonly<P> | readonly Readonly<P>[]);
        /**
         *  Use when returning a left value
         * @param key
         * @returns
         */
        value(key: keyof P): any;
        /**
         * Use when wrapping another object that will also inherit.
         */
        values(key: keyof P): any[];
        getProperties(): P;
        toJSON(): J;
    }
    /**
     * This module has implementations of IStyles that are 'pipelined' together.
     */
    /**
     * Subclassed by items that have properties that can be inherited.
     */
    class Inheritable<P, J> {
        protected _o: CreateCellStyleOptions;
        protected _p: readonly P[];
        protected _c: IStyleCollection;
        constructor(options: CreateCellStyleOptions, properties: P[]);
        protected _setValue(key: keyof P, value: any): any;
        /**
         *  Use when returning a left value
         * @param key
         * @returns
         */
        protected _value(key: keyof P): any;
        /**
         * Use when wrapping another object that will also inherit.
         */
        protected _values(key: keyof P): any[];
        getProperties(): P;
        toJSON(): J;
    }
    export class CellBorderStroke extends Inheritable<IBorder.StrokeProperties, IBorder.StrokeJSON> implements IBorder.IStroke {
        protected _edge: IBorder.Edge;
        constructor(edge: IBorder.Edge, options: CreateCellStyleOptions, properties: IBorder.StrokeProperties[]);
        /** {@inheritDoc IBorder.IStroke.getStyle} */
        getStyle(): IBorder.StrokeStyle;
        /** {@inheritDoc IBorder.IStroke.setStyle} */
        setStyle(style: IBorder.StrokeStyle | string | null, options?: IStyle.UpdateOptions): IBorder.IStroke;
        /** {@inheritDoc IBorder.IStroke.getColor} */
        getColor(): IColor;
        /** {@inheritDoc IBorder.IStroke.setColor} */
        setColor(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IBorder.IStroke;
        /** {@inheritDoc IBorder.IStroke.isNone} */
        isNone(): boolean;
        /** {@inheritDoc IBorder.IStroke.toCSS} */
        toCSS(): Partial<CSSStyleDeclaration>;
        get [Symbol.toStringTag](): string;
        toString(): string;
        /** {@inheritDoc IBorder.IStroke.isIStroke} */
        get isIStroke(): true;
    }
    export class CellBorder extends Inheritable<IBorder.Properties, IBorder.JSON> implements IBorder {
        /** {@inheritDoc IBorder.getLeft} */
        getLeft(): IBorder.IStroke;
        /** {@inheritDoc IBorder.setLeft} */
        setLeft(edge: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.Properties> | string | null, options?: IStyle.UpdateOptions): IBorder;
        /** {@inheritDoc IBorder.getRight} */
        getRight(): IBorder.IStroke;
        /** {@inheritDoc IBorder.setLeft} */
        setRight(edge: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.Properties> | string | null, options?: IStyle.UpdateOptions): IBorder;
        /** {@inheritDoc IBorder.getTop} */
        getTop(): IBorder.IStroke;
        /** {@inheritDoc IBorder.setTop} */
        setTop(edge: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.Properties> | string | null, options?: IStyle.UpdateOptions): IBorder;
        /** {@inheritDoc IBorder.IStroke.getBottom} */
        getBottom(): IBorder.IStroke;
        /** {@inheritDoc IBorder.setBottom} */
        setBottom(edge: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.Properties> | string | null, options?: IStyle.UpdateOptions): IBorder;
        /** {@inheritDoc IBorder.IStroke.getDiagonalUp} */
        getDiagonalUp(): IBorder.IStroke;
        /** {@inheritDoc IBorder.setDiagonalUp} */
        setDiagonalUp(edge: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.Properties> | string | null, options?: IStyle.UpdateOptions): IBorder;
        /** {@inheritDoc IBorder.IStroke.getDiagonalDown} */
        getDiagonalDown(): IBorder.IStroke;
        /** {@inheritDoc IBorder.setDiagonalDown} */
        setDiagonalDown(edge: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
        /** {@inheritDoc IBorder.IStroke.isEmpty} */
        isEmpty(): boolean;
        get [Symbol.toStringTag](): string;
        toString(): string;
        /** {@inheritDoc IBorder.IStroke.isIBorder} */
        get isIBorder(): true;
    }
    export class CellAlignment extends Inheritable<ITextFrame.IAlignment.Properties, ITextFrame.IAlignment.JSON> implements ITextFrame.IAlignment {
        /** {@inheritDoc ITextBoxAlignment.getHorizontal} */
        getHorizontal(): ITextFrame.HorizontalAlignment;
        /** {@inheritDoc ITextBoxAlignment.setHorizontal} */
        setHorizontal(horizontal: ITextFrame.HorizontalAlignment | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
        /** {@inheritDoc ITextBoxAlignment.getVertical} */
        getVertical(): ITextFrame.VerticalAlignment;
        /** {@inheritDoc ITextBoxAlignment.setVertical} */
        setVertical(vertical: ITextFrame.VerticalAlignment | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
        /** {@inheritDoc ITextBoxAlignment.getIndent} */
        getIndent(): number;
        /** {@inheritDoc ITextBoxAlignment.setIndent} */
        setIndent(indent: number | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
        /** {@inheritDoc ITextBoxAlignment.getRelativeIndent} */
        getRelativeIndent(): number;
        /** {@inheritDoc ITextBoxAlignment.setRelativeIndent} */
        setRelativeIndent(relativeIndent: number | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
        /** {@inheritDoc ITextBoxAlignment.getOverflow} */
        getOverflow(): ITextFrame.Overflow;
        /** {@inheritDoc ITextBoxAlignment.setOverflow} */
        setOverflow(overflow: ITextFrame.Overflow | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
        /** {@inheritDoc ITextBoxAlignment.getRotation} */
        getRotation(): number;
        /** {@inheritDoc ITextBoxAlignment.setRotation} */
        setRotation(rotation: number | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
        /** {@inheritDoc ITextBoxAlignment.getStacked} */
        getStacked(): boolean;
        /** {@inheritDoc ITextBoxAlignment.setStacked} */
        setStacked(stacked: boolean | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
        /** {@inheritDoc ITextBoxAlignment.getJustifyLastLine} */
        getJustifyLastLine(): boolean;
        /** {@inheritDoc ITextBoxAlignment.setJustifyLastLine} */
        setJustifyLastLine(justifyLastLine: boolean | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
        /** {@inheritDoc ITextBoxAlignment.getReadingDirection} */
        getReadingDirection(): ITextFrame.ReadingDirection;
        /** {@inheritDoc ITextBoxAlignment.setReadingDirection} */
        setReadingDirection(readingDirection: ITextFrame.ReadingDirection | null, options?: IStyle.UpdateOptions): ITextFrame.IAlignment;
        get [Symbol.toStringTag](): string;
        toString(): string;
        /** {@inheritDoc ITextBoxAlignment.isITextBoxAlignment} */
        get isITextBoxAlignment(): true;
    }
    export class CellFont extends Inheritable<IStyledFont.Properties, IStyledFont.JSON> implements IStyledFont {
        /** {@inheritDoc IStyle.isEqualMeasure} */
        isEqualMeasure(other: IStyledFont): boolean;
        /** {@inheritDoc IStyle.toCSS} */
        toCSS(darkMode?: boolean, zoom?: number, ignoreNormal?: boolean): CSSProperties;
        /** {@inheritDoc IStyle.isSuperSub} */
        isSuperSub(): boolean;
        /** {@inheritDoc IStyle.isSuperSub} */
        isSuperScript(): boolean;
        /** {@inheritDoc IStyle.getSuperSubScale} */
        getSuperSubScale(): number;
        /** {@inheritDoc IStyle.getSuperSubShift} */
        getSuperSubShift(): number;
        /** {@inheritDoc IStyle.getFamily} */
        getFamily(): string;
        /** {@inheritDoc IStyle.setFamily} */
        setFamily(family: string | null, options?: IStyle.UpdateOptions): IStyledFont;
        /** {@inheritDoc IStyle.getFallbacks} */
        getFallbacks(): string[];
        /** {@inheritDoc IStyle.setFamily} */
        setFallbacks(fallbacks: string[] | null, options?: IStyle.UpdateOptions): IStyledFont;
        /** {@inheritDoc IStyle.getSize} */
        getSize(): number;
        /** {@inheritDoc IStyle.setSize} */
        setSize(size: number | null, options?: IStyle.UpdateOptions): IStyledFont;
        /** {@inheritDoc IStyle.getWeight} */
        getWeight(): number;
        /** {@inheritDoc IStyle.setWeight} */
        setWeight(weight: number | null, options?: IStyle.UpdateOptions): IStyledFont;
        /** {@inheritDoc IStyle.getStyle} */
        getStyle(): IFont.Style;
        /** {@inheritDoc IStyle.setStyle} */
        setStyle(style: IFont.Style | null, options?: IStyle.UpdateOptions): IStyledFont;
        /** {@inheritDoc IStyle.getFill} */
        getFill(): IColor;
        /** {@inheritDoc IStyle.setFill} */
        setFill(fill: IColor | null, options?: IStyle.UpdateOptions): IStyledFont;
        /** {@inheritDoc IStyle.getLetterSpacing} */
        getLetterSpacing(): number;
        /** {@inheritDoc IStyle.setLetterSpacing} */
        setLetterSpacing(letterSpacing: number | null, options?: IStyle.UpdateOptions): IStyledFont;
        /** {@inheritDoc IStyle.getUnderline} */
        getUnderline(): IFont.UnderlineStyle;
        /** {@inheritDoc IStyle.setUnderline} */
        setUnderline(underline: IFont.UnderlineStyle | null, options?: IStyle.UpdateOptions): IStyledFont;
        /** {@inheritDoc IStyle.getStrike} */
        getStrike(): boolean;
        /** {@inheritDoc IStyle.setStrike} */
        setStrike(strike: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
        /** {@inheritDoc IStyle.getScheme} */
        getScheme(): IFont.Scheme;
        /** {@inheritdoc IStyle.setScheme} */
        setScheme(scheme: IFont.Scheme | null, options?: IStyle.UpdateOptions): IStyledFont;
        /** {@inheritDoc IStyle.getVerticalAlignment} */
        getVerticalAlignment(): IFont.VerticalAlignment;
        /** {@inheritDoc IStyle.setVerticalAlignment} */
        setVerticalAlignment(verticalAlign: IFont.VerticalAlignment | null, options?: IStyle.UpdateOptions): IStyledFont;
        /** {@inheritDoc IStyle.getShadow} */
        getShadow(): boolean;
        /** {@inheritDoc IStyle.setShadow} */
        setShadow(shadow: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
        /** {@inheritDoc IStyle.getOutline} */
        getOutline(): boolean;
        /** {@inheritDoc IStyle.setOutline} */
        setOutline(outline: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
        /** {@inheritDoc IStyle.getExtend} */
        getExtend(): boolean;
        /** {@inheritDoc IStyle.setExtend} */
        setExtend(extend: boolean | null, options?: IStyle.UpdateOptions): IStyledFont;
        get [Symbol.toStringTag](): string;
        /** {@inheritDoc ICellRanges.toString} */
        toString(): string;
        /** {@inheritDoc IStyle.isIStyledFont} */
        get isIStyledFont(): true;
    }
    export class NoneFill extends Inheritable<IFill.NoneProperties, IFill.NoneJSON> implements IFill.INone {
        /** {@inheritDoc IFill.INone.getType} */
        getType(): typeof IFill.Type.None;
        /** {@inheritDoc IFill.INone.toCSS} */
        toCSS(_darkMode?: boolean): CSSProperties;
        /** {@inheritDoc IFill.INone.toJSON} */
        toJSON(): IFill.NoneJSON;
        get [Symbol.toStringTag](): string;
        toString(): string;
        /** {@inheritDoc IFill.isIFill} */
        get isIFill(): true;
    }
    export class SolidFill extends Inheritable<IFill.SolidProperties, IFill.SolidJSON> implements IFill.ISolid {
        /** {@inheritDoc IFill.ISolid.getType} */
        getType(): typeof IFill.Type.Solid;
        /** {@inheritDoc IFill.ISolid.getColor} */
        getColor(): IColor;
        /** {@inheritDoc IFill.ISolid.setColor} */
        setColor(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IFill.ISolid;
        /** {@inheritDoc IFill.ISolid.toCSS} */
        toCSS(darkMode?: boolean): CSSProperties;
        /** {@inheritDoc IFill.ISolid.toJSON} */
        toJSON(): IFill.SolidJSON;
        get [Symbol.toStringTag](): string;
        toString(): string;
        /** {@inheritDoc IFill.isIFill} */
        get isIFill(): true;
    }
    export class GradientStop extends Inheritable<IFill.GradientStopProperties, any> implements IFill.IGradientStop {
        protected _i: number;
        protected _l: number;
        constructor(index: number, length: number, options: CreateCellStyleOptions, properties: IFill.GradientStopProperties[]);
        /** {@inheritDoc IFill.IGradientStop.getOffset} */
        getOffset(): number;
        /** {@inheritDoc IFill.IGradientStop.getColor} */
        getColor(): IColor;
    }
    export class GradientFill extends Inheritable<IFill.GradientProperties, IFill.GradientJSON> implements IFill.IGradient {
        /** {@inheritDoc IFill.IGradient.getType} */
        getType(): typeof IFill.Type.Gradient;
        /** {@inheritDoc IFill.IGradient.getStops} */
        getStops(): IFill.IGradientStop[];
        /** {@inheritDoc IFill.IGradient.setStops} */
        setStops(stops: IFill.IGradientStop[], options?: IStyle.UpdateOptions): IFill.IGradient;
        /** {@inheritDoc IFill.IGradient.getGradientType} */
        getGradientType(): IFill.GradientType;
        /** {@inheritDoc IFill.IGradient.setGradientType} */
        setGradientType(gradientType: IFill.GradientType, options?: IStyle.UpdateOptions): IFill.IGradient;
        /** {@inheritDoc IFill.IGradient.getAngle} */
        getAngle(): number;
        /** {@inheritDoc IFill.IGradient.setAngle} */
        setAngle(angle: number, options?: IStyle.UpdateOptions): IFill.IGradient;
        /** {@inheritDoc IFill.IGradient.getFillTo} */
        getFillTo(): Rectangle;
        /** {@inheritDoc IFill.IGradient.setFillTo} */
        setFillTo(fillTo: Rectangle, options?: IStyle.UpdateOptions): IFill.IGradient;
        /** {@inheritDoc IFill.IGradient.toCSS} */
        toCSS(darkMode?: boolean, bounds?: Bounds): CSSProperties;
        /** {@inheritDoc IFill.IGradient.toJSON} */
        toJSON(): IFill.GradientJSON;
        get [Symbol.toStringTag](): string;
        toString(): string;
        /** {@inheritDoc IFill.isIFill} */
        get isIFill(): true;
    }
    export class PatternFill extends Inheritable<IFill.PatternProperties, IFill.PatternJSON> implements IFill.IPattern {
        /** {@inheritDoc IFill.IPattern.getType} */
        getType(): typeof IFill.Type.Pattern;
        /** {@inheritDoc IFill.IPattern.getBackground} */
        getBackground(): IColor;
        /** {@inheritDoc IFill.ISolid.setBackground} */
        setBackground(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IFill.IPattern;
        /** {@inheritDoc IFill.IPattern.getForeground} */
        getForeground(): IColor;
        /** {@inheritDoc IFill.ISolid.setForeground} */
        setForeground(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IFill.IPattern;
        /** {@inheritDoc IFill.IPattern.getPatternType} */
        getPatternType(): IFill.BuiltInSheetPattern;
        /** {@inheritDoc IFill.IGradient.setPatternType} */
        setPatternType(patternType: IFill.BuiltInSheetPattern, options?: IStyle.UpdateOptions): IFill.IPattern;
        /** {@inheritDoc IFill.IPattern.toCSS} */
        toCSS(darkMode?: boolean): CSSProperties;
        /** {@inheritDoc IFill.IPattern.toJSON} */
        toJSON(): IFill.PatternJSON;
        get [Symbol.toStringTag](): string;
        toString(): string;
        /** {@inheritDoc IFill.isIFill} */
        get isIFill(): true;
    }
    export class SheetCellStyle implements IStyle {
        protected _o: CreateCellStyleOptions;
        protected _p: InheritableProperties<IStyle.Properties, IStyle.JSON>;
        protected _bestFit: Partial<Size>;
        protected _insets: Rectangle;
        protected _hasVisibleStyling: boolean;
        constructor(options: CreateCellStyleOptions);
        /** {@inheritDoc IStyle.toJSON} */
        toJSON(): IStyle.JSON;
        /** {@inheritDoc IStyle.hasVisibleStyling} */
        hasVisibleStyling(): boolean;
        /** {@inheritDoc IStyle.isNormal} */
        isNormal(): boolean;
        /** {@inheritDoc IStyle.createTemporaryStyle} */
        createTemporaryStyle(update: IStyle.Update): IStyle;
        /** {@inheritDoc IStyle.measureText} */
        measureText(text: string, size?: number, family?: string, options?: IFont.MetricOptions): IFont.ExtendedMetrics;
        /** {@inheritDoc IStyle.createTemporaryTextFrame} */
        createTemporaryTextFrame(text: string, allowWrap?: boolean): ITextFrame;
        /** {@inheritDoc IStyle.update} */
        update(update: IStyle.Update, options?: IStyle.UpdateOptions): IStyle;
        /** {@inheritDoc IStyle.getBestFit} */
        getBestFit(): Partial<Size> | null;
        /** {@inheritDoc IStyle.getInsets} */
        getInsets(): Rectangle;
        /** {@inheritDoc IStyle.getBorder} */
        getBorder(): IBorder;
        /** {@inheritDoc IStyle.setBorder} */
        setBorder(border: IBorder.Update, options?: IStyle.UpdateOptions): IStyle;
        /** {@inheritDoc IStyle.getFont} */
        getFont(): IStyledFont;
        /** {@inheritDoc IStyle.setFont} */
        setFont(font: IStyledFont.Update, options?: IStyle.UpdateOptions): IStyle;
        /** {@inheritDoc IStyle.getFill} */
        getFill(): IFill.ISolid | IFill.IGradient | IFill.IPattern | IFill.INone;
        /** {@inheritDoc IStyle.setFill} */
        setFill(fill: IFill.Update, options?: IStyle.UpdateOptions): IStyle;
        /** {@inheritDoc IStyle.getAlignment} */
        getAlignment(): ITextFrame.IAlignment;
        /** {@inheritDoc IStyle.setAlignment} */
        setAlignment(alignment: ITextFrame.IAlignment.Update | string | null, options?: IStyle.UpdateOptions): IStyle;
        /** {@inheritDoc IStyle.getNumberFormat} */
        getNumberFormat(): string;
        /** {@inheritDoc IStyle.setNumberFormat} */
        setNumberFormat(numFmt: string | null, options?: IStyle.UpdateOptions): IStyle;
        /** {@inheritDoc IStyle.getQuotePrefix} */
        getQuotePrefix(): boolean;
        /** {@inheritDoc IStyle.setQuotePrefix} */
        setQuotePrefix(quotePrefix: boolean | null, options?: IStyle.UpdateOptions): IStyle;
        /** {@inheritDoc IStyle.getNamed} */
        getNamed(): IStyle.INamed;
        /** {@inheritDoc IStyle.setNamed} */
        setNamed(named: string | IStyle.INamed | null, options?: IStyle.UpdateOptions): IStyle;
        get [Symbol.toStringTag](): string;
        toString(): string;
        /** {@inheritDoc IStyle.isIStyle} */
        get isIStyle(): true;
    }
    /**
     * Create an `IStyle` using the properties.
     *
     * @remarks
     * Not part of the public interface.
     */
    export const createCellStyle: (styles: IStyleCollection, layer: IProperties.ICellRanged<IStyle.Properties>, range?: Readonly<IRange.Coords>, updater?: CellStyleUpdater) => IStyle;
    export class EmptyStyle extends SheetCellStyle {
        /** {@inheritDoc IStyle.hasVisibleStyling} */
        hasVisibleStyling(): boolean;
    }
    export class NormalStyle extends SheetCellStyle {
        /** {@inheritDoc IStyle.isNormal} */
        isNormal(): boolean;
    }
    export const ReadOnlyUpdater: (update: IStyle.Update) => IStyle;
}
declare module "sheet/spatial/MergeEntry" {
    import { Scalar, IRange } from '@sheetxl/primitives';
    /**
     * MergeEntry
     */
    export class MergeEntry {
        private _c;
        private _tvTl;
        constructor(coords: IRange.Coords, tvTl?: (coords: IRange.Coords) => Scalar | null);
        /**
         * The cell value at the top left.
         * We track this because we want a quick way to access
         * the coords state during overflow scenarios.
         */
        tvTl(): Scalar | null;
        getCoords(): IRange.Coords;
    }
}
declare module "sheet/spatial/UnlockEntry" {
    import { IRange } from '@sheetxl/primitives';
    import { ISpatialMap } from "collections/ISpatialMap";
    export class UnlockEntry {
        private _c;
        constructor(coords: IRange.Coords);
        getCoords(): IRange.Coords;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getShifted} */
        getShifted(options: ISpatialMap.ShiftDetails<this>): ISpatialMap.Entry<this>;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getMerged} */
        getMerged(_other: this, coords: IRange.Coords, _orientation: IRange.Orientation): this | undefined;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getSplit} */
        getSplit(coords: [IRange.Coords, IRange.Coords], _orientation: IRange.Orientation): [this, this] | undefined;
    }
}
declare module "calculation/_CalculationUtils" {
    import { IRange, FormulaError } from '@sheetxl/primitives';
    import { ICalculation } from "calculation/ICalculation";
    export const tokensToR1C1: (tokens: ICalculation.FormulaToken[]) => string;
    export const tokensToA1: (tokens: ICalculation.FormulaToken[], rowIndex?: number, colIndex?: number) => string;
    export const tokensToPosition: (tokens: ICalculation.FormulaToken[], rowIndex?: number, colIndex?: number) => ICalculation.FormulaToken[];
    export const referencesToPosition: (references: readonly (IRange.FixableCoords | string | FormulaError.Known)[], rowIndex?: number, colIndex?: number) => (IRange.FixableCoords | string | FormulaError.Known)[];
    /**
     * Returns all tokens that are part of an evaluation.
     *
     * @param tokens The tokens to filter.
     * @param evalIndex The evaluation index to filter by.
     *
     * @remarks
     * Includes whitespace within but not surrounding the evaluation.
     */
    export const filterEvalTokens: (tokens: ICalculation.FormulaToken[], evalIndex?: number) => ICalculation.FormulaToken[];
}
declare module "sheet/spatial/FormulaEntry" {
    import { IRange, FormulaError } from '@sheetxl/primitives';
    import { ICalculation } from "calculation/index";
    /**
     * Used by Sheet to track formula strings (but not the calculation results)
     */
    export class FormulaEntry {
        private _c;
        private _tokens;
        private _references;
        constructor(coords: IRange.Coords, tokens?: ICalculation.FormulaToken[], references?: readonly (IRange.FixableCoords | string | FormulaError.Known)[]);
        getFormulaTextAt(row: number, column: number, r1c1?: boolean): string;
        getTokensAt(row: number, column: number, evalIndex?: number): readonly ICalculation.FormulaToken[];
        getReferencesAt(row: number, column: number): readonly (IRange.FixableCoords | string | FormulaError.Known)[];
        toJSON(): [string, string];
        getCoords(): IRange.Coords;
    }
}
declare module "sheet/spatial/index" {
    export * from "sheet/spatial/MergeEntry";
    export * from "sheet/spatial/UnlockEntry";
    export * from "sheet/spatial/FormulaEntry";
}
declare module "calculation/spatial/SpillEntry" {
    import { IRange } from '@sheetxl/primitives';
    import { ISpatialMap } from "collections/ISpatialMap";
    /**
     * Spill Entries are used to track spills.
     * There are two types of spills:
     * * Spill complete sets the input values during a calculation cycle.
     * * Spill errors can occur for 2 reasons.
     * *  a. a direct input from api.
     * *  b. a spill during a calculation cycle.
     */
    export class SpillEntry {
        private _c;
        private _e;
        private _cycleId;
        constructor(coords: IRange.Coords, cycleId: number, error?: boolean);
        getCycleId(): number;
        getError(): boolean;
        getCoords(): IRange.Coords;
        setError(error: boolean, cycleId: number): ISpatialMap.Entry<this>;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getShifted} */
        getShifted(options: ISpatialMap.ShiftDetails<this>): ISpatialMap.Entry<this>;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getMerged} */
        getMerged(_other: this, coords: IRange.Coords, _orientation: IRange.Orientation): this | undefined;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getSplit} */
        getSplit(coords: [IRange.Coords, IRange.Coords], _orientation: IRange.Orientation): [this, this] | undefined;
    }
}
declare module "calculation/spatial/ContentfulEntry" {
    import { Scalar, IRange } from '@sheetxl/primitives';
    import { ISpatialMap, Tuple } from "collections/index";
    /**
     * Used for identifying contiguously filled ranges.
     */
    export class ContentfulEntry {
        private _c;
        private _o;
        constructor(coords: IRange.Coords, orientation: IRange.Orientation);
        getCoords(): IRange.Coords;
        getOrientation(): IRange.Orientation;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getShifted} */
        getShifted(options: ISpatialMap.ShiftDetails<this>): ISpatialMap.Entry<this>;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getMerged} */
        getMerged(_other: this, coords: IRange.Coords, _orientation: IRange.Orientation): this;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getSplit} */
        getSplit(coords: [IRange.Coords, IRange.Coords], _orientation: IRange.Orientation): [this, this] | undefined;
        getState(): IRange.Coords;
    }
    /**
     * Wraps each value in a ContentfulEntry
     */
    export const tuplesToContentfulEntries2: (gridTuples: Tuple.GridTuple<Scalar>, isColumn: boolean) => ISpatialMap.Entry<ContentfulEntry>[];
    export const rangeToContentfulEntries: (entries: readonly ISpatialMap.Entry[], isColumn: boolean) => ISpatialMap.Entry<ContentfulEntry>[];
}
declare module "calculation/graph/CalcState" {
    import { IRange, FormulaError } from '@sheetxl/primitives';
    import { FormulaBlockEntry } from "calculation/spatial/FormulaBlockEntry";
    export const CalcState: {
        /**
         * The default state.
         */
        readonly Active: 0;
        /**
         * Causing a recalc due to a dynamic dependency. This is either a
         * dynamic precedent or a spill output.
         */
        readonly Skip: 1;
        readonly Removed: 2;
        /**
         * The calc node is pending and waiting for a precedent to resolve.
         * This is used to indicate that the user has been given a pending status.
         */
        readonly Pending: 3;
        /**
         * The calc node is pending and waiting for a precedent to resolve.
         * This is used for dynamic dependencies that are not yet resolved.
         */
        readonly PendingPrecedents: 4;
        /**
         * The calc node is pending and waiting for a precedent to resolve.
         * This is used for dynamic dependencies that are not yet resolved.
         */
        readonly PendingResolved: 5;
    };
    /**
     * We resolve precedents in the mark phase but need use them
     * in the eval phase too so we cache these on the Calc node.
     */
    export interface PrecedentCalcCache extends IRange.Coords {
        calc: CalcNode | undefined;
    }
    export interface CalcNode {
        block: FormulaBlockEntry;
        colIndex: number;
        rowIndex: number;
        cycleId: number;
        markId: number;
        inDegree: number;
        dependents: any[];
        inputs: any[];
        precedents: (PrecedentCalcCache | FormulaError.Known)[];
        dynamic: any[];
        cachedValue: any;
        removed: boolean;
        /**
         * Indicates if the pending is in the pending spatial (to avoid lookup)
         */
        pending: boolean;
        /**
         * Indicates the pending is waiting on a precedent to resolve.
         */
        pendingPrecedents: boolean;
        /**
         * Indicates the pending is full filled and waiting for the next cycle to resolve.
         */
        pendingResolved: boolean;
        pendingPromise: Promise<any> | null;
        /**
         * The state is a bit mask with transient states.
         * The CalcNode is reused across cycles and cloned records for performance.
         * To ensure that it is correct the cycleId id must be consulted.
         */
        state: number;
        error: FormulaError.Known;
    }
}
declare module "calculation/spatial/FormulaBlockEntry" {
    import { IRange } from '@sheetxl/primitives';
    import { ISpatialMap } from "collections/ISpatialMap";
    import { ICalcGraph } from "calculation/graph/ICalcGraph";
    import { CalcNode } from "calculation/graph/CalcState";
    export class FormulaBlockEntry implements ISpatialMap.IUpdatableEntry<FormulaBlockEntry> {
        ref: IRange.Coords;
        formula: ICalcGraph.IFormulaBlock;
        calcs: CalcNode[][];
        /**
         * If a calcs is provided it is assumed to be shallow cloned or ok to modify
         */
        constructor(coords: IRange.Coords, formula: ICalcGraph.IFormulaBlock, calcs?: CalcNode[][]);
        toJSON(): [coords: string, text: string];
        getCoords(): IRange.Coords;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getShifted} */
        getShifted(options: ISpatialMap.ShiftDetails<this>): ISpatialMap.Entry<this>;
        /**
         * Creates a new calculation entry with once precedent updated.
         * @param precedent
         * @param index
         */
        setReferenceAt(index: number, reference: IRange.FixableCoords): this;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getMerged} */
        getMerged(other: this, coords: IRange.Coords, orientation: IRange.Orientation): this | undefined;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getSplit} */
        getSplit(coords: [IRange.Coords, IRange.Coords], orientation: IRange.Orientation, offset: number): [this, this] | undefined;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.copyTo} */
        copyTo(destination: IRange.Coords, options?: ISpatialMap.CopyOptions): this;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.canTile} */
        canTile(_destination: IRange.Coords, _options?: ISpatialMap.CopyOptions): boolean;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getSplit} */
        onRemove?(entry: ISpatialMap.Entry<FormulaBlockEntry>): void;
    }
}
declare module "calculation/spatial/PrecedentEntry" {
    import { ISpatialMap } from "collections/ISpatialMap";
    import { CalcNode } from "calculation/graph/CalcState";
    import { FormulaBlockEntry } from "calculation/spatial/FormulaBlockEntry";
    export class PrecedentEntry {
        blockEntry: ISpatialMap.Entry<FormulaBlockEntry>;
        /**
         * This is the shape of the dependency entry. For inputs with ranges this will be greater than 1
         */
        width: number;
        height: number;
        /**
         * Indicate the precedent index. Used for finding input in the calc entry.
         * `-1` for dynamic dependencies.
         */
        index: number;
        /**
         * When a precedent has a cell address in a direction that is absolute. The entire
         * address is considered absolute in that direction. We must calc all nodes in that range
         */
        $absWidth: boolean;
        $absHeight: boolean;
        /**
         * For dynamic dependencies we use the calc node directly but we
         * still need to reference the calcEntry to determine if the range
         * has been removed
         */
        once?: CalcNode;
    }
}
declare module "calculation/spatial/index" {
    export * from "calculation/spatial/SpillEntry";
    export * from "calculation/spatial/ContentfulEntry";
    export * from "calculation/spatial/FormulaBlockEntry";
    export * from "calculation/spatial/PrecedentEntry";
}
declare module "sheet/_SheetTypes" {
    import { ScalarType, Scalar, IRange } from '@sheetxl/primitives';
    import type { Size, Rectangle } from '@sheetxl/utils';
    import { IProperties } from "type/index";
    import { NumberFormat } from "numFmt/index";
    import type { ITextFrame } from "text/index";
    import type { ITable } from "table/index";
    import type { IComment } from "comment/index";
    import type { IHyperlink } from "hyperlink/index";
    import type { IStyle } from "style/index";
    import type { ICellRange } from "cellRange/index";
    import type { OverlappingRange } from "collections/index";
    import type { FormulaEntry, MergeEntry, UnlockEntry } from "sheet/spatial/index";
    import type { SpillEntry, ContentfulEntry } from "calculation/spatial/index";
    import type { ConditionalEntry } from "conditional/ConditionalEntry";
    /**
     * This is a set of calculated values based on the Style and a Scalar.
     * All properties are single characters to minimize memory usage.
     * @internal
     */
    export interface ScalarStyleCache {
        /**
         * Style.
         * If this updates then all items in the cache are invalid.
         * Used to quickly invalid all of the styled cache values
         * @cacheValue
         */
        /**
         * The type of value.
         * @cacheValue
         * @remarks
         * In a javascript engine this can be inferred from the value and is derived.
         */
        /**
         * ParsedNumberFormat
         * Cached formatting details. This contains conditional number formatting details.
         * TODO - rationalized with textFrame?
         * @cacheValue
         */
        p?: NumberFormat.Parsed;
        /**
         * TextField
         * Similar to formatted value. Contains rich text and wrapping logic.
         * TODO - rationalized with formattedValue?
         * @cacheValue
         */
        t?: ITextFrame;
        /**
         * Insets
         * Similar to formatted value. Contains rich text and wrapping logic.
         * TODO - rationalized with formattedValue?
         * @cacheValue
         */
        i?: Readonly<Rectangle>;
        o?: Readonly<Partial<Size>> | null;
        w?: readonly string[] | null;
        B?: any;
        b?: any;
    }
    export const BREAK_TRUE: Readonly<{
        break: true;
    }>;
    export type WellKnownIterator<T, TReturn = any, TNext = undefined> = Iterator<T, TReturn, TNext>;
    export type WellKnownIteratorResult<T, TReturn = any> = IteratorResult<T, TReturn>;
    export namespace CellState {
        /**
         * The raw values values without any cached details.
         * This needs to be further decomposed into just 'data value' that is { value: number, type: string }
         * @internal
         */
        interface TypeAndValue {
            /**
             * The value of the CellState.
             */
            v: Scalar;
            /**
             * The type of value.
             */
            t: ScalarType;
        }
        /**
         * Entries iterators are arrays of fixed length 5.
         */
        type Entry = [
            coords: IRange.CellCoords,
            v: Scalar,
            rs: RangeState.Intersection,
            prev: IRange.CellCoords,
            next: IRange.CellCoords
        ];
        /**
         * Shorthand type.
         */
        type IteratorResult = WellKnownIteratorResult<CellState.Entry>;
        /**
         * Shorthand type.
         */
        type Iterator = WellKnownIterator<CellState.Entry, CellState.Entry, IRange.CellCoords>;
        /**
         * To reduce the number of objects we just extend ICellRange.IteratorOptions with new properties.
         * This will make a number of them redundant.
         *
         * @internal
         */
        interface IteratorOptions extends Omit<ICellRange.IteratorOptions, 'address'> {
            /**
             * When scanning for values includes ranges.
             * If `true` than will include all, `false` will include none but still honor hidden headers
             *
             * @remarks
             * If a string array is provided than this will only query those types of ranges.
             * @defaultValue false
             */
            includeRangeTypes?: boolean | RangeState.SearchTypes;
            /**
             * parsed address
             */
            bounds?: IRange.Coords;
            /**
             * If `true` then empty values will be ignored.
             *
             * @defaultValue false
             *
             * @remarks
             * This is used when iterating a cell values but that need intersection details
             * but we don't want to iterative non valued intersections.
             */
            ignoreEmptyIntersections?: boolean;
        }
    }
    export namespace RangeState {
        /**
         * The boolean is used to indicate if the search result must full contained to return
         */
        type SearchTypes = Partial<Record<RangeState.Type, boolean>>;
        interface IteratorOptions extends OverlappingRange.IteratorOptions {
            includeRangeTypes: boolean | SearchTypes;
            bounds?: IRange.Coords;
            ignoreHidden?: boolean | IRange.Orientation;
            includeMergeOverflow?: boolean;
        }
        interface Entry {
            /**
             * If byCell. Else null
             */
            cell: IRange.CellCoords;
            /**
             * The cell that starts the range.
             */
            start: IRange.CellCoords;
            /**
             * The cell that ends the range.
             */
            end: IRange.CellCoords;
            /**
             * The CellState.Ranged. We could also make this a lazy function
             */
            intersection: RangeState.Intersection;
        }
        /**
       * Shorthand type.
       */
        type IteratorResult = WellKnownIteratorResult<RangeState.Entry>;
        /**
         * Shorthand type.
         */
        type Iterator = WellKnownIterator<RangeState.Entry, RangeState.Entry, IRange.Coords>;
        /**
         * Dynamic state. These are values associated to a range of cells that
         * get realized at time of cell iterator.
         *
         * @internal
         */
        interface Intersection {
            /**
             * The merge state.
             */
            merge?: MergeEntry;
            /**
             * A table that this cell belongs to.
             */
            table?: ITable;
            /**
             * Conditional styles.
             *
             * @remarks
             * Overlaps are allowed
             */
            conditionals?: ConditionalEntry[];
            /**
             * The style for a collection of cells.
             *
             * @remarks
             * This is the style set by the user.
             */
            directStyle?: IProperties.ICellRanged<IStyle.Properties>;
            /**
             * The hyperlink.
             */
            hyperlink?: IHyperlink.Properties;
            /**
             * Directives for unlocking a range. (Only applies if the sheet is protected).
             *
             * @remarks
             * Overlaps are allowed
             */
            unlock?: UnlockEntry[];
            /**
             * Range contentful ranges.
             *
             * @remarks
             * Used for selectRegion merge contentful checks and other aggregation counting.
             * We are going to expand this for all of the aggregation counting.
             */
            contentful?: ContentfulEntry;
            /**
             * Styles that have a continuous alignment.
             *
             * @remarks
             * * These are just copies of directStyle for fast lookup.
             * * A continuous alignment is an alignment that spans multiple horizontal cells.
             */
            continuous?: IProperties.ICellRanged<IStyle.Properties>;
            /**
             * The comments.
             *
             * @remarks
             * A block of comments for the range.
             */
            comments?: IComment.JSON;
            /**
             * A block of R1C1 formulas.
             */
            formula?: FormulaEntry;
            /**
             * Spills.
             *
             * @remarks
             * There can be multiple spills on a cell but only one will be valid.
             */
            spills?: SpillEntry[];
            /**
             * Pending calcs.
             */
            pending?: boolean;
            /**
             * Errors during calculation.
             */
            calcError?: string;
            /**
             * Non overlapping data validation entries.
             */
            dataValidation?: any;
            /**
             * Overlapping named ranges.
             */
            namedRange?: any[];
        }
        /**
         * Range types are stored with a sheet range.
         * @internal
         */
        const Type: {
            readonly Style: "style";
            readonly Continuous: "continuous";
            readonly Table: "table";
            readonly Merge: "merge";
            readonly Hyperlink: "hyperlink";
            readonly Comments: "comments";
            readonly Unlock: "unlock";
            readonly Contentful: "contentful";
            readonly Conditional: "conditional";
            /**
             * Has a formula
             */
            readonly Formula: "formula";
            readonly Spill: "spill";
            readonly Pending: "pending";
            readonly CalcError: "calcError";
            readonly Validation: "dataValidation";
        };
        type Type = typeof Type[keyof typeof Type];
    }
    export const AllRangeTypes: RangeState.SearchTypes;
    export const CellStateRangeTypes: RangeState.SearchTypes;
    /**
     * We don't want to copy TextOverflows.
     * TODO - create a more generalize Type (Eager vs on demand.)
     * @internal
     */
    export const CopyRangeTypes: RangeState.SearchTypes;
    /**
     * Used by merge redirect lookup.
     * @internal
     */
    export const NoMergeRangeTypes: RangeState.SearchTypes;
    /**
     * Used by overlaps lookup
     * @internal
     */
    export const OverflowsRangeTypes: RangeState.SearchTypes;
}
declare module "sheet/listener/RangesListenerEntry" {
    import { IRange } from '@sheetxl/primitives';
    import { ISpatialMap } from "collections/ISpatialMap";
    export class RangesListenerEntry implements ISpatialMap.IUpdatableEntry<RangesListenerEntry> {
        uuid: string;
        groupId: string;
        noShift: boolean;
        constructor(groupId: string, uuid: string, noShift: boolean);
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.onRemove} */
        onRemove(options: IRange.Coords): void;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getShifted} */
        getShifted(options: ISpatialMap.ShiftDetails<this>): ISpatialMap.Entry<this>;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getSplit} */
        getSplit(_coords: [IRange.Coords, IRange.Coords], _orientation: IRange.Orientation): [this, this] | undefined;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.copyTo} */
        copyTo(_destination: IRange.Coords, _options?: ISpatialMap.CopyOptions): this;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.canTile} */
        canTile(_destination: IRange.Coords, _options?: ISpatialMap.CopyOptions): boolean;
    }
}
declare module "sheet/listener/RangesListener" {
    import { ICellRanges, ICellRange } from "cellRange/index";
    import { IListener } from "listener/index";
    import { ISpatialMap } from "collections/ISpatialMap";
    import { RangesListenerEntry } from "sheet/listener/RangesListenerEntry";
    import { ISheet } from "sheet/index";
    interface NotifierOptions {
        isTransactional?: boolean;
        timeStamp?: number;
        trigger?: string;
    }
    export class RangesListener {
        coords: ICellRanges.Coords | null;
        isRanges: boolean;
        spatialsIds: string[];
        uuid: string;
        sheet: ISheet;
        generation: number;
        handler: ICellRange.Listener;
        handlerW: WeakRef<ICellRange.Listener>;
        removeListener: IListener.Remove;
        options: ICellRange.ListenerOptions;
        constructor(uuid: string, spatialsIds: string[], coords: ICellRanges.Coords | null, isRanges: boolean, sheet: ISheet, generation: number, handler: ICellRange.Listener, handlerW: WeakRef<ICellRange.Listener>, removeListener: IListener.Remove, options: ICellRange.ListenerOptions);
        delete(): void;
        createRangeEvent(options: NotifierOptions, customError?: string): ICellRange.Event;
        notify(options: NotifierOptions, customError?: string): void;
        processRemove(entry: ISpatialMap.Entry<RangesListenerEntry>): RangesListener;
        processShift(entry: ISpatialMap.Entry<RangesListenerEntry>): RangesListener;
        processSplit(_entries: ISpatialMap.Entry<RangesListenerEntry>[]): RangesListener;
        processMerge(_entries: ISpatialMap.Entry<RangesListenerEntry>[]): RangesListener;
    }
}
declare module "sheet/listener/index" {
    export * from "sheet/listener/RangesListenerEntry";
    export * from "sheet/listener/RangesListener";
}
declare module "sheet/view/SheetView" {
    import { TopLeft } from '@sheetxl/utils';
    import { IListener } from "listener/index";
    import { IColor } from "color/index";
    import { IMovable, IMovableSelection } from "movable/index";
    import { IRangeSelection } from "selection/index";
    import { ISheet } from "sheet/ISheet";
    import { ISheetView } from "sheet/view/ISheetView";
    import { ListenerEmitter } from "listener/ListenerEmitter";
    /**
     * Default Sheet View
     */
    export class SheetView implements ISheetView, IMovableSelection {
        protected _state: Partial<ISheetView.Properties>;
        protected _sheet: ISheet;
        protected _emitter: ListenerEmitter<ISheetView, ISheetView.IListeners>;
        protected _movableSelection: readonly IMovable[];
        constructor(options: ISheetView.ConstructorOptions);
        /** {@inheritDoc ISheetView.addListeners} */
        addListeners(listeners: ISheetView.IListeners, options?: IListener.Options): IListener.Remove;
        /** {@inheritDoc ISheetView.setTopLeft} */
        setTopLeft(topLeft: Partial<TopLeft>): this;
        /** {@inheritDoc ISheetView.getTopLeft} */
        getTopLeft(): Partial<TopLeft>;
        /** {@inheritDoc ISheetView.getFreezePanes} */
        getFreezePanes(): ISheetView.FreezePanes;
        /** {@inheritDoc ISheetView.setFreezePanes} */
        setFreezePanes(freezePanes: Partial<ISheetView.FreezePanes> | null): this;
        protected _mergeFreezePanes(freezePanes: Partial<ISheetView.FreezePanes>): Partial<ISheetView.FreezePanes>;
        /** {@inheritDoc ISheetView.isShowRowHeaders} */
        isShowRowHeaders(): boolean;
        /** {@inheritDoc ISheetView.setShowRowHeaders} */
        setShowRowHeaders(newValue: boolean): this;
        /** {@inheritDoc ISheetView.isShowColumnHeaders} */
        isShowColumnHeaders(): boolean;
        /** {@inheritDoc ISheetView.setShowColumnHeaders} */
        setShowColumnHeaders(newValue: boolean): this;
        /** {@inheritDoc ISheetView.isShowRowGridlines} */
        isShowRowGridlines(): boolean;
        /** {@inheritDoc ISheetView.setShowRowGridlines} */
        setShowRowGridlines(newValue: boolean): this;
        /** {@inheritDoc ISheetView.isShowColumnGridlines} */
        isShowColumnGridlines(): boolean;
        /** {@inheritDoc ISheetView.setShowColumnGridlines} */
        setShowColumnGridlines(newValue: boolean): this;
        /** {@inheritDoc ISheetView.getRowHeaderStyle} */
        getRowHeaderStyle(): ISheetView.HeaderTextStyle;
        /** {@inheritDoc ISheetView.setRowHeaderStyle} */
        setRowHeaderStyle(newValue: ISheetView.HeaderTextStyle): this;
        /** {@inheritDoc ISheetView.getColumnHeaderStyle} */
        getColumnHeaderStyle(): ISheetView.HeaderTextStyle;
        /** {@inheritDoc ISheetView.setColumnHeaderStyle} */
        setColumnHeaderStyle(newValue: ISheetView.HeaderTextStyle): this;
        /** {@inheritDoc ISheetView.getZoomScale} */
        getZoomScale(): number;
        /** {@inheritDoc ISheetView.setZoomScale} */
        setZoomScale(newValue: number): this;
        /** {@inheritDoc ISheetView.isShowFormulas} */
        isShowFormulas(): boolean;
        /** {@inheritDoc ISheetView.setShowFormulas} */
        setShowFormulas(newValue: boolean): this;
        /** {@inheritDoc ISheetView.isShowZeros} */
        isShowZeros(): boolean;
        /** {@inheritDoc ISheetView.setShowZeros} */
        setShowZeros(newValue: boolean): this;
        /** {@inheritDoc ISheetView.getGridLineColor} */
        getGridLineColor(): any;
        /** {@inheritDoc ISheetView.setGridLineColor} */
        setGridLineColor(newValue: IColor | null): this;
        /** {@inheritDoc ISheetView.setSelection} */
        setRangeSelection(selection: IRangeSelection.Coords): this;
        /** {@inheritDoc ISheetView.getSelection} */
        getRangeSelection(): import("@sheetxl/utils").SelectionCoords;
        /** {@inheritDoc ISheetView.getMovableSelection} */
        getMovableSelection(): readonly IMovable[];
        /** {@inheritDoc ISheetView.setMovableSelection} */
        setMovableSelection(newValue: readonly IMovable[] | null): this;
        /** {@inheritDoc IMovableSelection.selectMovables} */
        selectMovables(movables: readonly IMovable[], addToSelection?: boolean): this;
        /** {@inheritDoc IMovableSelection.unselectMovables} */
        unselectMovables(movables: IMovable[]): this;
        protected _notifyAll(): void;
        /** {@inheritDoc ISheetView.toJSON} */
        toJSON(): ISheetView.JSON | null;
        protected _fromJSON(json: ISheetView.JSON): void;
        /** {@inheritDoc ISheetView.clear} */
        clear(notify?: boolean): this;
        /** {@inheritDoc ISheetView.update} */
        update(properties: ISheetView.Properties): this;
        /** {@inheritDoc ISheetView.isISheetView} */
        get isISheetView(): true;
    }
}
declare module "sheet/protection/SheetProtection" {
    import { DefaultProtection } from "protection/DefaultProtection";
    import { ISheetProtection } from "sheet/protection/ISheetProtection";
    export class SheetProtection extends DefaultProtection<ISheetProtection, ISheetProtection.Properties, ISheetProtection.JSON> implements ISheetProtection {
        /** {@inheritDoc ISheetProtection.isAutoFilterAllowed} */
        isAutoFilterAllowed(): boolean;
        /** {@inheritDoc ISheetProtection.isDeleteColumnsAllowed} */
        isDeleteColumnsAllowed(): boolean;
        /** {@inheritDoc ISheetProtection.isDeleteRowsAllowed} */
        isDeleteRowsAllowed(): boolean;
        /** {@inheritDoc ISheetProtection.isFormatCellsAllowed} */
        isFormatCellsAllowed(): boolean;
        /** {@inheritDoc ISheetProtection.isFormatColumnsAllowed} */
        isFormatColumnsAllowed(): boolean;
        /** {@inheritDoc ISheetProtection.isFormatRowsAllowed} */
        isFormatRowsAllowed(): boolean;
        /** {@inheritDoc ISheetProtection.isInsertColumnsAllowed} */
        isInsertColumnsAllowed(): boolean;
        /** {@inheritDoc ISheetProtection.isInsertHyperlinksAllowed} */
        isInsertHyperlinksAllowed(): boolean;
        /** {@inheritDoc ISheetProtection.isInsertRowsAllowed} */
        isInsertRowsAllowed(): boolean;
        /** {@inheritDoc ISheetProtection.isObjectsAllowed} */
        isObjectsAllowed(): boolean;
        /** {@inheritDoc ISheetProtection.isPivotTablesAllowed} */
        isPivotTablesAllowed(): boolean;
        /** {@inheritDoc ISheetProtection.isScenariosAllowed} */
        isScenariosAllowed(): boolean;
        /** {@inheritDoc ISheetProtection.isSortAllowed} */
        isSortAllowed(): boolean;
        isSelectLockedCellsAllowed(): boolean;
        isSelectUnlockedCellsAllowed(): boolean;
        protected _updateProperties(properties: ISheetProtection.Properties | null): void;
        protected _clearProperties(): void;
        protected _fromJSON(json: ISheetProtection.JSON | null): void;
        protected _toJSON(json: ISheetProtection.JSON): ISheetProtection.JSON;
        get [Symbol.toStringTag](): string;
        toString(): string;
    }
}
declare module "hyperlink/_HyperlinkMessages" {
    export const ERROR_INVALID_HYPERLINK = "Invalid hyperlink";
}
declare module "hyperlink/_Hyperlink" {
    import { ITypes } from "type/index";
    import { IHyperlink } from "hyperlink/IHyperlink";
    export class Hyperlink implements IHyperlink {
        protected _t: () => string;
        protected _p: IHyperlink.Properties;
        protected _r: (address: string, options: ITypes.SelectOptions, target: string, features: string) => Promise<boolean>;
        constructor(textToDisplay: () => string, resolver: (address: string, options: ITypes.SelectOptions, target: string, features: string) => Promise<boolean>, json: IHyperlink.JSON);
        /** {@inheritDoc IHyperlink.open} */
        open(target?: '_self' | '_blank', features?: string): Promise<boolean>;
        /** {@inheritDoc IHyperlink.getTarget} */
        getTarget(): string;
        /** {@inheritDoc IHyperlink.getDisplayText} */
        getDisplayText(): string;
        /** {@inheritDoc IHyperlink.getAddress} */
        getAddress(): string;
        /** {@inheritDoc IHyperlink.getTooltip} */
        getTooltip(): string;
        /** {@inheritDoc IHyperlink.isIHyperlink} */
        get isIHyperlink(): true;
    }
}
declare module "numFmt/_FormatCell" {
    import { ScalarType, Scalar } from '@sheetxl/primitives';
    import { IColor } from "color/index";
    import { IStyle } from "style/index";
    import { Parsed } from "numFmt/NumberFormatParser";
    export interface UnformattedTextOptions {
        date1904: boolean;
    }
    export const parseNumberFormat: (value: Scalar, style: IStyle, type: ScalarType, numberFormat: string, parseColor: (val: any) => IColor, date1904?: boolean) => Parsed;
    /**
     * Note - Even in the case of unformatted text we do a 'minimum' amount. For example we convert dates and percentages
     */
    export const unformattedTextFromCell: (value: Scalar, type: ScalarType, numberFormat: string, options: UnformattedTextOptions) => string;
}
declare module "sheet/SheetCell" {
    import { Scalar, ScalarType, IRange, FormulaError } from '@sheetxl/primitives';
    import { type Size, type Rectangle } from '@sheetxl/utils';
    import { IProperties, ITypes } from "type/index";
    import { NumberFormat } from "numFmt/index";
    import { ITextFrame } from "text/index";
    import { IAutoFilter } from "filter/index";
    import { IHyperlink } from "hyperlink/index";
    import { ICalculation } from "calculation/index";
    import { IComment } from "comment/index";
    import { IStyle, IStyleCollection } from "style/index";
    import { ICell, ICellProtection } from "cell/index";
    import { ICellRange } from "cellRange/index";
    import { ISheetProtection } from "sheet/protection/index";
    import { ISheetHeader } from "sheet/header/index";
    import { ISheet } from "sheet/ISheet";
    import { RangeState } from "sheet/_SheetTypes";
    import { FormulaEntry } from "sheet/spatial/index";
    import { CellStyleUpdater } from "sheet/style/SheetCellStyle";
    import { ICalcGraph } from "calculation/graph/index";
    /**
     * CellModifiers with all functions removed and all properties set and a type.
     */
    export interface ResolvedCellModifiers {
        type: ScalarType;
        value: Scalar | null;
        style: IStyle.Update | null;
        hyperlink: IHyperlink | null;
        formula: string | null;
        stringToParse: string | null;
    }
    interface Cache<K, V> {
        set(key: K, value: V): void;
        get(key: K): V;
    }
    /**
     * Converts a `ICell.Update` into a `ResolvedCellModifiers` with no functions.
     *
     * * Returns a reusable object.
     * * Will never return null.
     *
     * This resolves various update rules for cells.
     * Note that this doesn't take a tv because it does a full replacement.
     *
     * If fromString is null then then strings will be processed without any
     * special conditioning and this will be returned.
     *
     * // TODO - reuse ResolvedCellModifiers for createCellModifiersFromString.
     * // TODO - remove style dependency and see if we can remove it.
     */
    export const resolveCellModifiers: (update: ICell.Update, options: SheetCellOptions, optionsFromString?: ICell.ModifiersFromStringOptions, resolvedStringCache?: Map<string, ICell.Modifiers>, // assumes the same fromStringOptions is used
    isParsingCustom?: boolean) => ResolvedCellModifiers;
    export const csOverflowable: (type: ScalarType, style: IStyle, prev?: boolean, next?: boolean) => boolean;
    /**
     * Updates the overflow calc and returns a range if overflowed
     * @internal
     */
    export const calcTextOverflow: (rowIndex: number, colIndex: number, type: ScalarType, style: IStyle, value: Scalar, prev: IRange.CellCoords, next: IRange.CellCoords, continuousCoords: IRange.Coords, cellOptions: SheetCellOptions) => ICell.HorizontalOverflow | null;
    /** Guaranteed to never return null */
    export const csStyle: (specific: boolean, range: IRange.Coords, intersection: RangeState.Intersection, options: SheetCellOptions) => IStyle;
    export const csBestFit: (type: ScalarType, style: IStyle, value: Scalar, options: SheetCellOptions, colWidth: number, isMinContent: boolean, isRowOnly: boolean, // if true we only measure the height
    customHash?: string, cache?: Cache<string, Readonly<Partial<Size>>>) => Readonly<Partial<Size>>;
    export interface SheetCellOptions {
        resolveRange: (address?: ICellRange.Address) => ICellRange | null;
        sheet: ISheet;
        date1904: boolean;
        styles: IStyleCollection;
        normalStyleRanged: IProperties.ICellRanged<IStyle.Properties>;
        nextContentful(cell: IRange.CellCoords, limit: number, isLeft?: boolean): number;
        maxCoords: IRange.Coords;
        getProtection(): ISheetProtection;
        calcGraph(): ICalcGraph;
        colHeaders: ISheetHeader;
        getRange(coords: IRange.Coords): ICellRange;
        styleUpdater: CellStyleUpdater;
        opener(url: string, options: ICellRange.SelectOptions, target?: string, features?: string): Promise<boolean>;
    }
    export class SheetCell implements ICell {
        protected _ri: RangeState.Intersection;
        protected _p: IRange.CellCoords;
        protected _n: IRange.CellCoords;
        protected _to: ICell.HorizontalOverflow;
        protected _options: SheetCellOptions;
        protected _coords: IRange.CellCoords;
        protected _t: ScalarType;
        protected _v: Scalar;
        protected _styleSpecific: IStyle;
        protected _styleConditional: IStyle;
        constructor(options: SheetCellOptions, coords: IRange.CellCoords, type?: ScalarType, value?: Scalar, intersection?: RangeState.Intersection, p?: IRange.CellCoords, // prev
        n?: IRange.CellCoords);
        /** {@inheritDoc ICell.getRange} */
        getRange(): ICellRange;
        /** {@inheritDoc ICell.isEqual} */
        isEqual(other: ICell): boolean;
        /** {@inheritDoc ICell.getCoords} */
        getCoords(): IRange.CellCoords;
        /** {@inheritDoc ICell.getA1} */
        getA1(): string;
        /** {@inheritDoc ICell.getSheet} */
        getSheet(): ISheet;
        /** {@inheritDoc ICell.select} */
        select(options?: ITypes.SelectOptions): Promise<boolean>;
        /** {@inheritDoc ICell.getColumnFilter} */
        getColumnFilter(): IAutoFilter.IColumn | null;
        /** {@inheritDoc ICell.getProtection} */
        getProtection(): ICellProtection;
        /** {@inheritDoc ICell.getTextOverflow} */
        getTextOverflow(): Readonly<ICell.HorizontalOverflow> | null;
        /** {@inheritDoc ICell.getRenderHorizontalAlignment} */
        getRenderHorizontalAlignment(): ITextFrame.HorizontalAlignment;
        /** {@inheritDoc ICell.isEmpty} */
        isEmpty(): boolean;
        /** {@inheritDoc ICell.getExtrusions} */
        getExtrusions(): IRange.Coords | null;
        /** {@inheritDoc ICell.isEditAllowed} */
        isEditAllowed(): boolean;
        /** {@inheritDoc ICell.isFormulaHidden} */
        isFormulaHidden(): boolean;
        /** {@inheritDoc ICell.isContentful} */
        isContentful(): boolean;
        /** {@inheritDoc ICell.getBestFit} */
        getBestFit(colWidth?: number, minContent?: boolean): Readonly<Partial<Size>> | null;
        /** {@inheritDoc ICell.getInsets} */
        getInsets(): Rectangle;
        /** {@inheritDoc ICell.getTextFrame} */
        getTextFrame(showFormula?: boolean): ITextFrame;
        /** {@inheritDoc ICell.getValue} */
        getValue(): Scalar;
        /** {@inheritDoc ICell.getFormula} */
        getFormula(): ICalculation.IFormula | null;
        /** {@inheritDoc ICell.getFormulaText} */
        getFormulaText(): string | null;
        /** {@inheritDoc ICell.getCalcStatus} */
        getCalcStatus(): ICell.CalcStatus;
        /** {@inheritDoc ICell.getType} */
        getType(): ScalarType;
        /** {@inheritDoc ICell.getStyle} */
        getStyle(specific?: boolean): IStyle;
        /** {@inheritDoc ICell.createTemporaryCell} */
        createTemporaryCell(update: ICell.Update): ICell;
        private _isDate1904;
        /** {@inheritDoc ICell.getNumberFormat} */
        getNumberFormat(numberFormat?: string): NumberFormat.Parsed;
        /** {@inheritDoc ICell.toDate} */
        toDate(): Date | null;
        /** {@inheritDoc ICell.toText} */
        toText(): string;
        /** {@inheritDoc ICell.toTextUnformatted} */
        toTextUnformatted(showFormula?: boolean): string;
        /** {@inheritDoc ICell.getComments} */
        getComments(): Readonly<IComment.Properties>;
        /** {@inheritDoc ICell.getHyperlink} */
        getHyperlink(): IHyperlink;
        /** {@inheritDoc ICell.getErrors} */
        getErrors(): readonly string[];
        /** {@inheritDoc ICell.getWarnings} */
        getWarnings(): readonly string[];
        /** {@inheritDoc ICell.getSpans} */
        getSpans(): Readonly<Size>;
        /** {@inheritDoc ICell.isTopLeft} */
        isTopLeft(): boolean;
        /** {@inheritDoc ICell.getSpill} */
        getSpill(): ICellRange | null;
        /** {@inheritDoc ICell.isSpillOverflow} */
        isSpillOverflow(): boolean;
        get [Symbol.toStringTag](): string;
        /** {@inheritDoc ICell.toString} */
        toString(): string;
        /** {@inheritDoc ICell.isICell} */
        get isICell(): true;
    }
    /**
     * Default cell when there is no value. We never return null.
     * Needed to ensure we pass the correct options
     * @remarks
     * Only used for temporary cells with no coordinates.
     */
    export class EmptyCell extends SheetCell {
        constructor(options: SheetCellOptions);
        /** {@inheritDoc ICell.isEmpty} */
        isEmpty(): boolean;
        /** {@inheritDoc ICell.isContentful} */
        isContentful(): boolean;
        toString(): string;
    }
    /**
     * A formula for a cell
     */
    export class Formula implements ICalculation.IFormula {
        protected _options: SheetCellOptions;
        protected _entry: FormulaEntry;
        protected _coords: IRange.CellCoords;
        constructor(options: SheetCellOptions, entry: FormulaEntry, coords: IRange.CellCoords);
        /** {@inheritDoc ICalculation.getTokens} */
        getTokens(evalIndex?: number): readonly ICalculation.FormulaToken[];
        /** {@inheritDoc ICalculation.evaluate} */
        evaluate(evalIndex?: number): Promise<Scalar | IRange>;
        /** {@inheritDoc ICalculation.toText} */
        toText(r1c1?: boolean): string;
        /** {@inheritDoc ICalculation.getDirectPrecedents} */
        getDirectPrecedents(): readonly (IRange.Coords | FormulaError.Known)[];
        /** {@inheritDoc ICalculation.getReferences} */
        getReferences(): readonly (IRange.FixableCoords | string | FormulaError.Known)[];
        /** {@inheritDoc ICalculation.setReferenceAt} */
        setReferenceAt(index: number, precedent: IRange.FixableCoords): this;
        get [Symbol.toStringTag](): string;
        /**
         * Provides a string representation of the formula.
         */
        toString(): string;
    }
}
declare module "sheet/SheetRanges" {
    import { Scalar, IRange } from '@sheetxl/primitives';
    import type { ITransaction } from "transaction/index";
    import type { IListener } from "listener/index";
    import type { ICell } from "cell/index";
    import type { ICellRanges, ICellRange, ICellHeaderRange, ICellHeaderRanges } from "cellRange/index";
    import type { IStyle } from "style/index";
    import type { ISheet } from "sheet/index";
    export interface SheetRangesOptions {
        ignoreHidden?: boolean;
        readOnly?: string;
        getOptions: ICellRange.GetRangeOptions;
    }
    export class SheetRanges implements ICellRanges {
        protected _coords: readonly IRange.FixableCoords[];
        protected _readOnly: string | null;
        protected _options: SheetRangesOptions;
        protected _sheet: any;
        constructor(coords: readonly IRange.FixableCoords[], sheet: any, options: SheetRangesOptions);
        protected _createRanges(coords: readonly IRange.FixableCoords[], getOptions?: ICellRange.GetRangeOptions): this;
        protected _createRange(coords: Readonly<IRange.FixableCoords>, getOptions?: ICellRange.GetRangeOptions): ICellRange;
        protected _validateWrite(): void;
        /** {@inheritDoc ICellRanges.getCoords} */
        getCoords(): readonly IRange.FixableCoords[];
        /** {@inheritDoc ICellRange[Symbol.iterator]} */
        [Symbol.iterator](): IterableIterator<Scalar>;
        /** {@inheritDoc ICellRange.entries} */
        entries(options?: ICellRange.IteratorOptions): IterableIterator<ICellRange.Entry>;
        /** {@inheritDoc ICellRanges.select} */
        select(options?: ICellRange.SelectOptions): Promise<this>;
        /** {@inheritDoc ICellRange.calculate} */
        calculate(): this;
        /** {@inheritDoc ICellRange.addListener} */
        addListener2(listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
        /** {@inheritDoc ICellRanges.addListener} */
        addListener(listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
        /** {@inheritDoc ICellRanges.find} */
        find(options: string | ICellRange.FindOptions): Iterator<ICell>;
        /** {@inheritDoc ICellRanges.getFlattened} */
        getFlattened(options?: ICellRange.GetFlattenOptions): this;
        /** {@inheritDoc ICellRanges.getVisible} */
        getVisible(options?: ICellRange.GetVisibleOptions): this | null;
        /** {@inheritDoc ICellRanges.getFixed} */
        getFixed(options: ICellRange.GetFixedOptions): this;
        /** {@inheritDoc ICellRanges.autoFit} */
        autoFit(options?: ICellRange.AutoFitOptions): this;
        /** {@inheritDoc ICellRanges.clear} */
        clear(applyTo?: ICell.Content, options?: ITransaction.OperationOptions): this;
        /** {@inheritDoc ICellRanges.getStyle} */
        getStyle(): IStyle;
        /** {@inheritDoc ICellRanges.merge} */
        merge(options?: IRange.Orientations | ICellRange.MergeOptions): this;
        /** {@inheritDoc ICellRanges.unmerge} */
        unmerge(options?: ITransaction.OperationOptions): this;
        /** {@inheritDoc ICellRanges.getMerges} */
        getMerges(): IRange.Coords[];
        /** {@inheritDoc ICellRanges.insert} */
        insert(options?: IRange.Orientation | ICellRange.InsertOptions): this;
        /** {@inheritDoc ICellRanges.delete} */
        delete(options?: IRange.Orientation | ICellRange.DeleteOptions): this;
        /** {@inheritDoc ICellRanges.insertFrom} */
        insertFrom(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions): Promise<this | null>;
        /** {@inheritDoc ICellRanges.copyFrom} */
        copyFrom(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions): Promise<this | null>;
        /** {@inheritDoc ICellRanges.isInvalidAny} */
        isInvalidAny(): boolean;
        /** {@inheritDoc ICellRanges.getSnapshot} */
        getSnapshot(options?: ICellRange.CopyOptions): ICellRange.ISnapshot;
        /** {@inheritDoc ICellRanges.getEntireRows} */
        getEntireRows(shift?: boolean, options?: ICellRange.GetRangeOptions): this;
        /** {@inheritDoc ICellRanges.getEntireColumns} */
        getEntireColumns(shift?: boolean, options?: ICellRange.GetRangeOptions): this;
        /** {@inheritDoc ICellRange.getRowHeaders} */
        getRowHeaders(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
        /** {@inheritDoc ICellRange.getColumnHeaders}*/
        getColumnHeaders(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
        /** {@inheritDoc ICellRanges.getDefaultShiftOrientation} */
        getDefaultShiftOrientation(): IRange.Orientation;
        /** {@inheritDoc ICellRanges.getCount} */
        getCount(): number;
        /** {@inheritDoc ICellRanges.getCounts} */
        getCounts(types?: Partial<Record<ICell.Content, number | boolean>>): ICellRange.Counts | null;
        /** {@inheritDoc ICellRanges.isContentful} */
        isContentful(): boolean;
        /** {@inheritDoc ICellRanges.getRowCount} */
        getRowCount(): number;
        /** {@inheritDoc ICellRanges.getColumnCount} */
        getColumnCount(): number;
        /** {@inheritDoc ICellRanges.isEntireRowsAny} */
        isEntireRowsAny(): boolean;
        /** {@inheritDoc ICellRanges.isEntireColumnsAny} */
        isEntireColumnsAny(): boolean;
        /** {@inheritDoc ICellRanges.isEntireRows} */
        isEntireRows(): boolean;
        /** {@inheritDoc ICellRanges.isEntireColumns} */
        isEntireColumns(): boolean;
        /** {@inheritDoc ICellRanges.isOverlapping} */
        isOverlapping(): boolean;
        /** {@inheritDoc ICellRanges.at} */
        at(index: number): ICellRange;
        /** {@inheritDoc ICellRanges.isReadOnly} */
        isReadOnly(): boolean;
        /** {@inheritDoc ICellRanges.isInvalid} */
        isInvalid(): boolean;
        /** {@inheritDoc ICellRanges.getA1} */
        getA1(): string;
        /** {@inheritDoc ICellRanges.getSheet} */
        getSheet(): ISheet;
        /** {@inheritDoc ICellRanges.doBatch} */
        doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ITransaction.OperationOptions): R | Promise<R>;
        get [Symbol.toStringTag](): string;
        /** {@inheritDoc ICellRanges.toString} */
        toString(): string;
        /** {@inheritDoc ICellRanges.isICellRanges} */
        get isICellRanges(): true;
    }
}
declare module "calculation/graph/_CalcGraphUtils" {
    import { Scalar, IRange } from '@sheetxl/primitives';
    import { Tuple, ISparseGrid, ISpatialMap } from "collections/index";
    import { CalcNode } from "calculation/graph/CalcState";
    import { FormulaBlockEntry, ContentfulEntry, SpillEntry, PrecedentEntry } from "calculation/spatial/index";
    export const oncesCompareValues: (a: ISpatialMap.Entry<FormulaBlockEntry>, removing: ISpatialMap.Entry<FormulaBlockEntry>) => boolean;
    export const anchorCompareValues: (a: ISpatialMap.Entry<FormulaBlockEntry>, removing: ISpatialMap.Entry<FormulaBlockEntry>) => boolean;
    /**
     * Returns true if `coords` is top left.
     *
     * @param rowIndex number
     * @param colIndex number
     * @param range IRange.Coords
     */
    export const isAnchorRange: (rowIndex: number, colIndex: number, range: IRange.Coords) => boolean;
    export const rangeToTuples: (range: IRange, offsetMajor?: number, offsetMinor?: number) => Tuple.BoundedTuples<Scalar>;
    /**
     * Updates contentful and invalidates spills.
     *
     * @returns The bounds
     * @remarks
     * This code will inline spill errors but spill results are handled in calculations.
     */
    export const applyContentful: (cycleId: number, removes: readonly IRange.Coords[], inserts: ISpatialMap.Entry[], contentfulSpatial: ISpatialMap<ContentfulEntry>, spillSpatial: ISpatialMap<SpillEntry>, values: ISparseGrid<Scalar>, invalidationsEntries?: ISpatialMap.Entry[], notifyValuesSpatial?: ISpatialMap, notifySpillSpatial?: ISpatialMap<SpillEntry>, notifyPending?: ISpatialMap<boolean>, errorSpatial?: ISpatialMap<string>, // notifyErrorSpatial,
    isColumn?: boolean, notifyCalc?: boolean) => IRange.Coords;
    /**
     * Creates a map from tuples
     *
     * @remarks
     * This is here because of the ILikeLike dependency.
     */
    export const tuplesToA1Map: <T = any>(boundedTuples: Tuple.BoundedTuples<T> | undefined, orientation?: IRange.Orientation) => Map<string, T>;
    export const addDynamicPrecedent: (entries: ISpatialMap.Entry<PrecedentEntry>[], node: CalcNode, range?: IRange.Coords) => ISpatialMap.Entry<PrecedentEntry>[];
}
declare module "sheet/Sheet" {
    import { Scalar, JSScalar, IRange } from '@sheetxl/primitives';
    import { type Size, type Bounds, CoordUtils } from '@sheetxl/utils';
    import { ITypes, ICollection, IProperties } from "type/index";
    import type { IWorkbook } from "workbook/index";
    import type { IListener } from "listener/index";
    import { type ITransaction } from "transaction/index";
    import { type IResource, type IResourceCollection } from "resource/index";
    import { type IStringCollection } from "string/index";
    import type { IComment } from "comment/index";
    import { IColor } from "color/index";
    import type { IHyperlink } from "hyperlink/index";
    import { IAutoSort, ISort } from "sort/index";
    import { IAutoFilter } from "filter/index";
    import { IAnchored } from "anchored/index";
    import { ITable, type ITableCollection } from "table/index";
    import type { INamedCollection } from "named/index";
    import { IMovable, IMovableCollection } from "movable/index";
    import { ICell } from "cell/index";
    import { ICellRange, ICellRanges } from "cellRange/index";
    import { IStyle, IStyleCollection } from "style/index";
    import { IRangeSelection } from "selection/index";
    import { IConditionalFormat, IConditionalFormatCollection } from "conditional/index";
    import { Tuple, ISparseGrid, ISpatialMap, SortedMap } from "collections/index";
    import { ListenerEmitter } from "listener/ListenerEmitter";
    import { ConditionalEntry } from "conditional/ConditionalEntry";
    import { ISheetView } from "sheet/view/index";
    import { ISheetProtection } from "sheet/protection/index";
    import { ISheetHeader } from "sheet/header/index";
    import { ISheet } from "sheet/ISheet";
    import { SheetHeader } from "sheet/header/SheetHeader";
    import { SheetDirectStyle } from "sheet/style/SheetDirectStyle";
    import { CellState, RangeState } from "sheet/_SheetTypes";
    import { MergeEntry, FormulaEntry, UnlockEntry } from "sheet/spatial/index";
    import { RangesListener, RangesListenerEntry } from "sheet/listener/index";
    import { SheetProtection } from "sheet/protection/SheetProtection";
    import { SheetCellOptions } from "sheet/SheetCell";
    import { ICalculation } from "calculation/index";
    import type { ICalcGraph } from "calculation/graph/index";
    import { ContentfulEntry, SpillEntry } from "calculation/spatial/index";
    /**
     * Used for signalling tupleUpdate was called via private apis.
     * This allows use to 'avoid side effects' and skip validation checks.
     * @internal
     */
    interface InternalTupleUpdate {
        isCell?: boolean;
        isHyperlink?: boolean;
    }
    /**
     * Use to tell range converter which type of protection checks to perform before proceeding
     * * null means no protection check.
     * * empty array means we will fail for the operation it ANY protection is set.
     * @internal
     */
    interface ProtectionCheck {
        (coords?: IRange.Coords[]): ISheetProtection.PropertyKeys[];
    }
    /**
     * Interface for anchored items that need to have call back interactions.
     * @internal
     */
    interface IAnchorEntry<T = any> extends ISpatialMap.IUpdatableEntry {
        model: T;
        processShiftCallback: IAnchored.ShiftCallback;
        processDeleteCallback: IAnchored.DeleteCallback;
        processProtectionCallback: () => void;
        processLayoutCallback?: IAnchored.LayoutCallback;
    }
    interface ITableEntry extends IAnchorEntry<ITable> {
        currentName: string;
        removeListener: IListener.Remove;
    }
    /**
     * Used for creating maps to models
     */
    interface IModelEntry<T, S extends ISpatialMap.IUpdatableEntry = ISpatialMap.IUpdatableEntry> {
        model: T;
        spatials: ISpatialMap.Entry<S>[];
        removeListener: IListener.Remove;
        processCoordsChange?: IAnchored.CoordsChangeCallback;
    }
    interface IMovableEntry extends IAnchorEntry<IMovable> {
        processZIndexCallback: () => void;
        processSelectionCallback: (selected: boolean, first: boolean) => void;
        zIndex: number;
    }
    interface NotifierOptions {
        isDataChange?: boolean;
        isTransactional?: boolean;
        isUndo?: boolean;
        trigger?: string;
        from?: ICellRanges;
        to?: ICellRange;
        timeStamp?: number;
    }
    /**
     * We need to keep track of before/after for the undo stack when not part of the transaction.
     */
    interface BeforeAfterRange {
        beforeState: ICellRangesListenerEntry;
        afterState: ICellRangesListenerEntry;
    }
    interface ICellRangeListenerEntry {
        id: number;
        offset: number;
        options: ICellRange.ListenerOptions;
    }
    interface ICellRangesListenerEntry {
        id: number;
        /**
         * We have to track the range because we can't use the node coords
         * as shift/split can change the coords. and our range has fixed dimensions.
         */
        ranges: Readonly<IRange.FixableCoords>[];
        handler: ICellRange.Listener;
        handlerW: WeakRef<ICellRange.Listener>;
        removeListener: IListener.Remove;
        options: ICellRange.ListenerOptions;
    }
    interface GetTypedRangeOptions<T = any, E = any> {
        /**
         * If 'true' will not return ranges that are hidden.
         * If partially hidden the 'fullContained' is applied.
         */
        ignoreHidden?: boolean | IRange.Orientation;
        /**
         * Only return ranges that are completely contained with the search range.
         *
         * @defaultValue false
        */
        fullyContained?: boolean;
        sort?: {
            orientation?: IRange.Orientation;
            reverse?: boolean;
        };
        onEntry?: (value: E, entry: ISpatialMap.Entry<T>) => T | void;
        noCache?: boolean;
    }
    interface ViewEdgeEntry {
        rowIndex: number;
        colIndex: number;
        continuous: IProperties.ICellRanged<IStyle.Properties> | null;
        leftIndex: number;
        rightIndex: number;
        overflow: ICell.HorizontalOverflow | null;
        intersection: RangeState.Intersection;
        scalar: Scalar | null;
        style: IStyle;
    }
    interface State {
        cellValuesGrid: ISparseGrid<Scalar>;
        contentfulSpatial: ISpatialMap<ContentfulEntry>;
        formulaSpatial: ISpatialMap<FormulaEntry>;
        calcGraph: ICalcGraph;
        spillSpatial: ISpatialMap<SpillEntry>;
        pendingSpatial: ISpatialMap<boolean>;
        calcErrorsSpatial: ISpatialMap<string>;
        directStyleSpatial: ISpatialMap<SheetDirectStyle>;
        continuousFillSpatial: ISpatialMap<SheetDirectStyle>;
        mergeSpatial: ISpatialMap<MergeEntry>;
        hyperlinkSpatial: ISpatialMap<IHyperlink.Properties>;
        commentsSpatial: ISpatialMap<IComment.JSON>;
        movableSpatial: ISpatialMap<IMovableEntry>;
        movableMapModel: Map<IMovable, ISpatialMap.Entry<IMovableEntry>>;
        tableSpatial: ISpatialMap<ITableEntry>;
        tableMapModel: Map<ITable, ISpatialMap.Entry<ITableEntry>>;
        tableMapName: Map<string, ITable>;
        conditionalSpatial: ISpatialMap<ConditionalEntry>;
        conditionalModels: Map<string, IModelEntry<IConditionalFormat>>;
        rangesListenerSpatial2: ISpatialMap<RangesListenerEntry>;
        rangesListenerMap2: Map<string, RangesListener>;
        rangeListenerSpatial: ISpatialMap<ICellRangeListenerEntry>;
        rangesListenerMap: Map<number, ICellRangesListenerEntry>;
        unlockSpatial: ISpatialMap<UnlockEntry>;
        filter: IAutoFilter;
        sort: IAutoSort;
        deleted: boolean;
    }
    interface CommitEvents {
        address?: Map<string, RangesListener>;
        data?: IRange.Coords[];
        dataListeners?: Map<string, RangesListener>;
    }
    interface CommitView {
        initial?: boolean;
        view?: ISheetView;
        selection?: Partial<IRangeSelection.Coords>;
        selectOptions?: boolean | ICellRange.SelectOptions;
        movableSelection?: readonly IMovable[];
        ranges?: readonly IRange.FixableCoords[];
        events?: CommitEvents;
        formulas?: readonly IRange.FixableCoords[];
        /**
         * Special case for range listeners that monitored a remove.
         */
        merges?: readonly IRange.FixableCoords[];
        listeners?: Map<number, BeforeAfterRange>;
        /** If `true` then don't do protection check. (For example load or range listeners) */
        skipProtectionCheck?: boolean;
        /**
         * We update values (cache, potentially styling, as a result of calculations)
         */
        calculationSideEffect?: boolean;
    }
    /**
     * Base implementation of {@link ISheet}.
     */
    export class Sheet implements ISheet {
        protected _options: ISheet.ConstructorOptions;
        protected _transactions: ITransaction.IStore;
        protected _ownTransactions: boolean;
        protected _transactionsRemoveListener: IListener.Remove;
        protected _lastTransactionUUID: string;
        protected _emitter: ListenerEmitter<ISheet, ISheet.IListeners>;
        protected _initializing: boolean;
        protected _starting: Promise<void>;
        protected _strings: IStringCollection;
        protected _ownStrings: boolean;
        protected _styles: IStyleCollection;
        protected _ownStyles: boolean;
        protected _stylesRemoveListener: IListener.Remove;
        protected _normalStyleRanged: IProperties.ICellRanged<IStyle.Properties>;
        protected _resources: IResourceCollection;
        protected _ownResources: boolean;
        protected _names: INamedCollection;
        protected _ownNames: boolean;
        protected _namesRemoveListener: IListener.Remove;
        protected _calculation: ICalculation;
        protected _ownsCalculation: boolean;
        protected _workbook: IWorkbook | null;
        protected _tables: ITableCollection;
        protected _conditionals: IConditionalFormatCollection;
        protected _movables: IMovableCollection;
        protected _emitterMovables: ListenerEmitter<IMovableCollection, ICollection.IListeners>;
        protected _rangesListenerSorted: SortedMap<number, RangesListener>;
        protected _rangeListenerSpatial: ISpatialMap<ICellRangeListenerEntry>;
        protected _rangesListenerMap: Map<number, ICellRangesListenerEntry>;
        protected _lastCellDecoded: {
            address: ICell.Address;
            coords: IRange.CellCoords;
        };
        protected _lastCellSelected: {
            coords: IRange.CellCoords;
            cell: ICell;
        };
        protected _lastCellRead: {
            coords: IRange.CellCoords;
            cell: ICell;
        };
        protected _lastValueRead: {
            range: IRange.Coords;
            isDateOrTime: boolean;
        };
        protected _lastGetRangeRead: Record<string, {
            ranges: readonly IRange.Coords[];
            ignoreHidden: boolean | IRange.Orientation;
            results: any[];
        }>;
        protected _lastUsedCoordsRead: {
            coords: IRange.Coords;
            range: ICellRange;
        };
        protected _lastActiveRead: {
            selection: IRangeSelection.Coords;
            range: ICellRange;
            ranges: ICellRanges;
        };
        protected _lastRangeRead: {
            address: ICellRange.Address;
            range: ICellRange;
            ranges: ICellRanges;
        };
        protected _entireCoords: IRange.Coords;
        protected _entireRange: ICellRange;
        protected _isDataColumn: boolean;
        protected _rangeSelection: IRangeSelection;
        protected _rangeSelectionListener: IRangeSelection.IListeners;
        protected _rangeSelectionRemoveListener: IListener.Remove;
        protected _view: ISheetView;
        protected _viewListener: ISheetView.IListeners;
        protected _viewRemoveListener: IListener.Remove;
        protected _protection: SheetProtection;
        protected _protectionRemoveListener: IListener.Remove;
        protected _tabColor: IColor;
        protected _isDate1904: boolean;
        protected _colHeaders: ISheetHeader;
        protected _colHeadersShiftCallback: SheetHeader.ShiftCallback;
        protected _colHeadersListener: ISheetHeader.IListeners;
        protected _colHeadersRemoveListener: IListener.Remove;
        protected _rowHeaders: ISheetHeader;
        protected _rowHeadersShiftCallback: SheetHeader.ShiftCallback;
        protected _rowHeadersListener: ISheetHeader.IListeners;
        protected _rowHeadersRemoveListener: IListener.Remove;
        protected _emptyCell: ICell;
        protected _cellOptions: SheetCellOptions;
        protected _closed: boolean;
        protected _defaultColWidthCache: number;
        protected _defaultRowHeightCache: number;
        protected _defaultFontBoundsCache: Readonly<Size>;
        constructor(options?: ISheet.ConstructorOptions);
        /** @internal */
        protected _createRange(coords: Readonly<IRange.FixableCoords>, getOptions?: ICellRange.GetRangeOptions, readOnly?: string): ICellRange;
        /** @internal */
        protected _createRanges(coords: readonly IRange.Coords[], getOptions?: ICellRange.GetRangeOptions, readOnly?: string): ICellRanges;
        /** {@inheritDoc ISheet.getRange} */
        getRange(address: ICellRange.Address, options?: ICellRange.GetRangeOptions): ICellRange;
        /** {@inheritDoc ISheet.getCell} */
        getCell(address: ICell.Address): ICell;
        /** {@inheritDoc ISheet.getRange} */
        getRanges(address: ICellRanges.Address, options?: ICellRange.GetRangeOptions): ICellRanges;
        /** {@inheritDoc ISheet.getSelectedRange} */
        getSelectedRange(options?: ICellRange.GetRangeOptions): ICellRange;
        /** {@inheritDoc ISheet.getSelectedRanges} */
        getSelectedRanges(options?: ICellRange.GetRangeOptions): ICellRanges;
        /** {@inheritDoc ISheet.getEntireRange} */
        getEntireRange(options?: ICellRange.GetRangeOptions): ICellRange;
        /** {@inheritDoc ISheet.getUsedRange} */
        getUsedRange(options?: ICellRange.GetRangeOptions): ICellRange;
        /** @internal */
        protected _cellToCoords(address: ICell.Address): IRange.CellCoords;
        /** @internal */
        protected _validateCoords(coords: IRange.Coords, oobMessage?: string): void;
        /** @internal */
        protected _createRangeError(address: ICellRanges.Address): Error;
        /** @internal */
        protected _protectionCheck(check?: ProtectionCheck, coords?: Readonly<IRange.Coords> | readonly IRange.Coords[], action?: string): void;
        /**
         * Returns an array of ranges.
         *
         * @param address
         * @param protectionCheck
         *
         * @remarks
         * Defaults to maxCoords.
         * Returns an error if the address is unparsable.
         * @internal
         */
        protected _rangesToCoords(address: ICellRanges.Address, protectionCheck?: ProtectionCheck, lookupNames?: boolean, requireSameSheet?: boolean): IRange.Coords[];
        /**
         * Returns exactly 1 range.
         *
         * @remarks
         * This does not default address to maxCoords and fill error if anything other than 1 range is returned.
         * @internal
         */
        protected _rangeToCoords(address: ICellRange.Address, protectionCheck?: ProtectionCheck, lookupNames?: boolean): IRange.Coords;
        /**
         * Collects ranges.
         *
         * @param includeRangeTypes If value is in record it will be search, boolean flag is used for fullyEnclosed.
         * @internal
         */
        protected _collectRanges(queryCoords: IRange.Coords, rangesByType?: ISpatialMap.Entry<RangeState.Intersection>[], includeRangeTypes?: boolean | RangeState.SearchTypes, state?: State, expandMerges?: boolean): void;
        /**
         * This wraps the stateIterator with a ICell.IteratorContext.
         * // TODO - **PERFORMANCE** This slower than expected but _cellStateIterator but still reasonable.
         * @internal
         */
        protected _cellIterator(options: CellState.IteratorOptions): IterableIterator<ICellRange.Entry, ICellRange.Entry, IRange.CellCoords>;
        /**
         * `Options` is required. Will return Done if not provided.
         * @internal
         */
        protected _rangeStateIterator(options: RangeState.IteratorOptions): RangeState.Iterator;
        /**
         * iterator for overlaps and stops.
         *
         * @param view
         *
         * @internal
         */
        protected _overflowAndStops(bounds: IRange.Coords, maxDistance?: number): {
            overflows: ViewEdgeEntry[];
            stops: ViewEdgeEntry[];
        };
        /**
         * Creates a an iterator that combines the values and ranges into a single iterator.
         * @internal
         */
        protected _cellStateIterator(options?: CellState.IteratorOptions): CellState.Iterator;
        /** @internal */
        protected _indexMerges(mergeInserts: IRange.Coords[], mergeRemoves?: IRange.Coords[]): void;
        /** @internal */
        protected _updateStyles(ranges: readonly ISpatialMap.Entry<IStyle.Update>[], defaultUpdate?: IStyle.Update, // we do this because updateTuples may update each
        options?: IStyle.UpdateOptions, calcedNumberFormat?: boolean): void;
        /** @internal */
        protected _createIncrementalUpdater(options?: ICellRange.StartUpdateOptions, sheetRange?: ICellRange, internal?: InternalTupleUpdate): ICellRange.IncrementalUpdater;
        /**
         * TODO - how to support virtual lists (we need to allow for direct sets of lists (that don't iterator over each value) )
         * @internal
         */
        protected _updateTuples(boundedTuples: Tuple.BoundedTuples<ICell.Update>, options?: ICellRange.UpdateCellsOptions, coordValidator?: CoordUtils.CoordValidator, internalOptions?: InternalTupleUpdate): void;
        /** @internal */
        protected _sort(coords: Readonly<IRange.Coords>, options: boolean | (ISort.RangeOptions & ITransaction.OperationOptions)): IRange.Coords;
        /** @internal */
        protected _autoFill(template: IRange.Coords, destination: IRange.Coords, options?: ICellRange.AutoFillOptions): boolean;
        /** @internal */
        protected _setHyperlinks(ranges: readonly ISpatialMap.Entry<IHyperlink.Update>[], defaultUpdate?: IHyperlink.Update, // we do this because updateTuples may update each
        options?: ITransaction.OperationOptions): void;
        /** @internal */
        protected _updateFormulaSpatial(formulaSpatial: ISpatialMap<FormulaEntry>, formulaInserts: ISpatialMap.Entry<ICalcGraph.FormulaInsert>[], formulaRemoves: ISpatialMap.Entry[], styleSpatial?: ISpatialMap<SheetDirectStyle>): ISpatialMap.Entry<IStyle.Update>[];
        /** @internal */
        protected _realizeCalcedValues(results: ICalcGraph.Results): void;
        /** @internal */
        protected _calculate(ranges: ICellRanges.Coords, options?: ICalculation.CalculateOptions): void;
        /** @internal */
        protected _calculateFull(): void;
        /** @internal */
        protected _setComments(ranges: readonly ISpatialMap.Entry<IComment.JSON>[], comments?: IComment.JSON, // we do this because updateTuples may update each
        options?: ITransaction.OperationOptions): void;
        /** @internal */
        protected _clear(ranges: readonly IRange.Coords[], applyTo?: ICell.Content, options?: ITransaction.OperationOptions, excludeMerge?: boolean, isCut?: boolean): void;
        /** @internal */
        protected _merge(ranges: readonly IRange.Coords[], options?: IRange.Orientations | ICellRange.MergeOptions): void;
        /** @internal */
        protected _unmerge(ranges: readonly IRange.Coords[], options?: ITransaction.OperationOptions): void;
        /** @internal */
        protected _getMerges(ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Orientation): IRange.Coords[];
        /** @internal */
        protected _clone(): ISheet;
        /** @internal */
        protected _getSnapshot(coordsFrom?: readonly IRange.Coords[], optionsMark?: ICellRange.CopyOptions): ICellRange.ISnapshot;
        /**
         * Copy all items at a sheetRange.
         * @internal
         `*/
        protected _copyRange(sheetFrom: Sheet, sheetMark: Sheet, coordsFrom: readonly IRange.Coords[], sheetRangeTo: ICellRange, options: ICellRange.CopyOptions, toInfo: any): Promise<IRange.Coords>;
        /**
         * Returns `null` if invalid.
         * @internal
         */
        protected _snapShotFromSource(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions): ICellRange.ISnapshot;
        /** @internal */
        protected _copyFrom(destination: IRange.Coords, source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions): Promise<IRange.Coords>;
        /** @internal */
        protected _createFilter(coords: IRange.Coords, jsonFilter?: IAutoFilter.JSON, _jsonSort?: IAutoSort.JSON): IAutoFilter;
        /** {@inheritDoc ISheet.insertFilter} */
        insertFilter(address?: ICellRange.Address): IAutoFilter;
        /** {@inheritDoc ISheet.getFilter} */
        getFilter(): IAutoFilter | null;
        /** {@inheritDoc ISheet.insertSort} */
        insertSort(address?: ICellRange.Address): IAutoSort;
        /** {@inheritDoc ISheet.getSort} */
        getSort(): IAutoSort | null;
        /** @internal */
        protected _getDefaultShiftOrientation(coords?: IRange.Coords): IRange.Orientation;
        /** @internal */
        protected _getDefaultSortCriteria(coords: IRange.Coords, orientation: IRange.Orientation, cell: ICell.Address): ISort.DefaultSortCriteria;
        /** @internal */
        protected _insertFrom(ranges: readonly IRange.Coords[], source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions): Promise<IRange.Coords>;
        /** @internal */
        protected _insertCells(ranges: readonly IRange.Coords[], options?: IRange.Orientation | ICellRange.InsertOptions, coordValidator?: CoordUtils.CoordValidator): void;
        /** @internal */
        protected _deleteCells(ranges: readonly IRange.Coords[], options?: IRange.Orientation | ICellRange.DeleteOptions): void;
        /**
         * Automatically adjusts row heights and column widths to fit cell content and styles.
         * - Merges and sorts input ranges for efficient processing.
         * - Measures both style and content to determine optimal sizes.
         * - Handles merged cells, wrapped text, and special alignments.
         * - Updates header sizes in a single transaction for undo/redo support.
         * - Optimized for large sheets, but can be further improved for extreme cases.
         *
         * @param ranges Ranges to autofit.
         * @param options AutoFit options (orientation, expandOnly, skipCustomSize, etc).
         * @internal
         */
        protected _autoFit(ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions): void;
        /** @internal */
        protected _createRangeEvent(coords: (readonly IRange.FixableCoords[]) | IRange.FixableCoords, options: NotifierOptions, coordsFrom?: (readonly IRange.FixableCoords[]) | IRange.FixableCoords): ICellRange.Event;
        /**
         * Notifies listeners with a range.
         * @internal
         */
        protected _notifyAddressListeners(listenerMapAll: Map<string, RangesListener>, listenerMapEvent: Map<string, RangesListener>, visited: Set<string>, options: NotifierOptions): void;
        /**
         * Notifies listeners with a range.
         * @internal
         */
        protected _notifyDataListeners(spatialMap: ISpatialMap<RangesListenerEntry>, listenerMap: Map<string, RangesListener>, ranges: readonly IRange.FixableCoords[], visited: Set<string>, options: NotifierOptions): void;
        /**
         * Notifies listeners with a range.
         * @internal
         */
        protected _notifyRangeListeners(spatial: ISpatialMap<ICellRangeListenerEntry>, listenerMap: Map<number, ICellRangesListenerEntry>, ranges: readonly IRange.FixableCoords[], notificationOptions: NotifierOptions): void;
        /** @internal */
        protected _notifyRangeListener2(entry: ICellRangesListenerEntry, event?: ICellRange.Event | null, notificationOptions?: NotifierOptions): void;
        /** @internal */
        protected _notifyUsedRangeChange(): void;
        /** @internal */
        protected _notifyMergeChange(): void;
        /** {@inheritDoc ISheet.addListeners} */
        addListeners(listeners: ISheet.IListeners, options?: IListener.Options): IListener.Remove;
        /** @internal */
        protected _addRangesListeners(ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
        /** @internal */
        protected _addRangesListeners2(ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options: ICellRange.ListenerOptions, isRanges: boolean): IListener.Remove;
        /** @internal */
        protected _getUsedCoords(_options?: ICellRange.GetRangeOptions): IRange.Coords | null;
        /** @internal */
        protected _isContentful(ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Orientation): boolean;
        /** @internal */
        protected _getCount(coords: IRange.Coords[], ignoreHidden?: boolean): number;
        /** @internal */
        protected _contentCounts(ranges: readonly IRange.Coords[], types: ICell.Content[], ignoreHidden: boolean | IRange.Orientation): ICellRange.Counts;
        /** {@inheritDoc ISheet.getSelectedCell} */
        getSelectedCell(): ICell;
        /** {@inheritDoc ISheet.find} */
        find(options?: string | ICellRange.FindOptions): Iterator<ICell>;
        /** @internal */
        protected _setMaxSize(size: Partial<Size> | null, options?: ITransaction.OperationOptions): this;
        /** @internal */
        protected _find(ranges: readonly IRange.Coords[], options: string | ICellRange.FindOptions): Iterator<ICell>;
        /** {@inheritDoc ISheet.isDate1904} */
        isDate1904(): boolean;
        /** @internal */
        protected _surroundingRegion(range: IRange.Coords, options?: ICellRange.GetSurroundingOptions): IRange.Coords;
        /** @internal */
        protected _extendRange(direction: IRange.Direction, coords: IRange.CellCoords): Readonly<IRange.Coords>;
        /** @internal */
        protected _defaultFontDims(): Readonly<Size>;
        /** {@inheritDoc ISheet.getColumnWidthAsFontUnit} */
        getColumnWidthAsFontUnit(pixelWidth: number): number;
        /**
         * col width in character units
         * @internal
         */
        protected _defaultColWidth(): number;
        /**
         * row height in character pts. To get pixels multiple by scale
         * @internal
         */
        protected _defaultRowHeight(): number;
        /** {@inheritDoc ISheet.getProtection} */
        getProtection(): ISheetProtection;
        /** @internal */
        protected _selectSheet(coords: IRange.Coords, scrollIntoView?: boolean | ICellRange.ScrollIntoViewOptions): Promise<boolean>;
        /** {@inheritDoc ISheet.scrollTo} */
        scrollTo(coords: Partial<IRange.Coords>, options?: ISheet.ScrollToOptions): Promise<boolean>;
        /** @internal */
        protected _resolveSelectOptions(selectOptions: boolean | ICellRange.SelectOptions, orientation: IRange.Orientation): ICellRange.SelectOptions;
        /** @internal */
        protected _commitAndAutoSelect(trans: ITransaction, selection: Partial<IRangeSelection.Coords>, selectOptions?: boolean | ICellRange.SelectOptions, commitOptions?: ITransaction.StoreOperationOptions<CommitView>, orientation?: IRange.Orientation): Promise<IRange.Coords[]>;
        /** @internal */
        protected _autoSelect(options?: boolean | ICellRange.SelectOptions, selectionOverride?: Partial<IRangeSelection.Coords>, orientation?: IRange.Orientation): Promise<IRange.Coords[]>;
        /** {@inheritDoc ISheet.getSelection} */
        getSelection(): IRangeSelection;
        /** {@inheritDoc ISheet.getView} */
        getView(): ISheetView;
        /** {@inheritDoc ISheet.setView} */
        setView(view: ISheetView): this;
        /** {@inheritDoc ISheet.getTabColor} */
        getTabColor(): IColor;
        /** {@inheritDoc ISheet.setTabColor} */
        setTabColor(color: IColor | string | null): this;
        /** {@inheritDoc ISheet.getRowHeaders} */
        getRowHeaders(): ISheetHeader;
        /** {@inheritDoc ISheet.getColumnHeaders} */
        getColumnHeaders(): ISheetHeader;
        /** {@inheritDoc ISheet.toJSON} */
        toJSON(ignoreData?: boolean): Promise<ISheet.JSON>;
        /** {@inheritDoc ISheet.getStyles} */
        getStyles(): IStyleCollection;
        /** {@inheritDoc ISheet.getResources} */
        getResources(): IResourceCollection;
        /** {@inheritDoc ISheet.getTransactions} */
        getTransactions(): ITransaction.IStore;
        /** {@inheritDoc ISheet.getStrings} */
        getStrings(): IStringCollection;
        /** @internal */
        protected _searchMovables(options?: IMovableCollection.GetItemsOptions): IMovable[];
        /** @internal */
        protected _updateSelectedMovables(update: (movable: IMovable) => void, action?: string): void;
        /** @internal */
        protected _addMovable(options?: IMovableCollection.AddOptions): Promise<IMovable>;
        /** @internal */
        protected _addImage(image: string | IResourceCollection.AddOptions | IResource, options?: IMovableCollection.AddOptions): Promise<IMovable>;
        /** {@inheritDoc ISheet.getTables} */
        getTables(): ITableCollection;
        getConditionals(): IConditionalFormatCollection;
        /** {@inheritDoc ISheet.getMovables} */
        getMovables(): IMovableCollection;
        _doPerfTest(length?: number, doProfile?: boolean): void;
        /** @internal */
        protected _validateOrRemoveOverlaps(rangeCoords: IRange.Coords, type: string, table?: ITable, removeIfContains?: boolean): void;
        /**
         * Used by the TableCollection wrapper so we resolve ICellRange.Address here
         * @internal
         */
        protected _addTable(address: ICellRange.Address, options: ITableCollection.AddOptions): ITable;
        /**
         * Used by the ConditionalFormatCollection wrapper so we resolve ICellRange.Address here
         * @internal
         */
        protected _addConditional(address: ICellRange.Address, options: IConditionalFormatCollection.AddOptions): IConditionalFormat;
        /** {@inheritDoc ISheet.createTemporaryCell} */
        createTemporaryCell(update: ICell.Update, coords?: IRange.CellCoords): ICell;
        /** @internal */
        protected _getBoundsAtCoords(coords: IRange.Coords): Bounds;
        /** @internal */
        protected _getCoordsAtBounds(bounds: Bounds): IRange.Coords;
        /** {@inheritDoc ISheet.getRangeAtBounds} */
        getRangeAtBounds(bounds: Bounds, options?: ICellRange.GetRangeOptions): ICellRange;
        /** @internal */
        protected _getVisible(coords: readonly IRange.Coords[], options?: ICellRange.GetVisibleOptions): readonly IRange.Coords[];
        /**
         * Check if the spatial map has any entries in the given range.
         * @internal
         */
        protected _hasRangedEntries(key: keyof State, range: IRange.Coords): boolean;
        /**
         * Search spatial map for entries in the given range.
         * @remarks
         * Tries to cache and can exclude hidden.
         * @internal
         */
        protected _getRangedEntries<T, E = T>(key: keyof State, ranges: readonly IRange.Coords[], options?: GetTypedRangeOptions<T, E>): T[];
        /** @internal */
        protected _processAnchorShift<T extends IAnchorEntry>(options: ISpatialMap.ShiftDetails<T>): ISpatialMap.Entry<T>;
        /** @internal */
        protected _processListenerShift(rangesListenerMap: Map<number, ICellRangesListenerEntry>, beforeAfterMap: Map<number, BeforeAfterRange>, beforeStates: Map<number, ICellRangesListenerEntry>, options: ISpatialMap.ShiftDetails<ICellRangeListenerEntry>): ISpatialMap.Entry<ICellRangeListenerEntry>[] | void;
        /** {@inheritDoc ISheet.delete} */
        delete(): void;
        /** {@inheritDoc ITransaction.ITransactional.doBatch} */
        doBatch<R>(callback: (commit: ITransaction.ICommit) => Promise<R> | R, options?: string | ITransaction.OperationOptions): Promise<R> | R;
        /** {@inheritDoc ISheet.isClosed} */
        isClosed(): boolean;
        /** {@inheritDoc ISheet.close} */
        close(): void;
        /** {@inheritDoc ITransaction.ITransactional.beginCommit} */
        beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
        /** @internal */
        protected _getState(): Readonly<State>;
        /** @internal */
        protected _beginCommit(options?: ITransaction.StoreOperationOptions<CommitView>): ITransaction;
        /** @internal */
        protected _updateState(updateState?: Partial<State>): State;
        /** @internal */
        protected _addEvent(type: keyof CommitEvents, value: any): void;
        /** @internal */
        protected _getScalar(rowIndex: number, columnIndex: number, asJSDate?: boolean): Scalar | JSScalar;
        /** @internal */
        protected _getStyle(ranges: IRange.Coords[], anchor?: IRangeSelection.Coords): IStyle;
        /** @internal */
        protected _initState(): void;
        /** @internal */
        protected _clearState(): void;
        /** @internal */
        protected _createTableEntry(json: ITable.JSON, readSheetHeader?: boolean): ISpatialMap.Entry<ITableEntry>;
        /** @internal */
        protected _createConditionalEntries(json: IConditionalFormat.JSON, conditionalSpatials: ISpatialMap<ConditionalEntry>, conditionalModels: Map<string, IModelEntry<IConditionalFormat>>): IConditionalFormat;
        /** @internal */
        protected _createMovableEntry(json: IMovable.JSON, zIndex: number, fromResourceId?: (resourceId: number) => IResource): ISpatialMap.Entry<IMovableEntry>;
        /** @internal */
        protected _fromJSON(json: ISheet.JSON): void;
        /** {@inheritDoc ISheet.getName} */
        getName(): string;
        /** {@inheritDoc ISheet.setName} */
        setName(name: string): ISheet;
        /** {@inheritDoc ISheet.getVisibility} */
        getVisibility(): ISheet.Visibility;
        /** {@inheritDoc ISheet.setVisibility} */
        setVisibility(visibility?: ISheet.Visibility | boolean): this;
        /** {@inheritDoc ISheet.select} */
        select(options: ITypes.SelectOptions): Promise<ISheet>;
        /** {@inheritDoc ISheet.duplicate} */
        duplicate(): Promise<ISheet>;
        /** {@inheritDoc ISheet.setPosition} */
        setPosition(index: number): ISheet;
        /** {@inheritDoc ISheet.getNames} */
        getNames(): INamedCollection;
        /** {@inheritDoc ISheet.getCalculation} */
        getCalculation(): ICalculation;
        /** {@inheritDoc ISheet.getWorkbook} */
        getWorkbook(): IWorkbook | null;
        get [Symbol.toStringTag](): string;
        /** {@inheritDoc ICellRange.toString} */
        toString(): string;
        /** {@inheritDoc ISheet.isISheet} */
        get isISheet(): true;
    }
}
declare module "sheet/SheetRange" {
    import { Scalar, ScalarUpdate, JSScalar, IRange } from '@sheetxl/primitives';
    import { ITransaction } from "transaction/index";
    import { IListener } from "listener/index";
    import type { ICell } from "cell/index";
    import type { ICellRange, ICellRanges, ICellHeaderRange } from "cellRange/index";
    import type { IComment } from "comment/index";
    import type { IStyle } from "style/index";
    import type { IHyperlink } from "hyperlink/index";
    import type { ISort } from "sort/index";
    import type { ISheet } from "sheet/ISheet";
    import { Sheet } from "sheet/Sheet";
    export interface SheetRangeOptions {
        ignoreHidden?: boolean;
        readOnly?: string;
        getOptions: ICellRange.GetRangeOptions;
    }
    export class SheetRange implements ICellRange {
        protected _coords: Readonly<IRange.FixableCoords>;
        protected _readOnly: string | null;
        protected _options: SheetRangeOptions;
        protected _sheet: Sheet;
        constructor(coords: IRange.FixableCoords, sheet: Sheet, options: SheetRangeOptions);
        /** {@inheritDoc ICellRange.getCoords} */
        getCoords(): Readonly<IRange.FixableCoords>;
        /** @internal */
        protected _createRange(coords: Readonly<IRange.FixableCoords>, getOptions?: ICellRange.GetRangeOptions): this;
        /** @internal */
        protected _createRanges(coords: readonly IRange.FixableCoords[], getOptions?: ICellRange.GetRangeOptions): ICellRanges;
        /**
         * `createRanges` but with additional checks.
         * @internal
         */
        protected _deriveRanges(getOptions?: ICellRange.GetRangeOptions, callback?: (origCoords: IRange.Coords) => IRange.Coords[] | null): ICellRanges | null;
        /**
         * `createRange` but with additional checks.
         * @internal
         */
        protected _deriveRange(address: ICellRange.Address, options: ICellRange.GetRangeOptions, callback?: (newCoords: IRange.Coords, origCoords: IRange.Coords) => IRange.Coords): this;
        /** @internal */
        protected _validateMaxSize(maxSize?: number): void;
        /** {@inheritDoc ICellRange.entries} */
        entries(options?: ICellRange.IteratorOptions): IterableIterator<ICellRange.Entry>;
        /** {@inheritDoc ICellRange[Symbol.iterator]} */
        [Symbol.iterator](): IterableIterator<Scalar>;
        /** {@inheritDoc ICellRange.values} */
        values(options?: ICellRange.IteratorOptions): IterableIterator<Scalar>;
        /** {@inheritDoc ICellRange.forEach} */
        forEach<T>(callback: ICellRange.ForEachCallback, optionsIterator?: ICellRange.IteratorOptions): T | void;
        /** @internal */
        protected _validateWrite(): void;
        /** {@inheritDoc ICellRange.updateCells} */
        updateCells(value: ICellRange.Update, options?: ICellRange.UpdateCellsOptions, updateCoords?: IRange.Coords): this;
        /** {@inheritDoc ICellRange.setValues} */
        setValues(value: ICellRange.ValuesUpdate, options?: ICellRange.SetValuesOptions): this;
        /** {@inheritDoc ICellRange.setValue} */
        setValue(value: ScalarUpdate, options?: ICellRange.SetValuesOptions): this;
        /** {@inheritDoc ICellRange.setFormula} */
        setFormula(value: ScalarUpdate, options?: ICellRange.SetValuesOptions): this;
        /** @internal */
        protected _setValueOrValues(value: ICellRange.ValuesUpdate, options?: ICellRange.SetValuesOptions): this;
        /** {@inheritDoc ICellRange.getValues} */
        getValues(options?: ICellRange.GetValuesOptions): Scalar[][];
        /** {@inheritDoc ICellRange.toText} */
        toText(options?: ICellRange.ToTextOptions): string;
        /** {@inheritDoc ICellRange.getValues} */
        getValue(options?: ICellRange.GetValuesOptions): Scalar | JSScalar;
        /** {@inheritDoc ICellRange.calculate} */
        calculate(full: boolean): this;
        /** {@inheritDoc ICellRange.getCells} */
        getCells(options?: ICellRange.GetValuesOptions): ICell[][];
        /** {@inheritDoc ICellRange.getCell} */
        getCell(address?: ICell.Address): ICell;
        /** {@inheritDoc ICellRange.select} */
        select(options?: ICellRange.SelectOptions): Promise<this>;
        /** {@inheritDoc ICellRange.find} */
        find(options: string | ICellRange.FindOptions): Iterator<ICell>;
        /** {@inheritDoc ICellRange.getFixed} */
        getFixed(options: ICellRange.GetFixedOptions): this;
        /** {@inheritDoc ICellRange.getSurrounding} */
        getSurrounding(options?: ICellRange.GetSurroundingOptions): this;
        /** {@inheritDoc ICellRange.getExtended} */
        getExtended(direction: IRange.Direction, cell?: ICell.Address): this;
        /** {@inheritDoc ICellRange.getEntireRows} */
        getEntireRows(shift?: boolean, options?: ICellRange.GetRangeOptions): this;
        /** {@inheritDoc ICellRange.getEntireColumns} */
        getEntireColumns(shift?: boolean, options?: ICellRange.GetRangeOptions): this;
        /** {@inheritDoc ICellRange.getRowHeaders} */
        getRowHeaders(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
        /** {@inheritDoc ICellRange.getColumnHeaders} */
        getColumnHeaders(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
        /** {@inheritDoc ICellRange.getDifferences} */
        getDifferences(address: ICellRange.Address, options?: ICellRange.GetRangeOptions): ICellRanges | null;
        /** {@inheritDoc ICellRange.getIntersect} */
        getIntersect(address?: ICellRange.Address, options?: ICellRange.GetRangeOptions): this;
        /** {@inheritDoc ICellRange.getUnion} */
        getUnion(address?: ICellRange.Address, options?: ICellRange.GetRangeOptions): this;
        /** {@inheritDoc ICellRange.getResizeTo} */
        getResizeTo(rowCount: number, colCount: number, options?: ICellRange.GetRangeOptions): this;
        /** {@inheritDoc ICellRange.getResizeBy} */
        getResizeBy(rowDelta: number, colDelta: number, options?: ICellRange.GetRangeOptions): this;
        /** {@inheritDoc ICellRange.getOffsetTo} */
        getOffsetTo(rowIndex: number, colIndex: number, options?: ICellRange.GetRangeOptions): this;
        /** {@inheritDoc ICellRange.getOffsetBy} */
        getOffsetBy(rowDelta: number, colDelta: number, options?: ICellRange.GetRangeOptions): this;
        /** {@inheritDoc ICellRange.getUsedRange} */
        getUsedRange(options?: ICellRange.GetRangeOptions): this;
        /** {@inheritDoc ICellRange.isEmpty} */
        isEmpty(): boolean;
        /** {@inheritDoc ICellRange.getColumnStart} */
        getColumnStart(): number;
        /** {@inheritDoc ICellRange.getRowStart} */
        getRowStart(): number;
        /** {@inheritDoc ICellRange.getColumnEnd} */
        getColumnEnd(): number;
        /** {@inheritDoc ICellRange.getRowEnd} */
        getRowEnd(): number;
        /** {@inheritDoc ICellRange.getColumnCount} */
        getColumnCount(): number;
        /** {@inheritDoc ICellRange.getRowCount} */
        getRowCount(): number;
        /** {@inheritDoc ICellRange.getVisible} */
        getVisible(options?: ICellRange.GetVisibleOptions): ICellRanges | null;
        /** {@inheritDoc ICellRange.isContentful} */
        isContentful(types?: ICell.Content | ICell.Content[]): boolean;
        /** {@inheritDoc ICellRange.getCounts} */
        getCounts(types?: ICell.Content[]): ICellRange.Counts | null;
        /** {@inheritDoc ICellRange.getCount} */
        getCount(type?: ICell.Content): number;
        /** {@inheritDoc ICellRange.isEntireRows} */
        isEntireRows(): boolean;
        /** {@inheritDoc ICellRange.isEntireColumns} */
        isEntireColumns(): boolean;
        /** {@inheritDoc ICellRange.isEntireRange} */
        isEntireRange(): boolean;
        /** {@inheritDoc ICellRange.getWidth} */
        getWidth(): number;
        /** {@inheritDoc ICellRange.getHeight} */
        getHeight(): number;
        /** {@inheritDoc ICellRange.size} */
        get size(): number;
        /** {@inheritDoc ICellRange.getBounds} */
        getBounds(): any;
        /** {@inheritDoc ICellRange.isInvalid} */
        isInvalid(): boolean;
        /** {@inheritDoc ICellRange.getDefaultShiftOrientation} */
        getDefaultShiftOrientation(): IRange.Orientation;
        /** {@inheritDoc ICellRange.getDefaultSortCriteria} */
        getDefaultSortCriteria(orientation?: IRange.Orientation, cell?: ICell.Address): ISort.DefaultSortCriteria | null;
        /** {@inheritDoc ICellRange.getMerges} */
        getMerges(): IRange.Coords[];
        /** {@inheritDoc ICellRange.getSnapshot} */
        getSnapshot(options?: ICellRange.CopyOptions): ICellRange.ISnapshot;
        /** {@inheritDoc ICellRange.isReadOnly} */
        isReadOnly(): boolean;
        /** {@inheritDoc ICellRange.addListener} */
        addListener2(listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
        /** {@inheritDoc ICellRange.addListener} */
        addListener(listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
        /** {@inheritDoc ICellRange.getSheet} */
        getSheet(): ISheet;
        /** {@inheritDoc ICellRange.autoFill} */
        autoFill(destination: ICellRange.Address, options?: ICellRange.AutoFillOptions): this;
        /** {@inheritDoc ICellRange.autoFit} */
        autoFit(options?: ICellRange.AutoFitOptions): this;
        /** {@inheritDoc ICellRange.clear} */
        clear(applyTo?: ICell.Content, options?: ITransaction.OperationOptions): this;
        /** {@inheritDoc ICellRange.setHyperlink} */
        setHyperlink(hyperlink: IHyperlink.Update, options?: ITransaction.OperationOptions): this;
        /** {@inheritDoc ICellRange.setComments} */
        setComments(comments: IComment.Properties, options?: ITransaction.OperationOptions): this;
        /** {@inheritDoc ICellRange.getStyle} */
        getStyle(): IStyle;
        /** {@inheritDoc ICellRange.merge} */
        merge(options?: IRange.Orientations | ICellRange.MergeOptions): this;
        /** {@inheritDoc ICellRange.unmerge} */
        unmerge(options?: ITransaction.OperationOptions): this;
        /** {@inheritDoc ICellRange.insert} */
        insert(options?: IRange.Orientation | ICellRange.InsertOptions): this;
        /** {@inheritDoc ICellRange.insertFrom} */
        insertFrom(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions): Promise<this | null>;
        /** {@inheritDoc ICellRange.copyFrom} */
        copyFrom(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions): Promise<this | null>;
        /** {@inheritDoc ICellRange.delete} */
        delete(options?: IRange.Orientation | ICellRange.DeleteOptions): this;
        /** {@inheritDoc ICellRange.sort} */
        sort(options?: boolean | (ISort.RangeOptions & ITransaction.OperationOptions)): this;
        /** {@inheritDoc ICellRange.doBatch} */
        doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ITransaction.OperationOptions): Promise<R> | R;
        /** {@inheritDoc ICellRange.startIncrementalUpdates} */
        startIncrementalUpdates(options?: ICellRange.StartUpdateOptions): ICellRange.IncrementalUpdater;
        /** {@inheritDoc ICellRange.getA1} */
        getA1(): string;
        get [Symbol.toStringTag](): string;
        /** {@inheritDoc ICellRange.toString} */
        toString(): string;
        /** {@inheritDoc ICellRange.isICellRange} */
        get isICellRange(): true;
    }
}
declare module "workbook/WorkbookRanges" {
    import { IRange } from '@sheetxl/primitives';
    import { IListener } from "listener/index";
    import { ICellRange, ICellRanges } from "cellRange/index";
    import { IWorkbook } from "workbook/IWorkbook";
    import { SheetRanges, SheetRangesOptions } from "sheet/SheetRanges";
    export interface WorkbookRangesOptions extends SheetRangesOptions {
    }
    /**
     * Extends ICellRanges to have a sheet scope and to allow individual ranges to be on different sheets.
     */
    export class WorkbookRanges extends SheetRanges implements ICellRanges {
        protected _workbook: IWorkbook;
        constructor(coords: readonly IRange.FixableCoords[], sheet: any, workbook: IWorkbook, options: WorkbookRangesOptions);
        /** {@inheritDoc ICellRange.getSource} */
        getSource<S>(): S;
        protected _createRanges(coords: readonly IRange.Coords[], getOptions?: ICellRange.GetRangeOptions): this;
        protected _createRange(coords: Readonly<IRange.FixableCoords>, getOptions?: ICellRange.GetRangeOptions): ICellRange;
        /** {@inheritDoc ICellRanges.select} */
        select(options?: ICellRange.SelectOptions): Promise<this>;
        /** {@inheritDoc ICellRanges.addListener} */
        addListener(listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
        get [Symbol.toStringTag](): string;
        /** {@inheritDoc ICellRanges.toString} */
        toString(): string;
    }
}
declare module "workbook/WorkbookRange" {
    import { IRange } from '@sheetxl/primitives';
    import { IListener } from "listener/index";
    import { ICellRange, ICellRanges } from "cellRange/index";
    import { IWorkbook } from "workbook/IWorkbook";
    import { SheetRange, SheetRangeOptions } from "sheet/SheetRange";
    export interface WorkbookRangeOptions extends SheetRangeOptions {
    }
    /**
     * Extends I SheetRanges to have a sheet scope and to allow individual ranges to be on different sheets.
     */
    export class WorkbookRange extends SheetRange implements ICellRange {
        protected _workbook: IWorkbook;
        constructor(coords: IRange.FixableCoords, sheet: any, workbook: IWorkbook, options: WorkbookRangeOptions);
        protected _createRanges(coords: readonly IRange.FixableCoords[], getOptions?: ICellRange.GetRangeOptions): ICellRanges;
        protected _createRange(coords: Readonly<IRange.FixableCoords>, getOptions?: ICellRange.GetRangeOptions): this;
        /** {@inheritDoc ICellRange.addListener} */
        addListener(listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
        get [Symbol.toStringTag](): string;
        /** {@inheritDoc ICellRange.toString} */
        toString(): string;
    }
}
declare module "workbook/Workbook" {
    import type { IRange } from '@sheetxl/primitives';
    import { type ITransaction } from "transaction/index";
    import type { IListener } from "listener/index";
    import type { INamedCollection } from "named/index";
    import { ICalculation } from "calculation/index";
    import { type IScript, type IModule } from "script/index";
    import { type IResourceCollection } from "resource/index";
    import { type IStringCollection } from "string/index";
    import { type ITheme } from "theme/index";
    import { type ICell } from "cell/index";
    import { ICellRange, ICellRanges } from "cellRange/index";
    import { type IStyleCollection } from "style/index";
    import { ISheet, type ISheetCollection } from "sheet/index";
    import { type IWorkbookView } from "workbook/view/index";
    import { type IWorkbook } from "workbook/IWorkbook";
    import { type IWorkbookProtection } from "workbook/protection/index";
    import { ListenerEmitter } from "listener/ListenerEmitter";
    import { WorkbookProtection } from "workbook/protection/WorkbookProtection";
    /**
     * The reference to a sheet with in a workbook.
     * These are used for finding sheet and determining
     * it's location/visibility within a workbook.
     */
    interface SheetRef {
        /**
         * This is a unique id for the sheet.
         * Note - It is not the index and will not change if the sheet order is adjusted
         */
        id: number;
        /**
         * The display name of the sheet
         */
        name: string;
        /**
         * @defaultValue ISheet.Visibility.Visible
         */
        visibility: ISheet.Visibility;
        /**
         * The sheet model
         */
        sheet: ISheet;
    }
    type SheetKey = ISheet | SheetRef | string | number;
    interface State {
        sheetRefsAll: SheetRef[];
        sheetRefsVisibleAndHidden: SheetRef[];
        sheetRefsVisible: SheetRef[];
        refsById: Map<number, SheetRef>;
        sheetsById: Map<number, ISheet>;
        refsByLowerCaseName: Map<string, SheetRef>;
        sheetsByLowerCaseName: Map<string, ISheet>;
        refsByInstance: Map<ISheet, SheetRef>;
        lastId: number;
        sheetsCreated: Set<ISheet>;
        listenersSheets: Map<number, IListener.Remove>;
        name: string | null;
    }
    interface InternalCreateSheet {
        (
        /**
         * The id of the sheet being created.
         */
        id: number, 
        /**
         * The name of the new  sheet.
         */
        name: string, 
        /**
         * @defaultValue - ISheet.Visibility.Visible
         */
        visibility: ISheet.Visibility, 
        /**
         * The location of the sheet.
         * @defaultValue - End of sheets
         */
        index: number, 
        /**
         * The JSON representation of the sheet.
         */
        json: ISheet.JSON): ISheet;
    }
    /**
     * The Base implementation of {@link IWorkbook}.
     */
    export class Workbook implements IWorkbook {
        protected _options: IWorkbook.ConstructorOptions;
        protected _createSheet: InternalCreateSheet;
        protected _createSheetName: (id: number) => string;
        protected _transactions: ITransaction.IStore;
        protected _ownTransactions: boolean;
        protected _transactionsRemoveListener: IListener.Remove;
        protected _lastTransactionUUID: string;
        protected _starting: Promise<void>;
        protected _closed: boolean;
        protected _initializing: boolean;
        protected _emitter: ListenerEmitter<IWorkbook, IWorkbook.IListeners>;
        protected _scripts: IScript;
        protected _theme: ITheme;
        protected _strings: IStringCollection;
        protected _ownStrings: boolean;
        protected _styles: IStyleCollection;
        protected _ownStyles: boolean;
        protected _resources: IResourceCollection;
        protected _ownResources: boolean;
        protected _names: INamedCollection;
        protected _ownNames: boolean;
        protected _calculation: ICalculation;
        protected _ownsCalculation: boolean;
        protected _view: IWorkbookView;
        protected _activeSheetOffset: number;
        protected _sheets: ISheetCollection;
        protected _sheetOnNameChange: Map<number, () => void>;
        protected _sheetOnVisibilityChange: Map<number, () => void>;
        protected _sheetOnIndexChange: Map<number, () => void>;
        protected _protection: WorkbookProtection;
        protected _listenerProtection: IListener.Remove;
        protected _listenerWorkbookView: IListener.Remove;
        protected _isDate1904: boolean;
        constructor(options?: IWorkbook.ConstructorOptions);
        protected _initState(): void;
        /** {@inheritDoc IWorkbook.getName} */
        getName(): string | null;
        /** {@inheritDoc IWorkbook.setName} */
        setName(name: string | null): IWorkbook;
        /** {@inheritDoc IWorkbook.getView} */
        getView(): IWorkbookView;
        /** {@inheritDoc IWorkbook.setView} */
        setView(view: IWorkbookView): this;
        /** {@inheritDoc IWorkbook.isDate1904} */
        isDate1904(): boolean;
        /** {@inheritDoc IWorkbook.setDate1904} */
        setDate1904(date1904: boolean): this;
        /** {@inheritDoc IWorkbook.getStyles} */
        getStyles(): IStyleCollection;
        /** {@inheritDoc IWorkbook.getResources} */
        getResources(): IResourceCollection;
        /** {@inheritDoc IWorkbook.getTransactions} */
        getTransactions(): ITransaction.IStore;
        /** {@inheritDoc IWorkbook.getStrings} */
        getStrings(): IStringCollection;
        /** {@inheritDoc IWorkbook.getTheme} */
        getTheme(): ITheme;
        /** {@inheritDoc IWorkbook.setTheme} */
        setTheme(theme: ITheme): ITheme;
        /** {@inheritDoc IWorkbook.getSelectedSheetIndex} */
        getSelectedSheetIndex(): number;
        /** {@inheritDoc IWorkbook.getSelectedSheet} */
        getSelectedSheet(): ISheet;
        /** {@inheritDoc IWorkbook.getSheet} */
        getSheet(name: string, visibility?: ISheet.Visibility): ISheet;
        /** {@inheritDoc IWorkbook.getSheetAt} */
        getSheetAt(index: number, visibility?: ISheet.Visibility): ISheet;
        /** {@inheritDoc IWorkbook.getSheets} */
        getSheets(): ISheetCollection;
        /** {@inheritDoc IWorkbook.addSheet} */
        addSheet(options?: ISheetCollection.AddOptions | string | number): ISheet;
        protected _getSheets(visibility?: ISheet.Visibility): ISheet[];
        protected _getSheetRefs(visibility?: ISheet.Visibility): SheetRef[];
        /** @internal */
        protected _getSheetRef(key: SheetKey, visibility?: ISheet.Visibility): SheetRef;
        /** @internal */
        protected _validateNewSheetName(sheetName: string, checkDuplicates?: boolean): string;
        /** {@inheritDoc IWorkbook.findValidSheetName} */
        findValidSheetName(str: string): string;
        /** {@inheritDoc IWorkbook.isValidSheetNameCharacter} */
        isValidSheetNameCharacter(character: string): boolean;
        /** @internal */
        protected _addSheetOptions(options?: ISheetCollection.AddOptions | string | number): ISheet;
        /** @internal */
        protected _nextSheetName(sheetName?: string): string;
        /** @internal */
        protected _addSheet(notify: boolean, sheetName?: string, index?: number): ISheet;
        /** @internal */
        protected _updateSheetRefStates(sheetRefs: SheetRef[]): void;
        /** @internal */
        protected _addSheetRef(sheetRefAdd: SheetRef, index?: number): SheetRef;
        /** @internal */
        protected _adjustRemoveSelectionIfRequired(indexRemove: number, id: number): void;
        /** @internal */
        protected _adjustSheetNamesIfRequired(): void;
        /** @internal */
        protected _validateDeleteSheet(key: SheetKey): void;
        /** @internal */
        protected _findOffsetForId(id: number, refs: SheetRef[]): number;
        /** {@inheritDoc IWorkbook.find} */
        find(options: string | ICellRange.FindOptions): Iterator<ICell>;
        /** {@inheritDoc IWorkbook.replace} */
        replace(cells: Iterator<ICell>, replace: ICell.Update | ((original: ICell) => ICell.Update), options?: IWorkbook.ReplaceOptions): IWorkbook.ReplaceResults;
        /** @internal */
        protected _nextSheetIndex(index: number, refs?: SheetRef[]): number;
        /** @internal */
        protected _prevSheetIndex(index: number, refs?: SheetRef[]): number;
        /** {@inheritDoc IWorkbook.getNextSheet} */
        getNextSheet(index: number): ISheet;
        /** {@inheritDoc IWorkbook.getPreviousSheet} */
        getPreviousSheet(index: number): ISheet;
        /** @internal */
        protected _duplicateSheet(key?: SheetKey): Promise<ISheet>;
        /** @internal */
        protected _createRange(coords: IRange.FixableCoords, getOptions?: ICellRange.GetRangeOptions): ICellRange;
        /** @internal */
        protected _createRanges(coords: IRange.FixableCoords[], getOptions?: ICellRange.GetRangeOptions): ICellRanges;
        /** {@inheritDoc IWorkbook.getRange} */
        getRange(address: ICellRange.Address, options?: ICellRange.GetRangeOptions): ICellRange;
        /** {@inheritDoc IWorkbook.getRanges} */
        getRanges(address: ICellRanges.Address, options?: ICellRange.GetRangeOptions): ICellRanges;
        /** @internal */
        protected _activeRangeCoords(): IRange.FixableCoords[];
        /** {@inheritDoc IWorkbook.getSelectedRange} */
        getSelectedRange(options?: ICellRange.GetRangeOptions): ICellRange;
        /** {@inheritDoc IWorkbook.getSelectedRanges} */
        getSelectedRanges(options?: ICellRange.GetRangeOptions): ICellRanges;
        /** {@inheritDoc IWorkbook.getSelectedCell} */
        getSelectedCell(): ICell;
        /** @internal */
        protected _rangesAddressToCoords(address: ICellRanges.Address, performLookup?: boolean, visibility?: ISheet.Visibility): IRange.FixableCoords[];
        /** @internal */
        protected _validateCoords(coords: IRange.FixableCoords, visibility?: ISheet.Visibility, oobMessage?: string): void;
        /** @internal */
        protected _updateSheetRef(refOriginal: SheetRef, refNew: SheetRef): SheetRef;
        /**
         * Fires onSheetsChange
         * @internal
         */
        protected _setSheetName(key: SheetKey, sheetName: string): ISheet;
        /**
         * Fires onSheetsChange
         * @internal
         */
        protected _setSheetVisibility(key: SheetKey, visibility?: ISheet.Visibility): ISheet;
        /** @internal */
        protected _moveSheet(ref: SheetRef, indexTo: number): ISheet;
        /** @internal */
        protected _setSelectedSheet(key: SheetKey): ISheet;
        /** {@inheritDoc IWorkbook.getProtection} */
        getProtection(): IWorkbookProtection;
        /** {@inheritDoc IWorkbook.getNames} */
        getNames(): INamedCollection;
        /** {@inheritDoc IWorkbook.getCalculation} */
        getCalculation(): ICalculation;
        /** {@inheritDoc IWorkbook.getScripts} */
        getScripts(): IScript;
        /** @internal */
        protected _notifyAllChange(): void;
        /** {@inheritDoc IWorkbook.addListeners} */
        addListeners(listeners: IWorkbook.IListeners, options?: IListener.Options): IListener.Remove;
        /** @internal */
        protected _sheetToWBEvent(listenerWB: ICellRange.Listener): ICellRange.Listener;
        /** @internal */
        protected _fromJSON(json: IWorkbook.JSON): void;
        /** @internal */
        protected _createScripts(json?: Record<string, IModule.JSON>): IScript;
        /** {@inheritDoc IWorkbook.toJSON} */
        toJSON(ignoreData?: boolean): Promise<IWorkbook.JSON>;
        /** {@inheritDoc IWorkbook.isClosed} */
        isClosed(): boolean;
        /** {@inheritDoc IWorkbook.close} */
        close(): void;
        /** {@inheritDoc ITransaction.ITransactional.beginCommit} */
        beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
        /** {@inheritDoc ITransaction.ITransactional.doBatch} */
        doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ITransaction.OperationOptions): R | Promise<R>;
        /** @internal */
        protected _beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
        /** @internal */
        protected _getState(): State;
        /** @internal */
        protected _updateState(updateState?: Readonly<Partial<State>> | ((prev: Readonly<State>) => Readonly<State>), description?: string): void;
        /** {@inheritDoc IWorkbook.options} */
        get options(): IWorkbook.ConstructorOptions;
        get [Symbol.toStringTag](): string;
        toString(): string;
        /** {@inheritDoc IWorkbook.isIWorkbook} */
        get isIWorkbook(): true;
    }
}
declare module "workbook/index" {
    export * from "workbook/protection/index";
    export * from "workbook/view/index";
    export * from "workbook/IWorkbook";
    export * from "workbook/Workbook";
}
declare module "print/IPrint" {
    import type { ITypes } from "type/index";
    /**
     * Namespace for print-related configurations and settings.
     */
    export namespace IPrint {
        /**
         * Interface representing multi-page print options.
         */
        interface MultiPage {
            /**
             * Whether content should be aligned with the page margins.
             */
            alignWithMargins?: boolean;
            /**
             * Specifies if the first page is different from subsequent pages.
             */
            differentFirst?: boolean;
            /**
             * Specifies if odd and even pages should have different settings.
             */
            differentOddEven?: boolean;
            /**
             * Whether the content should scale proportionally with the document.
             */
            scaleWithDoc?: boolean;
        }
        /**
         * Interface for configuring headers and footers for print, supporting
         * different settings for first, odd, and even pages.
         */
        interface HeaderFooter extends MultiPage {
            /**
             * Configuration for general header and footer settings.
             */
            headerFooter?: MultiPage;
            /**
             * Configuration for the footer on even pages.
             */
            evenFooter?: MultiPage;
            /**
             * Configuration for the header on even pages.
             */
            evenHeader?: MultiPage;
            /**
             * Configuration for the footer on the first page.
             */
            firstFooter?: MultiPage;
            /**
             * Configuration for the header on the first page.
             */
            firstHeader?: MultiPage;
            /**
             * Configuration for the footer on odd pages.
             */
            oddFooter?: MultiPage;
            /**
             * Configuration for the header on odd pages.
             */
            oddHeader?: MultiPage;
        }
        /**
         * Interface representing the margins of a printed page, specified in inches.
         */
        interface PageMargin {
            /**
             * Margin from the bottom of the page.
             */
            bottom?: number;
            /**
             * Distance of the footer from the bottom of the page.
             */
            footer: number;
            /**
             * Distance of the header from the top of the page.
             */
            header: number;
            /**
             * Margin from the left side of the page.
             */
            left: number;
            /**
             * Margin from the right side of the page.
             */
            right: number;
            /**
             * Margin from the top of the page.
             */
            top: number;
        }
        /**
         * Interface for configuring page setup options for print.
         */
        interface PageSetup {
            /**
             * Whether to print in black and white.
             */
            blackAndWhite?: boolean;
            /**
             * Specifies how cell comments are printed.
             * @see {@link https://c-rex.net/samples/ooxml/e1/Part4/OOXML_P4_DOCX_ST_CellComments_topic_ID0EXMDFB.html#topic_ID0EXMDFB}
             */
            cellComments?: string;
            /**
             * The number of copies to print.
             */
            copies?: number;
            /**
             * Whether to print in draft mode for quicker printing.
             */
            draft?: boolean;
            /**
             * Specifies how errors should be displayed in the print.
             * @see {@link https://c-rex.net/samples/ooxml/e1/Part4/OOXML_P4_DOCX_ST_PrintError_topic_ID0EUTTFB.html#topic_ID0EUTTFB}
             */
            errors?: string;
            /**
             * The page number to start printing from.
             */
            firstPageNumber?: number;
            /**
             * The number of pages to fit vertically.
             */
            fitToHeight?: number;
            /**
             * The number of pages to fit horizontally.
             */
            fitToWidth?: number;
            /**
             * The horizontal DPI (dots per inch) for printing.
             */
            horizontalDpi?: number;
            /**
             * The orientation of the page (portrait or landscape).
             * @see
             * {@link https://c-rex.net/samples/ooxml/e1/Part4/OOXML_P4_DOCX_ST_Orientation_topic_ID0E4XPFB.html#topic_ID0E4XPFB}
             */
            orientation?: string;
            /**
             * Specifies the order of pages when printed.
             * @see
             * {@link https://c-rex.net/samples/ooxml/e1/Part4/OOXML_P4_DOCX_ST_PageOrder_topic_ID0EN5PFB.html#topic_ID0EN5PFB}
             */
            pageOrder?: string;
            /**
             * Specifies the paper size for printing (enum values 1-68).
             * @see
             * {@link https://c-rex.net/samples/ooxml/e1/Part4/OOXML_P4_DOCX_pageSetup_topic_ID0EHZ54.html#topic_ID0EHZ54}
             */
            paperSize?: number;
            /**
             * Specifies the scaling factor for printing (between 10 and 400).
             */
            scale?: number;
            /**
             * Whether to use the first page number specified in `firstPageNumber`.
             */
            useFirstPageNumber?: boolean;
            /**
             * Whether to use the printer's default settings for the print job.
             */
            usePrinterDefaults?: boolean;
            /**
             * The vertical DPI (dots per inch) for printing.
             */
            verticalDpi?: number;
        }
        /**
         * Interface for additional properties of page setup,
         * such as auto page breaks and fitting content to a page.
         */
        interface PageSetUpProperties {
            /**
             * Whether to automatically break pages when content overflows.
             */
            autoPageBreak?: boolean;
            /**
             * Whether content should fit to a single page when printed.
             */
            fitToPage?: boolean;
        }
        /**
         * Interface for configuring print options, such as grid lines
         * and content alignment.
         */
        interface PrintOptions {
            /**
             * Whether to print grid lines on the sheet.
             */
            gridLines?: boolean;
            /**
             * Whether grid lines are explicitly set for printing.
             */
            gridLinesSet?: boolean;
            /**
             * Whether to print row and column headings.
             */
            headings?: boolean;
            /**
             * Whether content should be horizontally centered on the page.
             */
            horizontalCentered?: boolean;
            /**
             * Whether content should be vertically centered on the page.
             */
            verticalCentered?: boolean;
        }
        /**
         * Interface for outline properties used in print, such as
         * the summary position and style application.
         */
        interface OutlineProperties {
            /**
             * Whether to apply styles to outline symbols.
             */
            applyStyles?: boolean;
            /**
             * Whether to display outline symbols in the print.
             */
            showOutlineSymbols?: boolean;
            /**
             * Whether the summary rows are displayed below the details.
             */
            summaryBelow?: boolean;
            /**
             * Whether the summary columns are displayed to the right of the details.
             */
            summaryRight?: boolean;
        }
        type Break = ITypes.RunCoordValue<{
            man?: boolean;
            pt?: boolean;
        }>;
    }
}
declare module "print/index" {
    export * from "print/IPrint";
}
declare module "sheet/ICellContainerOptions" {
    import type { ITransaction } from "transaction/index";
    import type { IResourceCollection } from "resource/index";
    import type { IStringCollection } from "string/index";
    import type { ICellRange } from "cellRange/index";
    import type { INamedCollection } from "named/index";
    import type { IStyleCollection } from "style/index";
    import type { ICalculation } from "calculation/index";
    import type { IWorkbook } from "workbook/index";
    /**
     * Contains a set of resources that can be shared across multiple cell containers.
     *
     * @remarks
     * Used by both workbooks and sheets.
     */
    export interface ICellContainerOptions {
        /**
         * Option to provide shared strings.
         */
        strings?: IStringCollection;
        /**
         * Option to provide a shared StyleCollection. If not provided then a new StyleCollection with default theming will be used.
         */
        styles?: IStyleCollection;
        /**
         * Option to provide shared resources.
         */
        resources?: IResourceCollection;
        /**
         * Option to provide shared names.
         *
         * @remarks
         * This is not the interface because we want the instance that allows
         * for adding items other than named ranges.
         */
        names?: INamedCollection;
        /**
         * Option to provide a custom calculation.
         */
        calculation?: ICalculation;
        /**
         * If the parent has a workbook
         */
        workbook?: IWorkbook;
        /**
         * The store for all state changes. This is provided to enable versioning, undo/redo, distributed editing, etc.
         *
         * @remarks
         * If not specified then an internal {@link ITransaction.IStore} will be created.
         */
        transactions?: ITransaction.IStore;
        /**
         * Allows for address to be resolved in custom ways.
         *
         * @remarks
         * * This should return `null` if unresolvable but only throw and error if it is identified a a parsing error.
         * * This is used by `INamedCollection` to created named ranges.
         */
        resolveRange?: (address?: ICellRange.Address) => ICellRange | null;
        /**
         * Determine if dates should be 1904 or 1900 based.
         *
         * @defaultValue false
         */
        date1904?: boolean;
        /**
         * If `true` then the model is readonly and cannot be save.
         *
         * @defaultValue false
         *
         * @remarks
         * Useful when you want to load a model for viewing only and prevent any accidental changes.
         */
        readonly?: boolean;
    }
}
declare module "sheet/ISheet" {
    import type { IRange, IRichData } from '@sheetxl/primitives';
    import type { Bounds } from '@sheetxl/utils';
    import type { ITypes } from "type/index";
    import type { ITransaction } from "transaction/index";
    import type { Tuple } from "collections/index";
    import type { IWorkbook } from "workbook/index";
    import type { IResourceCollection, IResource } from "resource/index";
    import type { IStringCollection } from "string/index";
    import type { IComment } from "comment/index";
    import type { IPrint } from "print/index";
    import type { IColor } from "color/index";
    import type { IListener } from "listener/index";
    import type { IAutoSort } from "sort/index";
    import type { IAutoFilter } from "filter/index";
    import type { IHyperlink } from "hyperlink/index";
    import type { IMovable, IMovableCollection } from "movable/index";
    import type { ICell, ICellHeader } from "cell/index";
    import type { ICellRange, ICellRanges } from "cellRange/index";
    import type { IStyleCollection } from "style/index";
    import type { ITableCollection, ITable } from "table/index";
    import type { INamedCollection } from "named/index";
    import type { ICalculation } from "calculation/index";
    import type { IRangeSelection } from "selection/index";
    import type { ISheetView } from "sheet/view/index";
    import type { ISheetHeader } from "sheet/header/index";
    import type { ISheetProtection } from "sheet/protection/index";
    import type { ICellContainerOptions } from "sheet/ICellContainerOptions";
    import type { IConditionalFormat } from "conditional/IConditionalFormat";
    /**
     * An `ISheet` represents a collection of elements (such as {@link ICellRange | ranges},
     * {@link ITable | tables}, etc) contained within and visualized through a {@link ISheetView | view}.
     *
     * This interface provides methods for accessing its elements and event handling.
     *
     * Most interactions with a {@link ISheet | sheet} are done using either a {@link ICellRange | range} or {@link ICellRanges | ranges}.
     *
     * @remarks
     * While a {@link ISheet | sheet} can be used stand-alone it is typically used within the context of a {@link IWorkbook | workbook}.
     *
     * ### **Key Methods**
     *
     * * {@link ISheet.getRange} - For interacting with {@link ICell | cells} and {@link Scalar | values} and formatting.
     * * {@link ISheet.getTables} - For managing {@link ITable | tables}.
     * * {@link ISheet.getView} - For non-data related properties such as selection or frozen headers.
     * * {@link IWorkbook} - For working with collections of `ISheets`.
     */
    export interface ISheet extends ITransaction.ITransactional, IListener.ISource<ISheet, ISheet.IListeners> {
        /**
         * Returns an {@link ICellRange} used to interact with a
         * a rectangular 2D collection of cells at a specific range.
         *
         * @param address Address of the ranges.
         * @param options Options for the ranges.
         */
        getRange(address: ICellRange.Address, options?: ICellRange.GetRangeOptions): ICellRange;
        /**
         * Returns a {@link ICell} at the specified address.
         *
         * @param address Address of the cell.
            */
        getCell(address: ICell.Address): ICell;
        /**
         * Returns an {@link ICellRanges}. An {@link ICellRanges} is an ordered list of
         * {@link ICellRange}s. These are used to interact with a set of contiguous 2D ranges.
         *
         * @param address Address of the ranges.
         * @param options Options for the ranges.
         */
        getRanges(address: ICellRanges.Address, options?: ICellRange.GetRangeOptions): ICellRanges;
        /**
         * Returns the range for the entire sheet.
         *
         * @see
         * {@link ICellRange}
         */
        getEntireRange(options?: ICellRange.GetRangeOptions): ICellRange;
        /**
         * Returns the smallest range within the sheet that contains any used cells.
         * @see
         * {@link ICellRange.getUsedRange}
         */
        getUsedRange(options?: ICellRange.GetRangeOptions): ICellRange;
        /**
         * Returns the current selection.
         *
         * @remarks
         * This allows for listening to selection changes and advanced navigation.
         */
        getSelection(): IRangeSelection;
        /**
         * Returns the selected cell.
         */
        getSelectedCell(): ICell;
        /**
         * Returns a range of cells for the current selection.
         *
         * @see
         * {@link ICellRange}
         */
        getSelectedRange(options?: ICellRange.GetRangeOptions): ICellRange;
        /**
         * Returns ranges of cells for the current selection.
         */
        getSelectedRanges(options?: ICellRange.GetRangeOptions): ICellRanges;
        /**
         * Returns an iterator of ICells that match the results.
         *
         * @param options This is either a search string or {@link ICellRange.FindOptions}.
         *
         * @remarks
         * This is the equivalent of `getEntireRange().find`.
         * @see
         * {@link ICellRange.find}
         */
        find(options: string | ICellRange.FindOptions): Iterator<ICell>;
        /**
         * Enable and return an {@link IAutoFilter}.
         *
         * @remarks
         * Only one {@link IAutoFilter} is allowed so this will
         * return the same instance if it has already been created.
         */
        insertFilter(address?: ICellRange.Address): IAutoFilter;
        /**
         * Enable and return an {@link IAutoSort}.
         *
         * @remarks
         * Only one {@link IAutoFilter} is supported so this will
         * return the same instance if it has already been created.
         */
        insertSort(address?: ICellRange.Address): IAutoSort;
        /**
         * Returns the {@link IAutoFilter} created using {@link insertFilter}.
         *
         * @returns The current filter or `null` if there is no filter.
         */
        getFilter(): IAutoFilter | null;
        /**
         * Returns the {@link IAutoSort} created using {@link insertSort}.
         *
         * @returns The current sort or `null` if there is no sort.
         */
        getSort(): IAutoSort | null;
        /**
         * Returns a collection of tables that are embedded in this sheet.
         */
        getTables(): ITableCollection;
        /**
         * Returns a collection of movables that are embedded in this sheet.
         */
        getMovables(): IMovableCollection;
        /**
         * Returns the row headers managed by the sheet.
         */
        getRowHeaders(): ISheetHeader;
        /**
         * Returns the column headers managed by the sheet.
         */
        getColumnHeaders(): ISheetHeader;
        /**
         * Return a custom color or `null` if no custom color has been set.
         *
         * @defaultValue null
         */
        getTabColor(): IColor;
        /**
         * See the tab color for the sheet.
         *
         * @param color The color
         *
         * @remarks
         * * If set to `null` the color will revert to the default.
         * * The tab color is not used by the sheet but rather by the workbook.
         */
        setTabColor(color: IColor | string | null): this;
        /**
         * Returns the sheet protection.
         */
        getProtection(): ISheetProtection;
        /**
         * Returns the current view settings
         * View settings determine how the sheet is displayed and interacted with (e.g., frozen panes, zoom level, selection) but do not affect the underlying data itself.
         *
         * @returns The {@link ISheetView} object representing the current view settings.
         */
        getView(): ISheetView;
        /**
         * Set a specific view.
         *
         * @param view The view properties.
         */
        setView(view: ISheetView): this;
        /**
         * Returns `IStyleCollection` associated with this sheet.
         */
        getStyles(): IStyleCollection;
        /**
         * Returns the current shared resources.
         */
        getResources(): IResourceCollection;
        /**
         * Returns the current shared resources.
         */
        getStrings(): IStringCollection;
        /**
         * Returns the current shared resources.
         */
        getTransactions(): ITransaction.IStore;
        /**
         * Indicates if the sheet is using 1904 dates.
         *
         * @remarks
         * This can not be set on the `ISheet`. This is managed by the sheet's container.
         */
        isDate1904(): boolean;
        /**
         * Returns the column width as a font unit.
         *
         * This is used as an informative tooltip.
         *
         * @param pixelWidth
         *
         * @see
         * * {@link https://docs.microsoft.com/en-us/office/troubleshoot/excel/determine-column-widths}
         * * {@link https://www.ablebits.com/office-addins-blog/change-autofit-column-width-excel/}
         */
        getColumnWidthAsFontUnit(pixelWidth: number): number;
        /**
         * Returns the {@link ICellRange | range} for a given pixel bounds.
         *
         * @param bounds
         */
        getRangeAtBounds(bounds: Bounds, options?: ICellRange.GetRangeOptions): ICellRange;
        /**
         * Creates a cell that is not including at a coordinate but adopts all rendering.
         *
         * Useful for previewing values such as tooltip. If the coords are passed it will return
         * a disconnect cell update for that value.
      
         * @param update Cell Update
         * @param coords Optional CellCoord
         * @returns A detached ICell
         *
         * @remarks
         * Does not add to the sheet but provides a standalone ICell.
         */
        createTemporaryCell(update: ICell.Update, coords?: IRange.FixableCellCoords): ICell;
        /**
         * Add Listeners.
         *
         * @see
         * {@link IListener.ISource.addListeners}
         */
        addListeners(listeners: ISheet.IListeners, options?: IListener.Options): IListener.Remove;
        /**
         * Returns the display name for the sheet.
         */
        getName(): string;
        /**
         * Set the display name for the sheet.
         */
        setName(name: string): ISheet;
        /**
         * Returns the visibility of the sheet.
         */
        getVisibility(): ISheet.Visibility;
        /**
         * Change the visibility of the sheet.
         *
         * @defaultValue ISheet.Visibility.Visible
         */
        setVisibility(visibility?: ISheet.Visibility | boolean): ISheet;
        /**
         * Returns a collection of {@link INamed}s.
         */
        getNames(): INamedCollection;
        /**
         * Returns the {@link ICalculation} for the sheet.
         */
        getCalculation(): ICalculation;
        /**
         * Returns the {@link IWorkbook} for the sheet.
         *
         * @remarks
         * This may be `null` if not created via a workbook.
         */
        getWorkbook(): IWorkbook | null;
        /**
         * Removes from a container. This is usually the `Workbook`. If this is being
         * used standalone this operation will throw an exception.
         */
        delete(): void;
        /**
         * Select the `ISheet`.
         */
        select(options?: ITypes.SelectOptions): Promise<ISheet>;
        /**
         * Attempt to scroll the range into view.
         *
         * @param coords The partial coords to scroll to.
         * @param options {@link ISheet.ScrollToOptions}.
         */
        scrollTo(coords: Partial<IRange.Coords>, options: ISheet.ScrollToOptions): Promise<boolean>;
        /**
         * Returns a promise that will resolve to a copy of the current sheet.
         */
        duplicate(): Promise<ISheet>;
        /**
         * Reorders the `ISheet` with in the container. This is generally the tab order within an `IWorkbook` but may
         * be the zIndex if the `ISheets` are movable. This only affects visual listings of the sheets (but selection doesn't change).
         *
         * @remarks
         * This is zero-based.
         */
        setPosition(index: number): ISheet;
        /**
         * Returns a JSON representation of the sheet.
         *
         * @param ignoreData If `true` only meta data about the sheet will be saved.
         */
        toJSON(ignoreData?: boolean): Promise<ISheet.JSON>;
        /**
         * Free all resources associated with the sheet.
         *
         * @remarks
         * * Called by workbooks when the workbook is is closed.
         * * This is different than delete which removes the sheet from the workbook.
         *
         * @see
         * {@link ISheet.addListeners} for closeEvent
         */
        close(): void;
        /**
         * Returns true if the sheet has been closed.
         */
        isClosed(): boolean;
        /**
         * For runtime type checking.
         */
        readonly isISheet: true;
    }
    /**
     * {@inheritDoc ISheet}
     * @see
     * ### **Interface**
     *
     * {@link ISheet}
     *
     * ### **Implementation**
     *
     *  {@link Sheet}
     */
    export namespace ISheet {
        /**
         * The different ways to identify a range within a sheet,
         * supporting both relative and absolute (fixed) addressing.
         *
         * Accepts:
         * - `ICellRange`
         * - A parsable `string` representing a range address (e.g., A1 or $A$1 notation).
         * - A partial `IRange.Coords` object (specifying at least some of the range boundaries),
         *   optionally with a `$fixed` flag to indicate absolute addressing.
         * - `ICellRange.Address` (representing a single cell within the sheet),
         *   optionally with a `$fixed` flag to indicate absolute addressing.
         *
         * @example
         * ```typescript
         * const address1: Address = "A1:B2"; // Relative addressing (A1 notation)
         * const address2: Address = "$A$1:$B$2"; // Absolute addressing (A1 notation)
         * ```
         */
        type RangeAddress = ICellRange | string | Partial<IRange.FixableCoords> | ICell.Address;
        /**
         * Represents the different ways to identify multiple ranges within a sheet.
         *
         * Accepts:
         * - `ICellRanges`
         * - A parsable `string` containing multiple range addresses separated by commas (e.g., "A1:B2,C3:D4").
         * - An array of `ICellRange.Address` objects, each representing a single range.
         *
         * @example
         * ```typescript
         * const address1: ICellRanges.Address = "A1:B2,C3:D4"; // String with multiple ranges.
         * ```
         * @remarks
         * This extends {@link ICellRange.Address} to support multiple values.
         */
        type RangesAddress = ICellRanges | string | ICellRange.Address | ICellRange.Address[];
        /**
         * Indicates how a sheet should be available to the user.
         */
        const Visibility: {
            /**
             * Visible in all sheet displays.
             * For example: Tabs, menus, and formulas)
             */
            readonly Visible: "visible";
            /**
             * Not visible in most menus but still available in
             * user unhide options as well as available to formulas.
             */
            readonly Hidden: "hidden";
            /**
             * Completely hidden to the user but still available via
             * apis.
             */
            readonly VeryHidden: "veryHidden";
        };
        type Visibility = typeof Visibility[keyof typeof Visibility];
        /**
         * Options for scrolling to a specific range.
         */
        interface ScrollToOptions {
            /**
             * The partial coords to scroll to.
             */
            coords?: Partial<IRange.Coords>;
            /**
             * Any pixel offsets
             */
            offsets?: Bounds;
            /**
             * The scrollTo options.
             */
            scroll?: globalThis.ScrollIntoViewOptions | boolean;
        }
        /**
         * Events for {@link ISheet}.
         */
        interface Events {
            /**
             * Called when the UsedRange bounds changes.
             *
             * @remarks
             * Useful when interested in knowing when the bounds of the area
             * that is being used within the sheet changes; for example this is used
             * by the scrollbars to adjust the size.
             * @see
             * {@link ISheet.getUsedRange}
             */
            onUsedRangeChange?(source: ISheet): void;
            /**
             * Called when the sheet tab color changes.
             */
            onTabColorChange?(source: ISheet): void;
            /**
             * Called when any merges are added or removed.
             */
            onMergesChange?(source: ISheet): void;
            /**
             * Called if any spills occur.
             */
            onSpillsChange?(source: ISheet): void;
            /**
             * Called when any movables are added or removed.
             */
            onMovablesChange?(source: ISheet): void;
            /**
             * Called when any table are added or removed.
             */
            onTablesChange?(source: ISheet): void;
            /**
             * Convenience method that listens to all changes on the style.
             */
            onStyleChange?(source: ISheet): void;
            /**
             * Called when the sizes of the cells change.
             *
             * @remarks
             * * This can be be due to row/column sizes changes or changing the max rows columns.
             * * Zoom and viewport do not change the underlying layout.
             */
            onLayoutChange?(source: ISheet): void;
            /**
             * Called on any protection changes.
             */
            onProtectionChange?(source: ISheet): void;
            /**
             * Called before load. If any exception is thrown this
             * exception will be returned to the client and delete will fail.
             */
            onBeforeLoad?(source: ISheet, json: ISheet.JSON): void;
            /**
             * Called after load.
             */
            onLoad?(source: ISheet): void;
            /**
             * Called before load. If any exception is thrown this
             * exception will be returned to the client and delete will be aborted.
             */
            onBeforeSave?(source: ISheet): Promise<void> | void;
            /**
             * Called after save.
             */
            onSave?(source: ISheet, json: ISheet.JSON): void;
            /**
             * Called before delete. If any exception is thrown the
             * exception will be returned to the client and delete will be aborted.
             */
            onBeforeDelete?(source: ISheet): void;
            /**
             * Request that the sheet become focused.
             * @returns A promise indicating if the focus was honored.
             *
             * @remarks
             * This should only be handled by one consumer.
             */
            onRequestScrollIntoView?(source: ISheet, options: ISheet.ScrollToOptions): Promise<boolean>;
            /**
             * Request that the sheet become focused.
             * @returns A promise indicating if the focus was honored.
             * @remarks
             * This should only be handled by one consumer.
             */
            onRequestFocus?(source: ISheet): Promise<boolean>;
            /**
             * Called when the sheet is deleted.
             */
            onDelete?(source: ISheet): void;
            /**
             * Called when the `ISheetView` changes.
             *
             * This is not called when individual properties on the view change.
             */
            onViewChange?(source: ISheet): void;
            /**
             * Called when the topLeft changes.
             *
             * @remarks
             * This is a delegated event from the `ISheetView`.
             */
            onTopLeftChange?(source: ISheet): void;
            /**
             * Called when the selection changes.
             *
             * @remarks
             * This is a delegated event from the `ISheetView`.
             */
            onSelectionChange?(source: ISheet): void;
            /**
             * Called when freeze or split settings have changed.
             *
             * @remarks
             * This is a delegated event from the `ISheetView`.
             */
            onFreezeSplitChange?(source: ISheet): void;
            /**
             * Called when the movable selection changes.
             *
             * @remarks
             * This is a delegated event from the `ISheetView`.
             */
            onMovableSelectionChange?(source: ISheet): void;
            /**
             * Called when the view changes.
             */
            onViewChange?(source: ISheet): void;
            /**
             * Called when the name changes.
             */
            onNameChange?(source: ISheet): void;
            /**
             * Called when the visibility changes..
             */
            onVisibilityChange?(source: ISheet): void;
            /**
             * Called when the state has been updated due to a undo/redo and a rerender is required.
             */
            onInvalidated?(source: ISheet): void;
            /**
             * Called when the sheet is closed.
             */
            onClose?(source: ISheet): void;
        }
        interface IListeners extends IListener.Callbacks<ISheet, ISheet.Events> {
        }
        /**
         * Optional values used in the construction of am {@link ISheet}.
         *
         * @remarks
         * Changes to these options will be ignored after construction.
         */
        interface ConstructorOptions extends ICellContainerOptions {
            /***
             * Set the maxRow size
             * @defaultValue 1048576
             */
            maxRows?: number;
            /***
             * Set the maxRow size
             * @defaultValue 16384
             */
            maxColumns?: number;
            /**
             * When adding to another container.
             */
            container?: ISheet.ContainerOptions;
            /**
             * A unique identifier used for identifying this sheet during operations (i.e. copy/paste).
             * This must be unique for all in-memory instances of a sheet.
             *
             * @returns A unique identifier for in memory operations. If not provided a default one will be used.
             * @remarks
             * This is not saved as part of the {@link ISheet.JSON} persisted model.
             */
            uid?: () => string;
            /**
             * Initial JSON.
             */
            json?: ISheet.JSON;
        }
        /**
         * Options needed for embedding a sheet into another container such as a workbook.
         */
        interface ContainerOptions {
            /**
             * Required to be called before from JSON.
             * @param self -The Sheet
             *
             * @remarks
             * This is needed to ensure the contain has access to the sheet reference so that
             * it can resolve references.
             */
            beforeFromJSON?: (self: ISheet) => void;
            /**
             * Callback to provide a sheet with a logical name. This is used
             * when a sheet name property is invoked.
             *
             * @remarks
             * Sheets don't have a name by default but as a convenience we allow
             * for the name to be called from the sheet.
             */
            getName: () => string | null;
            setName?: (name: string | null) => void;
            setNameChangeCallback?: (callback: () => void) => void;
            /**
             * Return the current index
             * @returns
             */
            getIndex: () => number | null;
            setIndexCallback?: (callback: () => void) => void;
            /**
             * Callback to provide a sheet with a visibility.
             *
             * @remarks
             * Sheets don't manage this but as a convenience we allow
             * for the visibility to be called from the sheet.
             */
            getVisibility?: () => ISheet.Visibility;
            setVisibility?: (visibility: ISheet.Visibility) => void;
            setVisibilityCallback?: (callback: () => void) => void;
            /**
             * Returns a copy of the sheet provided sheet.
             */
            duplicate?: () => Promise<ISheet>;
            /**
             * Request that this moved.
             *
             * @param index The index to set to.
             *
             * @remarks
             * For traditional workbooks with not docking tabs this will be the tab position.
             */
            setPosition?: (index: number) => boolean;
            /**
             * Request that the sheet become the active sheet.
             *
             * @returns A flag indicating that the sheet was brought to the front.
             *
             * @remarks
             * In a workbook context there is only one active sheet at a time but other clients
             * may treat this this differently.
             */
            requestSelect?: (options?: ITypes.SelectOptions) => Promise<boolean>;
        }
        /**
         * A set of properties for `ISheet`.
         */
        interface PropertiesJSON {
            custom?: Record<string, string>;
            calc?: {
                fullCalcOnLoad?: boolean;
            };
            ignoreErrors?: Record<string, string[]>;
            /** {@inheritDoc IPrint.HeaderFooter} */
            headerFooter?: IPrint.HeaderFooter;
            /** {@inheritDoc IPrint.PageSetup} */
            pageSetup?: IPrint.PageSetup;
            /** {@inheritDoc IPrint.PageSetUpProperties} */
            pageSetUpPr?: IPrint.PageSetUpProperties;
            /** {@inheritDoc IPrint.PrintOptions} */
            printOptions?: IPrint.PrintOptions;
            /** {@inheritDoc IPrint.OutlineProperties} */
            outlinePr?: IPrint.OutlineProperties;
            rowBreaks?: IPrint.Break[];
            colBreaks?: IPrint.Break[];
            phoneticPr?: {
                alignment?: string;
                fontId?: number;
                type: string;
            };
        }
        /**
         * ISheet persistence structure.
         */
        interface JSON {
            data?: Tuple.GridTuple<ICell.JSON>;
            formulas?: [address: string, text: string][];
            /**
             * Indicates a range was created via a dynamic array formula.
             * This is a specific type of dynamic.
             */
            dynamicArray?: [address: string, error: boolean][];
            volatile?: string[];
            cols?: ICellHeader.JSON[];
            defaultColSize?: number;
            outlineLevelCol?: number;
            rows?: ICellHeader.JSON[];
            defaultRowSize?: number;
            outlineLevelRow?: number;
            styles?: IStyleCollection.JSON;
            resources?: IResource.JSON[];
            strings?: string[];
            people?: IComment.PersonJSON[];
            comments?: IComment.JSON[];
            hyperlinks?: {
                r: ICellRange.RefJSON;
                v: IHyperlink.JSON;
            }[];
            /**
             * A generalize solution for dynamic areas.
             * This is used for externalData
             *
               "C5:G10": {
               "type": "externalData",
               "error": false,         // Or true if the last refresh failed
               "source": "Query1",     // Example: Type-specific info
               "overrides": {          // Object storing user edits within the region
                 "D6": "Manual Edit",  // Key = Cell Address within region
                 "F8": 123.45          // Value = User-entered value
               }
            }
            */
            dynamic?: {
                r: ICellRange.RefJSON;
                v: IRichData.JSON;
            }[];
            /**
             * Either an object with RangeAddress to style id or an array of RangeCoordValue to style id.
             */
            directStyles?: {
                r: ICellRange.RefJSON;
                v: number;
            }[];
            merges?: string[];
            tables?: ITable.JSON[];
            movables?: IMovable.JSON[];
            conditionals?: IConditionalFormat.JSON[];
            filter?: IAutoFilter.JSON;
            sort?: IAutoSort.JSON;
            tabColor?: string;
            protection?: ISheetProtection.JSON;
            view?: ISheetView.JSON;
        }
    }
}
declare module "sheet/header/ISheetHeader" {
    import { IRange } from '@sheetxl/primitives';
    import { RunCoords } from '@sheetxl/utils';
    import { ITypes } from "type/index";
    import { ITransaction } from "transaction/index";
    import { IListener } from "listener/index";
    import { ICellHeader } from "cell/index";
    import { ICellHeaderRange, ICellHeaderRanges } from "cellRange/index";
    import { ISheet } from "sheet/ISheet";
    /**
     * Provides a programmatic interface for interacting with and modifying entire rows or columns in a spreadsheet,
     * allowing for actions such as inserting, deleting, resizing, and applying formatting changes.
     */
    export interface ISheetHeader extends ITransaction.ITransactional, IListener.ISource<ISheetHeader> {
        /**
         * Returns the header at a given offset. Will only return null for invalid header offset. To get a list of headers use {@link getRange}.
         *
         * @param index 0-based absolute index.
         */
        at(index: number): ICellHeader;
        /**
         * Returns a displayable title for the given index.
         * @param index 0-based absolute index.
         */
        getTextAt(index: number): string;
        /**
         * Returns a range of cells for the specified range.
         *
         * @param address The address or addresses of the header range to retrieve.
         * @param options Options for retrieving the header ranges.
         * @see
         * {@link ICellHeaderRange}
         */
        getRange(address: ICellHeaderRange.Address, options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
        /**
         * Returns a collection of header ranges for the specified ranges.
         *
         * @param address The address or addresses of the header ranges to retrieve.
         * @param options Options for retrieving the header ranges.
         */
        getRanges(address: ICellHeaderRanges.Address, options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
        /**
         * Returns the active header range that is used in the selection.
         */
        getSelectedRange(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
        /**
         * Returns the active header ranges that are used in the selection.
         */
        getSelectedRanges(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
        /**
         * Returns the data ranges for headers that contain information.
         *
         * @remarks
         * * This is NOT the last cell that may have data or has been resized.
         * * This also has nothing to do with the selection bounds.
         * @see
         * {@link ICellRange.getUsedRange}
         */
        getUsedRange(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
        /**
         * The entire range for the header.
         */
        getEntireRange(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
        /**
         * The orientation the headers manage.
         */
        getOrientation(): IRange.Orientation;
        /**
         * Returns a flag indicating if the headers are protected by the sheet.
         */
        isProtected(): boolean;
        /**
         * All header sizes are returned in pixels. This is done
         * by multiplying the scaleFactor by the size on the cellHeader.
         */
        getScaleFactor(): number;
        /**
         * Finds the offset in pixels for the given header index
         * @param index 0-based absolute index.
         */
        findOffset(index: number): number;
        /**
         * Finds the index for the given header offset in pixels.
         * @param offset 0-based pixels.
         */
        findIndex(offset: number): number;
        /**
         * Finds the visibleIndex for a given absolute index.
         * * If it's hidden it will return a range of 1 with a value before the offset and after.
         * * If it's visible then it will return a range of 0 with the min and max that exactly match the offset.
         *
         * @param index 0-based absolute index.
         * @returns A {@link RunCoords} that  can be used to determine if an index is hidden.
      
         * @remarks
         * If this is on the edge of the bounds this will return a +/- 1 the max bounds.
         */
        findVisibleIndex(index: number): Readonly<RunCoords>;
        /**
         * Returns the number of indices visible. Between to indices.
         * @param indexFrom
         * @param indexTo
         */
        getVisibleCount(indexFrom: number, indexTo: number): number;
        /**
         * Returns the size of the header in pixels. If a second argument is passed it
         * will be the size of all the headers within the range.
         * Note - It is expected that indexFrom will always be less than or equal to indexTo
         */
        getSpanSize(indexFrom: number, indexTo?: number): number;
        /**
         * The default header size if not adjusted.
         */
        getDefaultSize(): number;
        /**
         * The maximum size of the header in native units.
         */
        getMaxSize(): number;
        /**
         * The minimum size of the header in native units.
         */
        getMinSize(): number;
        /**
         * This is a very specific optimization function. When
         * hiding many headers instead of scanning we can just skip.
         * If `0` is returned then there are no hidden headers immediately
         * following this one. If `1` is returned then only this header is hidden.
         *
         * @param index The location to start the search.
         * @param reverse Indicates if search should scan in reverse. defaults to `false`.
         * @returns The number of headers following the index.
         */
        hiddenHeadersAt(index: number, reverse?: boolean): number;
        /**
         * Returns true if any of the headers have the isHidden flag set to true or if any sizes are 0.
         */
        hasHidden(): boolean;
        /**
         * Returns true if header has a max selection at the given index.
         */
        isSelectedAll(index: number): boolean;
        /**
         * Returns true if header has a selection at the given index.
         */
        isSelected(index: number): boolean;
        /**
         * Returns a list of SelectedRuns.
         */
        getSelectedRuns(): readonly ITypes.RunCoordValue<ISheetHeader.SelectedRun>[];
        /**
         * Sets the headers. This supports setting values as a batch.
         *
         * @remarks
         * When setting headers the cells references by this sheet will not update.
         * To ensure they are updated on the sheet call updateHeaderPairs with the range from the header.
         */
        updateHeaderPairs(pairs: ICellHeaderRange.AddressUpdatePair[], options?: ICellHeaderRange.UpdateHeadersOptions): RunCoords[] | null;
        /**
         * Returns the sheet model used for the header.
         */
        getSheet(): ISheet;
        /**
         * Save the header state to a JSON object.
         */
        toJSON(): ISheetHeader.JSON;
        /**
         * Load the {@link ISheetHeader.JSON} state into the header. The current state will be lost.
         * @deprecated - Should be added to constructor.
         */
        fromJSON(json: ISheetHeader.JSON): void;
        /**
         * Add Listeners.
         *
         * @see
         * {@link IListener.ISource.addListeners}
         */
        addListeners(listeners: ISheetHeader.IListeners, options?: IListener.Options): IListener.Remove;
        close(): void;
    }
    /**
     * {@inheritDoc ISheetHeader}
     * @see
     * ### **Interface**
     *
     * {@link ISheetHeader}
     */
    export namespace ISheetHeader {
        /**
         * Run of headers with min/max embedded. (This prevents rows/columns from having min/max fields but makes persisted json a bit cleaner)
         */
        interface JSON {
            headers: ICellHeader.JSON[];
            defaultSize?: number;
        }
        interface SelectedRun {
            isSelectedAll: boolean;
        }
        interface Events {
            /**
             * Called when sizes of the headers have changed.
             */
            onSizesChange?(source: ISheetHeader): void;
        }
        interface IListeners extends IListener.Callbacks<ISheetHeader, ISheetHeader.Events> {
        }
    }
}
declare module "sheet/header/index" {
    export * from "sheet/header/ISheetHeader";
}
declare module "sheet/_SheetUtils" {
    import { IRange, Scalar, JSScalar } from '@sheetxl/primitives';
    import { RunCoords } from '@sheetxl/utils';
    import { ITypes } from "type/index";
    import type { IStringCollection } from "string/index";
    import { ISort } from "sort/index";
    import { type IStyle } from "style/index";
    import type { ICell, ICellHeader } from "cell/index";
    import type { ICellRange } from "cellRange/index";
    import type { ISheetHeader } from "sheet/header/index";
    import type { ISheet } from "sheet/ISheet";
    import { Tuple, ISpatialMap, IListLike } from "collections/index";
    import { MergeEntry } from "sheet/spatial/index";
    import { ContentfulEntry } from "calculation/spatial/index";
    import { RangeState, CellState } from "sheet/_SheetTypes";
    /**
     * TODO - This is creating a cyclical module dependency (we need to use it because we want the createTemporary capability on Empty)
     * I think the right answer is to create a function
     */
    import { SheetCellOptions } from "sheet/SheetCell";
    /**
     * Selects max coords in an orientation.
     */
    export const expandRanges: <CT extends IRange.Coords = IRange.Coords>(ranges: readonly CT[], maxRange: IRange.Coords, orientation: IRange.Orientation, after?: boolean) => CT[];
    export const isEntireRows: (coords: readonly IRange.Coords[], maxCoords: IRange.Coords, all: boolean) => boolean;
    export const isEntireCols: (coords: readonly IRange.Coords[], maxCoords: IRange.Coords, all: boolean) => boolean;
    export const countSpans: (coords: readonly IRange.Coords[], orientation?: IRange.Orientation) => number;
    /**
     * Defaults to IRange.Orientation.Row if the bounds are the same size.
     */
    export const getDefaultOrientation: (range: IRange.Coords) => IRange.Orientation;
    /**
     * Default insert/delete direction for a given range.
     */
    export const getDefaultShiftOrientation: (range: IRange.Coords, maxRange: IRange.Coords) => IRange.Orientation;
    /**
     * @internal
     */
    export const toAbsRangeCoords: (rowIndex: number, colIndex: number, relative: IRange.Coords) => IRange.Coords;
    export const RETURN_FALSE: () => boolean;
    export const RETURN_TRUE: () => boolean;
    export const RETURN_NULL: () => any;
    /**
     * This is for 0 size ranges.
     * @internal
     */
    export const RANGE_INVALID_REF: ICellRange;
    /** @internal */
    export function createRangeInvalidRef(sheet: ISheet, maxRange?: IRange.Coords, range?: IRange.Coords, errorType?: string): ICellRange;
    /**
     * Implementation of date/number/currency parsing
     *
     * @param reuseCellModifiers If this is provided it is expected to be pre-initialized with empty values.
     -We could to move to a more robust solution but I believe we have all of the accounting rules that Excel has
     -https://github.com/BrightspaceUI/intl - https://github.com/openexchangerates/accounting.js, https://github.com/dinerojs/dinero.js
     -TODO  internationalization - https://github.com/BrightspaceUI/intl
      * @internal
     */
    export const createCellModifiersFromString: (strValue: string, options?: ICell.ModifiersFromStringOptions, reuseCellModifiers?: ICell.Modifiers) => ICell.Modifiers;
    /**
     * Calculates the bottom inset based on accounting rules
     * @internal
     */
    export const calcAccountingBottomInset: (style: IStyle) => number;
    /** @internal */
    export const getHiddenRuns: (header: ISheetHeader) => RunCoords[];
    /**
     * Merges an array of rangeStateIntersections into a single RangeStateIntersection.
     *
     * @internal
     */
    export const mergeRangeStateIntersections: (ranges: readonly ITypes.RangeCoordValue<RangeState.Intersection>[]) => RangeState.Intersection;
    /**
     * @internal
     * * TODO - Use a lower level iterator to avoid cell context?
     */
    export const cellStateIteratorTo2DArray: (iteratorCallback: (options?: CellState.IteratorOptions) => Iterator<ICellRange.Entry, ICellRange.Entry, IRange.CellCoords>, bounds: IRange.Coords, asCells: boolean, options: ICellRange.GetValuesOptions) => (ICell | JSScalar)[][];
    /**
     * @internal
     * TODO - rationalize this with cellStateIteratorTo2DArray?
     * TODO - Use a lower level iterator to avoid cell context?
     */
    export const cellStateIteratorToString: (iteratorCallback: (options?: CellState.IteratorOptions) => Iterator<ICellRange.Entry, ICellRange.Entry, IRange.CellCoords>, bounds: IRange.Coords, options: ICellRange.ToTextOptions) => string;
    export const isEqualSheetRanges: (a?: IRange.FixableCoords, b?: IRange.FixableCoords) => boolean;
    /**
     * Check if two ranges arrays are equal
     * @param a First Range Array.
     * @param b Second Range Array.
     */
    export const isEqualSheetRangesArrays: (a?: readonly IRange.FixableCoords[], b?: readonly IRange.FixableCoords[]) => boolean;
    /**
     * Check if two coords are equal.
     * @param a First CellCoords
     * @param b Second CellCoords
     */
    export const isEqualSheetCells: (a: IRange.FixableCellCoords | null, b: IRange.FixableCellCoords | null) => boolean;
    export const sanitizeSheetCoords: (rangeOrCoords: IRange.FixableCoords | IRange.FixableCellCoords) => IRange.FixableCoords;
    /** Copies fixed values to dest values. */
    export const copyFixedRangeCoords: (dest: IRange.FixableCoords, source: IRange.FixableCoords) => void;
    /** adjust the FixedRangeCoords. */
    export const adjustFixedRangeCoords: (source: Readonly<IRange.FixableCoords>, options: ICellRange.GetFixedOptions | boolean) => Readonly<IRange.FixableCoords>;
    /**
     * Provides A ICell.IteratorContext for CellStateIterator.
     */
    export class CellStateIteratorContext {
        private _c;
        private _v;
        private _t;
        private _r;
        private _p;
        private _n;
        context: ICell.IteratorContext;
        setState: (entry: CellState.Entry) => Scalar;
        clear: () => void;
        constructor(strings: IStringCollection, iteratorOptions: CellState.IteratorOptions, options: SheetCellOptions);
    }
    /**
     * Returns the direction and orientation for fill.
     */
    export const getFillDirectionAmount: (template: IRange.Coords, destination: IRange.Coords) => {
        direction: IRange.Direction;
        amount: number;
    };
    /**
     * Quick and dirty merge of two objects.
     * @remark optionsB has higher priority.
     */
    export const mergeOptions: (optionsA: any, optionsB: any) => any;
    /**
     * Returns a regEx. Either a regular regex or a Excel like wildcard regex.
     */
    export const builtFindReg: (findText: string, matchCase: boolean, useRegex: boolean) => RegExp;
    export const rangeTopLeft: (range: IRange.Coords) => IRange.Coords;
    /**
     * Given a selection, find the 'natural' bounding area to sort.
     * When checking for header and default sort criteria this is the orientation to use. @default IRange.Orientation.Row
     */
    export const getDefaultSortCriteria: (sheet: ISheet, rangeCoords: IRange.Coords, cellCoords?: IRange.CellCoords, orientation?: IRange.Orientation) => ISort.DefaultSortCriteria;
    /**
     * Search all spatials expanding the range until no immediate bounding rectangles.
     */
    export const findSurroundingRegion: (range: IRange.Coords, spatials: ISpatialMap[], maxIterations?: number) => IRange.Coords | null;
    export const findExtendedRegion: (direction: IRange.Direction, coords: IRange.CellCoords, asRange: IRange.Coords, // TODO - merge this into coords?
    searchSpatials: (range: IRange.Coords) => IRange.Coords[], entireCoords: IRange.Coords) => IRange.Coords;
    /**
     * Internal representation of a Scalar.
     */
    export type TypeAndValue = [v: Scalar, t: string];
    /**
     * Converts TypeAndValue to a value appropriate for storing in the grid.
     *
     * @param values an array of Scalar.
     * @returns An `IListLike` of values
     */
    export const toListLike: (values: Scalar[], strings: IStringCollection, internal?: TypeAndValue[]) => IListLike<Scalar>;
    /**
     * Wraps each value in a ContentfulEntry
     */
    export const tuplesToContentfulEntries: (gridTuple: Tuple.GridTuple<Scalar>, isColumn: boolean) => ISpatialMap.Entry<ContentfulEntry>[];
    /**
     * Expands ranges to include merges.
     */
    export const expandToIncludeMerges: (ranges: readonly IRange.Coords[], mergeSpatial: ISpatialMap<MergeEntry>, entireCoords: IRange.Coords) => IRange.Coords[];
    export type OrientedStyled = {
        orientations: IRange.Orientations;
        index: number;
    };
    export const headerToRangedStyles: (headers: ICellHeader.JSON[], orientation: IRange.Orientation, entireCoords: IRange.Coords) => ITypes.RangeCoordValue<OrientedStyled>[] | null;
}
declare module "primitives/_PrimitiveUtils" {
    import { Scalar, JSScalar, ScalarType, FormulaError, IRange, IFormulaContext } from '@sheetxl/primitives';
    import { ISparseGrid } from "collections/index";
    export const REGEX_LITERAL_ARRAY: RegExp;
    export const defaultEntireCoords: IRange.Coords;
    export const defaultEmptyPosition: IRange.CellCoords;
    export const defaultGetEntireCoords: () => IRange.Coords;
    /**
     * Find the implied type from a Javascript value.
     *
     * @param jsV The `JSScalar`.
     * @returns The ScalarType or `null` if unable to determine.
     *
     * @remarks
     * This doesn't support dates as these are managed via numbers.
     */
    export const typeFromJsValue: (jsV: JSScalar, checkDate?: boolean) => ScalarType;
    export const toStringType: (scalar: ScalarType | string, range?: string) => string;
    /**
     * coerceScalar will convert a value from one type to another.
     * This takes a string in additional to a ScalarType to support
     * boxing non native types like `Date`.
     *
     * @remarks
     * Dates are only supported to from numbers as we don't store these.
     */
    export const coerceScalar: (value: any, fromType: ScalarType | "Date", toType?: (ScalarType | "Date"), includeBoolean?: boolean, date1904?: boolean) => Scalar;
    /**
     * Returns FormulaError.Value if more than 1 value or doesn't convert.
     *
     * @param value The value to extract
     * @param scalar The scalar type to convert to. If not specified then no conversion will occur.
     * @param forceOne If true this will return an error if an range with size > 1.
     *
     * @remarks
     * This will not extract if the range is a reference Range
     */
    export const coerceSingleValue: (value: any, scalar?: ScalarType, forceOne?: boolean) => any;
    /**
     * Returns FormulaError.Value if more than 1 value or doesn't convert.
     *
     * @param value
     */
    export const isSingleValue: (value: any) => boolean;
    /**
     * Counts the depth of the array. If it is an IRange then it will always add 2.
     */
    export const countDepth: (value: any) => number;
    export const convertToScalarArray: (context: IFormulaContext, coercedValues: any[], currentArg: any, scalar: ScalarType | null, // the scalar preference. If not specified no coercion will occur.
    range: string | null, // the range preference for dims higher than 2 (if not specified then will materialize to array values
    lax?: boolean) => void | FormulaError.Value;
    /**
     * Ranges are always 2d.
     */
    export const convertToRange: (context: IFormulaContext, coercedValues: any[], currentArg: any, scalarType: ScalarType | null, // the scalar preference. If not specified no coercion will occur.
    range: string | null, isArray: boolean) => void | FormulaError.Value;
    /**
     * Minimal validation used from the return value of functions.
     */
    export const minCoerce: (value: any, context?: IFormulaContext, type?: string) => any;
    /**
     * Fast version of `return a.toPrecision(15) === b.toPrecision(15);`
     *
     * @param a
     * @param b
     * @returns
     */
    export function excelEqual(a: number, b: number): boolean;
    export const gridFromArray: (value: Scalar | Scalar[][], values?: ISparseGrid, coords?: IRange.Coords, type?: ScalarType | null) => IRange;
}
declare module "calculation/grammar/ASTTypes" {
    import { IRange, IFunction, FormulaError } from '@sheetxl/primitives';
    import { ICalculation } from "calculation/index";
    /**
     * Represents a node in the Abstract Syntax Tree (AST) of a formula.
     */
    export interface ASTNode {
        /**
         * The type of AST node
         */
        type: string;
        /**
         * Identifies the value at the AST node.
         * (e.g. range, function name, operator, literal value, etc.)
         */
        value?: string | IRange.FixableCellCoords | FormulaError.Known | any;
        /**
         * A list of inputs (or child nodes) that contribute to the expression.
         */
        inputs?: ASTNode[];
        /**
         * The pre-resolve function
         */
        fn?: Function;
        /**
         * Any white space before the node.
         */
        wsBefore?: string;
        /**
         * Any white space after the node.
         *
         * @remarks
         * This will only be populated for the root node.
         */
        wsAfter?: string;
        /**
         * Indicates the ids for evaluating this node.
         * This is used incremental execution (tooltip)
         *
         * @see {@link ICalculation.FormulaToken.evalIndex}
         */
        evalIndex?: number;
        /**
         * For live editing. We may need to add original start/end offsets to align?
         *
         * @remarks
         * If an image does not exist then should be created from the value. For example a cell reference that
         * has been updated will not have an image.
         */
        image?: string;
        /**
         * If ast had an error.
         *
         * @remarks
         * This is different than a valid parsed error.
         */
        error?: boolean;
        /**
         * If the node is a reference.
         */
        isReference?: boolean;
        /**
         * Indicates the index of the references from getReferences()
         *
         * @remarks
         * * Multiple nodes may have the same reference index as these.
         * * Used to color code references in the editor.
         */
        refIndex?: number;
        /**
         * If the node is a literal.
         */
        isLiteral?: boolean;
    }
    /**
     * AST callback
     */
    export interface ASTVisitor {
        /**
         * Called once for every node (depth-first).
         *
         * @remarks
         * If a non-void value is returned the node will be replaced with it.
         * Returning `undefined` leaves the node intact.
         */
        (node: ASTNode, parent: ASTNode | undefined): ASTNode | void;
    }
    export interface CellNode extends ASTNode {
        type: 'cell';
        value: IRange.FixableCellCoords;
    }
    export interface FunctionNode extends ASTNode {
        type: 'function';
        cacheFn?: IFunction;
    }
    export interface ParenNode extends ASTNode {
    }
    /**
     * The compiled precedent.
     */
    export interface CompiledPrecedent {
        /**
         * The ast for the precedent
         */
        node: ASTNode;
        /**
         * The index of the results
         */
        index: number;
        /**
         * The index of the value if it doesn't have inputs.
         *
         * @remarks
         * For example a cell
         */
        value: number;
        /**
         * The index values of the inputs if this is an operator
         *
         * @remarks
         * For example ':' a union range operator.
         */
        inputs: number[];
        /**
         * A string representing the operation to perform.
         */
        op: string;
        /**
         * Quick indicator that the precedent has absolutes references.
         *
         * @remarks
         * We currently used this tell the calc engine to skip resolution and just evaluate all calcs in a formula block.
         */
        hasVerticalAbs?: boolean;
        /** @inheritdoc CompiledPrecedent.hasVerticalAbs */
        hasHorizontalAbs?: boolean;
    }
    /**
     * The compiled formula.
     */
    export interface CompiledFormula {
        /**
         * The formula expressed as a tree of node with indices for each node.
         *
         * @remarks
         * * The primary data structure for the formula.
         * * All other items are derived from this.
         */
        ast: ASTNode;
        /**
         * Hold all incremental evaluations.
         *
         * @remarks
         * A cache
         */
        evaluations: any[];
        /**
         * This is a sorted list of execution functions
         */
        executions: any[];
        /**
         * Represents all references as absolute ranges.
         *
         * @remarks
         * A cache
         */
        precedentsAbsolute: IRange.Coords[];
        /**
         * List of all executions required to calculate the precedents.
         */
        precedentsExecute: CompiledPrecedent[];
        /**
         * Any named references
         */
        precedentsNamed: (string | FormulaError.Known)[];
        /**
         * Represents all cell relative references.
         */
        precedentsRelative: IRange.FixableCoords[];
        /**
         * The high level precedents indices that will be returned to the caller
         */
        precedentsRoot: number[];
        /**
         * References to support getReferences() or updateReferences()
         *
         * @remarks
         * Because we manage as cells but update as ranges we need to track the start and end of the references.
         */
        references: number[];
        /**
         * Root convert to FormulaTokens
         */
        tokens: ICalculation.FormulaToken[];
        error?: any;
    }
}
declare module "calculation/grammar/Lexing" {
    import { type ILexingResult } from 'chevrotain';
    const TokenVocabulary: {};
    export { TokenVocabulary };
    export const doLex: (inputText: string) => ILexingResult;
}
declare module "calculation/grammar/Operators" {
    import { IReferenceRange, IRange, FormulaError, IFormulaContext } from '@sheetxl/primitives';
    export const Infix: {
        '+': (context: IFormulaContext, value1: any, value2: any) => number | IRange | FormulaError.Known;
        '-': (context: IFormulaContext, value1: any, value2: any) => number | IRange | FormulaError.Known;
        '*': (context: IFormulaContext, value1: any, value2: any) => number | IRange | FormulaError.Known;
        '/': (context: IFormulaContext, value1: any, value2: any) => number | IRange | FormulaError.Known;
        '^': (context: IFormulaContext, value1: any, value2: any) => number | IRange | FormulaError.Known;
        ' ': (context: IFormulaContext, value1: IReferenceRange, value2: IReferenceRange, reuse?: IRange.Coords) => IReferenceRange;
        ':': (context: IFormulaContext, value1: IReferenceRange, value2: IReferenceRange, reuse?: IRange.Coords) => IReferenceRange;
        '.:.': (context: IFormulaContext, value1: IReferenceRange, value2: IReferenceRange, reuse?: IRange.Coords) => IReferenceRange;
        '.:': (context: IFormulaContext, value1: IReferenceRange, value2: IReferenceRange, reuse?: IRange.Coords) => IReferenceRange;
        ':.': (context: IFormulaContext, value1: IReferenceRange, value2: IReferenceRange, reuse?: IRange.Coords) => IReferenceRange;
        '&': (context: IFormulaContext, value1: any, value2: any) => string | IRange;
        '=': (context: IFormulaContext, value1: any, value2: any) => boolean | IRange;
        '<>': (context: IFormulaContext, value1: any, value2: any) => boolean | IRange;
        '>': (context: IFormulaContext, value1: any, value2: any) => boolean | IRange;
        '<': (context: IFormulaContext, value1: any, value2: any) => boolean | IRange;
        '>=': (context: IFormulaContext, value1: any, value2: any) => boolean | IRange;
        '<=': (context: IFormulaContext, value1: any, value2: any) => boolean | IRange;
    };
    export const Prefix: {
        '-': (context: IFormulaContext, value: any) => any;
        '+': (context: IFormulaContext, value: any) => any;
        '@': (context: IFormulaContext, value: any) => any;
    };
    export const Postfix: {
        '%': (context: IFormulaContext, value: any) => any;
        '#': (context: IFormulaContext, value: any) => IReferenceRange;
    };
}
declare module "calculation/grammar/_ASTUtils" {
    import { FormulaError, IRange } from '@sheetxl/primitives';
    import type { ASTNode, ASTVisitor, CompiledFormula, CellNode, FunctionNode } from "calculation/grammar/ASTTypes";
    import { type ICalculation } from "calculation/index";
    /**
     * Convert column string to column name.
     */
    export function columnNameToNumber(columnName: string): number;
    /**
     * Parse the cell address only.
     */
    export function createCellAddress(address: string, position: IRange.CellCoords): CellNode;
    export function createCell(coords: IRange.FixableCellCoords): CellNode;
    export function createCol(address: string, position: IRange.CellCoords): CellNode;
    export function createRow(address: string, position: IRange.CellCoords): CellNode;
    export function createFunction(value: string, inputs: any[]): FunctionNode;
    export function createTableReference(value: string, inputs: any[]): ASTNode;
    export function createTableSpecifier(value: string): ASTNode;
    export function createStructuredArg(input: any): ASTNode;
    export function createInfixNode(operator: string, left: ASTNode, right: ASTNode, isReference?: boolean): ASTNode;
    export function createPostfix(operator: string, input: ASTNode, isReference?: boolean): ASTNode;
    export function createPrefix(operator: string, input: ASTNode, isReference?: boolean): ASTNode;
    /**
     * Used within literals
     */
    export function createPrefixLiteral(operator: string, node: ASTNode): ASTNode;
    export function createNamed(value: string): ASTNode;
    /**
     * @param text Converts text to number.
     */
    export function createNumber(text: string): ASTNode;
    /**
     * @param text Removes quotes.
     *
     * @remarks
     * Once the quotes are removed this will also check to see if the value is a number or boolean and return
     * the correct type. This is done at time of parsing and not at evaluation time deliberately.
     */
    export function createString(text: string): ASTNode;
    export function createLiteralArray(row: any): ASTNode;
    export function createLiteralRow(): ASTNode;
    /**
     * @param bool
     */
    export function createBoolean(bool: string): ASTNode;
    /**
     * @param error
     */
    export function createLiteralError(error: string): ASTNode;
    /**
     * Reference error is different from a literal error in that it's a reference.
     */
    export function createRefError(error?: string): ASTNode;
    /**
     * Used for empty arguments ',,'
     */
    export function createEmpty(): ASTNode;
    /**
     * Simple is FormulaError check.
     */
    export function isFormulaError(obj: any): boolean;
    /**
     * Visits the AST node depth first and call the visitor function. This will replace
     * the tree with a new tree if any visitor calls return a new value.
     *
     * @param root - The root AST node to start traversing from
     * @param visitor - The visitor function to apply to each node
     * @returns The potentially modified AST
     *
     * @remarks
     *   • Children are visited **before** their parent (post-order).
     *   • If the visitor returns a node, that node replaces the current one.
     *   • Child changes are applied using a cheap *copy-on-write* strategy, so the
     *     original tree is never mutated; unchanged sub-trees are kept by
     *     reference.
     */
    export function visitAST(root: ASTNode, visitor: ASTVisitor): ASTNode;
    export function generateFormulaTokens(rootNode: ASTNode): ICalculation.FormulaToken[];
    /**
     * Compiles the AST into a array indices for fast(er) resolution
     */
    export function compileAST(original: ASTNode, error: any): CompiledFormula;
    /**
     * Convert a chevrotain error to a formula error.
     *
     * @param error Any error from chevrotain.
     * @param message The original error message.
     */
    export function formatChevrotainError(error: any, message: string): FormulaError.Known;
    export const copyTrivia: (target: ASTNode, source: ASTNode) => ASTNode;
    export const XLFN = "_XLFN.";
    export const binaryOperatorsPrecedence: readonly string[][];
    export const rangeSpanOperators: readonly string[];
    export const rangesOperators: readonly string[];
}
declare module "calculation/grammar/ASTBuilder" {
    import { EmbeddedActionsParser } from 'chevrotain';
    import { IRange, IFormulaContext } from '@sheetxl/primitives';
    import { type ASTNode, CompiledFormula } from "calculation/grammar/ASTTypes";
    export class ASTBuilder extends EmbeddedActionsParser {
        protected position: IRange.CellCoords;
        protected inputTextLength: number;
        protected astErrors: any[];
        constructor();
        protected _reportError(node: ASTNode, message: string, indexToken?: number, name?: string): void;
        /**
         * Returns the whitespace before the node.
         *
         * @param node - The processed AST Node
         * @param index - this is lex token index 'getLexerPosition'
         * @param trailingOnly - outfix notation (function, paren has 2 positions)
         *
         * @remarks
         * * This is needed because the lexer strips whitespaces. We could try to add it back but...
         */
        protected _ensureWhitespace(node: ASTNode, index: number, leadingOnly?: boolean, trailingOnly?: boolean): ASTNode;
        /**
         * Parse and return the AST of the formula.
         *
         * @param lexResults This must be the result of the lexing process.
         * @param position This is also required to make ranges relative.
         * @returns The root ASTNode
         */
        protected _createAST(context: IFormulaContext, inputText: string): ASTNode;
        /**
         * Parse an formula and return and IndexedAST.
         *
         * @param inputText Input formula
         * @param position position is required to create relative references.
         * @param ignoreError if `true`, throw FormulaError when error occurred.
         *                    if `false`, the parser will return partial dependencies.
         * @returns AST
         */
        build(context: IFormulaContext, inputText: string): CompiledFormula;
    }
}
declare module "calculation/grammar/index" {
    export type * from "calculation/grammar/ASTTypes";
    export * from "calculation/grammar/ASTBuilder";
}
declare module "calculation/formula/FormulaBlock" {
    import { IFormulaContext, Scalar, IRange, FormulaError } from '@sheetxl/primitives';
    import type { ICalculation } from "calculation/ICalculation";
    import type { ICalcGraph } from "calculation/graph/index";
    import type { CompiledFormula, FunctionNode } from "calculation/grammar/index";
    /**
     * Constructor options for Formulas
     */
    export interface FormulaBlockConstructorOptions {
        /**
         * Returns the
         * @param name The name to resolve.
         * @param sheetName If not provided or `null`, the current sheet name is used.
         */
        getNamed?: (name: string, scope?: string) => IRange.FixableCoords[] | null;
        getEntireCoords?: (sheetName?: string) => IRange.Coords;
        getSheetName?: () => string;
    }
    export class FormulaBlock implements ICalcGraph.IFormulaBlock {
        protected _options: FormulaBlockConstructorOptions;
        protected _compiled: CompiledFormula;
        protected _context: IFormulaContext;
        constructor(options: FormulaBlockConstructorOptions, compiled: CompiledFormula);
        /** @inheritdoc ICalcGraph.IFormulaBlock.getTextAt */
        getTextAt(row: number, column: number, r1c1?: boolean): string;
        /** @inheritdoc ICalcGraph.IFormulaBlock.getTokens */
        getTokens(): ICalculation.FormulaToken[];
        /** @inheritdoc ICalcGraph.IFormulaBlock.getError */
        getError(): any;
        /** @inheritdoc ICalcGraph.IFormulaBlock.isEquals */
        isEquals(other: ICalcGraph.IFormulaBlock): boolean;
        /** @inheritdoc ICalcGraph.IFormulaBlock.getReferences */
        getReferences(): readonly (IRange.FixableCoords | string | FormulaError.Known)[];
        /** @inheritdoc ICalcGraph.IFormulaBlock.setReferenceAt */
        setReferenceAt(index: number, reference: IRange.FixableCoords | null): this;
        protected _resolveNamed(name: string, row: number, column: number, reuse?: IRange.Coords): IRange.Coords | FormulaError.Known;
        /** @inheritdoc ICalcGraph.IFormulaBlock.getDirectPrecedentsAt */
        getDirectPrecedentsAt(row: number, column: number, includeInvalidIntersect?: boolean, verticalAbs?: boolean[], horizontalAbs?: boolean[]): (IRange.Coords | FormulaError.Known)[];
        /** @inheritdoc ICalcGraph.IFormulaBlock.evaluate */
        evaluate(context: IFormulaContext, evalIndex?: number, resolvePrecedents?: any[]): Scalar | Promise<Scalar>;
        protected _resolvePrecedents(context: IFormulaContext): (IRange.Coords | FormulaError.Known)[];
        /** @inheritdoc ICalcGraph.IFormulaBlock.wrapImplicit */
        wrapImplicit(rowIndex: number, colIndex: number, setSpills: Set<string>): this;
        /**
         * Calls a function.
         *
         * @param context The context to use.
         * @param fnName The name of the function to call.
         * @param args The args to pass to the function.
         */
        protected _callFunction(context: IFormulaContext, node: FunctionNode, args: any[]): any;
        private _finalizeReturnValue;
        get [Symbol.toStringTag](): string;
        toString(): string;
    }
}
declare module "calculation/formula/FormulaParser" {
    import { IFormulaContext, Scalar, IRange } from '@sheetxl/primitives';
    import { ICalcGraph } from "calculation/graph/index";
    import { ASTBuilder } from "calculation/grammar/index";
    import { IFormulaParser } from "calculation/formula/IFormulaParser";
    import { FormulaBlockConstructorOptions } from "calculation/formula/FormulaBlock";
    export class FormulaParser implements IFormulaParser {
        protected _astBuilder: ASTBuilder;
        protected _options: FormulaBlockConstructorOptions;
        constructor(options?: FormulaBlockConstructorOptions);
        /** @inheritdoc IFormulaParser.parse */
        parse(context: IFormulaContext, textA1: string): ICalcGraph.IFormulaBlock;
        /** @inheritdoc IFormulaParser.eval */
        eval(context: IFormulaContext, textA1: string): IRange | Scalar;
    }
}
declare module "calculation/formula/index" {
    export type * from "calculation/formula/IFormulaParser";
    export * from "calculation/formula/FormulaParser";
    export * from "calculation/formula/FormulaBlock";
}
declare module "calculation/graph/ICalcGraph" {
    import type { Scalar, IRange, FormulaError, IFormulaContext } from '@sheetxl/primitives';
    import type { ReferenceableClipboard } from '@sheetxl/utils';
    import { type IListener } from "listener/index";
    import { type IHistory } from "history/index";
    import { type ISpatialMap, type Tuple } from "collections/index";
    import { type ICalculation } from "calculation/ICalculation";
    import { type IFormulaParser } from "calculation/formula/index";
    /**
     * The calc engine used to calculate the values in a direct graph.
     */
    export interface ICalcGraph {
        /**
         * Set a group of cells and formula ranges.
         *
         * @param values A set of input values as BoundedTuples
         * @param ranges A set of formula strings as ranged entries.
         */
        setInputs(values: Tuple.BoundedTuples<Scalar>, formulas: readonly ISpatialMap.Entry<string>[]): ISpatialMap.Updates<ICalcGraph.FormulaInsert>;
        /**
         * Delete all values within a range.
         *
         * @param coords The coordinates to delete.
         */
        delete(coords: IRange.Coords | string): ISpatialMap.Entry[];
        /**
         * Mark a range invalid. This will call the area to be recalculated on the next calculate call.
         *
         * @param coords An array of coordinates.
         */
        invalidate(coords: (IRange.Coords | string)[]): void;
        /**
         * Execute a calculate on the Graph.
         *
         * @param options The options or a boolean. If `true' a full calculation will be done.
         * @returns A promise that will be resolved when the calculation is completed.
         *
         * @remarks
         * For async functions this will return before they are completed.
         */
        calculate(options?: ICalculation.CalculateOptions | boolean): Promise<ICalcGraph.Results>;
        /**
         * The the value at a specific cell to a formula.
         *
         * @param coords The coords
         * @param formula A string formula or null to clear
         */
        setFormulaAt(coords: IRange.CellCoords | string, formula: string | null): ISpatialMap.Updates<ICalcGraph.FormulaInsert>;
        /**
         * Return a formula at a specific cell.
         *
         * @param coords The coords
         * @param r1c1 If 'true' then returns string as r1c1
         */
        getFormulaAt(coords: IRange.CellCoords | string, r1c1?: boolean): string;
        /**
         * Set a single input value for a cell.
         *
         * @param coords The coords
         * @param value The value
         */
        setInputAt(coords: IRange.CellCoords | string, value: Scalar): ISpatialMap.Updates<ICalcGraph.FormulaInsert>;
        /**
         * Shifts all values in the graph in a given direction.
         *
         * @param options The options for the shift.
         */
        shift(options: ICalcGraph.ShiftOptions): this;
        /**
         * Returns a snapshot of the graph that can be used for copying.
         */
        getSnapshot(options?: ICalcGraph.GetSnapshotOptions): ICalcGraph.ISnapshot;
        /**
         * Autofill the values from a single cell to the entire range.
         *
         * @remarks
         * This is similar to getSnapshot but doesn't return a promise.
         */
        autoFill(template: IRange.Coords | string, destination: IRange.Coords | string): this;
        /**
         * Returns the resolved direct precedents for a formula.
         *
         * @param row The row of the cell to evaluate.
         * @param column The column of the cell to evaluate.
         * @param includeInvalidIntersect
         * @throws Error if the cell is not a formula.
         */
        getDirectPrecedentsAt(row: number, column: number, includeInvalidIntersect?: boolean): readonly (IRange.Coords | FormulaError.Known)[] | null;
        /**
         * Returns the reference for a specific cell.
         *
         * @param row The row of the cell to evaluate.
         * @param column The column of the cell to evaluate.
         * @throws Error if the cell is not a formula.
         */
        getReferencesAt(row: number, column: number): readonly (IRange.FixableCoords | string | FormulaError.Known)[];
        /**
         * Sets the reference at a specific formula cell.
         *
         * @param row The row of the cell to evaluate.
         * @param column The column of the cell to evaluate.
         * @param index The index of the evaluation to use from the tokens.
         * @param reference The value to set
         * @throws Error if the cell is not a formula.
         */
        setReferenceAt(row: number, column: number, index: number, reference: IRange.FixableCoords | string): this;
        /**
         * Evaluates a formula outside of the calculation cycle.
         *
         * @param row The row of the cell to evaluate.
         * @param column The column of the cell to evaluate.
         * @param evalIndex The index of the evaluation to use from the tokens.
         * @throws Error if the cell is not a formula.
         *
         * @remarks
         * * Used for tooltip evaluation and other static evaluations.
         * * Used by {@see ICalculation.IFormula.evaluate}.
         */
        evaluateAt(row: number, column: number, evalIndex?: number): Promise<Scalar | IRange>;
        /**
         * Returns a copy on write clone.
         *
         * @param cloneKey A performance optimization that will avoid cloning if the same key is used.
         *
         * @remarks
         * If the same clone key is used then the same instance will be returned.
         */
        clone(cloneKey?: any): this;
        /** {@inheritDoc ICalcGraph.addListeners} */
        addListeners(listeners: ICalcGraph.IListeners, options?: IListener.Options): IListener.Remove;
        /**
         * Loads the json into the graph.
         *
         * @param json The JSON to load.
         *
         * @remarks
         * This will clear all values and formulas including any pending changes or invalidation.
         */
        fromJSON(json: ICalcGraph.JSON): ICalcGraph.Results;
        /**
         * Returns a JSON representation of the calcGraph.
         *
         * @param includeData If `true` the values will be saved.
         */
        toJSON(includeData?: boolean): Promise<ICalcGraph.JSON>;
    }
    /**
     * {@inheritDoc ICalcGraph}
     *
     * @see
     * ### **Interface**
     *
     * {@link ICalcGraph}
     */
    export namespace ICalcGraph {
        interface Results {
            /**
             * The id of the calculation that was completed.
             *
             * @remarks
             * * Every calculation will have a unique id so this can be used to track the completion of a calculation.
             * * If calculations was called but no calculation was performed and event will be fired with the
             *   previous calcCompleteId.
             */
            cycleId: number;
            /**
             * When a full calculation is performed removes are not return and the client must clear all caches `true`.
             *
             * @defaultValue `false`
             */
            isFull?: boolean;
            /**
             * The bounds of the result updates including tuples, spills inserts and spills removes.
             *
             * @remarks
             * This will be `null` if no calculation results were updated or if isFull.
             */
            bounds?: IRange.Coords | null;
            /**
             * The results of the calculation will either be as `Map` or as a `Tuple.BoundedTuples`.
             *
             * @see
             * {@link CalculateOptions.asTuples}
             */
            valueInserts?: Tuple.BoundedTuples<Scalar>;
            /**
             * Values that have been cleared.
             */
            valueRemoves?: IRange.Coords[];
            /**
             * Contains any formulas that were inserted.
             */
            formulaInserts?: ISpatialMap.Entry<ICalcGraph.FormulaInsert>[];
            /**
             * Contains any formulas that were removed.
             */
            formulaRemoves?: ISpatialMap.Entry[];
            /**
             * Contains any spills that were inserted.
             */
            spillInserts?: ISpatialMap.Entry<boolean>[];
            /**
             * Contains any spills that were removed.
             */
            spillRemoves?: ISpatialMap.Entry[];
            /**
             * Formatting updates due to functions.
             *
             * @remarks
             * Formats are not cleared.
             */
            formatInserts?: ISpatialMap.Entry<string>[];
            /**
             * Contains any errors that were inserted.
             */
            errorInserts?: ISpatialMap.Entry<string>[];
            /**
             * Contains any error that were removed.
             */
            errorRemoves?: ISpatialMap.Entry[];
            /**
             * Indicates that a pending status has been added or removed.
             * A `true` value indicates that the pending status has been added.
             * A `false` value indicates that the pending status has been removed.
             *
             * @remarks
             * These are guaranteed to not overlap.
             */
            pendingUpdates?: ISpatialMap.Entry<boolean>[];
        }
        /**
         * Contains the formula string and the coordinates of the precedents.
         */
        interface FormulaInsert {
            /**
             * The formula tokens.
             */
            tokens: ICalculation.FormulaToken[];
            /**
             * The coordinates of the formula. Used for formatting.
             */
            precedents: IRange.Coords[];
            /**
             * Contains the non resolved references.
             */
            references: readonly (IRange.FixableCoords | string | FormulaError.Known)[];
        }
        interface GetSnapshotOptions extends ReferenceableClipboard.CopyOptions {
            /**
             * The range to capture the snapshot from. If omitted the entire range will be used.
             */
            range?: IRange.Coords | string;
        }
        /**
         * Provides destination details for the Snapshot when using `IHistory.ISnapshot.copyTo`.
         */
        interface SnapshotDestination {
            /**
             * The destination calc graph to copy to.
             */
            calcGraph: ICalcGraph;
            /**
             * The range to copy the snapshot to.
             */
            range: IRange.Coords | string;
        }
        interface ISnapshot extends IHistory.ISnapshot<ICalcGraph.SnapshotDestination, ICalcGraph, IRange.Coords> {
            /**
             * Called when the table is copied to a new collection.
             */
            copyTo(destination: ICalcGraph.SnapshotDestination, options?: ICalcGraph.CopyOptions): Promise<IRange.Coords>;
        }
        /**
         * Options for {@link ISnapshot.copyTo}.
         */
        interface CopyOptions extends ReferenceableClipboard.CopyOptions {
            /**
             * When pasting from a smaller range to a larger range copy will repeat or 'wallpaper' the
             * source values.
             *
             * @remarks
             * Note - If the destination range is only a single cell then fitDestination will always be applied.
             */
            fitDestination?: boolean;
            /**
             * Have the data transposed for the original orientation.
             * @defaultValue false
             */
            transpose?: boolean;
        }
        interface Error {
            /**
             * The error message.
             */
            message?: string;
            /**
             * Some error types will give an indicate of the range location.
             */
            coords?: string[];
        }
        interface IFormulaBlock {
            /**
             * This is the eval used internally by graph.
             * precedents must be an array of either IRange or Scalar.
             *
             * @param context The context to evaluate the formula in.
             * @param evalIndex The index of the evaluation to use from the tokens.
             * @param precedents **PERFORMANCE** Allows for pre-calced precedents to be use for the evaluation.
             *
             * @remarks
             * The precedents can be passed in as a performance optimization graph caches them as it calculates.
             */
            evaluate(context: IFormulaContext, evalIndex?: number, precedents?: any[]): any;
            /**
             * Return the formula as an array of formula token values. These can be used
             * by advanced editors.
             */
            getTokens(): ICalculation.FormulaToken[];
            /**
             * Return the formula string.
             */
            getTextAt(row: number, column: number, r1c1?: boolean): string;
            /**
             * Returns the cell ranges that provide data to a formula.
             *
             * @param row The row of the formula.
             * @param column The column of the formula.
             * @param includeInvalidIntersect If `true` then invalid ranges will be included in the result.
             * @param verticalAbs If provided the array will be populated with flags if a vertical absolute is detected
             * @param horizontalAbs If provided the array will be populated with flags if a horizontal absolute is detected
             *
             * @remarks
             * * `[]` if no precedents are present; either because it has no formula or a formula with no inputs.
             * * Precedents are the logical ranges and may different the inputs into the formula.
             * * includeInvalidIntersect is required to manage dependencies for invalid intersections in shared formulas.
             */
            getDirectPrecedentsAt(row: number, column: number, includeInvalidIntersect?: boolean, verticalAbs?: boolean[], horizontalAbs?: boolean[]): (IRange.Coords | FormulaError.Known)[];
            /**
             * Returns a list of fixable coordinates used by the formula.
             *
             * @remarks
             * This is done to enable updates.
             */
            getReferences(): readonly (IRange.FixableCoords | string | FormulaError.Known)[];
            /**
             * Returns a new formula that has the reference at an index.
             *
             * @param index The index of the reference to set.
             * @param reference The reference to set.
             *
             * @remarks
             * This must align to the getReferences.
             * setReference does not support setting or updating named ranges
             */
            setReferenceAt(index: number, reference: IRange.FixableCoords | null): this;
            /**
             * Wraps the formula in an implicit reference operator if hasSpill returns true and the formula
             * expects a spill.
             *
             * @param rowIndex The row index of the formula.
             * @param colIndex The column index of the formula.
             * @param setSpillCells - A1 notation for all of the cells that contains spills.
             *
             * @remarks
             * This is used for importing Excel as it doesn't always add '@' for backward compatibility.
             */
            wrapImplicit(rowIndex: number, colIndex: number, setSpillCells: Set<string>): this;
            /**
             * Return an error with the formula.
             *
             * @remarks
             * This is not a value error but that the formula is unable to resolve.
             */
            getError(): FormulaError.Parse | null;
            /**
             * If the formula is logically equal to another formula.
             *
             * @param other The other formula block to compare to.
             */
            isEquals(other: ICalcGraph.IFormulaBlock): boolean;
        }
        /**
         * Options for shifting the calc graph.
         */
        interface ShiftOptions {
            /**
             * The range to shift.
             */
            range: IRange.Coords;
            /**
             * The direction to shift.
             */
            direction: IRange.Direction;
            /**
             * If `true` the this will return a clone instance of the graph if there are any modifications.
             *
             * @defaultValue false
             *
             * @remarks
             * This allows for a 0-1 clone on write.
             */
            cloneIfUpdate?: boolean;
        }
        /**
         * Events for {@link ICalcGraph}.
         */
        interface Events {
            /**
             * Called when the calculation has been updated and
             * a calculation has not been started.
             */
            onInvalidate?(source: ICalcGraph): void;
            /**
             * Called when a calculation is started.
             */
            onStart?(source: ICalcGraph): void;
            /**
             * Called when a calculation is started.
             */
            onComplete?(source: ICalcGraph, results: ICalcGraph.Results): void;
            /**
             * Called when the calculation engine is unable to calc.
             *
             * @remarks
             * This is not when a specific function fails, but when the calculation engine is unable to complete the calculation.
             */
            onError?(source: ICalcGraph): void;
            /**
             * Called when the CalcGraph is closed.
             */
            onClose?(source: ICalcGraph): void;
        }
        interface IListeners extends IListener.Callbacks<ICalcGraph, ICalcGraph.Events> {
        }
        /**
         * Options available when creating a CalcGraph.
         */
        interface ConstructorOptions extends ICalculation.ConstructorOptions {
            /**
             * The calculation instance that will be used to calculate the graph.
             *
             * @remarks
             * Required as this will contain the context
             */
            calculation: ICalculation;
            /**
             * The Formula parser for creating FormulaBlocks.
             *
             * @remarks
             * This is passed in so that the Calculation engine can share lazy load
             */
            getFormulaParser: () => IFormulaParser;
            /**
             * A callback that identifies the sheet name.
             */
            getSheetName?(): string;
            /**
             * Callback that determines the maximum coordinates of the graph.
             */
            getEntireCoords?: () => IRange.Coords;
            /**
             * A callback that is called when the calculation is completed.
             *
             * @remarks
             * This will persist through clones.
             */
            onCalculated?: (results: ICalcGraph.Results) => void;
        }
        interface JSON {
            /**
             * The input and calced data.
             *
             * @remarks
             * This is usually empty as the data is managed by the client of the graph.
             */
            data?: Tuple.GridTuple<Scalar>;
            /**
             * The formulas
             */
            formulas?: [address: string, text: string][];
            /**
             * Indicates a range was created via a dynamic array formula.
             * This is a specific type of dynamic.
             */
            dynamic?: [address: string, error: boolean][];
            /**
             * Indicates the range contains volatile functions.
             *
             * @remarks
             * For built-in functions volatile will be auto added.
             */
            volatile?: string[];
        }
    }
}
declare module "primitives/ReferenceRange" {
    import { Scalar, ScalarType, IReferenceRange, IRange } from '@sheetxl/primitives';
    import { ISparseGrid } from "collections/index";
    import { Range } from "primitives/Range";
    export class ReferenceRange extends Range implements IReferenceRange {
        protected _sheetName: string;
        protected _getEntireCoords: () => IRange.Coords;
        constructor(values: ISparseGrid<Scalar>, type: ScalarType, coords: IRange.Coords, sheetName?: string, getEntireCoords?: () => IRange.Coords);
        /** @inheritdoc IRange.toType */
        toType(type: ScalarType): this;
        /** @inheritdoc IReferenceRange.getCoords */
        getCoords(): IRange.Coords;
        /** @inheritdoc IReferenceRange.isIReferenceRange */
        get isIReferenceRange(): true;
        /** {@inheritDoc IRange.isLiteral} */
        isLiteral(): boolean;
        protected _validateCoords(coords: Partial<IRange.Coords>): void;
        get [Symbol.toStringTag](): string;
        /** {@inheritDoc IRange.toString} */
        toString(): string;
    }
}
declare module "primitives/index" {
    export * from "primitives/Range";
    export * from "primitives/ReferenceRange";
}
declare module "calculation/graph/_Types" {
    import { Scalar, IRange } from '@sheetxl/primitives';
    import { type ISpatialMap, type ISparseGrid } from "collections/index";
    import { IConflatingRanges } from "collections/_GridUtils";
    import { FormulaBlockEntry, PrecedentEntry } from "calculation/spatial/index";
    import { CalcNode } from "calculation/graph/CalcState";
    import { ICalcGraph } from "calculation/graph/ICalcGraph";
    export interface ICalcGraphScope {
        rowIndex: number;
        colIndex: number;
        sheetName: string;
        node: CalcNode;
        values: ISparseGrid<Scalar>;
        spillSpatial: ISpatialMap;
        formulaSpatial: ISpatialMap<FormulaBlockEntry>;
        volatile: Set<CalcNode | CalcNode[][]>;
        conflatingFormats: IConflatingRanges;
        dynamicPrecedentsInserts: ISpatialMap.Entry<PrecedentEntry>[];
        formula: ICalcGraph.IFormulaBlock;
        getEntireCoords?: () => IRange.Coords;
    }
}
declare module "calculation/graph/CalcGraph" {
    import { IRange, Scalar, FormulaError } from '@sheetxl/primitives';
    import type { IListener } from "listener/index";
    import { ListenerEmitter } from "listener/ListenerEmitter";
    import { Tuple, ISparseGrid, ISpatialMap } from "collections/index";
    import { ICalculation } from "calculation/ICalculation";
    import type { ICalcGraph } from "calculation/graph/ICalcGraph";
    import { type CalcNode } from "calculation/graph/CalcState";
    import type { IFormulaParser } from "calculation/formula/index";
    import { FormulaBlockEntry, PrecedentEntry } from "calculation/spatial/index";
    import { IStringCollection } from "string/index";
    import { ContentfulEntry, SpillEntry } from "calculation/spatial/index";
    import { ICalcGraphScope } from "calculation/graph/_Types";
    /**
     * The CalcGraph is used to calculate the values in a direct graph.
     *
     * It is given a inputValues grid and a set of formulas.
     *
     * @remarks
     * If inputValues are externally managed then formulas update must also be provided.
     */
    export class CalcGraph implements ICalcGraph {
        _strings: IStringCollection;
        /**
         * Top down evaluation and marking dirty.
         * This is the only spatial map that completely updated via api.
         */
        _formulaSpatial: ISpatialMap<FormulaBlockEntry>;
        /**
         * This is MOST set by the user but spills also contribute.
         * * trying to keep look up to a bare minimum.
         */
        _values: ISparseGrid<Scalar>;
        _precedentSpatial: ISpatialMap<PrecedentEntry>;
        _volatile: Set<CalcNode | CalcNode[][]>;
        _spillSpatial: ISpatialMap<SpillEntry>;
        _errorSpatial: ISpatialMap<string>;
        _pendingSpatial: ISpatialMap<boolean>;
        _contentfulSpatial: ISpatialMap<ContentfulEntry>;
        _fullCalcRequired: boolean;
        _invalidations: ISpatialMap;
        _notifyValues: ISpatialMap;
        _notifySpills: ISpatialMap;
        _notifyFormats: ISpatialMap;
        _notifyPending: ISpatialMap<boolean>;
        _notifyFormulaInsertEntries: ISpatialMap.Entry<ICalcGraph.FormulaInsert>[];
        _notifyFormulaRemoveEntries: ISpatialMap.Entry<string>[];
        _cloneKey: CalcGraph;
        _latest: {
            graph: CalcGraph;
        };
        _iterationId: number;
        _uuid: string;
        _options: ICalcGraph.ConstructorOptions;
        _getEntireCoords: () => IRange.Coords;
        _calculation: ICalculation;
        _cycleId: number;
        _pendingInvalidations: Set<CalcNode>;
        _getFormulaParser: () => IFormulaParser;
        protected _emitter: ListenerEmitter<ICalcGraph, ICalcGraph.IListeners>;
        protected _isProcessingJSON: boolean;
        protected _onCalculated: (results: ICalcGraph.Results) => void;
        protected _pendingActions: (() => Promise<ICalcGraph.Results>)[];
        constructor(options?: ICalcGraph.ConstructorOptions);
        /** {@inheritDoc ICalcGraph.addListeners} */
        addListeners(listeners: ICalcGraph.IListeners, options?: IListener.Options): IListener.Remove;
        /** @inheritdoc ICalcGraph.clone */
        shift(options: ICalcGraph.ShiftOptions): this;
        /** @inheritdoc ICalcGraph.clone */
        clone(cloneKey?: any): this;
        /** {@inheritDoc ICalcGraph.invalidate} */
        invalidate(coords: (IRange.Coords | string)[]): void;
        /** {@inheritDoc ICalcGraph.setFormulaAt} */
        setFormulaAt(coords: IRange.CellCoords | string, formula: string | null): ISpatialMap.Updates<ICalcGraph.FormulaInsert>;
        /** {@inheritDoc ICalcGraph.getFormulaAt} */
        getFormulaAt(coords: IRange.CellCoords | string, r1c1?: boolean): string;
        protected _formulaAt(row: number, column: number): ISpatialMap.Entry<FormulaBlockEntry>;
        /** {@inheritDoc ICalcGraph.getDirectPrecedentsAt} */
        getDirectPrecedentsAt(row: number, column: number, includeInvalidIntersect?: boolean): readonly (IRange.Coords | FormulaError.Known)[] | null;
        /** {@inheritDoc ICalcGraph.getReferencesAt} */
        getReferencesAt(row: number, column: number): readonly (IRange.FixableCoords | string | FormulaError.Known)[];
        /** {@inheritDoc ICalcGraph.setReferenceAt} */
        setReferenceAt(row: number, column: number, index: number, reference: IRange.FixableCoords): this;
        /** {@inheritDoc ICalcGraph.evaluateAt} */
        evaluateAt(row: number, column: number, evalIndex: number): Promise<Scalar | IRange>;
        /** {@inheritDoc ICalcGraph.setInputAt} */
        setInputAt(coords: IRange.CellCoords | string, value: Scalar): ISpatialMap.Updates<ICalcGraph.FormulaInsert>;
        /** @inheritdoc ICalcGraph.setInputs */
        setInputs(values: Tuple.BoundedTuples<Scalar>, formulas: readonly ISpatialMap.Entry<string>[]): ISpatialMap.Updates<ICalcGraph.FormulaInsert>;
        /** {@inheritDoc ICalcGraph.delete} */
        delete(range: IRange.Coords | string): ISpatialMap.Entry[];
        /**
         * Create non error spill entries for move/copy.
         */
        protected _createCopySpillEntries(spillSpatial: ISpatialMap<SpillEntry>, from: IRange.Coords, to: IRange.Coords, reuseInserts?: ISpatialMap.Entry<SpillEntry>[], reuseRemoves?: ISpatialMap.Entry<SpillEntry>[]): ISpatialMap.Updates;
        /**
         * Will copy tiles and invalidate relative precedents that are out
         * of bounds.
         */
        protected _copyCalcs(graphFrom: CalcGraph, from: IRange.Coords, to: IRange.Coords): void;
        /**
         * * Will update absolute precedents from precedentEntries
         * * Relative precedents get shifted
         */
        protected _moveCalcs(graphFrom: CalcGraph, from: IRange.Coords, to: IRange.Coords): void;
        /** {@inheritDoc ICalcGraph.getSnapshot} */
        getSnapshot(options?: ICalcGraph.GetSnapshotOptions): ICalcGraph.ISnapshot;
        /** {@inheritDoc ICalcGraph.autoFill} */
        autoFill(template: IRange.Coords | string, destination: IRange.Coords | string): this;
        protected _scheduleRecalculation(nodes?: CalcNode | CalcNode[]): void;
        protected _notifyCalculated(options: ICalculation.CalculateOptions | boolean): Promise<ICalcGraph.Results>;
        _setInputs(values: Tuple.BoundedTuples<Scalar>, formulas: readonly ISpatialMap.Entry<string>[], deleteRange?: IRange.Coords): ISpatialMap.Updates<ICalcGraph.FormulaInsert>;
        protected _invalidate(invalidations: ISpatialMap.Entry[]): void;
        /**
         * Searches all invalidations and collects immediate CalcNodes.
         *
         * @param forceFull
         *
         * @remarks
         * Does not walk the graph.
         */
        protected _collectDirties: (markId: number, forceFull: boolean, coords: IRange.Coords[], volatile: Set<CalcNode | CalcNode[][]>) => CalcNode[];
        /**
         * Returns an execution plan (sorted order of nodes to evaluate)
         *
         * @remarks
         * Uses Kahn's algorithm.
         */
        protected _markAndPlan(isFullCalc: boolean, initial: CalcNode[], markId: number): MarkResults;
        protected _evaluate(forceFull: boolean): EvalResults;
        /** {@inheritDoc ICalcGraph.calculate} */
        calculate(options?: ICalculation.CalculateOptions | boolean): Promise<ICalcGraph.Results>;
        protected _clearScope(): void;
        protected _resetScope(): ICalcGraphScope;
        /**
         * Clears just the calculations.
         *
         * @remarks
         * * Leaves the formulas and externally set values in place.
         * * Does not bump the cycle id.
         */
        protected _clearCalcs(): void;
        protected _clearNotifications(): void;
        /**
         * Used before loading a new state
         */
        protected _clearAll(): void;
        protected _addToPending(action: () => Promise<ICalcGraph.Results>): void;
        /** {@inheritDoc ICalcGraph.fromJSON} */
        fromJSON(json: ICalcGraph.JSON): ICalcGraph.Results;
        /** {@inheritDoc ICalcGraph.fromJSON} */
        toJSON(includeData?: boolean): Promise<ICalcGraph.JSON>;
    }
    interface MarkResults {
        completed: boolean;
        onces: ISpatialMap.Entry<PrecedentEntry>[];
    }
    interface EvalResults {
        completed: boolean;
        dynamic: ISpatialMap.Entry<PrecedentEntry>[];
        count: number;
    }
    export function delegatingNodeSplitter2<T>(value: T, destination: [ISpatialMap.Entry<T>, ISpatialMap.Entry<T>], orientation: IRange.Orientation, offset: number): [ISpatialMap.Entry<T>, ISpatialMap.Entry<T>];
}
declare module "calculation/graph/index" {
    export * from "calculation/graph/ICalcGraph";
    export * from "calculation/graph/CalcGraph";
}
declare module ".generated/formulas/impl/cube/Cube" {
    /**
     * @hidden Unimplemented
     * @summary Returns a key performance indicator (KPI) property and displays the KPI name in the cell.
     * @param connection is the name of a connection to an OLAP cube
     * @param kpiName is the KPI name
     * @param kpiProperty is the KPI property
     * @param caption is the caption to be displayed in the cell
     */
    export function CUBEKPIMEMBER(connection: string, kpiName: string, kpiProperty: number, // option 1-6
    caption?: string): Promise<string>;
    /**
     * @hidden Unimplemented
     * @summary Returns a member or tuple from the cube.
     * @param connection is the name of a connection to an OLAP cube
     * @param memberExpression is the expression representing the name of a member or tuple in the OLAP cube
     * @param caption is the caption to be displayed in the cell
     */
    export function CUBEMEMBER(connection: string, memberExpression: string, caption?: string): Promise<string>;
    /**
     * @hidden Unimplemented
     * @summary Returns the value of a member property from the cube.
     * @param connection is the name of a connection to an OLAP cube
     * @param memberExpression is the expression representing the name of a member in the OLAP cube
     * @param kpiProperty is the property name
     */
    export function CUBEMEMBERPROPERTY(connection: string, memberExpression: string, kpiProperty: number): Promise<string>;
    /**
     * @hidden Unimplemented
     * @summary Returns the nth, or ranked, member in a set.
     * @param connection is the name of a connection to an OLAP cube
     * @param setExpression is the set from which the element is to be retrieved
     * @param rank is the rank of the element to be retrieved
     * @param caption is the caption to be displayed in the cell
     */
    export function CUBERANKEDMEMBER(connection: string, setExpression: string, rank: number, // 1 - 5
    caption?: string): Promise<string>;
    /**
     * @hidden Unimplemented
     * @summary Defines a calculated set of members or tuples by sending a set expression to the cube on the server, which creates the set, and then returns that set to Microsoft Excel.
     * @param connection is the name of a connection to an OLAP cube
     * @param setExpression is the expression for the set
     * @param caption is the caption to be displayed in the cell
     * @param sortOrder is the sort order
     * @param sortBy is the sort by
     *
     * @remarks
     * https://support.office.com/client/results?authtype=unknown&lcid=1033&locale=en-us&microsoftapplicationstelemetrydeviceid=70192ff8-de17-4a6b-8e59-35903120b479&ns=EXCEL&syslcid=1033&uilcid=1033&version=90&helpid=xlmain11.chm60526
     */
    export function CUBESET(connection: string, setExpression: string, caption?: string, sortOrder?: number, // 1 - 6
    sortBy?: string): Promise<string>;
    /**
     * @hidden Unimplemented
     * @summary Returns the number of items in a set.
     * @param set is the set whose elements are to be counted
     */
    export function CUBESETCOUNT(set: string): Promise<number>;
    /**
     * @hidden Unimplemented
     * @summary Returns an aggregated value from the cube.
     * @param connection is the name of a connection to an OLAP cube
     * @param memberExpression
     */
    export function CUBEVALUE(connection: string, ...memberExpression: string[]): Promise<string>;
}
declare module ".generated/formulas/impl/database/Database" {
    import { IRange } from '@sheetxl/primitives';
    /**
     * @hidden Unimplemented
     * @summary Averages the values in a column in a list or database that match conditions you specify
     * @param database is the range of cells that makes up the list or database. A database is a list of related data
     * @param field is either the label of the column in double quotation marks or a number that represents the column's position in the list
     * @param criteria is the range of cells that contains the conditions you specify. The range includes a column label and one cell below the label for a condition
     */
    export function DAVERAGE(database: IRange, field: string, criteria: IRange<string>): Promise<IRange>;
    /**
     * @hidden Unimplemented
     * @summary Counts the cells containing numbers in the field (column) of records in the database that match the conditions you specify
     * @param database is the range of cells that makes up the list or database. A database is a list of related data
     * @param field is either the label of the column in double quotation marks or a number that represents the column's position in the list
     * @param criteria is the range of cells that contains the conditions you specify. The range includes a column label and one cell below the label for a condition
     */
    export function DCOUNT(database: IRange, field: string, criteria: IRange<string>): Promise<IRange>;
    /**
     * @hidden Unimplemented
     * @summary Counts nonblank cells in the field (column) of records in the database that match the conditions you specify
     * @param database is the range of cells that makes up the list or database. A database is a list of related data
     * @param field is either the label of the column in double quotation marks or a number that represents the column's position in the list
     * @param criteria is the range of cells that contains the conditions you specify. The range includes a column label and one cell below the label for a condition
     */
    export function DCOUNTA(database: IRange, field: string, criteria: IRange<string>): Promise<IRange>;
    /**
     * @hidden Unimplemented
     * @summary Extracts from a database a single record that matches the conditions you specify
     * @param database is the range of cells that makes up the list or database. A database is a list of related data
     * @param field is either the label of the column in double quotation marks or a number that represents the column's position in the list
     * @param criteria is the range of cells that contains the conditions you specify. The range includes a column label and one cell below the label for a condition
     */
    export function DGET(database: IRange, field: string, criteria: IRange<string>): Promise<IRange>;
    /**
     * @hidden Unimplemented
     * @summary Returns the largest number in the field (column) of records in the database that match the conditions you specify
     * @param database is the range of cells that makes up the list or database. A database is a list of related data
     * @param field is either the label of the column in double quotation marks or a number that represents the column's position in the list
     * @param criteria is the range of cells that contains the conditions you specify. The range includes a column label and one cell below the label for a condition
     */
    export function DMAX(database: IRange, field: string, criteria: IRange<string>): Promise<IRange>;
    /**
     * @hidden Unimplemented
     * @summary Returns the smallest number in the field (column) of records in the database that match the conditions you specify
     * @param database is the range of cells that makes up the list or database. A database is a list of related data
     * @param field is either the label of the column in double quotation marks or a number that represents the column's position in the list
     * @param criteria is the range of cells that contains the conditions you specify. The range includes a column label and one cell below the label for a condition
     */
    export function DMIN(database: IRange, field: string, criteria: IRange<string>): Promise<IRange>;
    /**
     * @hidden Unimplemented
     * @summary Multiplies the values in the field (column) of records in the database that match the conditions you specify
     * @param database is the range of cells that makes up the list or database. A database is a list of related data
     * @param field is either the label of the column in double quotation marks or a number that represents the column's position in the list
     * @param criteria is the range of cells that contains the conditions you specify. The range includes a column label and one cell below the label for a condition
     */
    export function DPRODUCT(database: IRange, field: string, criteria: IRange<string>): Promise<IRange>;
    /**
     * @hidden Unimplemented
     * @summary Estimates the standard deviation based on a sample from selected database entries
     * @param database is the range of cells that makes up the list or database. A database is a list of related data
     * @param field is either the label of the column in double quotation marks or a number that represents the column's position in the list
     * @param criteria is the range of cells that contains the conditions you specify. The range includes a column label and one cell below the label for a condition
     */
    export function DSTDEV(database: IRange, field: string, criteria: IRange<string>): Promise<IRange>;
    /**
     * @hidden Unimplemented
     * @summary Calculates the standard deviation based on the entire population of selected database entries
     * @param database is the range of cells that makes up the list or database. A database is a list of related data
     * @param field is either the label of the column in double quotation marks or a number that represents the column's position in the list
     * @param criteria is the range of cells that contains the conditions you specify. The range includes a column label and one cell below the label for a condition
     */
    export function DSTDEVP(database: IRange, field: string, criteria: IRange<string>): Promise<IRange>;
    /**
     * @hidden Unimplemented
     * @summary Adds the numbers in the field (column) of records in the database that match the conditions you specify
     * @param database is the range of cells that makes up the list or database. A database is a list of related data
     * @param field is either the label of the column in double quotation marks or a number that represents the column's position in the list
     * @param criteria is the range of cells that contains the conditions you specify. The range includes a column label and one cell below the label for a condition
     */
    export function DSUM(database: IRange, field: string, criteria: IRange<string>): Promise<IRange>;
    /**
     * @hidden Unimplemented
     * @summary Estimates variance based on a sample from selected database entries
     * @param database is the range of cells that makes up the list or database. A database is a list of related data
     * @param field is either the label of the column in double quotation marks or a number that represents the column's position in the list
     * @param criteria is the range of cells that contains the conditions you specify. The range includes a column label and one cell below the label for a condition
     */
    export function DVAR(database: IRange, field: string, criteria: IRange<string>): Promise<IRange>;
    /**
     * @hidden Unimplemented
     * @summary Calculates variance based on the entire population of selected database entries
     * @param database is the range of cells that makes up the list or database. A database is a list of related data
     * @param field is either the label of the column in double quotation marks or a number that represents the column's position in the list
     * @param criteria is the range of cells that contains the conditions you specify. The range includes a column label and one cell below the label for a condition
     */
    export function DVARP(database: IRange, field: string, criteria: IRange<string>): Promise<IRange>;
}
declare module ".generated/formulas/impl/_utils/_Types" {
    export const Types: {
        NUMBER: number;
        ARRAY: number;
        BOOLEAN: number;
        STRING: number;
        RANGE_REF: number;
        CELL_REF: number;
        NUMBER_NO_BOOLEAN: number;
    };
}
declare module ".generated/formulas/impl/_utils/_Helpers" {
    import { FormulaError } from '@sheetxl/primitives';
    /**
     * Formula helpers.
     */
    class _FormulaHelpers {
        protected Types: {
            NUMBER: number;
            ARRAY: number;
            BOOLEAN: number;
            STRING: number;
            RANGE_REF: number;
            CELL_REF: number;
            NUMBER_NO_BOOLEAN: number;
        };
        protected type2Number: {
            number: number;
            boolean: number;
            string: number;
            object: number;
        };
        /**
         * Flatten an array
         * @param {Array} arr1
         * @returns {*}
         */
        flattenDeep(arr1: any[]): any;
        /**
         *
         * @param obj
         * @param isArray - if it is an array: [1,2,3], will extract the first element
         * @param allowBoolean - Allow parse boolean into number
         */
        acceptNumber(obj: any, isArray?: boolean, allowBoolean?: boolean): number | FormulaError.Known;
        /**
         * Flatten parameters to 1D array.
         * @see {@link FormulaHelpers.accept}
         * @param {Array} params - Parameter that needs to flatten.
         * @param {Types|null} valueType - The type each item should be,
         *                          null if allows any type. This only applies to literals.
         * @param {boolean} allowUnion - Allow union, e.g. (A1:C1, E4:F3)
         * @param {function} hook - Invoked after parsing each item.
         *                         of the array.
         * @param {*} [defValue=null] - The value if an param is omitted. i.e. SUM(1,2,,,,,)
         * @param {number} [minSize=1] - The minimum size of the parameters
         */
        flattenParams(params: any[], valueType: any, allowUnion: boolean, hook: (param: any, info: any) => void, defValue?: any, minSize?: any): any;
        /**
         * Check if the param valid, return the parsed param.
         * If type is not given, return the un-parsed param.
         * @param {*} param
         * @param {number|null} [type] - The expected type
         *           NUMBER: Expect a single number,
         *           ARRAY: Expect an flatten array,
         *           BOOLEAN: Expect a single boolean,
         *           STRING: Expect a single string,
         *           COLLECTIONS: Expect an Array of the above types
         *           null: Do not parse the value, return it directly.
         *           The collection is not a flatted array.
         * @param {*} [defValue] - Default value if the param is not given.
         *               if undefined, this param is required, a Error will throw if not given.
         *               if null, and param is undefined, null will be returned.
         * @param {boolean} [flat=true] - If the array should be flattened,
         *                      only applicable when type is ARRAY.
         *                      If false, collection is disallowed.
         * @param {boolean} allowSingleValue - If pack single value into 2d array,
         *                     only applicable when type is ARRAY.
         * @returns {string|number|boolean|{}|Array}
         */
        accept(param: any, type?: any, defValue?: any, flat?: boolean, allowSingleValue?: boolean): any;
        type(variable: any): number;
    }
    export const FormulaHelpers: _FormulaHelpers;
}
declare module ".generated/formulas/impl/dateTime/Date" {
    import { Scalar } from '@sheetxl/primitives';
    /**
     * @summary Returns the number that represents the date in Microsoft Excel date-time code
     * @param year is a number from 1900 or 1904 (depending on the workbook's date system) to 9999
     * @param month is a number from 1 to 12 representing the month of the year
     * @param day is a number from 1 to 31 representing the day of the month
     */
    export function DATE(year: number, month: number, day: number): number;
    /**
     * @hidden Legacy
     * @summary Returns the number of days between two dates
     * @param startDate is a serial date number that represents the start date
     * @param endDate is a serial date number that represents the end date
     * @param unit is a string that specifies the unit of time to use
     */
    export function DATEDIF(startDate: number, // date
    endDate: number, // date
    unit: string): number;
    /**
     * @hidden Legacy
     * @summary Returns NA.
     * @param number is a number that is ignored
     */
    export function DATESTRING(number: number): any;
    /**
     * @summary Converts a date in the form of text to a number that represents the date in Microsoft Excel date-time code
     * @param dateText is text that represents a date in a Microsoft Excel date format, between 1/1/1900 or 1/1/1904 (depending on the workbook's date system) and 12/31/9999
     */
    export function DATEVALUE(dateText: string): number;
    /**
     * @summary Returns the day of the month, a number from 1 to 31.
     * @param serialOrString is a number in the date-time code used by Excel or text in time format, such as 16:48:00 or 4:48:00 PM
     */
    export function DAY(serialOrString: Scalar): number;
    /**
     * @summary Returns the number of days between the two dates.
     * @param endDate start_date and end_date are the two dates between which you want to know the number of days
     * @param startDate start_date and end_date are the two dates between which you want to know the number of days
     */
    export function DAYS(endDate: number, //date
    startDate: number): number;
    /**
     * @summary Returns the number of days between two dates based on a 360-day year (twelve 30-day months)
     * @param endDate start_date and end_date are the two dates between which you want to know the number of days
     * @param startDate start_date and end_date are the two dates between which you want to know the number of days
     * @param method is a logical value specifying the calculation method: U.S. (NASD) = FALSE; European = TRUE.
     */
    export function DAYS360(startDate: number, // date
    endDate: number, // date
    method?: boolean): number;
    /**
     * @summary Returns the serial number of the date that is the indicated number of months before or after the start date
     * @param startDate is a serial date number that represents the start date
     * @param months is the number of months before or after start_date
     */
    export function EDATE(startDate: Date, months: number): number;
    /**
     * @summary Returns the serial number of the last day of the month before or after a specified number of months
     * @param startDate is a serial date number that represents the start date
     * @param months is the number of months before or after the start_date
     */
    export function EOMONTH(startDate: Date, months: number): number;
    /**
     * @summary Returns the hour as a number from 0 (12:00 A.M.) to 23 (11:00 P.M.).
     * @param serialOrString is a number in the date-time code used by Excel or text in time format, such as 16:48:00 or 4:48:00 PM
     */
    export function HOUR(serialOrString: Scalar): number;
    /**
     * @summary Returns the ISO week number in the year for a given date
     * @param serialOrString is a number in the date-time code used by Excel or text in time format, such as 16:48:00 or 4:48:00 PM
     */
    export function ISOWEEKNUM(serialOrString: Scalar): number;
    /**
     * @summary Returns the minute, a number from 0 to 59.
     * @param serialOrString is a number in the date-time code used by Excel or text in time format, such as 16:48:00 or 4:48:00 PM
     */
    export function MINUTE(serialOrString: string): number;
    /**
     * @summary Returns the month, a number from 1 (January) to 12 (December).
     * @param serialOrString is a number in the date-time code used by Excel
     */
    export function MONTH(serialOrString: string): number;
    /**
     * @summary Returns the number of whole workdays between two dates
     * @param startDate is a serial date number that represents the start date
     * @param endDate is a serial date number that represents the end date
     * @param holidays is an optional set of one or more serial date numbers to exclude from the working calendar, such as state and federal holidays and floating holidays
     */
    export function NETWORKDAYS(startDate: Date, endDate: Date, holidays?: number[]): number;
    /**
     * @name NETWORKDAYS.INTL
     * @summary Returns the number of whole workdays between two dates with custom weekend parameters
     * @param startDate is a serial date number that represents the start date
     * @param endDate is a serial date number that represents the end date
     * @param weekend is a number or string specifying when weekends occur
     * @param holidays is an optional set of one or more serial date numbers to exclude from the working calendar, such as state and federal holidays and floating holidays
     */
    export function NETWORKDAYS_INTL(startDate: Date, endDate: Date, weekend?: any, holidays?: number[]): number;
    /**
     * @summary Returns the current date and time formatted as a date and time.
     */
    export function NOW(): number;
    /**
     * @summary Returns the second, a number from 0 to 59.
     * @param serialOrString is a number in the date-time code used by Excel or text in time format, such as 16:48:23 or 4:48:47 PM
     */
    export function SECOND(serialOrString: Scalar): number;
    /**
     * @summary Converts hours, minutes, and seconds given as numbers to an Excel serial number, formatted with a time format
     * @param hour is a number from 0 to 23 representing the hour
     * @param minute is a number from 0 to 59 representing the minute
     * @param second is a number from 0 to 59 representing the second
     */
    export function TIME(hour: number, minute: number, second: number): number;
    /**
     * @summary Converts a text time to an Excel serial number for a time, a number from 0 (12:00:00 AM) to 0.999988426 (11:59:59 PM). Format the number with a time format after entering the formula
     * @param timeText is a text string that gives a time in any one of the Excel time formats (date information in the string is ignored)
     */
    export function TIMEVALUE(timeText: string): number;
    /**
     * @summary Returns the current date formatted as a date.
     */
    export function TODAY(): number;
    /**
     * @summary Returns a number from 1 to 7 identifying the day of the week of a date.
     * @param serialOrString is a number that represents a date
     * @param returnType is a number: for Sunday=1 through Saturday=7, use 1; for Monday=1 through Sunday=7, use 2; for Monday=0 through Sunday=6, use 3
     */
    export function WEEKDAY(serialOrString: Scalar, returnType?: number): number;
    /**
     * @summary Returns the week number in the year
     * @param serialOrString is the date-time code used by Excel for date and time calculation
     * @param returnType is a number (1 or 2) that determines the type of the return value
     */
    export function WEEKNUM(serialOrString: any, returnType?: number): number;
    /**
     * @summary Returns the serial number of the date before or after a specified number of workdays
     * @param startDate is a serial date number that represents the start date
     * @param days is the number of nonweekend and non-holiday days before or after start_date
     * @param holidays is an optional array of one or more serial date numbers to exclude from the working calendar, such as state and federal holidays and floating holidays
     */
    export function WORKDAY(startDate: Date, days: number, holidays?: number[]): number;
    /**
     * @name WORKDAY.INTL
     * @summary Returns the serial number of the date before or after a specified number of workdays with custom weekend parameters
     * @param startDate is a serial date number that represents the start date
     * @param days is the number of nonweekend and non-holiday days before or after start_date
     * @param weekend is a number or string specifying when weekends occur
     * @param holidays is an optional array of one or more serial date numbers to exclude from the working calendar, such as state and federal holidays and floating holidays
     */
    export function WORKDAY_INTL(startDate: Date, days: number, weekend?: any, holidays?: number[]): number;
    /**
     * @summary Returns the year of a date, an integer in the range 1900 - 9999.
     * @param serialOrString is a number in the date-time code used by Excel
     */
    export function YEAR(serialOrString: Scalar): number;
    /**
     * @summary Returns the year fraction representing the number of whole days between start_date and end_date
     * @param startDate is a serial date number that represents the start date
     * @param endDate is a serial date number that represents the end date
     * @param basis is the type of day count basis to use
     */
    export function YEARFRAC(startDate: number, endDate: number, basis?: number): number;
}
declare module ".generated/formulas/impl/engineering/Bessel" {
    /**
     * @summary Returns the modified Bessel function In(x)
     * @param x is the value at which to evaluate the function
     * @param n is the order of the Bessel function
     */
    export function BESSELI(x: number, n: number): number;
    /**
     * @summary Returns the Bessel function Jn(x)
     * @param x is the value at which to evaluate the function
     * @param n is the order of the Bessel function
     */
    export function BESSELJ(x: number, n: number): number;
    /**
     * @summary Returns the modified Bessel function Kn(x)
     * @param x is the value at which to evaluate the function
     * @param n is the order of the function
     */
    export function BESSELK(x: number, n: number): number;
    /**
     * @summary Returns the Bessel function Yn(x)
     * @param x is the value at which to evaluate the function
     * @param n is the order of the function
     */
    export function BESSELY(x: number, n: number): number;
}
declare module ".generated/formulas/impl/engineering/Bitwise" {
    import { Scalar } from '@sheetxl/primitives';
    /**
     * @summary Converts a binary number to decimal
     * @param number is the binary number you want to convert
     */
    export function BIN2DEC(number: number): number;
    /**
     * @summary Converts a binary number to hexadecimal
     * @param number is the binary number you want to convert
     * @param places is the number of characters to use
     */
    export function BIN2HEX(number: number, places?: number): string;
    /**
     * @summary Converts a binary number to octal
     * @param number is the binary number you want to convert
     * @param places is the number of characters to use
     */
    export function BIN2OCT(number: number, places?: number): string;
    /**
     * @summary Returns a bitwise 'And' of two numbers
     * @param number1 is the decimal representation of the binary number you want to evaluate
     * @param number2 is the decimal representation of the binary number you want to evaluate
     */
    export function BITAND(number1: Scalar, number2: Scalar): number;
    /**
     * @summary Returns a number shifted left by shift_amount bits
     * @param number is the decimal representation of the binary number you want to evaluate
     * @param shiftAmount is the number of bits that you want to shift Number left by
     */
    export function BITLSHIFT(number: Scalar, shiftAmount: number): number;
    /**
     * @summary Returns a bitwise 'Or' of two numbers
     * @param number1 is the decimal representation of the binary number you want to evaluate
     * @param number2 is the decimal representation of the binary number you want to evaluate
     */
    export function BITOR(number1: Scalar, number2: Scalar): number;
    /**
     * @summary Returns a number shifted right by shift_amount bits
     * @param number is the decimal representation of the binary number you want to evaluate
     * @param shiftAmount is the number of bits that you want to shift Number left by
     */
    export function BITRSHIFT(number: Scalar, shiftAmount: number): number;
    /**
     * @summary Returns a bitwise 'Exclusive Or' of two numbers
     * @param number1 is the decimal representation of the binary number you want to evaluate
     * @param number2 is the decimal representation of the binary number you want to evaluate
     */
    export function BITXOR(number1: Scalar, number2: Scalar): number;
    /**
     * @summary Converts a decimal number to binary
     * @param number is the decimal integer you want to convert
     * @param places is the number of characters to use
     */
    export function DEC2BIN(number: number, places?: number): string;
    /**
     * @summary Converts a decimal number to hexadecimal
     * @param number is the decimal integer you want to convert
     * @param places is the number of characters to use
     */
    export function DEC2HEX(number: number, places?: number): string;
    /**
     * @summary Converts a decimal number to octal
     * @param number is the decimal integer you want to convert
     * @param places is the number of characters to use
     */
    export function DEC2OCT(number: number, places?: number): string;
    /**
     * @summary Converts a Hexadecimal number to binary
     * @param number is the hexadecimal number you want to convert
     * @param places is the number of characters to use
     */
    export function HEX2BIN(number: string, places?: number): string | number;
    /**
     * @summary Converts a hexadecimal number to decimal
     * @param number is the hexadecimal number you want to convert
     */
    export function HEX2DEC(number: string): number;
    /**
     * @summary Converts a hexadecimal number to octal
     * @param number is the hexadecimal number you want to convert
     * @param places is the number of characters to use
     */
    export function HEX2OCT(number: string, places?: number): string;
    /**
     * @summary Converts an octal number to binary
     * @param number is the octal number you want to convert
     * @param places is the number of characters to use
     */
    export function OCT2BIN(number: string, places?: number): string;
    /**
     * @summary Converts an octal number to decimal
     * @param number is the octal number you want to convert
     */
    export function OCT2DEC(number: string): number;
    /**
     * @summary Converts an octal number to hexadecimal
     * @param number is the octal number you want to convert
     * @param places is the number of characters to use
     */
    export function OCT2HEX(number: string, places?: number): string | number;
}
declare module ".generated/formulas/impl/engineering/Convert" {
    /**
     * @summary Converts a number from one measurement system to another
     * @param number is the value in from_unit to convert.
     * @param fromUnit is the units for number.
     * @param toUnit is the units for the result
     */
    export function CONVERT(number: number, fromUnit: string, toUnit: string): number;
}
declare module ".generated/formulas/impl/engineering/Engineering" {
    /**
     * @summary Tests whether two numbers are equal
     * @param number1 is the first number
     * @param number2 is the second number
     */
    export function DELTA(number1: number, number2?: number): number;
    /**
     * @summary Tests whether a number is greater than a threshold value
     * @param number is the value to test against step
     * @param step is the threshold value
     */
    export function GESTEP(number: number, step?: number): number;
}
declare module ".generated/formulas/impl/engineering/Error" {
    /**
     * @summary Returns the error function
     * @param lowerLimit is the lower bound for integrating ERF
     * @param upperLimit is the upper bound for integrating ERF
     */
    export function ERF(lowerLimit: number, upperLimit?: number): number;
    /**
     * @name ERF.PRECISE
     * @summary Returns the error function
     * @param x is the lower bound for integrating ERF.PRECISE
     */
    export function ERF_PRECISE(x: number): number;
    /**
     * @summary Returns the complementary error function
     * @param x is the lower bound for integrating ERF
     */
    export function ERFC(x: number): number;
}
declare module ".generated/formulas/impl/engineering/Imaginary" {
    import { Scalar } from '@sheetxl/primitives';
    /**
     * @summary Converts real and imaginary coefficients into a complex number
     * @param realNum is the real coefficient of the complex number
     * @param iNum is the imaginary coefficient of the complex number
     * @param suffix is the suffix for the imaginary component of the complex number
     */
    export function COMPLEX(realNum: number, iNum: number, suffix?: string): string | number;
    /**
     * @summary Returns the absolute value (modulus) of a complex number
     * @param inumber is a complex number for which you want the absolute value
     */
    export function IMABS(inumber: Scalar): number;
    /**
     * @summary Returns the imaginary coefficient of a complex number
     * @param inumber is a complex number for which you want the imaginary coefficient
     */
    export function IMAGINARY(inumber: Scalar): number;
    /**
     * @summary Returns the argument q, an angle expressed in radians
     * @param inumber is a complex number for which you want the argument
     */
    export function IMARGUMENT(inumber: Scalar): number;
    /**
     * @summary Returns the complex conjugate of a complex number
     * @param inumber is a complex number for which you want the conjugate
     */
    export function IMCONJUGATE(inumber: Scalar): string | number;
    /**
     * @summary Returns the cosine of a complex number
     * @param inumber is a complex number for which you want the cosine
     */
    export function IMCOS(inumber: Scalar): string | number;
    /**
     * @summary Returns the hyperbolic cosine of a complex number
     * @param inumber is a complex number for which you want the hyperbolic cosine
     */
    export function IMCOSH(inumber: Scalar): string | number;
    /**
     * @summary Returns the cotangent of a complex number
     * @param inumber is a complex number for which you want the cotangent
     */
    export function IMCOT(inumber: Scalar): string | number;
    /**
     * @summary Returns the cosecant of a complex number
     * @param inumber is a complex number for which you want the cosecant
     */
    export function IMCSC(inumber: Scalar): string | number;
    /**
     * @summary Returns the hyperbolic cosecant of a complex number
     * @param inumber is a complex number for which you want the hyperbolic cosecant
     */
    export function IMCSCH(inumber: Scalar): string | number;
    /**
     * @summary Returns the quotient of two complex numbers
     * @param inumber1 is the complex numerator or dividend
     * @param inumber2 is the complex denominator or divisor
     */
    export function IMDIV(inumber1: Scalar, inumber2: Scalar): string | number;
    /**
     * @summary Returns the exponential of a complex number
     * @param inumber is a complex number for which you want the exponential
     */
    export function IMEXP(inumber: Scalar): string | number;
    /**
     * @summary Returns the exponential of a complex number
     * @param inumber is a complex number for which you want the exponential
     */
    export function IMLN(inumber: Scalar): string | number;
    /**
     * @summary Returns the base-10 logarithm of a complex number
     * @param inumber is a complex number for which you want the common logarithm
     */
    export function IMLOG10(inumber: Scalar): string | number;
    /**
     * @summary Returns the base-2 logarithm of a complex number
     * @param inumber is a complex number for which you want the base-2 logarithm
     */
    export function IMLOG2(inumber: Scalar): string | number;
    /**
     * @summary Returns the base-2 logarithm of a complex number
     * @param inumber is a complex number for which you want the base-2 logarithm
     */
    export function IMPOWER(inumber: Scalar, number: number): string | number;
    /**
     * @summary Returns the product of 1 to 255 complex numbers
     * @param inumber inumber1,inumber2,... Inumber1, Inumber2,... are from 1 to 255 complex numbers to multiply.
     */
    export function IMPRODUCT(...inumber: Scalar[]): string | number;
    /**
     * @summary Returns the real coefficient of a complex number
     * @param inumber is a complex number for which you want the real coefficient
     */
    export function IMREAL(inumber: Scalar): number;
    /**
     * @summary Returns the secant of a complex number
     * @param inumber is a complex number for which you want the secant
     */
    export function IMSEC(inumber: Scalar): string | number;
    /**
     * @summary Returns the hyperbolic secant of a complex number
     * @param inumber is a complex number for which you want the hyperbolic secant
     */
    export function IMSECH(inumber: Scalar): string | number;
    /**
     * @summary Returns the sine of a complex number
     * @param inumber is a complex number for which you want the sine
     */
    export function IMSIN(inumber: Scalar): string | number;
    /**
     * @summary Returns the hyperbolic sine of a complex number
     * @param inumber is a complex number for which you want the hyperbolic sine
     */
    export function IMSINH(inumber: Scalar): string | number;
    /**
     * @summary Returns the square root of a complex number
     * @param inumber is a complex number for which you want the square root
     */
    export function IMSQRT(inumber: Scalar): string | number;
    /**
     * @summary Returns the difference of two complex numbers
     * @param inumber1 is the complex number from which to subtract inumber2
     * @param inumber2 is the complex number to subtract from inumber1
     */
    export function IMSUB(inumber1: Scalar, inumber2: Scalar): string | number;
    /**
     * @summary Returns the sum of complex numbers
     * @param inumber inumber1,inumber2,... are from 1 to 255 complex numbers to add
     */
    export function IMSUM(...inumber: Scalar[]): string | number;
    /**
     * @summary Returns the tangent of a complex number
     * @param inumber is a complex number for which you want the tangent
     */
    export function IMTAN(inumber: Scalar): string | number;
}
declare module ".generated/formulas/impl/financial/Financial" {
    import { IRange } from '@sheetxl/primitives';
    /**
     * @summary Returns the accrued interest for a security that pays periodic interest.
     * @param issue is the security's issue date, expressed as a serial date number
     * @param firstInterest is the security's first interest date, expressed as a serial date number
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param rate is the security's annual coupon rate
     * @param par is the security's par value
     * @param frequency is the number of coupon payments per year
     * @param basis is the type of day count basis to use
     * @param calcMethod is a logical value: to accrued interest from issue date = TRUE; to calculate from last coupon payment date = FALSE
     *
     * @remarks
     * {@link https://support.microsoft.com/en-us/office/accrint-function-fe45d089-6722-4fb3-9379-e1f911d8dc74|Docs}
     */
    export function ACCRINT(issue: number, // date
    firstInterest: number, //date
    settlement: number, //date
    rate: number, par: number, frequency: number, basis?: number, calcMethod?: boolean): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the accrued interest for a security that pays interest at maturity
     * @param issue is the security's issue date, expressed as a serial date number
     * @param settlement is the security's maturity date, expressed as a serial date number
     * @param rate is the security's annual coupon rate
     * @param par is the security's par value
     * @param basis is the type of day count basis to use
     */
    export function ACCRINTM(issue: number, // date
    settlement: number, // date
    rate: number, par: number, basis?: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the prorated linear depreciation of an asset for each accounting period.
     * @param cost is the cost of the asset
     * @param datePurchased is the date the asset is purchased
     * @param firstPeriod is the date of the end of the first period
     * @param salvarge is the salvage value at the end of life of the asset.
     * @param period is the period
     * @param rate is the rate of depreciation
     * @param basis year_basis : 0 for year of 360 days, 1 for actual, 3 for year of 365 days.
     */
    export function AMORLINC(cost: number, datePurchased: number, // date
    firstPeriod: number, salvarge: number, period: number, rate: number, basis?: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the number of days from the beginning of the coupon period to the settlement date
     * @param settlement is the security's settlement date, expressed as a serial date number is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param frequency is the number of coupon payments per year
     * @param basis is the type of day count basis to use
     */
    export function COUPDAYBS(settlement: number, // date
    maturity: number, // date
    frequency: number, basis?: number): number;
    /**
     * @summary Returns the number of days from the beginning of the coupon period to the settlement date
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param frequency is the number of coupon payments per year
     * @param basis is the type of day count basis to use
     */
    export function COUPDAYS(settlement: number, // date
    maturity: number, // date
    frequency: number, basis?: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the next coupon date after the settlement date
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param frequency is the number of coupon payments per year
     * @param basis is the type of day count basis to use
     */
    export function COUPNCD(settlement: number, // date
    maturity: number, // date
    frequency: number, basis?: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the number of coupons payable between the settlement date and maturity date
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param frequency is the number of coupon payments per year
     * @param basis is the type of day count basis to use
     */
    export function COUPNUM(settlement: number, // date
    maturity: number, // date
    frequency: number, basis?: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the previous coupon date before the settlement date
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param frequency is the number of coupon payments per year
     * @param basis is the type of day count basis to use
     */
    export function COUPPCD(settlement: number, // date
    maturity: number, // date
    frequency: number, basis?: number): number;
    /**
     * @summary Returns the cumulative interest paid between two periods
     * @param rate is the interest rate
     * @param nper is the total number of payment periods
     * @param pv is the present value of the investment
     * @param startPeriod is the first period in the calculation
     * @param endPeriod is the last period in the calculation
     * @param type is the timing of the payment
     */
    export function CUMIPMT(rate: number, nper: number, pv: number, startPeriod: number, // date
    endPeriod: number, // date
    type: number): number;
    /**
     * @summary Returns the cumulative principal paid on a loan between two periods
     * @param rate is the interest rate
     * @param nper is the total number of payment periods
     * @param pv is the present value of the investment
     * @param startPeriod is the first period in the calculation
     * @param endPeriod is the last period in the calculation
     * @param type is the timing of the payment
     */
    export function CUMPRINC(rate: number, nper: number, pv: number, startPeriod: number, // date
    endPeriod: number, // date
    type: number): number;
    /**
     * @summary Returns the depreciation of an asset for a specified period using the fixed-declining balance method
     * @param cost is the initial cost of the asset
     * @param salvage is the salvage value at the end of the life of the asset
     * @param life is the number of periods over which the asset is being depreciated (sometimes called the useful life of the asset)
     * @param period is the period for which you want to calculate the depreciation. Period must use the same units as Life
     * @param month is the number of months in the first year
     */
    export function DB(cost: number, salvage: number, life: number, period: number, month?: number): number;
    /**
     * @summary Returns the depreciation of an asset for a specified period using the double-declining balance method or some other method you specify
     * @param cost is the initial cost of the asset
     * @param salvage is the salvage value at the end of the life of the asset
     * @param life is the number of periods over which the asset is being depreciated (sometimes called the useful life of the asset)
     * @param period is the period for which you want to calculate the depreciation. Period must use the same units as Life
     * @param factor is the rate at which the balance declines
     */
    export function DDB(cost: number, salvage: number, life: number, period: number, factor?: number): number;
    /**
     * @summary Returns the discount rate for a security
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param pr is the security's price per $100 face value
     * @param redemption is the security's redemption value per $100 face value
     * @param basis is the type of day count basis to use
     */
    export function DISC(settlement: number, // date
    maturity: number, // date
    pr: number, redemption: number, basis?: number): number;
    /**
     * @summary Converts a dollar price, expressed as a fraction, into a dollar price, expressed as a decimal number
     * @param fractionalDollar is a number expressed as a fraction
     * @param fraction is the integer to use in the denominator of the fraction
     */
    export function DOLLARDE(fractionalDollar: number, fraction: number): number;
    /**
     * @summary Converts a dollar price, expressed as a decimal number, into a dollar price, expressed as a fraction
     * @param decimalDollar is a decimal number
     * @param fraction is the integer to use in the denominator of the fraction
     */
    export function DOLLARFR(decimalDollar: number, fraction: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the annual duration of a security with periodic interest payments
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param coupon is the security's annual coupon rate
     * @param yld is the security's annual yield
     * @param frequency is the number of coupon payments per year
     * @param basis is the type of day count basis to use
     */
    export function DURATION(settlement: number, // date
    maturity: number, // date
    coupon: number, yld: number, frequency: number, basis?: number): number;
    /**
     * @summary Returns the effective annual interest rate
     * @param nominalRate is the nominal interest rate
     * @param npery is the number of compounding periods per year
     */
    export function EFFECT(nominalRate: number, npery: number): number;
    /**
     * @summary Returns the future value of an investment based on periodic, constant payments and a constant interest rate
     * @param rate is the interest rate
     * @param nper is the total number of payment periods
     * @param pmt is the payment made each period; it cannot change over the life of the investment
     * @param pv is the present value of the investment
     * @param { '0' | '1' } type Indicates when pmts are due.
     */
    export function FV(rate: number, nper: number, pmt: number, pv?: number, type?: number): number;
    /**
     * @summary Returns the future value of an initial principal after applying a series of compound interest rates
     * @param principal is the present value
     * @param schedule is an array of interest rates to apply
     */
    export function FVSCHEDULE(principal: number, schedule: IRange<number>): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the interest rate for a fully invested security
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param investment is the amount invested in the security
     * @param redemption is the amount to be received at maturity
     * @param basis is the type of day count basis to use
     */
    export function INTRATE(settlement: number, // date
    maturity: number, // date
    investment: number, redemption: number, basis?: number): number;
    /**
     * @summary Returns the interest payment for a given period for an investment, based on periodic, constant payments and a constant interest rate
     * @param rate is the interest rate
     * @param per is the period for which you want to find the interest and must be in the range 1 to Nper
     * @param nper is the total number of payment periods
     * @param pv is the present value of the investment
     * @param fv is the future value, or a cash balance you want to attain after the last payment is made
     * @param type is a logical value representing the timing of payment: at the end of the period = 0, at the beginning of the period = 1
     */
    export function IPMT(rate: number, per: number, nper: number, pv: number, fv?: number, type?: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the internal rate of return for a series of cash flows
     * @param values is an array or a reference to cells that contain numbers for which you want to calculate the internal rate of return
     * @param guess is a number that you guess is close to the result of IRR
     */
    export function IRR(values: IRange<number>, guess?: number): number;
    /**
     * @summary Returns the interest paid during a specific period of an investment
     * @param rate is the interest rate
     * @param per period for which you want to find the interest
     * @param nper number of payment periods in an investment
     * @param pv lump sum amount that a series of future payments is right now
     */
    export function ISPMT(rate: number, per: number, nper: number, pv: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the Macauley modified duration for a security with an assumed par value of $100
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param coupon is the security's annual coupon rate
     * @param yld is the security's annual yield
     * @param frequency is the number of coupon payments per year
     * @param basis is the type of day count basis to use
     */
    export function MDURATION(settlement: number, // date
    maturity: number, // date
    coupon: number, yld: number, frequency: number, basis?: number): number;
    /**
     * @summary Returns the internal rate of return for a series of periodic cash flows, considering both cost of investment and interest on reinvestment of cash
     * @param values is an array or a reference to cells that contain numbers that represent a series of payments (negative) and income (positive) at regular periods
     * @param financeRate is the interest rate you pay on the money used in the cash flows
     * @param reinvestRate is the interest rate you receive on the cash flows as you reinvest them
     */
    export function MIRR(values: number[], // contiguous range of cash flows?
    financeRate: number, // date
    reinvestRate: number): number;
    /**
     * @summary Returns the annual nominal interest rate
     * @param effectiveRate is the effective interest rate
     * @param npery is the number of compounding periods per year@param npery
     */
    export function NOMINAL(effectiveRate: number, npery: number): number;
    /**
     * @summary Returns the number of periods for an investment based on periodic, constant payments and a constant interest rate
     * @param rate is the interest rate per period. For example, use 6%/4 for quarterly payments at 6% APR
     * @param pmt is the payment made each period; it cannot change over the life of the investment
     * @param pv is the present value, or the lump-sum amount that a series of future payments is worth now
     * @param fv is the future value, or a cash balance you want to attain after the last payment is made
     * @param type is a logical value: payment at the beginning of the period = 1; payment at the end of the period = 0
     */
    export function NPER(rate: number, pmt: number, pv: number, fv?: number, type?: number): number;
    /**
     * @summary Returns the net present value of an investment based on a discount rate and a series of future payments (negative values) and income (positive values)
     * @param rate is the rate of discount over the length of one period
     * @param value value1,value2,... are 1 to 254 payments and income, equally spaced in time and occurring at the end of each period
     */
    export function NPV(rate: number, ...value: number[]): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the price per $100 face value of a security with an odd first period
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param issue is the security's issue date, expressed as a serial date number
     * @param firstCoupon is the security's first coupon date, expressed as a serial date number
     * @param yld is the security's annual yield
     * @param redemption is the security's redemption value per $100 face value
     * @param frequency is the number of coupon payments per year
     * @param basis is the type of day count basis to use
     */
    export function ODDFPRICE(settlement: number, // date
    maturity: number, // date
    issue: number, // date
    firstCoupon: number, // date
    yld: number, redemption: number, frequency: number, basis?: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the yield of a security with an odd first period
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param issue is the security's issue date, expressed as a serial date number
     * @param firstCoupon is the security's first coupon date, expressed as a serial date number
     * @param yld is the security's annual yield
     * @param redemption is the amount to be received at maturity
     * @param frequency is the number of coupon payments per year
     * @param basis is the type of day count basis to use
     */
    export function ODDFYIELD(settlement: number, // date
    maturity: number, // date
    issue: number, // date
    firstCoupon: number, yld: number, redemption: number, frequency: number, basis?: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the price per $100 face value of a security with an odd last period
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param lastInterest is the security's last coupon date, expressed as a serial date number
     * @param rate is the interest rate
     * @param yld is the security's annual yield
     * @param redemption is the amount to be received at maturity
     * @param frequency is the number of coupon payments per year
     * @param basis is the type of day count basis to use
     */
    export function ODDLPRICE(settlement: number, // date
    maturity: number, // date
    lastInterest: number, rate: number, yld: number, redemption: number, frequency: number, // 1, 2, or 4
    basis?: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the yield of a security with an odd last period
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param lastInterest is the security's last coupon date, expressed as a serial date number
     * @param rate is the interest rate
     * @param pr is the security's price
     * @param redemption is the amount to be received at maturity
     * @param frequency is the number of coupon payments per year
     * @param basis is the type of day count basis to use
     */
    export function ODDLYIELD(settlement: number, // date
    maturity: number, // date
    lastInterest: number, rate: number, pr: number, redemption: number, frequency: number, // 1, 2, or 4
    basis?: number): number;
    /**
     * @summary Returns the number of periods required by an investment to reach a specified value
     * @param rate is the interest rate
     * @param pv is the present value of the investment
     * @param fv is the desired future value of the investment
     */
    export function PDURATION(rate: number, pv: number, fv: number): number;
    /**
     * @summary Calculates the payment for a loan based on constant payments and a constant interest rate
     * @param rate is the interest rate
     * @param nper is the total number of payment periods
     * @param pv is the present value of the investment
     * @param fv is the future value, or a cash balance you want to attain after the last payment is made
     * @param type is a logical value: payment at the beginning of the period = 1; payment at the end of the period = 0
     */
    export function PMT(rate: number, nper: number, pv: number, fv?: number, type?: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the price per $100 face value of a security that pays periodic interest
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param rate is the interest rate
     * @param yld is the security's annual yield
     * @param redemption is the amount to be received at maturity
     * @param frequency is the number of coupon payments per year
     * @param basis is the type of day count basis to use
     */
    export function PRICE(settlement: number, // date
    maturity: number, // date
    rate: number, yld: number, redemption: number, frequency: number, // 1, 2, or 4
    basis?: number): number;
    /**
     * @summary Returns the price per $100 face value of a discounted security
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param discount is the security's discount rate
     * @param redemption is the amount to be received at maturity
     * @param basis is the type of day count basis to use
     */
    export function PRICEDISC(settlement: number, // date
    maturity: number, // date
    discount: number, redemption: number, basis?: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the price per $100 face value of a security that pays interest at maturity
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param issue is the security's issue date, expressed as a serial date number
     * @param rate is the interest rate
     * @param yld is the security's annual yield
     * @param basis is the type of day count basis to use
     */
    export function PRICEMAT(settlement: number, // date
    maturity: number, // date
    issue: number, // date
    rate: number, yld: number, basis?: number): number;
    /**
     * @summary Returns the present value of an investment: the total amount that a series of future payments is worth now
     * @param rate is the interest rate
     * @param nper is the total number of payment periods in an investment
     * @param pmt is the payment made each period and cannot change over the life of the investment
     * @param fv is the future value, or a cash balance you want to attain after the last payment is made
     * @param type is a logical value: payment at the beginning of the period = 1; payment at the end of the period = 0
     */
    export function PV(rate: number, nper: number, pmt: number, fv?: number, type?: number): number;
    /**
     * @summary Returns the interest rate per period of a loan or an investment. For example, use 6%/4 for quarterly payments at 6% APR
     * @param nper is the total number of payment periods
     * @param pmt is the payment made each period and cannot change over the life of the loan or investment
     * @param pv is the present value: the total amount that a series of future payments is worth now
     * @param fv is the future value, or a cash balance you want to attain after the last payment is made
     * @param type is a logical value: payment at the beginning of the period = 1; payment at the end of the period = 0
     * @param guess is your guess for what the rate will be
     */
    export function RATE(nper: number, pmt: number, pv: number, fv?: number, type?: number, guess?: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the amount received at maturity for a fully invested security
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param investment is the amount invested in the security
     * @param discount is the security's discount rate
     * @param basis is the type of day count basis to use
     */
    export function RECEIVED(settlement: number, // date
    maturity: number, // date
    investment: number, discount: number, basis?: number): number;
    /**
     * @summary Returns an equivalent interest rate for the growth of an investment
     * @param nper is the total number of payment periods
     * @param pv is the present value of the investment
     * @param fv is the future value of the investment
     */
    export function RRI(nper: number, pv: number, fv: number): number;
    /**
     * @summary Returns the straight-line depreciation of an asset for one period
     * @param cost is the initial cost of the asset
     * @param salvage is the salvage value at the end of the life of the asset
     * @param life is the number of periods over which the asset is being depreciated (sometimes called the useful life of the asset)
     */
    export function SLN(cost: number, salvage: number, life: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns an array of historical quote data for a symbol and date range you specify.
     * @param stock Symbol of financial instrument to be considered or a Stock data type.
     * @param startDate First date to return data from.
     * @param endDate Last date to return data from.
     * @param interval A number indicating the granularity of the data; 0 - Daily, 1 - Weekly, 2 - Monthly
     * @param headers A logical value to add column header data; 0 - No column header, 1 - Show column header, 2 - Show instrument identifier and column header
     * @param properties properties1,properties2,... A number indicating which column of data to return; 0 through 5
     */
    export function STOCKHISTORY(stock: string, startDate: number, // date
    endDate: number, // date
    interval?: number, // 0=day, 1=week, 2=month
    headers?: number, // 0=none, 1=field names, 2=field names and row numbers
    properties?: number[]): Promise<IRange>;
    /**
     * @summary Returns the sum-of-years' digits depreciation of an asset for a specified period
     * @param cost is the initial cost of the asset
     * @param salvage is the salvage value at the end of the life of the asset
     * @param life is the number of periods over which the asset is being depreciated (sometimes called the useful life of the asset)
     * @param per is the period and must use the same units as Life
     */
    export function SYD(cost: number, salvage: number, life: number, per: number): number;
    /**
     * @summary Returns the bond-equivalent yield for a treasury bill
     * @param settlement is the Treasury bill's settlement date, expressed as a serial date number
     * @param maturity is the Treasury bill's maturity date, expressed as a serial date number
     * @param discount is the Treasury bill's discount rate
     */
    export function TBILLEQ(settlement: number, // date
    maturity: number, // date
    discount: number): number;
    /**
     * @summary Returns the price per $100 face value for a treasury bill
     * @param settlement is the Treasury bill's settlement date, expressed as a serial date number
     * @param maturity is the Treasury bill's maturity date, expressed as a serial date number
     * @param discount is the Treasury bill's discount rate
     */
    export function TBILLPRICE(settlement: number, // date
    maturity: number, // date
    discount: number): number;
    /**
     * @summary Returns the yield for a treasury bill
     * @param settlement is the Treasury bill's settlement date, expressed as a serial date number
     * @param maturity is the Treasury bill's maturity date, expressed as a serial date number
     * @param pr is the Treasury Bill's price per $100 face value
     */
    export function TBILLYIELD(settlement: number, // date
    maturity: number, // date
    pr: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the depreciation of an asset for any period you specify, including partial periods, using the double-declining balance method or some other method you specify
     * @param cost is the initial cost of the asset
     * @param salvage is the salvage value at the end of the life of the asset
     * @param life is the number of periods over which the asset is being depreciated (sometimes called the useful life of the asset)
     * @param startPeriod is the first period in the calculation
     * @param endPeriod is the last period in the calculation
     * @param factor is the rate at which the balance declines
     * @param noSwitch switch to straight-line depreciation when depreciation is greater than the declining balance = FALSE; do not switch = TRUE
     */
    export function VDB(cost: number, salvage: number, life: number, startPeriod: number, endPeriod: number, factor?: number, // double declining balance
    noSwitch?: boolean): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the internal rate of return for a schedule of cash flows
     * @param values is a series of cash flows that correspond to a schedule of payments in dates
     * @param dates is a schedule of payment dates that corresponds to the cash flow payments
     * @param guess is a number that you guess is close to the result of XIRR
     */
    export function XIRR(values: IRange<number>[], dates: IRange<number>[], guess?: number): number;
    /**
     * @summary Returns the net present value for a schedule of cash flows
     * @param rate is the discount rate to apply to the cash flows
     * @param values is a series of cash flows that correspond to a schedule of payments in dates
     * @param dates is a schedule of payment dates that corresponds to the cash flow payments
     */
    export function XNPV(rate: number, values: number[], dates: number[]): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the yield on a security that pays periodic interest
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param rate is the security's annual coupon rate
     * @param pr is the security's price per $100 face value
     * @param redemption is the security's redemption value per $100 face value
     * @param frequency is the number of coupon payments per year
     * @param basis is the type of day count basis to use
     */
    export function YIELD(settlement: number, // date
    maturity: number, // date
    rate: number, pr: number, redemption: number, frequency: number, basis?: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the annual yield for a discounted security. For example, a treasury bill
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param pr is the security's price per $100 face value
     * @param redemption is the security's redemption value per $100 face value
     * @param frequency is the number of coupon payments per year
     * @param basis is the type of day count basis to use
     */
    export function YIELDDISC(settlement: number, // date
    maturity: number, // date
    pr: number, redemption: number, frequency: number, basis?: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the annual yield of a security that pays interest at maturity
     * @param settlement is the security's settlement date, expressed as a serial date number
     * @param maturity is the security's maturity date, expressed as a serial date number
     * @param issue is the security's issue date, expressed as a serial date number
     * @param rate is the interest rate
     * @param pr is the security's price per $100 face value
     * @param basis is the type of day count basis to use
     */
    export function YIELDMAT(settlement: number, // date
    maturity: number, // date
    issue: number, // date
    rate: number, pr: number, basis?: number): number;
}
declare module ".generated/formulas/impl/information/Information" {
    import { FormulaError, type Scalar, type IReferenceRange, type IRange } from '@sheetxl/primitives';
    /**
     * @summary Returns information about the cell.
     * @param {'address' | 'col' | 'contents' | 'row' | 'type'} infoType The type of information to return.
     * @param infoType
     * @param reference
     *
     * @remarks
     * This has similar functionality to Excel online but is missing formatting information from Excel desktop.
     * {@link https://support.office.com/client/results?authtype=unknown&lcid=1033&locale=en-us&ns=EXCEL&syslcid=1033&uilcid=1033&version=90&helpid=xlmain11.chm60173}
     */
    export function CELL(infoType: string, reference: IReferenceRange): Scalar;
    /**
     * @name ERROR.TYPE
     * @summary Returns a number matching an error value
     * @param errorVal is the error value for which you want the identifying number, and can be an actual error value or a reference to a cell containing an error value.
     */
    export function ERROR_TYPE(errorVal: IRange): IRange;
    /**
     * @summary Returns information about the current operating system.
     * @param {'DIRECTORY' | 'NUMFILE' | 'ORIGIN' | 'OSVERSION' | 'RECALC' | 'RELEASE' | 'SYSTEM' | 'USER'} typeText The type of information to return
     */
    export function INFO(typeText: string): string;
    /**
     * @summary Checks whether a reference is to an empty cell, and returns TRUE or FALSE
     * @param value is the cell or a name that refers to the cell you want to test
     */
    export function ISBLANK(value: IRange): IRange;
    /**
     * @summary Checks whether a value is an error other than #N/A, and returns TRUE or FALSE
     * @param value is the value you want to test. Value can refer to a cell, a formula, or a name that refers to a cell, formula, or value
     */
    export function ISERR(value: IRange): IRange;
    /**
     * @summary Checks whether a value is an error, and returns TRUE or FALSE
     * @param value is the value you want to test. Value can refer to a cell, a formula, or a name that refers to a cell, formula, or value
     */
    export function ISERROR(value: IRange): IRange;
    /**
     * @summary Returns TRUE if the number is even
     * @param number is the value to test
     */
    export function ISEVEN(number: IRange<number>): IRange<boolean>;
    /**
     * @summary Checks whether a reference is to a cell containing a formula, and returns TRUE or FALSE
     * @param reference is a reference to the cell you want to test.  Reference can be a cell reference, a formula, or name that refers to a cell
     */
    export function ISFORMULA(reference: IReferenceRange): IRange;
    /**
     * @summary Checks whether a value is a logical value (TRUE or FALSE), and returns TRUE or FALSE
     * @param value is the value you want to test. Value can refer to a cell, a formula, or a name that refers to a cell, formula, or value
     */
    export function ISLOGICAL(value: IRange): IRange;
    /**
     * @summary Checks whether a value is #N/A, and returns TRUE or FALSE
     * @param value is the value you want to test. Value can refer to a cell, a formula, or a name that refers to a cell, formula, or value
     */
    export function ISNA(value: IRange): IRange;
    /**
     * @summary Checks whether a value is not text (blank cells are not text), and returns TRUE or FALSE
     * @param value is the value you want tested: a cell; a formula; or a name referring to a cell, formula, or value
     */
    export function ISNONTEXT(value: IRange): IRange;
    /**
     * @summary Checks whether a value is not text (blank cells are not text), and returns TRUE or FALSE
     * @param value is the value you want tested: a cell; a formula; or a name referring to a cell, formula, or value
     */
    export function ISNUMBER(value: IRange): IRange;
    /**
     * @summary Returns TRUE if the number is odd
     * @param number is the value to test
     */
    export function ISODD(number: IRange<number>): IRange<boolean>;
    /**
     * @summary Checks whether the value is omitted, and returns TRUE or FALSE
     * @param argument is the value you want to test, such as a LAMBDA parameter
     */
    export function ISOMITTED(argument: any): boolean;
    /**
     * @summary Checks whether a value is a reference, and returns TRUE or FALSE
     * @param value is the value you want to test. Value can refer to a cell, a formula, or a name that refers to a cell, formula, or value
     */
    export function ISREF(value: IRange): boolean;
    /**
     * @summary Converts a value to text in a specific number format
     * @param value is a number, a formula that evaluates to a numeric value, or a reference to a cell containing a numeric value
     */
    export function ISTEXT(value: IRange): IRange;
    /**
     * @summary Converts non-number value to a number, dates to serial numbers, TRUE to 1, anything else to 0 (zero)
     * @param value is the value to convert
     *
     * @remarks
     * We take a range to ensure that auto-spill doesn't occur.
     */
    export function N(value: IRange): number;
    /**
     * @summary Returns the #N/A error value
     */
    export function NA(): FormulaError.Known;
    /**
     * @summary Returns the sheet number of the referenced sheet
     * @param value is the name of a sheet or a reference that you want the sheet number of. If omitted the number of the sheet containing the function is returned
     */
    export function SHEET(value?: string): number;
    /**
     * @summary Returns the number of sheets in a reference
     * @param reference is a reference for which you want to know the number of sheets it contains. If omitted the number of sheets in the workbook containing the function is returned
      */
    export function SHEETS(reference?: IReferenceRange): number;
    /**
     * @summary Returns an integer representing the data type of a value: number = 1; text = 2; logical value = 4; error value = 16; array = 64; compound data = 128
     * @param value is the value to check
     */
    export function TYPE(value: IRange): number;
}
declare module ".generated/formulas/impl/logical/Logical" {
    import { IRange } from '@sheetxl/primitives';
    /**
     * @summary Checks whether all arguments are TRUE, and returns TRUE if all arguments are TRUE
     * @param logical logical1,logical2,... are 1 to 255 conditions you want to test that can be either TRUE or FALSE and can be logical values, arrays, or references
     */
    export function AND(...logical: IRange[]): any;
    /**
     * @hidden Unimplemented
     * @summary Applies a LAMBDA function to each column and returns an array of the results.
     * @param array is an array to be separated by column
     * @param fn is a LAMBDA that is called to scan the array.  The LAMBDA takes two parameters, accumulator and value.
     */
    export function BYCOL(array: IRange, fn: any): IRange;
    /**
     * @hidden Unimplemented
     * @summary Applies a LAMBDA function to each row and returns an array of the results.
     * @param array is an array to be separated by column
     * @param fn is a LAMBDA that is called to scan the array.  The LAMBDA takes two parameters, accumulator and value.
     */
    export function BYROW(array: IRange, fn: any): IRange;
    /**
     * @summary Returns the logical value FALSE
     */
    export function FALSE(): boolean;
    /**
     * @summary Checks whether a condition is met, and returns one value if TRUE, and another value if FALSE
     * @param logicalTest is any value or expression that can be evaluated to TRUE or FALSE
     * @param valueIfTrue is the value that is returned if Logical_test is TRUE. If omitted, TRUE is returned. You can nest up to seven IF functions
     * @param valueIfFalse is the value that is returned if Logical_test is FALSE. If omitted, FALSE is returned
     */
    export function IF(logicalTest: IRange, valueIfTrue: IRange, valueIfFalse?: IRange): IRange;
    /**
     * @summary Returns value_if_error if expression is an error and the value of the expression itself otherwise
     * @param value is any value or expression or reference
     * @param valueIfError is any value or expression or reference
     */
    export function IFERROR(value: IRange, valueIfError: IRange): IRange;
    /**
     * @summary Returns the value you specify if the expression resolves to #N/A, otherwise returns the result of the expression
     * @param value is any value or expression or reference
     * @param valueIfError is any value or expression or reference
     */
    export function IFNA(value: IRange, valueIfError: IRange): IRange;
    /**
     * @summary Checks whether one or more conditions are met and returns a value corresponding to the first TRUE condition
     * @param logicalTest logical_test1,logical_test2,... is any value or expression that can be evaluated to TRUE or FALSE
     * @param logicalTrue value_if_true1,value_if_true2,... is the value returned if Logical_test is TRUE
     */
    export function IFS(logicalTest: IRange, logicalTrue: IRange, ...rest: IRange[]): IRange;
    /**
     * @hidden Unimplemented
     * @summary Creates a function value with can be called within formulas.
     * @param parameterOrCalculation a parameter or a calculation that returns a value. If a parameter, it must be the last argument.
     */
    export function LAMDA(...parameterOrCalculation: IRange[]): any;
    /**
     * @hidden Unimplemented
     * @summary Assigns calculation results to names. Useful for storing intermediate calculations and values by defining names inside a formula. These names only apply within the scope of the LET function.
     * @param name name1,name2,... the name, or a calculation which can make use of all names within the LET. Names must start with a letter, cannot be the output of a formula, or conflict with range syntax.
     * @param nameOrValue name_value1,name_value2,... the value associated with the name.
     */
    export function LET(name: string, nameOrValue: IRange, calculationOrName: IRange, ...rest: IRange[]): any;
    /**
     * @hidden Unimplemented
     * @summary Returns a calculated array of a specified row and column size, by applying a LAMBDA function.
     * @param rows is the number of rows in the array.  Must be greater than zero.
     * @param columns is the number of columns in the array.  Must be greater than zero.
     * @param fn is a LAMBDA that is called to create the array.  The LAMBDA takes two parameters, row index and column index.
     */
    export function MAKEARRAY(rows: number, columns: number, fn: IRange): any;
    /**
     * @hidden Unimplemented
     * @summary Returns an array formed by 'mapping' each value in the array(s) to a new value by applying a lambda to create a new value.
     * @param array is an array to be mapped
     * @param lamdaOrArray lambda_or_array1,lambda_or_array2,... is a LAMBDA which must be the last argument and must have a parameter for each array passed, or another array to be mapped
     */
    export function MAP(array: IRange, ...lamdaOrArray: IRange[]): any;
    /**
     * @summary Changes FALSE to TRUE, or TRUE to FALSE
     * @param logical is a value or expression that can be evaluated to TRUE or FALSE
     */
    export function NOT(logical: IRange): IRange;
    /**
     * @summary Checks whether any of the arguments are TRUE, and returns TRUE or FALSE. Returns FALSE only if all arguments are FALSE
     * @param logical logical1,logical2,... are 1 to 255 conditions that you want to test that can be either TRUE or FALSE
     */
    export function OR(...logical: IRange[]): any;
    /**
     * @hidden Unimplemented
     * @summary Reduces an array to an accumulated value by applying a LAMBDA function to each value and returning the total value in the accumulator.
     * @param initialValue is the starting value for the accumulator
     * @param array is an array to be reduced
     * @param fn is a LAMBDA that is called to reduce the array.  The LAMBDA takes two parameters, accumulator and value.
     */
    export function REDUCE(initialValue: IRange, array: IRange, fn: IRange): any;
    /**
     * @hidden Unimplemented
     * @summary Scans an array by applying a LAMBDA function to each value and returns an array that has each intermediate value
     * @param initialValue is the starting value for the accumulator
     * @param array is an array to be reduced
     * @param fn is a LAMBDA that is called to reduce the array.  The LAMBDA takes two parameters, accumulator and value.
     */
    export function SCAN(initialValue: IRange, array: IRange, fn: IRange): any;
    /**
     * @hidden Unimplemented
     * @summary Evaluates an expression against a list of values and returns the result corresponding to the first matching value. If there is no match, an optional default value is returned
     * @param value is an expression to be evaluated
     * @param results result1,result2,... is a result to be returned if the corresponding value matches expression
     */
    export function SWITCH(expression: IRange, value: IRange, ...results: IRange[]): any;
    /**
     * @summary Returns the logical value TRUE
     */
    export function TRUE(): boolean;
    /**
     * @summary Returns a logical 'Exclusive Or' of all arguments
     * @param logical logical1,logical2,... are 1 to 254 conditions you want to test that can be either TRUE or FALSE and can be logical values, arrays, or references
     */
    export function XOR(...logical: IRange[]): any;
}
declare module ".generated/formulas/impl/_utils/_Utils" {
    export const WildCard: {
        /**
         * @param {string|*} obj
         * @returns {*}
         */
        isWildCard: (obj: any) => boolean;
        toRegex: (lookupText: string, flags?: any) => RegExp;
    };
    export const Criteria: {
        /**
         * Parse criteria, support comparison and wild card match.
         *
         * @param {string|number} criteria
         * @returns {{op: string, value: string|number|boolean|RegExp, match: boolean|undefined}} - The parsed criteria.
         */
        parse: (criteria: any) => {
            op: string;
            value: any;
            match?: boolean;
        };
    };
}
declare module ".generated/formulas/impl/_utils/index" {
    export * from ".generated/formulas/impl/_utils/_Utils";
}
declare module ".generated/formulas/impl/lookupReference/Reference" {
    import { Scalar, IRange, IReferenceRange } from '@sheetxl/primitives';
    /**
     * @summary Creates a cell reference as text, given specified row and column numbers
     * @param rowNum is the row number to use in the cell reference: Row_number = 1 for row 1
     * @param columnNum is the column number to use in the cell reference. For example, Column_number = 4 for column D
     * @param absNum specifies the reference type: absolute = 1; absolute row/relative column = 2; relative row/absolute column = 3; relative = 4
     * @param a1 is a logical value that specifies the reference style: A1 style = 1 or TRUE; R1C1 style = 0 or FALSE
     * @param sheetText is text specifying the name of the worksheet to be used as the external reference
     */
    export function ADDRESS(rowNum: number, columnNum: number, absNum?: number, a1?: boolean, sheetText?: string): string;
    /**
     * @summary Returns the number of areas in a reference. An area is a range of contiguous cells or a single cell
     * @param references is a reference to a cell or range of cells and can refer to multiple areas
     */
    export function AREAS(...references: IRange[]): number;
    /**
     * @summary Chooses a value or action to perform from a list of values, based on an index number
     * @param indexNum specifies which value argument is selected. Index_num must be between 1 and 254, or a formula or a reference to a number between 1 and 254
     * @param value1 value1,value2,... are 1 to 254 numbers, cell references, defined names, formulas, functions, or text arguments from which CHOOSE selects
     */
    export function CHOOSE(indexNum: number, value1: IRange, ...value: IRange[]): IRange;
    /**
     * @summary Returns columns from an array or reference.
     * @param array The array or reference from which to choose columns.
     * @param colNum1 col_num1,col_num2,... The number of the column to be returned.
     */
    export function CHOOSECOLS(array: IRange, colNum1: number, ...colNum: number[]): any;
    /**
     * @summary Returns rows from an array or reference.
     * @param array The array or reference from which to choose rows.
     * @param rowNum1 row_num1,row_num2,... The number of the row to be returned.
     */
    export function CHOOSEROWS(array: IRange, rowNum1: number, ...rowNum: number[]): any;
    /**
     * @summary Returns the column number of a reference
     * @param reference is the cell or range of contiguous cells for which you want the column number. If omitted, the cell containing the COLUMN function is used
     */
    export function COLUMN(reference?: IReferenceRange): number[];
    /**
     * @summary Returns the number of columns in an array or reference
     * @param array is an array or array formula, or a reference to a range of cells for which you want the number of columns
     */
    export function COLUMNS(array: IRange): number;
    /**
     * @hidden Unimplemented
     * @summary Drops rows or columns from array start or end.
     * @param array The array from which to drop rows or columns.
     * @param row The number of rows to drop. A negative value drops from the end of the array.
     * @param columns The number of columns to drop. A negative value drops from the end of the array.
     */
    export function DROP(array: IRange, row: number, columns?: number): IRange;
    /**
     * @hidden Unimplemented
     * @summary Expands an array to the specified dimensions.
     * @param array The array to expand.
     * @param row The number of rows in the expanded array. If missing, rows will not be expanded.
     * @param columns The number of columns in the expanded array. If missing, columns will not be expanded.
     * @param padWidth The value with which to pad. The default is #N/A.
     */
    export function EXPAND(array: IRange, row: number, columns?: number, padWidth?: Scalar): IRange;
    /**
     * @hidden Unimplemented
     * @summary Extracts a value from a field of a given record
     * @param value The record from which you want to extract the field
     * @param fieldName The names of the field or fields that you want to extract
     */
    export function FIELDVALUE(value: Scalar, fieldName: string): any;
    /**
     * @hidden Unimplemented
     * @summary Filter a range or array
     * @param array the range or array to filter
     * @param include an array of booleans where TRUE represents a row or column to retain
     * @param ifEmpty return if no items are retained
     */
    export function FILTER(array: IRange, include: IRange, ifEmpty: IRange): IRange;
    /**
     * @summary Returns a formula as a string
     * @param reference is a reference to a formula
     */
    export function FORMULATEXT(reference: IReferenceRange): string;
    /**
     * @hidden Unimplemented
     * @summary Extracts data stored in a PivotTable.
     * @param dataField is the name of the data field to extract data from
     * @param pivotTable is a reference to a cell or range of cells in the PivotTable that contains the data you want to retrieve
     * @param field1 field1,field2,... field to refer to
     * @param item1 item1,item2,... field item to refer to
     */
    export function GETPIVOTDATA(dataField: string, pivotTable: string, field1: string, //[]
    item1: IRange): string;
    /**
     * @hidden Unimplemented
     * @summary Aggregate values by row fields
     * @param rowFields The range or array containing the row fields
     * @param values The range or array containing the values to aggregate
     * @param fn The function used to do the aggregations
     * @param fieldHeaders A number between 0 and 3 that specifies whether the field data has headers and whether field headers should be returned in the results
     * @param totalDepth Show totals for the row fields. 0 for none, 1 for grand totals, 2 for grand total and first level subtotals, etc
     * @param sortOrder The column index to sort the row fields on. A negative index will sort in reverse order
     * @param filterArray param-534 paramName-535
     * @param fieldRelationship The relationship of fields when multiple columns are supplied to the row_fields argument
     */
    export function GROUPBY(rowFields: IReferenceRange, values: IRange, fn: any[], // this is a lambda function
    fieldHeaders?: number, // 0-no, 1-yes, 2-no but generate, 3-yes and show
    totalDepth?: number, // 0-no totals, 1-grand totals, 2-grand and subtotals, -1-grand totals at top, -2 grand and sub totals at top
    sortOrder?: any[], // <0, >0
    filterArray?: boolean[], fieldRelationship?: number): string;
    /**
     * @summary Looks for a value in the top row of a table or array of values and returns the value in the same column from a row you specify
     * @param lookupValue is the value to be found in the first row of the table and can be a value, a reference, or a text string
     * @param tableArray is a table of text, numbers, or logical values in which data is looked up. Table_array can be a reference to a range or a range name
     * @param rowIndexNum is the row number in table_array from which the matching value should be returned. The first row of values in the table is row 1
     * @param rangeLookup is a logical value: to find the closest match in the top row (sorted in ascending order) = TRUE; find an exact match = FALSE
     */
    export function HLOOKUP(lookupValue: Scalar, tableArray: IRange, rowIndexNum: number, rangeLookup?: boolean): any;
    /**
     * @hidden Unimplemented
     * @summary Horizontally stacks arrays into one array.
     * @param array array1,array2,... An array or reference to be stacked.
     */
    export function HSTACK(array1: IRange, ...array: IRange[]): Scalar;
    /**
     * @hidden Unimplemented
     * @summary Creates a shortcut or jump that opens a document stored on your hard drive, a network server, or on the Internet
     * @param linkLocation is the text giving the path and file name to the document to be opened, a hard drive location, UNC address, or URL path
     * @param friendlyName is text or a number that is displayed in the cell. If omitted, the cell displays the Link_location text
     */
    export function HYPERLINK(linkLocation: string, friendlyName?: string): any;
    /**
     * @hidden Unimplemented
     * @summary Returns an image from a given source
     * @param source The path of the source that points to the image
     * @param alternateText The alternative text that describes the image for accessibility
     * @param sizing The setting that determines the dimensions in which the image will be rendered in the cell
     * @param height The custom height of the image in pixels
     * @param width The custom width of the image in pixels
     */
    export function IMAGE(source: string, alternateText: string, sizing: number, height: number, width: number): any;
    /**
     * @summary Returns a value or reference of the cell at the intersection of a particular row and column, in a given range
     * @param array is a range of cells or an array constant.
     * @param rowNum selects the row in Array or Reference from which to return a value. If omitted, Column_num is required
     * @param colNum selects the column in Array or Reference from which to return a value. If omitted, Row_num is required
     * @param areaNum selects the area in Array or Reference from which to return a value. If omitted, the first area is used
     * @remarks
     * Excel has treats this as 2 signatures. Not sure why.
     */
    export function INDEX(array: IRange[], rowNum?: number, colNum?: number, areaNum?: number): any;
    /**
     * @summary Returns the reference specified by a text string
     * @param refText is a reference to a cell that contains an A1- or R1C1-style reference, a name defined as a reference, or a reference to a cell as a text string
     * @param a1 is a logical value that specifies the type of reference in Ref_text: R1C1-style = FALSE; A1-style = TRUE.
     */
    export function INDIRECT(refText: string, a1?: boolean): IReferenceRange;
    /**
     * @hidden Unimplemented
     * @summary Looks up a value either from a one-row or one-column range or from an array. Provided for backward compatibility
     * @param lookupValue is a value that LOOKUP searches for in Lookup_vector and can be a number, text, a logical value, or a name or reference to a value
     * @param lookupVector is a range that contains only one row or one column of text, numbers, or logical values, placed in ascending order
     * @param resultVector is a range that contains only one row or column, the same size as Lookup_vector
     */
    export function LOOKUP(lookupValue: Scalar, lookupVector: IRange, resultVector: IRange): any;
    /**
     * @hidden Unimplemented
     * @summary Returns the relative position of an item in an array that matches a specified value in a specified order
     * @param lookupValue is the value you use to find the value you want in the array, a number, text, or logical value, or a reference to one of these
     * @param lookupArray is a contiguous range of cells containing possible lookup values, an array of values, or a reference to an array
     * @param matchType is a number 1, 0, or -1 indicating which value to return.
     */
    export function MATCH(lookupValue: Scalar, lookupArray: number[][], //IRange with number
    matchType: number): number;
    /**
     * @summary Returns a reference to a range that is a given number of rows and columns from a given reference
     * @param reference is the reference from which you want to base the offset, a reference to a cell or range of adjacent cells
     * @param rows is the number of rows, up or down, that you want the upper-left cell of the result to refer to
     * @param cols is the number of columns, to the left or right, that you want the upper-left cell of the result to refer to
     * @param height is the height, in number of rows, that you want the result to be, the same height as Reference if omitted
     * @param width is the width, in number of columns, that you want the result to be, the same width as Reference if omitted
     */
    export function OFFSET(reference: IReferenceRange, rows: number, cols: number, height?: number, width?: number): IReferenceRange;
    /**
     * @hidden Unimplemented
     */
    export function PIVOTBY(rowFields: IReferenceRange, colFields: IReferenceRange, values: IRange[], fn: any[], // Wow, this is a lambda function
    fieldHeaders?: number, // 0-no, 1-yes, 2-no but generate, 3-yes and show
    rowTotalDepth?: number, // 0-no totals, 1-grand totals, 2-grand and subtotals, -1-grand totals at top, -2 grand and sub totals at top
    rowSortOrder?: any[], // <0, >0
    colTotalDepth?: number, // 0-no totals, 1-grand totals, 2-grand and subtotals, -1-grand totals at top, -2 grand and sub totals at top
    colSortOrder?: any[], // <0, >0
    filterArray?: boolean[], relativeTo?: number): number;
    /**
     * @summary Returns the row number of a reference
     * @param reference is the cell or a single range of cells for which you want the row number; if omitted, returns the cell containing the ROW function
     */
    export function ROW(reference?: IReferenceRange): number[];
    /**
     * @summary Returns the number of rows in a reference or array
     * @param array is an array, an array formula, or a reference to a range of cells for which you want the number of rows
     */
    export function ROWS(array: IRange): number;
    /**
     * @hidden Unimplemented
     * @summary Retrieves the real-time data (RTD) from a program that supports COM automation
     * @param progId is the programmatic identifier (ProgID) of a registered COM automation add-in. Enclose the id in quotation marks
     * @param server is the name of the server that provides the real-time data. If running locally us an empty string
     * @param topic topic1,topic2,... are 1 to 38 parameters that specify a piece of data
     */
    export function RTD(progId: string, server?: string, ...topic: string[]): any;
    /**
     * @hidden Unimplemented
     * @summary Sorts a range or array
     * @param array the range or array to sort
     * @param sortIndex a number indicating the row or column to sort by
     * @param sortOrder a number indicating the desired sort order; 1 for ascending order (default), -1 for descending order
     * @param byCol a logical value indicating the desired sort direction: FALSE to sort by row (default), TRUE to sort by column
     */
    export function SORT(array: IRange, sortIndex?: number[], sortOrder?: number[], byCol?: boolean): IRange;
    /**
     * @hidden Unimplemented
     * @summary Sorts a range or array based on the values in a corresponding range or array
     * @param array the range or array to sort
     * @param byArray1 by_array1,by_array2,... the range or array to sort on
     * @param sortOrder sort_order1,sort_order2,... a number indicating the desired sort order; 1 for ascending order (default), -1 for descending order
     */
    export function SORTBY(array: IRange, byArray1: IRange, sortOrder?: number[]): IRange;
    /**
     * @hidden Unimplemented
     * @summary Returns rows or columns from array start or end.
     * @param array The array from which to take rows or columns.
     * @param rows The number of rows to take. A negative value takes from the end of the array.
     * @param columns The number of columns to take. A negative value takes from the end of the array.
     */
    export function TAKE(array: IRange, rows: number, columns?: number): IRange;
    /**
     * @hidden Unimplemented
     * @summary Returns the array as one column.
     * @param array The array or reference to return as a column.
     * @param {'0 - Keep all values' | '1 - Ignore Blanks' | '2 - Ignore Errors' | '3 - Ignore Blanks and Errors'} ignore Whether to ignore certain types of values. By default, no values are ignored.
     * @param scanByColumn Scan the array by column. By default, the array is scanned by row.
     */
    export function TOCOL(array: IRange, ignore?: number, scanByColumn?: boolean): IRange;
    /**
     * @hidden Unimplemented
     * @summary Returns the array as one row.
     * @param array The array or reference to return as a column.
     * @param {'0 - Keep all values' | '1 - Ignore Blanks' | '2 - Ignore Errors' | '3 - Ignore Blanks and Errors'} ignore Whether to ignore certain types of values. By default, no values are ignored.
     * @param scanByColumn Scan the array by column. By default, the array is scanned by row.
     */
    export function TOROW(array: IRange, ignore?: number, scanByColumn?: boolean): IRange;
    /**
     * @summary Converts a vertical range of cells to a horizontal range, or vice versa
     * @param array is a range of cells on a worksheet or an array of values that you want to transpose
     */
    export function TRANSPOSE(array: IRange): IRange;
    /**
     * @summary Trims a range to the last used cell in any direction.
     * @param range The range to be trimmed
     * @param rowTrimMode Row trim direction. 0 - none, 1 - leading, 2 - trailing, 3 - both.
     * @param colTrimMode Column trim direction. 0 - none. 1 - leading, 2 - trailing, 3 - both.
     */
    export function TRIMRANGE(range: IRange, rowTrimMode?: number, colTrimMode?: number): IRange;
    /**
     * @hidden Unimplemented
     * @summary Returns the unique values from a range or array.
     * @param array the range or array from which to return unique rows or columns
     * @param byCol is a logical value: compare rows against each other and return the unique rows = FALSE; compare columns against each other and return the unique columns = TRUE
     * @param exactlyOnce is a logical value: return rows or columns that occur exactly once from the array = TRUE; return all distinct rows or columns from the array = FALSE
     */
    export function UNIQUE(array: IRange, byCol?: boolean, exactlyOnce?: boolean): IRange;
    /**
     * @summary Looks for a value in the leftmost column of a table, and then returns a value in the same row from a column you specify. By default, the table must be sorted in an ascending order
     * @param lookupValue is the value to be found in the first column of the table, and can be a value, a reference, or a text string
     * @param tableArray is a table of text, numbers, or logical values, in which data is retrieved. Table_array can be a reference to a range or a range name
     * @param colIndexNum is the column number in table_array from which the matching value should be returned. The first column of values in the table is column 1
     * @param rangeLookup is a logical value: to find the closest match in the first column (sorted in ascending order) = TRUE; find an exact match = FALSE
     */
    export function VLOOKUP(lookupValue: Scalar, tableArray: IRange, colIndexNum: number, rangeLookup?: boolean): Scalar;
    /**
     * @hidden Unimplemented
     * @summary Vertically stacks arrays into one array.
     * @param array1 array1,array2,... An array or reference to be stacked.
     * @param array array1,array2,... An array or reference to be stacked.
     */
    export function VSTACK(array1: IRange, ...array: IRange[]): IRange;
    /**
     * @hidden Unimplemented
     * @summary Wraps a row or column vector after a specified number of values.
     * @param vector The vector or reference to wrap.
     * @param wrapCount The maximum number of values per column.
     * @param padWith The value with which to pad. The default is #N/A.
     */
    export function WRAPCOLS(vector: IRange, wrapCount: number, padWith?: Scalar): IRange;
    /**
     * @hidden Unimplemented
     * @summary Wraps a row or column vector after a specified number of values.
     * @param vector The vector or reference to wrap.
     * @param wrapCount The maximum number of values per column.
     * @param padWith The value with which to pad. The default is #N/A.
     */
    export function WRAPROWS(vector: IRange, wrapCount: number, padWith?: Scalar): IRange;
    /**
     * @hidden Unimplemented
     * @summary Searches a range or an array for a match and returns the corresponding item from a second range or array. By default, an exact match is used
     * @param lookupValue is the value to search for
     * @param lookupArray is the array or range to search
     * @param returnArray is the array or range to return
     * @param ifNotFound returned if no match is found
     * @param matchMode specify how to match lookup_value against the values in lookup_array
     * @param searchMode specify the search mode to use. By default, a first to last search will be used
     */
    export function XLOOKUP(lookupValue: Scalar, lookupArray: IRange, returnArray: IRange, ifNotFound: Scalar, rangeLookup: boolean, matchMode: boolean, searchMode?: boolean): Scalar;
    /**
     * @hidden Unimplemented
     * @summary Returns the relative position of an item in an array. By default, an exact match is required
     * @param lookupValue is the value to search for
     * @param lookupArray is the array or range to search
     * @param matchMode specify how to match the lookup_value against the values in lookup_array
     * @param searchMode specify the search mode to use. By default, a first to last search will be used
     */
    export function XMATCH(lookupValue: Scalar, lookupArray: IRange, matchMode: boolean, searchMode?: boolean): Scalar;
}
declare module ".generated/formulas/impl/mathTrig/Math" {
    import { IRange, IReferenceRange } from '@sheetxl/primitives';
    /**
     * @summary Returns the absolute value of a number, a number without its sign
     * @param number is the real number for which you want the absolute value
     */
    export function ABS(number: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns information about the cell.
     * @param functionNum Is the number 1 to 19 that specifies the summary function for the aggregate.
     * @param options Is the number 0 to 78 that specified the values to ignore for the aggregate.
     * @param array Is the array or range of numerical data on which to calculate the aggregate.
     * @param K indicates the position of the array; it is k-th largest, k-th smallest, k-th percentile, or k-th quartile.
     */
    export function AGGREGATE(functionNum: number, options: number, array: IRange, K: number): number;
    /**
     * @summary Converts a Roman numeral to Arabic
     * @param text is the Roman numeral you want to convert
     */
    export function ARABIC(text: string): number;
    /**
     * @summary Converts a number into a text representation with the given radix (base)
     * @param number is the number that you want to convert
     * @param radix is the base Radix that you want to convert the number into
     * @param minLength is the minimum length of the returned string
     */
    export function BASE(number: number, radix: number, minLength?: number): string | number;
    /**
     * @summary Rounds a number up, to the nearest multiple of significance
     * @param number is the value you want to round
     * @param significance is the multiple to which you want to round
     * @category Compatible
     */
    export function CEILING(number: number, significance?: number): number;
    /**
     * @name CEILING.MATH
     * @summary Rounds a number up, to the nearest integer or to the nearest multiple of significance
     * @param number is the real number you want to round
     * @param significance when given and nonzero this function will round away from zero
     */
    export function CEILING_MATH(number: number, significance?: number, mode?: number): number;
    /**
     * @name CEILING.PRECISE
     * @summary Rounds a number up to the nearest integer or to the nearest multiple of significance
     * @param number is the real number you want to round
     * @param significance is the multiple to which you want to round
     * @category Compatible
     */
    export function CEILING_PRECISE(number: number, significance?: number): number;
    /**
     * @summary Returns the number of combinations for a given number of items
     * @param number is the total number of items
     * @param numberChosen is the number of items in each combination
     */
    export function COMBIN(number: number, numberChosen: number): number;
    /**
     * @summary Returns the number of combinations with repetitions for a given number of items
     * @param number is the total number of items
     * @param numberChosen is the number of items in each combination
     */
    export function COMBINA(number: number, numberChosen: number): number;
    /**
     * @summary Converts a text representation of a number in a given base into a decimal number
     * @param number is the number that you want to convert
     * @param radix is the base Radix of the number you are converting
     */
    export function DECIMAL(number: string, radix: number): number;
    /**
     * @summary Converts radians to degrees
     * @param angle is the angle in radians that you want to convert
     */
    export function DEGREES(angle: number): number;
    /**
     * @summary Rounds a positive number up and negative number down to the nearest even integer
     * @param number is the value to round
     */
    export function EVEN(number: number): number;
    /**
     * @summary Returns e raised to the power of a given number
     * @param number is the exponent applied to the base e. The constant e equals 2.71828182845904, the base of the natural logarithm
     */
    export function EXP(number: number): number;
    /**
     * @summary Returns the factorial of a number, equal to 1*2*3*...* Number
     * @param number is the nonnegative number you want the factorial of
     */
    export function FACT(number: number): number;
    /**
     * @summary Returns the double factorial of a number
     * @param number is the value for which to return the double factorial
     */
    export function FACTDOUBLE(number: number): number;
    /**
     * @summary Rounds a number down to the nearest multiple of significance
     * @param number is the real number you want to round
     * @param significance is the multiple to which you want to round. Number and Significance must either both be positive or both be negative
     * @category Compatible
     */
    export function FLOOR(number: number, significance?: number): number;
    /**
     * @name FLOOR.MATH
     * @summary Rounds a number down, to the nearest integer or to the nearest multiple of significance
     * @param number is the real number you want to round
     * @param significance is the multiple to which you want to round
     * @param mode when given and nonzero this function will round towards zero
     */
    export function FLOOR_MATH(number: number, significance?: number, mode?: number): number;
    /**
     * @name FLOOR.PRECISE
     * @summary Rounds a number down to the nearest integer or to the nearest multiple of significance
     * @param number is the real number you want to round
     * @param significance is the multiple to which you want to round
     */
    export function FLOOR_PRECISE(number: number, significance?: number): number;
    /**
     * @summary Returns the greatest common divisor
     * @param number number1,number2,... are 1 to 255 values
     */
    export function GCD(...number: number[]): number;
    /**
     * @summary Rounds a number down to the nearest integer
     * @param number is the real number you want to round down to an integer
     */
    export function INT(number: number): number;
    /**
     * @name ISO.CEILING
     * @summary Rounds a number up to the nearest integer
     * @param number is the real number you want to round up to an integer
     * @param significance is the multiple to which you want to round number
     * @category Compatible
     */
    export function ISO_CEILING(number: number, significance?: number): number;
    /**
     * @summary Returns the least common multiple
     * @param number number1,number2,... are 1 to 255 values for which you want the least common multiple
     */
    export function LCM(...number: number[]): number;
    /**
     * @summary Returns the natural logarithm of a number
     * @param number is the positive real number for which you want the natural logarithm
     */
    export function LN(number: number): number;
    /**
     * @summary Returns the logarithm of a number to the base you specify
     * @param number is the positive real number for which you want the logarithm
     * @param base is the base of the logarithm
     */
    export function LOG(number: number, base?: number): number;
    /**
     * @summary Returns the base-10 logarithm of a number
     * @param number is the positive real number for which you want the base-10 logarithm
     */
    export function LOG10(number: number): number;
    /**
     * @summary Returns the matrix determinant of an array
     * @param array is a numeric array with an equal number of rows and columns, either a cell range or an array constant
     */
    export function MDETERM(array: number[][]): number;
    /**
     * @summary Returns the inverse matrix for the matrix stored in an array
     * @param array is a numeric array with an equal number of rows and columns, either a cell range or an array constant
     */
    export function MINVERSE(array: number[][]): any;
    /**
     * @summary Returns the matrix product of two arrays, an array with the same number of rows as array1 and columns as array2
     * @param array1 is the first array of numbers to multiply and must have the same number of columns as Array2 has rows
     * @param array2 is the second array of numbers to multiply and must have the same number of columns as Array1 has rows
     */
    export function MMULT(array1: any[][], array2: any[][]): any[][];
    /**
     * @summary Returns the remainder after a number is divided by a divisor
     * @param number is the number for which you want to find the remainder after the division is performed
     * @param divisor is the number by which you want to divide Number
     */
    export function MOD(number: number, divisor: number): number;
    /**
     * @summary Returns a number rounded to the desired multiple
     * @param number is the value to round
     * @param multiple is the multiple to which you want to round number
     */
    export function MROUND(number: number, multiple: number): number;
    /**
     * @summary Returns the multinomial of a set of numbers
     * @param number number1,number2,... are 1 to 255 values for which you want the multinomial
     */
    export function MULTINOMIAL(...number: number[]): number;
    /**
     * @summary Returns the unit matrix for the specified dimension
     * @param dimension is an integer specifying the dimension of the unit matrix that you want to return
     */
    export function MUNIT(dimension: number): number[][];
    /**
     * @summary Rounds a positive number up and negative number down to the nearest odd integer
     * @param number is the value to round
     */
    export function ODD(number: number): number;
    /**
     * @summary Returns the value of Pi, 3.14159265358979, accurate to 15 digits
     */
    export function PI(): number;
    /**
     * @summary Returns the result of a number raised to a power
     * @param number is the base number, any real number
     * @param power is the exponent, to which the base number is raised
     */
    export function POWER(number: number, power: number): number;
    /**
     * @summary Multiplies all the numbers given as arguments
     * @param number number1,number2,... are 1 to 255 numbers, logical values, or text representations of numbers that you want to multiply
     */
    export function PRODUCT(...number: IRange<number>[]): number;
    /**
     * @summary Returns the integer portion of a division
     * @param numerator is the dividend
     * @param denominator is the divisor
     */
    export function QUOTIENT(numerator: number, denominator: number): number;
    /**
     * @summary Converts degrees to radians
     * @param angle is an angle in degrees that you want to convert
     */
    export function RADIANS(angle: number): number;
    /**
     * @summary Returns a random number greater than or equal to 0 and less than 1, evenly distributed (changes on recalculation)
     */
    export function RAND(): number;
    /**
     * @summary Returns an array of random numbers
     * @param rows the number of rows in the returned array
     * @param columns the number of columns in the returned array
     * @param min the minimum number you would like returned
     * @param max the maximum number you would like returned
     * @param integer return an integer or a decimal value. TRUE for an integer, FALSE for a decimal number
     */
    export function RANDARRAY(rows?: number, columns?: number, min?: number, max?: number, integer?: boolean): number[][] | number;
    /**
     * @summary Returns a random number between the numbers you specify
     * @param bottom is the smallest integer RANDBETWEEN will return
     * @param top is the largest integer RANDBETWEEN will return
     */
    export function RANDBETWEEN(bottom: number, top: number): number;
    /**
     * @summary Converts an Arabic numeral to Roman, as text
     * @param number is the Arabic numeral you want to convert
     * @param form is the number specifying the type of Roman numeral you want.
     */
    export function ROMAN(number: number, form?: number): string;
    /**
     * @summary Rounds a number to a specified number of digits
     * @param number is the number you want to round
     * @param numDigits is the number of digits to which you want to round. Negative rounds to the left of the decimal point to the nearest integer
     */
    export function ROUND(number: number, numDigits: number): number;
    /**
     * @summary Rounds a number down, toward zero
     * @param number is any real number that you want rounded down
     * @param numDigits is the number of digits to which you want to round. Negative rounds to the left of the decimal point to the nearest integer
     */
    export function ROUNDDOWN(number: number, numDigits: number): number;
    /**
     * @summary Rounds a number up, away from zero
     * @param number is any real number that you want rounded up
     * @param numDigits is the number of digits to which you want to round. Negative rounds to the left of the decimal point to the nearest integer
     */
    export function ROUNDUP(number: number, numDigits: number): number;
    /**
     * @summary Returns a sequence of numbers
     * @param rows the number of rows to return
     * @param columns the number of columns to return
     * @param start the first number in the sequence
     * @param step the amount to increment each subsequent value in the sequence
     */
    export function SEQUENCE(rows: number, columns?: number, start?: number, step?: number): number[][];
    /**
     * @summary Returns the sum of a power series based on the formula
     * @param x is the input value to the power series
     * @param n is the initial power to which you want to raise x
     * @param m is the step by which to increase n for each term in the series
     * @param coefficients is a set of coefficients by which each successive power of x is multiplied
     */
    export function SERIESSUM(x: number, n: number, m: number, ...coefficients: number[]): number;
    /**
     * @summary Returns the sign of a number: 1 if the number is positive, zero if the number is zero, or -1 if the number is negative
     * @param number is any real number
     */
    export function SIGN(number: number): number;
    /**
     * @summary Returns the square root of a number
     * @param number is the number for which you want the square root
     */
    export function SQRT(number: number): number;
    /**
     * @summary Returns the square root of (number * Pi)
     * @param number is the number by which p is multiplied
     */
    export function SQRTPI(number: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns a subtotal in a list or database
     * @param functionNum is the number 1 to 11 that specifies the summary function for the subtotal.
     * @param ref ref1,ref2,... are 1 to 254 ranges or references for which you want the subtotal
     */
    export function SUBTOTAL(functionNum: number, // 1 - 11
    ...ref: IRange[]): any;
    /**
     * @summary Adds all the numbers in a range of cells
     * @param number number1,number2,... are 1 to 255 numbers to sum. Logical values and text are ignored in cells, included if typed as arguments
     */
    export function SUM(...number: IRange<number>[]): number;
    /**
     * @hidden Unimplemented
     * @summary Adds the cells specified by a given condition or criteria
     * @param range is the range of cells you want evaluated
     * @param criteria is the condition or criteria in the form of a number, expression, or text that defines which cells will be added
     * @param sumRange are the actual cells to sum. If omitted, the cells in range are used
     */
    export function SUMIF(range: IRange, criteria: IRange, sumRange?: IReferenceRange): IReferenceRange;
    /**
     * @hidden Unimplemented
     * @summary Adds the cells specified by a given set of conditions or criteria
     * @param sumRange are the actual cells to sum.
     * @param criteriaRange criteria_range1,criteria_range2,... is the range of cells you want evaluated for the particular condition
     * @param criteria criteria1,criteria2,... is the condition or criteria in the form of a number, expression, or text that defines which cells will be added
     */
    export function SUMIFS(sumRange: IRange, criteriaRange: IReferenceRange, // repeating pair
    criteria: IRange): any;
    /**
     * @summary Returns the sum of the products of corresponding ranges or arrays
     * @param array1 array1,array2,... are 2 to 255 arrays for which you want to multiply and then add components. All arrays must have the same dimensions
     */
    export function SUMPRODUCT(array1: any[][], ...rest: any[][][]): any;
    /**
     * @summary Returns the sum of the squares of the arguments. The arguments can be numbers, arrays, names, or references to cells that contain numbers
     * @param number number1,number2,... are 1 to 255 numbers, arrays, names, or references to arrays for which you want the sum of the squares
     */
    export function SUMSQ(...number: IRange[]): number;
    /**
     * @summary Sums the differences between the squares of two corresponding ranges or arrays
     * @param arrayX is the first range or array of numbers and can be a number or name, array, or reference that contains numbers
     * @param arrayY is the second range or array of numbers and can be a number or name, array, or reference that contains numbers
     */
    export function SUMX2MY2(arrayX: any[][], arrayY: any[][]): number;
    /**
     * @summary Returns the sum total of the sums of squares of numbers in two corresponding ranges or arrays
     * @param arrayX is the first range or array of numbers and can be a number or name, array, or reference that contains numbers
     * @param arrayY is the second range or array of numbers and can be a number or name, array, or reference that contains numbers
     */
    export function SUMX2PY2(arrayX: any[][], arrayY: any[][]): number;
    /**
     * @summary Sums the squares of the differences in two corresponding ranges or arrays
     * @param arrayX is the first range or array of numbers and can be a number or name, array, or reference that contains numbers
     * @param arrayY is the second range or array of numbers and can be a number or name, array, or reference that contains numbers
     */
    export function SUMXMY2(arrayX: any[][], arrayY: any[][]): number;
    /**
     * @summary Truncates a number to an integer by removing the decimal, or fractional, part of the number
     * @param number is the number you want to truncate
     * @param numDigits is a number specifying the precision of the truncation
     */
    export function TRUNC(number: number, numDigits?: number): number;
}
declare module ".generated/formulas/impl/mathTrig/Trig" {
    /**
     * @summary Returns the arccosine of a number, in radians in the range 0 to Pi. The arccosine is the angle whose cosine is Number
     * @param number is the cosine of the angle you want and must be from -1 to 1
     */
    export function ACOS(number: number): number;
    /**
     * @summary Returns the inverse hyperbolic cosine of a number
     * @param number is any real number equal to or greater than 1
     */
    export function ACOSH(number: number): number;
    /**
     * @summary Returns the arccotangent of a number, in radians in the range 0 to Pi.
     * @param number is the cotangent of the angle you want
     */
    export function ACOT(number: number): number;
    /**
     * @summary Returns the inverse hyperbolic cotangent of a number
     * @param number is the hyperbolic cotangent of the angle that you want
     */
    export function ACOTH(number: number): number;
    /**
     * @summary Returns the arcsine of a number in radians, in the range -Pi/2 to Pi/2
     * @param number is the sine of the angle you want and must be from -1 to 1
     */
    export function ASIN(number: number): number;
    /**
     * @summary Returns the inverse hyperbolic sine of a number
     * @param number is any real number equal to or greater than 1
     */
    export function ASINH(number: number): number;
    /**
     * @summary Returns the arctangent of a number in radians, in the range -Pi/2 to Pi/2
     * @param number is the tangent of the angle you want
     */
    export function ATAN(number: number): number;
    /**
     * @summary Returns the arctangent of the specified x- and y- coordinates, in radians between -Pi and Pi, excluding -Pi
     * @param x is the x-coordinate of the point
     * @param y is the y-coordinate of the point
     */
    export function ATAN2(x: number, y: number): number;
    /**
     * @summary Returns the inverse hyperbolic tangent of a number
     * @param number is any real number between -1 and 1 excluding -1 and 1
     */
    export function ATANH(number: number): number;
    /**
     * @summary Returns the cosine of an angle
     * @param number is the angle in radians for which you want the cosine
     */
    export function COS(number: number): number;
    /**
     * @summary Returns the hyperbolic cosine of a number
     * @param number is any real number
     */
    export function COSH(number: number): number;
    /**
     * @summary Returns the cotangent of an angle
     * @param number is the angle in radians for which you want the cotangent
     */
    export function COT(number: number): number;
    /**
     * @summary Returns the hyperbolic cotangent of a number
     * @param number is the angle in radians for which you want the hyperbolic cotangent
     */
    export function COTH(number: number): number;
    /**
     * @summary Returns the cosecant of an angle
     * @param number is the angle in radians for which you want the cosecant
     */
    export function CSC(number: number): number;
    /**
     * @summary Returns the hyperbolic cosecant of an angle
     * @param number is the angle in radians for which you want the hyperbolic cosecant
     */
    export function CSCH(number: number): number;
    /**
     * @summary Returns the secant of an angle
     * @param number is the angle in radians for which you want the secant
     */
    export function SEC(number: number): number;
    /**
     * @summary Returns the hyperbolic secant of an angle
     * @param number is the angle in radians for which you want the hyperbolic secant
     */
    export function SECH(number: number): number;
    /**
     * @summary Returns the sine of an angle
     * @param number is the angle in radians for which you want the sine. Degrees * PI()/180 = radians
     */
    export function SIN(number: number): number;
    /**
     * @summary Returns the hyperbolic sine of a number
     * @param number is any real number
     */
    export function SINH(number: number): number;
    /**
     * @summary Returns the tangent of an angle
     * @param number is the angle in radians for which you want the tangent. Degrees * PI()/180 = radians
     */
    export function TAN(number: number): number;
    /**
     * @summary Returns the hyperbolic tangent of a number
     * @param number is any real number
     */
    export function TANH(number: number): number;
}
declare module ".generated/formulas/impl/statistical/Statistical" {
    import { IRange, IReferenceRange } from '@sheetxl/primitives';
    /**
     * @summary Returns the average of the absolute deviations of data points from their mean. Arguments can be numbers or names, arrays, or references that contain numbers
     * @param number number1,number2,... are 1 to 255 arguments for which you want the average of the absolute deviations
     */
    export function AVEDEV(...number: IRange<number>[]): number;
    /**
     * @summary Returns the average (arithmetic mean) of its arguments, which can be numbers or names, arrays, or references that contain numbers
     * @param number number1,number2,... are 1 to 255 numeric arguments for which you want the average
     */
    export function AVERAGE(...number: IRange<number>[]): number;
    /**
     * @summary Returns the average (arithmetic mean) of its arguments, evaluating text and FALSE in arguments as 0; TRUE evaluates as 1. Arguments can be numbers, names, arrays, or references
     * @param value value1,value2,... are 1 to 255 arguments for which you want the average
     */
    export function AVERAGEA(...value: IRange<number>[]): number;
    /**
     * @hidden Unimplemented
     * @summary Finds average(arithmetic mean) for the cells specified by a given condition or criteria
     * @param range is the range of cells you want evaluated
     * @param criteria is the condition or criteria in the form of a number, expression, or text that defines which cells will be used to find the average
     * @param averageRange are the actual cells to be used to find the average. If omitted, the cells in range are used
     */
    export function AVERAGEIF(range: IRange, criteria: IRange, averageRange?: IReferenceRange): IReferenceRange;
    /**
     * @hidden Unimplemented
     * @summary Finds average(arithmetic mean) for the cells specified by a given set of conditions or criteria
     * @param averageRange are the actual cells to be used to find the average.
     * @param criteriaRange criteria_range1,criteria_range2,... is the range of cells you want evaluated for the particular condition
     * @param criteria criteria1,criteria2,... is the condition or criteria in the form of a number, expression, or text that defines which cells will be used to find the average
     */
    export function AVERAGEIFS(averageRange: IRange, criteriaRange: IRange, ...criteria: IRange[]): any;
    /**
     * @summary Counts the number of cells in a range that contain numbers
     * @param number value1,value2,... are 1 to 255 arguments that can contain or refer to a variety of different types of data, but only numbers are counted
     */
    export function COUNT(...number: IRange<number>[]): number;
    /**
     * @summary Counts the number of cells in a range that are not empty
     * @param value value1,value2,... are 1 to 255 arguments representing the values and cells you want to count. Values can be any type of information
     */
    export function COUNTA(...value: IRange<number>[]): number;
    /**
     * @hidden Unimplemented
     * @summary Counts the number of empty cells in a specified range of cells
     * @param range is the range from which you want to count the empty cells
     */
    export function COUNTBLANK(range: IRange): number;
    /**
     * @hidden Unimplemented
     * @summary Counts the number of cells within a range that meet the given condition
     * @param range is the range of cells from which you want to count nonblank cells
     * @param criteria is the condition in the form of a number, expression, or text that defines which cells will be counted
     */
    export function COUNTIF(range: IRange, criteria: IRange): number;
    /**
     * @hidden Unimplemented
     * @summary Counts the number of cells specified by a given set of conditions or criteria
     * @param criteriaRange criteria_range1,criteria_range2,... is the range of cells you want evaluated for the particular condition
     * @param criteria criteria1,criteria2,... is the condition in the form of a number, expression, or text that defines which cells will be counted
     */
    export function COUNTIFS(criteriaRange: IRange, criteria: IRange): number;
    /**
     * @summary Returns the k-th largest value in a data set. For example, the fifth largest number.
     * @param array is the array or range of data for which you want to determine the k-th largest value.
     * @param k is the position (from the largest) in the array or cell range of the value to return.
     */
    export function LARGE(array: IRange<number>, k: number): number;
    /**
     * @summary Returns the largest value in a set of values. Ignores logical values and text
     * @param number number1,number2,... are 1 to 255 numbers, empty cells, logical values, or text numbers for which you want the maximum
     */
    export function MAX(...number: IRange<number>[]): number;
    /**
     * @summary Returns the largest value in a set of values. Does not ignore logical values and text
     * @param value value1,value2,... are 1 to 255 numbers, empty cells, logical values, or text numbers for which you want the maximum
     */
    export function MAXA(...value: IRange[]): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the maximum value among cells specified by a given set of conditions or criteria
     * @param maxRange the cells in which to determine the maximum value
     * @param criteriaRange criteria_range1,criteria_range2,... is the range of cells you want to evaluate for the particular condition
     * @param criteria criteria1,criteria2,... is the condition or criteria in the form of a number, expression, or text that defines which cells will be included when determining the maximum value
     */
    export function MAXIFS(maxRange: IRange, criteriaRange: IRange, ...criteria: IRange[]): number;
    /**
     * @summary Returns the median, or the number in the middle of the set of given numbers
     * @param number number1,number2,... are 1 to 255 numbers or names, arrays, or references that contain numbers for which you want the median
     */
    export function MEDIAN(...number: IRange<number>[]): number;
    /**
     * @summary Returns the smallest number in a set of values. Ignores logical values and text
     * @param number number1,number2,... are 1 to 255 numbers, empty cells, logical values, or text numbers for which you want the minimum
     */
    export function MIN(...number: IRange<number>[]): number;
    /**
     * @summary Returns the smallest value in a set of values. Does not ignore logical values and text
     * @param value value1,value2,... are 1 to 255 numbers, empty cells, logical values, or text numbers for which you want the minimum
     */
    export function MINA(...value: IRange[]): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the minimum value among cells specified by a given set of conditions or criteria
     * @param maxRange is the range of cells to evaluate for the minimum value
     * @param criteriaRange is the range of cells to evaluate against the criteria
     * @param criteria is the criteria to evaluate against the criteria range
     */
    export function MINIFS(maxRange: IRange, criteriaRange: IRange, ...criteria: IRange[]): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the number of permutations for a given number of objects that can be selected from the total objects
     * @param number is the total number of objects
     * @param numberChoosen is the number of objects in each permutation
     */
    export function PERMUT(number: number, numberChoosen: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the number of permutations for a given number of objects (with repetitions) that can be selected from the total objects
     * @param number is the total number of objects
     * @param numberChoosen is the number of objects in each permutation
     */
    export function PERMUTATIONA(number: number, numberChoosen: number): number;
    /**
     * @summary Returns the k-th smallest value in a data set. For example, the fifth smallest number
     * @param array is an array or range of numerical data for which you want to determine the k-th smallest value
     * @param k is the position (from the smallest) in the array or range of the value to return
     */
    export function SMALL(array: IRange<number>, k: number): number;
}
declare module ".generated/formulas/impl/statistical/Distribution" {
    import { IRange } from '@sheetxl/primitives';
    /**
     * @name BETA.DIST
     * @summary Returns the beta probability distribution function
     * @param x is the value between A and B at which to evaluate the function
     * @param alpha is a parameter to the distribution and must be greater than 0
     * @param beta is a parameter to the distribution and must be greater than 0
     * @param cumulative is a logical value: for the cumulative distribution function, use TRUE; for the probability density function, use FALSE
     * @param a lower bound to the interval of x
     * @param b upper bound to the interval of x
     */
    export function BETA_DIST(x: number, alpha: number, beta: number, cumulative: boolean, a?: number, b?: number): number;
    /**
     * @summary Returns the cumulative beta probability density function
     * @param x is the value between A and B at which to evaluate the function
     * @param alpha is a parameter to the distribution and must be greater than 0
     * @param beta is a parameter to the distribution and must be greater than 0
     * @param cumulative is a logical value: for the cumulative distribution function, use TRUE; for the probability density function, use FALSE
     * @param a lower bound to the interval of x
     * @param b upper bound to the interval of x
     * @category Compatibility
     */
    export function BETADIST(x: number, alpha: number, beta: number, cumulative: boolean, a?: number, b?: number): number;
    /**
     * @name BETA.INV
     * @summary Returns the inverse of the cumulative beta probability density function (BETA.DIST)
     * @param probability is a probability associated with the beta distribution
     * @param alpha is a parameter to the distribution and must be greater than 0
     * @param beta is a parameter to the distribution and must be greater than 0
     * @param a lower bound to the interval of x
     * @param b upper bound to the interval of x
     */
    export function BETA_INV(probability: number, alpha: number, beta: number, a?: number, b?: number): number;
    /**
     * @category Compatibility
     * @summary Returns the inverse of the cumulative beta probability density function (BETADIST)
     * @param probability is a probability associated with the beta distribution
     * @param alpha is a parameter to the distribution and must be greater than 0
     * @param beta is a parameter to the distribution and must be greater than 0
     * @param a lower bound to the interval of x
     * @param b upper bound to the interval of x
     */
    export function BETAINV(probability: number, alpha: number, beta: number, a?: number, b?: number): number;
    /**
     * @name BINOM.DIST
     * @summary Returns the individual term binomial distribution probability
     * @param numberS is the number of successes in trials
     * @param trials is the number of independent trials
     * @param probabilityS is the probability of success on each trial
     * @param cumulative is a logical value: for the cumulative distribution function, use TRUE; for the probability mass function, use FALSE
     */
    export function BINOM_DIST(numberS: number, trials: number, probabilityS: number, cumulative: boolean): number;
    /**
     * @category Compatibility
     * @summary Returns the individual term binomial distribution probability
     * @param numberS is the number of successes in trials
     * @param trials is the number of independent trials
     * @param probabilityS is the probability of success on each trial
     * @param cumulative is a logical value: for the cumulative distribution function, use TRUE; for the probability mass function, use FALSE
     */
    export function BINOMDIST(numberS: number, trials: number, probabilityS: number, cumulative: boolean): number;
    /**
     * @name BINOM.DIST.RANGE
     * @summary Returns the probability of a trial result using a binomial distribution
     * @param trials is the number of independent trials
     * @param probabilityS is the probability of success on each trial
     * @param numberS is the number of successes in trials
     * @param numberS2 if provided this function returns the probability that the number of successful trials shall lie between number_s and number_s2
     */
    export function BINOM_DIST_RANGE(trials: number, probabilityS: number, numberS: number, numberS2?: number): number;
    /**
     * @name BINOM.INV
     * @summary Returns the smallest value for which the cumulative binomial distribution is greater than or equal to a criterion value
     * @param trials is the number of Bernoulli trials
     * @param probabilityS is the probability of success on each trial, a number between 0 and 1 inclusive
     * @param alpha is the criterion value, a number between 0 and 1 inclusive
     */
    export function BINOM_INV(trials: number, probabilityS: number, alpha: number): number;
    /**
     * @name CHISQ.DIST
     * @summary Returns the left-tailed probability of the chi-squared distribution
     * @param x is the value at which you want to evaluate the distribution, a nonnegative number
     * @param degFreedom is the number of degrees of freedom, a number between 1 and 10^10, excluding 10^10
     * @param cumulative is a logical value for the function to return: the cumulative distribution function = TRUE; the probability density function = FALSE
     */
    export function CHISQ_DIST(x: number, degFreedom: number, cumulative?: boolean): number;
    /**
     * @category Compatibility
     * @summary Returns the right-tailed probability of the chi-squared distribution
     * @param x is the value at which you want to evaluate the distribution, a nonnegative number
     * @param degFreedom is the number of degrees of freedom, a number between 1 and 10^10, excluding 10^10
     */
    export function CHIDIST(x: number, degFreedom: number): number;
    /**
     * @name CHISQ.DIST.RT
     * @summary Returns the right-tailed probability of the chi-squared distribution
     * @param x is the value at which you want to evaluate the distribution, a nonnegative number
     * @param degFreedom is the number of degrees of freedom, a number between 1 and 10^10, excluding 10^10
     */
    export function CHISQ_DIST_RT(x: number, degFreedom: number): number;
    /**
     * @name CHISQ.INV
     * @summary Returns the inverse of the left-tailed probability of the chi-squared distribution
     * @param probability is a probability associated with the chi-squared distribution, a value between 0 and 1 inclusive
     * @param degFreedom is the number of degrees of freedom, a number between 1 and 10^10, excluding 10^10
     */
    export function CHISQ_INV(probability: number, degFreedom: number): number;
    /**
     * @category Compatibility
     * @summary Returns the inverse of the right-tailed probability of the chi-squared distribution
     * @param probability is a probability associated with the chi-squared distribution, a value between 0 and 1 inclusive
     * @param degFreedom is the number of degrees of freedom, a number between 1 and 10^10, excluding 10^10
     */
    export function CHIINV(probability: number, degFreedom: number): number;
    /**
     * @name CHISQ.INV.RT
     * @summary Returns the right-tailed probability of the chi-squared distribution
     * @param probability is a probability associated with the chi-squared distribution, a value between 0 and 1 inclusive
     * @param degFreedom is the number of degrees of freedom, a number between 1 and 10^10, excluding 10^10
     */
    export function CHISQ_INV_RT(probability: number, degFreedom: number): number;
    /**
     * @name CHISQ.TEST
     * @summary Returns the test for independence: the value from the chi-squared distribution for the statistic and the appropriate degrees of freedom
     * @param actualRange is the range of data that contains observations to test against expected values
     * @param expectedRange is the range of data that contains the ratio of the product of row totals and column totals to the grand total
     */
    export function CHISQ_TEST(actualRange: any[][], expectedRange: any[][]): number;
    /**
     * @category Compatibility
     * @summary Returns the test for independence: the value from the chi-squared distribution for the statistic and the appropriate degrees of freedom
     * @param actualRange is the range of data that contains observations to test against expected values
     * @param expectedRange is the range of data that contains the ratio of the product of row totals and column totals to the grand total
     */
    export function CHITEST(actualRange: any[][], expectedRange: any[][]): number;
    /**
     * @name CONFIDENCE.NORM
     * @summary Returns the confidence interval for a population mean, using a normal distribution
     * @param alpha is the significance level used to compute the confidence level, a number greater than 0 and less than 1
     * @param standardDev is the population standard deviation for the data range and is assumed to be known. Standard_dev must be greater than 0
     * @param size is the sample size
     */
    export function CONFIDENCE_NORM(alpha: number, standardDev: number, size: number): number;
    /**
     * @category Compatibility
     * @summary Returns the confidence interval for a population mean, using a normal distribution
     * @param alpha is the significance level used to compute the confidence level, a number greater than 0 and less than 1
     * @param std is the population standard deviation for the data range and is assumed to be known. Standard_dev must be greater than 0
     * @param dev is the population standard deviation for the data range and is assumed to be known. Standard_dev must be greater than 0
     * @param size is the sample size
     */
    export function CONFIDENCE(alpha: number, std: number, dev: number, size: number): number;
    /**
     * @name CONFIDENCE.T
     * @summary Returns the confidence interval for a population mean, using a Student's T distribution
     * @param alpha is the significance level used to compute the confidence level, a number greater than 0 and less than 1
     * @param standardDev is the population standard deviation for the data range and is assumed to be known. Standard_dev must be greater than 0
     * @param size is the sample size
     */
    export function CONFIDENCE_T(alpha: number, standardDev: number, size: number): number;
    /**
     * @summary Returns the correlation coefficient between two data sets
     * @param array1 is a cell range of values. The values should be numbers, names, arrays, or references that contain numbers
     * @param array2 is a second cell range of values. The values should be numbers, names, arrays, or references that contain numbers
     */
    export function CORREL(array1: any[], array2: any[]): number;
    /**
     * @name COVARIANCE.P
     * @summary Returns population covariance, the average of the products of deviations for each data point pair in two data sets
     * @param array1 is the first cell range of integers and must be numbers, arrays, or references that contain numbers
     * @param array2 is the second cell range of integers and must be numbers, arrays, or references that contain numbers
     */
    export function COVARIANCE_P(array1: any[], array2: any[]): number;
    /**
     * @category Compatibility
     * @summary Returns population covariance, the average of the products of deviations for each data point pair in two data sets
     * @param array1 is the first cell range of integers and must be numbers, arrays, or references that contain numbers
     * @param array2 is the second cell range of integers and must be numbers, arrays, or references that contain numbers
     */
    export function COVARIANCE(array1: any[], array2: any[]): number;
    /**
     * @name COVARIANCE.S
     * @summary Returns sample covariance, the average of the products of deviations for each data point pair in two data sets
     * @param array1 is the first cell range of integers and must be numbers, arrays, or references that contain numbers
     * @param array2 is the second cell range of integers and must be numbers, arrays, or references that contain numbers
     */
    export function COVARIANCE_S(array1: any[], array2: any[]): number;
    /**
     * @hidden Unimplemented
     * @category Compatibility
     * @summary Returns the smallest value for which the cumulative binomial distribution is greater than or equal to a criterion value
     * @param trails is the number of Bernoulli trials
     * @param probabilityS is the probability of success on each trial, a number between 0 and 1 inclusive
     * @param alpha is the criterion value, a number between 0 and 1 inclusive
     */
    export function CRITBINOM(trails: any[][], probabilityS: number, alpha: number): number;
    /**
     * @summary Returns the sum of squares of deviations of data points from their sample mean
     * @param number number1,number2,... are 1 to 255 arguments, or an array or array reference, on which you want DEVSQ to calculate
     */
    export function DEVSQ(...number: IRange<number>[]): number;
    /**
     * @name EXPON.DIST
     * @summary Returns the exponential distribution
     * @param x is the value of the function, a nonnegative number
     * @param lambda is the parameter value, a positive number
     * @param cumulative is a logical value for the function to return: the cumulative distribution function = TRUE; the probability density function = FALSE
     */
    export function EXPON_DIST(x: number, lambda: number, cumulative: boolean): number;
    /**
     * @category Compatibility
     * @summary Returns the exponential distribution
     * @param x is the value of the function, a nonnegative number
     * @param lambda is the parameter value, a positive number
     * @param cumulative is a logical value for the function to return: the cumulative distribution function = TRUE; the probability density function = FALSE
     *
     */
    export function EXPONDIST(x: number, lambda: number, cumulative: boolean): number;
    /**
     * @name F.DIST
     * @summary Returns the (left-tailed) F probability distribution (degree of diversity) for two data sets
     * @param x is the value at which to evaluate the function, a nonnegative number
     * @param degFreedom1 is the numerator degrees of freedom, a number between 1 and 10^10, excluding 10^10
     * @param degFreedom2 is the denominator degrees of freedom, a number between 1 and 10^10, excluding 10^10
     * @param cumulative is a logical value for the function to return: the cumulative distribution function = TRUE; the probability density function = FALSE
     */
    export function F_DIST(x: number, degFreedom1: number, degFreedom2: number, cumulative: boolean): number;
    /**
     * @category Compatibility
     * @summary Returns the (left-tailed) F probability distribution (degree of diversity) for two data sets
     * @param x is the value at which to evaluate the function, a nonnegative number
     * @param degFreedom1 is the numerator degrees of freedom, a number between 1 and 10^10, excluding 10^10
     * @param degFreedom2 is the denominator degrees of freedom, a number between 1 and 10^10, excluding 10^10
     */
    export function FDIST(x: number, degFreedom1: number, degFreedom2: number): number;
    /**
     * @name F.DIST.RT
     * @summary Returns the (right-tailed) F probability distribution (degree of diversity) for two data sets
     * @param x is the value at which to evaluate the function, a nonnegative number
     * @param degFreedom1 is the numerator degrees of freedom, a number between 1 and 10^10, excluding 10^10
     * @param degFreedom2 is the denominator degrees of freedom, a number between 1 and 10^10, excluding 10^10
     */
    export function F_DIST_RT(x: number, degFreedom1: number, degFreedom2: number): number;
    /**
     * @name F.INV
     * @summary Returns the inverse of the (left-tailed) F probability distribution: if p = F.DIST(x,...), then F.INV(p,...) = x
     * @param probability is a probability associated with the F cumulative distribution, a number between 0 and 1 inclusive
     * @param degFreedom1 is the numerator degrees of freedom, a number between 1 and 10^10, excluding 10^10
     * @param degFreedom2 is the denominator degrees of freedom, a number between 1 and 10^10, excluding 10^10
     */
    export function F_INV(probability: number, degFreedom1: number, degFreedom2: number): number;
    /**
     * @category Compatibility
     * @summary Returns the inverse of the (left-tailed) F probability distribution: if p = F.DIST(x,...), then F.INV(p,...) = x
     * @param probability is a probability associated with the F cumulative distribution, a number between 0 and 1 inclusive
     * @param degFreedom1 is the numerator degrees of freedom, a number between 1 and 10^10, excluding 10^10
     * @param degFreedom2 is the denominator degrees of freedom, a number between 1 and 10^10, excluding 10^10
     */
    export function FINV(probability: number, degFreedom1: number, degFreedom2: number): number;
    /**
     * @name F.INV.RT
     * @summary Returns the inverse of the (right-tailed) F probability distribution: if p = F.DIST.RT(x,...), then F.INV.RT(p,...) = x
     * @param probability is a probability associated with the F cumulative distribution, a number between 0 and 1 inclusive
     * @param degFreedom1 is the numerator degrees of freedom, a number between 1 and 10^10, excluding 10^10
     * @param degFreedom2 is the denominator degrees of freedom, a number between 1 and 10^10, excluding 10^10
     */
    export function F_INV_RT(probability: number, degFreedom1: number, degFreedom2: number): number;
    /**
     * @name F.TEST
     * @summary Returns the result of an F-test, the two-tailed probability that the variances in Array1 and Array2 are not significantly different
     * @param array1 is the first array or range of data and can be numbers or names, arrays, or references that contain numbers (blanks are ignored)
     * @param array2 is the second array or range of data and can be numbers or names, arrays, or references that contain numbers (blanks are ignored)
     *
     * @help https://en.wikipedia.org/wiki/F-test_of_equality_of_variances
     */
    export function F_TEST(array1: any[], array2: any[]): number;
    /**
     * @category Compatibility
     * @summary Returns the result of an F-test, the two-tailed probability that the variances in Array1 and Array2 are not significantly different
     * @param array1 is the first array or range of data and can be numbers or names, arrays, or references that contain numbers (blanks are ignored)
     * @param array2 is the second array or range of data and can be numbers or names, arrays, or references that contain numbers (blanks are ignored)
     */
    export function FTEST(array1: any[], array2: any[]): number;
    /**
     * @summary Returns the Fisher transformation
     * @param x is the value for which you want the transformation, a number between -1 and 1, excluding -1 and 1
     */
    export function FISHER(x: number): number;
    /**
     * @summary Returns the inverse of the Fisher transformation: if y = FISHER(x), then FISHERINV(y) = x
     * @param y is the value for which you want to perform the inverse of the transformation
     */
    export function FISHERINV(y: number): number;
    /**
     * @category Compatibility
     * @summary Calculates, or predicts, a future value along a linear trend by using existing values
     * @param x is the data point for which you want to predict a value and must be a numeric value
     * @param knownYs is the dependent array or range of numeric data
     * @param knownXs is the independent array or range of numeric data. The variance of Known_x's must not be zero
     */
    export function FORECAST(x: number, knownYs?: any[], knownXs?: any[]): number;
    /**
     * @hidden Unimplemented
     * @name FORECAST.ETS
     * @summary Returns the forecasted value for a specific future target date using exponential smoothing method
     * @param targetDate is the data point for which you want to predict a value. It should carry on the pattern of values in the timeline
     * @param values is the array or range of numberic data you're predicting
     * @param timeline is the independent array or range of numberic data. The dtes in the timeline must have a consistent step between them and can't be zero.
     * @param seasonality is a number value that indicates the length of the seasonal pattern in the data. It must be between 0 and 1, where 0 means no seasonality and 1 means full seasonality
     * @param dataCompletion is a number value that indicates how much of the data is complete. It must be between 0 and 1, where 0 means no data is complete and 1 means all data is complete
     * @param aggregation is a number value that indicates how the data should be aggregated. It must be between 0 and 1, where 0 means no aggregation and 1 means full aggregation
     */
    export function FORECAST_ETS(targetDate: number, values: IRange, //[] union?
    timeline: IRange, //[] union?
    seasonality?: number, // 0-1
    dataCompletion?: number, aggregation?: number): number;
    /**
     * @hidden Unimplemented
     * @name FORECAST.ETS.CONFINT
     * @summary Retursn a confidence interval for the forecasted value at the specified target date
     * @param targetDate is the data point for which you want to predict a value. It should carry on the pattern of values in the timeline
     * @param values is the array or range of numberic data you're predicting
     * @param timeline is the independent array or range of numberic data. The dtes in the timeline must have a consistent step between them and can't be zero.
     * @param confiedenceLevel is a number value that indicates the confidence level for the forecasted value. It must be between 0 and 1, where 0 means no confidence and 1 means full confidence
     * @param seasonality is a number value that indicates the length of the seasonal pattern in the data. It must be between 0 and 1, where 0 means no seasonality and 1 means full seasonality
     * @param dataCompletion is a number value that indicates how much of the data is complete. It must be between 0 and 1, where 0 means no data is complete and 1 means all data is complete
     * @param aggregation is a number value that indicates how the data should be aggregated. It must be between 0 and 1, where 0 means no aggregation and 1 means full aggregation
     */
    export function FORECAST_ETS_CONFINT(targetDate: number, values: IRange, //[] union?
    timeline: IRange, //[] union?
    confiedenceLevel?: number, // 0-1
    seasonality?: number, // 0-1
    dataCompletion?: number, aggregation?: number): number;
    /**
     * @hidden Unimplemented
     * @name FORECAST.ETS.SEASONALITY
     * @summary Returns the length of the repetitive pattern in the data for the specific time series.
     * @param values is the array or range of numberic data you're predicting
     * @param timeline is the independent array or range of numberic data. The dtes in the timeline must have a consistent step between them and can't be zero.
     * @param dataCompletion is a number value that indicates how much of the data is complete. It must be between 0 and 1, where 0 means no data is complete and 1 means all data is complete
     * @param aggregation is a number value that indicates how the data should be aggregated. It must be between 0 and 1, where 0 means no aggregation and 1 means full aggregation
     */
    export function FORECAST_ETS_SEASONALITY(values: IRange, //[] union?
    timeline: IRange, //[] union?
    dataCompletion?: number, aggregation?: number): number;
    /**
     * @hidden Unimplemented
     * @name FORECAST.ETS.STAT
     * @summary Returns the requested statistic for the forecast
     * @param values is the array or range of numberic data you're predicting
     * @param timeline is the independent array or range of numberic data. The dtes in the timeline must have a consistent step between them and can't be zero.
     * @param statisticType is a number between 1 and 8 that indicates the type of statistic to return:
     * @param seasonality is a number value that indicates the length of the seasonal pattern in the data. It must be between 0 and 1, where 0 means no seasonality and 1 means full seasonality
     * @param dataCompletion is a number value that indicates how much of the data is complete. It must be between 0 and 1, where 0 means no data is complete and 1 means all data is complete
     * @param aggregation is a number value that indicates how the data should be aggregated. It must be between 0 and 1, where 0 means no aggregation and 1 means full aggregation
     */
    export function FORECAST_ETS_STAT(values: IRange, //[] union?
    timeline: IRange, //[] union?
    statisticType: number, // 1- 8
    seasonality?: number, dataCompletion?: number, aggregation?: number): number;
    /**
     * @hidden Unimplemented
     * @name FORECAST.LINEAR
     * @summary Calculates, or predicts, a future value along a linear trend by using existing values
     * @param x is the data point for which you want to predict a value and must be a numeric value
     * @param knownYs is the dependent array or range of numeric data
     * @param knownXs is the independent array or range of numeric data. The variance of Known_x's must not be zero
     */
    export function FORECAST_LINEAR(x: number, knownYs: any[], knownXs?: any[]): number;
    /**
     * @summary Calculates how often values occur within a range of values and then returns a vertical array of numbers having one more element than Bins_array
     * @param dataArray is an array of or reference to a set of values for which you want to count frequencies (blanks and text are ignored)
     * @param binsArray is an array of or reference to intervals into which you want to group the values in data_array
     */
    export function FREQUENCY(dataArray: any[][], binsArray: any[][]): any[][];
    /**
     * @summary Returns the Gamma function value
     * @param x is the value for which you want to calculate Gamma
     */
    export function GAMMA(x: number): number;
    /**
     * @name GAMMA.DIST
     * @summary Returns the gamma distribution
     * @param x is the value at which you want to evaluate the distribution, a nonnegative number
     * @param alpha is a parameter to the distribution, a positive number
     * @param beta is a parameter to the distribution, a positive number. If beta = 1, GAMMA.DIST returns the standard gamma distribution
     * @param cumulative is a logical value: return the cumulative distribution function = TRUE; return the probability mass function = FALSE
     */
    export function GAMMA_DIST(x: number, alpha: number, beta: number, cumulative?: boolean): number;
    /**
     * @name GAMMA.INV
     * @summary Returns the inverse of the gamma cumulative distribution: if p = GAMMA.DIST(x,...), then GAMMA.INV(p,...) = x
     * @param probability is the probability associated with the gamma distribution, a number between 0 and 1, inclusive
     * @param alpha is a parameter to the distribution, a positive number
     * @param beta is a parameter to the distribution, a positive number. If beta = 1, GAMMA.DIST returns the standard gamma distribution
     */
    export function GAMMA_INV(probability: number, alpha: number, beta: number): number;
    /**
     * @summary Returns the natural logarithm of the gamma function
     * @param x is the value for which you want to calculate GAMMALN, a positive number
     */
    export function GAMMALN(x: number): number;
    /**
     * @name GAMMALN.PRECISE
     * @summary Returns the natural logarithm of the gamma function
     * @param x is the value for which you want to calculate GAMMALN.PRECISE, a positive number
     */
    export function GAMMALN_PRECISE(x: number): number;
    /**
     * @summary Returns 0.5 less than the standard normal cumulative distribution
     * @param x is the value for which you want the distribution
     */
    export function GAUSS(x: number): number;
    /**
     * @summary Returns the geometric mean of an array or range of positive numeric data
     * @param number number1,number2,... are 1 to 255 numbers or names, arrays, or references that contain numbers for which you want the mean
     */
    export function GEOMEAN(...number: IRange<number>[]): number;
    /**
     * @summary Returns numbers in an exponential growth trend matching known data points
     * @param knownYs is the set of y-values you already know in the relationship y = b*m^x, an array or range of positive numbers
     * @param knownXs is an optional set of x-values that you may already know in the relationship y = b*m^x, an array or range the same size as Known_y's
     * @param newXs  are new x-values for which you want GROWTH to return corresponding y-values
     * @param useConst is a logical value: the constant b is calculated normally if Const = TRUE; b is set equal to 1 if Const = FALSE
     */
    export function GROWTH(knownYs: any[], knownXs?: any[], newXs?: any[][], useConst?: boolean): number[][];
    /**
     * @summary Returns the harmonic mean of a data set of positive numbers: the reciprocal of the arithmetic mean of reciprocals
     * @param number number1,number2,... are 1 to 255 numbers or names, arrays, or references that contain numbers for which you want the harmonic mean
     */
    export function HARMEAN(...number: IRange<number>[]): number;
    /**
     * @name HYPGEOM.DIST
     * @summary Returns the hypergeometric distribution
     * @param sampleS is the number of successes in the sample
     * @param numberSample is the size of the sample
     * @param populationS is the number of successes in the population
     * @param numberPop is the population size
     * @param cumulative is a logical value: for the cumulative distribution function, use TRUE; for the probability density function, use FALSE
     */
    export function HYPGEOM_DIST(sampleS: number, numberSample: number, populationS: number, numberPop: number, cumulative: boolean): number;
    /**
     * @summary Calculates the point at which a line will intersect the y-axis by using a best-fit regression line plotted through the known x-values and y-values
     * @param knownYs is the dependent set of observations or data and can be numbers or names, arrays, or references that contain numbers
     * @param knownXs is the independent set of observations or data and can be numbers or names, arrays, or references that contain numbers
     */
    export function INTERCEPT(knownYs: any[], knownXs: any[]): number;
    /**
     * @summary Returns the kurtosis of a data set
     * @param number number1,number2,... are 1 to 255 numbers or names, arrays, or references that contain numbers for which you want the kurtosis
     */
    export function KURT(...number: IRange<number>[]): number;
    /**
     * @summary Returns statistics that describe a linear trend matching known data points, by fitting a straight line using the least squares method
     * @param knownYs is the set of y-values you already know in the relationship y = mx + b
     * @param knownXs is an optional set of x-values that you may already know in the relationship y = mx + b
     * @param constant is a logical value: the constant b is calculated normally if Const = TRUE; b is set equal to 0 if Const = FALSE
     * @param stats is a logical value: return additional regression statistics = TRUE; return m-coefficients and the constant b = FALSE
     */
    export function LINEST(knownYs: IRange, knownXs?: IRange, constant?: boolean, stats?: boolean): number[];
    /**
     * @hidden Unimplemented Buggy
     * @summary Returns statistics that describe an exponential curve matching known data points
     * @param knownYs is the set of y-values you already know in the relationship y = b*m^x
     * @param knownXs is an optional set of x-values that you may already know in the relationship y = b*m^x
     * @param constant is a logical value: the constant b is calculated normally if Const = TRUE; b is set equal to 1 if Const = FALSE
     * @param stats is a logical value: return additional regression statistics = TRUE; return m-coefficients and the constant b = FALSE
     */
    export function LOGEST(knownYs: IRange, knownXs?: IRange, constant?: boolean, stats?: boolean): number[];
    /**
     * @name LOGNORM.DIST
     * @summary Returns the lognormal distribution of x, where ln(x) is normally distributed with parameters Mean and Standard_dev
     * @param x is the value at which to evaluate the function, a positive number
     * @param mean is the mean of ln(x)
     * @param standardDev is the standard deviation of ln(x), a positive number
     * @param cumulative is a logical value: for the cumulative distribution function, use TRUE; for the probability density function, use FALSE
     */
    export function LOGNORM_DIST(x: number, mean: number, standardDev: number, cumulative: boolean): number;
    /**
     * @name LOGNORM.INV
     * @summary Returns the inverse of the lognormal cumulative distribution function of x, where ln(x) is normally distributed with parameters Mean and Standard_dev
     * @param probability is a probability associated with the lognormal distribution, a number between 0 and 1, inclusive
     * @param mean is the mean of ln(x)
     * @param standardDev is the standard deviation of ln(x), a positive number
     */
    export function LOGNORM_INV(probability: number, mean: number, standardDev: number): number;
    /**
     * @hidden Unimplemented
     * @name MODE.MULT
     * @summary Returns a vertical array of the most frequently occurring, or repetitive, values in an array or range of data.  For a horizontal array, use =TRANSPOSE(MODE.MULT(number1,number2,...))
     * @param number <div class="param-538">number1,number2,... are 1 to 255 numbers, or names, arrays, or references that contain numbers for which you want the mode</div>
     */
    export function MODE_MULT(...number: IRange[]): number;
    /**
     * @hidden Unimplemented
     * @name MODE.SNGL
     * @summary Returns the most frequently occurring, or repetitive, value in an array or range of data
     * @param number number1,number2,... are 1 to 255 numbers, or names, arrays, or references that contain numbers for which you want the mode
     */
    export function MODE_SNGL(...number: IRange[]): number;
    /**
     * @name NEGBINOM.DIST
     * @summary Returns the negative binomial distribution, the probability that there will be Number_f failures before the Number_s-th success, with Probability_s probability of a success
     * @param numberF is the number of failures
     * @param numberS is the threshold number of successes
     * @param probabilityS is the probability of a success; a number between 0 and 1
     * @param cumulative is a logical value: for the cumulative distribution function, use TRUE; for the probability mass function, use FALSE
     */
    export function NEGBINOM_DIST(numberF: number, numberS: number, probabilityS: number, cumulative: boolean): number;
    /**
     * @name NORM.DIST
     * @summary Returns the normal distribution for the specified mean and standard deviation
     * @param x is the value for which you want the distribution
     * @param mean is the arithmetic mean of the distribution
     * @param standardDev is the standard deviation of the distribution, a positive number
     * @param cumulative is a logical value: for the cumulative distribution function, use TRUE; for the probability density function, use FALSE
     */
    export function NORM_DIST(x: number, mean: number, standardDev: number, cumulative: boolean): number;
    /**
     * @name NORM.INV
     * @summary Returns the inverse of the normal cumulative distribution for the specified mean and standard deviation
     * @param probability is a probability corresponding to the normal distribution, a number between 0 and 1 inclusive
     * @param mean is the arithmetic mean of the distribution
     * @param standardDev is the standard deviation of the distribution, a positive number
     */
    export function NORM_INV(probability: number, mean: number, standardDev: number): number;
    /**
     * @name NORM.S.DIST
     * @summary Returns the standard normal distribution (has a mean of zero and a standard deviation of one)
     * @param z is the value for which you want the distribution
     * @param cumulative is a logical value for the function to return: the cumulative distribution function = TRUE; the probability density function = FALSE
     */
    export function NORM_S_DIST(z: number, cumulative: boolean): number;
    /**
     * @name NORM.S.INV
     * @summary Returns the inverse of the standard normal cumulative distribution (has a mean of zero and a standard deviation of one)
     * @param probability is a probability corresponding to the normal distribution, a number between 0 and 1 inclusive
     */
    export function NORM_S_INV(probability: number): number;
    /**
     * @summary Returns the Pearson product moment correlation coefficient, r
     * @param array1 is a set of independent values
     * @param array2 is a set of dependent values
     */
    export function PEARSON(array1: IRange, array2: IRange): number;
    /**
     * @hidden Unimplemented
     * @name PERCENTILE.EXC
     * @summary Returns the k-th percentile of values in a range, where k is in the range 0..1, exclusive
     * @param array is the array or range of data that defines relative standing
     * @param k is the percentile value that is between 0 through 1, inclusive
     */
    export function PERCENTILE_EXC(array: IRange, k: number): IRange;
    /**
     * @hidden Unimplemented
     * @name PERCENTILE.INC
     * @summary Returns the k-th percentile of values in a range, where k is in the range 0..1, inclusive
     * @param array is the array or range of data that defines relative standing
     * @param k is the percentile value that is between 0 through 1, inclusive
     */
    export function PERCENTILE_INC(array: IRange, k: number): IRange;
    /**
     * @hidden Unimplemented
     * @name PERCENTRANK.EXC
     * @summary Returns the rank of a value in a data set as a percentage (0..1, exclusive) of the data set
     * @param array is the array or range of data with numeric values that defines relative standing
     * @param x is the value for which you want to know the rank
     * @param significance is an optional value that identifies the number of significant digits for the returned percentage
     */
    export function PERCENTRANK_EXC(array: IRange, x: number, significance?: number): number;
    /**
     * @hidden Unimplemented
     * @name PERCENTRANK.INC
     * @summary Returns the rank of a value in a data set as a percentage (0..1, inclusive) of the data set
     * @param array is the array or range of data with numeric values that defines relative standing
     * @param x is the value for which you want to know the rank
     * @param significance is an optional value that identifies the number of significant digits for the returned percentage
     */
    export function PERCENTRANK_INC(array: IRange, x: number, significance?: number): number;
    /**
     * @summary Returns the value of the density function for a standard normal distribution
     * @param x is the number for which you want the density of the standard normal distribution
     */
    export function PHI(x: number): number;
    /**
     * @name POISSON.DIST
     * @summary Returns the Poisson distribution
     * @param x is the number of events
     * @param mean is the expected numeric value, a positive number
     * @param cumulative is a logical value: for the cumulative Poisson probability, use TRUE; for the Poisson probability mass function, use FALSE
     */
    export function POISSON_DIST(x: number, mean: number, cumulative: boolean): number;
    /**
     * @summary Returns the probability that values in a range are between two limits or equal to a lower limit
     * @param xRange is the range of numeric values of x with which there are associated probabilities
     * @param probRange is the set of probabilities associated with values in X_range, values between 0 and 1 and excluding 0
     * @param lowerLimit is the lower bound on the value for which you want a probability
     * @param upperLimit is the optional upper bound on the value. If omitted, PROB returns the probability that X_range values are equal to Lower_limit
     */
    export function PROB(xRange: IRange, probRange: IRange, lowerLimit: number, upperLimit?: number): number;
    /**
     * @hidden Unimplemented
     * @name QUARTILE.EXC
     * @summary Returns the quartile of a data set, based on percentile values from 0..1, exclusive
     * @param array is the array or cell range of numeric values for which you want the quartile value
     * @param quart is a number: minimum value = 0; 1st quartile = 1; median value = 2; 3rd quartile = 3; maximum value = 4
     */
    export function QUARTILE_EXC(array: IRange, quart: number): number;
    /**
     * @hidden Unimplemented
     * @name QUARTILE.INC
     * @summary Returns the quartile of a data set, based on percentile values from 0..1, inclusive
     * @param array is the array or cell range of numeric values for which you want the quartile value
     * @param quart is a number: minimum value = 0; 1st quartile = 1; median value = 2; 3rd quartile = 3; maximum value = 4
     */
    export function QUARTILE_INC(array: IRange, quart: number): number;
    /**
     * @hidden Unimplemented
     * @name RANK.AVG
     * @summary Returns the rank of a number in a list of numbers: its size relative to other values in the list; if more than one value has the same rank, the average rank is returned
     * @param number is the number for which you want to find the rank
     * @param ref is an array of, or a reference to, a list of numbers. Nonnumeric values are ignored
     * @param order is a number: rank in the list sorted descending = 0; rank in the list sorted ascending = any nonzero value
     */
    export function RANK_AVG(number: number, ref: IRange, order?: number): number;
    /**
     * @hidden Unimplemented
     * @name RANK.EQ
     * @summary Returns the rank of a number in a list of numbers: its size relative to other values in the list; if more than one value has the same rank, the top rank of that set of values is returned
     * @param number is the number for which you want to find the rank
     * @param ref is an array of, or a reference to, a list of numbers. Nonnumeric values are ignored
     * @param order is a number: rank in the list sorted descending = 0; rank in the list sorted ascending = any nonzero value
     */
    export function RANK_EQ(number: number, ref: IRange, order?: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the square of the Pearson product moment correlation coefficient through the given data points
     * @param knownYs is an array or range of data points and can be numbers or names, arrays, or references that contain numbers
     * @param knownXs is an array or range of data points and can be numbers or names, arrays, or references that contain numbers
     */
    export function RSQ(knownYs: any[], knownXs: any[]): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the skewness of a distribution: a characterization of the degree of asymmetry of a distribution around its mean
     * @param number number1,number2,... are 1 to 255 numbers or names, arrays, or references that contain numbers for which you want the skewness
     */
    export function SKEW(...number: IRange[]): number;
    /**
     * @hidden Unimplemented
     * @name SKEW.P
     * @summary Returns the skewness of a distribution based on a population: a characterization of the degree of asymmetry of a distribution around its mean
     * @param number number1,number2,... are 1 to 254 numbers or names, arrays, or references that contain numbers for which you want the population skewness
     */
    export function SKEW_P(...number: IRange[]): number;
    /**
     * @summary Returns the slope of the linear regression line through the given data points
     * @param knownYs is an array or cell range of numeric dependent data points and can be numbers or names, arrays, or references that contain numbers
     * @param knownXs iis the set of independent data points and can be numbers or names, arrays, or references that contain numbers
     */
    export function SLOPE(knownYs: IRange, knownXs: IRange): number;
    /**
     * @summary Returns a normalized value from a distribution characterized by a mean and standard deviation
     * @param x is the value you want to normalize
     * @param mean is the arithmetic mean of the distribution
     * @param standardDev is the standard deviation of the distribution, a positive number
     */
    export function STANDARDIZE(x: number, mean: number, standardDev: number): number;
    /**
     * @hidden Unimplemented
     * @name STDEV.P
     * @summary Calculates standard deviation based on the entire population given as arguments (ignores logical values and text)
     * @param number number1,number2,... are 1 to 255 numbers corresponding to a population and can be numbers or references that contain numbers
     */
    export function STDEV_P(...number: IRange<number>[]): number;
    /**
     * @name STDEV.S
     * @summary Estimates standard deviation based on a sample (ignores logical values and text in the sample)
     * @param number number1,number2,... are 1 to 255 numbers corresponding to a sample of a population and can be numbers or references that contain numbers
     */
    export function STDEV_S(...number: IRange<number>[]): number;
    /**
     * @hidden Unimplemented
     * @summary Estimates standard deviation based on a sample, including logical values and text. Text and the logical value FALSE have the value 0; the logical value TRUE has the value 1
     * @param value value1,value2,... are 1 to 255 values corresponding to a sample of a population and can be values or names or references to values
     */
    export function STDEVA(...value: IRange[]): number;
    /**
     * @summary Calculates standard deviation based on an entire population, including logical values and text. Text and the logical value FALSE have the value 0; the logical value TRUE has the value 1
     * @param value value1,value2,... are 1 to 255 values corresponding to a population and can be values, names, arrays, or references that contain values
     * @hidden Unimplemented
     */
    export function STDEVPA(...value: IRange[]): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the standard error of the predicted y-value for each x in a regression
     * @param knownYs is an array or range of dependent data points and can be numbers or names, arrays, or references that contain numbers
     * @param knownXs is an array or range of independent data points and can be numbers or names, arrays, or references that contain numbers
     */
    export function STEYX(knownYs: any[], knownXs: any[]): number;
    /**
     * @name T.DIST
     * @summary Returns the left-tailed Student's t-distribution
     * @param x is the numeric value at which to evaluate the distribution
     * @param degFreedom is an integer indicating the number of degrees of freedom that characterize the distribution
     * @param cumulative is a logical value: for the cumulative distribution function, use TRUE; for the probability density function, use FALSE
     */
    export function T_DIST(x: number, degFreedom: number, cumulative: boolean): number;
    /**
     * @name T.DIST.2T
     * @summary Returns the two-tailed Student's t-distribution
     * @param x is the numeric value at which to evaluate the distribution
     * @param degFreedom is an integer indicating the number of degrees of freedom that characterize the distribution
     */
    export function T_DIST_2T(x: number, degFreedom: number): number;
    /**
     * @name T.DIST.RT
     * @summary Returns the right-tailed Student's t-distribution
     * @param x is the numeric value at which to evaluate the distribution
     * @param degFreedom is an integer indicating the number of degrees of freedom that characterize the distribution
     */
    export function T_DIST_RT(x: number, degFreedom: number): number;
    /**
     * @name T.INV
     * @summary Returns the left-tailed inverse of the Student's t-distribution
     * @param probability is the probability associated with the two-tailed Student's t-distribution, a number between 0 and 1 inclusive
     * @param degFreedom is a positive integer indicating the number of degrees of freedom to characterize the distribution
     */
    export function T_INV(probability: number, degFreedom: number): number;
    /**
     * @name T.INV.2T
     * @summary Returns the two-tailed inverse of the Student's t-distribution
     * @param probability is the probability associated with the two-tailed Student's t-distribution, a number between 0 and 1 inclusive
     * @param degFreedom is a positive integer indicating the number of degrees of freedom to characterize the distribution
     */
    export function T_INV_2T(probability: number, degFreedom: number): number;
    /**
     * @hidden Unimplemented
     * @name T.TEST
     * @summary Returns the probability associated with a Student's t-Test
     * @param array1 is the first data set
     * @param array2 is the second data set
     * @param tails specifies the number of distribution tails to return: one-tailed distribution = 1; two-tailed distribution = 2
     * @param type is the kind of t-test: paired = 1, two-sample equal variance (homoscedastic) = 2, two-sample unequal variance = 3
     */
    export function T_TEST(array1: IRange, array2: IRange, tails: number, // 1 or 2
    type: number): number;
    /**
     * @hidden Unimplemented
     * @summary Returns numbers in a linear trend matching known data points, using the least squares method
     * @param knownYs is a range or array of y-values you already know in the relationship y = mx + b
     * @param knownXs is an optional range or array of x-values that you know in the relationship y = mx + b, an array the same size as Known_y's
     * @param newXs is a range or array of new x-values for which you want TREND to return corresponding y-values
     * @param consts is a logical value: the constant b is calculated normally if Const = TRUE; b is set equal to 0 if Const = FALSE
     */
    export function TREND(knownYs: any[], knownXs?: any[], newXs?: any[], consts?: boolean): number[];
    /**
     * @hidden Unimplemented
     * @summary Returns the mean of the interior portion of a set of data values
     * @param array is the range or array of values to trim and average
     * @param percent is the fractional number of data points to exclude from the top and bottom of the data set
     */
    export function TRIMMEAN(array: IRange, percent: IRange): number;
    /**
     * @name VAR.P
     * @summary Calculates variance based on the entire population (ignores logical values and text in the population)
     * @param number number1,number2,... are 1 to 255 numeric arguments corresponding to a population
     */
    export function VAR_P(...number: IRange<number>[]): number;
    /**
     * @name VAR.S
     * @summary Estimates variance based on a sample (ignores logical values and text in the sample)
     * @param number number1,number2,... are 1 to 255 numeric arguments corresponding to a sample of a population
     */
    export function VAR_S(...number: IRange<number>[]): number;
    /**
     * @summary Estimates variance based on a sample, including logical values and text. Text and the logical value FALSE have the value 0; the logical value TRUE has the value 1
     * @param value value1,value2,... are 1 to 255 value arguments corresponding to a sample of a population
     */
    export function VARA(...value: IRange[]): number;
    /**
     * @summary Calculates variance based on the entire population, including logical values and text. Text and the logical value FALSE have the value 0; the logical value TRUE has the value 1
     * @param value value1,value2,... are 1 to 255 value arguments corresponding to a population
     */
    export function VARPA(...value: IRange[]): number;
    /**
     * @name WEIBULL.DIST
     * @summary Returns the Weibull distribution
     * @param x is the value at which to evaluate the function, a nonnegative number
     * @param alpha is a parameter to the distribution, a positive number
     * @param beta is a parameter to the distribution, a positive number
     * @param cumulative is a logical value: for the cumulative distribution function, use TRUE; for the probability mass function, use FALSE
     */
    export function WEIBULL_DIST(x: number, alpha: number, beta: number, cumulative: boolean): number;
    /**
     * @name Z.TEST
     * @summary Returns the one-tailed P-value of a z-test
     * @param array is the array or range of data against which to test X
     * @param x is the value to test
     * @param sigma is the population (known) standard deviation. If omitted, the sample standard deviation is used
     */
    export function Z_TEST(array: IRange, x: number, sigma?: number): number;
}
declare module ".generated/formulas/impl/testing/Testing" {
    import { Scalar, IRange } from '@sheetxl/primitives';
    /**
     * @hidden Testing
     * @summary Returns the input value after a delay.
     * @param time the delay time in milliseconds. Default is 1000ms (1 second).
     * @param input returns the input.
     * @param label optional label for the delay function.
     */
    export function DELAY(time: number, input: Scalar, label?: string): Promise<Scalar>;
    /**
     * @hidden Testing
     * @summary Starts waiting for event
     * @param type the type of message.
     * @param input an optional dependency.
     *
     * @remarks
     * To use:
     *  '=WAIT("test", A1)'
     *   [globalThis].debugEventTarget.dispatchEvent(new CustomEvent(type, payload));
     *   (e.g. globalThis.debugEventTarget.dispatchEvent(new CustomEvent('test', { detail: "ping" }));
     */
    export function WAIT(type: string, input?: IRange): Promise<string>;
}
declare module ".generated/formulas/impl/text/Baht" {
    /**
     * @summary Converts a number to baht (Thai) text
     * @param number is the number to convert
     */
    export function BAHTTEXT(number: number): string;
}
declare module ".generated/formulas/impl/text/Text" {
    import { Scalar, IRange, IReferenceRange } from '@sheetxl/primitives';
    /**
     * @hidden DBCS
     * @summary Converts a string to full-width characters to half-width. Uses the double-byte character set (DBCS).
     * @param text is a text or a reference to a cell containing text
     */
    export function ASC(text: string): string;
    /**
     * @summary Returns a text representation of an array
     * @param array the array to represent as text
     * @param format 0 for relaxed format, 1 for strict format
     */
    export function ARRAYTOTEXT(array: IRange, format?: number): string;
    /**
     * @summary Returns the character specified by the code number from the character set for your computer
     * @param number is a number between 1 and 255 specifying which character you want
     */
    export function CHAR(number: number): string;
    /**
     * @summary Removes all nonprintable characters from text
     * @param text is the text you want to clean
     */
    export function CLEAN(text: string): string;
    /**
     * @summary Returns the Unicode value of the first character in a text string
     * @param text is the text string whose Unicode value you want
     */
    export function CODE(text: string): number;
    /**
     * @summary Concatenates a list or range of text strings
     * @param text text1,text2,... are 1 to 252 text strings or ranges to be joined
     */
    export function CONCAT(...text: IRange[]): string;
    /**
     * @summary Joins several text strings into one text string
     * @category Compatibility
     * @param text text1, text2,... are 1 to 252 text strings or ranges to be joined
     *
     * @remarks
     * Similar to CONCAT, but only uses the first argument in a range.
     */
    export function CONCATENATE(...text: IRange[]): string;
    /**
     * @hidden Unimplemented
     * @summary Detects the language of a given text.
     * @param text is the text to detect the language of
     */
    export function DETECTLANGUAGE(text: string): string;
    /**
     * @hidden DBCS
     * @summary Changes half-width characters to full-width characters. Uses the double-byte character set (DBCS).
     * @param text is a text or a reference to a cell containing text
     */
    export function DBCS(text: string): string;
    /**
     * @summary Converts a number to text in currency format
     * @param number is the number to convert
     * @param decimals is the number of digits to the right of the decimal point
     */
    export function DOLLAR(number: number, decimals?: number): string;
    /**
     * @summary Checks whether two text strings are exactly the same, and returns TRUE or FALSE. EXACT is case-sensitive
     * @param text1 is the first text string
     * @param text2 is the second text string
     */
    export function EXACT(text1: string, text2: string): boolean;
    /**
     * @summary Returns the starting position of one text string within another text string. FIND is case-sensitive
     * @param findText Returns the starting position of one text string within another text string. FIND is case-sensitive
     * @param withinText is the text you want to search
     * @param startNum specifies the character at which to start the search. The first character in Within_text is character number 1
     */
    export function FIND(findText: string, withinText: string, startNum?: number): number;
    /**
     * @hidden DBCS
     * @summary Finds the starting position of one text string with another text string. FINDB is case-sensitive. Use with double-byte characters.
     * @param findText is the text you want to find
     * @param withinText is the text you want to search
     * @param startNum is the position in within_text to start searching
     */
    export function FINDB(findText: string, withinText: string, startNum?: number): number;
    /**
     * @summary Rounds a number to the specified number of decimals and returns the result as text with or without commas
     * @param number is the number you want to round and convert to text
     * @param decimals is the number of digits to the right of the decimal point
     * @param noCommas is a logical value: do not display commas in the returned text = TRUE; do display commas in the returned text = FALSE
     */
    export function FIXED(number: number, decimals?: number, noCommas?: boolean): string;
    /**
     * @summary Returns the specified number of characters from the start of a text string
     * @param text is the text string from which you want to extract characters
     * @param numChars specifies how many characters you want LEFT to extract
     */
    export function LEFT(text: string, numChars?: number): string;
    /**
     * @hidden DBCS
     * @summary Returns the leftmost num_bytes characters from text. Uses double-byte characters.
     * @param text is the text string from which you want to extract characters
     * @param numBytes is the number of bytes to extract
     */
    export function LEFTB(text: string, numBytes?: number): string;
    /**
     * @summary Returns the number of characters in a text string
     * @param text is the text whose length you want to find. Spaces count as characters
     */
    export function LEN(text: string): number;
    /**
     * @summary Returns the number of bytes in a text string. Uses double-byte characters.
     * @param text is the text string from which you want to extract characters
     */
    export function LENB(text: string): number;
    /**
     * @summary Converts all letters in a text string to lowercase
     * @param text is the text you want to convert to lowercase. Characters in Text that are not letters are not changed
     */
    export function LOWER(text: string): string;
    /**
     * @summary Returns the characters from the middle of a text string, given a starting position and length
     * @param text is the text string from which you want to extract characters
     * @param startNum is the position of the first character you want to extract
     * @param numChars specifies how many characters to return from Text
     */
    export function MID(text: string, startNum: number, numChars: number): string;
    /**
     * @hidden DBCS
     * @summary Returns characters from the middle of a text string. Uses double-byte characters.
     * @param text is the text string from which you want to extract characters
     * @param startNum is the position of the first character you want to extract
     * @param numBytes is the number of bytes to extract
     */
    export function MIDB(text: string, startNum: number, numBytes: number): string;
    /**
     * @summary Converts text to number in a locale-independent manner
     * @param text is the text string you want to convert
     * @param decimalSeparator is the character that separates the integer part from the decimal part of the number
     * @param groupSeparator is the character that separates groups of thousands
     */
    export function NUMBERVALUE(text: string, decimalSeparator?: string, groupSeparator?: string): number;
    /**
     * @hidden Unimplemented
     * @summary Returns the percentage of a subset of a given data set
     * @param dataSubset is the subset
     * @param dataAll is the data set
     */
    export function PERCENTOF(dataSubset: IRange, dataAll: IRange): IRange;
    /**
     * @hidden Unimplemented
     * @summary Returns the phonetic spelling of a text string
     * @param reference Text string or a reference to a single cell or a range of cells that contain a furigana text string
     */
    export function PHONETIC(reference: IReferenceRange): any;
    /**
     * @summary Converts the first letter of each word in a text string to uppercase
     * @param text is the text string you want to convert
     */
    export function PROPER(text: string): string;
    /**
     * @hidden Unimplemented
     * @summary Extracts substrings of 'text' based on the provided REGEX 'pattern'
     * @param text is the text string from which you want to extract characters
     * @param pattern The regular expression to be applied
     * @param returnMode Specify which matches to return
     * @param caseSensitivity Whether the match is case sensitive
     */
    export function REGEXEXTRACT(text: string, pattern: string, returnMode?: number, caseSensitivity?: boolean): string[];
    /**
     * @hidden Unimplemented
     * @summary Returns 'text', with 'replacement' in place of matches with 'pattern'
     * @param text is the text string from which you want to extract characters
     * @param pattern The regular expression to be applied
     * @param replacement The replacement string
     * @param occurrence The occurrence of the match to replace
     * @param caseSensitivity Whether the match is case sensitive
     */
    export function REGEXREPLACE(text: string, pattern: string, replacement: string, occurrence?: number, caseSensitivity?: boolean): string[];
    /**
     * @hidden Unimplemented
     * @summary Checks whether the input matches the pattern, and returns TRUE or FALSE
     * @param text is the text string to be checked
     * @param pattern is the regular expression to be applied
     * @param caseSensitivity Whether the match is case sensitive
     */
    export function REGEXTEST(text: string, pattern: string, caseSensitivity?: boolean): boolean;
    /**
     * @summary Replaces part of a text string with a different text string
     * @param oldText is the text string to be changed
     * @param startNum is the position of the first character you want to replace
     * @param numChars is the number of characters to replace
     * @param newText is the text string that will replace old_text
     */
    export function REPLACE(oldText: string, startNum: number, numChars: number, newText: string): string;
    /**
     * @hidden DBCS
     * @summary Replaces part of a text string with a different text string using the number of bytes. Uses the double-byte character set (DBCS).
     * @param oldText is the text string to be changed
     * @param startNum is the position of the first character you want to replace
     * @param numBytes is the number of bytes to replace
     * @param newText is the text string that will replace old_text
     */
    export function REPLACEB(oldText: string, startNum: number, numBytes: number, newText: string): string;
    /**
     * @summary Repeats text a given number of times
     * @param text is the text you want to repeat
     * @param numberTimes is the number of times you want to repeat text
     */
    export function REPT(text: string, numberTimes: number): string;
    /**
     * @summary Returns the specified number of characters from the end of a text string
     * @param text is the text string that contains the characters you want to extract
     * @param numChars specifies how many characters you want to extract
     */
    export function RIGHT(text: string, numChars?: number): string;
    /**
     * @summary Returns the rightmost num_bytes characters from text. Uses double-byte characters.
     * @param text is the text string from which you want to extract characters
     * @param numBytes is the number of bytes to extract
     */
    export function RIGHTB(text: string, numBytes?: number): string;
    /**
     * @summary Returns the number of the character at which a specific character or text string is first found, reading left to right (not case-sensitive)
     * @param findText Returns the number of the character at which a specific character or text string is first found, reading left to right (not case-sensitive)
     * @param withinText is the text in which you want to search for Find_text
     * @param startNum is the character number in Within_text, counting from the left, at which you want to start searching
     */
    export function SEARCH(findText: string, withinText: string, startNum?: number): number;
    /**
     * @hidden DBCS
     * @summary Returns the number of the character at which a specific character or text string is first found, reading left to right (not case-sensitive). Uses the double-byte character set (DBCS).
     * @param findText Returns the number of the character at which a specific character or text string is first found, reading left to right (not case-sensitive)
     * @param withinText is the text in which you want to search for Find_text
     * @param startBytes is the character number in Within_text, counting from the left, at which you want to start searching
     */
    export function SEARCHB(findText: string, withinText: string, startBytes?: number): number;
    /**
     * @summary Replaces existing text with new text in a text string
     * @param text is the text or the reference to a cell containing text in which you want to substitute characters
     * @param oldText is the existing text you want to replace. If the case of Old_text does not match the case of text, SUBSTITUTE will not replace the text
     * @param newText is the text you want to replace Old_text with
     * @param instanceNum specifies which occurrence of Old_text you want to replace. If omitted, every instance of Old_text is replaced
     */
    export function SUBSTITUTE(text: string, oldText: string, newText: string, instanceNum?: number): string;
    /**
     * @summary Checks whether a value is text, and returns the text if it is, or returns double quotes (empty text) if it is not
     * @param value is the value to test
     */
    export function T(value: Scalar): string;
    /**
     * @summary Converts a value to text in a specific number format
     * @param value is a number, a formula that evaluates to a numeric value, or a reference to a cell containing a numeric value
     * @param formatText is a text string that defines the number format to use
     */
    export function TEXT(value: Scalar, formatText: string): string;
    /**
     * @summary Returns text that's after delimiting characters.
     * @param text The text you want to search for the delimiter.
     * @param delimiter The character or string to use as a delimiter.
     * @param instanceNum The desired occurrence of delimiter. The default is 1. A negative number searches from the end.
     * @param matchMode Searches the text for a delimiter match. By default, a case-sensitive match is done.
     * @param matchEnd Whether to match the delimiter against the end of text. By default, they're not matched.
     * @param ifNotFound Returned if no match is found. By default, #N/A is returned.
     */
    export function TEXTAFTER(text: string, delimiter: string, instanceNum?: number, matchMode?: number, matchEnd?: number, ifNotFound?: string): any;
    /**
     * @summary Concatenates a list or range of text strings using a delimiter
     * @param delimiter Character or string to insert between each text item
     * @param ignoreEmpty if TRUE(default), ignores empty cells
     * @param text text1,text2,... are 1 to 252 text strings or ranges to be joined
     */
    export function TEXTJOIN(delimiter: string, ignoreEmpty: boolean, ...text: IRange[]): string;
    /**
     * @summary Splits text into rows or columns using delimiters.
     * @param text The text to split
     * @param colDelimiter The column delimiter(s) - can be string or array of strings
     * @param rowDelimiter The row delimiter(s), null/undefined means no row splitting
     * @param ignoreEmpty Whether to ignore empty values (defaults to `false`)
     * @param matchMode Whether to use case-sensitive (0) or case-insensitive (1) match (defaults to `0`)
     * @param padWith Value to use for padding if matrix is uneven (defaults to `#N/A`)
     */
    export function TEXTSPLIT(text: string, colDelimiter: string[], rowDelimiter?: string[], ignoreEmpty?: boolean, matchMode?: number, padWith?: string): any;
    /**
     * @summary Returns text that's before delimiting characters.
     * @param text The text you want to search for the delimiter.
     * @param delimiter The character or string to use as a delimiter.
     * @param instanceNum The desired occurrence of delimiter. The default is 1. A negative number searches from the end.
     * @param matchMode Whether to use case-sensitive (0) or case-insensitive (1) match (defaults to `0`)
     * @param matchEnd Whether to match the delimiter against the end of text. By default, they're not matched.
     * @param ifNotFound Returned if no match is found. By default, #N/A is returned.
     */
    export function TEXTBEFORE(text: string, delimiter: string, instanceNum?: number, matchMode?: number, matchEnd?: number, ifNotFound?: string): any;
    /**
     * @hidden Unimplemented
     * @summary Translate a text string from one language to another using the Microsoft Translator service.
     * @param text The text to translate.
     * @param sourceLanguage Specifiy the source language your text is currently in. Expressed as a two-letter language code.
     * @param targetLanguage Specifiy the source language you want your text to be translated to. Expressed as a two-letter language code.
     */
    export function TRANSLATE(text: string, sourceLanguage: string, targetLanguage: string): string;
    /**
     * @summary Removes all spaces from text except for single spaces between words.
     * @param text The text from which you want to remove extra spaces.
     */
    export function TRIM(text: string): string;
    /**
     * @summary Returns the Unicode character referenced by the given numeric value
     * @param number is the Unicode number representing a character
     */
    export function UNICHAR(number: number): string;
    /**
     * @summary Returns the number (code point) corresponding to the first character of the text
     * @param text is the character that you want the Unicode value of
     */
    export function UNICODE(text: string): number;
    /**
     * @summary Converts a text string to all uppercase letters
     * @param text is the text you want converted to uppercase, a reference or a text string
     */
    export function UPPER(text: string): string;
    /**
     * @summary Converts a text string that represents a number to a number
     * @param text is the text enclosed in quotation marks or a reference to a cell containing the text you want to convert
     */
    export function VALUE(text: string): number;
    /**
     * @summary Returns a text representation of a value
     * @param value the value to represent as text
     * @param format the format of the text
     */
    export function VALUETOTEXT(value: Scalar, format?: number): string;
}
declare module ".generated/formulas/impl/web/FilterXML" {
    /**
     * @summary Returns specific data from XML content using the specified XPath.
     * @param xml is a string in valid XML format.
     * @param xpath is a string in standard XPath format.
     */
    export function FILTERXML(xml: string, xpath: string): Promise<string>;
}
declare module ".generated/formulas/impl/web/Web" {
    /**
     * @summary Returns a URL-encoded string
     * @param text is a string to be URL encoded
     */
    export function ENCODEURL(text: string): string;
    /**
     * @summary Retrieves data from a web service.
     * @param url is the URL of the web service
     */
    export function WEBSERVICE(url: string): Promise<string>;
}
declare module ".generated/formulas/decl/cube/Cube.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/database/Database.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/dateTime/Date.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/engineering/Bessel.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/engineering/Bitwise.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/engineering/Convert.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/engineering/Engineering.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/engineering/Error.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/engineering/Imaginary.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/financial/Financial.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/information/Information.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/logical/Logical.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/lookupReference/Reference.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/mathTrig/Math.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/mathTrig/Trig.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/statistical/Distribution.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/statistical/Statistical.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/testing/Testing.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/text/Baht.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/text/Text.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/web/FilterXML.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/decl/web/Web.decl" {
    import { MinifiedDeclarations } from '@sheetxl/scripting';
    const declarations: MinifiedDeclarations;
    export default declarations;
}
declare module ".generated/formulas/desc/cube/Cube.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/database/Database.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/dateTime/Date.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/engineering/Bessel.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/engineering/Bitwise.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/engineering/Convert.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/engineering/Engineering.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/engineering/Error.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/engineering/Imaginary.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/financial/Financial.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/information/Information.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/logical/Logical.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/lookupReference/Reference.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/mathTrig/Math.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/mathTrig/Trig.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/statistical/Distribution.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/statistical/Statistical.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/testing/Testing.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/text/Baht.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/text/Text.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/web/FilterXML.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/desc/web/Web.desc" {
    import { MinifiedDescriptors } from '@sheetxl/scripting';
    const descriptors: MinifiedDescriptors;
    export default descriptors;
}
declare module ".generated/formulas/index" {
    import { IFunction, IFormulaContext } from '@sheetxl/primitives';
    import { FunctionBinder } from '@sheetxl/scripting';
    /**
     * Returns a map of functions
     */
    export default function initialize(getContext: () => IFormulaContext, bindFn: FunctionBinder): Map<string, IFunction>;
}
declare module "calculation/builtIns/initializeBuiltIns" {
    import type { IFunction, IFormulaContext } from '@sheetxl/primitives';
    import type { Implementations, MinifiedDeclaration, DynamicDescriptors } from '@sheetxl/scripting';
    /**
     * Calls the auto generated binding function to bind all built-in functions.
     */
    export function initializeBuiltIns(getContext: () => IFormulaContext): Map<string, IFunction>;
    /**
     * load and bind functions to the mapFunctions
     *
     * @param mapFunctions the map to bind functions to
     * @param getContext a function to get the current formula context
     * @param implementations the function module containing the actual implementations
     * @param declarations the built-in declarations
     * @param getDynamicDescriptors an optional function to get the dynamic descriptor module
     * @param defaultCategory the default category to use if not specified in the declaration
     */
    export const bindDeclarations: (mapFunctions: Map<string, IFunction>, getContext: () => IFormulaContext, implementations: Implementations, // TODO make this dynamic
    declarations: MinifiedDeclaration, // TODO make this dynamic
    getDynamicDescriptors?: DynamicDescriptors, defaultCategory?: string) => void;
}
declare module "calculation/builtIns/index" {
    export { initializeBuiltIns } from "calculation/builtIns/initializeBuiltIns";
}
declare module "calculation/graph/CalculationContext" {
    import { Scalar, ScalarType, IReferenceRange, IRange, IFunction, IFormulaContext, IRuntime } from '@sheetxl/primitives';
    import { Tuple } from "collections/index";
    import { ICalculation } from "calculation/ICalculation";
    import { ICalcGraph } from "calculation/graph/ICalcGraph";
    import { ICalcGraphScope } from "calculation/graph/_Types";
    export class CalculationContext implements IFormulaContext {
        protected _calcScope: ICalcGraphScope;
        protected _instanceScope: any;
        protected _options: ICalculation.ConstructorOptions;
        protected _runtime: IRuntime;
        protected _builtInFunctions: ReadonlyMap<string, IFunction>;
        protected _getFunction: (name: string) => IFunction;
        protected _isColumn: boolean;
        constructor(options?: ICalculation.ConstructorOptions, isColumn?: boolean);
        /** @hidden */
        _setInstanceScope(instanceScope: any): void;
        /** @hidden */
        _initialize(): Promise<{
            builtInFunctions: ReadonlyMap<string, IFunction>;
            calcScope?: ICalcGraphScope;
        }>;
        /**
         * Returns a builtin map of built-in functions.
         */
        getBuiltInFunctions(): ReadonlyMap<string, IFunction>;
        /** @inheritdoc IFormulaContext.getFunction */
        getFunction(name: string): IFunction;
        /** @inheritdoc IFormulaContext.getNumberFormat */
        getNumberFormat(formatText: string, value: Scalar): string;
        /** @inheritdoc IFormulaContext.getEntireCoords */
        getEntireCoords(): IRange.Coords;
        /** @inheritdoc IFormulaContext.getFormulaAt */
        getFormulaAt(row: number, column: number): string | null;
        /** @inheritdoc IFormulaContext.markVolatile */
        markVolatile(): void;
        /** @inheritdoc IFormulaContext.formatResults */
        formatResults(numFmt: string): void;
        /** @inheritdoc IFormulaContext.getSheetIndex */
        getSheetIndex(sheetName?: string): number;
        /** @inheritdoc IFormulaContext.getSheetCount */
        getSheetCount(): number;
        /** @inheritdoc IFormulaContext.isValidDate */
        isValidDate(value: any): boolean;
        /** @inheritdoc IFormulaContext.fromOADate */
        fromOADate(oaDate: number): Date;
        /** @inheritdoc IFormulaContext.toOADate */
        toOADate(date: Date): number;
        protected _fromTuples(boundedTuples: Tuple.BoundedTuples<Scalar>, type?: ScalarType, isLiteral?: boolean): IRange;
        /** @inheritdoc IFormulaContext.getValueAt */
        getValueAt(rowIndex: number, colIndex: number): Scalar | null;
        /** @inheritdoc IFormulaContext.getRange */
        getSpillAt(rowIndex: number, colIndex: number): IReferenceRange | null;
        /** @inheritdoc IFormulaContext.getRange */
        getRange(value: Scalar | Scalar[][], isLiteral?: boolean): IRange;
        /** @inheritdoc IFormulaContext.getPosition */
        getPosition(): IRange.CellCoords;
        /** @inheritdoc IFormulaContext.getReference */
        getReference(coords: IRange.Coords | string, r1c1?: boolean): IReferenceRange;
        /** @inheritdoc IFormulaContext.getAddress */
        getAddress(coords?: Readonly<IRange.FixableCoords | IRange.FixableCellCoords>, r1c1?: boolean): string;
        /** @inheritdoc IFormulaContext.parseAsDateTime */
        parseAsDateTime(text: string, requireDate?: boolean): number | null;
        /** @inheritdoc IFormulaContext.getRuntime */
        getRuntime(): IRuntime;
        get [Symbol.toStringTag](): string;
        toString(): string;
    }
    export const defaultCreateScope: () => ICalcGraphScope;
    export const defaultCalcOptions: Partial<ICalcGraph.ConstructorOptions>;
}
declare module "calculation/_CalculationMessages" {
    export const ERROR_NOT_STARTED = "The calculation engine is not started. Call start() first.";
    export const ERROR_INITIALIZING = "The calculation engine is initializing. Please wait until it is ready.";
}
declare module "calculation/Calculation" {
    import { IRuntime } from '@sheetxl/primitives';
    import { ListenerEmitter } from "listener/ListenerEmitter";
    import { IModel, AbstractModel } from "model/index";
    import { IFunctionCollection } from "script/index";
    import { type ICalcGraph } from "calculation/graph/index";
    import type { IFormulaParser } from "calculation/formula/index";
    import { ICalcGraphScope } from "calculation/graph/_Types";
    import { CalculationContext } from "calculation/graph/CalculationContext";
    import { ICalculation } from "calculation/ICalculation";
    interface State extends AbstractModel.State {
    }
    interface CommitView extends AbstractModel.CommitView {
    }
    /**
     * Implementation for {@link ICalculation}.
     */
    export class Calculation extends AbstractModel<State, ICalculation.JSON, CommitView, ICalculation.IListeners> implements ICalculation {
        protected _context: CalculationContext;
        protected _scope: ICalcGraphScope;
        protected _graphsCalcing: Map<string, ICalcGraph>;
        protected _graphsAll: Map<string, ICalcGraph>;
        protected _functions: IFunctionCollection;
        protected _runtime: IRuntime;
        protected _formulaParser: IFormulaParser;
        protected _emitter: ListenerEmitter<Calculation, ICalculation.IListeners>;
        protected _status: ICalculation.Status;
        protected _statusTransition: Promise<void> | null;
        constructor(options?: Calculation.ConstructorOptions);
        protected _getContext(): CalculationContext;
        protected _getScope(): ICalcGraphScope;
        protected _getCalcingGraphs(): Map<string, ICalcGraph>;
        protected _getAllGraphs(): Map<string, ICalcGraph>;
        /** @inheritdoc ICalculation.start */
        start(): Promise<void>;
        protected _createGraph(options: ICalcGraph.ConstructorOptions): ICalcGraph;
        /** @inheritdoc ICalculation.stop */
        stop(): Promise<void>;
        /** @inheritdoc ICalculation.getStatus */
        getStatus(): ICalculation.Status;
        /** @inheritdoc ICalculation.ready */
        ready(options?: ICalculation.CalculateOptions): Promise<void>;
        /** @inheritdoc ICalculation.getFunctions */
        getFunctions(): IFunctionCollection;
        /** @inheritdoc IFormulaContext.getRuntime */
        getRuntime(): IRuntime;
        protected _checkReady(): void;
        protected _statusMessage(): string;
        get [Symbol.toStringTag](): string;
        toString(): string;
    }
    /**
     * Interfaces for creating `Calculation` items.
     *
     * @see
     * ### **Interface**
     *
     * {@link Calculation}
     */
    export namespace Calculation {
        /**
         * Options for creating an ICalculation.
         */
        interface ConstructorOptions extends ICalculation.ConstructorOptions, IModel.ConstructorOptions<ICalculation.JSON> {
        }
    }
}
declare module "calculation/index" {
    export * from "calculation/ICalculation";
    export * from "calculation/Calculation";
}
declare module "cell/ICellProtection" {
    /**
     * Additional cell protection properties.
     *
     */
    export interface ICellProtection {
        /**
         * This is specified in ooxml but not sure what behavior it has.
         * @defaultValue true
         */
        isEditAllowed(): boolean;
        /**
         * If the formula will be hidden when the worksheet is protected.
         * @remarks
         * This is called hidden in ooxml but in Excel object model it is formulaHidden.
         * @defaultValue false
         */
        isFormulaHidden(): boolean;
        /**
         * For runtime type checking.
         */
        readonly isICellProtection: true;
    }
    /**
     * {@inheritDoc ICellProtection}
     * @see
     * ### **Interface**
     *
     * {@link ICellProtection}
     */
    export namespace ICellProtection {
        /**
         * Properties for ICellProperties.
         */
        interface Properties {
            edit?: boolean;
            formulaHidden?: boolean;
        }
        interface JSON extends Properties {
        }
    }
}
declare module "cell/ICell" {
    import type { Scalar, JSScalarUpdate, ScalarType, IRange } from '@sheetxl/primitives';
    import type { Size, Rectangle, Bounds } from '@sheetxl/utils';
    import type { ITypes } from "type/index";
    import type { ITextFrame } from "text/index";
    import type { NumberFormat } from "numFmt/index";
    import type { IAutoFilter } from "filter/index";
    import type { IHyperlink } from "hyperlink/index";
    import type { IComment } from "comment/index";
    import type { IStyle } from "style/index";
    import type { ICellRange } from "cellRange/index";
    import type { ICalculation } from "calculation/index";
    import type { ISheet } from "sheet/index";
    import type { ICellProtection } from "cell/ICellProtection";
    /**
     * A single unit of data and meta data within an `ICellRange`, located at a specific row and column.
     */
    export interface ICell {
        /**
         * Returns the range of the cell.
         *
         * @remarks
         * Returns a range for a single cell.
         * Temporary cells will have to return InvalidRange
         */
        getRange(): ICellRange;
        /**
         * Returns the value of the cell.
         *
         * @remarks
         * Returns `null` if the cell has no value.
         */
        getValue(): Scalar;
        /**
         * Returns the type of the cell (e.g., text, number, date).
         */
        getType(): ScalarType;
        /**
         * Returns the formula assigned to the cell.
         *
         * @remarks
         * Returns `null` if the cell has no formula.
         */
        getFormula(): ICalculation.IFormula | null;
        /**
         * Returns the formula text assigned to the cell.
         *
         * @remarks
         * Returns `null` if the cell has no formula.
         */
        getFormulaText(): string | null;
        /**
         * Returns the CalcStatus.
         */
        getCalcStatus(): ICell.CalcStatus;
        /**
         * Returns the hyperlink assigned to the cell.
         *
         * @remarks
         * Returns `null` if no hyperlink is set.
         */
        getHyperlink(): IHyperlink | null;
        /**
         * Retrieves a list of comments associated with the cell.
         *
         * **Note**: This feature is not yet implemented.
         */
        getComments(): Readonly<IComment.Properties>;
        /**
         * Retrieves any warnings attached to the cell.
         *
         * @remarks
         * Warnings differ from errors in that they may alter the display of the cell's value or type.
         */
        getWarnings(): readonly string[];
        /**
         * Retrieves any errors attached to the cell.
         */
        getErrors(): readonly string[];
        /**
         * Returns the style information applied to the cell.
         *
         * @param specific - *`default`* `true`
         *
         * @remarks
         * If `true`, Returns the style directly set on the cell.
         * Otherwise, returns the rendered style, which may include effects like
         * conditional or table formatting.
         */
        getStyle(specific?: boolean): IStyle;
        /**
         * Returns the cell's value as a formatted string, applying any number formatting.
         *
         * @see
         * {@link toTextUnformatted}
         */
        toText(): string;
        /**
         * Returns the cell's value as an unformatted string.
         *
         * @param useFormula If `true` this will return a text frame for formula (if there is one else).
         *
         * @remarks
         * Minimum formatting is still applied to certain values, such as dates, times, and percentages.
         */
        toTextUnformatted(useFormula?: boolean): string;
        /**
         * Returns the cell's value as a JavaScript `Date` object if the cell contains a date.
         *
         * @remarks
         * Only returns a date if the number formatting is a date format and the cell's value
         * can be interpreted as a valid JavaScript `Date`. Otherwise, returns `null`.
         */
        toDate(): Date | null;
        /**
         * Returns the cell's value as a string with additional number format details.
         *
         * @param override A custom number format to apply (optional).
         *
         * @remarks
         * This method always returns a formatted string and never `null`.
         */
        getNumberFormat(override?: string): NumberFormat.Parsed;
        /**
         * Retrieves a {@link ITextFrame} containing text layout details, such as wrapping and alignment.
         *
         * @param useFormula If `true` this will return a text frame for formula (if there is one).
         *
         * @remarks
         * Returns `null` if the cell does not contain text or does not contain a formula.
         * This includes text formatting, rich text, and number formatting.
         */
        getTextFrame(useFormula?: boolean): ITextFrame | null;
        /**
         * Calculates the optimal size required to display the cell's content.
         *
         * @param colWidth The column width, used for text wrapping calculations. Default value `the current column width`.
         * @param minContent If `true`, calculates the size using the min width possible. For decimal numbers this will round.
         *
         * @remarks
         * Returns `null` if this cell should be ignored for sizing purposes.
         * Either dimension can also be `null`, indicating that the specific direction should not be used.
         */
        getBestFit(colWidth?: number, minContent?: boolean): Readonly<Partial<Size>> | null;
        /**
         * Returns protection information.
         */
        getProtection(): ICellProtection;
        /**
         * Returns the padding around the cell's content.
         *
         * @remarks
         * Insets do not affect the fill or background of the cell.
         */
        getInsets(): Readonly<Rectangle>;
        /**
         * Returns the span dimensions for merged cells.
         */
        getSpans(): Readonly<Size>;
        /**
         * Returns `true` if the cell is the top-left cell of a merged region, or if it is not part of a merged region.
         */
        isTopLeft(): boolean;
        /**
         * Returns the range of the cell if it is a spill cell.
         */
        getSpill(): ICellRange | null;
        /**
         * Returns `true` if the cell is a spill and not the top left.
         */
        isSpillOverflow(): boolean;
        /**
         * Returns the overflow details for the cell's text overflow or `null` if the cell does not overflow.
         *
         * @remarks
         * * This will only return a value if iterating using `ICellRange.Orientation.Row`.
         */
        getTextOverflow(): Readonly<ICell.HorizontalOverflow> | null;
        /**
         * Returns the extruding range of the cell if it extends beyond its original coordinates.
         *
         * @remarks
         * Useful for cells that have been merged or have text overflow. This can also
         * be included when iterating ranges with the `extendedRange` flag set to `true`.
         */
        getExtrusions(): Readonly<IRange.Coords> | null;
        /**
         * Returns the appropriate horizontal alignment for rendering the cell's content.
         *
         * @remarks
         * This takes into account both the style's alignment settings and the type of data in the cell.
         */
        getRenderHorizontalAlignment(): ITextFrame.HorizontalAlignment;
        /**
         * Return an {@link IAutoFilter.IColumn} if the cell is the the first row of an AutoFiltered range.
         */
        getColumnFilter(): IAutoFilter.IColumn | null;
        /**
         * Returns `true` if the cell contains a value.
         *
         * @remarks
         * A cell can be contentful even if it has no value but contains styling or other
         * characteristics like row/col spans or borders.
         */
        isContentful(): boolean;
        /**
         * Returns `true` if the cell is empty, meaning it has no value and its style is set to 'Normal'.
         *
         * @see
         * {@link ICell.isContentful}
         */
        isEmpty(): boolean;
        /**
         * Returns `true` if the cell is read-only.
         *
         * @remarks
         * A cell can be read-only due to protection or other reasons.
         */
        isEditAllowed(): boolean;
        /**
         * Returns `true` if the formula is hidden.
         */
        isFormulaHidden(): boolean;
        /**
         * Compares the current cell to another instance to determine if they are logically equal.
         *
         * @param other The cell to compare to.
         *
         * @remarks
         * * To be equal the cells must have the same values and be at the same address.
         * * Useful when ICells are dynamically generated because '===' comparison is not valid.
         */
        isEqual(other: ICell): boolean;
        /**
         * Creates a temporary copy of the cell with the specified updates applied.
         *
         * @remarks
         * The original cell remains unchanged, making this useful for temporary modifications.
         */
        createTemporaryCell(modifiers: ICell.Update): ICell;
        /**
         * Returns the `CellCoords`.
         */
        getCoords(): Readonly<IRange.CellCoords>;
        /**
         * Returns an A1-style string address (e.g., 'A1', 'B5').
         */
        getA1(): string;
        /**
         * Selects the current cell.
         * @returns An async boolean indicating the cell was selected.
         */
        select(options?: ITypes.SelectOptions): Promise<boolean>;
        /**
         * Returns the Sheet.
         */
        getSheet(): ISheet;
        /**
         * For runtime type checking.
         */
        readonly isICell: true;
    }
    /**
     * {@inheritDoc ICell}
     * @see
     * ### **Interface**
     *
     * {@link ICell}
     */
    export namespace ICell {
        /**
         * This is either:
         * 1. A string that can be parsed into a IRange.CellCoords (e.g. 'A1')
         * 2. A `IRange.CellCoords`
         * 3. An `ICell`
         */
        type Address = string | Readonly<IRange.FixableCellCoords> | ICell;
        /**
         * Expansive way to set cell updates options.
         */
        type Update = ICell | ICell.Modifiers<JSScalarUpdate> | JSScalarUpdate | null;
        /**
         * Used for updating multiple properties on a cell at the same time.
         * Any value that is null will be If a value is null then this will be treated as a remove.
         */
        interface Modifiers<T = Scalar> {
            /**
             * If a Date is passed to it will be converted internally into an OADate number with a date format (unless the style format is also set)
             */
            value?: T | null;
            /**
             * Update the style.
             */
            style?: IStyle.Update;
            /**
             * Allow to to set a hyperlink to this value.
             */
            hyperlink?: IHyperlink.Update;
        }
        /**
         * Configuration options for customizing the parsing of a string into an `ICell.Update` object.
         * Commonly used for processing CSV imports and other string-based data sources.
         */
        interface ModifiersFromStringOptions {
            /**
             * If `true`, the leading quote character in the string will be ignored during parsing.
             * This option is typically useful when importing data from CSV files.
             *
             * @defaultValue false
             */
            ignoreQuotePrefix?: boolean;
            /**
             * If `true`, dates parsed as numbers will follow the 1904 date system.
             * When not specified, the setting is inherited from the containing cell's configuration.
             *
             * @defaultValue inherited from the cell container
             */
            date1904?: boolean;
            /**
             * When `true`, strings in the format `m/d/yy` will be automatically parsed as dates.
             * This option is usually bypassed in favor of using localization for date formatting.
             *
             * @defaultValue false
             */
            dateNF?: boolean;
            /**
             * Provides a custom callback for parsing strings during updates. This is particularly
             * useful for handling complex data transformations in CSV imports or other data bindings.
             *
             * - The `context` parameter supplies cell-specific information and utility methods.
             * - The callback should return an `ICell.Update` object, or `undefined` to use the default parsed value.
             *
             * @param text The input string to parse.
             * @param context The context providing access to cell-specific information for parsing.
             *
             * @returns The parsed `ICell.Update` object, or `undefined` to use the default value.
             */
            parse?: (text: string, context: ICell.IteratorContext) => ICell.Update;
        }
        /**
         * Provides access to cell-specific information and utility functions during range iteration.
         *
         * This object serves as a context in the iterator, offering a convenient way to retrieve
         * the cell's coordinates, the full {@link ICell} object, and perform additional operations
         * like converting values to JavaScript dates or getting the cell's address.
         */
        interface IteratorContext {
            /**
             * Return the ScalarType of the value.
             */
            getType(): ScalarType;
            /**
             * Retrieves the `ICell` associated with the current iteration.
             *
             * @remarks
             * `ICells` are dynamically created and are significantly slower to access than simple values.
             */
            getCell(): ICell;
            /**
             * Retrieves the `IRange.CellCoords` associated with the current iteration.
             */
            getCoords(): IRange.CellCoords;
            /**
             * Converts the given or current cell coordinates to their corresponding A1-style address string (e.g., 'A1').
             *
             * @param coords The coordinates to convert. If not provided, the coordinates of the
             * current cell in the iteration will be used.
             * @returns The A1-style address string representing the cell coordinates.
             *
             * @remarks
             * The returned address can be used for further range queries or operations within the spreadsheet.
             */
            getA1(coords?: Partial<IRange.FixableCellCoords>): string;
            /**
             * Convert the current value to a Javascript `Date` object, considering the containers's 1904 date system setting.
             *
             * @returns A JavaScript `Date` object representing the converted date, or `null` if the value is not a valid date (< 0 or greater than December 31, 9999).
             *
             * @remarks
             * Spreadsheets store dates internally as serial numbers (OADates) to optimize calculation performance. These are integer values representing
             * the number of days since either January 1, 1900, or January 1, 1904, depending on the container's settings.
             *
             * For type-safe date retrieval consider using the {@link ICell.toDate} method, which returns null if the cell value is not a valid date.
             *
             * @see
             * Refer to the following resources for more details:
             * {@link https://support.microsoft.com/en-us/office/date-systems-in-excel-e7fe7167-48a9-4b96-bb53-5612a800b487 | Date systems in Excel}
             * {@link https://learn.microsoft.com/en-us/dotnet/api/system.datetime.tooadate?view=net-8.0 | DateTime.ToOADate Method}
             */
            toJSDate(value?: number): Date | null;
        }
        /**
         * Describes how text overflows horizontally outside the normal cell boundaries,
         * either to the left, right, or both. This is commonly used for features like
         * "Text Overflow" or "Center Continuous" in cells.
         */
        interface HorizontalOverflow {
            /**
             * The number of cells to the left that the content overflows into.
             * Ignored if not greater than 0. This value represents cells, not pixels.
             *
             * @defaultValue 0
             */
            leftIndex: number;
            /**
             * The number of cells to the right that the content overflows into.
             * Ignored if not greater than 0. This value represents cells, not pixels.
             *
             * @defaultValue 0
             */
            rightIndex: number;
            /**
             * The number of pixels by which the content overflows to the left of the current cell.
             * Ignored if not greater than 0.
             *
             * @defaultValue 0
             */
            leftOffset: number;
            /**
             * The number of pixels by which the content overflows to the right of the current cell.
             * Ignored if not greater than 0.
             *
             * @defaultValue 0
             */
            rightOffset: number;
            /**
             * The number of cells spanned by the overflow. Typically, this is 1, but
             * can be greater when a continuous fill is applied to the overflow.
             *
             * @defaultValue 1
             */
            colSpan: number;
            /**
             * The bounding box of the content within the cell, excluding any overflow.
             * This is relative to the cell's original size.
             */
            colBounds: Bounds;
            /**
             * The relative position of the content's anchor within the cell.
             * Defines where the anchor point of the content is located.
             */
            anchorBounds: Bounds;
        }
        /**
         * A value encoded as a number with an associated type.
         */
        interface JSONTypedValue {
            t: ScalarType;
            v: number;
        }
        /**
         * Reexports the `IRange.CellCoords` type for use in cell coordinates.
         */
        type Coords = IRange.CellCoords;
        /**
         * JSON values types that have their type embedded in the
         * 'format'.
         *
         * @remarks
         * A string value is the string id in the `IStringsCollection`.
         */
        type JSONUnTypedValue = number | boolean | string;
        /**
         * For persisting a single Cell value and type.
         *
         * @remarks
         * Styling and other advanced properties are stored as ranges.
         */
        type JSON = JSONUnTypedValue | JSONTypedValue;
        /**
         * Represents the calculation status.
         */
        const CalcStatus: {
            /**
             * The cell's value is up-to-date and reflects the latest calculation.
             */
            readonly Ready: "ready";
            /**
             * The cell's value may not reflect the latest calculation, typically due to the calculation engine being in manual mode.
             */
            readonly Stale: "stale";
            /**
             * The cell's value is being calculated asynchronously, typically because the function used returned a Promise.
             * All dependent cells will also be in the Pending state. If the promise returns an error or times out, the cell's value will be an error value.
             */
            readonly Pending: "pending";
            /**
             * The cell's value is up-to-date, but the underlying data source is streaming live updates.
             */
            readonly Streaming: "streaming";
        };
        type CalcStatus = typeof CalcStatus[keyof typeof CalcStatus];
        /**
         * Represents the types of content that can be associated with a cell or range.
         */
        const Content: {
            /**
             * Represents the actual values stored in the cells (numbers, text, booleans, etc.).
             */
            readonly Values: "values";
            /**
             * Represents the formatting and styling applied to the cells (fonts, colors, borders, etc.).
             */
            readonly Formats: "formats";
            /**
             * Represents the formulas contained within the cells.
             */
            readonly Formulas: "formula";
            /**
             * Represents hyperlinks associated with the cells.
             */
            readonly Hyperlinks: "hyperlinks";
            /**
             * Represents tables associated with the cells.
             */
            readonly Tables: "tables";
            /**
             * Represents notes associated with the cells.
             * @remarks
             * **NOT IMPLEMENTED**
             */
            readonly Notes: "notes";
            /**
             * Represents comments attached to the cells.
             */
            readonly Comments: "comments";
            /**
             * Represents warnings or informational messages associated with the cells.
             */
            readonly Warnings: "warnings";
            /**
             * Represents error values (e.g., #DIV/0!, #N/A) within the cells.
             */
            readonly Errors: "errors";
            /**
             * Represents values that have merge spans.
             */
            readonly Merges: "merges";
        };
        type Content = typeof Content[keyof typeof Content];
    }
}
declare module "cell/ICellHeader" {
    import type { IRange } from '@sheetxl/primitives';
    import type { IStyle } from "style/index";
    import type { ICell } from "cell/ICell";
    /**
     * A logic label for an entire span of cells in either direction.
     */
    export interface ICellHeader {
        /**
         * The absolute size in pixels.
         */
        getSize(): number;
        /**
         * Returns the header display.
         */
        getDisplayText(): string;
        /**
         * The style for the header.
         *
         * @remarks
         * This represents a default style for the entire span. It generally is not used for formatting the header
         * itself.
         */
        getStyle(): IStyle;
        /**
         * Returns orientation for the header.
         */
        getOrientation(): IRange.Orientation;
        /**
         * Flag to indicate if column is hidden. Note - A column with a size > 0 but hidden is true is valid
         * because when hiding a value we don't change the size so that an unhide will restore to it's previous location
         */
        isHidden(): boolean;
        /**
        * Note - size can be a function of autoFitting isCustomSize means the field has set by the user
        * and should not be autoSize due to autoFitting (unless explicitly done so by a user gesture)
        */
        isCustomSize(): boolean;
        /**
         * Creates a new detected header from the modifiers.
         */
        createTemporaryCellHeader(update: ICellHeader.Modifiers): ICellHeader;
        /**
         * If a cell has no sizing or custom formatting.
         */
        isEmpty(): boolean;
        /**
         * Returns true if the headers are logically equal.
         * @param other
         */
        isEqual(other: ICellHeader): boolean;
        /**
         * Returns the header as an ICell.
         */
        asCell(): ICell;
        /**
         * Rows and columns sizes are managed internally as relative size to the normal styling font size.
         * This is done to allow for the sizes to auto adjustment when the style changes.
         *
         * @see
         * {@link https://support.microsoft.com/en-us/office/change-the-column-width-and-row-height-72f5e3cc-994d-43e8-ae58-9774a0905f46}
         */
        getSizeRelative(): number;
        /**
         * For runtime introspection.
         */
        get isICellHeader(): true;
    }
    /**
     * {@inheritDoc ICellHeader}
     * @see
     * ### **Interface**
     *
     * {@link ICellHeader}
     */
    export namespace ICellHeader {
        /**
         * Combine various ways to update a CellHeader.
         */
        type Update = ICellHeader.Modifiers | ICellHeader | null;
        /**
         * Allows for headers to be updated.
         */
        interface Modifiers {
            /**
             * The size of the header in either absolute or relative value.
             *
             * @default 'The default size for the sheet'
             *
             * @remarks
             * If the size is set to a 0 this will become hidden even if hidden is set to `false`.
             *
             * @see
             * {@link relativeSize}
             */
            size?: number | string | ((size: number) => number);
            /**
             * @see
             * {@link ICellHeader.isHidden()}
             */
            hidden?: boolean;
            /**
             * @see
             * {@link ICellHeader.isCustomSize()}
             */
            autoSize?: boolean;
            /**
             * @see
             * {@link ICellHeader.getSizeRelative()}
             */
            relativeSize?: boolean;
            /**
             * @see
             * {@link ICellHeader.getStyle()}
             */
            style?: IStyle.Update;
        }
        /**
         * Stores information about header runs.
         */
        interface JSON {
            min: number;
            max: number;
            /**
             * Size - height or width
             */
            sz?: number;
            /**
             * Custom size
             */
            csz?: boolean;
            /**
             * Hidden
             */
            h?: boolean;
            /**
             * Style id
             */
            s?: number;
            /**
             * Header level
             */
            l?: number;
            /**
             * Collapsed level
             */
            cl?: boolean;
        }
    }
}
declare module "cell/index" {
    export * from "cell/ICell";
    export * from "cell/ICellProtection";
    export * from "cell/ICellHeader";
}
declare module "sort/IAutoSort" {
    import type { IRange } from '@sheetxl/primitives';
    import type { ISort } from "sort/ISort";
    /**
     * Capabilities for applying and managing sorting on a range.
     *
     * `AutoSort` enables dynamic sorting of data based on criteria specified per column,
     * allowing users to organize and arrange information effectively.
     *
     * Key features include:
     * - Sorting one or more columns within a range.
     * - Specifying sort order (ascending or descending) for each column.
     * - Applying custom sort options (e.g., case sensitivity).
     * - Clearing or modifying sort.
     */
    export interface IAutoSort {
        /**
         * Returns the range that filter is applied to.
         */
        getRange(): IRange.Coords;
        /**
         * Returns the current fields or an empty array if nothing is sorted.
         */
        getFieldAt(offset: number): ISort.Criteria;
        /**
         * Updates the current sort fields.
         * @param offset Offset relative to the sort.
         * @param field The field to sort.
         */
        setFieldAt(offset: number, field: ISort.Criteria): IAutoSort;
        /**
         * Set all field fields.
         */
        apply(fields: ISort.Field[]): IAutoSort;
        /**
         * Reapply sort to the fields.
         */
        reapply(): IAutoSort;
        /**
         * Remove the current sort.
         * @remarks
         * This is a convenience methods that does the same thing that setFields with an empty array does.
         */
        clear(): IAutoSort;
        /**
         * Delete this sort.
         */
        delete(): void;
        /**
         * Returns persistable state.
         */
        toJSON(): IAutoSort.JSON;
    }
    /**
     * {@inheritDoc IAutoSort}
     * @see
     * ### **Interface**
     *
     * {@link IAutoSort}
     */
    export namespace IAutoSort {
        interface JSON extends ISort.Criteria {
            /**
             * If not defined then assume the container has default the range.
             */
            ref?: string;
            /**
             * Sort fields.
             */
            fields?: ISort.Field[];
        }
    }
}
declare module "sort/AutoSort" {
    import { IRange } from '@sheetxl/primitives';
    import { ITransaction } from "transaction/index";
    import { ISort } from "sort/ISort";
    import { IAutoSort } from "sort/IAutoSort";
    import { IAnchored } from "anchored/index";
    import { AbstractAnchored } from "anchored/AbstractAnchored";
    interface State extends AbstractAnchored.State {
        byOffset?: Map<number, ISort.Field>;
    }
    interface CommitView extends AbstractAnchored.CommitView {
    }
    /**
     * Sort capabilities.
     */
    export class AutoSort extends AbstractAnchored<State, CommitView> implements IAutoSort {
        private _apply;
        private _processUpdate;
        constructor(options: AutoSort.ConstructorOptions);
        /** {@inheritDoc IAutoFilter.getRange} */
        getRange(): IRange.Coords;
        /** {@inheritDoc IAutoFilter.getFieldAt} */
        getFieldAt(offset: number): ISort.Field;
        /** {@inheritDoc IAutoFilter.insertSort} */
        insertSort(): IAutoSort;
        /** {@inheritDoc IAutoFilter.getSort} */
        getSort(): IAutoSort;
        /** {@inheritDoc IAutoFilter.setFieldAt} */
        apply(fields: ISort.Field[]): IAutoSort;
        /** {@inheritDoc IAutoFilter.reapply} */
        setFieldAt(offset: number, filter: ISort.Field): IAutoSort;
        protected _processStateChange(state: State, view: CommitView, commit: ITransaction.ICommit): void;
        /** {@inheritDoc IAutoFilter.reapply} */
        reapply(): IAutoSort;
        /** {@inheritDoc IAutoFilter.clear} */
        clear(): IAutoSort;
        protected _fromJSON(json: IAutoSort.JSON): void;
        /** {@inheritDoc IAutoFilter.toJSON} */
        toJSON(): IAutoSort.JSON;
    }
    /**
     * Interfaces for creating `AutoSort`.
     *
     * @see
     * ### **Interface**
     *
     * {@link AutoSort}
     */
    export namespace AutoSort {
        interface ConstructorOptions extends IAnchored.ConstructorOptions {
            /**
             * JSON state to load.
             */
            json?: IAutoSort.JSON;
            /**
             * Apply the sort
             */
            apply?(fields: ISort.Field[]): void;
            processUpdate: () => void;
        }
    }
}
declare module "table/Table" {
    import { IRange } from '@sheetxl/primitives';
    import { ReferenceableClipboard } from '@sheetxl/utils';
    import { IListener } from "listener/index";
    import { ITransaction } from "transaction/index";
    import { ICellRange } from "cellRange/index";
    import { IStyle } from "style/index";
    import { IAnchored } from "anchored/index";
    import { IAutoSort } from "sort/index";
    import { IAutoFilter } from "filter/index";
    import { ITableStyle } from "table/ITableStyle";
    import { ITable } from "table/ITable";
    import { AbstractAnchored } from "anchored/AbstractAnchored";
    /** @internal */
    interface State extends AbstractAnchored.State {
        name: string;
        description: string;
        headerRowCount: number;
        totalsRowCount: number;
        columns: ITable.Column[];
        styleOptions?: ITableStyle.StyleOptions;
        filter: IAutoFilter;
        sort: IAutoSort;
        headerRemoveListener: IListener.Remove;
    }
    /** @internal */
    interface CommitView extends AbstractAnchored.CommitView {
    }
    /**
     * Implementation of {@link ITable}.
     */
    export class Table extends AbstractAnchored<State, CommitView> implements ITable {
        private _sheet;
        private _styles;
        private _stylesRemoveListener;
        private _headerValueListener;
        private _isUpdatingHeader;
        private _autoExpandRemoveListener;
        private _styleCache;
        private _stylePropsCache;
        private _processTableUpdate;
        private _setNameOnContainer;
        private _names;
        private _namedItem;
        private _filterShiftCallback;
        private _filterCoordsCallback;
        private _colHeadersSizeUnlistener;
        private _rowHeadersSizeUnlistener;
        private _visibleRange;
        private _isHeaderVisible;
        private _isTotalVisible;
        private _isFirstColumnVisible;
        private _isLastColumnVisible;
        private _range;
        constructor(options: ITable.ConstructorOptions);
        /** {@inheritDoc ITable.getSnapshot} */
        getSnapshot(options?: ReferenceableClipboard.CopyOptions): ITable.ISnapshot;
        /** {@inheritDoc ITable.getAnchorType} */
        getAnchorType(): IAnchored.Type;
        /** {@inheritDoc ITable.getStyle} */
        getStyle(): ITableStyle;
        /** {@inheritDoc ITable.resize} */
        addRows(_offset: number, count?: number): this;
        /** {@inheritDoc ITable.deleteRowsAt} */
        deleteRowsAt(_offset: number, count?: number): this;
        /** {@inheritDoc ITable.addColumn} */
        addColumn(offset: number, name: string): ITable.Column;
        /** {@inheritDoc ITable.getColumns} */
        getColumns(): ITable.Column[];
        /** {@inheritDoc ITable.convertToRange} */
        convertToRange(maxCells?: number): ICellRange;
        /** {@inheritDoc ITable.resize} */
        resize(address: ICellRange.Address, description?: string): ICellRange;
        /** {@inheritDoc ITable.getName} */
        getName(): string;
        /** {@inheritDoc ITable.setName} */
        setName(name: string): this;
        /** {@inheritDoc ITable.getDescription} */
        getDescription(): string;
        /** {@inheritDoc ITable.setDescription} */
        setDescription(description: string): this;
        /** {@inheritDoc ITable.select} */
        select(options?: ICellRange.SelectOptions): Promise<ICellRange>;
        /** {@inheritDoc ITable.getRange} */
        getRange(): ICellRange;
        /** @internal */
        protected _processRestoreOrRevert(state: State, view: CommitView, commit: ITransaction.ICommit): void;
        /** @internal */
        protected _processAnchorCoords(): void;
        /** {@inheritDoc ITable.getRange} */
        getUsedRange(): ICellRange;
        private _getUsedCoords;
        /** {@inheritDoc ITable.getHeaderRange} */ /** {@link ITable.getHeaderRange} @hidden */
        getHeaderRange(): ICellRange;
        private _getHeaderCoords;
        /** {@inheritDoc ITable.getTotalRange} */ /** {@link ITable.getTotalRange} @hidden */
        getTotalRange(): ICellRange;
        private _getTotalCoords;
        /** {@inheritDoc ITable.getStyleOptions} */
        getStyleOptions(): ITableStyle.StyleOptions;
        /** {@inheritDoc ITable.updateStyleOptions} */
        updateStyleOptions(options: ITableStyle.StyleOptions, description?: string): this;
        /** {@inheritDoc ITable.getStyleAt} */
        getStyleAt(coords: IRange.CellCoords): IStyle;
        /** {@inheritDoc ITable.getShowTotals} */
        getShowTotals(): boolean;
        /** {@inheritDoc ITable.setShowTotals} */
        setShowTotals(showTotals: boolean): this;
        /** {@inheritDoc ITable.getShowHeaders} */
        getShowHeaders(): boolean;
        /** {@inheritDoc ITable.setShowHeaders} */
        setShowHeaders(showHeaders: boolean): this;
        /** {@inheritDoc ITable.getShowFilterButton} */
        getShowFilterButton(): boolean;
        /** {@inheritDoc ITable.setShowFilterButton} */
        setShowFilterButton(showFilterButton: boolean): this;
        private _applyFilterAndSort;
        private _processUpdate;
        private _createFilter;
        /** {@inheritDoc ITable.insertFilter} */
        insertFilter(): IAutoFilter;
        /** {@inheritDoc ITable.getFilter} */
        getFilter(): IAutoFilter | null;
        private _createSort;
        /** {@inheritDoc ITable.insertSort} */
        insertSort(): IAutoSort;
        /** {@inheritDoc ITable.getSort} */
        getSort(): IAutoSort | null;
        /** {@inheritDoc ITable.getColumnFilter} */
        getColumnFilter(offset: number): IAutoFilter.IColumn;
        /** {@inheritDoc ITable.getVisibleRefRangeCoords} */
        getVisibleRefRangeCoords(): IRange.Coords;
        /** {@inheritDoc ITable.getVisibleCellCoords} */
        getVisibleCellCoords(coords: IRange.CellCoords): IRange.CellCoords;
        /** {@inheritDoc ITable.isHeaderVisible} */
        isHeaderVisible(): boolean;
        /** {@inheritDoc ITable.isTotalVisible} */
        isTotalVisible(): boolean;
        /** {@inheritDoc ITable.isFirstColumnVisible} */
        isFirstColumnVisible(): boolean;
        /** {@inheritDoc ITable.isLastColumnVisible} */
        isLastColumnVisible(): boolean;
        /** @internal */
        protected _columnsFromSheet(): {
            columns: ITable.Column[];
            forceUpdate: boolean;
        };
        /**
         * This takes a list of columns headers and then validates them
         * and if there is a sheet it will set the values back into the sheet.
         *
         * 1. They must be unique. (case insensitive)
         * 2. They can't be blank.
         * 3. They must be text
         * @internal
         */
        protected _updateColumns(columns: ITable.Column[], isNew: boolean, forceUpdate: boolean, trimmed: ITable.Column[]): ITable.Column[];
        /** @internal */
        protected _processDelete(): void;
        /** @internal */
        protected _processFilterUpdate(): void;
        /** @internal */
        protected _processContainerShift(options: IAnchored.ShiftOptions): IRange.Coords | void;
        private _modifyTable;
        /** {@inheritDoc IListener.ISource.addListeners} */
        addListeners(listeners: ITable.IListeners, options?: IListener.Options): IListener.Remove;
        /** @internal */
        protected _processStateChange(state: State, view: CommitView, commit: ITransaction.ICommit): void;
        /** @internal */
        protected _processHeaderListener(): void;
        get [Symbol.toStringTag](): string;
        /** {@inheritDoc ICellRanges.toString} */
        toString(): string;
        /** {@inheritDoc ITable.toJSON} */
        toJSON(): ITable.JSON | null;
        private _createNamed;
        private _fromJSON;
        /** {@inheritDoc ITable.close} */
        close(): void;
        /** {@inheritDoc ITable.isITable} */
        get isITable(): true;
    }
}
declare module "table/index" {
    export * from "table/ITable";
    export * from "table/ITableStyle";
    export * from "table/ITableCollection";
    export * from "table/Table";
}
declare module "style/IStyleCollection" {
    import type { IProperties } from "type/index";
    import type { IListener } from "listener/index";
    import type { IColor } from "color/index";
    import type { ITheme } from "theme/index";
    import type { ITableStyle } from "table/index";
    import type { IStyle } from "style/index";
    /**
     * Contains collections of Named and Table Styles.
     */
    export interface IStyleCollection {
        /**
         * Returns The named style from either a custom style or a builtIn.
         *
         * @remarks
         * Will try to return:
         * 1. The custom style for the name
         * 2. The builtin style for the name.
         * 3. nul if it doesn't exist.
         */
        getNamed(name: string): IStyle.INamed | null;
        /**
         * Returns all customized named cell styles.
         *
         * @remarks
         * This includes new style names and builtin overrides.
         */
        getCustomNamed(): IStyle.INamed[];
        /**
         * This will add or update a cell style.
         *
         * @param modifiers The Style or Style Modifiers
         * @param mergeIfExists If true then the style will be merged with the existing style otherwise is a replace. @defaultValue false
         * @returns The new style after any merges.
         *
         * @remarks
         * Names are case insensitive; for duplicate detection purposes.
         */
        setNamed(modifiers: IStyle.NamedUpdate, mergeIfExists?: boolean): IStyle.INamed;
        /**
         * Returns The table style. This can be either a custom or a built in table style.
         *
         * @remarks
         * Will try to return:
         * 1. The custom style for the name
         * 2. The builtIn style for the name.
         * 3. `null` if it doesn't exist.
         */
        getTableStyle(name?: string): ITableStyle | null;
        /**
         * Returns all customized table styles.
         *
         * @remarks
         * This includes new table styles and builtin overrides.
         */
        getCustomTableStyles(): ITableStyle[];
        /**
         * This will add or update a table style.
      
         * @param name A string of the name of the table.
         * @param properties The values to set for the table style.
         * @returns A new `ITableStyle` representing the updated style.
         *
         * @remarks
         * Case insensitive; for duplicate detection purposes.
         */
        setCustomTableStyle(name: string, properties: ITableStyle.ResolvableProperties): ITableStyle;
        /**
         * Set the default table style to use if a table is created without specifying a style.
         *
         * @param name A string of the name of the table
         * @remarks
         * The style must exist or the defaultStyle will be set to 'TableStyleMedium2'.
         */
        setDefaultTableStyle(name: string): void;
        /**
         * Returns the default ITableStyle.
         * @see
         * {@link setDefaultTableStyle}
         */
        getDefaultTableStyle(): ITableStyle;
        /**
         * Returns the current theme
         */
        getTheme(): ITheme;
        /**
         * Set the theme used to calculate styles.
         *
         * @param theme The ITheme to use.
         */
        setTheme(theme: ITheme): void;
        /**
         * Themes do not contain font sizes but it is possible to set a default font size at the document or application level.
         */
        getDefaultFontSize(): number;
        /**
         * Set the default fontSize. Note - A theme does NOT contain this.
         * @param fontSize The new default font size.
         */
        setDefaultFontSize(fontSize: number): void;
        /**
         * This is available for functions that want to resolve colors for the theme used specifically for this style.
         */
        schemeLookup(): IColor.SchemeLookup;
        /**
         * This is available for functions that want to resolve colors using the index color palette.
         * @see
         * {@link IColor.IndexedLookup}
         */
        indexedLookup(): IColor.IndexedLookup;
        /**
         * Parses the color using the Theme being used by this style
         * @param str Any string that represents a color {@link IColor}.
         */
        parseColor(str: any): IColor;
        /**
         * Returns a list of colors that were added via {@link addRecentColor}.
         */
        recentColors(): readonly IColor[];
        /**
         * Add a color to the mru list. This is used to populate color pickers.
         *
         * @param color The color to record.
         *
         * @remarks
         * Any color can be added but generally this should be limited to custom/non-themed color
         */
        addRecentColor(color: IColor): readonly IColor[];
        /**
         * Clears the mru color list
         */
        clearRecentColors(): void;
        /**
         * Returns an array of colors that will be used to resolve any colors that use IndexXX or ColorXX as a key.
         */
        getIndexedColors(): readonly IColor[];
        /**
         * Override the default indexed colors.
         * @param colors An array of colors.
         */
        setCustomIndexedColors(colors: readonly IColor[]): void;
        /**
         * Returns the customized Indexed colors.
         */
        getCustomIndexedColors(): readonly IColor[];
        /**
         * Add Listeners.
         *
         * @see
         * {@link IListener.ISource.addListeners}
         */
        addListeners(listeners: IStyleCollection.IListeners, options?: IListener.Options): IListener.Remove;
        /**
         * Converts a list of `IStyle.Modifiers` that contain shorthand values into native values.
         *
         * @param modifiers {@link IStyle.Modifiers}
         * @param name Name used to normalize against. This overrides any specified in the modifiers.
         * @returns A valid IStyle.Modifiers with values that match the normal style removed.
         *
         * @remarks
         * Will also remove any value that resolve to the same values as the referenced named style (or Normal if this is not specified).
         */
        normalize(modifiers: IStyle.Modifiers, name?: string): Partial<IStyle.Modifiers>;
        /**
         * Convenience mechanism (and slightly faster) way to call getNamed('Normal').getRanged();
         */
        getNormalRanged(): IProperties.ICellRanged<IStyle.Properties>;
        /**
         * Return a the Normal styles as an IStyle.;
         */
        getNormal(): IStyle;
        /**
         * Checks the current name to see if this is a valid sheetName.
         */
        validateStyleName(name: string, checkDuplicates?: boolean): void;
        /**
         * Start persisting styles.
         *
         * * This is used during save/load to allow for styles to be references by an id count.
         * * This is a stack so multiple begins will need to be matched with an end.
         * @see
         * {@link IStyleCollection.IPersistScope}
         */
        beginPersist(): IStyleCollection.IPersistScope;
    }
    /**
     * {@inheritDoc IStyleCollection}
     * @see
     * ### **Interface**
     *
     * {@link IStyleCollection}
     */
    export namespace IStyleCollection {
        interface Events {
            /**
            * Notify that the named styled has changed
            */
            onNamedStylesChange?(source: IStyleCollection): void;
            onTableStylesChange?(source: IStyleCollection): void;
            onThemeChange?(source: IStyleCollection): void;
            onDefaultFontChange?(source: IStyleCollection): void;
            onAnyChange?(source: IStyleCollection): void;
        }
        interface IListeners extends IListener.Callbacks<IStyleCollection, IStyleCollection.Events> {
        }
        interface JSON {
            /**
             * Used by cells styles.
             */
            direct?: IStyle.JSON[];
            /**
             * cells styles with a name for quick styling.
             */
            named?: IStyle.NamedJSON[];
            /**
             * Table styles.
             */
            tables?: ITableStyle.JSONS;
            /**
             * A list of custom colors.
             */
            mruColors?: string[];
            /**
             * Overrides for indexed colors.
             */
            indexedColors?: string[];
        }
        /**
         * A transient scope for persisting styles with a given
         * set of StyleIDs.
         *
         * @remarks
         * This is done to ensure that styles across multiple
         * sheets are rationalized
         */
        interface IPersistScope {
            /**
             * End the persist scope. This will clear the stack and stop tracking access to this.
             */
            endPersist(): void;
            /**
             * This can be called multiple times.
             *
             * @returns The state as {@link IStyleCollection.JSON}.
             *
             * @remarks
             * Only shared styles that have had the toResourceId called will
             * be shown in the persisted json.
             */
            toJSON(): IStyleCollection.JSON;
            /**
             * Load a JSON for a StyleCollection object.
             *
             * @remarks
             * Once this is called the getSharedStyle is available for all
             * the ids defined in the JSON for the current scope.
             * @param json {@link IStyleCollection.JSON}
             */
            fromJSON(json: IStyleCollection.JSON): void;
            /**
             * Given the id return the style.
             * This assumes that the fromJSON has been called previously.
             *
             * @param id
             */
            getElementJSON(id: number): IStyle.JSON;
            /**
             * A 0-based style id for the given style. If this is a named style
             * or a style that is not available with the styles then this will return null.
             *
             * @remarks
             * This is a side effect operation. Calling this will cause the style to be persisted as part of the toJSON
             *
             * @param json
             */
            getElementID(json: IStyle.JSON): number | null;
        }
    }
}
declare module "table/_BuiltInTableStyles" {
    import { ITableStyle } from "table/ITableStyle";
    /**
     * Returns a set of predefined table styles that match ooxml definitions.
     * // TODO - either make the map readonly or just expose a few methods
     */
    export const _BuiltInTableStyles: () => ReadonlyMap<string, ITableStyle.Properties>;
    export const DefaultTableStyleName: string;
    export const DefaultPivotStyleName: string;
}
declare module "sheet/style/SheetTableStyle" {
    import { IRange } from '@sheetxl/primitives';
    import { IProperties } from "type/index";
    import { IStyle, IStyleCollection } from "style/index";
    import { ITable, ITableStyle } from "table/index";
    export class TableRangedStyle implements IProperties.ICellRanged<IStyle.Properties> {
        protected _styles: IStyleCollection;
        protected _properties: ITableStyle.Properties;
        protected _table: ITable;
        constructor(table: ITable, styles: IStyleCollection, properties: ITableStyle.Properties);
        protected _resolveProperties(properties: ITableStyle.Properties): ITableStyle.Properties;
        getCoords(): IRange.Coords;
        getPropertiesAt(rowIndex: number, colIndex: number): Readonly<IStyle.Properties>;
    }
    export class SheetTableStyle implements ITableStyle {
        protected _styles: IStyleCollection;
        protected _properties: Readonly<ITableStyle.Properties>;
        protected _isBuiltIn: boolean;
        protected _doDelete: (styleName: string) => void;
        constructor(styles: IStyleCollection, properties: ITableStyle.Properties, isBuiltIn: boolean, _doDelete?: (styleName: string) => void);
        protected _resolveProperties(properties: ITableStyle.Properties): ITableStyle.Properties;
        /** {@inheritDoc ITableStyle.delete} */
        delete(): void;
        /** {@inheritDoc ITableStyle.getRanged} */
        getRanged(table: ITable): IProperties.ICellRanged<IStyle.Properties>;
        /** {@inheritDoc ITableStyle.getProperties} */
        getProperties(): Readonly<ITableStyle.Properties>;
        /** {@inheritDoc ITableStyle.getName} */
        getName(): string;
        /** {@inheritDoc ITableStyle.isShownInTableStyles} */
        isShownInTableStyles(): boolean;
        /** {@inheritDoc ITableStyle.isShownInPivotStyles} */
        isShownInPivotStyles(): boolean;
        /** {@inheritDoc ITableStyle.isBuiltIn} */
        isBuiltIn(): boolean;
        /** {@inheritDoc ITableStyle.toJSON} */
        toJSON(): ITableStyle.JSON;
        get isITableStyle(): true;
    }
}
declare module "sheet/style/SheetNamedStyle" {
    import { IRange } from '@sheetxl/primitives';
    import { IProperties } from "type/index";
    import { IStyle, IStyleCollection } from "style/index";
    import { ISpatialMap } from "collections/ISpatialMap";
    import { SheetDirectStyle } from "sheet/style/SheetDirectStyle";
    export class NamedRangedStyle extends SheetDirectStyle {
        constructor(styles: IStyleCollection, properties?: IStyle.Properties);
        isEmpty(): boolean;
        /** {@inheritDoc IProperties.ICellRanged.getCoords} */
        getCoords(): Readonly<IRange.Coords>;
        /** {@inheritDoc IProperties.ICellRanged.cloneWithUpdate} */
        cloneWithUpdate(updates: IStyle.Properties): this;
        protected _createShifted(coords: IRange.Coords): this;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getShifted} */
        getShifted(options: ISpatialMap.ShiftDetails<this>): ISpatialMap.Entry<this>;
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getSplit} */
        getSplit(coords: [IRange.Coords, IRange.Coords], _orientation: IRange.Orientation): [this, this];
        /** {@inheritDoc ISpatialMap.IUpdatableEntry.getMerged} */
        getMerged(other: this, coords: IRange.Coords, _orientation: IRange.Orientation): this;
        getPropertiesAt(_rowIndex: number, _colIndex: number): Readonly<IStyle.Properties>;
        toJSON(): IStyle.JSON;
    }
    export class SheetNamedStyle implements IStyle.INamed {
        private _name;
        private _properties;
        private _rangeStyle;
        private _builtInID;
        private _doDelete;
        constructor(style: IStyleCollection, properties: Readonly<IStyle.NamedProperties>, doDelete: (style: IStyle.INamed | string) => void, builtInID?: number | null);
        /** {@inheritDoc IStyle.INamed.getRanged} */
        getRanged(): IProperties.ICellRanged<IStyle.Properties>;
        /** {@inheritDoc IStyle.INamed.getName} */
        getName(): string;
        /** {@inheritDoc IStyle.INamed.isHidden} */
        isHidden(): boolean;
        /** {@inheritDoc IStyle.INamed.getILevel} */
        getILevel(): number | null;
        /** {@inheritDoc IStyle.INamed.getBuiltInID} */
        getBuiltInID(): number | null;
        /** {@inheritDoc IStyle.INamed.delete} */
        delete(): void;
        /** {@inheritDoc IStyle.INamed.toJSON} */
        toJSON(): IStyle.NamedJSON;
        /** {@inheritDoc IStyle.INamed.isINamed} */
        get isINamed(): true;
    }
}
declare module "style/StyleCollection" {
    import { IProperties } from "type/index";
    import { IListener } from "listener/index";
    import { IColor } from "color/index";
    import { ITheme } from "theme/index";
    import { ITableStyle } from "table/index";
    import { IStyle } from "style/IStyle";
    import { IStyleCollection } from "style/IStyleCollection";
    import { ListenerEmitter } from "listener/ListenerEmitter";
    interface PersistScopeState {
        byJSONs: Map<string, number>;
        byIds: Map<number, IStyle.JSON>;
        openScopes: Set<PersistScope>;
    }
    class PersistScope implements IStyleCollection.IPersistScope {
        protected _state: PersistScopeState;
        protected _normalJSON: IStyle.JSON;
        protected _toJSONInternal: (jsonSheetStyleShared: IStyle.JSON[]) => IStyleCollection.JSON;
        protected _fromJSONInternal: (json: IStyleCollection.JSON) => void;
        protected _onLastEnd: () => void;
        protected _isClosed: boolean;
        constructor(state: PersistScopeState, normalJSON: IStyle.JSON, toJSONInternal: () => IStyleCollection.JSON, fromJSONInternal: (json: IStyleCollection.JSON) => void, onLastEnd: () => void);
        /** {@inheritDoc IStyleCollection.IPersistScope.endPersist} */
        endPersist(): void;
        /** {@inheritDoc IStyleCollection.IPersistScope.getElementID} */
        getElementID(json: IStyle.JSON): number | null;
        /** {@inheritDoc IStyleCollection.IPersistScope.getElementJSON} */
        getElementJSON(id: number): IStyle.JSON;
        /** {@inheritDoc IStyleCollection.IPersistScope.fromJSON} */
        fromJSON(json: IStyleCollection.JSON): void;
        /** {@inheritDoc IStyleCollection.IPersistScope.toJSON} */
        toJSON(): IStyleCollection.JSON;
    }
    /**
     * Base implementation of {@link IStyleCollection}
     *
     * TODO - defaultFontSize move to theme?
     *
     */
    export class StyleCollection implements IStyleCollection {
        protected _emitter: ListenerEmitter<IStyleCollection, IStyleCollection.IListeners>;
        protected _theme: ITheme;
        protected _defaultFontSize: number;
        protected _schemeLookup: IColor.SchemeLookup;
        protected _indexedLookup: IColor.IndexedLookup;
        protected _builtInsCellStyles: Map<string, IStyle.INamed>;
        protected _customCellStyles: Map<string, IStyle.INamed>;
        protected _builtInsTableStyles: Map<string, ITableStyle>;
        protected _customTableStyles: Map<string, ITableStyle>;
        protected _emptyTableStyle: ITableStyle.Empty;
        protected _indexedColors: readonly IColor[];
        protected _mruColors: readonly IColor[];
        protected _normalStyle: IStyle;
        protected _normalRanged: IProperties.ICellRanged<IStyle.Properties>;
        protected _defaultTableStyle: ITableStyle;
        protected _persistCache: PersistScopeState;
        constructor(theme?: ITheme, indexedColors?: string[], defaultFontSize?: number);
        protected _initializeNamedStyles(namedStyles: readonly IStyle.Properties[], builtInStyleMap: Map<string, IStyle.INamed>): void;
        protected _initializeTableStyles(): Map<string, ITableStyle>;
        protected _initializeBuiltIns(): void;
        /** {@inheritDoc IStyleCollection.getNormal} */
        getNormal(): IStyle;
        /** {@inheritDoc IStyleCollection.getNormalRanged} */
        getNormalRanged(): IProperties.ICellRanged<IStyle.Properties>;
        /** {@inheritDoc IStyleCollection.setTheme} */
        setTheme(theme: ITheme): void;
        /** {@inheritDoc IStyleCollection.getTheme} */
        getTheme(): ITheme;
        /** {@inheritDoc IStyleCollection.setDefaultFontSize} */
        setDefaultFontSize(fontSize: number): void;
        /** {@inheritDoc IStyleCollection.getDefaultFontSize} */
        getDefaultFontSize(): number;
        /** {@inheritDoc IStyleCollection.beginPersist} */
        beginPersist(): IStyleCollection.IPersistScope;
        /** {@inheritDoc IStyleCollection.getNamed} */
        getNamed(name: string | IStyle.BuiltInName): IStyle.INamed;
        /** {@inheritDoc IStyleCollection.getCustomNamed} */
        getCustomNamed(): IStyle.INamed[];
        /** {@inheritDoc IStyleCollection.setNamed} */
        setNamed(modifiers: IStyle.NamedUpdate, mergeIfExists?: boolean): IStyle.INamed;
        protected _setCustomCellStyleInternal(modifiers: IStyle.NamedUpdate, mergeIfExists?: boolean, _i?: number | null): IStyle.INamed;
        protected _setCustomTableStyleInternal(name: string, properties: ITableStyle.ResolvableProperties): ITableStyle;
        protected _hideOrRemoveNamed(style: IStyle.INamed | string): boolean;
        /** {@inheritDoc IStyleCollection.getTableStyle} */
        getTableStyle(name: string): ITableStyle | null;
        /** {@inheritDoc IStyleCollection.getCustomTableStyles} */
        getCustomTableStyles(): ITableStyle[];
        /** {@inheritDoc IStyleCollection.setDefaultTableStyle} */
        setDefaultTableStyle(styleName: string): boolean;
        /** {@inheritDoc IStyleCollection.getDefaultTableStyle} */
        getDefaultTableStyle(): ITableStyle;
        protected _deleteCustomTableStyle(styleName: string): boolean;
        /** {@inheritDoc IStyleCollection.setCustomTableStyle} */
        setCustomTableStyle(name: string, properties: ITableStyle.ResolvableProperties): ITableStyle;
        /** {@inheritDoc IStyleCollection.validateStyleName} */
        validateStyleName(name: string, checkDuplicates?: boolean): void;
        /** {@inheritDoc IStyleCollection.normalize} */
        normalize(values: IStyle.Modifiers, name?: string): Partial<IStyle.Properties>;
        /** {@inheritDoc IStyleCollection.schemeLookup} */
        schemeLookup(): IColor.SchemeLookup;
        /** {@inheritDoc IStyleCollection.indexedLookup} */
        indexedLookup(): IColor.IndexedLookup;
        /** {@inheritDoc IStyleCollection.parseColor} */
        parseColor(str: string): IColor;
        /** {@inheritDoc IStyleCollection.recentColors} */
        recentColors(): readonly IColor[];
        /** {@inheritDoc IStyleCollection.addRecentColor} */
        addRecentColor(color: IColor): readonly IColor[];
        /** {@inheritDoc IStyleCollection.clearRecentColors} */
        clearRecentColors(): void;
        /** {@inheritDoc IStyleCollection.getIndexedColors} */
        getIndexedColors(): readonly IColor[];
        /** {@inheritDoc IStyleCollection.setCustomIndexedColors} */
        setCustomIndexedColors(colors: readonly IColor[]): void;
        /** {@inheritDoc IStyleCollection.getCustomIndexedColors} */
        getCustomIndexedColors(): readonly IColor[];
        /** {@inheritDoc IListener.ISource.addListeners} */
        addListeners(listeners: IStyleCollection.IListeners, options?: IListener.Options): IListener.Remove;
        protected _toJSONInternal(jsonSheetStyleShared: IStyle.JSON[]): IStyleCollection.JSON;
        protected _fromJSONIndexedColors(indexedColors: string[]): IColor[];
        protected _fromJSONInternal(json: IStyleCollection.JSON): void;
    }
}
declare module "style/index" {
    export * from "style/IStyle";
    export * from "style/IStyleCollection";
    export * from "style/StyleCollection";
}
declare module "sort/ISort" {
    import type { ScalarType, Scalar, IRange } from '@sheetxl/primitives';
    import type { IStyle } from "style/index";
    /**
     * Types used for sorting.
     */
    export namespace ISort {
        /**
         * Default collators for sorting.
         */
        const SortOn: {
            readonly Value: "value";
            readonly FillColor: "fillColor";
            readonly FontColor: "fontColor";
            readonly Icon: "icon";
        };
        type SortOn = typeof SortOn[keyof typeof SortOn];
        /**
         * A collator for a Scalar of a specific type.
         *
         * @remarks
         * Sorting supports sorting across multiple data types. Each collator
         * will have a type.
         */
        interface Collator {
            /**
             * The `ScalarType` that this collator can understand or a 'string' that represent the
             * type for `ScalarType.RichData;
             */
            type: ScalarType | string;
            /**
             * Used for sorting. Equal values and `null` values are presorted and
             * do not need to be handled in the collator implementation.
             *
             * @param options `defaultOptions` with any user overrides.
             *
             * @remarks
             * * Options defined in defaultOptions with any user overrides are passed as the options.
             */
            compare: (a: Scalar, b: Scalar, options?: Intl.CollatorOptions) => number;
            /**
             * The options passed to the collator.
             */
            defaultOptions?: Intl.CollatorOptions;
        }
        interface Criteria {
            /**
             * Determines whether to reverse the default sort order.
             *
             * @defaultValue false - (sorts in the default order, typically ascending)
             *
             * @remarks
             * The `reverse` flag flips the sort order. When set to `true`, the sort will
             * be performed in reverse order compared to the default (which is usually ascending).
             *
             * This flag is data-type agnostic, meaning it will reverse the default order
             * regardless of whether the data is numeric, alphabetic, or complex (e.g., booleans, lists).
             *
             * Example usage:
             * ```ts
             * const options: ISort.Options = {
             *   reverse: true, // Sorts in descending order (for numbers/alphabetic)
             * };
             * ```
             */
            reverse?: boolean;
            /**
             * Additional options for sorting.
             *
             * @remarks
             * * Excel has a matchCase flag but we use Intl.CollatorOptions
             * * Excel has  Normal | 'TextAsNumber' but we use Intl.CollatorOptions
             */
            collatorOptions?: Record<ScalarType, Intl.CollatorOptions> | Intl.CollatorOptions;
            /**
             * Only value is currently supported
             */
            sortOn?: SortOn;
            /**
             * Used with sortOn === Icon
             * @remarks
             * **PLACEHOLDER** - This is a placeholder for future use.
             */
            iconSet?: IStyle.IconSet;
            /**
             * Used with sortOn === Icon
             * @remarks
             * **PLACEHOLDER** - This is a placeholder for future use.
             */
            iconId?: number;
            /**
             * Used with sortOn === cellColor or fontColor
             *
             * @remarks
             * **PLACEHOLDER** - This is a placeholder for future use.
             */
            dxfId?: any;
            /**
             * Sort by a custom list.
             * @remarks
             * **PLACEHOLDER** - This is a placeholder for future use.
             */
            customList?: string;
        }
        interface Field extends Criteria {
            /**
             * 0-based offset for the header based on orientation
             *
             * @defaultValue The first index of the selected range
             */
            offset: number;
        }
        /**
         * Options for sorting with a filter.
         *
         * @remarks
         * This is very similar to a range sort but with a few less options.
         */
        interface Options extends ISort.Criteria {
            /**
             * Allows you to override individual sorts for each additional level.
             * All sort criteria default to the sort criteria specified on the sort option.
             */
            fields?: (number | ISort.Field)[];
            /**
             * 0-based offset for the header based on orientation
             *
             * @defaultValue The first index of the selected range
             */
            offset?: number;
        }
        /**
         * Shows a list of options that will be used for the current sort unless overridden.
         */
        interface DefaultSortCriteria {
            /**
             * The cords that will be sorted.
             * This will include headers even if the are ignored.
             */
            coords: IRange.Coords;
            /**
             * Options to pass to sort.
             */
            options: ISort.RangeOptions;
            /**
             * If headers The map will contain the offset as a key by the value as string.
             *
             * @remarks
             * If no headers are found this will be empty.
             */
            headers: Map<number, string>;
            /**
             * The coords without any headers.
             */
            sortCoords: IRange.Coords;
        }
        /**
         * Extends sort options to include options for sorting a range.
         *
         * @remarks
         * This include orientation, hasHeader, and includeHidden.
         */
        interface RangeOptions extends ISort.Options {
            /**
             * Indicate the orientation to sort.
             *
             * @defaultValue ICellRange.Orientation.Row
             */
            orientation?: IRange.Orientation;
            /**
             * Indicate if the sort has a header. If the sort has a head this will be ignored.
             *
             * @defaultValue Use data to make a 'guess'
             */
            hasHeader?: boolean;
            /**
             * Determine if sort should include values that are hidden.
             *
             * @defaultValue false
             */
            includeHidden?: boolean;
            /**
             * Override the collators used.
             *
             * @defaultValue Sort.DefaultCollators
             */
            collators?: readonly ISort.Collator[];
        }
    }
}
declare module "sort/Sort" {
    import { ISort } from "sort/ISort";
    /**
     * Contains types for {@link ISort}.
     */
    export namespace Sort {
        const CaseInsensitiveOptions: Intl.CollatorOptions;
        const CaseSensitiveOptions: Intl.CollatorOptions;
        /**
         * For comparing `boolean` cell types.
         */
        const BooleanCollator: ISort.Collator;
        /**
         * For comparing `string` `ScalarTypes`.
         */
        const StringCollator: ISort.Collator;
        /**
         * For comparing `number` `ScalarTypes`.
         *
         * @remarks
         * This will include dates.
         */
        const NumberCollator: ISort.Collator;
        /**
         * For comparing `RichData` `ScalarTypes`.
         *
         * @remarks
         * **PARTIAL IMPLEMENTATION**
         */
        const RichDataCollator: ISort.Collator;
        /**
         * Default {@link ISort.RangeOptions}.
         */
        const DefaultRangeOptions: ISort.RangeOptions;
        /**
         * The default sorting for mixed ScalarTypes.
         */
        const DefaultCollators: readonly ISort.Collator[];
    }
}
declare module "sort/index" {
    export * from "sort/ISort";
    export * from "sort/IAutoSort";
    export * from "sort/Sort";
}
declare module "cellRange/ICellHeaderRange" {
    import type { IRange } from '@sheetxl/primitives';
    import type { RunCoords, ReferenceableClipboard } from '@sheetxl/utils';
    import type { ITransaction } from "transaction/index";
    import type { ICellHeader } from "cell/index";
    import type { ICellRange } from "cellRange/ICellRange";
    /**
     * Represents a collection of ICellHeaders.
     */
    export interface ICellHeaderRange {
        /**
         * The RunCoords for the range.
         */
        getCoords(): ICellHeaderRange.Coords;
        /**
         * Iterate over cells headers.
         *
         * @remarks
         * * Callbacks can return a 'break' value to stop the visit.
         */
        forEach<T = any>(callback: ICellHeaderRange.ForEachCallback<T>, options?: ICellHeaderRange.IteratorOptions): T | void;
        /**
         * Returns the header at a location relative to the range.
         *
         * @param index
         */
        at(index: number): ICellHeader;
        /**
         * Set the size of the headers.
         *
         * @param size This can be a number of a string with units
         * @param options {@link ICellHeaderRange.SetSizeOptions}
         */
        setSize(size?: number | string, options?: ICellHeaderRange.SetSizeOptions): this;
        /**
         * Hides or show the columns for the given range.
         *
         * @defaultValue false
         */
        setHidden(hidden?: boolean): this;
        /**
         * Provides a convenient method for setting values with a range of calls.
         *
         * @remarks
         * If an array is provided then values will be in row-major order and will
         * repeat if the range is larger than the array
         */
        updateHeaders(values: ICellHeader.Update, options?: ICellHeaderRange.UpdateHeadersOptions): this;
        /**
         * Returns the data ranges for headers that contain information.
         *
         * @remarks
         * * This is NOT the last cell that may have data or has been resized.
         * * This also has nothing to do with the selection bounds.
         */
        getUsedRange(options?: ICellHeaderRange.GetRangeOptions): this;
        /**
         * Clear the header format. Specially this will clear the sizes.
         */
        clear(): this;
        /**
         * Returns the number of headers included in the range.
         */
        getCount(): number;
        /**
         * Returns the number of headers.
         */
        getHeaderCount(): number;
        /**
         * Returns the number of visible headers in the range.
         */
        getVisibleCount(): number;
        /**
         * Returns true if the range represents all headers.
         */
        isEntireHeaders(): boolean;
        /**
         * Returns the header orientation.
         */
        getOrientation(): IRange.Orientation;
        /**
         * Similar to {@link forEach} but only spans that are different.
         *
         * @remarks
         * * Callbacks can return a 'break' value to stop the visit.
         */
        forEachSpan<T = any>(callback: ICellHeaderRange.ForEachSpanCallback<T>, options?: ICellHeaderRange.IteratorOptions): T | void;
        /**
         * Visits visible spans.
         *
         * @remarks
         * * If there are no hidden headers this will still be called once.
         */
        forEachVisibleSpan<T = any>(callback: ICellHeaderRange.ForEachVisibleSpanCallback<T>, options?: ICellHeaderRange.ForEachVisibleSpanOptions): T | void;
        /**
         * {@inheritDoc ICellRange.getSnapshot}
         */
        getSnapshot(options?: ICellHeaderRange.CopyOptions): ICellHeaderRange.ISnapshot;
        /**
         * Perform operation on all ranges.
         *
         * @see
         * {@link ICellRange.doBatch}
         */
        doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ICellHeaderRange.UpdateHeadersOptions): R | Promise<R>;
        /**
         * Returns the SheetHeader.
         */
        getSheetHeader<S>(): S;
        /**
         * {@inheritDoc ICellRange.getA1}
         */
        getA1(): string;
        /**
         * Returns the address as a string.
         */
        toString(): string;
        /**
         * For runtime type checking.
         */
        readonly isICellHeaderRange: true;
    }
    /**
     * {@inheritDoc ICellHeaderRange}
     * @see
     * ### **Interface**
     *
     * {@link ICellHeaderRange}
     */
    export namespace ICellHeaderRange {
        /**
         * The coord type for a header range.
         */
        type Coords = RunCoords;
        /**
         * Specify either a range a run or a string.
         * @remarks
         * If the value is a string it will be parse as an a1 style address if it is a number it will be a zero based index.
         */
        type Address = Partial<IRange.Coords> | RunCoords | string | number;
        /**
         * Callback used for visiting a cells headers. If break is returned the visiting will stop with the
         * break value returned.
         *
         * The context allows for the retrieval of additional information associated with the Cell include the
         * {@link ICellHeader} object.
         */
        interface ForEachCallback<T = any> {
            (size: number, context: ICellHeaderRange.CellHeaderContext): {
                break: T;
            } | void;
        }
        interface IteratorOptions {
            /**
             * The address for the range.
             */
            address?: ICellHeaderRange.Address;
            /**
             * Include all headers even empty ones.
             * @defaultValue false
            */
            includeEmpty?: boolean;
            /**
             * Only include if the size is set and different from the default.
             * @defaultValue false
            */
            includeSizes?: boolean;
            /**
             * Include headers that have custom styling.
             * @defaultValue false
             * @deprecated We are removing styles from headers (but will need in sheet for backward compatibility with Excel)
             */
            includeStyles?: boolean;
            /**
             * When scanning skip cells that are hidden via headers.
             * @defaultValue false
             * @remarks
             * optionally a header orientation for skipping case be passed in.
             * An example of this is for sorting where the sort direction (row) skips hidden rows but the column direction does not.
             */
            ignoreHidden?: boolean;
        }
        /**
         * Context for Iterators to provide access to the `IRange.CellCoords`, the `ICellHeader`, and additional operators.
         */
        interface CellHeaderContext {
            /**
             * Returns the index for the header
             */
            getIndex(): number;
            /**
             * Returns the CellHeader.
             */
            getCellHeader(): ICellHeader;
            /**
             * Utility method to return the offset as an A1 string.
             */
            getA1(offset?: number): string;
            /**
             * Returns the coords for the header.
             */
            getCoords(): RunCoords;
        }
        /**
         * Simple type to pairs an address with an update value.
         */
        interface AddressUpdatePair {
            /**
             * Allows for either a Cell or a Range.
             */
            address?: ICellHeaderRange.Address;
            /**
             * If null will clear the value.
             */
            update: ICellHeader.Update;
        }
        interface ForEachSpanCallback<T = any> {
            (size: number, context: ICellHeaderRange.CellHeaderContext): {
                break: T;
            } | void;
        }
        interface ForEachVisibleSpanCallback<T = any> {
            (min: number, max: number): {
                break: T;
            } | void;
        }
        interface ForEachVisibleSpanOptions {
            includeHidden?: boolean;
        }
        interface GetRangeOptions {
        }
        /**
         * Options for copying ICellHeaderRange.
         */
        interface CopyOptions extends ICellRange.SetValuesOptions, ReferenceableClipboard.CopyOptions {
            /** {@inheritDoc ICellRange.CopyOptions.fitDestination} */
            fitDestination?: boolean;
        }
        /**
         * Options for `updateHeaders`.
         */
        interface UpdateHeadersOptions extends ITransaction.OperationOptions {
            /**
             * If this is set to `true` then any headers that have custom sizes will be ignored.
             * @defaultValue false
             */
            skipCustomSize?: boolean;
        }
        /**
         * Options for `setSize`.
         */
        interface SetSizeOptions extends ITransaction.OperationOptions {
            /**
             * Sets if the size value is interpret as absolute or relative.
             * @defaultValue false
             *
             * @remarks
             * Rows and columns sizes are managed internally as relative size to the normal styling font size.
             * This is done to allow for the sizes to auto adjustment when the style changes.
             *
             * If the value is a number then the size is interpreted as relative size.
             *
             * If the size is set using a string that ends in 'px' This option will be ignored.
             *
             * @see
             * * {@link ICellHeader.getSizeRelative()}
             * * {@link https://support.microsoft.com/en-us/office/change-the-column-width-and-row-height-72f5e3cc-994d-43e8-ae58-9774a0905f46}
             */
            relativeSize?: boolean;
            /**
             * If this is set to `true` then the value will not be an autoSize value.
             *
             * @defaultValue false
             */
            autoSize?: boolean;
            /**
             * If this is set to `true` then any headers that have custom sizes will be ignored.
             *
             * @defaultValue false
             */
            skipCustomSize?: boolean;
        }
        /**
         * A snapshot of a header to use for laster copying.
         */
        interface ISnapshot<T = any> {
            /**
             * Called when the item is copied to a new header range.
             */
            copyTo(range: ICellHeaderRange, options?: ICellHeaderRange.CopyOptions): Promise<RunCoords> | RunCoords;
            /**
             * The RunCoords that bounds the current item.
             */
            getCoords?(): RunCoords;
            /**
             * Allow items to be copied as text.
             */
            toText?(): Promise<string> | string;
            /**
             * Allow items to be copied as html.
             */
            toHtml?(): Promise<string> | string;
            /**
             * Allow items to be copied as an image Blob.
             */
            toImage?(): Promise<Blob> | Blob;
            /**
             * The source that created the snapshot.
             * This is used by copy to quickly do comparisons.
             */
            getSource(): T;
            /**
             * A user friendly name of a the snapshot item.
             */
            getName?(): string;
            /**
             * For runtime type checking.
             */
            readonly isISnapshot: true;
        }
    }
}
declare module "cellRange/ICellHeaderRanges" {
    import type { IRange } from '@sheetxl/primitives';
    import type { RunCoords } from '@sheetxl/utils';
    import type { ITransaction } from "transaction/index";
    import type { ICellHeader } from "cell/index";
    import type { ICellHeaderRange } from "cellRange/ICellHeaderRange";
    /**
     * An `ICellHeaderRanges` is a collection of {@link ICellHeaderRange}s.
     *
     * Useful when working with a discontinuous set of headers.
     */
    export interface ICellHeaderRanges {
        /**
         * The RunCoords for the range.
         */
        getCoords(): Readonly<ICellHeaderRanges.Coords>;
        /**
         * Returns the header range at a location relative to the range.
         *
         * @param index
         */
        at(index: number): ICellHeaderRange;
        /**
         * Returns the number of headers ranges.
         */
        getCount(): number;
        /**
         * {@inheritDoc ICellHeaderRange.setSize}
         */
        setSize(size?: number | string, options?: ICellHeaderRange.SetSizeOptions): this;
        /**
         * {@inheritDoc ICellHeaderRange.setHidden}
         */
        setHidden(hidden?: boolean): this;
        /**
         * {@inheritDoc ICellHeaderRange.clear}
         */
        clear(): this;
        /**
         * Returns the number of headers.
         *
         * @remarks
         * This will remove overlaps.
         */
        getHeaderCount(): number;
        /**
         * {@inheritDoc ICellHeaderRange.getVisibleCount}
         */
        getVisibleCount(): number;
        /**
         * Returns true if all of the ranges cover the entire headers.
         */
        isEntireHeaders(): boolean;
        /**
         * Returns true if any of the ranges cover entire headers.
         */
        isEntireHeadersAny(): boolean;
        /**
         * {@inheritDoc ICellHeaderRange.getOrientation}
         */
        getOrientation(): IRange.Orientation;
        /**
         * {@inheritDoc ICellHeaderRange.updateHeaders}
         */
        updateHeaders(values: ICellHeader.Update, options?: ICellHeaderRange.UpdateHeadersOptions): this;
        /**
         * {@inheritDoc ICellHeaderRange.doBatch}
         */
        doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ICellHeaderRange.UpdateHeadersOptions): R | Promise<R>;
        /**
         * {@inheritDoc ICellHeaderRange.getSheetHeader}
         */
        getSheetHeader<S>(): S;
        /**
         * {@inheritDoc ICellHeaderRange.getA1}
         */
        getA1(): string;
        /**
         * {@inheritDoc ICellHeaderRange.toString}
         */
        toString(): string;
        /**
         * For runtime type checking.
         */
        readonly isICellHeaderRanges: true;
    }
    /**
     * {@inheritDoc ICellHeaderRanges}
     * @see
     * ### **Interface**
     *
     * {@link ICellHeaderRanges}
     */
    export namespace ICellHeaderRanges {
        /**
         * The coord type for a header ranges.
         */
        type Coords = RunCoords[];
        /**
         * Address for multiple {@link ICellHeaderRange}s.
         */
        type Address = ICellHeaderRanges | string | ICellHeaderRange.Address | readonly ICellHeaderRange.Address[];
        /**
         * Shorthand for persisting.
         */
        type RefJSON = RunCoords[] | RunCoords | string;
    }
}
declare module "cellRange/ICellRanges" {
    import type { Scalar, IRange } from '@sheetxl/primitives';
    import type { IListener } from "listener/index";
    import type { ITransaction } from "transaction/index";
    import type { IStyle } from "style/index";
    import type { ICell } from "cell/index";
    import type { ISheet } from "sheet/index";
    import type { ICellRange } from "cellRange/ICellRange";
    import type { ICellHeaderRange } from "cellRange/ICellHeaderRange";
    import type { ICellHeaderRanges } from "cellRange/ICellHeaderRanges";
    /**
     * An `ICellRanges` is a collection of {@link ICellRange}s.
     *
     * Useful when working with a discontinuous set of ranges.
     */
    export interface ICellRanges {
        /**
         * {@inheritDoc ICellRange.getMerges}
         */
        getMerges(): IRange.Coords[];
        /**
         * {@inheritDoc ICellRange.getSheet}
         */
        getSheet(): ISheet;
        /**
         * Returns the style for the range.
         *
         * @remarks
         * When querying the style the values will always be for the top left. However the
         * set values work for the entire range.
         */
        getStyle(): IStyle;
        /**
         * {@inheritDoc ICellRange.find}
         */
        find(options: string | ICellRange.FindOptions): Iterator<ICell>;
        /**
         * Iterates over the values, yielding each values in the collection.
         *
         * @remarks
         * This does not iterate over the ranges but rather the individual cells within the ranges.
         * @see {@link ICellRanges.entries()}
         */
        [Symbol.iterator](): IterableIterator<Scalar>;
        /**
         * Returns an iterator that allows you to iterate over the individual cells within the ranges,
         * yielding pairs of `IteratorContext` and a `Value`.
         *
         * @param options Configuration options for the iterator, such as filtering or sorting.
         * @returns An iterator that yields `[ICell.IteratorContext, Value]` tuples for each value within the range.
         *
         * @remarks
         * If the ranges overlap this will return the same value multiple times. If each cell
         * should only be visited once, use {@link ICellRanges.getFlattened} to remove overlaps.
         */
        entries(options?: ICellRange.IteratorOptions): IterableIterator<ICellRange.Entry>;
        /**
         * {@inheritDoc ICellRange.autoFit}
         */
        autoFit(options?: ICellRange.AutoFitOptions): this;
        /**
         * {@inheritDoc ICellRange.calculate}
         */
        calculate(fullRecalc?: boolean): this;
        /**
         * {@inheritDoc ICellRange.clear}
         */
        clear(applyTo?: ICell.Content, options?: ITransaction.OperationOptions): this;
        /**
         * {@inheritDoc ICellRange.merge}
         */
        merge(options?: IRange.Orientations | ICellRange.MergeOptions): this;
        /**
         * {@inheritDoc ICellRange.unmerge}
         */
        unmerge(options?: ITransaction.OperationOptions): this;
        /**
         * {@inheritDoc ICellRange.insert}
         */
        insert(options?: IRange.Orientation | ICellRange.InsertOptions): this;
        /**
         * {@inheritDoc ICellRange.delete}
         */
        delete(options?: IRange.Orientation | ICellRange.DeleteOptions): this;
        /**
         * {@inheritDoc ICellRange.insertFrom}
         */
        insertFrom(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions): Promise<this | null>;
        /**
         * Returns a `ICellRange.ISnapshot` for all of the ranges.
         *
         * @remarks
         * * This will fail if the ranges are not 'aligned'.
         * @see
         * {@link ICellRange.getSnapshot}
         */
        getSnapshot(options?: ICellRange.CopyOptions): ICellRange.ISnapshot;
        /**
         * {@inheritDoc ICellRange.copyFrom}
         */
        copyFrom(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions): Promise<this | null>;
        /**
         * {@inheritDoc ICellRange.getEntireRows}
         */
        getEntireRows(shiftColumns?: boolean, options?: ICellRange.GetRangeOptions): this;
        /**
         * {@inheritDoc ICellRange.getEntireColumns}
         */
        getEntireColumns(shiftRows?: boolean, options?: ICellRange.GetRangeOptions): this;
        /**
         * {@inheritDoc ICellRange.getRowHeaders}
         */
        getRowHeaders(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
        /**
         * {@inheritDoc ICellRange.getColumnHeaders}
         */
        getColumnHeaders(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
        /**
         * {@inheritDoc ICellRange.getDefaultShiftOrientation}
         */
        getDefaultShiftOrientation(): IRange.Orientation;
        /**
         * Returns a set of ranges with overlaps removed and attempts to merge adjacent ranges into larger ranges.
         *
         * @remarks
         * By default, ranges will also be merged into larger ranges where possible, but this behavior can be customized using the `mergeOrientation` parameter.
         * This method will not modify the original ranges.
         * @see
         * {@link isOverlapping}
         */
        getFlattened(options?: ICellRange.GetFlattenOptions): this;
        /**
         * {@inheritDoc ICellRange.getVisible}
         */
        getVisible(options?: ICellRange.GetVisibleOptions): this | null;
        /**
         * {@inheritDoc ICellRange.getA1}
         */
        getA1(): string;
        /**
         * {@inheritDoc ICellRange.getCounts}
         */
        getCounts(types?: Partial<Record<ICell.Content, number | boolean>>): ICellRange.Counts | null;
        /**
         * {@inheritDoc ICellRange.isContentful}
         */
        isContentful(types?: ICell.Content | ICell.Content[]): boolean;
        /**
         * Returns the count for all rows in the ranges. This will ensure rows that are included in multiples ranges are
         * not double counted.
         */
        getRowCount(): number;
        /**
         * Returns the count for all columns in the ranges. This will ensure columns that are included in multiples ranges are
         * not double counted.
         */
        getColumnCount(): number;
        /**
         * {@inheritDoc ICellRange.isReadOnly}
         */
        isReadOnly(): boolean;
        /**
         * Returns a flag indicating if any of the ranges are overlapping.
         *
         * @remarks
         * To get a range with no overlaps {@link ICellRanges.getFlattened} can be used.
         */
        isOverlapping(): boolean;
        /**
         * Returns `true` if all of the the ranges have selected all of the rows.
         *
         * @remarks
         * This is different from `isEntireRowsAny` in that it will return `true` if 'ALL' of the
         * ranges have isEntireRows `true`.
         */
        isEntireRows(): boolean;
        /**
         * Returns `true` if any of the ranges have selected all of the rows.
         *
         * @remarks
         * This is different from `isEntireRows` in that it it will return true if 'ANY' of the
         * ranges have isEntireRows `true`.
         */
        isEntireRowsAny(): boolean;
        /**
         * Returns `true` if all of the the ranges have selected all of the columns.
         *
         * @remarks
         * This is different from `isEntireColumnsAny` in that it will return `true` if 'ALL' of the
         * ranges have isEntireColumns `true`.
         */
        isEntireColumns(): boolean;
        /**
         * Returns `true` if any of the ranges have selected all of the columns.
         *
         * @remarks
         * This is different from `isEntireColumns` in that it will return `true` if 'ANY' of the
         * ranges have isEntireColumns `true`.
         */
        isEntireColumnsAny(): boolean;
        /**
         * Returns `true` if any of the ranges are invalid.
         */
        isInvalidAny(): boolean;
        /**
         * Returns a ranges with coordinates adjusted to be fixed (absolute) or flexible (relative).
         *
         * @see
         * {@link ICellRange.getFixed}
         */
        getFixed(options: ICellRange.GetFixedOptions | boolean): this;
        /**
         * Returns the total number of contiguous ranges in this collection.
         */
        getCount(): number;
        /**
         * Returns the range at a specific index.
         *
         * @param index
         */
        at(index: number): ICellRange;
        /**
         * {@inheritDoc ICellRange.doBatch}
         */
        doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ITransaction.OperationOptions): R | Promise<R>;
        /**
         * The RangeCoords.
         */
        getCoords(): readonly Readonly<IRange.FixableCoords>[];
        /**
         * Returns true if the range is invalid.
         * This can occur if a range is removed or created with invalid coordinates.
         */
        isInvalid(): boolean;
        /**
         * Returns the address as a string.
         */
        toString(): string;
        /**
         * {@inheritDoc ICellRange.select}
         */
        select(options?: ICellRange.SelectOptions): Promise<this>;
        /**
         * {@inheritDoc ICellRange.addListener}
         */
        addListener(listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
        /**
         * Returns an iterator that allows you to iterate over the individual values within the range.
         *
         * @param options Configuration options for the iterator, such as filtering or sorting.
         * @returns An iterator that yields `Scalar` value, each representing a single cell within the range.
         */
        [Symbol.iterator](options?: ICellRange.IteratorOptions<any>): Iterator<Scalar>;
        /**
         * For runtime type checking.
         */
        readonly isICellRanges: true;
    }
    /**
     * {@inheritDoc ICellRanges}
     * @see
     * ### **Interface**
     *
     * {@link ICellRanges}
     */
    export namespace ICellRanges {
        /**
         * The coord type for a ranges.
         */
        type Coords = IRange.Coords[];
        /**
         * Address for multiple {@link ICellRange}s.
         */
        type Address = ICellRanges | string | ICellRange.Address | readonly ICellRange.Address[];
        /**
         * Options when visiting a ICellRanges.
         */
        interface IteratorOptions<T = ICellRanges.Address> extends ICellRange.IteratorOptions<T> {
        }
        /**
         * Shorthand for persisting.
         */
        type RefJSON = IRange.Coords[] | IRange.Coords | string;
    }
}
declare module "cellRange/ICellRange" {
    import { type Scalar, type JSScalar, type JSScalarUpdate, IRange } from '@sheetxl/primitives';
    import type { Bounds, ReferenceableClipboard } from '@sheetxl/utils';
    import type { ITypes } from "type/index";
    import type { IListener } from "listener/index";
    import type { ITransaction } from "transaction/index";
    import type { IHyperlink } from "hyperlink/index";
    import type { IComment } from "comment/index";
    import type { ISort } from "sort/index";
    import type { IAutoFill } from "autoFill/index";
    import type { IStyle } from "style/index";
    import { ISheet } from "sheet/index";
    import { ICell } from "cell/index";
    import type { ICellRanges } from "cellRange/ICellRanges";
    import type { ICellHeaderRange } from "cellRange/ICellHeaderRange";
    /**
     * A {@link ICellRange} represents a rectangular collection of {@link ICell}
     * within an {@link ISheet}.
     *
     * **Naming Conventions:** Methods usually adhere to the following conventions except
     * when adhering to a idiomatic existing conventions of Typescript (for example `size` or 'length'):
     *
     * - Methods returning information about the range (e.g., width, count) use a `get` prefix.
     * - Methods that transform the range's data into a different type use a `to` prefix (e.g., `toArray()`).
     */
    export interface ICellRange {
        /**
         * Return an array of coords for all merges.
         *
         * * @returns A array of 'IRange.Coords` that contain merges.
         */
        getMerges(): IRange.Coords[];
        /**
         * Returns a cell in the range.
         *
         * @param address The address of the cell to retrieve. This must be within the range bounds. Default Value the 'top left'
         *
         * @see
         * {@link ICellRange.getCells}
         */
        getCell(address?: ICell.Address): ICell;
        /**
         * Return a 2D array of {@link ICell | cells} in the shape of the range.
         *
         * @param options {@link ICellRange.GetValuesOptions}
         * @returns A 2D array of {@link ICell}s.
         *
         * @remarks
         * * Empty values will be `null`.
         * * {@link ICellRange.GetValuesOptions.asJSDate} is ignored; use {@link ICell.asDate()} when working with {@link ICell}.
         */
        getCells(options?: ICellRange.GetValuesOptions): ICell[][];
        /**
         * Returns the value for the top left `Scalar`.
         *
         * @remarks
         * The `ignoreHidden` option is ignored.
         *
         * @see
         * {@link ICellRange.getValues}
         */
        getValue(options?: ICellRange.GetValuesOptions): Scalar | JSScalar;
        /**
         * Returns the style for the ranges.
         *
         * @see
         * {@link ICellRange.getStyle}
         */
        getStyle(): IStyle;
        /**
         * Returns the intersection of the current range and the specified range.
         *
         * @param address The address of the other range to intersect with..
         * @returns `ICellRange` at the intersection of the two ranges, or `null` if there's no overlap.
         */
        getIntersect(address?: ICellRange.Address, options?: ICellRange.GetRangeOptions): this | null;
        /**
         * Returns the union of the current range with the specified range.
         *
         * @param address The address of the other range to intersect with.
         * @returns `ICellRange` at the union of the two ranges.
         */
        getUnion(address?: ICellRange.Address, options?: ICellRange.GetRangeOptions): this;
        /**
         * Returns a set of non-overlapping ranges the represents the difference between the current
         * range and the specified range.
         *
         * @param address The address of the range to subtract from the current range.
         * @returns `ICellRanges` containing the resulting non-overlapping ranges,
         * or `null` if:
         *   - There is no intersection between the current range and the specified address.
         *   - The specified address is the same as or encompasses the current range.
         *
         * @remarks
         * - The method will always return between 0 and 4 ranges.
         * - If there's no intersection, it returns an `ICellRanges` containing only the current range.
         */
        getDifferences(address: ICellRange.Address, options?: ICellRange.GetRangeOptions): ICellRanges | null;
        /**
         * Returns a range that includes the columns for the entire sheet.
         * For example, if the range is `A1:B2`, this method will return `A:B`.
         *
         * @param shift If `true` this will also shift the columns by the width of the range. default `false`.
         * @param options Additional options for getting the range.
         * @returns `ICellRange` at the repositioned range.
         */
        getEntireColumns(shift?: boolean, options?: ICellRange.GetRangeOptions): this;
        /**
         * Returns a range that includes the rows for the entire sheet.
         * For example, if the range is `A1:B2`, this method will return `1:2`.
         *
         * @param shift If `true` this will also shift the rows by the height of the range.  default `false`.
         * @param options Additional options for getting the range.
         * @returns `ICellRange` at the repositioned range.
         */
        getEntireRows(shift?: boolean, options?: ICellRange.GetRangeOptions): this;
        /**
         * Returns a range that includes the current range up to a content edge boundary.
         *
         * @param direction The direction.
         * @param cell The cell to use as a starting point.
         *               If not provide the cell closest to the edge will be used.
         * @returns `ICellRange` extended in the given direction.
         */
        getExtended(direction: IRange.Direction, cell?: ICell.Address): this;
        /**
         * Returns a range with coordinates adjusted to be fixed (absolute) or flexible (relative).
         *
         * @param options Either a {@link ICellRange.GetFixedOptions} object to
         *                  specify individual coordinate settings, or a `boolean`
         *                  to adjust all coordinates at once. If a `boolean` is provided:
         *                  - `true` sets all coordinates to absolute.
         *                  - `false` sets all coordinates to relative.
         * @returns `ICellRange` with updated coordinate references types.
         *
         * @remarks
         * If no `options` are provided, this method toggles the fixed flags for the range's coordinates
         * based on their current settings. Calling this repeatedly will cycle between relative and absolute references.
         * For example: `A1` → `$A$1` → `A$1` → `$A1` → `A1`
         */
        getFixed(options?: ICellRange.GetFixedOptions | boolean): this;
        /**
         * Returns a range with the top-left corner moved by the specified row and column offsets.
         *
         * @param rowDelta The number of rows to move the top-left corner up (negative) or down (positive).
         * @param colDelta The number of columns to move the top-left corner left (negative) or right (positive).
         * @returns `ICellRange` at the repositioned range.
         */
        getOffsetBy(rowDelta: number, colDelta: number, options?: ICellRange.GetRangeOptions): this;
        /**
         * Returns a range repositioned to the specified starting row and column indices.
         *
         * @param rowStart The new starting row index (inclusive).
         * @param colStart The new starting column index (inclusive).
         * @returns `ICellRange` at the repositioned range.
         */
        getOffsetTo(rowStart: number, colStart: number, options?: ICellRange.GetRangeOptions): this;
        /**
         * Returns a range with the bottom-right corner moved by the specified row and column offsets.
         *
         * @param rowDelta The number of rows to move the bottom-right corner up (negative) or down (positive).
         * @param colDelta The number of columns to move the bottom-right corner left (negative) or right (positive).
         * @returns `ICellRange` with the resized range.
         */
        getResizeBy(rowDelta: number, colDelta: number, options?: ICellRange.GetRangeOptions): this;
        /**
         * Resizes the current range to the specified ending row and column indices.
         *
         * @param rowEnd The new ending row index (inclusive).
         * @param colEnd The new ending column index (inclusive).
         * @returns `ICellRange` with the resized range.
         */
        getResizeTo(rowEnd: number, colEnd: number, options?: ICellRange.GetRangeOptions): this;
        /**
         * Returns a range with surrounding data or the entire range if there is no data nearby.
         *
         * @returns `ICellRange` containing either nearby content or the entire range.
         */
        getSurrounding(options?: ICellRange.GetSurroundingOptions): this;
        /**
         * Returns the smallest range within the range that contains any used cells.
         *
         * This method returns the range of cells that have been "used," which includes cells with data,
         * as well as certain types of formatting or styling. It focuses on cells that have been interacted with
         * in some form, whether through data entry or other modifications. Merged cells and overflow values
         * may not always be included in this range.
         *
         * @returns `ICellRange` that contains the smallest range with used cells, or `null` if the range is empty.
         */
        getUsedRange(options?: ICellRange.GetRangeOptions): this | null;
        /**
         * Returns a range that excludes any hidden rows or columns.
         *
         * @param options Optional parameters that can adjust how visibility is determined (e.g., by ignoring specific visibility rules).
         * @returns An `ICellRanges` object that contains the visible portions of the range, excluding any hidden rows or columns.
         *
         * @remarks
         * - If all ranges within the original selection are visible, this method returns an `ICellRanges` object with a single range and a length of `1`.
         * - If the entire range is hidden, the method will return `null`.
         * - The resulting ranges reflect the currently visible state of the sheet, including hidden rows, columns, or headers.
         */
        getVisible(options?: ICellRange.GetVisibleOptions): ICellRanges | null;
        /**
         * Returns the header range for the rows.
         *
         * @returns `ICellHeaderRange` for the rows.
         */
        getRowHeaders(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
        /**
         * Returns the header range for the columns.
         *
         * @returns `ICellHeaderRange` for the columns.
         */
        getColumnHeaders(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
        /**
         * Returns the default shift {@link IRange.Orientation} for {@link insert} and {@link delete}
         * if no orientation is provided.
         *
         * @returns Default `IRange.Orientation` that will be used to shift the range.
         * @remarks
         * By default the direction of the shift will be the direction that shifts the fewest cells. If
         * the range is the same size in both directions `IRange.Orientation.Row` will be used.
         *
         * For example, a range with 5 columns and 1 row will have a default orientation of `IRange.Orientation.Row`.
         */
        getDefaultShiftOrientation(): IRange.Orientation;
        /**
         * Returns a default sort that would be used if no overrides where provided.
         *
         * @param orientation The orientation to sort. Default Value `IRange.Orientation.Row`.
         * @param cell A cell location that can be used to determine the sort column.
         * @returns Default `ISort.DefaultSortCriteria` or `null` if there is not valid sort criteria.
         *
         * @remarks
         * Useful for displaying options to the ui. The default behavior will look for headers and
         * merges.
         */
        getDefaultSortCriteria(orientation?: IRange.Orientation, cell?: ICell.Address): ISort.DefaultSortCriteria | null;
        /**
         * Returns a count for of values.
         */
        getCount(): number;
        /**
         * Returns a record of multiple counts for the given types.
         *
         * @param types The type of content to count. If not specified it will return the context for all content types`
         *
         */
        getCounts(types?: ICell.Content[]): ICellRange.Counts | null;
        /**
         * Returns a 2D array of {@link Scalar | values} in the shape of the range.
         *
         * @param options -
         * - `asJSDate` Return dates as Javascript dates instead of OADates but is slower due to need
         *   to determine if the Cell is a date or a number. See {@link ICell.IteratorContext.toJSDate}.
         *   defaultValue `false`.
         * - `maxSize` Limit the size of the results. defaultValue `10000`.
         *
         * @returns A 2D array of values.
         *
         * @remarks
         * * Empty values will be `null`.
         * * This is faster than {@link getCells} when only the values are needed.
         * * Setting {@link ICellRange.GetValuesOptions.asJSDate} to `true` will add make slower.
         */
        getValues(options?: ICellRange.GetValuesOptions): Scalar[][];
        /**
         * Returns the range value as a string.
         */
        toText(options?: ICellRange.ToTextOptions): string;
        /**
         * Set the value(s) of one or more cells within a range.
         *
         * @param values The value to be set or a callback that will generate a value.
         * @param options {@link ICellRange.SetValuesOptions}
         * @returns The current `ICellRange`.
         *
         * @remarks
         * - `null` values will clear the corresponding cells.
         * - `undefined` values will be ignored, leaving the existing cell values unchanged.
         * - If an array is passed the values will be in row-major order and will repeat if the range is larger than the array
         * - If a single value is passed in it will repeat the entire range.
         */
        setValues(values: ICellRange.ValuesUpdate, options?: ICellRange.SetValuesOptions): this;
        /**
         * Provides a convenient method for setting values with a range of calls.
         *
         * @param update {@link ICellRange.Update}
         * @param options {@link ICellRange.UpdateCellsOptions}
         * @returns The current `ICellRange`.
         *
         * @remarks
         * - **Performance** This is will always be significantly slow than setting attributes
         * use the related range APIs.
         * - For setting non contiguous values see {@link ICellRange.startIncrementalUpdates}
         * @see
         * * {@link updateStyle}
         * * {@link setHyperlink}
         */
        updateCells(update: ICellRange.Update, options?: ICellRange.UpdateCellsOptions): this;
        /**
         * Set a single value to the entire range.
         *
         * @see
         * {@link ICellRange.setValues}
         */
        setValue(value: ICellRange.ValuesUpdateOrCallback, options?: ICellRange.SetValuesOptions): this;
        /**
         * Set the formula for a range.
         *
         * @remarks
         * Identical behavior to setValue. Exists for ergonomics
         * @see
         * {@link ICellRange.setValue}
         */
        setFormula(value: ICellRange.ValuesUpdateOrCallback, options?: ICellRange.SetValuesOptions): this;
        /**
         * Re-evaluates and formulas within the range.
         * @param full If `true` then all formulas will be recalculated.
         */
        calculate(full?: boolean): this;
        /**
         * Fill the range to a destination using an array of {@link IAutoFill.Filler}.
         *
         * @param destination The range to autoFill including the current range.
         * @param options {@link ICellRange.AutoFillOptions}
         * @throws `Error` If the destination range does not overlap with the range on 3 out of 4 sides.
         * @returns `ICellRange` at the destination.
         *
         * @remarks
         * * If the range contains merges then the amount must be a 'fill' dimension must a multiple of the initialRange 'fill' dimension.
         * * The destination range must be the same size as the original with 1 edge adjusted.
         */
        autoFill(destination: ICellRange.Address, options?: ICellRange.AutoFillOptions): this;
        /**
         * Adjusts the column widths and rows heights to fit the content.
         *
         * @param options {@link ICellRange.AutoFitOptions}
         * @returns Current `ICellRange`.
         */
        autoFit(options?: ICellRange.AutoFitOptions): this;
        /**
         * Clear the range.
         *
         * @param applyTo {@link ICell.Content} @defaultValue ICell.Content.Values
         * @param options {@link ITransaction.OperationOptions}
         * @returns Current `ICellRange`.
         */
        clear(applyTo?: ICell.Content, options?: ITransaction.OperationOptions): this;
        /**
         * Set the hyperlink for a range of values.
         *
         * @param hyperlink {@link IHyperlink.Update}
         * @param options {@link ITransaction.OperationOptions}
         * @returns Current `ICellRange`.
         *
         * @remarks
         * To clear hyperlinks either set to `null` or call `clear(ICell.Content.Hyperlinks)`.
         */
        setHyperlink(hyperlink: IHyperlink.Update, options?: ITransaction.OperationOptions): this;
        /**
         * Update the comments for the range.
         *
         * @param comments Comment properties
         * @param options {@link ITransaction.OperationOptions}
         * @returns Current `ICellRange`.
         *
         * @remarks
         * **NOT FINISHED**
         */
        setComments(comments: IComment.Properties, options?: ITransaction.OperationOptions): this;
        /**
         * Merges all cells within the selection ranges.
         *
         * @param options {@link ICellRange.MergeOptions}
         * @returns Current `ICellRange`.
         *
         * @remarks
         * If the ranges overlap then this operation will throw an exception
         */
        merge(options?: IRange.Orientations | ICellRange.MergeOptions): this;
        /**
         * Unmerge all cells within the selection ranges.
         *
         * @param options {@link ITransaction.OperationOptions}
         * @returns Current `ICellRange`.
         */
        unmerge(options?: ITransaction.OperationOptions): this;
        /**
         * Returns an iterator of ICells that match the results.
         *
         * @param options The text to search for or {@link FindOptions}
         */
        find(options: string | ICellRange.FindOptions): Iterator<ICell>;
        /**
         * Sort the given range.
         *
         * @param options `boolean` | {@link ISort.RangeOptions}
         * @returns Current `ICellRange`.
         *
         * @remarks
         * The sorting of various data types has a default priority of of boolean > string > number and dates are treated as numbers.
         * If `true` then the sort is reversed (descending).
         */
        sort(options?: boolean | ISort.RangeOptions & ITransaction.OperationOptions): this;
        /**
         * Insert a new, empty range within the sheet and shifts existing cells to accommodate it.
         *
         * By default the values will direction in whichever direction the selection shape is smaller.
         * For example a selection with a 5 column by 1 row will direction Down (rows).
         * Note - This will error if direction data will fall outsize of the max sheet size.
         * @param options The orientation or The direction in which to shift existing cells.
         *   Defaults to the orientation where the range's dimension is smaller (e.g., shifts down if the range is wider than it is tall).
         *   See {@link ICellRange.getDefaultShiftOrientation} for details on the default behavior.
         *   See {@link ITransaction.OperationOptions}
         * @throws `Error` If the insertion would cause data to exceed the maximum sheet size.
         * @returns Current `ICellRange`.
         */
        insert(options?: IRange.Orientation | ICellRange.InsertOptions): this;
        /**
         * Delete the cells within the range and shifts the remaining cells to fill the gap.
         *
         * @param options The orientation or The direction in which to shift existing cells.
         *   Defaults to the orientation where the range's dimension is smaller (e.g., shifts down if the range is wider than it is tall).
         *   See {@link ICellRange.getDefaultShiftOrientation} for details on the default behavior.
         *   See {@link ITransaction.OperationOptions}
         * @returns Current `ICellRange`.
         *
         * @remarks
         * This is different from clearing cells, which removes their content but doesn't affect the
         * overall sheet structure. Deleting cells results in a shift of the remaining data.
         */
        delete(options?: IRange.Orientation | ICellRange.DeleteOptions): this;
        /**
         * Returns a snapshot of the current range's data and formatting suitable for copying or archiving.
         *
         * @param options Default options to apply during the copy operation.
         * @returns A `ISnapshot` object representing the range.
         *
         * @remarks
         * - **Option Merging:** If options are also provided during the copy operation, the two will be merged
         *   with the copy options taking precedence.
         * - `getSnapshot` can be called multiple times allowing for multiple snapshots.
         */
        getSnapshot(options?: ICellRange.CopyOptions): ICellRange.ISnapshot;
        /**
         * Inserts the contents of the `source` into the sheet, shifting existing cells to make space.
         *
         * @param source The source of the data and formatting to insert.
         *   This can be either a range address, another range object, or an `ISnapshot`
         *   created using the `getSnapshot` method.
         * @param options {@link ICellRange.InsertFromOptions}
         * @returns A promise that resolve to an `ICellRange` or 'null' when the copy has completed.
         *
         * @remarks
         * * Behaves similarly to {@link insert} and {@link copyFrom}, but instead of inserting empty space at the range
         * it also inserts the content of the `source`.
         * * Will return `null` if nothing was inserted or the source doesn't have a range.
         */
        insertFrom(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions): Promise<this | null>;
        /**
         * Copies (or cuts) data and formatting from a specified source to the current range.
         *
         * @param source The source of the data and formatting to be copied or cut.
         *   This can be either a range address, another range object, or an `ISnapshot`
         *   created using the `getSnapshot` method.
         * @param options Additional options for customizing the paste operation (e.g., `transpose`, `skipBlanks`).
         * @returns A promise that resolve to an `ICellRange` or 'null' when the copy has completed.
         *
         * @remarks
         * * Will return `null` if nothing was inserted or the source doesn't have a range.
         * @see
         *  {@link ICellRange.getSnapshot}
         */
        copyFrom(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions): Promise<this | null>;
        /**
         * Update the protection for the range.
         *
         * @returns Current `ICellRange`.
         *
         * @remarks
         * Setting to `null` will remove protections.
         */
        /**
         * Perform a set of operations as a batch.
         *
         * @param callback Function to perform the operations.
         * @param options Description of the operation or additional options. This will be used for tracking undo/redo and history. @defaultValue 'Range Update'
         * @template R - The callback return type.
         * @returns The result of the callback.
         */
        doBatch<R>(callback: (commit: ITransaction.ICommit) => Promise<R> | R, options?: string | ITransaction.OperationOptions): Promise<R> | R;
        /**
         * Creates a `IncrementalUpdater` for efficiently updating sparsely populated cells in a streaming low memory way.
         *
         * For contiguous or mostly contiguous updates, the {@link ICellRange.updateCells} method is simpler
         * and will use {@link ICellRange.IncrementalUpdater} internally.
         *
         * @param options {@link ICellRange.StartUpdateOptions}
         *
         * @remarks
         * - **Ordering:** By default updates must be added in either row-major or column-major order, as specified
         * by the `orientation` parameter, with major/minor coordinates increasing monotonically. Unless
         * `allowUnorderedWrites` is set to `true out of order updates will result in an error.
      
         * - **Performance:**  Setting `orientation` to `IRange.Orientation.Column` is generally faster as it aligns with the internal data representation.
         * - **Performance:**  Setting `allowUnorderedWrites` adds a nominal performance overhead for all updates and will do a full apply when an
         *      out of order update is detected.
         *   The default `IRange.Orientation.Row` is provided for compatibility with common spreadsheet APIs.
         * - **Validation:** Data validation (e.g., for protected cells or boundaries) is performed when the `apply` method is called.
         * - **Transactions:**
         *    - Adding values to the `IncrementalUpdater` only builds a temporary representation of the updates.
         *      No actual changes are made to the sheet until `apply` is called.
         *    - This allows for safe batching of updates within a single transaction using `doBatch`.
      
         * @example
      ```typescript startIncrementalUpdates
        const updates = range.startIncrementalUpdates()
          .push('A1', 2)
          .push('A2', 567)
          .push('A3', 3)
          .push('A4', 123)
          .push('A5', 1)
          .apply();
        });
      ```
         */
        startIncrementalUpdates(options?: ICellRange.StartUpdateOptions): ICellRange.IncrementalUpdater;
        /**
         * Returns `true` if there is any content within the range.
         *
         * @returns 'boolean' indicating if there is content.
         *
         * @remarks
         * Some uses cases for this are checking for data to delete a sheet, checking for multiple values
         * for merges.
         */
        isContentful(): boolean;
        /**
         * Returns `true` if the range represents the entire rows.
         */
        isEntireRows(): boolean;
        /**
         * Returns `true` if the range represents the entire columns.
         */
        isEntireColumns(): boolean;
        /**
         * Returns `true` if the range represents both entire rows and entire columns.
         */
        isEntireRange(): boolean;
        /**
         * Returns the width of the range.
         */
        getWidth(): number;
        /**
         * Returns the height of the range.
         */
        getHeight(): number;
        /**
         * Returns the size of the range this is the width * height.
         */
        get size(): number;
        /**
         * Returns the absolute bounds for the range.
         */
        getBounds(): Bounds;
        /**
         * Indicates if the range is readonly only.
         *
         * @remarks
         * Not an indicator of if the range is protected but rather
         * if the range is being used in a way that doesn't support write operations.
         * (e.g. the range is being provided as a listener source {@link ICellRange.Event}
         * or the range belongs to a historical snapshot.)
         */
        isReadOnly(): boolean;
        /**
         * Returns the `Coords` an A1-style address string (e.g., 'A1' or 'A1:E5').
         */
        getA1(): string;
        /**
         * Returns the column start.
         */
        getColumnStart(): number;
        /**
         * Returns the top of the range.
         */
        getRowStart(): number;
        /**
         * Returns the right of the range.
         */
        getColumnEnd(): number;
        /**
         * Returns the bottom of the range.
         */
        getRowEnd(): number;
        /**
         * Returns the number of columns of the range.
         */
        getColumnCount(): number;
        /**
         * Returns the number of rows of the range.
         */
        getRowCount(): number;
        /**
         * Checks if the ranges is empty, meaning it has no values or formatting.
         *
         * @remarks
         * Convenience ```getUsedRange() !== null``` or `getCount() === 0`.
         *
         * @see
         * {@link ICellRange.getUsedRange}
         */
        isEmpty(): boolean;
        /**
         * Returns the Sheet.
         */
        getSheet(): ISheet;
        /**
         * The IRange.Coords.
         */
        getCoords(): Readonly<IRange.FixableCoords>;
        /**
         * Returns true if the range is invalid.
         * This can occur if a range is removed or created with invalid coordinates.
         */
        isInvalid(): boolean;
        /**
         * Returns the address as a string.
         */
        toString(): string;
        /**
         * Selects the current range.
         *
         * @returns An async `ICellRange`.
         */
        select(options?: ICellRange.SelectOptions): Promise<this>;
        /**
         * Add a listener to the range.
         *
         * @param listener {@link ICellRange.Listener}
         * @param options {@link ICellRange.ListenerOptions}
         * @returns A callback to remove. {@link IListener.Remove}
         *
         * @remarks
         * If the range becomes invalid through a delete this will auto remove.
         */
        addListener(listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
        /**
         * Returns an iterator that allows you to iterate over the individual values within the range.
         *
         * @remarks
         * For more advanced iteration, use {@link ICellRange.entries} or {@link ICellRange.forEach}.
         */
        [Symbol.iterator](): IterableIterator<Scalar>;
        /**
         * Returns an iterator that allows you to iterate over the individual entries within the range,
         * yielding pairs of `IteratorContext` and a `Value`.
         *
         * @param options Configuration options for the iterator, such as filtering or sorting.
         * @returns An iterator that yields `[ICell.IteratorContext, Value]` tuples for each value within the range.
         */
        entries(options?: ICellRange.IteratorOptions): IterableIterator<ICellRange.Entry>;
        /**
         * Returns the values within the range, yielding each value.
         *
         * @param options Configuration options for the iterator, such as filtering or sorting.
         * @returns An iterator that yields `[ICell.IteratorContext, Value]` tuples for each value within the range.
         */
        values(options?: ICellRange.IteratorOptions): IterableIterator<Scalar>;
        /**
         * Iterates over the cells within the range, applying the provided callback function to each cell.
         *
         * This method is a more scalable alternative to `getValues` or `getCells` for large or sparse ranges,
         * as it:
         * 1. Skips empty values by default.
         * 2. Avoids creating large arrays.
         * 3. Allows for early termination.
      
         * @param callback A function that will be called for each non-empty cell in the range. The callback receives:
         *   - `value`: The `Scalar` at the current cell.
         *   - `context`: A `IteratorContext` object providing additional information and utilities for the cell.
         *   - The callback can return `{ break: T }` to stop the iteration early.
         * @param options {@link ICellRange.IteratorOptions} for configuring which cells to visit.
         * @template  R - The callback return type.
         * @returns The value returned by the callback function if it explicitly returned to stop the iteration early; otherwise, `void`.
         */
        forEach<B>(callback: ICellRange.ForEachCallback<B>, options?: ICellRange.IteratorOptions): B | void;
        /**
         * For runtime type checking.
         */
        readonly isICellRange: true;
    }
    /**
     * {@inheritDoc ICellRange}
     * @see
     * ### **Interface**
     *
     * {@link ICellRange}
     */
    export namespace ICellRange {
        /**
         * This is either:
         * 1. Another ICellRange
         * 2. A string that can be parsed into a CellRange (e.g. 'A1:B2') or a named range.
         * 3. Partial IRange.FixableCoords
         */
        type Address = ICellRange | string | Readonly<Partial<IRange.FixableCoords>> | ICell.Address;
        /**
         * Single or 2D.
         */
        type Update = ICell.Update | readonly ICell.Update[][];
        /**
         * Expands the CellUpdateValue to support a single value or arrays of arrays (2d arrays).
         */
        type ValuesUpdate = JSScalarUpdate | readonly JSScalarUpdate[][];
        /**
         * Allows for Values to be set via a callback.
         */
        type ValuesUpdateOrCallback<T = Scalar> = ValuesUpdate | ((row: number, column: number) => T | null);
        /**
         * Options for `ISheet.getRange`.
         */
        interface GetRangeOptions {
        }
        /**
         * Options for `ICellRange.delete`.
         */
        interface InsertOptions extends ITransaction.OperationOptions {
            /**
             * The direction in which to shift existing cells.
             *   Defaults to the orientation where the range's dimension is smaller (e.g., shifts down if the range is wider than it is tall).
             *   See {@link ICellRange.getDefaultShiftOrientation}
             */
            orientation?: IRange.Orientation;
        }
        /**
         * Options for `ICellRange.delete`.
         */
        interface DeleteOptions extends ITransaction.OperationOptions {
            /**
             * The direction in which to shift existing cells.
             *   Defaults to the orientation where the range's dimension is smaller (e.g., shifts down if the range is wider than it is tall).
             *   See {@link ICellRange.getDefaultShiftOrientation}
             */
            orientation?: IRange.Orientation;
        }
        /**
         * Shorthand for persisting.
         */
        type RefJSON = IRange.Coords | string;
        /**
         * Options for configuring range coordinate reference types.
         * Each option allows you to specify whether a coordinate should be fixed
         * (absolute) or flexible (relative).
         *
         * @see
         * {@link ICellRange.getFixed}
         */
        interface GetFixedOptions {
            /**
             * If `true`, sets the starting row coordinate as absolute; if `false`,
             * sets it as relative. Defaults to no change if not provided.
             */
            rowStart?: boolean;
            /**
             * If `true`, sets the starting column coordinate as absolute; if `false`,
             * sets it as relative. Defaults to no change if not provided.
             */
            colStart?: boolean;
            /**
             * If `true`, sets the ending row coordinate as absolute; if `false`,
             * sets it as relative. Defaults to no change if not provided.
             */
            rowEnd?: boolean;
            /**
             * If `true`, sets the ending column coordinate as absolute; if `false`,
             * sets it as relative. Defaults to no change if not provided.
             */
            colEnd?: boolean;
        }
        /**
         * Options for {@link ICellRange.getSurrounding}.
         */
        interface GetSurroundingOptions {
            /**
             * If `true` then only the content will be included.
             *
             * @defaultValue false
             *
             * @remarks
             * If `true` then tables and sheet boundaries will be ignored mimicking the behavior
             * of 'Ctrl+Shift+*'.
             */
            contentOnly?: boolean;
        }
        /**
         * A callback to enabled additional customization during copy.
         *
         * @remarks
         * Return `undefined` will leave the value undefined altered.
         */
        interface CopyCellsCallback {
            (value: Scalar, context: ICell.IteratorContext, to: IRange.CellCoords, options: ICellRange.CopyOptions): ICell.Update;
        }
        /**
         * Options for {@link ICellRange.ISnapshot.copyTo}.
         */
        interface CopyOptions extends ITransaction.OperationOptions, ReferenceableClipboard.CopyOptions {
            /**
             * When pasting from a smaller range to a larger range copy will repeat or 'wallpaper' the
             * source values.
             *
             * @remarks
             * Note - If the destination range is only a single cell then fitDestination will always be applied.
             */
            fitDestination?: boolean;
            /**
             * Have the data transposed for the original orientation.
             * @defaultValue false
             */
            transpose?: boolean;
            /**
             * If `true` then blank values will not be copied.
             * @defaultValue false
             */
            skipBlanks?: boolean;
            /**
             * Indicate which items are copied.
             */
            type?: ICell.Content;
            /**
             * Indicates if the header (size) should be copied.
             * @remarks
             * The default is to only copy the headers if the range is entire header span.
             */
            includeHeaders?: boolean;
            /**
             * Allows for undo to range selection to be altered.
             *
             * @remarks
             * This is used to during drag.
             */
            undoRange?: ICellRange;
            /**
             * Callback to allow for additional customizations.
             */
            adjustCells?: ICellRange.CopyCellsCallback;
        }
        /**
         * Options for {@link ICellRange.insertFrom}.
         *
         * @remarks
         * This extends {@link ICellRange.CopyOptions} and adds an {@{@link IRange.Orientation}.
         */
        interface InsertFromOptions extends ICellRange.CopyOptions {
            /**
              * The direction in which to shift existing cells.
              *   Defaults to the orientation where the copied range's dimension is smaller.
              *   See {@link ICellRange.getDefaultShiftOrientation} for details on the default behavior.
             */
            orientation?: IRange.Orientation;
        }
        /**
         * Options for {@link ICellRange.setValues}.
         */
        interface SetValuesOptions extends ITransaction.OperationOptions {
            /**
             * By default setValue will attempt to parse text values into a native type.
             * This can be disabled or customized using the parseText flag.
             * Setting this to false will use the raw text value.
             */
            textParser?: boolean | ICell.ModifiersFromStringOptions;
            /**
             * Specifies the direction for iterating over the range (row-major or column-major).
             *
             * @defaultValue `IRange.Orientation.Row`
             *
             * @remarks
             * Both {@link SetValuesOptions} and {@link GetValuesOptions} allow for {@link IRange.Orientation}s.
             */
            orientation?: IRange.Orientation;
            /**
             * Convenience method that calls autoFit after the setValues.
             * @defaultValue `none` - No autofit.
             *
             * @remarks
             * If set to `true` then autoFit will mimic the UI with the following options:
        ```
        {
          skipCustomSize: true,
          expandOnly: true,
          minContent: true
        }
        ```
             */
            autoFit?: boolean | ICellRange.AutoFitOptions;
            /**
             * Skip the bounds check when setting values.
             *
             * @remarks
             * When set to `true`, this option allows value arrays to exceed the
             * dimensions of the range. This is useful for setting values in a table
             * where the range is smaller than the data, but determining the exact
             * size requires processing the entire dataset.
             */
            skipBoundsCheck?: boolean;
        }
        /**
         * Options for {@link ICellRange.getValues}.
         */
        interface GetValuesOptions {
            /**
             * Return dates as Javascript dates instead of OADates. This is slower for values
             * that are numbers as the Style needs to be read to determine if the
             * value should be interpreted as a date or a number. See {@link ICell.IteratorContext.asJSDate}.
             *
             * @defaultValue false
             */
            asJSDate?: boolean;
            /**
             * Limits the maximum number of values returned. An error will be thrown if results contain more values than `maxSize`.
             *
             * @defaultValue 10000
             */
            maxSize?: number;
            /**
             * Specifies the primary direction for iterating over the range (row-major or column-major).
             *
             * @defaultValue IRange.Orientation.Row
             * @remarks
             * Both {@link SetValuesOptions} and {@link GetValuesOptions} allow for {@link IRange.Orientation}s.
             */
            orientation?: IRange.Orientation;
            /**
             * Reverses the iteration order (e.g., from bottom to top for rows, or from right to left for columns).
             *
             * @defaultValue false
             */
            reverse?: boolean;
            /**
             * Excludes hidden cells from the returned values.
             *
             * @defaultValue false
             *
             * @remarks
             * - When enabled, the number of returned rows or columns might be less than the range size.
             * - If the entire range is hidden, the result will be empty and empty Array (`[]`).
             * - Optionally, you can specify a `IRange.Orientation` to indicate the header orientation for skipping cases.
             *   For example, in sorting, you might want to skip hidden rows but not hidden columns.
             */
            ignoreHidden?: boolean | IRange.Orientation;
            /** {@inheritDoc ICellRange.IteratorOptions.includeMergeOverflow} */
            includeMergeOverflow?: boolean;
        }
        /**
         * Options for {@link ICellRange.toText}.
         */
        interface ToTextOptions extends ICellRange.GetValuesOptions {
            ignoreFormatting?: boolean;
        }
        /**
         * Options for {@link ICellRange.autoFit}.
         */
        interface AutoFitOptions extends ITransaction.OperationOptions {
            /**
             * Best fit using the minimum amount of space required.
             *
             * @defaultValue false
             *
             * @remarks
             * When `true` the numbers will include as few decimals as allowed overflow into the next cell.
             */
            minContent?: boolean;
            /**
             * By default autoFit will adjust in both directions.
             *
             * @defaultValue false
             */
            expandOnly?: boolean | IRange.Orientation;
            /**
             * If this is set to `true` then any headers that have custom sizes will be ignored.
             *
             * @defaultValue false
             */
            skipCustomSize?: boolean;
            /**
             * The orientation to autoFit.
             *
             * @defaultValue IRange.Orientations.Both
             */
            orientations?: IRange.Orientations;
        }
        /**
         * Options for {@link ICellRanges.getFlattened}.
         */
        interface GetFlattenOptions extends GetRangeOptions {
            /**
             * Returns a set of ranges with overlaps removed and attempts to merge adjacent ranges into larger ranges.
             *
             * @param orientations The overlap detection and initial merge orientation.
             * @param options Additional options to control range behavior.
             * @returns A new `ICellRanges` object with non-overlapping, and where possible, merged ranges.
             *
             * @defaultValue `IRange.Orientations.Both`.
             */
            orientations?: IRange.Orientations;
        }
        /**
         * Options for {@link ICellRange.getVisible}.
         */
        interface GetVisibleOptions extends GetRangeOptions {
            /**
             * The visible orientations.
             *
             * @defaultValue `IRange.Orientations.Both`
             */
            orientations?: IRange.Orientations;
        }
        /**
         * Callback that will return a a temporary cell given a coords.
         * @see
         * {@link ICell.createTemporaryCell}.
         */
        interface AutoFillPreviewCallback {
            /**
             * Reviews a temporary cell that can be used for previewing.
             *
             * @remarks
             * The {@link ICell | cell} is the cell from the corner.
             */
            (destination: ICellRange.Address): ICell;
        }
        /**
         * Options for {@link ICellRange.autoFill}.
         */
        interface AutoFillOptions extends ITransaction.OperationOptions {
            /**
             * Provide custom fillers.
             *
             * @defaultValue `AutoFill.Types.Series`
             */
            filler?: IAutoFill.Filler;
            /**
             * Options to pass to the `IAutoFill.Filler`.
             * @remarks
             * These will also be passed if a custom filler is used.
             */
            fillerOptions?: IAutoFill.Options;
            /**
             * If `true` then will only copy values and not formatting.
             *
             * @defaultValue false (unless starting within a table)
             */
            contentsOnly?: boolean;
            /**
             * If a previewOnly callback is provided then autoFill will not commit any changes but will
             * call previewOnly with a Preview function and then return the original range.
             * * Useful for creating tooltips.
             *
             * @defaultValue null
             */
            previewOnly?: (callback: ICellRange.AutoFillPreviewCallback) => void;
        }
        /**
         * Options for {@link ICellRange.updateCells}.
         */
        interface UpdateCellsOptions extends SetValuesOptions {
        }
        /**
         * Provides an API for efficiently performing incremental updates to specific cells within a range.
         *
         * Unless {@link ICellRange.StartUpdateOptions.allowUnorderedWrites} is `true` the updates must be written
         * in row-major or column-major order as determined by {@link IRange.Orientation}, with major/minor
         * coordinates increasing on each update, otherwise an error will be thrown.
         *
         * @example
         * ```typescript
         * const updater = range.startIncrementalUpdates();
         * updater.pushAt(1, 1, "Hello"); // as row, column, primitive - fastest
         * updater.push({ rowIndex: 2, colIndex: 1 }, { value: "Beautiful" }); // as coordinate and json object
         * updater.push('A3', { value: "World" });  // as a1 string and json
         * updater.apply();
         * ```
         * @template S - The return type of {@link apply}, typically the source range (`ICellRange`).
         * @see {@link ICellRange.startIncrementalUpdates}
         */
        interface IncrementalUpdater<S = ICellRange> {
            /**
             * Adds an update at a specific cell address.
             *
             * @param address The cell address to update. See {@link ICell.Address}.
             * @param update The update to apply. See {@link ICell.Update}.
             * @throws `Error` If the coordinates are out of order compared to previously added coordinates.
             * @returns The current `IncrementalUpdater` instance for chaining.
             */
            push(address: ICell.Address, update: ICell.Update): this;
            /**
             * Adds an update at a specific major (row) and minor (column) index.
             *
             * This method is slightly faster than {@link push} as it bypasses address parsing.
             *
             * @param row The row index of the cell to update.
             * @param col The column index of the cell to update.
             * @param update The update to apply. See {@link ICell.Update}.
             * @throws `Error` If the coordinates are out of order compared to previously added coordinates.
             * @returns The current `IncrementalUpdater` instance for chaining.
             */
            pushAt(row: number, col: number, update: ICell.Update): this;
            /**
             * Adds multiple updates for contiguous cells along the minor axis (columns), starting at the specified indices.
             *
             * @param row The row index of the starting cell.
             * @param col The column index of the starting cell.
             * @param updates An array of updates to apply to contiguous cells.
             * @throws `Error` If the coordinates are out of order compared to previously added coordinates.
             * @returns The current `IncrementalUpdater` instance for chaining.
             */
            pushMultipleAt(row: number, col: number, updates: ICell.Update[]): this;
            /**
             * Finalizes and applies all queued updates to the range.
             *
             * This method commits the changes added via {@link push}, {@link pushAt}, or {@link pushMultipleAt}.
             *
             * @param options Optional settings for the update operation.
             * @returns The source object, typically the range (`ICellRange`).
             */
            apply(options?: ICellRange.UpdateCellsOptions): S;
        }
        interface StartUpdateOptions {
            /**
             * The orientation to write.
             */
            orientation?: IRange.Orientation;
            /**
             * Allowing unordered writes is slower but relaxes the rule that the updates must be written in order.
             *
             * @defaultValue false
             */
            allowUnorderedWrites?: boolean | ICellRange.UpdateCellsOptions;
        }
        /**
         * Options for {@link ICellRange.merge}.
         */
        interface MergeOptions extends SetValuesOptions {
            /**
             * The orientations of the merge.
             *
             * @defaultValue IRange.Orientations.Both
             */
            orientations?: IRange.Orientations;
            /**
             * If `true` then merge will merge even if there is more than one value.
             *
             * @defaultValue false
             */
            discardMultipleValues?: boolean;
        }
        /**
         * Options use for filtering elements during a find.
         */
        interface FindCriteria {
            /**
             * If `true` then the text search is case sensitive.
             *
             * @defaultValue false
             */
            matchCase?: boolean;
            /**
             * If `true` the text must match the entire cell to be true.
             *
             * @defaultValue false
             */
            matchEntireCell?: boolean;
            /**
             * Determines whether the find operation should treat the search text as a regular expression (RegEx).
             *
             * @defaultValue false
             *
             * @remarks
             * When `true`, the search text will be interpreted as a regular expression (RegEx), allowing for
             * advanced pattern matching.
             *
             * If `false`, the find operation will not use RegEx but will support three wildcard characters
             * for flexible searching:
             *
             * - `?` (question mark): Matches any single character.
             * - `*` (asterisk): Matches any number of characters, including zero.
             * - `~` (tilde followed by `?`, `*`, or `~`): Escapes the wildcard characters (`?` or `*`) to allow
             *   searching for these literal characters in the text.
             *
             * Example usage:
             * ```ts
             * // Search for text matching a RegEx pattern
             * const Iterator<ICell> results = range.find("\\d+", { useRegex: true}); // Finds numeric values
             *
             * // Search for text using wildcards
             * const Iterator<ICell> results = range.find("abc*", { useRegex: false }); // Finds text starting with "abc"
             * ```
             */
            useRegex?: boolean;
            /**
             * An enum of the types of values to search within each field.
             *
             * @defaultValue `[FindField.Formulas]`
             */
            fields?: ICell.Content[];
        }
        /**
         * Options for {@link ICellRange.find}.
         */
        interface FindOptions extends FindCriteria {
            /**
             * The text to search for.
             */
            text: string;
            /**
             * Provides custom logic for matching values during the find operation.
             *
             * @param value The current cell value being checked against the `criteria`.
             * @param matchDefault A default implementation of the find operation's matching logic.
             *   You can call this in your custom logic to fall back to the default behavior if needed.
             * @param criteria The criteria that the find operation is trying to match.
             *   This is typically defined by the user and passed to the find method.
             * @param context Contextual information about the cell, such as its address or value-related utilities.
             *   See {@link ICell.IteratorContext} for more details.
             * @returns A boolean indicating if the `value` satisfies the `criteria`.
             *
             * @remarks
             * If `matchCustom` is provided, this function will override the default matching logic for the find operation.
             * Use it to implement custom search rules, while the `matchDefault` can be used as a fallback for standard criteria.
             *
             * Example usage:
             * ```ts
             * const options = {
             *   matchCustom: (value, matchDefault, criteria, context) => {
             *     // Custom match logic
             *     if (typeof value === 'string' && value.includes('important')) {
             *       return true;
             *     }
             *     // Fallback to default match
             *     return matchDefault();
             *   }
             * };
             * ```
             */
            matchCustom?: (value: Scalar, matchDefault: () => boolean, criteria: FindCriteria, context: ICell.IteratorContext) => boolean;
            /**
             * Specifies the direction of the search.
             *
             * @defaultValue IRange.Orientation.Row
             */
            orientation?: IRange.Orientation;
            /**
             * If `true`, the search will proceed in reverse order.
             *
             *
             * @defaultValue false
             */
            reverse?: boolean;
            /**
             * The starting point for the search. If not provided, the search will start
             * from the top left corner of the range, or from the bottom right if `reverse` is true.
             *
             * @defaultValue top left corner or bottom right if reverse
             */
            from?: ICell.Address;
            /**
             * If `true`, the search will not wrap around to the beginning of the range after reaching
             * the end. By default, the search will wrap.
             *
             * @defaultValue false
             */
            disableWrap?: boolean;
        }
        /**
         * Represents an immutable reference to an `ICellRange`, capturing its content and metadata.
         * It may include complex objects such as tables, movables, images, listeners, or other items.
         *
         * `ISnapshot` can be provided to `ICellRange.copyFrom``.
         */
        interface ISnapshot<T = any, J = any> {
            /**
             * Copies the snapshot to the specified range.
             *
             * @param destination The destination `ICellRange` where the snapshot will be copied.
             * @param options {@link ICellRange.CopyOptions}
             *
             * @returns A promise that resolves when the copy is complete, or `void` if no asynchronous operation is required.
             */
            copyTo(destination: ICellRange, options?: ICellRange.CopyOptions): Promise<IRange.Coords | null> | IRange.Coords | null;
            /**
             * Return the options used when creating.
             * @remarks
             * This is done so that we can create a copy.
             */
            getMarkOptions(): ICellRange.CopyOptions;
            /**
             * Retrieves the coordinates that bound the current snapshot.
             *
             * @returns The `IRange.Coords` defining the bounds of the snapshot.
             */
            getCoords?(): Readonly<IRange.Coords>;
            /**
             * Converts the snapshot to a plain text representation.
             *
             * @returns A string or promise resolving to the text representation of the snapshot.
             */
            toText?(): Promise<string> | string;
            /**
             * Converts the snapshot to an HTML representation.
             *
             * @returns A string or promise resolving to the HTML representation of the snapshot.
             */
            toHtml?(): Promise<string> | string;
            /**
             * Converts the snapshot to an image blob.
             *
             * @returns A `Blob` or promise resolving to the image representation of the snapshot.
             */
            toImage?(): Promise<Blob> | Blob;
            /**
             * Converts the snapshot to a JSON object.
             *
             * @returns A JSON object or promise resolving to the JSON representation of the snapshot.
             */
            toJSON?(): Promise<J> | J;
            /**
             * The source that created the snapshot.
             * This is used by copy to quickly do comparisons.
             */
            getSource(): T;
            /**
             * A user friendly name of a the snapshot item.
             */
            getName?(): string;
            /**
             * For runtime type checking.
             */
            readonly isISnapshot: true;
        }
        /**
         * Callback used for visiting a collection of cells. If break is returned the visiting will stop with the
         * break value returned.
         *
         * The context allows for the retrieval of additional information associated with the Cell include the
         * {@link ICell} object.
         */
        interface ForEachCallback<T = any> {
            (value: Scalar, context: ICell.IteratorContext): {
                break: T;
            } | void;
        }
        /**
         * Alias type for count results by type.
         */
        type Counts = Partial<Record<ICell.Content, number>>;
        interface ScrollIntoViewOptions extends globalThis.ScrollIntoViewOptions {
            /**
             * If provided then will only scroll in the provided orientation.
             *
             * @remarks
             * This is useful for only scrolling vertically or horizontally for insert/deleteCells
             */
            orientation?: IRange.Orientation;
        }
        /**
         * Extends SelectionOptions to include the option to adjust the anchor cell.
         */
        interface SelectOptions extends ITypes.SelectOptions {
            /**
             * If `true` then the anchor cell will be adjusted to the top-left cell of the range.
             *
             * @defaultValue false
             *
             * @remarks
             * If the current anchor is not within the current range this will be forced to `true`.
             */
            anchor?: boolean | Partial<IRange.CellCoords>;
            /**
             * If `true` or if a valid `ScrollIntoViewOptions` object is provided,
             * the selected element will be scrolled into view.
             *
             * @remarks
             * - If a `ScrollIntoViewOptions` object is provided, it will control the exact scrolling behavior.
             * - If `false` (or omitted), the selected element will not be scrolled into view.
             *
             * @defaultValue false
             */
            scrollIntoView?: boolean | ICellRange.ScrollIntoViewOptions;
        }
        /**
         * Options for customizing how values are retrieved from a range and returned as a 2D array.
         */
        interface IteratorOptions<T = ICellRange.Address> {
            /**
             * The containing range coords for the scan.
             *
             * @remarks
             * If not specified will scan all of the data.
             */
            address?: T;
            /**
             * If true will visit empty cells.
             * This is a potentially huge performance improvement if set to false.
             *
             * @defaultValue false
             *
             * @remarks
             * If includeEmpty is true this will always return rectangular results.
             * If bounds are provided it will provide empty spaces before and after.
             * If passing a large bound care must be taken.
             */
            includeEmpty?: boolean;
            /**
             * When scanning skip cells that are hidden via headers.
             *
             * @defaultValue false
             *
             * @remarks
             * Optionally a header orientation for skipping case be passed in.
             * An example of this is for sorting where the sort direction (row) skips hidden rows but the column direction does not.
             */
            ignoreHidden?: boolean | IRange.Orientation;
            /**
             * If set to true the only the raw values will be visited.
             *
             * @defaultValue false
             *
             * @remarks
             * This allows for much faster reading when only the value is needed.
             */
            ignoreCellDetails?: boolean;
            /**
             * Includes any merge overflow in first element visited.
             *
             * @defaultValue false
             *
             * @remarks
             * If `true` any merges that fall outside of the range will be include in the top/left most cell that the
             * merge intersects. Useful for rendering merged cells when the top/left is outside the viewport.
             */
            includeMergeOverflow?: boolean;
            /**
             * The direction of the scan.
             * @defaultValue `IRange.Orientation.Row`
             */
            orientation?: IRange.Orientation;
            /**
             * Iterate in reverse order.
             *
             * @defaultValue false
             */
            reverse?: boolean;
        }
        interface Event {
            /**
             * The source of the event. This will be a readonly range.
             *
             * @remarks
             * This may change shape due to insert/delete/move of cells or sheets.
             */
            getSource<T = ICellRange | ICellRanges>(): T;
            /**
             * This is the range of data that has been changed.
             *
             * @remarks
             * This is different than the source range as that is the entire range area that was listened to.
             */
            getFrom(): ICellRanges;
            /**
             * Used for moves. Represents the new location of the data that has changed.
             */
            getTo?(): ICellRange;
            /**
             * Indicates the type of change that triggered the event.
             *
             * @remarks
             * * `'data'`: Data within the range has changed.
             *   The range's address and dimensions remain the same.
             * * `'address'`: The range's *address* or *dimensions* have changed. This
             *   occurs due to row/column insertions, deletions, or move operations.
             * * `'restore'`: The range has been restored to a different revision
             *   (undo/redo). The 'restore' trigger is not available for transactional listeners.
             */
            readonly trigger2?: 'data' | 'address' | 'restore';
            readonly trigger: string;
            /**
             * Indicates if the event is being fired from an undo event.
             */
            readonly isUndo?: boolean;
            /**
             * Indicates if the event is part of a transaction.
             *
             * @see
             * {@link ListenerOptions.transactional}
             */
            readonly isTransactional?: boolean;
            /**
             * Indicates if the event is being fired due to a cell value change.
             *
             * @see
             * {@link ListenerOptions.ignoreDataChanges}
             */
            readonly isDataChange?: boolean;
            /**
             * To string the event.
             */
            toString(): string;
            /**
             * The timestamp of the event.
             */
            readonly timeStamp: number;
        }
        /**
         * Represents a listen for a range. The listener will be called when the range's
         * data, address, or restore state changes, subject to the provided options.
         *
         * @remarks
         * If the range is deleted (rows/columns removed), the trigger will be `'address'`
         * `trigger` of `'address'` and `getRange().getError()`
         * returning `"#REF!"`.
         *
         * If the ranges is restored to a revision *before* the listener was
         * added, the listener will receive event with a `trigger` of `'restore'`
         * and `getRange().getError()` returning `"#N/A"`.
         */
        interface Listener {
            (event: Event): void;
        }
        /**
         * Options to control which events trigger a listener. By default, all
         * event types will trigger the listener. Setting any of these options to
         * `true` will *prevent* the listener from being called for that event type.
         */
        interface ListenerOptions {
            /**
             * The actual range can also change due to insert/removes or delete of a sheet.
             * Setting absoluteCoords to true will ignore shifts in the range.
             *
             * @defaultValue false
             */
            ignoreShifts?: boolean;
            /**
            * If `true`, the listener will be treated as *transactional*. This has
            * a few implications:
            *
            * 1. **Synchronous Execution:** The listener will be called *synchronously*
            *    as part of the same transaction that triggered the event.  Any
            *    side-effects of the listener will be included in the transaction's
            *    commit history.
            * 2. **No 'restore' Events:** Transactional listeners will *never* receive
            *    'restore' events. They are only concerned with changes within the
            *    current transaction.
            *
            * If `false` (the default), the listener will be called *asynchronously*
            * after the transaction is complete. The listener's side-effects will
            * *not* be part of the transaction's commit history.
            *
            * @defaultValue false
            */
            transactional?: boolean;
            /**
             * If `true`, the listener will *not* be called when the range's
             * address changes (due to row/column insert/delete, or moves)
             *
             * @defaultValue false
             */
            ignoreAddressChanges?: boolean;
            /**
             * If `true`, the listener will *not* be called when the data
             * within the range changes.
             *
             * @defaultValue false
             */
            ignoreDataChanges?: boolean;
            /**
             * If `true` then the listener will be weakly and will be auto removed it the listener is gc'ed.
             *
             * @defaultValue false
             */
            weakly?: boolean;
            /**
             * If `true` then will auto deregister once fired.
             */
            once?: boolean;
        }
        /**
         * Entry for ICellRange when iterator or visiting.
         */
        interface Entry<T = Scalar> {
            /** {@inheritDoc Scalar} */
            value: T;
            /** {@inheritDoc ICell.IteratorContext} */
            context: ICell.IteratorContext;
        }
    }
}
declare module "cellRange/index" {
    export * from "cellRange/ICellRange";
    export * from "cellRange/ICellRanges";
    export * from "cellRange/ICellHeaderRange";
    export * from "cellRange/ICellHeaderRanges";
}
declare module "anchored/IAnchored" {
    import type { IRange } from '@sheetxl/primitives';
    import type { ITransaction } from "transaction/index";
    import type { IListener } from "listener/index";
    import type { ICellRange } from "cellRange/index";
    /**
     * `IAnchored` objects are anchored to a range.
     */
    export interface IAnchored {
        /**
         * Returns the anchor.
         */
        getAnchorCoords(): IRange.Coords;
        /**
         * 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;
        /**
         * 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 namespace IAnchored {
        interface Events {
            /**
             * Called when the anchor bounds are updated.
             */
            onAnchorCoordsChange?(source: IAnchored): void;
            /**
             * Called when the anchor protection is updated.
             */
            onProtectedChange?(source: IAnchored): void;
            /**
             * Called when the anchor is removed.
             */
            onDelete?(source: IAnchored): void;
            /**
             * Called when the state has been updated due to a undo/redo and a rerender is required.
             */
            onInvalidated?(source: IAnchored): void;
            /**
             * Called when the state has been updated for any reason.
             */
            onAnyChange?(source: IAnchored): void;
            /**
             * Called when the anchor transaction is closed.
             */
            onClose?(source: IAnchored): 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];
        /**
         * @see
         * {@link IAnchored.ConstructorOptions.setContainerShiftCallback}
         */
        type ShiftCallback = (options: IAnchored.ShiftOptions) => IRange.Coords | void;
        /**
         * @see
         * {@link IAnchored.ConstructorOptions.setContainerDeleteCallback}
         */
        type DeleteCallback = () => void;
        /**
         * @see
         * {@link IAnchored.ConstructorOptions.setContainerLayoutCallback}
         */
        type LayoutCallback = () => void;
        /**
         * @see
         * {@link IAnchored.ConstructorOptions.setContainerProtectionCallback}
         */
        type ProtectionCallback = () => void;
        interface CoordsChangeOptions {
            before: Readonly<IRange.Coords[]>;
            after: Readonly<IRange.Coords[]>;
        }
        type CoordsChangeCallback = (options: CoordsChangeOptions) => void;
        interface ShiftOptions {
            before: IRange.Coords;
            after: IRange.Coords;
            intersect: IRange.Coords;
            isSplit: boolean;
            orientation: IRange.Orientation;
            amount: number;
        }
        interface ConstructorOptions {
            /**
             * The anchor used when the item is first created.
             */
            initialAnchor: IRange.Coords;
            /**
             * If provided will allow for items to store relative ranges.
             */
            maxRangeCoords?: IRange.Coords;
            /**
             * Notify the container that a anchor change is required.
             *
             * @param address Set the anchor on the container
             */
            setContainerCoords?(address: ICellRange.Address): IRange.Coords;
            /**
             * Notify anchored item that the anchor bounds have changed due to an insert/remove.
             *
             * @param callback
             */
            setContainerShiftCallback?(callback: IAnchored.ShiftCallback): void;
            /**
             * Delete from the container.
             */
            deleteFromContainer?(options?: ITransaction.OperationOptions): void;
            /**
             * Notify anchored item that the record has been deleted from the container.
             *
             * @param callback
             */
            setContainerDeleteCallback?(callback: IAnchored.DeleteCallback): void;
            /**
             * If protected the container can protected the item.
             */
            isProtected?(): boolean;
            /**
             * Notify anchor it's protection has been updated from the container.
             *
             * @param callback
             */
            setContainerProtectionCallback?(callback: IAnchored.ProtectionCallback): void;
            /**
             * Notify anchored item that the pixel bounds have changed due to a resize.
             *
             * @param callback
             */
            setContainerLayoutCallback?(callback: IAnchored.LayoutCallback): void;
            /**
             * A transaction store that can be used to undo/redo changes.
             */
            transactions?: ITransaction.IStore;
            /**
             * Use for the creation transaction description.
             */
            createDescription?: string;
        }
    }
}
declare module "anchored/index" {
    export * from "anchored/IAnchored";
}
declare module "movable/IMovable" {
    import type { Bounds, Point, ReferenceableClipboard } from '@sheetxl/utils';
    import type { ITypes } from "type/index";
    import type { ITransaction } from "transaction/index";
    import type { IResource } from "resource/index";
    import type { IListener } from "listener/index";
    import type { IModel } from "model/index";
    import type { IHistory } from "history/index";
    import type { IAnchored } from "anchored/index";
    import type { IMovableCollection } from "movable/IMovableCollection";
    /**
     * Capabilities for working with graphical elements that can be
     * arbitrarily placed (floated) within a virtual 'canvas'.
     *
     * Encompasses objects like images, charts, shapes, and custom widgets.
     *
     * Key features include:
     * - Inserting, positioning, resizing, and scaling movables.
     * - Grouping and layering multiple movables.
     * - Loading, saving, and copy/pasting movables.
     */
    export interface IMovable extends IAnchored, IHistory.ISnapshotSource<IMovable.SnapshotDestination, IMovable, Bounds> {
        /**
         * Returns the content of the movable.
         */
        getContent<T extends IModel>(): T;
        /**
         * Selects the current movable.
         *
         * @returns An async boolean indicating the movable was selected.
         */
        select(options?: IMovable.SelectOptions): Promise<boolean>;
        /**
         * Remove the movable the current selection.
         * @returns A flag indicating if it was previously in the selection.
         */
        unselect: () => boolean;
        /**
         * Returns a flag indicating if the movable is selected.
         */
        isSelected: () => boolean;
        /**
         * Set the absolution position of a movable in pixels.
         * @param bounds The new bounds.
         *
         * @remarks
         * If only some of the points are provided then only those will be moved.
         */
        setBounds(bounds: Partial<Bounds>, options?: ITransaction.OperationOptions): IMovable;
        /**
         * Scroll the movable into the viewport.
         *
         * @returns A promise that resolve to a `boolean` when the scroll is complete.
         *
         * @remarks
         * This will return when the scroll view is loaded but before any scroll animations have started or finished.
         */
        scrollIntoView: (options?: globalThis.ScrollIntoViewOptions | boolean) => Promise<boolean>;
        /**
         * Returns the absolute bounds of the movable object in pixels.
         */
        getBounds(): Bounds;
        /**
         * Set the name for a movable object.
         *
         * @param name The name of the IMovable.
         */
        setName(name: string): IMovable;
        /**
         * @see
         * {@link setName}
         */
        getName(): string;
        /**
         * This is the alternative text use for assistive technologies.
         */
        setDescription(description: string | null): IMovable;
        /**
         * @see
         * {@link setDescription}
         */
        getDescription(): string;
        /**
         * If true then the movable object is hidden.
         */
        setHidden(hidden: boolean): IMovable;
        /**
         * @see
         * {@link setHidden}
         */
        isHidden(): boolean;
        /**
         * Set the rotation in degrees.
         */
        setRotation(rotation: number): IMovable;
        /**
         * @see
         * {@link setHidden}
         */
        getRotation(): number;
        /**
         * If true then the aspect should be maintained during resize if using the corners or if
         * the api only specifies one dimension.
         *
         * @remarks
         * Lock aspect ratio will have different default values depending on the movable type.
         */
        setLockAspectRatio(locked: boolean): IMovable;
        /**
         * @see
         * {@link setLockAspectRatio}
         */
        isLockAspectRatio(): boolean;
        /**
         * Ses the anchor type.
         */
        setAnchorType(anchorType: IAnchored.Type): IMovable;
        /**
         * The order in the z plane. To adjust this use the move methods.
         */
        getZIndex(): number;
        /**
         * Move movable to the back in the zIndex.
         */
        moveToBack(): this;
        /**
         * Move movable backward one layer in the zIndex.
         */
        moveBackward(): this;
        /**
         * Move movable to the font in the zIndex.
         */
        moveToFront(): this;
        /**
         * Move movable forward one layer in the zIndex.
         */
        moveForward(): this;
        /**
         * Add Listeners.
         *
         * @see
         * {@link IListener.ISource.addListeners}
         */
        addListeners(listeners: IMovable.IListeners, options?: IListener.Options): IListener.Remove;
        /**
         * If defined this will be called when the containing sheet is being
         * serialized.
         */
        toJSON?(toResourceId?: (resource: IResource) => number): IMovable.JSON;
        /**
         * A specific uuid for use in memory.
         *
         * @remarks
         * Useful for caches and react keys. This is not persisted.
         */
        getUUID(): string;
        /**
         * For runtime type checking.
         */
        readonly isIMovable: true;
    }
    /**
     * {@inheritDoc IMovable}
     * @see
     * ### **Interface**
     *
     * {@link IMovable}
     */
    export namespace IMovable {
        /**
         * Extends {@link ITypes.SelectOptions} to include options for `IMovable`.
         */
        interface SelectOptions extends ITypes.SelectOptions {
            /**
             * Flag to indicate the the movable should be added to the selection
             * or should replace the existing selection.
             *
             * @remarks
             * Setting this to true is the equivalent of press the Ctrl in the UI.
             */
            addToSelection?: boolean;
        }
        /**
         * `Events` for {@link IMovable} events.
         */
        interface Events extends IAnchored.Events {
            /**
             * Called when the isSelect status has changed.
             */
            onSelectionChange?(source: IMovable): void;
            /**
             * Called when the name has changed.
             */
            onNameChange?(source: IMovable): void;
            /**
             * Called when selection changes.
             */
            onBoundsChange?(source: IMovable): void;
            /**
             * Called when the anchor type is updated.
             */
            onAnchorTypeChange?(source: IMovable): void;
            /**
             * Called when any property has changed.
             */
            onAnyChange?(source: IMovable): void;
            /**
             * Request that the movable become focused.
             *
             * @returns A promise indicating if the focus was honored.
             *
             * @remarks
             * This should only be handled by one consumer.
             */
            onRequestFocus?(source: IMovable): Promise<boolean>;
        }
        interface IListeners extends IListener.Callbacks<IMovable, IMovable.Events> {
        }
        /**
         * Provides destination details for the Snapshot when using {@link IHistory.ISnapshot.copyTo}.
         */
        interface SnapshotDestination {
            /**
             * The movable collection to copy to.
             */
            movables: IMovableCollection;
            /**
             * The bounds to copy to.
             */
            bounds: Bounds;
        }
        interface ISnapshot extends IHistory.ISnapshot<IMovable.SnapshotDestination, IMovable, Bounds> {
            /**
             * Called when the movable is copied to a new container.
             */
            copyTo(destination: IMovable.SnapshotDestination, options?: IMovable.CopyOptions): Promise<Bounds> | Bounds;
        }
        interface CopyOptions extends ReferenceableClipboard.CopyOptions {
            /** {@inheritDoc IMovable.SelectOptions} */
            autoSelect?: boolean | IMovable.SelectOptions;
        }
        interface OffsetCoords extends Partial<Point> {
            /** The row index */
            r: number;
            /** The column index */
            c: number;
        }
        interface AnchorOffset {
            tl: OffsetCoords;
            br: OffsetCoords;
        }
        interface ClientData {
            /**
             * disable selection on movable elements when the sheet is protected
             * @defaultValue false
             */
            fLocksWithSheet?: boolean;
            /**
             * print movable elements when printing the sheet
             * @defaultValue true
             */
            fPrintsWithSheet?: boolean;
        }
        interface ContentJSON<J> {
            /**
             * Identifies the type of movable object.
             *
             * @remarks
             * This must align to a known movable object type. Defined in the IEmbeddedDrawing interface.
             */
            type: string;
            /**
             * Underlying json.
             */
            json: J;
        }
        interface JSON<J = any> {
            /**
             * The anchor for the movable object.
             */
            anchor: IMovable.AnchorOffset;
            /**
             * The content of the movable object.
             */
            content: ContentJSON<J>;
            /**
             * The behavior of how the movable resizes as the anchor/cells change.
             */
            anchorType?: IAnchored.Type;
            /**
             * The name of the movable object.
             */
            name?: string;
            /**
             * This is the alternative text use for assistive technologies.
             *
             * @defaultValue null
             */
            description?: string;
            /**
             * If true then the movable object is hidden.
             *
             * @defaultValue false
             */
            hidden?: boolean;
            /**
             * The rotation in degrees.
             *
             * @defaultValue 0
             */
            rotation?: number;
            /**
             * Whether resizing should keep the aspect ratio.
             */
            lockAspect?: boolean;
            /**
             * lock specific fields*/
            locks?: any;
            clientData?: IMovable.ClientData;
        }
    }
}
declare module "movable/IMovableSelection" {
    import { IListener } from "listener/index";
    import { IMovable } from "movable/IMovable";
    /**
     * Manages a selection of `IMovable`a.
     */
    export interface IMovableSelection extends IListener.ISource<IMovableSelection> {
        /**
         * The movable selection.
         */
        getMovableSelection(): readonly IMovable[];
        /**
         * Select a movable object.
         *
         * @param movables
         * @param addToSelection
         */
        selectMovables(movables: readonly IMovable[], addToSelection?: boolean): this;
        /**
         * Returns the movable from the selection.
         *
         * @param movables
         */
        unselectMovables(movables: IMovable[]): this;
        /**
         * Add Listeners.
         *
         * @see
         * {@link IListener.ISource.addListeners}
         */
        addListeners(listeners: IMovableSelection.IListeners, options?: IListener.Options): IListener.Remove;
    }
    /**
     * {@inheritDoc IMovableSelection}
     * @see
     * ### **Interface**
     *
     * {@link IMovableSelection}
     */
    export namespace IMovableSelection {
        interface Events {
            /**
             * Called when the selection has changed.
             */
            onMovableSelectionChange?(source: IMovableSelection): void;
        }
        interface IListeners extends IListener.Callbacks<IMovableSelection, IMovableSelection.Events> {
        }
    }
}
declare module "movable/index" {
    export * from "movable/IMovable";
    export * from "movable/IMovableCollection";
    export * from "movable/IMovableSelection";
}
declare module "sheet/view/ISheetView" {
    import { IRange } from '@sheetxl/primitives';
    import { TopLeft } from '@sheetxl/utils';
    import { IListener } from "listener/index";
    import { IColor } from "color/index";
    import { IMovable, IMovableSelection } from "movable/index";
    import { IRangeSelection } from "selection/index";
    import { ISheet } from "sheet/index";
    /**
     * The `ISheetView` provides properties and methods for controlling how a sheet is displayed and interacted with,
     * without affecting the underlying data itself.
     *
     * View settings include aspects like frozen panes, zoom level, selection, gridlines visibility, and whether formulas are displayed.
     * but do not affect the underlying data itself.
     *
     * @remarks
     * * Since views only affect the presentation of the data, changes to view settings are typically not included in the undo/redo stack.
     * * Multiple views can be associated to the same collection of data, each providing a different way of viewing and interacting.
     */
    export interface ISheetView extends IMovableSelection, IListener.ISource<IMovableSelection> {
        /**
         * The default top left corner accounting for scrolling.
         */
        setTopLeft(topLeft: Partial<TopLeft> | null): this;
        /**
         * @see {@link setTopLeft}
         */
        getTopLeft(): Partial<TopLeft>;
        /**
         * The freeze panes.
         */
        setFreezePanes(freezePanes: ISheetView.FreezePanes): this;
        /**
         * @see {@link setFreezePanes}
         */
        getFreezePanes(): ISheetView.FreezePanes;
        /**
         * Show/Hide row headers.
         * @defaultValue true;
         */
        setShowRowHeaders(showRowHeaders: boolean): this;
        /**
         * @see {@link setShowRowHeaders}
         */
        isShowRowHeaders(): boolean;
        /**
         * Show/Hide columns headers.
         * @defaultValue true;
         */
        setShowColumnHeaders(showColumnHeaders: boolean): this;
        /**
         * @see {@link setShowColumnHeaders}
         */
        isShowColumnHeaders(): boolean;
        /**
         * Show/Hide row gridlines.
         * @defaultValue true;
         */
        setShowRowGridlines(showRowGridlines: boolean): this;
        /**
         * @see {@link setShowRowGridlines}
         */
        isShowRowGridlines(): boolean;
        /**
         * Show/Hide column gridlines.
         * @defaultValue true;
         */
        setShowColumnGridlines(showColumnGridlines: boolean): this;
        /**
         * @see {@link setShowColumnGridlines}
         */
        isShowColumnGridlines(): boolean;
        /**
         * Style of displaying default row header text
         * Note - This does not affect how formulas are resolved
         *
         * @defaultValue HeaderTextStyle.A1
         * // TODO - allow a function callback (but this won't be persisted)
         */
        setRowHeaderStyle(rowHeaderStyle: ISheetView.HeaderTextStyle): this;
        /**
         * @see {@link setRowHeaderStyle}
         */
        getRowHeaderStyle(): ISheetView.HeaderTextStyle;
        /**
         * Style of displaying default row header column
         * Note - This does not affect how formulas are resolved
         *
         * @defaultValue HeaderTextStyle.One
         * // TODO - allow a function callback (but this won't be persisted)
         */
        setColumnHeaderStyle(columnHeaderStyle: ISheetView.HeaderTextStyle): this;
        /**
         * @see {@link setColumnHeaderStyle}
         */
        getColumnHeaderStyle(): ISheetView.HeaderTextStyle;
        /**
         * Zoom. This is expressed as a percentage. Values can be between 10 (10%) or 400 (400%).
         *
         * @defaultValue 100
         * // TODO - support zoomScaleNormal, zoomScalePageLayout, zoomScaleSheetLayoutView,
         */
        setZoomScale(zoomScale: number): this;
        /**
         * @see {@link setZoomScale}
         */
        getZoomScale(): number;
        /**
         * Indicate if view is showing formulas or values
         *
         * @defaultValue false
         */
        setShowFormulas(showFormulas: boolean): this;
        /**
         * @see {@link setShowFormulas}
         */
        isShowFormulas(): boolean;
        /**
         * Indicate whether the sheet should show 0 (zero) or blanks in cells containing zero values.
         *
         * @defaultValue true
         *
         * @remarks
         * When false, cells with zero value appear blank instead of showing the number zero.
         */
        setShowZeros(showZeros: boolean): this;
        /**
         * @see {@link setShowZeros}
         */
        isShowZeros(): boolean;
        /**
         * The color of the gridline on the sheet.
         *
         * @defaultValue null (adopts the app theme color)
         *
         * @remarks
         * GridLine color is a sheet view attribute but in Excel is a workbook attribute.
         * If null then use the app theme.
         */
        setGridLineColor(gridLineColor: any): this;
        /**
         * @see {@link setGridLineColor}
         */
        getGridLineColor(): any;
        /**
         * The current selection for the view.
         *
         * @remarks
         * This is generally not set directly but through the selection object.
         */
        setRangeSelection(selection: IRangeSelection.Coords): this;
        /**
         * @see {@link setRangeSelection}
         */
        getRangeSelection(): IRangeSelection.Coords;
        /**
         * Add a movable to the selection.
         * If addToSelection is true then the items will be added to the selection.
         *
         * @param movables The movables to select.
         * @param addToSelection
         */
        selectMovables(movables: readonly IMovable[], addToSelection?: boolean): this;
        /**
         * Removes the movables from selection (if they were selected)
         * @param movables
         */
        unselectMovables(movables: readonly IMovable[]): this;
        /**
         * Allow for a bulk update of the view properties.
         *
         * @param properties
         */
        update(properties: ISheetView.Properties): this;
        /**
         * Set the view to initial values.
         * @param notify
         */
        clear(notify?: boolean): this;
        /**
         * Add Listeners.
         *
         * @see
         * {@link IListener.ISource.addListeners}
         */
        addListeners(listeners: ISheetView.IListeners, options?: IListener.Options): IListener.Remove;
        /**
         * Persist to JSON.
         *
         * @remarks
         * Returns null if it has no customized values.
         */
        toJSON(): ISheetView.JSON | null;
        /**
         * For runtime type checking.
         */
        readonly isISheetView: true;
    }
    /**
     * {@inheritDoc ISheetView}
     * @see
     * ### **Interface**
     *
     * {@link ISheetView}
     */
    export namespace ISheetView {
        /**
         * The coordinates for a FreezePane.
         *
         * Can have either a coordinate or a topLeft or both.
         */
        interface FreezePanes {
            /**
             * At least one direction must be set.
             */
            coords?: Partial<IRange.CellCoords>;
            /**
             * If scrolling then this will be set.
             * @remarks
             * If the current view has a scroll offset and
             * freeze is called it will 'transfer' the scroll coordinates.
             */
            topLeft?: Partial<TopLeft>;
        }
        /**
         * A listener for changes to the ISheetView object.
         */
        interface Events extends IMovableSelection.Events {
            /**
             * Called when the sheetView changes.
             */
            onTopLeftChange?(source: ISheetView): void;
            /**
             * Called when freeze or split settings have changed
             */
            onFreezeSplitChange?(source: ISheetView): void;
            /**
             * Called when the selection changes.
             */
            onRangeSelectionChange?(source: ISheetView): void;
            /**
             * Called when the movable selection changes.
             */
            onMovableSelectionChange?(source: ISheetView): void;
            /**
             * Called when the movable selection changes.
             */
            onAnyChange?(source: ISheetView): void;
        }
        interface IListeners extends IListener.Callbacks<ISheetView, ISheetView.Events> {
        }
        /**
         * A set of values that can be set on a ISheetView.
         *
         * @see
         * {@link ISheetView}
         */
        interface Properties {
            /** The selection coords.  */
            selection?: IRangeSelection.Coords;
            /** {@inheritDoc ISheetView.setTopLeft} */
            topLeft?: Partial<TopLeft>;
            /** {@inheritDoc ISheetView.setFreezePanes} */
            freezePanes?: ISheetView.FreezePanes;
            /** {@inheritDoc ISheetView.setShowRowHeaders} */
            showRowHeaders?: boolean;
            /** {@inheritDoc ISheetView.setShowColumnHeaders} */
            showColumnHeaders?: boolean;
            /** {@inheritDoc ISheetView.setShowRowGridlines} */
            showRowGridlines?: boolean;
            /** {@inheritDoc ISheetView.setShowColumnGridlines} */
            showColumnGridlines?: boolean;
            /** {@inheritDoc ISheetView.setRowHeaderStyle} */
            rowHeaderStyle?: ISheetView.HeaderTextStyle;
            /** {@inheritDoc ISheetView.setColumnHeaderStyle} */
            columnHeaderStyle?: ISheetView.HeaderTextStyle;
            /** {@inheritDoc ISheetView.setZoomScale} */
            zoomScale?: number;
            /** {@inheritDoc ISheetView.setShowFormulas} */
            showFormulas?: boolean;
            /** {@inheritDoc ISheetView.setShowZeros} */
            showZeros?: boolean;
            /** {@inheritDoc ISheetView.setGridLineColor} */
            gridLineColor?: string | IColor;
        }
        interface ConstructorOptions {
            /**
             * Sheets need to be associated with a sheet.
             */
            sheet: ISheet;
            /**
             * The state to load.
             */
            json?: ISheetView.JSON;
        }
        /**
         * A JSON representation useful for persistence.
         */
        interface JSON extends Omit<Properties, 'selection' | 'topLeft' | 'freezePanes' | 'zoomScale'> {
            selection?: IRangeSelection.Coords;
            topLeft?: string | Partial<TopLeft>;
            freezePanes?: string | FreezePanes;
            zoomScale?: string | number;
        }
        /**
         * The default style for displaying the header text.
         *
         * @remarks
         * This is a suggestion and may be ignored by the HeaderRenderer.
         */
        const HeaderTextStyle: {
            readonly A1: "a1";
            readonly Zero: "zero";
            readonly One: "one";
        };
        type HeaderTextStyle = typeof HeaderTextStyle[keyof typeof HeaderTextStyle];
    }
}
declare module "sheet/view/index" {
    export * from "sheet/view/ISheetView";
}
declare module "sheet/clipboard/SheetHTMLTableParser" {
    import { IRange } from '@sheetxl/primitives';
    import { ICell } from "cell/index";
    import { IStyleCollection } from "style/index";
    import { ISheet } from "sheet/index";
    import { IHTMLParser } from "sheet/clipboard/IHTMLParser";
    /**
     * Reads html and writes to an ISheet.
     */
    export class SheetHTMLTableParser implements IHTMLParser.TableParser {
        private _sheet;
        private _styles;
        private _topLeft;
        private _cellUpdater;
        private _mergedReading;
        private _colsReading;
        private _rowsReading;
        constructor(styles: IStyleCollection, date1904: boolean, description?: string, topLeft?: IRange.CellCoords);
        /**
         * Requires both to be non-null
         */
        applyCSSStyle(modifiers: ICell.Modifiers, cssStylesOriginal: Record<string, string>): void;
        onCell(coords: IRange.Coords, plainValue: string, htmlValue: string | null, getStyles: IHTMLParser.GetCSSStyles, element: Element | null): void;
        onNoTable(strValue: string, getStyles: IHTMLParser.GetCSSStyles, element: Element): void;
        onRowStart(rowIndex: number, rowSpan: number, getStyles: IHTMLParser.GetCSSStyles, element: HTMLTableRowElement | null): void;
        onColumn(colIndex: number, colSpan: number, getStyles: IHTMLParser.GetCSSStyles, element: HTMLTableColElement | null): void;
        onDone(): void;
        sheet(): ISheet;
    }
}
declare module "sheet/clipboard/RangeClipboardItems" {
    import { ReferenceableClipboard, EditMode } from '@sheetxl/utils';
    import { ICellRange } from "cellRange/index";
    import { IStyleCollection } from "style/index";
    import { ISheet } from "sheet/index";
    /**
     * Implements {@link ReferenceableClipboard.ReferenceItem} by delegating to {@link ICellRange.ISnapshot}.
     */
    export class RangeClipboardItem implements ReferenceableClipboard.ReferenceItem<ICellRange.ISnapshot> {
        protected _snapshot: ICellRange.ISnapshot;
        constructor(snapshot: ICellRange.ISnapshot);
        getItemType(): string;
        getItem(): ICellRange.ISnapshot;
        editMode(): EditMode;
        isCut(): boolean;
        getName(): string;
        toText(): Promise<string> | string;
        toHtml(): Promise<string> | string;
        toImage(): Promise<Blob> | Blob;
        get isClipboardItem(): true;
    }
    /**
     * Implements {@link ReferenceableClipboard.ReferenceItem} by creating a {@link ICellRange.ISnapshot} from
     * {@link ReferenceableClipboard.NativeItems}.
     *
     * @remarks
     * **IMPORTANT** Before this api can be used the async {@link parse} methods needs to be called and resolved.
     * @see
     * {@link parse}
     */
    export class ExternalRangeClipboardItem implements ReferenceableClipboard.ReferenceItem<ICellRange.ISnapshot> {
        private _native;
        private _markOptions;
        private _styles;
        private _isDate1904;
        private _snapshot;
        private _parsed;
        constructor(native: ReferenceableClipboard.NativeItems, markOptions?: ICellRange.CopyOptions, styles?: IStyleCollection, date1904?: boolean);
        getItemType(): string;
        isCut(): boolean;
        toText(): string;
        toHtml(): string;
        toImage(): Blob;
        getItem(): ICellRange.ISnapshot<ISheet>;
        /**
         * Required to be called before getItem().
         * @remarks
         * This is required because the ExternalClipboard lazy loads the parsing library.
         */
        parse(): Promise<boolean>;
        get isClipboardItem(): true;
    }
}
declare module "sheet/clipboard/index" {
    export * from "sheet/clipboard/RangeClipboardItems";
}
declare module "sheet/index" {
    export * from "sheet/view/index";
    export * from "sheet/header/index";
    export * from "sheet/protection/index";
    export * from "sheet/clipboard/index";
    export * from "sheet/ICellContainerOptions";
    export * from "sheet/ISheet";
    export * from "sheet/ISheetCollection";
    export * from "sheet/Sheet";
}
declare module "types-scripting" {
    /**
     * Scripting types entry point for Monaco editor and other scripting environments.
     * This file contains global ambient types specifically for use in script editors.
     */
    export {};
    type ISheet_Static = import("sheet/index").ISheet;
    type ISheet_JSON_Static = import("sheet/index").ISheet.JSON;
    type ISheet_Visibility_Static = import("sheet/index").ISheet.Visibility;
    type ISheet_Visibility_Runtime = typeof import("sheet/index").ISheet.Visibility;
    type IColor_Named_Static = import("color/index").IColor.Named;
    type IColor_Scheme_Static = import("color/index").IColor.Scheme;
    type IColor_Named_Runtime = typeof import("color/index").IColor.Named;
    type IColor_Scheme_Runtime = typeof import("color/index").IColor.Scheme;
    type SheetXL_Runtime = {
        ISheet: {
            Visibility: ISheet_Visibility_Runtime;
        };
        IColor: {
            Named: IColor_Named_Runtime;
            Scheme: IColor_Scheme_Runtime;
        };
        Direction: typeof import('@sheetxl/utils').Direction;
    };
    global {
        /**
         * SheetXL namespace. For full documentation see
         * {@link https://api.sheetxl.com | API Documentation}
         */
        namespace SheetXL {
            type ISheet = ISheet_Static;
            /**
             * Main interface. - Copy from interface.
             */
            namespace ISheet {
                /**
                 * For Persistence - Copy from interface
                 */
                type JSON = ISheet_JSON_Static;
                /**
                 * Makes it Visible - Copy from interface
                 */
                type Visibility = ISheet_Visibility_Static;
            }
            type IColor = import("color/index").IColor;
            /**
             * Copy from interface.
             */
            namespace IColor {
                /**
                 * Copy from interface.
                 */
                type Named = IColor_Named_Static;
                /**
                 * Copy from interface.
                 */
                type Scheme = IColor_Scheme_Static;
            }
            type Direction = import('@sheetxl/utils').Direction;
            type IWorkbook = import("workbook/index").IWorkbook;
            /**
             * Copy from interface.
             */
            namespace IWorkbook {
            }
            type ICellRanges = import("cellRange/index").ICellRanges;
            /**
             * Copy from interface.
             */
            namespace ICellRanges {
            }
            type ICellRange = import("cellRange/index").ICellRange;
            /**
             * Copy from interface.
             */
            namespace ICellRange {
            }
            type ICell = import("cell/index").ICell;
            /**
             * Copy from interface.
             */
            namespace ICell {
            }
            type ICellProtection = import("cell/index").ICellProtection;
            /**
             * Copy from interface.
             */
            namespace ICellProtection {
            }
            type IRangeSelection = import("selection/index").IRangeSelection;
            /**
             * Copy from interface.
             */
            namespace IRangeSelection {
            }
            type IStyle = import("style/index").IStyle;
            /**
             * Copy from interface.
             */
            namespace IStyle {
            }
            type IStyleCollection = import("style/index").IStyleCollection;
            /**
             * Copy from interface.
             */
            namespace IStyleCollection {
            }
            namespace ICalculation {
            }
        }
        export const SheetXL: SheetXL_Runtime;
    }
}