import * as ChartJs from 'chart.js';
import { ChartConfiguration, CoreChartOptions, Scriptable, Color as Color$1, ScriptableContext, FontSpec } from 'chart.js';

/**
 * Block of code that produces a value.
 */
interface FunctionCode {
    readonly returnExpression: string;
    /**
     * Return the same function code but with the return expression assigned to a variable.
     */
    assignResultToVariable(): FunctionCode;
}
declare class FunctionCodeBuilder {
    private scope;
    private code;
    constructor(scope?: Scope);
    append(...lines: (string | FunctionCode)[]): void;
    return(expression: string): FunctionCode;
    toString(): string;
}
declare class Scope {
    private nextId;
    private declaredVariables;
    nextVariableName(): string;
    isAlreadyDeclared(name: string): boolean;
}

type LocaleCode = string & Alias;
interface Locale {
    name: string;
    code: LocaleCode;
    thousandsSeparator?: string;
    decimalSeparator: string;
    weekStart: number;
    dateFormat: string;
    timeFormat: string;
    formulaArgSeparator: string;
}
declare const DEFAULT_LOCALES: Locale[];
declare const DEFAULT_LOCALE: Locale;

type Format = string & Alias;
type FormattedValue = string & Alias;

interface CellAttributes {
    readonly id: UID;
    /**
     * Raw cell content
     */
    readonly content: string;
    readonly format?: Format;
}
interface LiteralCell extends CellAttributes {
    readonly isFormula: false;
    readonly parsedValue: CellValue;
}
interface FormulaCell extends CellAttributes {
    readonly isFormula: true;
    readonly compiledFormula: RangeCompiledFormula;
}
type Cell = LiteralCell | FormulaCell;
interface EvaluatedCellProperties extends FunctionResultObject {
    readonly format?: Format;
    /**
     * Cell value formatted based on the format
     */
    readonly formattedValue: FormattedValue;
    readonly defaultAlign: "right" | "center" | "left";
    /**
     * Can the cell appear in an automatic sum zone.
     */
    readonly isAutoSummable: boolean;
    readonly link?: Link;
}
type CellValue = string | number | boolean | null;
type EvaluatedCell = NumberCell | TextCell | BooleanCell | EmptyCell | ErrorCell;
interface NumberCell extends EvaluatedCellProperties {
    readonly type: CellValueType.number;
    readonly value: number;
}
interface TextCell extends EvaluatedCellProperties {
    readonly type: CellValueType.text;
    readonly value: string;
}
interface BooleanCell extends EvaluatedCellProperties {
    readonly type: CellValueType.boolean;
    readonly value: boolean;
}
interface EmptyCell extends EvaluatedCellProperties {
    readonly type: CellValueType.empty;
    readonly value: null;
}
interface ErrorCell extends EvaluatedCellProperties {
    readonly type: CellValueType.error;
    readonly value: string;
    readonly message?: string;
}
declare enum CellValueType {
    boolean = "boolean",
    number = "number",
    text = "text",
    empty = "empty",
    error = "error"
}

/**
 * Tokenizer
 *
 * A tokenizer is a piece of code whose job is to transform a string into a list
 * of "tokens". For example, "(12+" is converted into:
 *   [{type: "LEFT_PAREN", value: "("},
 *    {type: "NUMBER", value: "12"},
 *    {type: "OPERATOR", value: "+"}]
 *
 * As the example shows, a tokenizer does not care about the meaning behind those
 * tokens. It only cares about the structure.
 *
 * The tokenizer is usually the first step in a compilation pipeline.  Also, it
 * is useful for the composer, which needs to be able to work with incomplete
 * formulas.
 */
declare const POSTFIX_UNARY_OPERATORS: string[];
type TokenType = "OPERATOR" | "NUMBER" | "STRING" | "SYMBOL" | "SPACE" | "DEBUGGER" | "ARG_SEPARATOR" | "ARRAY_ROW_SEPARATOR" | "LEFT_PAREN" | "RIGHT_PAREN" | "LEFT_BRACE" | "RIGHT_BRACE" | "REFERENCE" | "INVALID_REFERENCE" | "UNKNOWN";
interface Token {
    readonly type: TokenType;
    readonly value: string;
}
declare function tokenize(str: string, locale?: Locale): Token[];

interface BarChartDefinition extends CommonChartDefinition {
    readonly type: "bar";
    readonly stacked: boolean;
    readonly horizontal?: boolean;
    readonly zoomable?: boolean;
}
type BarChartRuntime = {
    chartJsConfig: ChartConfiguration<"bar" | "line">;
    masterChartConfig?: ChartConfiguration<"bar">;
    background: Color;
};

interface GenericCriterion {
    type: GenericCriterionType;
    values: string[];
}
type GenericCriterionType = "containsText" | "notContainsText" | "isEqualText" | "isEmail" | "isLink" | "dateIs" | "dateIsBefore" | "dateIsOnOrBefore" | "dateIsAfter" | "dateIsOnOrAfter" | "dateIsBetween" | "dateIsNotBetween" | "dateIsValid" | "isEqual" | "isNotEqual" | "isGreaterThan" | "isGreaterOrEqualTo" | "isLessThan" | "isLessOrEqualTo" | "isBetween" | "isNotBetween" | "isBoolean" | "isValueInList" | "isValueInRange" | "customFormula" | "beginsWithText" | "endsWithText" | "isNotEmpty" | "isEmpty";
type DateCriterionValue = "today" | "tomorrow" | "yesterday" | "lastWeek" | "lastMonth" | "lastYear" | "exactDate";
type EvaluatedCriterion<T extends GenericCriterion = GenericCriterion> = Omit<T, "values"> & {
    values: CellValue[];
};

interface RangePart {
    readonly colFixed: boolean;
    readonly rowFixed: boolean;
}
interface Range {
    readonly zone: Readonly<Zone>;
    readonly unboundedZone: Readonly<UnboundedZone>;
    readonly parts: readonly RangePart[];
    readonly invalidXc?: string;
    /** true if the user provided the range with the sheet name */
    readonly prefixSheet: boolean;
    /** the name of any sheet that is invalid */
    readonly invalidSheetName?: string;
    /** the sheet on which the range is defined */
    readonly sheetId: UID;
}
interface RangeStringOptions {
    useBoundedReference?: boolean;
    useFixedReference?: boolean;
}
interface RangeData {
    _zone: Zone | UnboundedZone;
    _sheetId: UID;
}

interface Table {
    readonly id: TableId;
    readonly range: Range;
    readonly filters: Filter[];
    readonly config: TableConfig;
}
interface StaticTable extends Table {
    readonly type: "static" | "forceStatic";
}
interface DynamicTable extends Omit<Table, "filters"> {
    readonly type: "dynamic";
}
type CoreTable = StaticTable | DynamicTable;
type CoreTableType = Extract<CoreTable, {
    type: string;
}>["type"];
interface Filter {
    readonly id: UID;
    readonly rangeWithHeaders: Range;
    readonly col: number;
    /** The filtered zone doesn't includes the headers of the table */
    readonly filteredRange: Range | undefined;
}
interface TableConfig {
    hasFilters: boolean;
    totalRow: boolean;
    firstColumn: boolean;
    lastColumn: boolean;
    numberOfHeaders: number;
    bandedRows: boolean;
    bandedColumns: boolean;
    automaticAutofill?: boolean;
    styleId: string;
}
interface TableElementStyle {
    border?: TableBorder;
    style?: Style;
    size?: number;
}
interface TableBorder extends Border {
    horizontal?: BorderDescr;
    vertical?: BorderDescr;
}
interface TableStyle {
    category: string;
    displayName: string;
    templateName: TableStyleTemplateName;
    primaryColor: string;
    wholeTable?: TableElementStyle;
    firstColumnStripe?: TableElementStyle;
    secondColumnStripe?: TableElementStyle;
    firstRowStripe?: TableElementStyle;
    secondRowStripe?: TableElementStyle;
    firstColumn?: TableElementStyle;
    lastColumn?: TableElementStyle;
    headerRow?: TableElementStyle;
    totalRow?: TableElementStyle;
}
type TableStyleTemplateName = "none" | "lightColoredText" | "lightAllBorders" | "mediumAllBorders" | "lightWithHeader" | "mediumBandedBorders" | "mediumMinimalBorders" | "darkNoBorders" | "mediumWhiteBorders" | "dark";
declare const filterCriterions: GenericCriterionType[];
type FilterCriterionType = (typeof filterCriterions)[number];
interface ValuesFilter {
    filterType: "values";
    hiddenValues: string[];
}
interface CriterionFilter {
    filterType: "criterion";
    type: FilterCriterionType | "none";
    values: string[];
    dateValue?: DateCriterionValue;
}
type DataFilterValue = ValuesFilter | CriterionFilter;

declare class PositionMap<T> {
    private map;
    constructor(entries?: Iterable<readonly [CellPosition, T]>);
    set({ sheetId, col, row }: CellPosition, value: T): void;
    setMany(values: Iterable<[CellPosition, T]>): void;
    get({ sheetId, col, row }: CellPosition): T | undefined;
    getSheet(sheetId: UID): Record<number, Record<number, T>> | undefined;
    clearSheet(sheetId: UID): void;
    has({ sheetId, col, row }: CellPosition): boolean;
    delete({ sheetId, col, row }: CellPosition): void;
    keys(): CellPosition[];
    keysForSheet(sheetId: UID): CellPosition[];
    entries(): IterableIterator<[CellPosition, T]>;
}

/**
 * An Operation can be executed to change a data structure from state A
 * to state B.
 * It should hold the necessary data used to perform this transition.
 * It should be possible to revert the changes made by this operation.
 *
 * In the context of o-spreadsheet, the data from an operation would
 * be a revision (the commands are used to execute it, the `changes` are used
 * to revert it).
 */
declare class Operation<T> {
    readonly id: UID;
    readonly data: T;
    constructor(id: UID, data: T);
    transformed(transformation: Transformation<T>): Operation<T>;
}

/**
 * A branch holds a sequence of operations.
 * It can be represented as "A - B - C - D" if A, B, C and D are executed one
 * after the other.
 *
 * @param buildTransformation Factory to build transformations
 * @param operations initial operations
 */
declare class Branch<T> {
    private readonly buildTransformation;
    private operations;
    constructor(buildTransformation: TransformationFactory<T>, operations?: Operation<T>[]);
    getOperations(): readonly Operation<T>[];
    getOperation(operationId: UID): Operation<T>;
    getLastOperationId(): UID | undefined;
    /**
     * Get the id of the operation appears first in the list of operations
     */
    getFirstOperationAmong(op1: UID, op2: UID): UID;
    contains(operationId: UID): boolean;
    /**
     * Add the given operation as the first operation
     */
    prepend(operation: Operation<T>): void;
    /**
     * add the given operation after the given predecessorOpId
     */
    insert(newOperation: Operation<T>, predecessorOpId: UID): void;
    /**
     * Add the given operation as the last operation
     */
    append(operation: Operation<T>): void;
    /**
     * Append operations in the given branch to this branch.
     */
    appendBranch(branch: Branch<T>): void;
    /**
     * Create and return a copy of this branch, starting after the given operationId
     */
    fork(operationId: UID): Branch<T>;
    /**
     * Transform all the operations in this branch with the given transformation
     */
    transform(transformation: Transformation<T>): void;
    /**
     * Cut the branch before the operation, meaning the operation
     * and all following operations are dropped.
     */
    cutBefore(operationId: UID): void;
    /**
     * Cut the branch after the operation, meaning all following operations are dropped.
     */
    cutAfter(operationId: UID): void;
    /**
     * Find an operation in this branch based on its id.
     * This returns the operation itself, operations which comes before it
     * and operation which comes after it.
     */
    private locateOperation;
}

interface CreateRevisionOptions {
    revisionId?: UID;
    clientId?: UID;
    pending?: boolean;
}
interface HistoryChange {
    key: string;
    target: any;
    before: any;
}
interface WorkbookHistory<Plugin> {
    update<T extends keyof Plugin>(key: T, val: Plugin[T]): void;
    update<T extends keyof Plugin, U extends keyof NonNullable<Plugin[T]>>(key1: T, key2: U, val: NonNullable<Plugin[T]>[U]): void;
    update<T extends keyof Plugin, U extends keyof NonNullable<Plugin[T]>, K extends keyof NonNullable<NonNullable<Plugin[T]>[U]>>(key1: T, key2: U, key3: K, val: NonNullable<NonNullable<Plugin[T]>[U]>[K]): void;
    update<T extends keyof Plugin, U extends keyof NonNullable<Plugin[T]>, K extends keyof NonNullable<NonNullable<Plugin[T]>[U]>, V extends keyof NonNullable<NonNullable<NonNullable<Plugin[T]>[U]>[K]>>(key1: T, key2: U, key3: K, key4: V, val: NonNullable<NonNullable<NonNullable<Plugin[T]>[U]>[K]>[V]): void;
    update<T extends keyof Plugin, U extends keyof NonNullable<Plugin[T]>, K extends keyof NonNullable<NonNullable<Plugin[T]>[U]>, V extends keyof NonNullable<NonNullable<NonNullable<Plugin[T]>[U]>[K]>, W extends keyof NonNullable<NonNullable<NonNullable<NonNullable<Plugin[T]>[U]>[K]>[V]>>(key1: T, key2: U, key3: K, key4: V, key5: W, val: NonNullable<NonNullable<NonNullable<NonNullable<Plugin[T]>[U]>[K]>[V]>[W]): void;
    update<T extends keyof Plugin, U extends keyof NonNullable<Plugin[T]>, K extends keyof NonNullable<NonNullable<Plugin[T]>[U]>, V extends keyof NonNullable<NonNullable<NonNullable<Plugin[T]>[U]>[K]>, W extends keyof NonNullable<NonNullable<NonNullable<NonNullable<Plugin[T]>[U]>[K]>[V]>, Y extends keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<Plugin[T]>[U]>[K]>[V]>[W]>>(key1: T, key2: U, key3: K, key4: V, key5: W, key6: Y, val: NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<Plugin[T]>[U]>[K]>[V]>[W]>[Y]): void;
}
type Transformation<T = unknown> = (dataToTransform: T) => T;
interface TransformationFactory<T = unknown> {
    /**
     * Build a transformation function to transform any operation as if the execution of
     * a previous `operation` was omitted.
     */
    without: (operation: T) => Transformation<T>;
    /**
     * Build a transformation function to transform any operation as if a new `operation` was
     * executed before.
     */
    with: (operation: T) => Transformation<T>;
}
interface OperationSequenceNode<T> {
    operation: Operation<T>;
    branch: Branch<T>;
    isCancelled: boolean;
    next?: {
        operation: Operation<T>;
        branch: Branch<T>;
    };
}

type HistoryPath = [any, ...(number | string)[]];
declare class StateObserver {
    private changes;
    private commands;
    /**
     * Record the changes which could happen in the given callback, save them in a
     * new revision with the given id and userId.
     */
    recordChanges(callback: () => void): {
        changes: HistoryChange[];
        commands: CoreCommand[];
    };
    addCommand(command: CoreCommand): void;
    addChange(...args: [...HistoryPath, any]): void;
}

interface CarouselState {
    readonly carousels: Record<UID, Record<UID, Carousel | undefined> | undefined>;
}
declare class CarouselPlugin extends CorePlugin<CarouselState> implements CarouselState {
    static getters: readonly ["getCarousel", "doesCarouselExist"];
    readonly carousels: Record<UID, Record<UID, Carousel | undefined> | undefined>;
    allowDispatch(cmd: CoreCommand): CommandResult.Success | CommandResult.InvalidFigureId | CommandResult.DuplicatedFigureId;
    handle(cmd: CoreCommand): void;
    doesCarouselExist(figureId: UID): boolean;
    getCarousel(figureId: UID): Carousel;
    private removeDeletedCharts;
    import(data: WorkbookData): void;
    export(data: WorkbookData): void;
}

interface CoreState$1 {
    cells: Record<UID, Record<UID, Cell | undefined> | undefined>;
    nextId: number;
}
/**
 * Core Plugin
 *
 * This is the most fundamental of all plugins. It defines how to interact with
 * cell and sheet content.
 */
declare class CellPlugin extends CorePlugin<CoreState$1> implements CoreState$1 {
    static getters: readonly ["zoneToXC", "getCells", "getTranslatedCellFormula", "getCellById", "getFormulaString", "getFormulaMovedInSheet"];
    readonly nextId = 1;
    readonly cells: {
        [sheetId: string]: {
            [id: string]: Cell;
        };
    };
    adaptRanges({ applyChange }: RangeAdapterFunctions, sheetId: UID, sheetName: AdaptSheetName): void;
    allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
    handle(cmd: CoreCommand): void;
    private clearZones;
    /**
     * Set a format to all the cells in a zone
     */
    private setFormatter;
    /**
     * Clear the styles and format of zones
     */
    private clearFormatting;
    /**
     * Clear the styles, the format and the content of zones
     */
    private clearCells;
    /**
     * Copy the format of the reference column/row to the new columns/rows.
     */
    private handleAddColumnsRows;
    import(data: WorkbookData): void;
    export(data: WorkbookData): void;
    importCell(sheetId: UID, content?: string, format?: Format): Cell;
    exportForExcel(data: ExcelWorkbookData): void;
    getCells(sheetId: UID): Record<UID, Cell>;
    /**
     * get a cell by ID. Used in evaluation when evaluating an async cell, we need to be able to find it back after
     * starting an async evaluation even if it has been moved or re-allocated
     */
    getCellById(cellId: UID): Cell | undefined;
    getFormulaString(sheetId: UID, tokens: Token[], dependencies: Range[], useBoundedReference?: boolean): string;
    getTranslatedCellFormula(sheetId: UID, offsetX: number, offsetY: number, tokens: Token[]): string;
    getFormulaMovedInSheet(originSheetId: UID, targetSheetId: UID, tokens: Token[]): string;
    /**
     * Converts a zone to a XC coordinate system
     *
     * The conversion also treats merges as one single cell
     *
     * Examples:
     * {top:0,left:0,right:0,bottom:0} ==> A1
     * {top:0,left:0,right:1,bottom:1} ==> A1:B2
     *
     * if A1:B2 is a merge:
     * {top:0,left:0,right:1,bottom:1} ==> A1
     * {top:1,left:0,right:1,bottom:2} ==> A1:B3
     *
     * if A1:B2 and A4:B5 are merges:
     * {top:1,left:0,right:1,bottom:3} ==> A1:A5
     */
    zoneToXC(sheetId: UID, zone: Zone, fixedParts?: RangePart[]): string;
    /**
     * Copy the format of one column to other columns.
     */
    private copyColumnFormat;
    /**
     * Copy the format of one row to other rows.
     */
    private copyRowFormat;
    /**
     * gets the currently used style and format of a cell based on it's coordinates
     */
    private getFormat;
    private getNextUid;
    private updateCell;
    private createCell;
    private createLiteralCell;
    private createFormulaCell;
    /**
     * Create a new formula cell with the content
     * being a computed property to rebuild the dependencies XC.
     */
    private createFormulaCellWithDependencies;
    private checkCellOutOfSheet;
    private checkUselessClearCell;
    private checkUselessUpdateCell;
}

interface Validator {
    /**
     * Combine multiple validation functions into a single function
     * returning the list of result of every validation.
     */
    batchValidations<T>(...validations: Validation<T>[]): Validation<T>;
    /**
     * Combine multiple validation functions. Every validation is executed one after
     * the other. As soon as one validation fails, it stops and the cancelled reason
     * is returned.
     */
    chainValidations<T>(...validations: Validation<T>[]): Validation<T>;
    checkValidations<T>(command: T, ...validations: Validation<T>[]): CommandResult | CommandResult[];
}

/**
 * AbstractChart is the class from which every Chart should inherit.
 * The role of this class is to maintain the state of each chart.
 */
declare abstract class AbstractChart {
    readonly sheetId: UID;
    readonly title: TitleDesign;
    abstract readonly type: ChartType;
    protected readonly getters: CoreGetters;
    readonly humanize: boolean;
    constructor(definition: ChartDefinition, sheetId: UID, getters: CoreGetters);
    /**
     * Validate the chart definition given as arguments. This function will be
     * called from allowDispatch function
     */
    static validateChartDefinition(validator: Validator, definition: ChartDefinition): CommandResult | CommandResult[];
    /**
     * Get a new chart definition transformed with the executed command. This
     * functions will be called during operational transform process
     */
    static transformDefinition(chartSheetId: UID, definition: ChartDefinition, applyChange: RangeAdapter): ChartDefinition;
    /**
     * Get an empty definition based on the given context
     */
    static getDefinitionFromContextCreation(context: ChartCreationContext): ChartDefinition;
    /**
     * Get the definition of the chart
     */
    abstract getDefinition(): ChartDefinition;
    /**
     * Get the definition of the chart that will be used for excel export.
     * If the chart is not supported by Excel, this function returns undefined.
     */
    abstract getDefinitionForExcel(getters: CoreGetters): ExcelChartDefinition | undefined;
    /**
     * This function should be used to update all the ranges of the chart after
     * a grid change (add/remove col/row, rename sheet, ...)
     */
    abstract updateRanges(rangeAdapters: RangeAdapterFunctions): AbstractChart;
    /**
     * Duplicate the chart when a sheet is duplicated.
     * The ranges that are in the same sheet as the chart are adapted to the new sheetId.
     */
    abstract duplicateInDuplicatedSheet(newSheetId: UID): AbstractChart;
    /**
     * Get a copy a the chart in the given sheetId.
     * The ranges of the chart will stay the same as the copied chart.
     */
    abstract copyInSheetId(sheetId: UID): AbstractChart;
    /**
     * Extract the ChartCreationContext of the chart
     */
    abstract getContextCreation(): ChartCreationContext;
    protected getCommonDataSetAttributesForExcel(labelRange: Range | undefined, dataSets: DataSet[], shouldRemoveFirstLabel: boolean): {
        dataSets: ExcelChartDataset[];
        labelRange: string | undefined;
    };
}

interface FigureChart {
    figureId: UID;
    chart: AbstractChart;
}
interface ChartState {
    readonly charts: Record<UID, FigureChart | undefined>;
}
declare class ChartPlugin extends CorePlugin<ChartState> implements ChartState {
    static getters: readonly ["isChartDefined", "getChartDefinition", "getChartType", "getChartIds", "getChart", "getFigureIdFromChartId", "getContextCreationChart"];
    readonly charts: Record<UID, FigureChart | undefined>;
    private createChart;
    private validateChartDefinition;
    adaptRanges(rangeAdapters: RangeAdapterFunctions): void;
    allowDispatch(cmd: Command): CommandResult | CommandResult[];
    handle(cmd: CoreCommand): void;
    getContextCreationChart(chartId: UID): ChartCreationContext | undefined;
    getChart(chartId: UID): AbstractChart | undefined;
    getFigureIdFromChartId(chartId: UID): UID;
    getChartType(chartId: UID): ChartType;
    isChartDefined(chartId: UID): boolean;
    getChartIds(sheetId: UID): string[];
    getChartDefinition(chartId: UID): ChartDefinition;
    import(data: WorkbookData): void;
    export(data: WorkbookData): void;
    /**
     * Add a figure with tag chart with the given id at the given position
     */
    private addFigure;
    /**
     * Add a chart in the local state. If a chart already exists, this chart is
     * replaced
     */
    private addChart;
    private checkChartDuplicate;
    private checkChartExists;
    private checkChartChanged;
    /** If the command is meant to create a new figure, the position & offset argument need to be defined in the command */
    private checkFigureArguments;
}

/**
 * https://docs.microsoft.com/en-us/openspecs/office_standards/ms-xlsx/025ea6e4-ad42-43ea-a016-16f4e4688ac8
 */
interface ConditionalFormat {
    id: UID;
    rule: ConditionalFormatRule;
    stopIfTrue?: boolean;
    ranges: string[];
}
interface ConditionalFormatInternal extends Omit<ConditionalFormat, "ranges" | "rule"> {
    ranges: Range[];
    rule: ConditionalFormatRuleInternal;
}
type ConditionalFormatRule = SingleColorRules | ColorScaleRule | IconSetRule | DataBarRule;
type ConditionalFormatRuleInternal = SingleColorRules | ColorScaleRule | IconSetRule | DataBarRuleInternal;
type SingleColorRules = CellIsRule;
interface SingleColorRule {
    style: Style;
}
interface CellIsRule extends SingleColorRule {
    type: "CellIsRule";
    operator: ConditionalFormattingOperatorValues;
    values: string[];
    dateValue?: DateCriterionValue;
}
type ThresholdType = "value" | "number" | "percentage" | "percentile" | "formula";
type ColorScaleThreshold = {
    color: number;
    type: ThresholdType;
    value?: string;
};
type ColorScaleMidPointThreshold = {
    color: number;
    type: Exclude<ThresholdType, "value">;
    value: string;
};
type IconThreshold = {
    type: Exclude<ThresholdType, "value">;
    operator: "gt" | "ge";
    value: string;
};
interface ColorScaleRule {
    type: "ColorScaleRule";
    minimum: ColorScaleThreshold;
    maximum: ColorScaleThreshold;
    midpoint?: ColorScaleMidPointThreshold;
}
interface DataBarRule {
    type: "DataBarRule";
    color: number;
    rangeValues?: string;
}
interface DataBarRuleInternal extends Omit<DataBarRule, "rangeValues"> {
    rangeValues?: Range;
}
interface IconSet {
    upper: string;
    middle: string;
    lower: string;
}
interface IconSetRule {
    type: "IconSetRule";
    icons: IconSet;
    upperInflectionPoint: IconThreshold;
    lowerInflectionPoint: IconThreshold;
}
declare const cfOperators: readonly ["containsText", "notContainsText", "isGreaterThan", "isGreaterOrEqualTo", "isLessThan", "isLessOrEqualTo", "isBetween", "isNotBetween", "beginsWithText", "endsWithText", "isNotEmpty", "isEmpty", "isNotEqual", "isEqual", "customFormula", "dateIs", "dateIsBefore", "dateIsAfter", "dateIsOnOrBefore", "dateIsOnOrAfter"];
type ConditionalFormattingOperatorValues = (typeof cfOperators)[number];

interface ConditionalFormatState {
    readonly cfRules: {
        [sheet: string]: ConditionalFormatInternal[];
    };
}
declare class ConditionalFormatPlugin extends CorePlugin<ConditionalFormatState> implements ConditionalFormatState {
    static getters: readonly ["getConditionalFormats", "getRulesSelection", "getRulesByCell", "getAdaptedCfRanges"];
    readonly cfRules: {
        [sheet: string]: ConditionalFormatInternal[];
    };
    adaptCFFormulas({ applyChange, adaptFormulaString }: RangeAdapterFunctions): void;
    adaptCFRanges(sheetId: UID, { applyChange }: RangeAdapterFunctions): void;
    adaptRanges(rangeAdapters: RangeAdapterFunctions, sheetId: UID): void;
    allowDispatch(cmd: Command): CommandResult | CommandResult[];
    handle(cmd: CoreCommand): void;
    import(data: WorkbookData): void;
    export(data: Partial<WorkbookData>): void;
    exportForExcel(data: ExcelWorkbookData): void;
    /**
     * Returns all the conditional format rules defined for the current sheet to display the user
     */
    getConditionalFormats(sheetId: UID): ConditionalFormat[];
    getRulesSelection(sheetId: UID, selection: Zone[]): UID[];
    getRulesByZone(sheetId: UID, zone: Zone): Set<UID>;
    getRulesByCell(sheetId: UID, cellCol: number, cellRow: number): Set<ConditionalFormat>;
    /**
     * Add or remove cells to a given conditional formatting rule and return the adapted CF's XCs.
     */
    getAdaptedCfRanges(sheetId: UID, cf: ConditionalFormat, toAdd: Zone[], toRemove: Zone[]): RangeData[] | undefined;
    private mapToConditionalFormat;
    private mapToConditionalFormatInternal;
    /**
     * Add or replace a conditional format rule
     */
    private addConditionalFormatting;
    private checkValidPriorityChange;
    private checkEmptyRange;
    private checkCFRule;
    private checkCFHasChanged;
    private checkOperatorArgsNumber;
    private checkNaN;
    private checkFormulaCompilation;
    private checkThresholds;
    private checkInflectionPoints;
    private checkLowerBiggerThanUpper;
    private checkMinBiggerThanMax;
    private checkMidBiggerThanMax;
    private checkMinBiggerThanMid;
    private checkCFValues;
    private removeConditionalFormatting;
    private changeCFPriority;
}

interface DataValidationRule {
    id: UID;
    criterion: DataValidationCriterion;
    ranges: Range[];
    isBlocking?: boolean;
}
type TextContainsCriterion = {
    type: "containsText";
    values: string[];
};
type TextNotContainsCriterion = {
    type: "notContainsText";
    values: string[];
};
type TextIsCriterion = {
    type: "isEqualText";
    values: string[];
};
type TextIsEmailCriterion = {
    type: "isEmail";
    values: string[];
};
type TextIsLinkCriterion = {
    type: "isLink";
    values: string[];
};
type DateIsCriterion = {
    type: "dateIs";
    dateValue: DateCriterionValue;
    values: string[];
};
type DateIsBeforeCriterion = {
    type: "dateIsBefore";
    dateValue: DateCriterionValue;
    values: string[];
};
type DateIsOnOrBeforeCriterion = {
    type: "dateIsOnOrBefore";
    dateValue: DateCriterionValue;
    values: string[];
};
type DateIsAfterCriterion = {
    type: "dateIsAfter";
    dateValue: DateCriterionValue;
    values: string[];
};
type DateIsOnOrAfterCriterion = {
    type: "dateIsOnOrAfter";
    dateValue: DateCriterionValue;
    values: string[];
};
type DateIsBetweenCriterion = {
    type: "dateIsBetween";
    values: string[];
};
type DateIsNotBetweenCriterion = {
    type: "dateIsNotBetween";
    values: string[];
};
type DateIsValidCriterion = {
    type: "dateIsValid";
    values: string[];
};
type IsEqualCriterion = {
    type: "isEqual";
    values: string[];
};
type IsNotEqualCriterion = {
    type: "isNotEqual";
    values: string[];
};
type IsGreaterThanCriterion = {
    type: "isGreaterThan";
    values: string[];
};
type IsGreaterOrEqualToCriterion = {
    type: "isGreaterOrEqualTo";
    values: string[];
};
type IsLessThanCriterion = {
    type: "isLessThan";
    values: string[];
};
type IsLessOrEqualToCriterion = {
    type: "isLessOrEqualTo";
    values: string[];
};
type IsBetweenCriterion = {
    type: "isBetween";
    values: string[];
};
type IsNotBetweenCriterion = {
    type: "isNotBetween";
    values: string[];
};
type IsCheckboxCriterion = {
    type: "isBoolean";
    values: string[];
};
type IsValueInListCriterion = {
    type: "isValueInList";
    values: string[];
    colors?: Record<string, Color | undefined>;
    displayStyle: "arrow" | "plainText" | "chip";
};
type IsValueInRangeCriterion = {
    type: "isValueInRange";
    values: string[];
    colors?: Record<string, Color | undefined>;
    displayStyle: "arrow" | "plainText" | "chip";
};
type CustomFormulaCriterion = {
    type: "customFormula";
    values: string[];
};
type DataValidationCriterion = TextContainsCriterion | TextNotContainsCriterion | TextIsCriterion | TextIsEmailCriterion | TextIsLinkCriterion | IsBetweenCriterion | DateIsCriterion | DateIsBeforeCriterion | DateIsOnOrBeforeCriterion | DateIsAfterCriterion | DateIsOnOrAfterCriterion | DateIsBetweenCriterion | DateIsNotBetweenCriterion | DateIsValidCriterion | IsEqualCriterion | IsNotEqualCriterion | IsGreaterThanCriterion | IsGreaterOrEqualToCriterion | IsLessThanCriterion | IsLessOrEqualToCriterion | IsNotBetweenCriterion | IsCheckboxCriterion | IsValueInListCriterion | IsValueInRangeCriterion | CustomFormulaCriterion;
type DataValidationCriterionType = DataValidationCriterion["type"];

interface DataValidationState {
    readonly rules: {
        [sheet: string]: DataValidationRule[];
    };
}
declare class DataValidationPlugin extends CorePlugin<DataValidationState> implements DataValidationState {
    static getters: readonly ["cellHasListDataValidationIcon", "getDataValidationRule", "getDataValidationRules", "getValidationRuleForCell"];
    readonly rules: {
        [sheet: string]: DataValidationRule[];
    };
    adaptRanges(rangeAdapters: RangeAdapterFunctions, sheetId: UID): void;
    private adaptDVFormulas;
    private adaptDVRanges;
    allowDispatch(cmd: Command): CommandResult | CommandResult[];
    handle(cmd: CoreCommand): void;
    getDataValidationRules(sheetId: UID): DataValidationRule[];
    getDataValidationRule(sheetId: UID, id: UID): DataValidationRule | undefined;
    getValidationRuleForCell({ sheetId, col, row }: CellPosition): DataValidationRule | undefined;
    cellHasListDataValidationIcon(cellPosition: CellPosition): boolean;
    private addDataValidationRule;
    private removeRangesFromRules;
    private removeDataValidationRule;
    private setCenterStyleToBooleanCells;
    private checkEmptyRange;
    import(data: WorkbookData): void;
    export(data: Partial<WorkbookData>): void;
    exportForExcel(data: ExcelWorkbookData): void;
    private checkCriterionTypeIsValid;
    private checkCriterionHasValidNumberOfValues;
    private checkCriterionValuesAreValid;
    private checkValidRange;
}

interface FigureState {
    readonly figures: {
        [sheet: string]: Record<UID, Figure | undefined> | undefined;
    };
    readonly insertionOrders: UID[];
}
declare class FigurePlugin extends CorePlugin<FigureState> implements FigureState {
    static getters: readonly ["getFigures", "getFigure", "getFigureSheetId"];
    readonly figures: {
        [sheet: string]: Record<UID, Figure | undefined> | undefined;
    };
    readonly insertionOrders: UID[];
    adaptRanges({ applyChange }: RangeAdapterFunctions, sheetId: UID): void;
    allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
    beforeHandle(cmd: CoreCommand): void;
    handle(cmd: CoreCommand): void;
    private onColRemove;
    private onRowRemove;
    private getPositionInSheet;
    private updateFigure;
    private addFigure;
    private deleteSheet;
    private removeFigure;
    private checkFigureExists;
    private checkFigureDuplicate;
    private checkFigureAnchorOffset;
    getFigures(sheetId: UID): Figure[];
    getFigure(sheetId: UID, figureId: string): Figure | undefined;
    getFigureSheetId(figureId: string): UID | undefined;
    import(data: WorkbookData): void;
    export(data: WorkbookData): void;
    exportForExcel(data: ExcelWorkbookData): void;
}

interface State {
    groups: Record<UID, Record<Dimension, HeaderGroup[]>>;
}
declare class HeaderGroupingPlugin extends CorePlugin<State> {
    static getters: readonly ["getHeaderGroups", "getGroupsLayers", "getVisibleGroupLayers", "getHeaderGroup", "getHeaderGroupsInZone", "isGroupFolded", "isRowFolded", "isColFolded"];
    private readonly groups;
    allowDispatch(cmd: CoreCommand): CommandResult;
    handle(cmd: CoreCommand): void;
    getHeaderGroups(sheetId: UID, dim: Dimension): HeaderGroup[];
    getHeaderGroup(sheetId: UID, dim: Dimension, start: number, end: number): HeaderGroup | undefined;
    getHeaderGroupsInZone(sheetId: UID, dim: Dimension, zone: Zone): HeaderGroup[];
    /**
     * Get all the groups of a sheet in a dimension, and return an array of layers of those groups.
     *
     * The layering rules are:
     * 1) A group containing another group should be on a layer above the group it contains
     * 2) The widest/highest groups should be on the left/top layer compared to the groups it contains
     * 3) The group should be on the left/top-most layer possible, barring intersections with other groups (see rules 1 and 2)
     */
    getGroupsLayers(sheetId: UID, dimension: Dimension): HeaderGroup[][];
    /**
     * Get all the groups of a sheet in a dimension, and return an array of layers of those groups,
     * excluding the groups that are totally hidden.
     */
    getVisibleGroupLayers(sheetId: UID, dimension: Dimension): HeaderGroup[][];
    isGroupFolded(sheetId: UID, dimension: Dimension, start: number, end: number): boolean;
    isRowFolded(sheetId: UID, row: HeaderIndex): boolean;
    isColFolded(sheetId: UID, col: HeaderIndex): boolean;
    private getGroupId;
    /**
     * To get layers of groups, and to add/remove headers from groups, we can see each header of a group as a brick. Each
     * brick falls down in the pile corresponding to its header, until it hits another brick, or the ground.
     *
     * With this abstraction, we can very simply group/ungroup headers from groups, and get the layers of groups.
     * - grouping headers is done by adding a brick to each header pile
     * - un-grouping headers is done by removing a brick from each header pile
     * - getting the layers of groups is done by simply letting the brick fall and checking the result
     *
     * Example:
     * We have 2 groups ([A=>E] and [C=>D]), and we want to group headers [C=>F]
     *
     * Headers :                 A B C D E F G          A B C D E F G            A B C D E F G
     * Headers to group: [C=>D]:     _ _         [C=>F]:    _ _ _ _
     *                               | |           ==>      | | | |       ==>                    ==> Result: 3 groups
     *                               | |                    ˅ ˅ | |                  _ _                - [C=>D]
     * Groups:                       ˅ ˅                    _ _ ˅ |                  _ _ _              - [C=>E]
     * Groups:                   _ _ _ _ _              _ _ _ _ _ ˅              _ _ _ _ _ _            - [A=>F]
  
     * @param groups
     * @param start start of the range where to add/remove headers
     * @param end end of the range where to add/remove headers
     * @param delta -1: remove headers, 1: add headers, 0: get layers (don't add/remove anything)
     */
    private bricksFallingAlgorithm;
    private groupHeaders;
    /**
     * Ungroup the given headers. The headers will be taken out of the group they are in. This might split a group into two
     * if the headers were in the middle of a group. If multiple groups contains a header, it will only be taken out of the
     * lowest group in the layering of the groups.
     */
    private unGroupHeaders;
    private moveGroupsOnHeaderInsertion;
    private moveGroupsOnHeaderDeletion;
    private doGroupOverlap;
    private removeDuplicateGroups;
    private findGroupWithStartEnd;
    /**
     * Fold the given group, and all the groups starting at the same index that are contained inside the given group.
     */
    private foldHeaderGroup;
    /**
     * Unfold the given group, and all the groups starting at the same index that contain the given group.
     */
    private unfoldHeaderGroup;
    private getGroupIndex;
    import(data: WorkbookData): void;
    export(data: WorkbookData): void;
    exportForExcel(data: ExcelWorkbookData): void;
}

interface HeaderSizeState$1 {
    sizes: Record<UID, Record<Dimension, Array<Pixel | undefined>>>;
}
declare class HeaderSizePlugin extends CorePlugin<HeaderSizeState$1> implements HeaderSizeState$1 {
    static getters: readonly ["getUserRowSize", "getColSize"];
    readonly sizes: Record<UID, Record<Dimension, Array<Pixel | undefined>>>;
    handle(cmd: Command): void;
    getColSize(sheetId: UID, index: HeaderIndex): Pixel;
    getUserRowSize(sheetId: UID, index: HeaderIndex): Pixel | undefined;
    import(data: WorkbookData): void;
    exportForExcel(data: ExcelWorkbookData): void;
    export(data: WorkbookData): void;
    /**
     * Export the header sizes
     *
     * @param exportDefaults : if true, export column/row sizes even if they have the default size
     */
    exportData(data: WorkbookData, exportDefaults?: boolean): void;
}

declare class HeaderVisibilityPlugin extends CorePlugin {
    static getters: readonly ["checkElementsIncludeAllVisibleHeaders", "getHiddenColsGroups", "getHiddenRowsGroups", "isHeaderHiddenByUser", "isRowHiddenByUser", "isColHiddenByUser"];
    private readonly hiddenHeaders;
    allowDispatch(cmd: Command): CommandResult.Success | CommandResult.NotEnoughElements | CommandResult.InvalidSheetId | CommandResult.TooManyHiddenElements | CommandResult.InvalidHeaderIndex;
    handle(cmd: Command): void;
    checkElementsIncludeAllVisibleHeaders(sheetId: UID, dimension: Dimension, elements: HeaderIndex[]): boolean;
    isHeaderHiddenByUser(sheetId: UID, dimension: Dimension, index: HeaderIndex): boolean;
    isRowHiddenByUser(sheetId: UID, index: HeaderIndex): boolean;
    isColHiddenByUser(sheetId: UID, index: HeaderIndex): boolean;
    getHiddenColsGroups(sheetId: UID): ConsecutiveIndexes[];
    getHiddenRowsGroups(sheetId: UID): ConsecutiveIndexes[];
    private getAllVisibleHeaders;
    import(data: WorkbookData): void;
    exportForExcel(data: ExcelWorkbookData): void;
    export(data: WorkbookData): void;
    exportData(data: WorkbookData, exportDefaults?: boolean): void;
}

type ImageSVG = {
    name: string;
    width: number;
    height: number;
    paths: {
        path: string;
        fillColor: Color;
    }[];
};
interface Image$1 {
    path: string;
    size: FigureSize;
    mimetype?: string;
}
declare const AllowedImageMimeTypes: readonly ["image/avif", "image/bmp", "image/gif", "image/vnd.microsoft.icon", "image/jpeg", "image/png", "image/tiff", "image/webp"];

type FilePath = string;
/**
 * FileStore manage the transfer of file with the server.
 */
interface FileStore {
    /**
     * Upload a file to a server and returns its path.
     */
    upload(file: File): Promise<FilePath>;
    /**
     * get File from the server
     */
    getFile(filePath: FilePath): Promise<File | Blob>;
}
/**
 * ImageProvider can request the user to input an image file before sending it to a server.
 */
interface ImageProviderInterface {
    /**
     * RequestImage ask the user to input an image file. Then send it to a server trough an FileStore. Finally it return the path and the size of the image in the server.
     */
    requestImage(): Promise<Image$1>;
    uploadFile(file: File | Blob): Promise<Image$1>;
    getImageOriginalSize(path: string): Promise<FigureSize>;
}

interface ImageState {
    readonly images: Record<UID, Record<UID, Image$1 | undefined> | undefined>;
}
declare class ImagePlugin extends CorePlugin<ImageState> implements ImageState {
    static getters: readonly ["getImage", "getImagePath", "getImageSize"];
    readonly fileStore?: FileStore;
    readonly images: Record<UID, Record<UID, Image$1 | undefined> | undefined>;
    /**
     * paths of images synced with the file store server.
     */
    readonly syncedImages: Set<Image$1["path"]>;
    constructor(config: CorePluginConfig);
    allowDispatch(cmd: CoreCommand): CommandResult.Success | CommandResult.InvalidFigureId;
    handle(cmd: CoreCommand): void;
    getImage(figureId: UID): Image$1;
    getImagePath(figureId: UID): string;
    getImageSize(figureId: UID): FigureSize;
    private addFigure;
    import(data: WorkbookData): void;
    export(data: WorkbookData): void;
    exportForExcel(data: ExcelWorkbookData): void;
}

type SheetMergeCellMap = Record<number, Record<number, number | undefined> | undefined>;
interface MergeState {
    readonly merges: Record<UID, Record<number, Range | undefined> | undefined>;
    readonly mergeCellMap: Record<UID, SheetMergeCellMap | undefined>;
}
declare class MergePlugin extends CorePlugin<MergeState> implements MergeState {
    static getters: readonly ["isInMerge", "isInSameMerge", "isMergeHidden", "getMainCellPosition", "expandZone", "doesIntersectMerge", "doesColumnsHaveCommonMerges", "doesRowsHaveCommonMerges", "getMerges", "getMerge", "getMergesInZone", "isSingleCellOrMerge", "getSelectionRangeString", "isMainCellPosition"];
    private nextId;
    readonly merges: Record<UID, Record<number, Range | undefined> | undefined>;
    readonly mergeCellMap: Record<UID, SheetMergeCellMap | undefined>;
    allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
    handle(cmd: CoreCommand): void;
    adaptRanges(rangeAdapters: RangeAdapterFunctions, sheetId: UID): void;
    getMerges(sheetId: UID): Merge[];
    getMerge({ sheetId, col, row }: CellPosition): Merge | undefined;
    getMergesInZone(sheetId: UID, zone: Zone): Merge[];
    /**
     * Same as `getRangeString` but add all necessary merge to the range to make it a valid selection
     */
    getSelectionRangeString(range: Range, forSheetId: UID): string;
    /**
     * Return true if the zone intersects an existing merge:
     * if they have at least a common cell
     */
    doesIntersectMerge(sheetId: UID, zone: Zone): boolean;
    /**
     * Returns true if two columns have at least one merge in common
     */
    doesColumnsHaveCommonMerges(sheetId: string, colA: HeaderIndex, colB: HeaderIndex): boolean;
    /**
     * Returns true if two rows have at least one merge in common
     */
    doesRowsHaveCommonMerges(sheetId: string, rowA: HeaderIndex, rowB: HeaderIndex): boolean;
    /**
     * Add all necessary merge to the current selection to make it valid
     */
    expandZone(sheetId: UID, zone: Zone): Zone;
    isInSameMerge(sheetId: UID, colA: HeaderIndex, rowA: HeaderIndex, colB: HeaderIndex, rowB: HeaderIndex): boolean;
    isInMerge({ sheetId, col, row }: CellPosition): boolean;
    getMainCellPosition(position: CellPosition): CellPosition;
    isMergeHidden(sheetId: UID, merge: Merge): boolean;
    /**
     * Check if the zone represents a single cell or a single merge.
     */
    isSingleCellOrMerge(sheetId: UID, zone: Zone): boolean;
    isMainCellPosition(position: CellPosition): boolean;
    /**
     * Return true if the current selection requires losing state if it is merged.
     * This happens when there is some textual content in other cells than the
     * top left.
     */
    private isMergeDestructive;
    private getMergeById;
    private checkDestructiveMerge;
    private checkOverlap;
    private checkFrozenPanes;
    /**
     * The content of a merged cell should always be empty.
     * Except for the top-left cell.
     */
    private checkMergedContentUpdate;
    private checkMergeExists;
    /**
     * Merge the current selection. Note that:
     * - it assumes that we have a valid selection (no intersection with other
     *   merges)
     * - it does nothing if the merge is trivial: A1:A1
     */
    private addMerge;
    private removeMerge;
    /**
     * Apply a range change on merges of a particular sheet.
     */
    private applyRangeChangeOnSheet;
    import(data: WorkbookData): void;
    private importMerges;
    export(data: WorkbookData): void;
    exportForExcel(data: ExcelWorkbookData): void;
}

type Aggregator = "array_agg" | "count" | "count_distinct" | "bool_and" | "bool_or" | "max" | "min" | "avg" | "sum";
type Granularity = "day" | "month" | "year" | "second_number" | "minute_number" | "hour_number" | "day_of_week" | "day_of_month" | "iso_week_number" | "month_number" | "quarter_number";
interface PivotCoreDimension {
    fieldName: string;
    order?: SortDirection;
    granularity?: Granularity | string;
    isCustomField?: boolean;
    parentField?: string;
    customGroups?: PivotCustomGroup[];
}
interface PivotCoreMeasure {
    /**
     * Identifier of the measure, `technicalName:aggregator{:autoIncrementedNumber}`.
     * It's used to identify the measure in the pivot formula.
     */
    id: string;
    userDefinedName?: string;
    fieldName: string;
    aggregator: Aggregator | string;
    isHidden?: boolean;
    format?: Format;
    computedBy?: {
        sheetId: UID;
        formula: string;
    };
    display?: PivotMeasureDisplay;
}
interface CommonPivotCoreDefinition {
    columns: PivotCoreDimension[];
    rows: PivotCoreDimension[];
    measures: PivotCoreMeasure[];
    name: string;
    deferUpdates?: boolean;
    sortedColumn?: PivotSortedColumn;
    collapsedDomains?: PivotCollapsedDomains;
    customFields?: Record<string, PivotCustomGroupedField>;
    style?: PivotStyle;
}
interface PivotSortedColumn {
    order: SortDirection;
    domain: PivotDomain;
    measure: string;
}
interface PivotCollapsedDomains {
    COL: PivotDomain[];
    ROW: PivotDomain[];
}
interface PivotCustomGroupedField {
    parentField: string;
    name: string;
    groups: PivotCustomGroup[];
}
interface PivotCustomGroup {
    name: string;
    values: CellValue[];
    isOtherGroup?: boolean;
}
interface SpreadsheetPivotCoreDefinition extends CommonPivotCoreDefinition {
    type: "SPREADSHEET";
    dataSet?: {
        sheetId: UID;
        zone: Zone;
    };
}
interface FakePivotDefinition extends CommonPivotCoreDefinition {
    type: "FAKE";
}
type PivotCoreDefinition = SpreadsheetPivotCoreDefinition | FakePivotDefinition;
type TechnicalName = string;
interface PivotField {
    name: TechnicalName;
    type: string;
    string: string;
    aggregator?: string;
    help?: string;
    isCustomField?: boolean;
    parentField?: string;
    customGroups?: PivotCustomGroup[];
}
type PivotFields = Record<TechnicalName, PivotField | undefined>;
interface PivotMeasure extends PivotCoreMeasure {
    displayName: string;
    type: string;
    isValid: boolean;
}
interface PivotDimension extends PivotCoreDimension {
    nameWithGranularity: string;
    displayName: string;
    type: string;
    isValid: boolean;
}
interface PivotTableColumn {
    fields: string[];
    values: CellValue[];
    width: number;
    offset: number;
}
interface PivotTableRow {
    fields: string[];
    values: CellValue[];
    indent: number;
}
interface PivotTableData {
    cols: PivotTableColumn[][];
    rows: PivotTableRow[];
    measures: string[];
    fieldsType?: Record<string, string | undefined>;
}
interface PivotHeaderCell {
    type: "HEADER";
    domain: PivotDomain;
    dimension: Dimension;
}
interface PivotMeasureHeaderCell {
    type: "MEASURE_HEADER";
    domain: PivotDomain;
    measure: string;
}
interface PivotValueCell {
    type: "VALUE";
    domain: PivotDomain;
    measure: string;
}
interface PivotEmptyCell {
    type: "EMPTY";
}
type PivotTableCell = PivotHeaderCell | PivotMeasureHeaderCell | PivotValueCell | PivotEmptyCell;
interface PivotNode {
    field: string;
    type: string;
    value: CellValue;
}
type PivotDomain = PivotNode[];
declare const PREVIOUS_VALUE = "(previous)";
declare const NEXT_VALUE = "(next)";
interface PivotMeasureDisplay {
    type: PivotMeasureDisplayType;
    fieldNameWithGranularity?: string;
    value?: string | boolean | number | typeof PREVIOUS_VALUE | typeof NEXT_VALUE;
}
type PivotMeasureDisplayType = "no_calculations" | "%_of_grand_total" | "%_of_col_total" | "%_of_row_total" | "%_of_parent_row_total" | "%_of_parent_col_total" | "index" | "%_of_parent_total" | "running_total" | "%_running_total" | "rank_asc" | "rank_desc" | "%_of" | "difference_from" | "%_difference_from";
interface DimensionTreeNode {
    value: CellValue;
    field: string;
    type: string;
    children: DimensionTree;
    width: number;
}
type DimensionTree = DimensionTreeNode[];
interface PivotStyle {
    numberOfRows?: number;
    numberOfColumns?: number;
    displayTotals?: boolean;
    displayColumnHeaders?: boolean;
    displayMeasuresRow?: boolean;
}

interface Pivot$1 {
    definition: PivotCoreDefinition;
    formulaId: string;
}
interface MeasureState {
    formula: RangeCompiledFormula;
    dependencies: Range[];
}
interface CoreState {
    nextFormulaId: number;
    pivots: Record<UID, Pivot$1 | undefined>;
    formulaIds: Record<UID, string | undefined>;
    compiledMeasureFormulas: Record<UID, Record<string, MeasureState | undefined>>;
}
declare class PivotCorePlugin extends CorePlugin<CoreState> implements CoreState {
    static getters: readonly ["getPivotCoreDefinition", "getPivotDisplayName", "getPivotId", "getPivotFormulaId", "getPivotIds", "getMeasureCompiledFormula", "getPivotName", "isExistingPivot", "getMeasureFullDependencies"];
    readonly nextFormulaId: number;
    readonly pivots: {
        [pivotId: UID]: Pivot$1 | undefined;
    };
    readonly formulaIds: {
        [formulaId: UID]: UID | undefined;
    };
    readonly compiledMeasureFormulas: Record<UID, Record<string, MeasureState>>;
    allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
    handle(cmd: CoreCommand): void;
    adaptRanges({ applyChange, adaptFormulaString }: RangeAdapterFunctions): void;
    getPivotDisplayName(pivotId: UID): string;
    getPivotName(pivotId: UID): string;
    /**
     * Returns the pivot core definition of the pivot with the given id.
     * Be careful, this is the core definition, this should be used only in a
     * context where the pivot is not loaded yet.
     */
    getPivotCoreDefinition(pivotId: UID): PivotCoreDefinition;
    /**
     * Get the pivot ID (UID) from the formula ID (the one used in the formula)
     */
    getPivotId(formulaId: string): UID | undefined;
    getPivotFormulaId(pivotId: UID): string;
    getPivotIds(): UID[];
    isExistingPivot(pivotId: UID): boolean;
    getMeasureCompiledFormula(pivotId: UID, measure: PivotCoreMeasure): RangeCompiledFormula;
    getMeasureFullDependencies(pivotId: UID, measure: PivotCoreMeasure): Range[];
    private addPivot;
    private compileCalculatedMeasures;
    private computeMeasureFullDependencies;
    private insertPivot;
    private resizeSheet;
    private getPivotCore;
    private compileMeasureFormula;
    private replaceMeasureFormula;
    private checkSortedColumnInMeasures;
    private checkDuplicatedMeasureIds;
    private checkCustomFieldsAreValid;
    /**
     * Import the pivots
     */
    import(data: WorkbookData): void;
    /**
     * Export the pivots
     */
    export(data: WorkbookData): void;
}

declare class RangeAdapterPlugin implements CommandHandler<CoreCommand> {
    private getters;
    private providers;
    private isAdaptingRanges;
    constructor(getters: CoreGetters);
    static getters: readonly ["copyFormulaStringForSheet", "extendRange", "getRangeString", "getRangeFromSheetXC", "createAdaptedRanges", "getRangeData", "getRangeDataFromXc", "getRangeDataFromZone", "getRangeFromRangeData", "getRangeFromZone", "getRangesUnion", "recomputeRanges", "isRangeValid", "removeRangesSheetPrefix"];
    allowDispatch(cmd: CoreCommand): CommandResult;
    beforeHandle(command: Command): void;
    handle(cmd: CoreCommand): void;
    finalize(): void;
    /**
     * Return a modified adapting function that verifies that after adapting a range, the range is still valid.
     * Any range that gets adapted by the function adaptRange in parameter does so
     * without caring if the start and end of the range in both row and column
     * direction can be incorrect. This function ensure that an incorrect range gets removed.
     */
    private verifyRangeRemoved;
    private executeOnAllRanges;
    /**
     * Stores the functions bound to each plugin to be able to iterate over all ranges of the application,
     * without knowing any details of the internal data structure of the plugins and without storing ranges
     * in the range adapter.
     *
     * @param provider a function bound to a plugin that will loop over its internal data structure to find
     * all ranges
     */
    addRangeProvider(provider: RangeProvider["adaptRanges"]): void;
    createAdaptedRanges(ranges: Range[], offsetX: number, offsetY: number, sheetId: UID): Range[];
    /**
     * Remove the sheet name prefix if a range is part of the given sheet.
     */
    removeRangesSheetPrefix(sheetId: UID, ranges: Range[]): Range[];
    extendRange(range: Range, dimension: Dimension, quantity: number): Range;
    /**
     * Creates a range from a XC reference that can contain a sheet reference
     * @param defaultSheetId the sheet to default to if the sheetXC parameter does not contain a sheet reference (usually the active sheet Id)
     * @param sheetXC the string description of a range, in the form SheetName!XC:XC
     */
    getRangeFromSheetXC(defaultSheetId: UID, sheetXC: string): Range;
    /**
     * Gets the string that represents the range as it is at the moment of the call.
     * The string will be prefixed with the sheet name if the call specified a sheet id in `forSheetId`
     * different than the sheet on which the range has been created.
     *
     * @param range the range (received from getRangeFromXC or getRangeFromZone)
     * @param forSheetId the id of the sheet where the range string is supposed to be used.
     * @param options
     * @param options.useBoundedReference if true, the range will be returned with bounded row and column
     * @param options.useFixedReference if true, the range will be returned with fixed row and column
     */
    getRangeString(range: Range, forSheetId: UID, options?: RangeStringOptions): string;
    getRangeDataFromXc(sheetId: UID, xc: string): RangeData;
    getRangeDataFromZone(sheetId: UID, zone: Zone | UnboundedZone): RangeData;
    getRangeData(range: Range): RangeData;
    getRangeFromZone(sheetId: UID, zone: Zone | UnboundedZone): Range;
    /**
     * Allows you to recompute ranges from the same sheet
     */
    recomputeRanges(ranges: Range[], rangesToRemove: Range[]): Range[];
    getRangeFromRangeData(data: RangeData): Range;
    isRangeValid(rangeStr: string): boolean;
    getRangesUnion(ranges: Range[]): Range;
    /**
     * Copy a formula string to another sheet.
     *
     * @param mode
     * `keepSameReference` will make the formula reference the exact same ranges,
     * `moveReference` will change all the references to `sheetIdFrom` into references to `sheetIdTo`.
     */
    copyFormulaStringForSheet(sheetIdFrom: UID, sheetIdTo: UID, formula: string, mode: "keepSameReference" | "moveReference"): string;
}

declare class SettingsPlugin extends CorePlugin {
    static getters: readonly ["getLocale"];
    private locale;
    allowDispatch(cmd: CoreCommand): CommandResult.Success | CommandResult.InvalidLocale;
    handle(cmd: CoreCommand): void;
    getLocale(): Locale;
    private changeCellsDateFormatWithLocale;
    import(data: WorkbookData): void;
    export(data: WorkbookData): void;
}

interface SheetState {
    readonly sheets: Record<UID, Sheet | undefined>;
    readonly orderedSheetIds: UID[];
    readonly sheetIdsMapName: Record<string, UID | undefined>;
    readonly cellPosition: Record<UID, CellPosition | undefined>;
}
declare class SheetPlugin extends CorePlugin<SheetState> implements SheetState {
    static getters: readonly ["getSheetName", "tryGetSheetName", "getSheet", "tryGetSheet", "getSheetIdByName", "getSheetIds", "getVisibleSheetIds", "isSheetVisible", "doesHeaderExist", "doesHeadersExist", "getCell", "getCellPosition", "getColsZone", "getRowCells", "getRowsZone", "getNumberCols", "getNumberRows", "getNumberHeaders", "getGridLinesVisibility", "getNextSheetName", "getSheetSize", "getSheetZone", "getPaneDivisions", "checkZonesExistInSheet", "getCommandZones", "getUnboundedZone", "checkElementsIncludeAllNonFrozenHeaders", "getDuplicateSheetName"];
    readonly sheetIdsMapName: Record<string, UID | undefined>;
    readonly orderedSheetIds: UID[];
    readonly sheets: Record<UID, Sheet | undefined>;
    readonly cellPosition: Record<UID, CellPosition | undefined>;
    allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
    beforeHandle(cmd: CoreCommand): void;
    handle(cmd: CoreCommand): void;
    import(data: WorkbookData): void;
    private exportSheets;
    export(data: WorkbookData): void;
    exportForExcel(data: ExcelWorkbookData): void;
    getGridLinesVisibility(sheetId: UID): boolean;
    tryGetSheet(sheetId: UID): Sheet | undefined;
    getSheet(sheetId: UID): Sheet;
    isSheetVisible(sheetId: UID): boolean;
    /**
     * Return the sheet name. Throw if the sheet is not found.
     */
    getSheetName(sheetId: UID): string;
    /**
     * Return the sheet name or undefined if the sheet doesn't exist.
     */
    tryGetSheetName(sheetId: UID): string | undefined;
    getSheetIdByName(name: string | undefined): UID | undefined;
    getSheetIds(): UID[];
    getVisibleSheetIds(): UID[];
    doesHeaderExist(sheetId: UID, dimension: Dimension, index: number): boolean;
    doesHeadersExist(sheetId: UID, dimension: Dimension, headerIndexes: HeaderIndex[]): boolean;
    getCell({ sheetId, col, row }: CellPosition): Cell | undefined;
    getColsZone(sheetId: UID, start: HeaderIndex, end: HeaderIndex): Zone;
    getRowCells(sheetId: UID, row: HeaderIndex): UID[];
    getRowsZone(sheetId: UID, start: HeaderIndex, end: HeaderIndex): Zone;
    getCellPosition(cellId: UID): CellPosition;
    getNumberCols(sheetId: UID): number;
    getNumberRows(sheetId: UID): number;
    getNumberHeaders(sheetId: UID, dimension: Dimension): HeaderIndex;
    getNextSheetName(baseName?: string): string;
    getSheetSize(sheetId: UID): ZoneDimension;
    getSheetZone(sheetId: UID): Zone;
    getUnboundedZone(sheetId: UID, zone: Zone | UnboundedZone): UnboundedZone;
    getPaneDivisions(sheetId: UID): Readonly<PaneDivision>;
    private setPaneDivisions;
    /**
     * Checks if all non-frozen header indices are present in the provided elements of selected rows/columns.
     * This validation ensures that all rows or columns cannot be deleted when frozen panes exist.
     */
    checkElementsIncludeAllNonFrozenHeaders(sheetId: UID, dimension: Dimension, elements: HeaderIndex[]): boolean;
    getCommandZones(cmd: Command): Zone[];
    /**
     * Check if zones in the command are well formed and
     * not outside the sheet.
     */
    checkZonesExistInSheet(sheetId: UID, zones: Zone[]): CommandResult;
    private updateCellPosition;
    /**
     * Set the cell at a new position and clear its previous position.
     */
    private setNewPosition;
    /**
     * Remove the cell at the given position (if there's one)
     */
    private clearPosition;
    private setGridLinesVisibility;
    private createSheet;
    private moveSheet;
    private findIndexOfTargetSheet;
    private checkSheetName;
    private checkSheetPosition;
    private checkRowFreezeQuantity;
    private checkColFreezeQuantity;
    private checkRowFreezeOverlapMerge;
    private checkColFreezeOverlapMerge;
    private isRenameAllowed;
    private renameSheet;
    private hideSheet;
    private showSheet;
    private duplicateSheet;
    getDuplicateSheetName(sheetName: string): string;
    private deleteSheet;
    /**
     * Delete column. This requires a lot of handling:
     * - Update all the formulas in all sheets
     * - Move the cells
     * - Update the cols/rows (size, number, (cells), ...)
     * - Reevaluate the cells
     *
     * @param sheet ID of the sheet on which deletion should be applied
     * @param columns Columns to delete
     */
    private removeColumns;
    /**
     * Delete row. This requires a lot of handling:
     * - Update the merges
     * - Update all the formulas in all sheets
     * - Move the cells
     * - Update the cols/rows (size, number, (cells), ...)
     * - Reevaluate the cells
     *
     * @param sheet ID of the sheet on which deletion should be applied
     * @param rows Rows to delete
     */
    private removeRows;
    private addColumns;
    private addRows;
    private moveCellOnColumnsDeletion;
    /**
     * Move the cells after a column or rows insertion
     */
    private moveCellsOnAddition;
    /**
     * Move all the cells that are from the row under `deleteToRow` up to `deleteFromRow`
     *
     * b.e.
     * move vertically with delete from 3 and delete to 5 will first clear all the cells from lines 3 to 5,
     * then take all the row starting at index 6 and add them back at index 3
     *
     */
    private moveCellOnRowsDeletion;
    private updateRowsStructureOnDeletion;
    /**
     * Add empty rows at the end of the rows
     *
     * @param sheet Sheet
     * @param quantity Number of rows to add
     */
    private addEmptyRows;
    private getImportedSheetSize;
    /**
     * Check that any "sheetId" in the command matches an existing
     * sheet.
     */
    private checkSheetExists;
    /**
     * Check if zones in the command are well formed and
     * not outside the sheet.
     */
    private checkZonesAreInSheet;
}

type ZoneStyle = {
    zone: UnboundedZone;
    style: Style;
};
interface StylePluginState {
    readonly styles: Record<UID, ZoneStyle[] | undefined>;
}
declare class StylePlugin extends CorePlugin<StylePluginState> implements StylePluginState {
    static getters: readonly ["getCellStyle", "getCellStyleInZone", "getZoneStyles", "getStyleColors"];
    readonly styles: Record<UID, ZoneStyle[] | undefined>;
    allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
    handle(cmd: CoreCommand): void;
    adaptRanges({ applyChange }: RangeAdapterFunctions, sheetId: UID): void;
    private handleAddColumnn;
    private handleAddRows;
    private styleIsDefault;
    private removeDefaultStyleValues;
    private onMerge;
    private setStyles;
    private setStyle;
    private clearStyle;
    getCellStyle(cellPosition: CellPosition): Style | undefined;
    getCellStyleInZone(sheetId: UID, zone: Zone): PositionMap<Style>;
    getZoneStyles(sheetId: UID, zone: Zone): ZoneStyle[];
    getStyleColors(sheetId: UID): Color[];
    import(data: WorkbookData): void;
    export(data: WorkbookData): void;
    exportForExcel(data: ExcelWorkbookData): void;
    private checkUselessSetFormatting;
}

interface TableState {
    tables: Record<UID, Record<TableId, CoreTable | undefined>>;
    nextTableId: number;
}
declare class TablePlugin extends CorePlugin<TableState> implements TableState {
    static getters: readonly ["getCoreTable", "getCoreTables", "getCoreTableMatchingTopLeft"];
    readonly tables: Record<UID, Record<TableId, CoreTable | undefined>>;
    readonly nextTableId: number;
    adaptRanges({ applyChange }: RangeAdapterFunctions, sheetId: UID): void;
    allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
    handle(cmd: CoreCommand): void;
    getCoreTables(sheetId: UID): CoreTable[];
    getCoreTable({ sheetId, col, row }: CellPosition): CoreTable | undefined;
    private getTablesOverlappingZones;
    /** Extend a table down one row */
    private extendTableDown;
    /** Extend a table right one col */
    private extendTableRight;
    /**
     * Check if an UpdateCell command should cause the given table to be extended by one row or col.
     *
     * The table should be extended if all of these conditions are true:
     * 1) The updated cell is right below/right of the table
     * 2) The command adds a content to the cell
     * 3) No cell right below/right next to the table had any content before the command
     * 4) Extending the table down/right would not overlap with another table
     * 5) Extending the table down/right would not overlap with a merge
     *
     */
    private canUpdateCellCmdExtendTable;
    getCoreTableMatchingTopLeft(sheetId: UID, zone: Zone): CoreTable | undefined;
    private checkUpdatedTableZoneIsValid;
    private checkTableConfigUpdateIsValid;
    private createStaticTable;
    private createDynamicTable;
    private updateTable;
    private updateStaticTable;
    private updateDynamicTable;
    /**
     * Update the old config of a table with the new partial config from an UpdateTable command.
     *
     * Make sure the new config make sense (e.g. if the table has no header, it should not have
     * filters and number of headers should be 0)
     */
    private updateTableConfig;
    private createFilterFromZone;
    private copyStaticTableForSheet;
    private copyDynamicTableForSheet;
    private applyRangeChangeOnTable;
    private consumeNextId;
    import(data: WorkbookData): void;
    export(data: WorkbookData): void;
    exportForExcel(data: ExcelWorkbookData): void;
}

/**
 * Union of all getter names of a plugin.
 *
 * e.g. With the following plugin
 * ```ts
 * class MyPlugin {
 *   static getters = [
 *     "getCell",
 *     "getCellValue",
 *   ] as const;
 *   getCell() { ... }
 *   getCellValue() { ... }
 * }
 * ```
 * `type Names = GetterNames<typeof MyPlugin>` is equivalent to
 * `type Names = "getCell" | "getCellValue"`
 *
 * Some technical comments:
 *
 * - Since the getter names are in a static array, the type of the plugin must
 *   be given, not the class itself.
 *
 * - we need to index the getters array with every index:
 *   `Plugin["getters"][0] | Plugin["getters"][1] | Plugin["getters"][2] | ...`
 *   which is equivalent to `Plugin["getters"][0 | 1 | 2 | ...]`.
 *   This can be generalized because the union of all indices `0 | 1 | 2 | 3 | ...`
 *   is actually the type `number`.
 */
type GetterNames<Plugin extends {
    getters: readonly string[];
}> = Plugin["getters"][number];
/**
 * Extract getter methods from a plugin, based on its `getters` static array.
 * @example
 * class MyPlugin {
 *   static getters = [
 *     "getCell",
 *     "getCellValue",
 *   ] as const;
 *   getCell() { ... }
 *   getCellValue() { ... }
 * }
 * type MyPluginGetters = PluginGetters<typeof MyPlugin>;
 * // MyPluginGetters is equivalent to:
 * // {
 * //   getCell: () => ...,
 * //   getCellValue: () => ...,
 * // }
 */
type PluginGetters<Plugin extends {
    new (...args: unknown[]): any;
    getters: readonly string[];
}> = Pick<InstanceType<Plugin>, GetterNames<Plugin>>;
type RangeAdapterGetters = Pick<RangeAdapterPlugin, GetterNames<typeof RangeAdapterPlugin>>;
type CoreGetters = PluginGetters<typeof SheetPlugin> & PluginGetters<typeof HeaderSizePlugin> & PluginGetters<typeof HeaderVisibilityPlugin> & PluginGetters<typeof CellPlugin> & PluginGetters<typeof StylePlugin> & PluginGetters<typeof MergePlugin> & PluginGetters<typeof BordersPlugin> & PluginGetters<typeof ChartPlugin> & PluginGetters<typeof ImagePlugin> & PluginGetters<typeof CarouselPlugin> & PluginGetters<typeof FigurePlugin> & RangeAdapterGetters & PluginGetters<typeof ConditionalFormatPlugin> & PluginGetters<typeof TablePlugin> & PluginGetters<typeof SettingsPlugin> & PluginGetters<typeof HeaderGroupingPlugin> & PluginGetters<typeof DataValidationPlugin> & PluginGetters<typeof PivotCorePlugin>;

type VerticalAxisPosition = "left" | "right";
type LegendPosition = "top" | "bottom" | "left" | "right" | "none";
interface CommonChartDefinition {
    readonly dataSets: CustomizedDataSet[];
    readonly dataSetsHaveTitle: boolean;
    readonly labelRange?: string;
    readonly title: TitleDesign;
    readonly background?: Color;
    readonly legendPosition: LegendPosition;
    readonly aggregated?: boolean;
    readonly axesDesign?: AxesDesign;
    readonly showValues?: boolean;
    readonly humanize?: boolean;
}

interface GeoChartDefinition extends CommonChartDefinition {
    readonly type: "geo";
    readonly colorScale?: ChartColorScale;
    readonly missingValueColor?: Color;
    readonly region?: string;
    readonly showColorBar?: boolean;
}
type GeoChartRuntime = {
    chartJsConfig: ChartConfiguration;
    background: Color;
};
type GeoChartProjection = "azimuthalEqualArea" | "azimuthalEquidistant" | "gnomonic" | "orthographic" | "stereographic" | "equalEarth" | "albers" | "albersUsa" | "conicConformal" | "conicEqualArea" | "conicEquidistant" | "equirectangular" | "mercator" | "transverseMercator" | "naturalEarth1";
interface GeoChartRegion {
    id: string;
    label: string;
    defaultProjection: GeoChartProjection;
}

type ClientId = string;
interface Client {
    id: ClientId;
    name: string;
    position?: ClientPosition;
    color?: Color;
}
interface ClientWithPosition extends Client {
    position: ClientPosition;
}
interface ClientWithColor extends Client {
    color: Color;
}
interface ClientPosition {
    sheetId: UID;
    col: HeaderIndex;
    row: HeaderIndex;
}
interface RemoteRevisionReceivedEvent {
    type: "remote-revision-received";
    commands: readonly CoreCommand[];
}
interface RevisionAcknowledgedEvent {
    type: "revision-acknowledged";
    revisionId: UID;
}
interface RevisionUndone {
    type: "revision-undone";
    revisionId: UID;
    commands: readonly CoreCommand[];
}
interface RevisionRedone {
    type: "revision-redone";
    revisionId: UID;
    commands: readonly CoreCommand[];
}
interface CollaborativeEventReceived {
    type: "collaborative-event-received";
}
interface UnexpectedRevisionIdEvent {
    type: "unexpected-revision-id";
}
interface NewLocalStateUpdateEvent {
    type: "new-local-state-update";
    id: UID;
}
interface SnapshotEvent {
    type: "snapshot";
}
type CollaborativeEvent = NewLocalStateUpdateEvent | UnexpectedRevisionIdEvent | RemoteRevisionReceivedEvent | RevisionAcknowledgedEvent | RevisionUndone | RevisionRedone | SnapshotEvent | CollaborativeEventReceived;

interface AbstractMessage {
    version: number;
}
interface RemoteRevisionMessage extends AbstractMessage {
    type: "REMOTE_REVISION";
    clientId: ClientId;
    commands: readonly CoreCommand[];
    nextRevisionId: UID;
    serverRevisionId: UID;
    timestamp?: number;
}
interface RevisionUndoneMessage extends AbstractMessage {
    type: "REVISION_UNDONE";
    undoneRevisionId: UID;
    nextRevisionId: UID;
    serverRevisionId: UID;
}
interface RevisionRedoneMessage extends AbstractMessage {
    type: "REVISION_REDONE";
    redoneRevisionId: UID;
    nextRevisionId: UID;
    serverRevisionId: UID;
}
interface ClientJoinedMessage extends AbstractMessage {
    type: "CLIENT_JOINED";
    client: ClientWithPosition;
}
interface ClientLeftMessage extends AbstractMessage {
    type: "CLIENT_LEFT";
    clientId: ClientId;
}
interface ClientMovedMessage extends AbstractMessage {
    type: "CLIENT_MOVED";
    client: ClientWithPosition;
}
/**
 * Send a snapshot of the spreadsheet to the collaborative server
 */
interface SnapshotMessage extends AbstractMessage {
    type: "SNAPSHOT";
    data: WorkbookData;
    serverRevisionId: UID;
    nextRevisionId: UID;
}
/**
 * Notify all clients that the server has a new snapshot of the
 * spreadsheet and that the previous history may be lost.
 */
interface SnapshotCreatedMessage extends AbstractMessage {
    type: "SNAPSHOT_CREATED";
    serverRevisionId: UID;
    nextRevisionId: UID;
}
type CollaborationMessage = RevisionUndoneMessage | RevisionRedoneMessage | RemoteRevisionMessage | SnapshotMessage | SnapshotCreatedMessage | ClientMovedMessage | ClientJoinedMessage | ClientLeftMessage;
type StateUpdateMessage = Extract<CollaborationMessage, {
    nextRevisionId: UID;
}>;
type NewMessageCallback<T = any> = (message: T) => void;
/**
 * The transport service allows to communicate between multiple clients.
 * A client can send any message to others.
 * The service will handle all networking details internally.
 */
interface TransportService<T = any> {
    /**
     * Send a message to all clients
     */
    sendMessage: (message: T) => Promise<void>;
    /**
     * Register a callback function which will be called each time
     * a new message is received.
     * The new message is given to the callback.
     *
     * ```js
     * transportService.onNewMessage(id, (message) => {
     *   // ... handle the new message
     * })
     * ```
     * The `id` is used to unregister this callback when the session is closed.
     */
    onNewMessage: (id: UID, callback: NewMessageCallback<T>) => void;
    /**
     * Unregister a callback linked to the given id
     */
    leave: (id: UID) => void;
}

interface Currency {
    name: string;
    code: string;
    symbol: string;
    decimalPlaces: number;
    position: "before" | "after";
}

type NotificationType = "danger" | "info" | "success" | "warning";
interface InformationNotification {
    text: string;
    type: NotificationType;
    sticky: boolean;
}

type Mode = "normal" | "readonly" | "dashboard";
interface ModelConfig {
    readonly mode: Mode;
    /**
     * Any external custom dependencies your custom plugins or functions might need.
     * They are available in plugins config and functions
     * evaluation context.
     */
    readonly custom: Readonly<{
        [key: string]: any;
    }>;
    readonly defaultCurrency?: Partial<Currency>;
    /**
     * External dependencies required to enable some features
     * such as uploading images.
     */
    readonly external: Readonly<ModelExternalConfig>;
    readonly moveClient: (position: ClientPosition) => void;
    readonly transportService: TransportService;
    readonly client: Client;
    readonly snapshotRequested: boolean;
    readonly notifyUI: (payload: InformationNotification) => void;
    readonly raiseBlockingErrorUI: (text: string) => void;
    readonly customColors: Color[];
}
interface ModelExternalConfig {
    readonly fileStore?: FileStore;
    readonly loadCurrencies?: () => Promise<Currency[]>;
    readonly loadLocales?: () => Promise<Locale[]>;
    readonly geoJsonService?: {
        getAvailableRegions: () => GeoChartRegion[];
        getTopoJson: (region: string) => Promise<any>;
        /**  Convert the name of a geographical feature (eg. France) to the id of the corresponding feature in the TopoJSON */
        geoFeatureNameToId: (region: string, territory: string) => string | undefined;
    };
}

/**
 * BasePlugin
 *
 * Since the spreadsheet internal state is quite complex, it is split into
 * multiple parts, each managing a specific concern.
 *
 * This file introduces the BasePlugin, which is the common class that defines
 * how each of these model sub parts should interact with each other.
 * There are two kinds of plugins: core plugins handling persistent data
 * and UI plugins handling transient data.
 */
declare class BasePlugin<State = any, C = any> implements CommandHandler<C>, Validator {
    static getters: readonly string[];
    protected history: WorkbookHistory<State>;
    constructor(stateObserver: StateObserver);
    /**
     * Export for excel should be available for all plugins, even for the UI.
     * In some cases, we need to export evaluated value, which is available from
     * UI plugin only.
     */
    exportForExcel(data: ExcelWorkbookData): void | Promise<void>;
    /**
     * Before a command is accepted, the model will ask each plugin if the command
     * is allowed. If all of them return true, then we can proceed. Otherwise,
     * the command is cancelled.
     *
     * There should not be any side effects in this method.
     */
    allowDispatch(command: C): CommandResult | CommandResult[];
    /**
     * This method is useful when a plugin needs to perform some action before a
     * command is handled in another plugin. This should only be used if it is not
     * possible to do the work in the handle method.
     */
    beforeHandle(command: C): void;
    /**
     * This is the standard place to handle any command. Most of the plugin
     * command handling work should take place here.
     */
    handle(command: C): void;
    /**
     * Sometimes, it is useful to perform some work after a command (and all its
     * subcommands) has been completely handled. For example, when we paste
     * multiple cells, we only want to reevaluate the cell values once at the end.
     */
    finalize(): void;
    /**
     * Combine multiple validation functions into a single function
     * returning the list of results of every validation.
     */
    batchValidations<T>(...validations: Validation<T>[]): Validation<T>;
    /**
     * Combine multiple validation functions. Every validation is executed one after
     * the other. As soon as one validation fails, it stops and the cancelled reason
     * is returned.
     */
    chainValidations<T>(...validations: Validation<T>[]): Validation<T>;
    checkValidations<T>(command: T, ...validations: Validation<NoInfer<T>>[]): CommandResult | CommandResult[];
}

interface CorePluginConfig {
    readonly getters: CoreGetters;
    readonly stateObserver: StateObserver;
    readonly range: RangeAdapterPlugin;
    readonly dispatch: CoreCommandDispatcher["dispatch"];
    readonly canDispatch: CoreCommandDispatcher["dispatch"];
    readonly custom: ModelConfig["custom"];
    readonly external: ModelConfig["external"];
}
/**
 * Core plugins handle spreadsheet data.
 * They are responsible to import, export and maintain the spreadsheet
 * persisted state.
 * They should not be concerned about UI parts or transient state.
 */
declare class CorePlugin<State = any> extends BasePlugin<State, CoreCommand> implements RangeProvider {
    protected getters: CoreGetters;
    protected dispatch: CoreCommandDispatcher["dispatch"];
    protected canDispatch: CoreCommandDispatcher["dispatch"];
    constructor({ getters, stateObserver, range, dispatch, canDispatch }: CorePluginConfig);
    import(data: WorkbookData): void;
    export(data: WorkbookData): void;
    /**
     * This method can be implemented in any plugin, to loop over the plugin's data structure and adapt the plugin's ranges.
     * To adapt them, the implementation of the function must have a perfect knowledge of the data structure, thus
     * implementing the loops over it makes sense in the plugin itself.
     * When calling the method applyChange, the range will be adapted if necessary, then a copy will be returned along with
     * the type of change that occurred.
     *
     * @param applyChange a function that, when called, will adapt the range according to the change on the grid
     * @param sheetId an sheetId to adapt either range of that sheet specifically, or ranges pointing to that sheet
     * @param sheetName couple of old and new sheet names to adapt ranges pointing to that sheet
     */
    adaptRanges(rangeAdapterFunctions: RangeAdapterFunctions, sheetId: UID, sheetName: AdaptSheetName): void;
}

type ZoneBorderData = {
    top?: BorderDescr;
    bottom?: BorderDescr;
    left?: BorderDescr;
    right?: BorderDescr;
    vertical?: BorderDescr;
    horizontal?: BorderDescr;
};
type ZoneBorder = {
    zone: UnboundedZone;
    style: ZoneBorderData;
};
interface BordersPluginState {
    readonly borders: Record<UID, ZoneBorder[] | undefined>;
}
declare class BordersPlugin extends CorePlugin<BordersPluginState> implements BordersPluginState {
    static getters: readonly ["getCellBorder", "getBorders", "getBordersColors", "getCellBordersInZone"];
    readonly borders: BordersPluginState["borders"];
    allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
    handle(cmd: CoreCommand): void;
    beforeHandle(cmd: CoreCommand): void;
    adaptRanges({ applyChange }: RangeAdapterFunctions, sheetId: UID): void;
    private onRowRemove;
    private onColRemove;
    getCellBorder(position: CellPosition): Border;
    private getZoneExternalBorders;
    getCellBordersInZone(sheetId: UID, zone: Zone): PositionMap<Border>;
    getBordersColors(sheetId: UID): Color[];
    getBorders(sheetId: UID, zone: Zone): ZoneBorder[];
    private computeBorderFromZone;
    private borderIsClear;
    private clearBorders;
    private removeAndClearAdjacent;
    private addBorders;
    private addBorder;
    private borderDataToNewBorderData;
    private checkBordersUnchanged;
    private ensureHasBorder;
    /**
     * Compute the borders to add to the given zone merged.
     */
    private addBordersToMerge;
    import(data: WorkbookData): void;
    export(data: WorkbookData): void;
    exportForExcel(data: ExcelWorkbookData): void;
}

interface HeaderData {
    size?: number;
    isHidden?: boolean;
}
interface FigureData<T> {
    id: UID;
    col: HeaderIndex;
    row: HeaderIndex;
    offset: PixelPosition;
    width: Pixel;
    height: Pixel;
    tag: string;
    data: T;
}
interface SheetData {
    id: string;
    name: string;
    colNumber: number;
    rowNumber: number;
    cells: {
        [key: string]: string | undefined;
    };
    styles: {
        [zone: string]: number;
    };
    formats: {
        [zone: string]: number;
    };
    borders: {
        [zone: string]: number;
    };
    merges: string[];
    figures: FigureData<any>[];
    cols: {
        [key: number]: HeaderData;
    };
    rows: {
        [key: number]: HeaderData;
    };
    conditionalFormats: ConditionalFormat[];
    dataValidationRules: DataValidationRuleData[];
    tables: TableData[];
    areGridLinesVisible?: boolean;
    isVisible: boolean;
    panes?: PaneDivision;
    headerGroups?: Record<Dimension, HeaderGroup[]>;
    color?: Color;
}
interface WorkbookSettings {
    locale: Locale;
    disableCellAnimations?: boolean;
}
type PivotData = {
    formulaId: string;
} & PivotCoreDefinition;
interface WorkbookData {
    version: string;
    sheets: SheetData[];
    styles: {
        [key: number]: Style;
    };
    formats: {
        [key: number]: Format;
    };
    borders: {
        [key: number]: ZoneBorderData;
    };
    pivots: {
        [key: string]: PivotData;
    };
    pivotNextId: number;
    revisionId: UID;
    uniqueFigureIds: boolean;
    settings: WorkbookSettings;
    customTableStyles: {
        [key: string]: TableStyleData;
    };
}
interface ExcelWorkbookData extends WorkbookData {
    sheets: ExcelSheetData[];
}
interface ExcelSheetData extends Omit<SheetData, "figureTables" | "cols" | "rows"> {
    cellValues: {
        [xc: string]: CellValue | undefined;
    };
    formulaSpillRanges: {
        [xc: string]: string;
    };
    charts: FigureData<ExcelChartDefinition>[];
    images: FigureData<Image$1>[];
    tables: ExcelTableData[];
    cols: {
        [key: number]: ExcelHeaderData;
    };
    rows: {
        [key: number]: ExcelHeaderData;
    };
}
interface ExcelHeaderData extends HeaderData {
    outlineLevel?: number;
    collapsed?: boolean;
}
interface TableData {
    range: string;
    config?: TableConfig;
    type?: CoreTableType;
}
interface DataValidationRuleData extends Omit<DataValidationRule, "ranges"> {
    ranges: string[];
}
interface ExcelTableData {
    range: string;
    filters: ExcelFilterData[];
    config: TableConfig;
}
interface ExcelFilterData {
    colId: number;
    displayedValues: string[];
    displayBlanks?: boolean;
}
interface TableStyleData {
    templateName: TableStyleTemplateName;
    primaryColor: string;
    displayName: string;
}

interface TableStylesState {
    readonly styles: {
        [styleId: string]: TableStyle;
    };
}
declare class TableStylePlugin extends CorePlugin<TableStylesState> implements TableStylesState {
    static getters: readonly ["getNewCustomTableStyleName", "getTableStyle", "getTableStyles", "isTableStyleEditable"];
    readonly styles: {
        [styleId: string]: TableStyle;
    };
    allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
    handle(cmd: CoreCommand): void;
    getTableStyle(styleId: string): TableStyle;
    getTableStyles(): Record<string, TableStyle>;
    getNewCustomTableStyleName(): string;
    isTableStyleEditable(styleId: string): boolean;
    import(data: WorkbookData): void;
    export(data: WorkbookData): void;
}

/**
 * This is a generic event bus based on the Owl event bus.
 * This bus however ensures type safety across events and subscription callbacks.
 */
declare class EventBus<Event extends {
    type: string;
}> {
    subscriptions: {
        [eventType: string]: Subscription[];
    };
    /**
     * Add a listener for the 'eventType' events.
     *
     * Note that the 'owner' of this event can be anything, but will more likely
     * be a component or a class. The idea is that the callback will be called with
     * the proper owner bound.
     *
     * Also, the owner should be kind of unique. This will be used to remove the
     * listener.
     */
    on<T extends Event["type"], E extends Extract<Event, {
        type: T;
    }>>(type: T, owner: any, callback: (r: Omit<E, "type">) => void): void;
    /**
     * Emit an event of type 'eventType'.  Any extra arguments will be passed to
     * the listeners callback.
     */
    trigger<T extends Event["type"], E extends Extract<Event, {
        type: T;
    }>>(type: T, payload?: Omit<E, "type">): void;
    /**
     * Remove a listener
     */
    off<T extends Event["type"]>(eventType: T, owner: any): void;
    /**
     * Remove all subscriptions.
     */
    clear(): void;
}
type Callback = (...args: any[]) => void;
interface Subscription {
    owner: any;
    callback: Callback;
}

declare class SelectiveHistory<T = unknown> {
    private HEAD_BRANCH;
    private HEAD_OPERATION;
    private tree;
    private readonly applyOperation;
    private readonly revertOperation;
    private readonly buildEmpty;
    private readonly buildTransformation;
    /**
     * The selective history is a data structure used to register changes/updates of a state.
     * Each change/update is called an "operation".
     * The data structure allows to easily cancel (and redo) any operation individually.
     * An operation can be represented by any data structure. It can be a "command", a "diff", etc.
     * However it must have the following properties:
     * - it can be applied to modify the state
     * - it can be reverted on the state such that it was never executed.
     * - it can be transformed given other operation (Operational Transformation)
     *
     * Since this data structure doesn't know anything about the state nor the structure of
     * operations, the actual work must be performed by external functions given as parameters.
     * @param initialOperationId
     * @param applyOperation a function which can apply an operation to the state
     * @param revertOperation  a function which can revert an operation from the state
     * @param buildEmpty  a function returning an "empty" operation.
     *                    i.e an operation that leaves the state unmodified once applied or reverted
     *                    (used for internal implementation)
     * @param buildTransformation Factory used to build transformations
     */
    constructor(args: {
        initialOperationId: UID;
        applyOperation: (data: T) => void;
        revertOperation: (data: T) => void;
        buildEmpty: (id: UID) => T;
        buildTransformation: TransformationFactory<T>;
    });
    /**
     * Return the operation identified by its id.
     */
    get(operationId: UID): T;
    /**
     * Append a new operation as the last one
     */
    append(operationId: UID, data: T): void;
    /**
     * Insert a new operation after a specific operation (may not be the last operation).
     * Following operations will be transformed according
     * to the new operation.
     */
    insert(operationId: UID, data: T, insertAfter: UID): void;
    /**
     * @param operationId operation to undo
     * @param undoId the id of the "undo operation"
     * @param insertAfter the id of the operation after which to insert the undo
     */
    undo(operationId: UID, undoId: UID, insertAfter: UID): void;
    /**
     * @param operationId operation to redo
     * @param redoId the if of the "redo operation"
     * @param insertAfter the id of the operation after which to insert the redo
     */
    redo(operationId: UID, redoId: UID, insertAfter: UID): void;
    rebase(operationId: UID): void;
    /**
     * Revert the state as it was *before* the given operation was executed.
     */
    private revertBefore;
    /**
     * Revert the state as it was *after* the given operation was executed.
     */
    private revertTo;
    /**
     * Revert an execution
     */
    private revert;
    /**
     * Replay the operations between the current HEAD_BRANCH and the end of the tree
     */
    private fastForward;
}

interface RevisionData {
    readonly id: UID;
    readonly clientId: ClientId;
    readonly commands: readonly CoreCommand[];
}

declare class Revision implements RevisionData {
    readonly rootCommand?: Command | undefined;
    readonly timestamp?: number | undefined;
    readonly id: UID;
    readonly clientId: ClientId;
    private _commands;
    private _changes;
    /**
     * A revision represents a whole client action (Create a sheet, merge a Zone, Undo, ...).
     * A revision contains the following information:
     *  - id: ID of the revision
     *  - commands: CoreCommands that are linked to the action, and should be
     *              dispatched in other clients
     *  - clientId: Client who initiated the action
     *  - changes: List of changes applied on the state.
     */
    constructor(id: UID, clientId: ClientId, commands: readonly CoreCommand[], rootCommand?: Command | undefined, changes?: readonly HistoryChange[], timestamp?: number | undefined);
    setChanges(changes: readonly HistoryChange[]): void;
    get commands(): readonly CoreCommand[];
    get changes(): readonly HistoryChange[];
}

declare class Session extends EventBus<CollaborativeEvent> {
    private revisions;
    private transportService;
    private serverRevisionId;
    /**
     * Positions of the others client.
     */
    private clients;
    private clientId;
    /**
     * Id of the server revision
     */
    private debouncedMove;
    private pendingMessages;
    /**
     * Stored position of the client, if session.move is called while the client is not in a session.
     * Will be used to send the position to the server when the client joins.
     */
    private awaitingClientPosition;
    private waitingAck;
    /**
     * Flag used to block all commands when an undo or redo is triggered, until
     * it is accepted on the server
     */
    private waitingUndoRedoAck;
    private isReplayingInitialRevisions;
    private processedRevisions;
    private lastRevisionMessage;
    private uuidGenerator;
    private lastLocalOperation;
    /**
     * Manages the collaboration between multiple users on the same spreadsheet.
     * It can forward local state changes to other users to ensure they all eventually
     * reach the same state.
     * It also manages the positions of each clients in the spreadsheet to provide
     * a visual indication of what other users are doing in the spreadsheet.
     *
     * @param revisions
     * @param transportService communication channel used to send and receive messages
     * between all connected clients
     * @param client the client connected locally
     * @param serverRevisionId
     */
    constructor(revisions: SelectiveHistory<Revision>, transportService: TransportService<CollaborationMessage>, serverRevisionId?: UID);
    canApplyOptimisticUpdate(): boolean;
    /**
     * Add a new revision to the collaborative session.
     * It will be transmitted to all other connected clients.
     */
    save(rootCommand: Command, commands: CoreCommand[], changes: HistoryChange[]): void;
    undo(revisionId: UID): void;
    redo(revisionId: UID): void;
    /**
     * Notify that the position of the client has changed
     */
    move(position: ClientPosition): void;
    join(client?: Client): void;
    loadInitialMessages(messages: StateUpdateMessage[]): void;
    /**
     * Notify the server that the user client left the collaborative session
     */
    leave(data?: Lazy<WorkbookData>): Promise<void>;
    /**
     * Send a snapshot of the spreadsheet to the collaboration server
     */
    snapshot(data: WorkbookData): Promise<void>;
    getCurrentClient(): Client;
    getClient(clientId: ClientId): Client;
    getConnectedClients(): Set<Client>;
    getRevisionId(): UID;
    isFullySynchronized(): boolean;
    /**
     * Get the last local revision
     * */
    getLastLocalNonEmptyRevision(): Revision | undefined;
    private _move;
    /**
     * Handles messages received from other clients in the collaborative
     * session.
     */
    private onMessageReceived;
    private onClientMoved;
    /**
     * Register the new client and send your
     * own position back.
     */
    private onClientJoined;
    private onClientLeft;
    private sendUpdateMessage;
    private sendToTransport;
    /**
     * Send the next pending message
     */
    private sendPendingMessage;
    private acknowledge;
    private isAlreadyProcessed;
    isWrongServerRevisionId(message: CollaborationMessage): boolean;
    private dropPendingHistoryMessages;
}

interface CoreViewPluginConfig {
    readonly getters: Getters;
    readonly stateObserver: StateObserver;
    readonly custom: ModelConfig["custom"];
    readonly session: Session;
    readonly defaultCurrency?: Partial<Currency>;
    readonly customColors: Color[];
    readonly external: ModelConfig["external"];
}
/**
 * Core view plugins handle any data derived from core date (i.e. evaluation).
 * They cannot impact the model data (i.e. cannot dispatch commands).
 */
declare class CoreViewPlugin<State = any> extends BasePlugin<State, Command> {
    protected getters: Getters;
    constructor({ getters, stateObserver }: CoreViewPluginConfig);
}

declare class EvaluationPlugin extends CoreViewPlugin {
    static getters: readonly ["evaluateFormula", "evaluateFormulaResult", "evaluateCompiledFormula", "getCorrespondingFormulaCell", "getRangeFormattedValues", "getRangeValues", "getRangeFormats", "getEvaluatedCell", "getEvaluatedCells", "getEvaluatedCellsInZone", "getEvaluatedCellsPositionInZone", "getEvaluatedCellsPositions", "getSpreadZone", "getArrayFormulaSpreadingOn", "isArrayFormulaSpillBlocked", "isEmpty"];
    private shouldRebuildDependenciesGraph;
    private evaluator;
    private positionsToUpdate;
    constructor(config: CoreViewPluginConfig);
    beforeHandle(cmd: Command): void;
    handle(cmd: CoreViewCommand): void;
    finalize(): void;
    evaluateFormula(sheetId: UID, formulaString: string): CellValue | Matrix<CellValue>;
    evaluateFormulaResult(sheetId: UID, formulaString: string): Matrix<FunctionResultObject> | FunctionResultObject;
    evaluateCompiledFormula(sheetId: UID, compiledFormula: RangeCompiledFormula, getSymbolValue: GetSymbolValue): FunctionResultObject | Matrix<FunctionResultObject>;
    /**
     * Return the value of each cell in the range as they are displayed in the grid.
     */
    getRangeFormattedValues(range: Range): FormattedValue[];
    /**
     * Return the value of each cell in the range.
     */
    getRangeValues(range: Range): CellValue[];
    /**
     * Return the format of each cell in the range.
     */
    getRangeFormats(range: Range): (Format | undefined)[];
    getEvaluatedCell(position: CellPosition): EvaluatedCell;
    getEvaluatedCells(sheetId: UID): EvaluatedCell[];
    getEvaluatedCellsPositions(sheetId: UID): CellPosition[];
    getEvaluatedCellsInZone(sheetId: UID, zone: Zone): EvaluatedCell[];
    getEvaluatedCellsPositionInZone(sheetId: UID, zone: Zone): [CellPosition, EvaluatedCell][];
    /**
     * Return the spread zone the position is part of, if any
     */
    getSpreadZone(position: CellPosition, options?: {
        ignoreSpillError: boolean;
    }): Zone | undefined;
    getArrayFormulaSpreadingOn(position: CellPosition): CellPosition | undefined;
    isArrayFormulaSpillBlocked(position: CellPosition): boolean;
    /**
     * Check if a zone only contains empty cells
     */
    isEmpty(sheetId: UID, zone: Zone): boolean;
    /**
     * Maps the visible positions of a range  according to a provided callback
     * @param range - the range we filter out
     * @param evaluationCallback - the callback applied to the filtered positions
     * @returns the values filtered (ie we keep only the not hidden values)
     */
    private mapVisiblePositions;
    exportForExcel(data: ExcelWorkbookData): void;
    /**
     * Returns the corresponding formula cell of a given cell
     * It could be the formula present in the cell itself or the
     * formula of the array formula that spreads to the cell
     */
    getCorrespondingFormulaCell(position: CellPosition): FormulaCell | undefined;
}

declare class CellIconPlugin extends CoreViewPlugin {
    static getters: readonly ["doesCellHaveGridIcon", "getCellIcons", "getCellIconRect"];
    private cellIconsCache;
    handle(cmd: Command): void;
    getCellIcons(position: CellPosition): GridIcon[];
    getCellIconRect(icon: GridIcon, cellRect: Rect): Rect;
    private getIconHorizontalPosition;
    private computeCellIcons;
    doesCellHaveGridIcon(position: CellPosition): boolean;
}

interface CustomColorState {
    readonly customColors: Immutable<Record<Color, true>>;
    readonly shouldUpdateColors: boolean;
}
/**
 * CustomColors plugin
 * This plugins aims to compute and keep to custom colors used in the
 * current spreadsheet
 */
declare class CustomColorsPlugin extends CoreViewPlugin<CustomColorState> {
    private readonly customColors;
    private readonly shouldUpdateColors;
    static getters: readonly ["getCustomColors"];
    constructor(config: CoreViewPluginConfig);
    handle(cmd: Command): void;
    finalize(): void;
    getCustomColors(): Color[];
    private computeCustomColors;
    private getColorsFromCells;
    private getFormattingColors;
    private getChartColors;
    private getTableColors;
    private getTableStyleElementColors;
    private tryToAddColors;
}

declare class DynamicTablesPlugin extends CoreViewPlugin {
    static getters: readonly ["canCreateDynamicTableOnZones", "doesZonesContainFilter", "getFilter", "getFilters", "getTable", "getTables", "getTablesOverlappingZones", "getFilterId", "getFilterHeaders", "isFilterHeader"];
    tables: Record<UID, Table[]>;
    handle(cmd: Command): void;
    finalize(): void;
    private computeTables;
    getFilters(sheetId: UID): Filter[];
    getTables(sheetId: UID): Table[];
    getFilter(position: CellPosition): Filter | undefined;
    getFilterId(position: CellPosition): FilterId | undefined;
    getTable({ sheetId, col, row }: CellPosition): Table | undefined;
    getTablesOverlappingZones(sheetId: UID, zones: Zone[]): Table[];
    doesZonesContainFilter(sheetId: UID, zones: Zone[]): boolean;
    getFilterHeaders(sheetId: UID): CellPosition[];
    isFilterHeader({ sheetId, col, row }: CellPosition): boolean;
    /**
     * Check if we can create a dynamic table on the given zones.
     * - The zones must be continuous
     * - The union of the zones must be either:
     *    - A single cell that contains an array formula
     *    - All the spread cells of a single array formula
     */
    canCreateDynamicTableOnZones(sheetId: UID, zones: Zone[]): boolean;
    private coreTableToTable;
    private getDynamicTableFilters;
    private getDynamicTableFilterId;
    exportForExcel(data: ExcelWorkbookData): void;
}

interface EvaluationChartStyle {
    background: Color;
    fontColor: Color;
}
interface EvaluationChartState {
    charts: Record<UID, ChartRuntime | undefined>;
}
declare class EvaluationChartPlugin extends CoreViewPlugin<EvaluationChartState> {
    static getters: readonly ["getChartRuntime", "getStyleOfSingleCellChart"];
    charts: Record<UID, ChartRuntime | undefined>;
    private createRuntimeChart;
    handle(cmd: CoreViewCommand): void;
    getChartRuntime(chartId: UID): ChartRuntime;
    /**
     * Get the background and textColor of a chart based on the color of the first cell of the main range of the chart.
     */
    getStyleOfSingleCellChart(chartBackground: Color | undefined, mainRange: Range | undefined): EvaluationChartStyle;
    exportForExcel(data: ExcelWorkbookData): Promise<void>;
}

declare class EvaluationConditionalFormatPlugin extends CoreViewPlugin {
    static getters: readonly ["getConditionalIcon", "getCellConditionalFormatStyle", "getConditionalDataBar"];
    private isStale;
    private computedStyles;
    private computedIcons;
    private computedDataBars;
    handle(cmd: CoreViewCommand): void;
    finalize(): void;
    getCellConditionalFormatStyle(position: CellPosition): Style | undefined;
    getConditionalIcon({ sheetId, col, row }: CellPosition): string | undefined;
    getConditionalDataBar({ sheetId, col, row }: CellPosition): DataBarFill | undefined;
    /**
     * Compute the styles according to the conditional formatting.
     * This computation must happen after the cell values are computed if they change
     *
     * This result of the computation will be in the state.cell[XC].conditionalStyle and will be the union of all the style
     * properties of the rules applied (in order).
     * So if a cell has multiple conditional formatting applied to it, and each affect a different value of the style,
     * the resulting style will have the combination of all those values.
     * If multiple conditional formatting use the same style value, they will be applied in order so that the last applied wins
     */
    private getComputedStyles;
    private getComputedIcons;
    private getComputedDataBars;
    private parsePoint;
    /** Compute the CF icons for the given range and CF rule, and apply in in the given computedIcons object */
    private applyIcon;
    private computeIcon;
    private applyDataBar;
    /** Compute the color scale for the given range and CF rule, and apply in in the given computedStyle object */
    private applyColorScale;
    private getRuleResultForTarget;
}

interface InvalidValidationResult {
    readonly isValid: false;
    readonly rule: DataValidationRule;
    readonly error: string;
}
interface ValidValidationResult {
    readonly isValid: true;
}
type ValidationResult = ValidValidationResult | InvalidValidationResult;
type SheetValidationResult = {
    [col: HeaderIndex]: Array<Lazy<ValidationResult>>;
};
declare class EvaluationDataValidationPlugin extends CoreViewPlugin {
    static getters: readonly ["getDataValidationInvalidCriterionValueMessage", "getInvalidDataValidationMessage", "getValidationResultForCellValue", "getDataValidationRangeValues", "isCellValidCheckbox", "getDataValidationCellStyle", "getDataValidationChipStyle", "isDataValidationInvalid"];
    validationResults: Record<UID, SheetValidationResult>;
    handle(cmd: CoreViewCommand): void;
    isDataValidationInvalid(cellPosition: CellPosition): boolean;
    getDataValidationCellStyle(position: CellPosition): Style | undefined;
    getDataValidationChipStyle(position: CellPosition): Style | undefined;
    getInvalidDataValidationMessage(cellPosition: CellPosition): string | undefined;
    /**
     * Check if the value is valid for the given criterion, and return an error message if not.
     *
     * The value must be canonicalized.
     */
    getDataValidationInvalidCriterionValueMessage(criterionType: DataValidationCriterionType, value: string): string | undefined;
    getDataValidationRangeValues(sheetId: UID, criterion: EvaluatedCriterion): {
        value: string;
        label: string;
    }[];
    isCellValidCheckbox(cellPosition: CellPosition): boolean;
    /** Get the validation result if the cell on the given position had the given value */
    getValidationResultForCellValue(cellValue: CellValue, cellPosition: CellPosition): ValidationResult;
    private hasChip;
    private getDataValidationStyle;
    private getValueColor;
    private isValidFormula;
    private getValidationResultForCell;
    private computeSheetValidationResults;
    private getRuleErrorForCellValue;
    /** Get the offset of the cell inside the ranges of the rule. Throws an error if the cell isn't inside the rule. */
    private getCellOffsetInRule;
    private getEvaluatedCriterionValues;
}

type Canvas2DContext = CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D;

interface HeaderSizeState {
    tallestCellInRow: Immutable<Record<UID, Array<CellWithSize | undefined>>>;
}
interface CellWithSize {
    cell: CellPosition;
    size: Pixel;
}
declare class HeaderSizeUIPlugin extends CoreViewPlugin<HeaderSizeState> implements HeaderSizeState {
    static getters: readonly ["getRowSize", "getHeaderSize", "getMaxAnchorOffset"];
    readonly tallestCellInRow: Immutable<Record<UID, Array<CellWithSize | undefined>>>;
    ctx: Canvas2DContext;
    beforeHandle(cmd: Command): void;
    handle(cmd: Command): void;
    getRowSize(sheetId: UID, row: HeaderIndex): Pixel;
    getMaxAnchorOffset(sheetId: UID, height: Pixel, width: Pixel): AnchorOffset;
    getHeaderSize(sheetId: UID, dimension: Dimension, index: HeaderIndex): Pixel;
    private updateRowSizeForZoneChange;
    private updateRowSizeForCellChange;
    private initializeSheet;
    /**
     * Return the height the cell should have in the sheet, which is either DEFAULT_CELL_HEIGHT if the cell is in a multi-row
     * merge, or the height of the cell computed based on its style/content.
     */
    private getCellHeight;
    private isInMultiRowMerge;
    /**
     * Get the tallest cell of a row and its size.
     */
    private getRowTallestCell;
}

/**
 * Represent a pivot runtime definition. A pivot runtime definition is a pivot
 * definition that has been enriched to include the display name of its attributes
 * (measures, columns, rows).
 */
declare class PivotRuntimeDefinition {
    readonly measures: PivotMeasure[];
    readonly columns: PivotDimension[];
    readonly rows: PivotDimension[];
    readonly sortedColumn?: PivotSortedColumn;
    readonly collapsedDomains?: PivotCollapsedDomains;
    readonly customFields?: Record<string, PivotCustomGroupedField>;
    constructor(definition: CommonPivotCoreDefinition, fields: PivotFields);
    getDimension(nameWithGranularity: string): PivotDimension;
    getMeasure(id: string): PivotMeasure;
    get invalidAggregatorsForCustomField(): string[];
    private createMeasure;
    private createPivotDimension;
}

interface CollapsiblePivotTableColumn extends PivotTableColumn {
    collapsedHeader?: boolean;
}
/**
 * Class used to ease the construction of a pivot table.
 * Let's consider the following example, with:
 * - columns groupBy: [sales_team, create_date]
 * - rows groupBy: [continent, city]
 * - measures: [revenues]
 * _____________________________________________________________________________________|   ----|
 * |                |   Sale Team 1             |  Sale Team 2            |             |       |
 * |                |___________________________|_________________________|_____________|       |
 * |                |   May 2020   | June 2020  |  May 2020  | June 2020  |   Total     |       |<---- `cols`
 * |                |______________|____________|____________|____________|_____________|       |   ----|
 * |                |   Revenues   |  Revenues  |  Revenues  |  Revenues  |   Revenues  |       |       |<--- `measureRow`
 * |________________|______________|____________|____________|____________|_____________|   ----|   ----|
 * |Europe          |     25       |     35     |     40     |     30     |     65      |   ----|
 * |    Brussels    |      0       |     15     |     30     |     30     |     30      |       |
 * |    Paris       |     25       |     20     |     10     |     0      |     35      |       |
 * |North America   |     60       |     75     |            |            |     60      |       |<---- `body`
 * |    Washington  |     60       |     75     |            |            |     60      |       |
 * |Total           |     85       |     110    |     40     |     30     |     125     |       |
 * |________________|______________|____________|____________|____________|_____________|   ----|
 *
 * |                |
 * |----------------|
 *         |
 *         |
 *       `rows`
 *
 * `rows` is an array of cells, each cells contains the indent level, the fields used for the group by and the values for theses fields.
 * For example:
 *   `Europe`: { indent: 1, fields: ["continent"], values: ["id_of_Europe"]}
 *   `Brussels`: { indent: 2, fields: ["continent", "city"], values: ["id_of_Europe", "id_of_Brussels"]}
 *   `Total`: { indent: 0, fields: [], values: []}
 *
 * `columns` is an double array, first by row and then by cell. So, in this example, it looks like:
 *   [[row1], [row2], [measureRow]]
 *   Each cell of a column's row contains the width (span) of the cells, the fields used for the group by and the values for theses fields.
 * For example:
 *   `Sale Team 1`: { width: 2, fields: ["sales_team"], values: ["id_of_SaleTeam1"]}
 *   `May 2020` (the one under Sale Team 2): { width: 1, fields: ["sales_team", "create_date"], values: ["id_of_SaleTeam2", "May 2020"]}
 *   `Revenues` (the one under Total): { width: 1, fields: ["measure"], values: ["revenues"]}
 *
 */
declare class SpreadsheetPivotTable {
    readonly columns: CollapsiblePivotTableColumn[][];
    rows: PivotTableRow[];
    readonly measures: string[];
    readonly fieldsType: Record<string, string | undefined>;
    readonly maxIndent: number;
    readonly pivotCells: {
        [key: string]: PivotTableCell[][];
    };
    private rowTree;
    private colTree;
    isSorted: boolean;
    constructor(columns: CollapsiblePivotTableColumn[][], rows: PivotTableRow[], measures: string[], fieldsType: Record<string, string | undefined>, collapsedDomains?: PivotCollapsedDomains);
    private removeCollapsedColumns;
    private isParentCollapsed;
    /**
     * Get the number of columns leafs (i.e. the number of the last row of columns)
     */
    getNumberOfDataColumns(): number;
    private getSkippedRows;
    getPivotCells(pivotStyle?: Required<PivotStyle>): PivotTableCell[][];
    getRowTree(): DimensionTree;
    getColTree(): DimensionTree;
    private isTotalRow;
    private getPivotCell;
    private getColHeaderDomain;
    private getDomain;
    private getColDomain;
    private getColMeasure;
    buildRowsTree(): DimensionTree;
    buildColumnsTree(): DimensionTree;
    export(): {
        cols: CollapsiblePivotTableColumn[][];
        rows: PivotTableRow[];
        measures: string[];
        fieldsType: Record<string, string | undefined>;
    };
    sort(measure: string, sortedColumn: PivotSortedColumn, getValue: (measure: string, domain: PivotDomain) => FunctionResultObject): void;
    private rowTreeToRows;
    get numberOfCells(): number;
    getColumnDomainsAtDepth(depth: number): {
        type: string;
        field: string;
        value: CellValue;
    }[][];
    getRowDomainsAtDepth(depth: number): {
        type: string;
        field: string;
        value: CellValue;
    }[][];
}

interface InitPivotParams {
    reload?: boolean;
}
interface Pivot<T = PivotRuntimeDefinition> {
    type: PivotCoreDefinition["type"];
    definition: T;
    init(params?: InitPivotParams): void;
    isValid(): boolean;
    onDefinitionChange(nextDefinition: PivotCoreDefinition): void;
    getCollapsedTableStructure(): SpreadsheetPivotTable;
    getExpandedTableStructure(): SpreadsheetPivotTable;
    getFields(): PivotFields;
    getPivotHeaderValueAndFormat(domain: PivotDomain): FunctionResultObject;
    getPivotCellValueAndFormat(measure: string, domain: PivotDomain): FunctionResultObject;
    getPivotMeasureValue(measure: string, domain: PivotDomain): FunctionResultObject;
    getMeasure: (id: string) => PivotMeasure;
    parseArgsToPivotDomain(args: Maybe<FunctionResultObject>[]): PivotDomain;
    areDomainArgsFieldsValid(args: Maybe<FunctionResultObject>[]): boolean;
    assertIsValid({ throwOnError }: {
        throwOnError: boolean;
    }): FunctionResultObject | undefined;
    getPossibleFieldValues(dimension: PivotDimension): {
        value: string | boolean | number;
        label: string;
    }[];
    needsReevaluation: boolean;
    markAsDirtyForEvaluation?(): void;
}

declare class PivotUIPlugin extends CoreViewPlugin {
    static getters: readonly ["getPivot", "getFirstPivotFunction", "getPivotCellSortDirection", "getPivotIdFromPosition", "getPivotCellFromPosition", "generateNewCalculatedMeasureName", "isPivotUnused", "isSpillPivotFormula"];
    private pivots;
    private unusedPivotsInFormulas?;
    private custom;
    constructor(config: CoreViewPluginConfig);
    beforeHandle(cmd: Command): void;
    handle(cmd: Command): void;
    /**
     * Get the id of the pivot at the given position. Returns undefined if there
     * is no pivot at this position
     */
    getPivotIdFromPosition(position: CellPosition): "" | UID | undefined;
    isSpillPivotFormula(position: CellPosition): boolean;
    getFirstPivotFunction(sheetId: UID, tokens: Token[]): {
        functionName: string;
        args: (CellValue | Matrix<CellValue> | undefined)[];
    } | undefined;
    /**
     * Returns the domain args of a pivot formula from a position.
     * For all those formulas:
     *
     * =PIVOT.VALUE(1,"expected_revenue","stage_id",2,"city","Brussels")
     * =PIVOT.HEADER(1,"stage_id",2,"city","Brussels")
     * =PIVOT.HEADER(1,"stage_id",2,"city","Brussels","measure","expected_revenue")
     *
     * the result is the same: ["stage_id", 2, "city", "Brussels"]
     *
     * If the cell is the result of PIVOT, the result is the domain of the cell
     * as if it was the individual pivot formula
     */
    getPivotCellFromPosition(position: CellPosition): PivotTableCell;
    generateNewCalculatedMeasureName(measures: PivotCoreMeasure[]): string;
    getPivot(pivotId: UID): Pivot<PivotRuntimeDefinition>;
    isPivotUnused(pivotId: UID): boolean;
    getPivotCellSortDirection(position: CellPosition): SortDirection | "none" | undefined;
    /**
     * Refresh the cache of a pivot
     */
    private refreshPivot;
    setupPivot(pivotId: UID, { recreate }?: {
        recreate: boolean;
    }): void;
    private _getUnusedPivotsInFormulas;
}

/**
 * An AutofillModifier describe the possible operations to apply to the
 * content of a cell when we autofill this cell.
 *
 * It could be:
 *  - Increment: increment the content by a given step
 *  - Copy: simply copy the content
 *  - Formula: update the formula, with the same behavior than paste
 */

interface Tooltip {
    props: any;
    component?: any;
}

interface StreamCallbacks<Event> {
    handleEvent: (event: Event) => void;
    /** this callback will only be called when another consumer captures the stream,
     * not when the current consumer decides to release itself */
    release?: () => void;
}

type SelectionEventOptions = {
    scrollIntoView?: boolean;
    unbounded?: boolean;
};
interface SelectionEvent {
    anchor: AnchorZone;
    previousAnchor: AnchorZone;
    mode: "newAnchor" | "overrideSelection" | "updateAnchor" | "commitSelection";
    options: SelectionEventOptions;
}

type StatefulStream<Event, State> = {
    capture(owner: unknown, state: State, callbacks: StreamCallbacks<Event>): void;
    registerAsDefault: (owner: unknown, state: State, callbacks: StreamCallbacks<Event>) => void;
    resetDefaultAnchor: (owner: unknown, state: State) => void;
    resetAnchor: (owner: unknown, state: State) => void;
    observe: (owner: unknown, callbacks: StreamCallbacks<Event>) => void;
    unobserve: (owner: unknown) => void;
    release: (owner: unknown) => void;
    getBackToDefault(): void;
};
/**
 * Allows to select cells in the grid and update the selection
 */
interface SelectionProcessor {
    selectZone(anchor: AnchorZone, options?: SelectionEventOptions): DispatchResult;
    selectCell(col: number, row: number): DispatchResult;
    moveAnchorCell(direction: Direction, step: SelectionStep): DispatchResult;
    setAnchorCorner(col: number, row: number): DispatchResult;
    addCellToSelection(col: number, row: number): DispatchResult;
    resizeAnchorZone(direction: Direction, step: SelectionStep): DispatchResult;
    selectColumn(index: number, mode: SelectionEvent["mode"]): DispatchResult;
    selectRow(index: number, mode: SelectionEvent["mode"]): DispatchResult;
    selectAll(): DispatchResult;
    loopSelection(): DispatchResult;
    selectTableAroundSelection(): DispatchResult;
    commitSelection(): DispatchResult;
    isListening(owner: unknown): boolean;
}
type SelectionStreamProcessor = SelectionProcessor & StatefulStream<SelectionEvent, AnchorZone>;

type UIActions = Pick<ModelConfig, "notifyUI" | "raiseBlockingErrorUI">;
interface UIPluginConfig {
    readonly getters: Getters;
    readonly stateObserver: StateObserver;
    readonly dispatch: CommandDispatcher["dispatch"];
    readonly canDispatch: CommandDispatcher["dispatch"];
    readonly selection: SelectionStreamProcessor;
    readonly moveClient: (position: ClientPosition) => void;
    readonly uiActions: UIActions;
    readonly custom: ModelConfig["custom"];
    readonly session: Session;
    readonly defaultCurrency?: Partial<Currency>;
    readonly customColors: Color[];
    readonly external: ModelConfig["external"];
}
/**
 * UI plugins handle any transient data required to display a spreadsheet.
 * They can draw on the grid canvas.
 */
declare class UIPlugin<State = any> extends BasePlugin<State, Command> {
    static layers: Readonly<LayerName[]>;
    protected getters: Getters;
    protected ui: UIActions;
    protected selection: SelectionStreamProcessor;
    protected dispatch: CommandDispatcher["dispatch"];
    protected canDispatch: CommandDispatcher["dispatch"];
    constructor({ getters, stateObserver, dispatch, canDispatch, uiActions, selection, }: UIPluginConfig);
    drawLayer(ctx: GridRenderingContext, layer: LayerName): void;
}

/**
 * Autofill Plugin
 *
 */
declare class AutofillPlugin extends UIPlugin {
    static layers: readonly ["Autofill"];
    static getters: readonly ["getAutofillTooltip"];
    private autofillZone;
    private steps;
    private lastCellSelected;
    private direction;
    private tooltip;
    allowDispatch(cmd: LocalCommand): CommandResult;
    handle(cmd: Command): void;
    getAutofillTooltip(): Tooltip | undefined;
    /**
     * Autofill the autofillZone from the current selection
     * @param apply Flag set to true to apply the autofill in the model. It's
     *              useful to set it to false when we need to fill the tooltip
     */
    private autofill;
    private collectBordersData;
    private collectConditionalFormatsData;
    private collectDataValidationsData;
    private autofillCell;
    private autofillBorders;
    private autofillConditionalFormats;
    private autofillDataValidations;
    /**
     * Select a cell which becomes the last cell of the autofillZone
     */
    private select;
    /**
     * Computes the autofillZone to autofill when the user double click on the
     * autofiller
     */
    private autofillAuto;
    private getAutofillAutoLastRow;
    /**
     * Generate the next cell
     */
    private computeNewCell;
    /**
     * Get the rule associated to the current cell
     */
    private getRule;
    /**
     * Create the generator to be able to autofill the next cells.
     */
    private createGenerator;
    private saveZone;
    /**
     * Compute the direction of the autofill from the last selected zone and
     * a given cell (col, row)
     */
    private getDirection;
    private autofillMerge;
    drawLayer(renderingContext: GridRenderingContext): void;
}

interface AutomaticSum {
    position: Position;
    zone: Zone;
}
declare class AutomaticSumPlugin extends UIPlugin {
    static getters: readonly ["getAutomaticSums"];
    handle(cmd: Command): void;
    getAutomaticSums(sheetId: UID, zone: Zone, anchor: Position): AutomaticSum[];
    private sumData;
    private sumAdjacentData;
    /**
     * Find a zone to automatically sum a column or row of numbers.
     *
     * We first decide which direction will be summed (column or row).
     * Here is the strategy:
     *  1. If the left cell is a number and the top cell is not: choose horizontal
     *  2. Try to find a valid vertical zone. If it's valid: choose vertical
     *  3. Try to find a valid horizontal zone. If it's valid: choose horizontal
     *  4. Otherwise, no zone is returned
     *
     * Now, how to find a valid zone?
     * The zone starts directly above or on the left of the starting point
     * (depending on the direction).
     * The zone ends where the first continuous sequence of numbers ends.
     * Empty or text cells can be part of the zone while no number has been found.
     * Other kind of cells (boolean, dates, etc.) are not valid in the zone and the
     * search stops immediately if one is found.
     *
     *  -------                                       -------
     * |   1   |                                     |   1   |
     *  -------                                       -------
     * |       |                                     |       |
     *  -------  <= end of the sequence, stop here    -------
     * |   2   |                                     |   2   |
     *  -------                                       -------
     * |   3   | <= start of the number sequence     |   3   |
     *  -------                                       -------
     * |       | <= ignored                          | FALSE | <= invalid, no zone is found
     *  -------                                       -------
     * |   A   | <= ignored                          |   A   | <= ignored
     *  -------                                       -------
     */
    private findAdjacentData;
    /**
     * Return the zone to sum if a valid one is found.
     * @see getAutomaticSumZone
     */
    private findSuitableZoneToSum;
    private findVerticalZone;
    private findHorizontalZone;
    /**
     * Reduces a column or row zone to a valid zone for the automatic sum.
     * @see getAutomaticSumZone
     * @param sheet
     * @param zone one dimensional zone (a single row or a single column). The zone is
     *             assumed to start at the beginning of the column (top=0) or the row (left=0)
     * @param end end index of the zone (`bottom` or `right` depending on the dimension)
     * @returns the starting position of the valid zone or Infinity if the zone is not valid.
     */
    private reduceZoneStart;
    private shouldFindData;
    private isNumber;
    private isZoneValid;
    private lastColIsEmpty;
    private lastRowIsEmpty;
    /**
     * Decides which dimensions (columns or rows) should be summed
     * based on its shape and what's inside the zone.
     */
    private dimensionsToSum;
    /**
     * Sum each column and/or row in the zone in the appropriate cells,
     * depending on the available space.
     */
    private sumDimensions;
    /**
     * Sum the total of the zone in the bottom right cell, assuming
     * the last row contains summed columns.
     */
    private sumTotal;
    private sumColumns;
    private sumRows;
    private dispatchCellUpdates;
    /**
     * Find the first row where all cells below the zone are empty.
     */
    private nextEmptyRow;
    /**
     * Find the first column where all cells right of the zone are empty.
     */
    private nextEmptyCol;
    /**
     * Transpose the given dimensions.
     * COL becomes ROW
     * ROW becomes COL
     */
    private transpose;
}

declare class CellComputedStylePlugin extends UIPlugin {
    static getters: readonly ["getCellComputedBorder", "getCellComputedStyle"];
    private styles;
    private borders;
    handle(cmd: Command): void;
    getCellComputedBorder(position: CellPosition, precomputeZone?: Zone): Border | null;
    private precomputeCellBorders;
    getCellComputedStyle(position: CellPosition, precomputeZone?: Zone): Style;
    private precomputeCellStyle;
}

declare class CheckboxTogglePlugin extends UIPlugin {
    static getters: readonly ["hasBooleanValidationInZones"];
    handle(cmd: Command): void;
    hasBooleanValidationInZones(zones: Zone[]): boolean;
    private toggleCheckbox;
}

interface ClientToDisplay extends Required<Client> {
}
declare class CollaborativePlugin extends UIPlugin {
    static getters: readonly ["getClientsToDisplay", "getClient", "getCurrentClient", "getConnectedClients", "isFullySynchronized"];
    static layers: readonly ["Selection"];
    private colors;
    private session;
    constructor(config: UIPluginConfig);
    private isPositionValid;
    getClient(clientId: ClientId): Client;
    getCurrentClient(): Client;
    getConnectedClients(): ClientWithColor[];
    isFullySynchronized(): boolean;
    /**
     * Get the list of others connected clients which are present in the same sheet
     * and with a valid position
     */
    getClientsToDisplay(): ClientToDisplay[];
    drawLayer(renderingContext: GridRenderingContext): void;
}

/**
 * This plugin provides dynamic translation getter. In o-spreadsheet, it has
 * no implementation, but this plugin can be replaced by another one to provide
 * a real implementation.
 *
 * For example, in Odoo, the plugin is replaced by a plugin that used the
 * module namespace to dynamically translate terms.
 */
declare class DynamicTranslate extends UIPlugin {
    static getters: readonly ["dynamicTranslate"];
    dynamicTranslate(term: string): string;
}

declare class GeoFeaturePlugin extends UIPlugin {
    static getters: readonly ["getGeoJsonFeatures", "geoFeatureNameToId", "getGeoChartAvailableRegions"];
    private readonly geoJsonService;
    private geoJsonCache;
    constructor(config: UIPluginConfig);
    getGeoChartAvailableRegions(): GeoChartRegion[];
    getGeoJsonFeatures(region: string): GeoJSON.Feature[] | undefined;
    geoFeatureNameToId(region: string, featureName: string): string | undefined;
    private convertToGeoJson;
}

declare class HeaderVisibilityUIPlugin extends UIPlugin {
    static getters: readonly ["getNextVisibleCellPosition", "findVisibleHeader", "findLastVisibleColRowIndex", "findFirstVisibleColRowIndex", "isRowHidden", "isColHidden", "isHeaderHidden"];
    isRowHidden(sheetId: UID, index: number): boolean;
    isColHidden(sheetId: UID, index: number): boolean;
    isHeaderHidden(sheetId: UID, dimension: Dimension, index: number): boolean;
    getNextVisibleCellPosition({ sheetId, col, row }: CellPosition): CellPosition;
    /**
     * Find the first visible header in the range [`from` => `to`].
     *
     * Both `from` and `to` are inclusive.
     */
    findVisibleHeader(sheetId: UID, dimension: Dimension, from: number, to: number): number | undefined;
    findLastVisibleColRowIndex(sheetId: UID, dimension: Dimension, { last, first }: {
        first: HeaderIndex;
        last: HeaderIndex;
    }): HeaderIndex;
    findFirstVisibleColRowIndex(sheetId: UID, dimension: Dimension): number | undefined;
    exportForExcel(data: ExcelWorkbookData): void;
}

/**
 * Local History
 *
 * The local history is responsible of tracking the locally state updates
 * It maintains the local undo and redo stack to allow to undo/redo only local
 * changes
 */
declare class HistoryPlugin extends UIPlugin {
    static getters: readonly ["canUndo", "canRedo"];
    /**
     * Ids of the revisions which can be undone
     */
    private undoStack;
    /**
     * Ids of the revisions which can be redone
     */
    private redoStack;
    private session;
    constructor(config: UIPluginConfig);
    allowDispatch(cmd: Command): CommandResult;
    handle(cmd: Command): void;
    finalize(): void;
    private requestHistoryChange;
    canUndo(): boolean;
    canRedo(): boolean;
    private onNewLocalStateUpdate;
    /**
     * Fetch the last revision which is not empty and not a repeated command
     *
     * Ignore repeated commands (REQUEST_REDO command as root command)
     * Ignore standard undo/redo revisions (that are empty)
     */
    private getPossibleRevisionToRepeat;
}

declare class PivotPresenceTracker {
    private trackedValues;
    private domainToArray;
    isValuePresent(measure: string, domain: PivotDomain): boolean;
    isHeaderPresent(domain: PivotDomain): boolean;
    trackValue(measure: string, domain: PivotDomain): void;
    trackHeader(domain: PivotDomain): void;
}

declare class PivotPresencePlugin extends UIPlugin {
    static getters: readonly ["getPivotPresenceTracker"];
    private trackPresencePivotId?;
    private tracker?;
    handle(cmd: Command): void;
    getPivotPresenceTracker(pivotId: UID): PivotPresenceTracker | undefined;
}

declare class SortPlugin extends UIPlugin {
    allowDispatch(cmd: LocalCommand): CommandResult | CommandResult[];
    handle(cmd: Command): void;
    private checkMerge;
    private checkMergeSizes;
    private checkArrayFormulaInSortZone;
    /**
     * This function evaluates if the top row of a provided zone can be considered as a `header`
     * by checking the following criteria:
     * * If the left-most column top row value (topLeft) is empty, we ignore it while evaluating the criteria.
     * 1 - Apart from the left-most column, every element of the top row must be non-empty, i.e. a cell should be present in the sheet.
     * 2 - There should be at least one column in which the type (CellValueType) of the rop row cell differs from the type of the cell below.
     *  For the second criteria, we ignore columns on which the cell below is empty.
     *
     */
    private hasHeader;
    private sortZone;
    /**
     * Return the distances between main merge cells in the zone.
     * (1 if there are no merges).
     * Note: it is assumed all merges are the same in the zone.
     */
    private mainCellsSteps;
    /**
     * Return a 2D array of cells in the zone (main merge cells if there are merges)
     */
    private mainCells;
}

declare class SplitToColumnsPlugin extends UIPlugin {
    static getters: readonly ["getAutomaticSeparator"];
    allowDispatch(cmd: Command): CommandResult | CommandResult[];
    handle(cmd: Command): void;
    getAutomaticSeparator(): string;
    private getAutoSeparatorForString;
    private splitIntoColumns;
    private getSplittedCols;
    private splitAndRemoveTrailingEmpty;
    private willSplittedColsOverwriteContent;
    private removeMergesInSplitZone;
    private addColsToAvoidCollisions;
    private getColsToAddToAvoidCollision;
    private addColumnsToNotOverflowSheet;
    private checkSingleColSelected;
    private checkNonEmptySelector;
    private checkNotOverwritingContent;
    private checkSeparatorInSelection;
}

declare class SubtotalEvaluationPlugin extends UIPlugin {
    private subtotalCells;
    handle(cmd: Command): void;
}

declare class TableComputedStylePlugin extends UIPlugin {
    static getters: readonly ["getCellTableStyle", "getCellTableBorder", "getCellTableBorderZone", "getCellTableStyleZone"];
    private tableStyles;
    handle(cmd: Command): void;
    finalize(): void;
    getCellTableStyle(position: CellPosition): Style | undefined;
    getCellTableStyleZone(sheetId: UID, zone: Zone): PositionMap<Style>;
    getCellTableBorder(position: CellPosition): Border | undefined;
    getCellTableBorderZone(sheetId: UID, zone: Zone): PositionMap<Border>;
    private computeTableStyle;
    /**
     * Get the actual table config that will be used to compute the table style. It is different from
     * the config of the table because of hidden rows and columns in the sheet. For example remove the
     * hidden rows from config.numberOfHeaders.
     */
    private getTableRuntimeConfig;
    /**
     * Get a mapping: relative col/row position in the table <=> col/row in the sheet
     */
    private getTableMapping;
}

declare class UIOptionsPlugin extends UIPlugin {
    static getters: readonly ["shouldShowFormulas"];
    private showFormulas;
    handle(cmd: Command): void;
    shouldShowFormulas(): boolean;
}

declare class SheetUIPlugin extends UIPlugin {
    static getters: readonly ["getCellWidth", "getTextWidth", "getCellText", "getCellMultiLineText", "getMultilineTextSize", "getContiguousZone", "computeTextYCoordinate"];
    private ctx;
    allowDispatch(cmd: LocalCommand): CommandResult | CommandResult[];
    handle(cmd: Command): void;
    getCellWidth(position: CellPosition): number;
    getTextWidth(text: string, style: Style): Pixel;
    getMultilineTextSize(text: string[], style: Style): {
        width: number;
        height: number;
    };
    getCellText(position: CellPosition, args?: {
        showFormula?: boolean;
        availableWidth?: number;
    }): string;
    /**
     * Return the text of a cell, split in multiple lines if needed. The text will be split in multiple
     * line if it contains NEWLINE characters, or if it's longer than the given width.
     */
    getCellMultiLineText(position: CellPosition, args: {
        wrapText: boolean;
        maxWidth: number;
    }): string[];
    /** Computes the vertical start point from which a text line should be draw in a cell.
     *
     * Note that in case the cell does not have enough spaces to display its text lines,
     * (wrapping cell case) then the vertical align should be at the top.
     * */
    computeTextYCoordinate(cellRect: Rect, textLineHeight: number, verticalAlign?: VerticalAlign, numberOfLines?: number): number;
    /**
     * Expands the given zone until bordered by empty cells or reached the sheet boundaries.
     */
    getContiguousZone(sheetId: UID, zoneToExpand: Zone): Zone;
    /**
     * Checks if a cell is empty (i.e. does not have a content or a formula does not spread over it).
     * If the cell is part of a merge, the check applies to the main cell of the merge.
     */
    private isCellEmpty;
    private getColMaxWidth;
    /**
     * Check that any "sheetId" in the command matches an existing
     * sheet.
     */
    private checkSheetExists;
    /**
     * Check if zones in the command are well formed and
     * not outside the sheet.
     */
    private checkZonesAreInSheet;
    private autoResizeRows;
}

declare class CarouselUIPlugin extends UIPlugin {
    static getters: readonly ["getSelectedCarouselItem", "getChartFromFigureId", "getChartIdFromFigureId"];
    private uuidGenerator;
    carouselStates: Record<UID, string | undefined>;
    allowDispatch(cmd: LocalCommand): CommandResult | CommandResult[];
    handle(cmd: Command): void;
    popOutChartFromCarousel(carouselId: UID, chartId: UID, sheetId: UID): void;
    getSelectedCarouselItem(figureId: UID): CarouselItem | undefined;
    getChartFromFigureId(figureId: UID): AbstractChart | undefined;
    getChartIdFromFigureId(figureId: UID): UID | undefined;
    private fixWrongCarouselState;
    private addNewChartToCarousel;
    private addFigureChartToCarousel;
    private duplicateCarouselChart;
    private getCarouselItemId;
}

declare enum ClipboardMIMEType {
    PlainText = "text/plain",
    Html = "text/html",
    Image = "image"
}
type OSClipboardContent = {
    [key in (typeof AllowedImageMimeTypes)[number]]?: Blob;
} & {
    [ClipboardMIMEType.PlainText]?: string;
    [ClipboardMIMEType.Html]?: string;
};
interface SpreadsheetClipboardData extends MinimalClipboardData {
    version?: string;
    clipboardId?: string;
}
type ParsedOSClipboardContent = {
    text?: string;
    data?: SpreadsheetClipboardData;
    imageBlob?: Blob;
};
type ParsedOsClipboardContentWithImageData = ParsedOSClipboardContent & {
    imageData?: Image$1;
};
type ClipboardPasteOptions = "onlyFormat" | "asValue";
type MinimalClipboardData = {
    sheetId?: UID;
    cells?: ClipboardCell[][];
    zones?: Zone[];
    figureId?: UID;
    [key: string]: unknown;
};

/**
 * Clipboard Plugin
 *
 * This clipboard manages all cut/copy/paste interactions internal to the
 * application, and with the OS clipboard as well.
 */
declare class ClipboardPlugin extends UIPlugin {
    static layers: readonly ["Clipboard"];
    static getters: readonly ["getClipboardTextAndImageContent", "getClipboardId", "getClipboardTextContent", "isCutOperation"];
    private status;
    private originSheetId?;
    private copiedData?;
    private _isCutOperation;
    private clipboardId;
    private fileStore?;
    private uuidGenerator;
    constructor(config: UIPluginConfig);
    allowDispatch(cmd: LocalCommand): CommandResult;
    handle(cmd: Command): void;
    private convertTextToClipboardData;
    private selectClipboardHandlers;
    private isCutAllowedOn;
    private isPasteAllowed;
    private isColRowDirtyingClipboard;
    private copy;
    private paste;
    /**
     * Add columns and/or rows to ensure that col + width and row + height are still
     * in the sheet
     */
    private addMissingDimensions;
    /**
     * Format the current clipboard to a string suitable for being pasted in other
     * programs.
     *
     * - add a tab character between each consecutive cells
     * - add a newline character between each line
     *
     * Note that it returns \t if the clipboard is empty. This is necessary for the
     * clipboard copy event to add it as data, otherwise an empty string is not
     * considered as a copy content.
     */
    getClipboardTextContent(): string;
    getClipboardId(): string;
    getClipboardTextAndImageContent(): Promise<OSClipboardContent>;
    private getSheetData;
    private getPlainTextContent;
    private getHTMLContent;
    private readFileAsDataURL;
    private craftImageHTML;
    private getImageContent;
    isCutOperation(): boolean;
    private getDeleteCellsTargets;
    private getInsertCellsTargets;
    private getClipboardData;
    drawLayer(renderingContext: GridRenderingContext): void;
}

declare class FilterEvaluationPlugin extends UIPlugin {
    static getters: readonly ["getFilterValue", "getFilterHiddenValues", "getFilterCriterionValue", "getFirstTableInSelection", "isRowFiltered", "isFilterActive"];
    private filterValues;
    hiddenRows: Record<UID, Set<number> | undefined>;
    isEvaluationDirty: boolean;
    allowDispatch(cmd: LocalCommand): CommandResult;
    handle(cmd: Command): void;
    finalize(): void;
    isRowFiltered(sheetId: UID, row: number): boolean;
    getFilterValue(position: CellPosition): DataFilterValue | undefined;
    getFilterHiddenValues(position: CellPosition): string[];
    getFilterCriterionValue(position: CellPosition): CriterionFilter;
    isFilterActive(position: CellPosition): boolean;
    getFirstTableInSelection(): Table | undefined;
    private updateFilter;
    private updateHiddenRows;
    private getCellValueAsString;
    exportForExcel(data: ExcelWorkbookData): void;
    /**
     * Get an unique column name for the column at colIndex. If the column name is already in the array of used column names,
     * concatenate a number to the name until we find a new unique name (eg. "ColName" => "ColName1" => "ColName2" ...)
     */
    private getUniqueColNameForExcel;
}

declare class HeaderPositionsUIPlugin extends UIPlugin {
    static getters: readonly ["getColDimensions", "getRowDimensions", "getColRowOffset"];
    private headerPositions;
    private isDirty;
    handle(cmd: Command): void;
    finalize(): void;
    /**
     * Returns the size, start and end coordinates of a column on an unfolded sheet
     */
    getColDimensions(sheetId: UID, col: HeaderIndex): HeaderDimensions;
    /**
     * Returns the size, start and end coordinates of a row an unfolded sheet
     */
    getRowDimensions(sheetId: UID, row: HeaderIndex): HeaderDimensions;
    /**
     * Returns the offset of a header (determined by the dimension) at the given index
     * based on the referenceIndex given. If start === 0, this method will return
     * the start attribute of the header.
     *
     * i.e. The size from A to B is the distance between A.start and B.end
     */
    getColRowOffset(dimension: Dimension, referenceIndex: HeaderIndex, index: HeaderIndex, sheetId?: UID): Pixel;
    private computeHeaderPositionsOfSheet;
    private computePositions;
}

/**
 * SelectionPlugin
 */
declare class GridSelectionPlugin extends UIPlugin {
    static layers: readonly ["Selection"];
    static getters: readonly ["getActiveSheet", "getActiveSheetId", "getActiveSheetName", "getActiveCell", "getActiveCols", "getActiveRows", "getCurrentStyle", "getSelectedZones", "getSelectedZone", "getSelectedCells", "getSelectedFigureId", "getSelection", "getActivePosition", "getSheetPosition", "isSingleColSelected", "getElementsFromSelection", "tryGetActiveSheetId", "isGridSelectionActive", "getSelectecUnboundedZone"];
    private gridSelection;
    private selectedFigureId;
    private sheetsData;
    private moveClient;
    private isUnbounded;
    activeSheet: Sheet;
    constructor(config: UIPluginConfig);
    allowDispatch(cmd: LocalCommand): CommandResult;
    private handleEvent;
    handle(cmd: Command): void;
    finalize(): void;
    isGridSelectionActive(): boolean;
    getActiveSheet(): Readonly<Sheet>;
    getActiveSheetId(): UID;
    getActiveSheetName(): string;
    tryGetActiveSheetId(): UID | undefined;
    getActiveCell(): EvaluatedCell;
    getActiveCols(): Set<number>;
    getActiveRows(): Set<number>;
    getCurrentStyle(): Style;
    getSelectedZones(): Zone[];
    getSelectedZone(): Zone;
    getSelectecUnboundedZone(): UnboundedZone;
    getSelection(): Selection;
    getSelectedCells(): EvaluatedCell[];
    getSelectedFigureId(): UID | null;
    getActivePosition(): CellPosition;
    getSheetPosition(sheetId: UID): CellPosition;
    isSingleColSelected(): boolean;
    /**
     * Returns a sorted array of indexes of all columns (respectively rows depending
     * on the dimension parameter) intersected by the currently selected zones.
     *
     * example:
     * assume selectedZones: [{left:0, right: 2, top :2, bottom: 4}, {left:5, right: 6, top :3, bottom: 5}]
     *
     * if dimension === "COL" => [0,1,2,5,6]
     * if dimension === "ROW" => [2,3,4,5]
     */
    getElementsFromSelection(dimension: Dimension): number[];
    private activateSheet;
    /**
     * Ensure selections are not outside sheet boundaries.
     * They are clipped to fit inside the sheet if needed.
     */
    private setSelectionMixin;
    /**
     * Change the anchor of the selection active cell to an absolute col and row index.
     *
     * This is a non trivial task. We need to stop the editing process and update
     * properly the current selection.  Also, this method can optionally create a new
     * range in the selection.
     */
    private selectCell;
    private setActiveSheet;
    private activateNextSheet;
    private onColumnsRemoved;
    private onRowsRemoved;
    private onAddElements;
    private onMoveElements;
    private getFiguresUpdates;
    private applyFigureUpdates;
    private isMoveElementAllowed;
    private isTableRowMoveAllowed;
    private fallbackToVisibleSheet;
    /**
     * Clip the selection if it spans outside the sheet
     */
    private clipSelection;
    drawLayer(renderingContext: GridRenderingContext): void;
}

declare class InternalViewport {
    private getters;
    private sheetId;
    private boundaries;
    top: HeaderIndex;
    bottom: HeaderIndex;
    left: HeaderIndex;
    right: HeaderIndex;
    offsetX: Pixel;
    offsetY: Pixel;
    canScrollVertically: boolean;
    canScrollHorizontally: boolean;
    viewportWidth: Pixel;
    viewportHeight: Pixel;
    offsetCorrectionX: Pixel;
    offsetCorrectionY: Pixel;
    constructor(getters: Getters, sheetId: UID, boundaries: Zone, sizeInGrid: DOMDimension, options: {
        canScrollVertically: boolean;
        canScrollHorizontally: boolean;
    }, offsets: DOMCoordinates);
    /** Returns the maximum size (in Pixels) of the viewport relative to its allocated client size
     * When the viewport grid size is smaller than its client width (resp. height), it will return
     * the client width (resp. height).
     */
    getMaxSize(): DOMDimension;
    /**
     * Return the index of a column given an offset x, based on the pane left
     * visible cell.
     * It returns -1 if no column is found.
     */
    getColIndex(x: Pixel): HeaderIndex;
    /**
     * Return the index of a row given an offset y, based on the pane top
     * visible cell.
     * It returns -1 if no row is found.
     */
    getRowIndex(y: Pixel): HeaderIndex;
    /**
     * This function will make sure that the provided cell position (or current selected position) is part of
     * the pane that is actually displayed on the client. We therefore adjust the offset of the pane
     * until it contains the cell completely.
     */
    adjustPosition(position: Position): void;
    private adjustPositionX;
    private adjustPositionY;
    willNewOffsetScrollViewport(offsetX: Pixel, offsetY: Pixel): boolean;
    setViewportOffset(offsetX: Pixel, offsetY: Pixel): void;
    adjustViewportZone(): void;
    /**
     *
     * Computes the visible coordinates & dimensions of a given zone inside the viewport
     *
     */
    getVisibleRect(zone: Zone): Rect | undefined;
    /**
     *
     * @returns Computes the absolute coordinates & dimensions of a given zone inside the viewport
     *
     */
    getFullRect(zone: Zone): Rect | undefined;
    isVisible(col: HeaderIndex, row: HeaderIndex): boolean;
    private searchHeaderIndex;
    private setViewportOffsetX;
    private setViewportOffsetY;
    /** Corrects the viewport's horizontal offset based on the current structure
     *  To make sure that at least one column is visible inside the viewport.
     */
    private adjustViewportOffsetX;
    /** Corrects the viewport's vertical offset based on the current structure
     *  To make sure that at least one row is visible inside the viewport.
     */
    private adjustViewportOffsetY;
    /** Updates the pane zone and snapped offset based on its horizontal
     * offset (will find Left) and its width (will find Right) */
    private adjustViewportZoneX;
    /** Updates the pane zone and snapped offset based on its vertical
     * offset (will find Top) and its width (will find Bottom) */
    private adjustViewportZoneY;
    /** represents the part of the header on the topLeft that could be partially
     * hidden due to the scroll
     * */
    private get snapCorrection();
}

/**
 *   EdgeScrollCases Schema
 *
 *  The dots/double dots represent a freeze (= a split of viewports)
 *  In this example, we froze vertically between columns D and E
 *  and horizontally between rows 4 and 5.
 *
 *  One can see that we scrolled horizontally from column E to G and
 *  vertically from row 5 to 7.
 *
 *     A  B  C  D   G  H  I  J  K  L  M  N  O  P  Q  R  S  T
 *     _______________________________________________________
 *  1 |           :                                           |
 *  2 |           :                                           |
 *  3 |           :        B   ↑                 6            |
 *  4 |           :        |   |                 |            |
 *     ····················+···+·················+············|
 *  7 |           :        |   |                 |            |
 *  8 |           :        ↓   2                 |            |
 *  9 |           :                              |            |
 * 10 |       A --+--→                           |            |
 * 11 |           :                              |            |
 * 12 |           :                              |            |
 * 13 |        ←--+-- 1                          |            |
 * 14 |           :                              |        3 --+--→
 * 15 |           :                              |            |
 * 16 |           :                              |            |
 * 17 |       5 --+-------------------------------------------+--→
 * 18 |           :                              |            |
 * 19 |           :                  4           |            |
 * 20 |           :                  |           |            |
 *     ______________________________+___________| ____________
 *                                   |           |
 *                                   ↓           ↓
 */
/**
 * Viewport plugin.
 *
 * This plugin manages all things related to all viewport states.
 *
 */
declare class SheetViewPlugin extends UIPlugin {
    static getters: readonly ["getColIndex", "getRowIndex", "getActiveMainViewport", "getSheetViewDimension", "getSheetViewDimensionWithHeaders", "getMainViewportRect", "isVisibleInViewport", "getEdgeScrollCol", "getEdgeScrollRow", "getVisibleFigures", "getVisibleRect", "getVisibleRectWithoutHeaders", "getVisibleRectWithZoom", "getVisibleCellPositions", "getColRowOffsetInViewport", "getMainViewportCoordinates", "getActiveSheetScrollInfo", "getSheetViewVisibleCols", "getSheetViewVisibleRows", "getFrozenSheetViewRatio", "isPixelPositionVisible", "getColDimensionsInViewport", "getRowDimensionsInViewport", "getAllActiveViewportsZonesAndRect", "getRect", "getFigureUI", "getPositionAnchorOffset", "getGridOffset", "getViewportZoomLevel", "getScrollBarWidth", "getMaximumSheetOffset"];
    private viewports;
    /**
     * The viewport dimensions are usually set by one of the components
     * (i.e. when grid component is mounted) to properly reflect its state in the DOM.
     * In the absence of a component (standalone model), is it mandatory to set reasonable default values
     * to ensure the correct operation of this plugin.
     */
    private sheetViewWidth;
    private sheetViewHeight;
    private gridOffsetX;
    private gridOffsetY;
    private zoomLevel;
    private sheetsWithDirtyViewports;
    private shouldAdjustViewports;
    allowDispatch(cmd: LocalCommand): CommandResult | CommandResult[];
    private handleEvent;
    handle(cmd: Command): void;
    finalize(): void;
    private setViewports;
    /**
     * Return the index of a column given an offset x, based on the viewport left
     * visible cell.
     * It returns -1 if no column is found.
     */
    getColIndex(x: Pixel): HeaderIndex;
    /**
     * Return the index of a row given an offset y, based on the viewport top
     * visible cell.
     * It returns -1 if no row is found.
     */
    getRowIndex(y: Pixel): HeaderIndex;
    getSheetViewDimensionWithHeaders(): DOMDimension;
    getSheetViewDimension(): DOMDimension;
    getGridOffset(): DOMCoordinates;
    /** type as pane, not viewport but basically pane extends viewport */
    getActiveMainViewport(): Viewport;
    /**
     * Return the DOM scroll info of the active sheet, ie. the offset between the viewport left/top side and
     * the grid left/top side, corresponding to the scroll of the scrollbars and not snapped to the grid.
     */
    getActiveSheetScrollInfo(): SheetDOMScrollInfo;
    getSheetViewVisibleCols(): HeaderIndex[];
    getSheetViewVisibleRows(): HeaderIndex[];
    /**
     * Get the positions of all the cells that are visible in the viewport, taking merges into account.
     */
    getVisibleCellPositions(): CellPosition[];
    /**
     * Return the main viewport maximum size relative to the client size.
     */
    getMainViewportRect(): Rect;
    getMaximumSheetOffset(): {
        maxOffsetX: Pixel;
        maxOffsetY: Pixel;
    };
    getColRowOffsetInViewport(dimension: Dimension, referenceHeaderIndex: HeaderIndex, targetHeaderIndex: HeaderIndex): Pixel;
    /**
     * Check if a given position is visible in the viewport.
     */
    isVisibleInViewport({ sheetId, col, row }: CellPosition): boolean;
    getScrollBarWidth(): Pixel;
    getEdgeScrollCol(x: number, previousX: number, startingX: number): EdgeScrollInfo;
    getEdgeScrollRow(y: number, previousY: number, startingY: number): EdgeScrollInfo;
    /**
     * Computes the coordinates and size to draw the zone on the canvas
     */
    getVisibleRect(zone: Zone): Rect;
    /**
     * Computes the coordinates and size to draw the zone on the canvas after it has been zoomed
     */
    getVisibleRectWithZoom(zone: Zone): Rect;
    /**
     * Computes the coordinates and size to draw the zone without taking the grid offset into account
     */
    getVisibleRectWithoutHeaders(zone: Zone): Rect;
    /**
     * Computes the actual size and position (:Rect) of the zone on the canvas
     * regardless of the viewport dimensions.
     */
    getRect(zone: Zone): Rect;
    /**
     * Computes the actual size and position (:Rect) of the zone on the canvas
     * regardless of the viewport dimensions.
     */
    getRectWithoutHeaders(zone: Zone): Rect;
    /**
     * Returns the position of the MainViewport relatively to the start of the grid (without headers)
     * It corresponds to the summed dimensions of the visible cols/rows (in x/y respectively)
     * situated before the pane divisions.
     */
    getMainViewportCoordinates(): DOMCoordinates;
    /**
     * Returns the size, start and end coordinates of a column relative to the left
     * column of the current viewport
     */
    getColDimensionsInViewport(sheetId: UID, col: HeaderIndex): HeaderDimensions;
    /**
     * Returns the size, start and end coordinates of a row relative to the top row
     * of the current viewport
     */
    getRowDimensionsInViewport(sheetId: UID, row: HeaderIndex): HeaderDimensions;
    getAllActiveViewportsZonesAndRect(): {
        zone: Zone;
        rect: Rect;
    }[];
    getViewportZoomLevel(): number;
    private ensureMainViewportExist;
    private getSubViewports;
    private checkPositiveDimension;
    private checkValuesAreDifferent;
    private checkScrollingDirection;
    private checkIfViewportsWillChange;
    private getMainViewport;
    private getMainInternalViewport;
    /** gets rid of deprecated sheetIds */
    private cleanViewports;
    private resizeSheetView;
    private recomputeViewports;
    private setSheetViewOffset;
    private getViewportOffset;
    private resetViewports;
    /**
     * Adjust the viewport such that the anchor position is visible
     */
    private refreshViewport;
    /**
     * Shift the viewport vertically and move the selection anchor
     * such that it remains at the same place relative to the
     * viewport top.
     */
    private shiftVertically;
    /**
     * Return the index of a col given a negative offset x, based on the main viewport top
     * visible cell of the main viewport.
     * It returns -1 if no col is found.
     */
    private getColIndexLeftOfMainViewport;
    /**
     * Return the index of a row given a negative offset y, based on the main viewport top
     * visible cell of the main viewport.
     * It returns -1 if no row is found.
     */
    private getRowIndexTopOfMainViewport;
    getVisibleFigures(): FigureUI[];
    getFigureUI(sheetId: UID, figure: Figure): FigureUI;
    getPositionAnchorOffset(position: PixelPosition): AnchorOffset;
    isPixelPositionVisible(position: PixelPosition): boolean;
    getFrozenSheetViewRatio(sheetId: UID): {
        xRatio: number;
        yRatio: number;
    };
    mapViewportsToRect(sheetId: UID, rectCallBack: (viewport: InternalViewport) => Rect | undefined): Rect;
}

type Getters = {
    isReadonly: () => boolean;
    isDashboard: () => boolean;
} & CoreGetters & PluginGetters<typeof AutofillPlugin> & PluginGetters<typeof AutomaticSumPlugin> & PluginGetters<typeof HistoryPlugin> & PluginGetters<typeof ClipboardPlugin> & PluginGetters<typeof EvaluationPlugin> & PluginGetters<typeof EvaluationChartPlugin> & PluginGetters<typeof EvaluationConditionalFormatPlugin> & PluginGetters<typeof HeaderVisibilityUIPlugin> & PluginGetters<typeof CustomColorsPlugin> & PluginGetters<typeof AutomaticSumPlugin> & PluginGetters<typeof GridSelectionPlugin> & PluginGetters<typeof CollaborativePlugin> & PluginGetters<typeof SortPlugin> & PluginGetters<typeof UIOptionsPlugin> & PluginGetters<typeof SheetUIPlugin> & PluginGetters<typeof SheetViewPlugin> & PluginGetters<typeof FilterEvaluationPlugin> & PluginGetters<typeof SplitToColumnsPlugin> & PluginGetters<typeof SubtotalEvaluationPlugin> & PluginGetters<typeof HeaderSizeUIPlugin> & PluginGetters<typeof EvaluationDataValidationPlugin> & PluginGetters<typeof HeaderPositionsUIPlugin> & PluginGetters<typeof TableStylePlugin> & PluginGetters<typeof CellComputedStylePlugin> & PluginGetters<typeof DynamicTablesPlugin> & PluginGetters<typeof PivotUIPlugin> & PluginGetters<typeof TableComputedStylePlugin> & PluginGetters<typeof GeoFeaturePlugin> & PluginGetters<typeof PivotPresencePlugin> & PluginGetters<typeof TableComputedStylePlugin> & PluginGetters<typeof CheckboxTogglePlugin> & PluginGetters<typeof CellIconPlugin> & PluginGetters<typeof DynamicTranslate> & PluginGetters<typeof CarouselUIPlugin>;

interface SearchOptions {
    matchCase: boolean;
    exactMatch: boolean;
    searchFormulas: boolean;
    searchScope: "allSheets" | "activeSheet" | "specificRange";
    specificRange?: Range;
}

/**
 * Escapes a string to use as a literal string in a RegExp.
 * @url https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Escaping
 */
declare function escapeRegExp(str: string): string;
/**
 * Deep copy arrays, plain objects and primitive values.
 * Throws an error for other types such as class instances.
 * Sparse arrays remain sparse.
 */
declare function deepCopy<T>(obj: T): T;
/**
 * Sanitize the name of a sheet, by eventually removing quotes.
 */
declare function getUnquotedSheetName(sheetName: string): string;
/**
 * Remove quotes from a quoted string.
 */
declare function unquote(string: string, quoteChar?: "'" | '"'): string;
/**
 * Add quotes around the sheet name or any symbol name if it contains at least one non alphanumeric character.
 */
declare function getCanonicalSymbolName(symbolName: string): string;
/** Replace the excel-excluded characters of a sheetName */
declare function sanitizeSheetName(sheetName: string, replacementChar?: string): string;
declare function clip(val: number, min: number, max: number): number;
/**
 * Create a range from start (included) to end (excluded).
 * range(10, 13) => [10, 11, 12]
 * range(2, 8, 2) => [2, 4, 6]
 */
declare function range(start: number, end: number, step?: number): number[];
/**
 * Groups consecutive numbers.
 * The input array is assumed to be sorted
 * @param numbers
 */
declare function groupConsecutive(numbers: number[]): ConsecutiveIndexes[];
/**
 * Create one generator from two generators by linking
 * each item of the first generator to the next item of
 * the second generator.
 *
 * Let's say generator G1 yields A, B, C and generator G2 yields X, Y, Z.
 * The resulting generator of `linkNext(G1, G2)` will yield A', B', C'
 * where `A' = A & {next: Y}`, `B' = B & {next: Z}` and `C' = C & {next: undefined}`
 * @param generator
 * @param nextGenerator
 */
declare function linkNext<T>(generator: Generator<T>, nextGenerator: Generator<T>): Generator<T & {
    next?: T;
}>;
declare function isBoolean(str: string): boolean;
declare function isMarkdownLink(str: string): boolean;
/**
 * Check if the string is a web link.
 * e.g. http://odoo.com
 */
declare function isWebLink(str: string): boolean;
/**
 * Build a markdown link from a label and an url
 */
declare function markdownLink(label: string, url: string): string;
declare function parseMarkdownLink(str: string): {
    url: string;
    label: string;
};
declare function isSheetUrl(url: string): boolean;
declare function buildSheetLink(sheetId: UID): string;
/**
 * Parse a sheet link and return the sheet id
 */
declare function parseSheetUrl(sheetLink: string): string;
/**
 * This helper function can be used as a type guard when filtering arrays.
 * const foo: number[] = [1, 2, undefined, 4].filter(isDefined)
 */
declare function isDefined<T>(argument: T | undefined): argument is T;
declare function isNotNull<T>(argument: T | null): argument is T;
/**
 * Check if all the values of an object, and all the values of the objects inside of it, are undefined.
 */
declare function isObjectEmptyRecursive<T extends object>(argument: T | undefined): boolean;
/**
 * Returns a function, that, as long as it continues to be invoked, will not
 * be triggered. The function will be called after it stops being called for
 * N milliseconds. If `immediate` is passed,  the function is called is called
 * immediately on the first call and the debouncing is triggered starting the second
 * call in the defined time window.
 *
 * Example:
 * debouncedFunction = debounce(() => console.log('Hello!'), 250);
 * debouncedFunction(); debouncedFunction(); // Will log 'Hello!' after 250ms
 *
 * debouncedFunction = debounce(() => console.log('Hello!'), 250, true);
 * debouncedFunction(); debouncedFunction(); // Will log 'Hello!' and relog it after 250ms
 *
 *
 * Also decorate the argument function with two methods: stopDebounce and isDebouncePending.
 *
 * Inspired by https://davidwalsh.name/javascript-debounce-function
 */
declare function debounce<T extends (...args: any) => void>(func: T, wait: number, immediate?: boolean): DebouncedFunction<T>;
/**
 * Creates a batched version of a callback so that all calls to it in the same
 * microtick will only call the original callback once.
 *
 * @param callback the callback to batch
 * @returns a batched version of the original callback
 *
 * Copied from odoo/owl repo.
 */
declare function batched(callback: () => void): () => void;
declare function concat(chars: string[]): string;
/**
 * Lazy value computed by the provided function.
 */
declare function lazy<T>(fn: (() => T) | T): Lazy<T>;
/**
 * Find the next defined value after the given index in an array of strings. If there is no defined value
 * after the index, return the closest defined value before the index. Return an empty string if no
 * defined value was found.
 *
 */
declare function findNextDefinedValue(arr: string[], index: number): string;
/** Get index of first header added by an ADD_COLUMNS_ROWS command */
declare function getAddHeaderStartIndex(position: "before" | "after", base: number): number;
/**
 * Compares n objects.
 */
declare function deepEquals(...o: any[]): boolean;
/**
 * Compares two arrays.
 * For performance reasons, this function is to be preferred
 * to 'deepEquals' in the case we know that the inputs are arrays.
 */
declare function deepEqualsArray(arr1: unknown[], arr2: unknown[]): boolean;
/**
 * Check if the given array contains all the values of the other array.
 * It makes the assumption that both array do not contain duplicates.
 */
declare function includesAll<T>(arr: T[], values: T[]): boolean;
/**
 * Return an object with all the keys in the object that have a falsy value removed.
 */
declare function removeFalsyAttributes<T extends Object | undefined | null>(obj: T): T;
declare const specialWhiteSpaceRegexp: RegExp;
declare const whiteSpaceCharacters: string[];
/**
 * Replace all different newlines characters by \n.
 */
declare function replaceNewLines(text: string | undefined): string;
/**
 * Determine if the numbers are consecutive.
 */
declare function isConsecutive(iterable: Iterable<number>): boolean;
/**
 * Creates a version of the function that's memoized on the value of its first argument, if any.
 */
declare function memoize<T extends any[], U>(func: (...args: T) => U): (...args: T) => U;
/**
 * Removes the specified indexes from the array.
 * Sparse (empty) elements are transformed to undefined (unless their index is explicitly removed).
 */
declare function removeIndexesFromArray<T>(array: readonly T[], indexes: number[]): T[];
declare function insertItemsAtIndex<T>(array: readonly T[], items: T[], index: number): T[];
declare function replaceItemAtIndex<T>(array: readonly T[], newItem: T, index: number): T[];
declare function trimContent(content: string): string;
declare function isNumberBetween(value: number, min: number, max: number): boolean;
/**
 * Get a Regex for the find & replace that matches the given search string and options.
 */
declare function getSearchRegex(searchStr: string, searchOptions: SearchOptions): RegExp;
/**
 * Alternative to Math.max that works with large arrays.
 * Typically useful for arrays bigger than 100k elements.
 */
declare function largeMax(array: number[]): number;
/**
 * Alternative to Math.min that works with large arrays.
 * Typically useful for arrays bigger than 100k elements.
 */
declare function largeMin(array: number[]): number;
declare class TokenizingChars {
    private text;
    private currentIndex;
    current: string;
    constructor(text: string);
    shift(): string;
    advanceBy(length: number): void;
    isOver(): boolean;
    remaining(): string;
    currentStartsWith(str: string): boolean;
}
/**
 * Remove duplicates from an array.
 *
 * @param array The array to remove duplicates from.
 * @param cb A callback to get an element value.
 */
declare function removeDuplicates<T>(array: T[], cb?: (a: T) => any): T[];
/**
 * Similar to transposing and array, but with POJOs instead of arrays. Useful, for example, when manipulating
 * a POJO grid[col][row] and you want to transpose it to grid[row][col].
 *
 * The resulting object is created such as result[key1][key2] = pojo[key2][key1]
 */
declare function transpose2dPOJO<T>(pojo: Record<string, Record<string, T>>): Record<string, Record<string, T>>;
declare function getUniqueText(text: string, texts: string[], options?: {
    compute?: (text: string, increment: number) => string;
    start?: number;
    computeFirstOne?: boolean;
}): string;
declare function isFormula(content: string): boolean;
declare function chartStyleToCellStyle(style: ChartStyle): Style;

/**
 * This function returns a regexp that is supposed to be as close as possible as the numberRegexp,
 * but its purpose is to be used by the tokenizer.
 *
 * - it tolerates extra characters at the end. This is useful because the tokenizer
 *   only needs to find the number at the start of a string
 * - it does not support % symbol, in formulas % is an operator
 */
declare const getFormulaNumberRegex: (decimalSeparator: string) => RegExp;
/**
 * Return true if the argument is a "number string".
 *
 * Note that "" (empty string) does not count as a number string
 */
declare function isNumber(value: string | undefined, locale: Locale): boolean;
/**
 * Convert a string into a number. It assumes that the string actually represents
 * a number (as determined by the isNumber function)
 *
 * Note that it accepts "" (empty string), even though it does not count as a
 * number from the point of view of the isNumber function.
 */
declare function parseNumber(str: string, locale: Locale): number;
declare function percentile(values: number[], percent: number, isInclusive: boolean): number;

declare const cellReference: RegExp;
declare const rangeReference: RegExp;
declare function isColReference(xc: string): boolean;
declare function isRowReference(xc: string): boolean;
declare function isColHeader(str: string): boolean;
declare function isRowHeader(str: string): boolean;
declare function isSingleCellReference(xc: string): boolean;
declare function splitReference(ref: string): {
    sheetName?: string;
    xc: string;
};
declare function getFullReference(sheetName: string | undefined, xc: string): string;
type FixedReferenceType = "col" | "row" | "colrow" | "none";
/**
 * Change the reference types inside the given token, if the token represent a range or a cell
 *
 * Eg. :
 *   A1 => $A$1 => A$1 => $A1 => A1
 *   A1:$B$1 => $A$1:B$1 => A$1:$B1 => $A1:B1 => A1:$B$1
 */
declare function loopThroughReferenceType(token: Readonly<Token>): Token;
/**
 * Returns the given XC with the given reference type.
 */
declare function setXcToFixedReferenceType(xc: string, referenceType: FixedReferenceType): string;

/**
 * Create an empty structure according to the type of the node key:
 * string: object
 * number: array
 */
declare function createEmptyStructure(node: string | number | any): {};

declare class UuidGenerator {
    private getCrypto;
    /**
     * Generates a custom UUID using a simple 36^12 method (8-character alphanumeric string with lowercase letters)
     * This has a higher chance of collision than a UUIDv4, but not only faster to generate than an UUIDV4,
     * it also has a smaller size, which is preferable to alleviate the overall data size.
     *
     * This method is preferable when generating uuids for the core data (sheetId, figureId, etc)
     * as they will appear several times in the revisions and local history.
     *
     */
    smallUuid(): string;
    /**
     * Generates an UUIDV4, has astronomically low chance of collision, but is larger in size than the smallUuid.
     * This method should be used when you need to avoid collisions at all costs, like the id of a revision.
     */
    uuidv4(): string;
}

/**
 * Model
 *
 * The Model class is the owner of the state of the Spreadsheet. However, it
 * has more a coordination role: it defers the actual state manipulation work to
 * plugins.
 *
 * At creation, the Model instantiates all necessary plugins. They each have
 * a private state (for example, the Selection plugin has the current selection).
 *
 * State changes are then performed through commands.  Commands are dispatched
 * to the model, which will then relay them to each plugins (and the history
 * handler). Then, the model will trigger an 'update' event to notify whoever
 * is concerned that the command was applied (if it was not cancelled).
 *
 * Also, the model has an unconventional responsibility: it actually renders the
 * visible viewport on a canvas. This is because each plugins actually manage a
 * specific concern about the content of the spreadsheet, and it is more natural
 * if they are able to read data from their internal state to represent it on the
 * screen.
 *
 * Note that the Model can be used in a standalone way to manipulate
 * programmatically a spreadsheet.
 */
declare class Model extends EventBus<any> implements CommandDispatcher {
    private corePlugins;
    private statefulUIPlugins;
    private range;
    private session;
    /**
     * In a collaborative context, some commands can be replayed, we have to ensure
     * that these commands are not replayed on the UI plugins.
     */
    private isReplayingCommand;
    /**
     * A plugin can draw some contents on the canvas. But even better: it can do
     * so multiple times.  The order of the render calls will determine a list of
     * "layers" (i.e., earlier calls will be obviously drawn below later calls).
     * This list simply keeps the renderers+layer information so the drawing code
     * can just iterate on it
     */
    private renderers;
    /**
     * Internal status of the model. Important for command handling coordination
     */
    private status;
    /**
     * The config object contains some configuration flag and callbacks
     */
    readonly config: ModelConfig;
    private corePluginConfig;
    private coreViewPluginConfig;
    private uiPluginConfig;
    private state;
    readonly selection: SelectionStreamProcessor;
    /**
     * Getters are the main way the rest of the UI read data from the model. Also,
     * it is shared between all plugins, so they can also communicate with each
     * other.
     */
    getters: Getters;
    /**
     * Getters that are accessible from the core plugins. It's a subset of `getters`,
     * without the UI getters
     */
    private coreGetters;
    uuidGenerator: UuidGenerator;
    private readonly handlers;
    private readonly uiHandlers;
    private readonly coreHandlers;
    constructor(data?: any, config?: Partial<ModelConfig>, stateUpdateMessages?: StateUpdateMessage[], uuidGenerator?: UuidGenerator, verboseImport?: boolean);
    joinSession(): void;
    leaveSession(): Promise<void>;
    private setupUiPlugin;
    private setupCoreViewPlugin;
    /**
     * Initialize and properly configure a plugin.
     *
     * This method is private for now, but if the need arise, there is no deep
     * reason why the model could not add dynamically a plugin while it is running.
     */
    private setupCorePlugin;
    private onRemoteRevisionReceived;
    private setupSession;
    private setupSessionEvents;
    private setupConfig;
    private setupExternalConfig;
    private setupCorePluginConfig;
    private setupCoreViewPluginConfig;
    private setupUiPluginConfig;
    /**
     * Check if the given command is allowed by all the plugins and the history.
     */
    private checkDispatchAllowed;
    private checkDispatchAllowedCoreCommand;
    private checkDispatchAllowedLocalCommand;
    private finalize;
    /**
     * Check if a command can be dispatched, and returns a DispatchResult object with the possible
     * reasons the dispatch failed.
     */
    canDispatch: CommandDispatcher["dispatch"];
    /**
     * The dispatch method is the only entry point to manipulate data in the model.
     * This is through this method that commands are dispatched most of the time
     * recursively until no plugin want to react anymore.
     *
     * CoreCommands dispatched from this function are saved in the history.
     *
     * Small technical detail: it is defined as an arrow function.  There are two
     * reasons for this:
     * 1. this means that the dispatch method can be "detached" from the model,
     *    which is done when it is put in the environment (see the Spreadsheet
     *    component)
     * 2. This allows us to define its type by using the interface CommandDispatcher
     */
    dispatch: CommandDispatcher["dispatch"];
    /**
     * Dispatch a command from a Core Plugin (or the History).
     * A command dispatched from this function is not added to the history.
     */
    private dispatchFromCorePlugin;
    /**
     * Dispatch the given command to the given handlers.
     * It will call `beforeHandle` and `handle`
     */
    private dispatchToHandlers;
    /**
     * When the Grid component is ready (= mounted), it has a reference to its
     * canvas and need to draw the grid on it.  This is then done by calling this
     * method, which will dispatch the call to all registered plugins.
     *
     * Note that nothing prevent multiple grid components from calling this method
     * each, or one grid component calling it multiple times with a different
     * context. This is probably the way we should do if we want to be able to
     * freeze a part of the grid (so, we would need to render different zones)
     */
    drawLayer(context: GridRenderingContext, layer: LayerName): void;
    /**
     * As the name of this method strongly implies, it is useful when we need to
     * export data out of the model.
     */
    exportData(): WorkbookData;
    updateMode(mode: Mode): void;
    /**
     * Exports the current model data into a list of serialized XML files
     * to be zipped together as an *.xlsx file.
     *
     * We need to trigger a cell revaluation  on every sheet and ensure that even
     * async functions are evaluated.
     * This prove to be necessary if the client did not trigger that evaluation in the first place
     * (e.g. open a document with several sheet and click on download before visiting each sheet)
     */
    exportXLSX(): Promise<XLSXExport>;
}

type ClipboardReadResult = {
    status: "ok";
    content: OSClipboardContent;
} | {
    status: "permissionDenied" | "notImplemented";
};
interface ClipboardInterface {
    write(clipboardContent: OSClipboardContent): Promise<void>;
    writeText(text: string): Promise<void>;
    read(): Promise<ClipboardReadResult>;
}

/**
 * An injectable store constructor
 */
interface StoreConstructor<T = any, A extends unknown[] = any[]> {
    new (get: Get, ...args: A): T;
}
/**
 * A function used to inject dependencies in a store constructor
 */
type Get = <T extends StoreConstructor>(Store: T) => T extends StoreConstructor<infer I> ? Store<I> : never;
type OmitFunctions<T> = {
    [K in keyof T as T[K] extends Function ? never : K]: T[K];
};
type Store<S> = S extends {
    mutators: readonly (keyof S)[];
} ? CQS<Pick<S, S["mutators"][number]> & OmitFunctions<S>> : CQS<OmitFunctions<S>>;
/**
 * Command Query Separation [1,2] implementation with types.
 *
 * Mapped type applying CQS principles to an object by forcing
 * - methods (commands) to never return anything, effectively making them write-only,
 * - all properties (queries) to be read-only [3]
 *
 * [1] https://martinfowler.com/bliki/CommandQuerySeparation.html
 * [2] https://en.wikipedia.org/wiki/Command%E2%80%93query_separation
 * [3] in an ideal world, they would be deeply read-only, but that's not possible natively in TypeScript
 */
type CQS<T> = {
    readonly [key in keyof T]: NeverReturns<T[key]>;
};
/**
 * Force any function to never return anything, effectively
 * making it write-only.
 */
type NeverReturns<T> = T extends (...args: any[]) => any ? (...args: Parameters<T>) => void : T;

interface NotificationStoreMethods {
    notifyUser: (notification: InformationNotification) => void;
    raiseError: (text: string, callback?: () => void) => void;
    askConfirmation: (content: string, confirm: () => void, cancel?: () => void) => void;
}

interface SpreadsheetChildEnv extends NotificationStoreMethods {
    model: Model;
    imageProvider?: ImageProviderInterface;
    isDashboard: () => boolean;
    openSidePanel: (panel: string, panelProps?: any) => void;
    replaceSidePanel: (panel: string, currentPanel: string, panelProps?: any) => void;
    toggleSidePanel: (panel: string, panelProps?: any) => void;
    clipboard: ClipboardInterface;
    startCellEdition: (content?: string) => void;
    loadCurrencies?: () => Promise<Currency[]>;
    loadLocales: () => Promise<Locale[]>;
    getStore: Get;
    isSmall: boolean;
    isMobile: () => boolean;
}

interface GridIcon {
    type: string;
    position: CellPosition;
    horizontalAlign: Exclude<Align, undefined>;
    size: number;
    margin: number;
    svg?: ImageSVG;
    hoverSvg?: ImageSVG;
    priority: number;
    onClick?: (position: CellPosition, env: SpreadsheetChildEnv) => void;
}

/**
 * Coordinate in pixels
 */
interface DOMCoordinates {
    x: Pixel;
    y: Pixel;
}
interface DOMDimension {
    width: Pixel;
    height: Pixel;
}
type Rect = DOMCoordinates & DOMDimension;
interface BoxTextContent {
    textLines: string[];
    width: Pixel;
    textHeight: Pixel;
    textWidth: Pixel;
    align: Align;
    fontSizePx: number;
    x: Pixel;
    y: Pixel;
}
type BorderDescrWithOpacity = BorderDescr & {
    opacity?: number;
};
type RenderingBorder = {
    top?: BorderDescrWithOpacity;
    right?: BorderDescrWithOpacity;
    bottom?: BorderDescrWithOpacity;
    left?: BorderDescrWithOpacity;
};
type RenderingGridIcon = GridIcon & {
    clipRect?: Rect;
    opacity?: number;
};
interface RenderingBox {
    id: string;
    content?: BoxTextContent;
    style: Style;
    chip?: {
        x: number;
        y: number;
        width: Pixel;
        height: Pixel;
        color: Color;
    };
    dataBarFill?: DataBarFill;
    border?: RenderingBorder;
    clipRect?: Rect;
    isError?: boolean;
    isMerge?: boolean;
    isOverflow?: boolean;
    overlayColor?: Color;
    icons: {
        left?: RenderingGridIcon;
        right?: RenderingGridIcon;
        center?: RenderingGridIcon;
    };
    textOpacity?: number;
    skipCellGridLines?: boolean;
    disabledAnimation?: boolean;
}
type Box = RenderingBox & Rect;
interface Image {
    clipIcon: Rect | null;
    size: Pixel;
    type: "icon";
    svg: ImageSVG;
}
/**
 * The viewport is the visible area of a sheet.
 * Column and row headers are not included in the viewport.
 */
type Viewport = Zone & Alias;
interface SheetDOMScrollInfo {
    /**
     * The scrollBar offset in the X coordinate
     */
    scrollX: Pixel;
    /**
     * The scrollBar offset in the Y coordinate
     */
    scrollY: Pixel;
}
interface GridRenderingContext {
    ctx: CanvasRenderingContext2D;
    dpr: number;
    thinLineWidth: number;
}
declare const LAYERS: {
    readonly Background: 0;
    readonly Highlights: 1;
    readonly Clipboard: 2;
    readonly Chart: 4;
    readonly Autofill: 5;
    readonly Selection: 6;
    readonly Headers: 100;
};
type LayerName = keyof typeof LAYERS;
declare const OrderedLayers: () => ("Background" | "Highlights" | "Clipboard" | "Chart" | "Autofill" | "Selection" | "Headers")[];
/**
 *
 * @param layer New layer name
 * @param priority The lower priorities are rendered first
 */
declare function addRenderingLayer(layer: string, priority: number): void;
interface EdgeScrollInfo {
    canEdgeScroll: boolean;
    direction: ScrollDirection;
    delay: number;
}
type ScrollDirection = 1 | 0 | -1 | "reset";

interface FigureInfo {
    id: UID;
    width: Pixel;
    height: Pixel;
    tag: string;
}
interface Figure extends FigureInfo, AnchorOffset {
}
interface FigureUI extends DOMCoordinates, Figure {
}
interface AnchorOffset {
    col: HeaderIndex;
    row: HeaderIndex;
    offset: PixelPosition;
}
interface FigureSize {
    width: Pixel;
    height: Pixel;
}
interface Carousel {
    readonly items: CarouselItem[];
    readonly title?: TitleDesign;
}
type CarouselItem = {
    type: "chart";
    chartId: UID;
    title?: string;
} | {
    type: "carouselDataView";
    title?: string;
};

type XLSXExportFile = XLSXExportImageFile | XLSXExportXMLFile;
interface XLSXExportXMLFile {
    path: string;
    content: string;
    contentType?: string;
}
interface XLSXExportImageFile {
    path: string;
    imageSrc: string;
}
interface XLSXExport {
    name: string;
    files: XLSXExportFile[];
}
/**
 * Standardized XLSX hexadecimal color (with or without alpha channel).
 * Note that the alpha channel goes first! AARRGGBB
 * e.g. "1E5010" or "331E5010"
 */
type XlsxHexColor = string & Alias;

declare const CALENDAR_CHART_GRANULARITIES: ("year" | "second_number" | "minute_number" | "hour_number" | "day_of_week" | "day_of_month" | "iso_week_number" | "month_number" | "quarter_number")[];
type CalendarChartGranularity = (typeof CALENDAR_CHART_GRANULARITIES)[number];
interface CalendarChartDefinition extends CommonChartDefinition {
    readonly type: "calendar";
    readonly horizontalGroupBy: CalendarChartGranularity;
    readonly verticalGroupBy: CalendarChartGranularity;
    readonly colorScale?: ChartColorScale;
    readonly missingValueColor?: Color;
}

interface ComboChartDefinition extends CommonChartDefinition {
    readonly dataSets: ComboChartDataSet[];
    readonly type: "combo";
    readonly hideDataMarkers?: boolean;
    readonly zoomable?: boolean;
}
type ComboChartDataSet = CustomizedDataSet & {
    type?: "bar" | "line";
};
type ComboChartRuntime = {
    chartJsConfig: ChartConfiguration;
    masterChartConfig?: ChartConfiguration;
    background: Color;
};

interface FunnelChartDefinition {
    readonly type: "funnel";
    readonly dataSets: CustomizedDataSet[];
    readonly dataSetsHaveTitle: boolean;
    readonly labelRange?: string;
    readonly title: TitleDesign;
    readonly background?: Color;
    readonly legendPosition: LegendPosition;
    readonly horizontal?: boolean;
    readonly axesDesign?: AxesDesign;
    readonly aggregated?: boolean;
    readonly showValues?: boolean;
    readonly funnelColors?: FunnelChartColors;
    readonly cumulative?: boolean;
    readonly humanize?: boolean;
}
type FunnelChartRuntime = {
    chartJsConfig: ChartConfiguration;
    background: Color;
};
type FunnelChartColors = (Color | undefined)[];

interface GaugeChartDefinition {
    readonly type: "gauge";
    readonly title: TitleDesign;
    readonly dataRange?: string;
    readonly sectionRule: SectionRule;
    readonly background?: Color;
    readonly humanize?: boolean;
}
interface SectionRule {
    readonly colors: ColorSet;
    readonly rangeMin: string;
    readonly rangeMax: string;
    readonly lowerInflectionPoint: SectionThreshold;
    readonly upperInflectionPoint: SectionThreshold;
}
interface ColorSet {
    readonly lowerColor: Color;
    readonly middleColor: Color;
    readonly upperColor: Color;
}
interface SectionThreshold {
    readonly type: "number" | "percentage";
    readonly value: string;
    readonly operator: "<" | "<=";
}
interface GaugeValue {
    value: number;
    label: string;
}
interface GaugeInflectionValue extends GaugeValue {
    operator: "<" | "<=";
}
interface GaugeChartRuntime {
    background: Color;
    title: TitleDesign;
    minValue: GaugeValue;
    maxValue: GaugeValue;
    gaugeValue?: GaugeValue;
    inflectionValues: GaugeInflectionValue[];
    colors: Color[];
}

interface LineChartDefinition extends CommonChartDefinition {
    readonly type: "line";
    readonly labelsAsText: boolean;
    readonly stacked: boolean;
    readonly aggregated?: boolean;
    readonly cumulative: boolean;
    readonly fillArea?: boolean;
    readonly hideDataMarkers?: boolean;
    readonly zoomable?: boolean;
}
type LineChartRuntime = {
    chartJsConfig: ChartConfiguration<"line">;
    masterChartConfig?: ChartConfiguration<"line">;
    background: Color;
};

interface PieChartDefinition extends CommonChartDefinition {
    readonly type: "pie";
    readonly aggregated?: boolean;
    readonly isDoughnut?: boolean;
    readonly showValues?: boolean;
    readonly pieHolePercentage?: number;
}
type PieChartRuntime = {
    chartJsConfig: ChartConfiguration<"pie" | "doughnut">;
    background: Color;
};

interface PyramidChartDefinition extends Omit<BarChartDefinition, "type" | "zoomable"> {
    readonly type: "pyramid";
}
type PyramidChartRuntime = {
    chartJsConfig: ChartConfiguration;
    background: Color;
};

interface RadarChartDefinition extends CommonChartDefinition {
    readonly type: "radar";
    readonly aggregated?: boolean;
    readonly stacked: boolean;
    readonly fillArea?: boolean;
    readonly hideDataMarkers?: boolean;
    readonly humanize?: boolean;
}
type RadarChartRuntime = {
    chartJsConfig: ChartConfiguration;
    background: Color;
};

interface ScatterChartDefinition extends Omit<LineChartDefinition, "type" | "stacked" | "cumulative"> {
    readonly type: "scatter";
}
type ScatterChartRuntime = LineChartRuntime;

interface ScorecardChartDefinition {
    readonly type: "scorecard";
    readonly title: TitleDesign;
    readonly keyValue?: string;
    readonly keyDescr?: TitleDesign;
    readonly baseline?: string;
    readonly baselineMode: BaselineMode;
    readonly baselineDescr?: TitleDesign;
    readonly background?: Color;
    readonly baselineColorUp: Color;
    readonly baselineColorDown: Color;
    readonly humanize?: boolean;
}
type BaselineMode = "text" | "difference" | "percentage" | "progress";
type BaselineArrowDirection = "neutral" | "up" | "down";
interface ProgressBar {
    readonly value: number;
    readonly color: Color;
}
interface ScorecardChartRuntime {
    readonly title: TitleDesign;
    readonly keyValue: string;
    readonly keyDescr: string;
    readonly baselineDisplay: string;
    readonly baselineColor?: string;
    readonly baselineArrow: BaselineArrowDirection;
    readonly baselineDescr?: string;
    readonly background: Color;
    readonly fontColor: Color;
    readonly keyValueStyle?: Style;
    readonly keyValueDescrStyle?: Style;
    readonly baselineStyle?: Style;
    readonly baselineDescrStyle?: Style;
    readonly progressBar?: ProgressBar;
}

interface SunburstChartDefinition {
    readonly type: "sunburst";
    readonly dataSets: CustomizedDataSet[];
    readonly dataSetsHaveTitle: boolean;
    readonly labelRange?: string;
    readonly title: TitleDesign;
    readonly background?: Color;
    readonly legendPosition: LegendPosition;
    readonly showValues?: boolean;
    readonly showLabels?: boolean;
    readonly valuesDesign?: ChartStyle;
    readonly groupColors?: (Color | undefined | null)[];
    readonly pieHolePercentage?: number;
    readonly humanize?: boolean;
}
type SunburstChartRuntime = {
    chartJsConfig: ChartConfiguration<"doughnut">;
    background: Color;
};

/*!
 * chartjs-chart-treemap v3.1.0
 * https://chartjs-chart-treemap.pages.dev/
 * (c) 2024 Jukka Kurkela
 * Released under the MIT license
 */

type AnyObject = Record<string, unknown>;
type TreemapScriptableContext = ScriptableContext<"treemap"> & {
    raw: TreemapDataPoint;
};
type TreemapControllerDatasetCaptionsOptions = {
    align?: Scriptable<LabelAlign, TreemapScriptableContext>;
    color?: Scriptable<Color$1, TreemapScriptableContext>;
    display?: boolean;
    formatter?: Scriptable<string, TreemapScriptableContext>;
    font?: FontSpec;
    hoverColor?: Scriptable<Color$1, TreemapScriptableContext>;
    hoverFont?: FontSpec;
    padding?: number;
};
type TreemapControllerDatasetLabelsOptions = {
    align?: Scriptable<LabelAlign, TreemapScriptableContext>;
    color?: Scriptable<Color$1 | Color$1[], TreemapScriptableContext>;
    display?: boolean;
    formatter?: Scriptable<string | Array<string>, TreemapScriptableContext>;
    font?: Scriptable<FontSpec | FontSpec[], TreemapScriptableContext>;
    hoverColor?: Scriptable<Color$1 | Color$1[], TreemapScriptableContext>;
    hoverFont?: Scriptable<FontSpec | FontSpec[], TreemapScriptableContext>;
    overflow?: Scriptable<LabelOverflow, TreemapScriptableContext>;
    padding?: number;
    position?: Scriptable<LabelPosition, TreemapScriptableContext>;
};
type LabelPosition = "top" | "middle" | "bottom";
type LabelAlign = "left" | "center" | "right";
type LabelOverflow = "cut" | "hidden" | "fit";
type TreemapControllerDatasetDividersOptions = {
    display?: boolean;
    lineCapStyle?: string;
    lineColor?: string;
    lineDash?: number[];
    lineDashOffset?: number;
    lineWidth?: number;
};
interface TreemapControllerDatasetOptions<DType> {
    spacing?: number;
    rtl?: boolean;
    backgroundColor?: Scriptable<Color$1, TreemapScriptableContext>;
    borderColor?: Scriptable<Color$1, TreemapScriptableContext>;
    borderWidth?: number;
    hoverBackgroundColor?: Scriptable<Color$1, TreemapScriptableContext>;
    hoverBorderColor?: Scriptable<Color$1, TreemapScriptableContext>;
    hoverBorderWidth?: number;
    captions?: TreemapControllerDatasetCaptionsOptions;
    dividers?: TreemapControllerDatasetDividersOptions;
    labels?: TreemapControllerDatasetLabelsOptions;
    label?: string;
    data: TreemapDataPoint[];
    groups?: Array<keyof DType>;
    sumKeys?: Array<keyof DType>;
    tree: number[] | DType[] | AnyObject;
    treeLeafKey?: keyof DType;
    key?: keyof DType;
    hidden?: boolean;
    displayMode?: "containerBoxes" | "headerBoxes";
    groupColors?: TreeMapGroupColor[];
}
interface TreemapDataPoint {
    x: number;
    y: number;
    w: number;
    h: number;
    /**
     * Value
     */
    v: number;
    /**
     * Sum
     */
    s: number;
    /**
     * Depth, only available if grouping
     */
    l?: number;
    /**
     * Group name, only available if grouping
     */
    g?: string;
    /**
     * Group Sum, only available if grouping
     */
    gs?: number;
    /**
     * additonal keys sums, only available if grouping
     */
    vs?: AnyObject;
    isLeaf?: boolean;
}
declare module "chart.js" {
    interface ChartTypeRegistry {
        treemap: {
            chartOptions: CoreChartOptions<"treemap">;
            datasetOptions: TreemapControllerDatasetOptions<Record<string, unknown>>;
            defaultDataPoint: TreemapDataPoint;
            metaExtensions: AnyObject;
            parsedDataType: unknown;
            scales: never;
        };
    }
}

interface TreeMapChartDefinition {
    readonly type: "treemap";
    readonly dataSets: CustomizedDataSet[];
    readonly dataSetsHaveTitle: boolean;
    readonly labelRange?: string;
    readonly title: TitleDesign;
    readonly background?: Color;
    readonly legendPosition: LegendPosition;
    readonly showHeaders?: boolean;
    readonly headerDesign?: TitleDesign;
    readonly showValues?: boolean;
    readonly showLabels?: boolean;
    readonly valuesDesign?: TitleDesign;
    readonly coloringOptions?: TreeMapColoringOptions;
    readonly humanize?: boolean;
}
type TreeMapCategoryColorOptions = {
    type: "categoryColor";
    colors: (Color | undefined | null)[];
    useValueBasedGradient: boolean;
};
type TreeMapColorScaleOptions = {
    type: "colorScale";
    minColor: Color;
    midColor?: Color;
    maxColor: Color;
};
interface TreeMapGroupColor {
    label: string;
    color: Color;
}
type TreeMapColoringOptions = TreeMapCategoryColorOptions | TreeMapColorScaleOptions;
type TreeMapChartRuntime = {
    chartJsConfig: ChartConfiguration;
    background: Color;
};

interface WaterfallChartDefinition extends CommonChartDefinition {
    readonly type: "waterfall";
    readonly verticalAxisPosition: VerticalAxisPosition;
    readonly aggregated?: boolean;
    readonly showSubTotals: boolean;
    readonly showConnectorLines: boolean;
    readonly firstValueAsSubtotal?: boolean;
    readonly positiveValuesColor?: Color;
    readonly negativeValuesColor?: Color;
    readonly subTotalValuesColor?: Color;
    readonly zoomable?: boolean;
}
type WaterfallChartRuntime = {
    chartJsConfig: ChartConfiguration;
    background: Color;
};

declare const CHART_TYPES: readonly ["line", "bar", "pie", "scorecard", "gauge", "scatter", "combo", "waterfall", "pyramid", "radar", "geo", "funnel", "sunburst", "treemap", "calendar"];
type ChartType = (typeof CHART_TYPES)[number];
type ChartDefinition = LineChartDefinition | PieChartDefinition | BarChartDefinition | ScorecardChartDefinition | GaugeChartDefinition | ScatterChartDefinition | ComboChartDefinition | WaterfallChartDefinition | PyramidChartDefinition | RadarChartDefinition | GeoChartDefinition | FunnelChartDefinition | SunburstChartDefinition | TreeMapChartDefinition | CalendarChartDefinition;
type ChartJSRuntime = LineChartRuntime | PieChartRuntime | BarChartRuntime | ComboChartRuntime | ScatterChartRuntime | WaterfallChartRuntime | PyramidChartRuntime | RadarChartRuntime | GeoChartRuntime | FunnelChartRuntime | SunburstChartRuntime | TreeMapChartRuntime;
type ChartRuntime = ChartJSRuntime | ScorecardChartRuntime | GaugeChartRuntime;
interface DatasetDesign {
    readonly backgroundColor?: string;
    readonly yAxisId?: string;
    readonly label?: string;
}
interface AxisDesign {
    readonly title?: TitleDesign;
}
interface AxesDesign {
    readonly x?: AxisDesign;
    readonly y?: AxisDesign;
    readonly y1?: AxisDesign;
}
interface ChartStyle {
    readonly bold?: boolean;
    readonly italic?: boolean;
    readonly align?: Align;
    readonly verticalAlign?: VerticalAlign;
    readonly color?: Color;
    readonly fontSize?: number;
    readonly fillColor?: Color;
}
interface TitleDesign extends ChartStyle {
    readonly text?: string;
}
type TrendType = "polynomial" | "exponential" | "logarithmic" | "trailingMovingAverage";
interface TrendConfiguration {
    type?: TrendType;
    order?: number;
    color?: Color;
    display?: boolean;
    window?: number;
}
type CustomizedDataSet = {
    readonly dataRange: string;
    readonly trend?: TrendConfiguration;
} & DatasetDesign;
interface DataSet {
    readonly labelCell?: Range;
    readonly dataRange: Range;
    readonly rightYAxis?: boolean;
    readonly backgroundColor?: Color;
    readonly customLabel?: string;
    readonly trend?: TrendConfiguration;
}
interface ExcelChartDataset {
    readonly label?: {
        text?: string;
    } | {
        reference?: string;
    };
    readonly range: string;
    readonly backgroundColor?: Color;
    readonly rightYAxis?: boolean;
    readonly trend?: ExcelChartTrendConfiguration;
}
interface ExcelChartTrendConfiguration {
    readonly type?: ExcelTrendlineType;
    readonly order?: number;
    readonly color?: Color;
    readonly window?: number;
}
type ExcelTrendlineType = "poly" | "exp" | "log" | "movingAvg" | "linear";
type ExcelChartType = "line" | "bar" | "pie" | "combo" | "scatter" | "radar" | "pyramid";
interface ExcelChartDefinition {
    readonly title?: TitleDesign;
    readonly type: ExcelChartType;
    readonly dataSets: ExcelChartDataset[];
    readonly labelRange?: string;
    readonly backgroundColor: XlsxHexColor;
    readonly fontColor: XlsxHexColor;
    readonly legendPosition: LegendPosition;
    readonly stacked?: boolean;
    readonly cumulative?: boolean;
    readonly verticalAxis?: {
        useLeftAxis?: boolean;
        useRightAxis?: boolean;
    };
    readonly axesDesign?: AxesDesign;
    readonly horizontal?: boolean;
    readonly isDoughnut?: boolean;
    readonly pieHolePercentage?: number;
    readonly maxValue?: number;
}
interface ChartCreationContext {
    readonly range?: CustomizedDataSet[];
    readonly hierarchicalRanges?: CustomizedDataSet[];
    readonly title?: TitleDesign;
    readonly background?: Color;
    readonly auxiliaryRange?: string;
    readonly aggregated?: boolean;
    readonly stacked?: boolean;
    readonly cumulative?: boolean;
    readonly dataSetsHaveTitle?: boolean;
    readonly labelsAsText?: boolean;
    readonly showSubTotals?: boolean;
    readonly showConnectorLines?: boolean;
    readonly firstValueAsSubtotal?: boolean;
    readonly legendPosition?: LegendPosition;
    readonly axesDesign?: AxesDesign;
    readonly fillArea?: boolean;
    readonly showValues?: boolean;
    readonly funnelColors?: FunnelChartColors;
    readonly showLabels?: boolean;
    readonly hideDataMarkers?: boolean;
    readonly valuesDesign?: ChartStyle;
    readonly groupColors?: (Color | undefined | null)[];
    readonly horizontal?: boolean;
    readonly isDoughnut?: boolean;
    readonly pieHolePercentage?: number;
    readonly showHeaders?: boolean;
    readonly headerDesign?: TitleDesign;
    readonly treemapColoringOptions?: TreeMapColoringOptions;
    readonly zoomable?: boolean;
    readonly humanize?: boolean;
}
interface ChartColorScale {
    minColor: Color;
    midColor?: Color;
    maxColor: Color;
}

/**
 * There are two kinds of commands: CoreCommands and LocalCommands
 *
 * - CoreCommands are commands that
 *   1. manipulate the imported/exported spreadsheet state
 *   2. are shared in collaborative environment
 *
 * - LocalCommands: every other command
 *   1. manipulate the local state
 *   2. can be converted into CoreCommands
 *   3. are not shared in collaborative environment
 *
 * For example, "RESIZE_COLUMNS_ROWS" is a CoreCommand. "AUTORESIZE_COLUMNS"
 * can be (locally) converted into a "RESIZE_COLUMNS_ROWS", and therefore, is not a
 * CoreCommand.
 *
 * CoreCommands should be "device agnostic". This means that they should
 * contain all the information necessary to perform their job. Local commands
 * can use inferred information from the local internal state, such as the
 * active sheet.
 */
interface SheetDependentCommand {
    sheetId: UID;
}
interface HeadersDependentCommand {
    sheetId: UID;
    dimension: Dimension;
    elements: HeaderIndex[];
}
interface SheetEditingCommand {
    sheetName: string;
}
interface TargetDependentCommand {
    sheetId: UID;
    target: Zone[];
}
interface RangesDependentCommand {
    ranges: RangeData[];
}
interface PositionDependentCommand {
    sheetId: UID;
    col: number;
    row: number;
}
interface ZoneDependentCommand {
    sheetId: UID;
    zone: Zone;
}
interface UpdateCellCommand extends PositionDependentCommand {
    type: "UPDATE_CELL";
    content?: string;
    style?: Style | null;
    format?: Format;
}
/**
 * Move a cell to a given position or clear the position.
 */
interface UpdateCellPositionCommand extends PositionDependentCommand {
    type: "UPDATE_CELL_POSITION";
    cellId?: UID;
}
interface AddColumnsRowsCommand extends SheetDependentCommand, SheetEditingCommand {
    type: "ADD_COLUMNS_ROWS";
    dimension: Dimension;
    base: HeaderIndex;
    quantity: number;
    position: "before" | "after";
}
interface RemoveColumnsRowsCommand extends HeadersDependentCommand, SheetEditingCommand {
    type: "REMOVE_COLUMNS_ROWS";
    elements: HeaderIndex[];
}
interface MoveColumnsRowsCommand extends HeadersDependentCommand, SheetEditingCommand {
    type: "MOVE_COLUMNS_ROWS";
    base: HeaderIndex;
    elements: HeaderIndex[];
    position: "before" | "after";
}
interface ResizeColumnsRowsCommand extends HeadersDependentCommand {
    type: "RESIZE_COLUMNS_ROWS";
    elements: number[];
    size: number | null;
}
interface HideColumnsRowsCommand extends HeadersDependentCommand {
    type: "HIDE_COLUMNS_ROWS";
    elements: HeaderIndex[];
}
interface UnhideColumnsRowsCommand extends HeadersDependentCommand {
    type: "UNHIDE_COLUMNS_ROWS";
    elements: HeaderIndex[];
}
/**
 * Freeze a given number of columns on top of the sheet
 */
interface FreezeColumnsCommand extends SheetDependentCommand {
    type: "FREEZE_COLUMNS";
    /** number of columns frozen */
    quantity: number;
}
/**
 * Freeze a given number of rows on top of the sheet
 */
interface FreezeRowsCommand extends SheetDependentCommand {
    type: "FREEZE_ROWS";
    /** number of frozen rows */
    quantity: number;
}
interface UnfreezeColumnsRowsCommand {
    type: "UNFREEZE_COLUMNS_ROWS";
    sheetId: UID;
}
interface UnfreezeColumnsCommand {
    type: "UNFREEZE_COLUMNS";
    sheetId: UID;
}
interface UnfreezeRowsCommand {
    type: "UNFREEZE_ROWS";
    sheetId: UID;
}
interface SetGridLinesVisibilityCommand extends SheetDependentCommand {
    type: "SET_GRID_LINES_VISIBILITY";
    areGridLinesVisible: boolean;
}
interface AddMergeCommand extends TargetDependentCommand {
    type: "ADD_MERGE";
    force?: boolean;
}
interface RemoveMergeCommand extends TargetDependentCommand {
    type: "REMOVE_MERGE";
}
interface CreateSheetCommand extends SheetDependentCommand {
    type: "CREATE_SHEET";
    position: number;
    name: string;
    cols?: number;
    rows?: number;
}
interface DeleteSheetCommand extends SheetDependentCommand, SheetEditingCommand {
    type: "DELETE_SHEET";
}
interface DuplicateSheetCommand extends SheetDependentCommand {
    type: "DUPLICATE_SHEET";
    sheetIdTo: UID;
    sheetNameTo: string;
}
interface MoveSheetCommand extends SheetDependentCommand {
    type: "MOVE_SHEET";
    delta: number;
}
interface RenameSheetCommand extends SheetDependentCommand {
    type: "RENAME_SHEET";
    newName: string;
    oldName: string;
}
interface ColorSheetCommand extends SheetDependentCommand {
    type: "COLOR_SHEET";
    color?: Color;
}
interface HideSheetCommand extends SheetDependentCommand {
    type: "HIDE_SHEET";
}
interface ShowSheetCommand extends SheetDependentCommand {
    type: "SHOW_SHEET";
}
/**
 * Command created in order to apply a translational movement for all references
 * to cells/ranges within a specific zone.
 * Command particularly useful during CUT / PATE.
 */
interface MoveRangeCommand extends PositionDependentCommand, TargetDependentCommand, SheetEditingCommand {
    type: "MOVE_RANGES";
    targetSheetId: string;
}
/**
 * todo: use id instead of a list. this is not safe to serialize and send to
 * another user
 */
interface AddConditionalFormatCommand extends SheetDependentCommand, RangesDependentCommand {
    type: "ADD_CONDITIONAL_FORMAT";
    cf: Omit<ConditionalFormat, "ranges">;
}
interface RemoveConditionalFormatCommand extends SheetDependentCommand {
    type: "REMOVE_CONDITIONAL_FORMAT";
    id: string;
}
interface MoveConditionalFormatCommand extends SheetDependentCommand {
    type: "CHANGE_CONDITIONAL_FORMAT_PRIORITY";
    cfId: UID;
    delta: number;
}
interface CreateFigureCommand extends BaseFigureCommand {
    type: "CREATE_FIGURE";
    tag: string;
}
interface UpdateFigureCommand extends Omit<Partial<Figure>, "id" | "col" | "row">, SheetDependentCommand, PositionDependentCommand {
    type: "UPDATE_FIGURE";
    figureId: UID;
}
interface DeleteFigureCommand extends SheetDependentCommand {
    type: "DELETE_FIGURE";
    figureId: UID;
}
interface BaseFigureCommand extends PositionDependentCommand {
    figureId: UID;
    offset: PixelPosition;
    size: FigureSize;
}
interface CreateChartCommand {
    type: "CREATE_CHART";
    chartId: UID;
    definition: ChartDefinition;
    sheetId: UID;
    figureId: UID;
    offset?: PixelPosition;
    size?: FigureSize;
    col?: number;
    row?: number;
}
interface UpdateChartCommand extends SheetDependentCommand {
    type: "UPDATE_CHART";
    figureId: UID;
    chartId: UID;
    definition: ChartDefinition;
}
interface DeleteChartCommand extends SheetDependentCommand {
    type: "DELETE_CHART";
    chartId: UID;
}
interface CreateCarouselCommand extends BaseFigureCommand {
    type: "CREATE_CAROUSEL";
    definition: Carousel;
}
interface UpdateCarouselCommand extends SheetDependentCommand {
    type: "UPDATE_CAROUSEL";
    figureId: UID;
    definition: Carousel;
}
interface AddNewChartToCarouselCommand extends SheetDependentCommand {
    type: "ADD_NEW_CHART_TO_CAROUSEL";
    figureId: UID;
}
interface AddFigureChartToCarouselCommand extends SheetDependentCommand {
    type: "ADD_FIGURE_CHART_TO_CAROUSEL";
    carouselFigureId: UID;
    chartFigureId: UID;
}
interface DuplicateCarouselChartCommand extends SheetDependentCommand {
    type: "DUPLICATE_CAROUSEL_CHART";
    carouselId: UID;
    chartId: UID;
    duplicatedChartId: UID;
}
interface UpdateCarouselActiveItemCommand extends SheetDependentCommand {
    type: "UPDATE_CAROUSEL_ACTIVE_ITEM";
    figureId: UID;
    item: CarouselItem;
}
interface PopOutChartFromCarouselCommand extends SheetDependentCommand {
    type: "POPOUT_CHART_FROM_CAROUSEL";
    carouselId: UID;
    chartId: UID;
}
interface CreateImageOverCommand extends BaseFigureCommand {
    type: "CREATE_IMAGE";
    definition: Image$1;
}
interface CreateTableCommand extends RangesDependentCommand {
    type: "CREATE_TABLE";
    sheetId: UID;
    config: TableConfig;
    tableType: CoreTableType;
}
interface RemoveTableCommand extends TargetDependentCommand {
    type: "REMOVE_TABLE";
}
interface UpdateTableCommand {
    type: "UPDATE_TABLE";
    zone: Zone;
    sheetId: UID;
    newTableRange?: RangeData;
    tableType?: CoreTableType;
    config?: Partial<TableConfig>;
}
interface ResizeTableCommand {
    type: "RESIZE_TABLE";
    zone: Zone;
    sheetId: UID;
    newTableRange: RangeData;
    tableType?: CoreTableType;
}
interface AutofillTableCommand extends PositionDependentCommand {
    type: "AUTOFILL_TABLE_COLUMN";
    /** The row to start the autofill in. If undefined, it will autofill from the top of the table column */
    autofillRowStart?: number;
    /** The row to end the autofill in. If undefined, it will autofill to the bottom of the table column */
    autofillRowEnd?: number;
}
interface CreateTableStyleCommand {
    type: "CREATE_TABLE_STYLE";
    tableStyleId: string;
    tableStyleName: string;
    templateName: TableStyleTemplateName;
    primaryColor: Color;
}
interface RemoveTableStyleCommand {
    type: "REMOVE_TABLE_STYLE";
    tableStyleId: string;
}
interface UpdateFilterCommand extends PositionDependentCommand {
    type: "UPDATE_FILTER";
    value: DataFilterValue;
}
interface SetFormattingCommand extends TargetDependentCommand {
    type: "SET_FORMATTING";
    style?: Style;
    format?: Format;
}
interface SetZoneBordersCommand extends TargetDependentCommand {
    type: "SET_ZONE_BORDERS";
    border: BorderData;
}
interface SetBorderCommand extends PositionDependentCommand {
    type: "SET_BORDER";
    border: Border | undefined;
}
interface SetBorderTargetCommand extends TargetDependentCommand {
    type: "SET_BORDERS_ON_TARGET";
    border: Border | undefined;
}
interface ClearFormattingCommand extends TargetDependentCommand {
    type: "CLEAR_FORMATTING";
}
interface SetDecimalCommand extends TargetDependentCommand {
    type: "SET_DECIMAL";
    step: SetDecimalStep;
}
interface SetContextualFormatCommand extends TargetDependentCommand {
    type: "SET_FORMATTING_WITH_PIVOT";
    format: Format;
}
interface UpdateLocaleCommand {
    type: "UPDATE_LOCALE";
    locale: Locale;
}
interface AddPivotCommand {
    type: "ADD_PIVOT";
    pivotId: UID;
    pivot: PivotCoreDefinition;
}
interface UpdatePivotCommand {
    type: "UPDATE_PIVOT";
    pivotId: UID;
    pivot: PivotCoreDefinition;
}
interface InsertPivotCommand extends PositionDependentCommand {
    type: "INSERT_PIVOT";
    pivotId: UID;
    table: PivotTableData;
}
interface RenamePivotCommand {
    type: "RENAME_PIVOT";
    pivotId: UID;
    name: string;
}
interface RemovePivotCommand {
    type: "REMOVE_PIVOT";
    pivotId: UID;
}
interface DuplicatePivotCommand {
    type: "DUPLICATE_PIVOT";
    pivotId: UID;
    newPivotId: string;
    duplicatedPivotName?: string;
}
interface RemoveDuplicatesCommand {
    type: "REMOVE_DUPLICATES";
    columns: HeaderIndex[];
    hasHeader: boolean;
}
interface TrimWhitespaceCommand {
    type: "TRIM_WHITESPACE";
}
interface GroupHeadersCommand extends SheetDependentCommand {
    type: "GROUP_HEADERS";
    dimension: Dimension;
    start: HeaderIndex;
    end: HeaderIndex;
}
interface UnGroupHeadersCommand extends SheetDependentCommand {
    type: "UNGROUP_HEADERS";
    dimension: Dimension;
    start: HeaderIndex;
    end: HeaderIndex;
}
interface FoldHeaderGroupCommand extends SheetDependentCommand {
    type: "FOLD_HEADER_GROUP";
    dimension: Dimension;
    start: HeaderIndex;
    end: HeaderIndex;
}
interface UnfoldHeaderGroupCommand extends SheetDependentCommand {
    type: "UNFOLD_HEADER_GROUP";
    dimension: Dimension;
    start: HeaderIndex;
    end: HeaderIndex;
}
interface FoldAllHeaderGroupsCommand extends SheetDependentCommand {
    type: "FOLD_ALL_HEADER_GROUPS";
    dimension: Dimension;
}
interface UnfoldAllHeaderGroupsCommand extends SheetDependentCommand {
    type: "UNFOLD_ALL_HEADER_GROUPS";
    dimension: Dimension;
}
interface UnfoldHeaderGroupsInZoneCommand extends ZoneDependentCommand {
    type: "UNFOLD_HEADER_GROUPS_IN_ZONE";
    dimension: Dimension;
}
interface FoldHeaderGroupsInZoneCommand extends ZoneDependentCommand {
    type: "FOLD_HEADER_GROUPS_IN_ZONE";
    dimension: Dimension;
}
interface AddDataValidationCommand extends SheetDependentCommand, RangesDependentCommand {
    type: "ADD_DATA_VALIDATION_RULE";
    rule: Omit<DataValidationRule, "ranges">;
}
interface RemoveDataValidationCommand extends SheetDependentCommand {
    type: "REMOVE_DATA_VALIDATION_RULE";
    id: string;
}
interface CopyCommand {
    type: "COPY";
}
interface CutCommand {
    type: "CUT";
}
interface PasteCommand {
    type: "PASTE";
    target: Zone[];
    pasteOption?: ClipboardPasteOptions;
}
interface CopyPasteCellsAboveCommand {
    type: "COPY_PASTE_CELLS_ABOVE";
}
interface CopyPasteCellsOnLeftCommand {
    type: "COPY_PASTE_CELLS_ON_LEFT";
}
interface RepeatPasteCommand {
    type: "REPEAT_PASTE";
    target: Zone[];
    pasteOption?: ClipboardPasteOptions;
}
interface CleanClipBoardHighlightCommand {
    type: "CLEAN_CLIPBOARD_HIGHLIGHT";
}
interface AutoFillCellCommand {
    type: "AUTOFILL_CELL";
    originCol: number;
    originRow: number;
    col: HeaderIndex;
    row: HeaderIndex;
    content?: string;
    style?: Style | null;
    border?: Border;
    format?: Format;
}
interface PasteFromOSClipboardCommand {
    type: "PASTE_FROM_OS_CLIPBOARD";
    target: Zone[];
    clipboardContent: ParsedOsClipboardContentWithImageData;
    pasteOption?: ClipboardPasteOptions;
}
interface AutoresizeColumnsCommand {
    type: "AUTORESIZE_COLUMNS";
    sheetId: UID;
    cols: HeaderIndex[];
}
interface AutoresizeRowsCommand {
    type: "AUTORESIZE_ROWS";
    sheetId: UID;
    rows: HeaderIndex[];
}
interface ActivateSheetCommand {
    type: "ACTIVATE_SHEET";
    sheetIdFrom: UID;
    sheetIdTo: UID;
}
interface EvaluateCellsCommand {
    type: "EVALUATE_CELLS";
    cellIds?: UID[];
}
interface EvaluateChartsCommand {
    type: "EVALUATE_CHARTS";
}
interface StartChangeHighlightCommand {
    type: "START_CHANGE_HIGHLIGHT";
    zone: Zone;
}
interface ShowFormulaCommand {
    type: "SET_FORMULA_VISIBILITY";
    show: boolean;
}
interface DeleteContentCommand {
    type: "DELETE_CONTENT";
    sheetId: UID;
    target: Zone[];
}
interface ClearCellCommand extends PositionDependentCommand {
    type: "CLEAR_CELL";
}
interface ClearCellsCommand extends TargetDependentCommand {
    type: "CLEAR_CELLS";
}
interface UndoCommand {
    type: "UNDO";
    commands: readonly CoreCommand[];
}
interface RedoCommand {
    type: "REDO";
    commands: readonly CoreCommand[];
}
interface RequestUndoCommand {
    type: "REQUEST_UNDO";
}
interface RequestRedoCommand {
    type: "REQUEST_REDO";
}
interface StartCommand {
    type: "START";
}
interface AutofillCommand {
    type: "AUTOFILL";
}
interface AutofillSelectCommand {
    type: "AUTOFILL_SELECT";
    col: HeaderIndex;
    row: HeaderIndex;
}
interface AutofillAutoCommand {
    type: "AUTOFILL_AUTO";
}
interface SelectFigureCommand {
    type: "SELECT_FIGURE";
    figureId: UID | null;
}
interface ReplaceSearchCommand {
    type: "REPLACE_SEARCH";
    searchString: string;
    replaceWith: string;
    searchOptions: SearchOptions;
    matches: CellPosition[];
}
interface SortCommand {
    type: "SORT_CELLS";
    sheetId: UID;
    col: number;
    row: number;
    zone: Zone;
    sortDirection: SortDirection;
    sortOptions?: SortOptions;
}
interface ResizeViewportCommand {
    type: "RESIZE_SHEETVIEW";
    width: Pixel;
    height: Pixel;
    gridOffsetX?: Pixel;
    gridOffsetY?: Pixel;
}
interface SetViewportOffsetCommand {
    type: "SET_VIEWPORT_OFFSET";
    offsetX: Pixel;
    offsetY: Pixel;
}
interface SetZoomCommand {
    type: "SET_ZOOM";
    zoom: number;
}
/**
 * Shift the viewport down by the viewport height
 */
interface MoveViewportDownCommand {
    type: "SHIFT_VIEWPORT_DOWN";
}
/**
 * Shift the viewport up by the viewport height
 */
interface MoveViewportUpCommand {
    type: "SHIFT_VIEWPORT_UP";
}
interface MoveViewportToCellCommand {
    type: "SCROLL_TO_CELL";
    col: HeaderIndex;
    row: HeaderIndex;
}
/**
 * Sum data according to the selected zone(s) in the appropriated
 * cells.
 */
interface SumSelectionCommand {
    type: "SUM_SELECTION";
}
interface DeleteCellCommand {
    type: "DELETE_CELL";
    shiftDimension: Dimension;
    zone: Zone;
}
interface InsertCellCommand {
    type: "INSERT_CELL";
    shiftDimension: Dimension;
    zone: Zone;
}
interface ActivateNextSheetCommand {
    type: "ACTIVATE_NEXT_SHEET";
}
interface ActivatePreviousSheetCommand {
    type: "ACTIVATE_PREVIOUS_SHEET";
}
interface SplitTextIntoColumnsCommand {
    type: "SPLIT_TEXT_INTO_COLUMNS";
    separator: string;
    addNewColumns: boolean;
    force?: boolean;
}
interface RefreshPivotCommand {
    type: "REFRESH_PIVOT";
    id: UID;
}
interface InsertNewPivotCommand {
    type: "INSERT_NEW_PIVOT";
    pivotId: UID;
    newSheetId: UID;
}
interface DuplicatePivotInNewSheetCommand {
    type: "DUPLICATE_PIVOT_IN_NEW_SHEET";
    pivotId: UID;
    newPivotId: UID;
    newSheetId: UID;
}
interface InsertPivotWithTableCommand extends PositionDependentCommand {
    type: "INSERT_PIVOT_WITH_TABLE";
    pivotId: UID;
    table: PivotTableData;
    pivotMode: "static" | "dynamic";
}
interface SplitPivotFormulaCommand extends PositionDependentCommand {
    type: "SPLIT_PIVOT_FORMULA";
    pivotId: UID;
}
interface PaintFormat extends TargetDependentCommand {
    type: "PAINT_FORMAT";
}
interface DeleteUnfilteredContentCommand extends TargetDependentCommand {
    type: "DELETE_UNFILTERED_CONTENT";
}
interface PivotStartPresenceTracking {
    type: "PIVOT_START_PRESENCE_TRACKING";
    pivotId: UID;
}
interface PivotStopPresenceTracking {
    type: "PIVOT_STOP_PRESENCE_TRACKING";
}
interface ToggleCheckboxCommand extends TargetDependentCommand {
    type: "TOGGLE_CHECKBOX";
}
type CoreCommand = 
/** CELLS */
UpdateCellCommand | UpdateCellPositionCommand | ClearCellCommand | ClearCellsCommand | DeleteContentCommand
/** GRID SHAPE */
 | AddColumnsRowsCommand | RemoveColumnsRowsCommand | ResizeColumnsRowsCommand | HideColumnsRowsCommand | UnhideColumnsRowsCommand | SetGridLinesVisibilityCommand | FreezeColumnsCommand | FreezeRowsCommand | UnfreezeColumnsRowsCommand | UnfreezeColumnsCommand | UnfreezeRowsCommand
/** MERGE */
 | AddMergeCommand | RemoveMergeCommand
/** SHEETS MANIPULATION */
 | CreateSheetCommand | DeleteSheetCommand | DuplicateSheetCommand | MoveSheetCommand | RenameSheetCommand | ColorSheetCommand | HideSheetCommand | ShowSheetCommand
/** RANGES MANIPULATION */
 | MoveRangeCommand
/** CONDITIONAL FORMAT */
 | AddConditionalFormatCommand | RemoveConditionalFormatCommand | MoveConditionalFormatCommand
/** FIGURES */
 | CreateFigureCommand | DeleteFigureCommand | UpdateFigureCommand | CreateCarouselCommand | UpdateCarouselCommand
/** FORMATTING */
 | SetFormattingCommand | ClearFormattingCommand | SetZoneBordersCommand | SetBorderCommand | SetBorderTargetCommand
/** CHART */
 | CreateChartCommand | UpdateChartCommand | DeleteChartCommand
/** IMAGE */
 | CreateImageOverCommand
/** FILTERS */
 | CreateTableCommand | RemoveTableCommand | UpdateTableCommand | CreateTableStyleCommand | RemoveTableStyleCommand
/** HEADER GROUP */
 | GroupHeadersCommand | UnGroupHeadersCommand | UnfoldHeaderGroupCommand | FoldHeaderGroupCommand | FoldAllHeaderGroupsCommand | UnfoldAllHeaderGroupsCommand | UnfoldHeaderGroupsInZoneCommand | FoldHeaderGroupsInZoneCommand
/** DATA VALIDATION */
 | AddDataValidationCommand | RemoveDataValidationCommand
/** MISC */
 | UpdateLocaleCommand
/** PIVOT */
 | AddPivotCommand | UpdatePivotCommand | InsertPivotCommand | RenamePivotCommand | RemovePivotCommand | DuplicatePivotCommand;
type LocalCommand = RequestUndoCommand | RequestRedoCommand | UndoCommand | RedoCommand | CopyCommand | CutCommand | PasteCommand | CopyPasteCellsAboveCommand | CopyPasteCellsOnLeftCommand | RepeatPasteCommand | CleanClipBoardHighlightCommand | AutoFillCellCommand | PasteFromOSClipboardCommand | AutoresizeColumnsCommand | AutoresizeRowsCommand | MoveColumnsRowsCommand | ActivateSheetCommand | EvaluateCellsCommand | EvaluateChartsCommand | StartChangeHighlightCommand | StartCommand | AutofillCommand | AutofillSelectCommand | AutofillTableCommand | ShowFormulaCommand | AutofillAutoCommand | SelectFigureCommand | ReplaceSearchCommand | SortCommand | SetDecimalCommand | SetContextualFormatCommand | ResizeViewportCommand | SetZoomCommand | SumSelectionCommand | DeleteCellCommand | InsertCellCommand | SetViewportOffsetCommand | MoveViewportDownCommand | MoveViewportUpCommand | MoveViewportToCellCommand | ActivateNextSheetCommand | ActivatePreviousSheetCommand | UpdateFilterCommand | SplitTextIntoColumnsCommand | RemoveDuplicatesCommand | TrimWhitespaceCommand | ResizeTableCommand | RefreshPivotCommand | InsertNewPivotCommand | DuplicatePivotInNewSheetCommand | InsertPivotWithTableCommand | SplitPivotFormulaCommand | PaintFormat | DeleteUnfilteredContentCommand | PivotStartPresenceTracking | PivotStopPresenceTracking | ToggleCheckboxCommand | AddNewChartToCarouselCommand | AddFigureChartToCarouselCommand | DuplicateCarouselChartCommand | UpdateCarouselActiveItemCommand | PopOutChartFromCarouselCommand;
type Command = CoreCommand | LocalCommand;
/**
 * Holds the result of a command dispatch.
 * The command may have been successfully dispatched or cancelled
 * for one or more reasons.
 */
declare class DispatchResult {
    readonly reasons: CancelledReason[];
    constructor(results?: CommandResult | CommandResult[]);
    /**
     * Static helper which returns a successful DispatchResult
     */
    static get Success(): DispatchResult;
    get isSuccessful(): boolean;
    /**
     * Check if the dispatch has been cancelled because of
     * the given reason.
     */
    isCancelledBecause(reason: CancelledReason): boolean;
}
type CancelledReason = Exclude<CommandResult, CommandResult.Success>;
declare const enum CommandResult {
    Success = "Success",
    CancelledForUnknownReason = "CancelledForUnknownReason",
    WillRemoveExistingMerge = "WillRemoveExistingMerge",
    CannotMoveTableHeader = "CannotMoveTableHeader",
    MergeIsDestructive = "MergeIsDestructive",
    CellIsMerged = "CellIsMerged",
    InvalidTarget = "InvalidTarget",
    EmptyUndoStack = "EmptyUndoStack",
    EmptyRedoStack = "EmptyRedoStack",
    NotEnoughElements = "NotEnoughElements",
    NotEnoughSheets = "NotEnoughSheets",
    MissingSheetName = "MissingSheetName",
    UnchangedSheetName = "UnchangedSheetName",
    DuplicatedSheetName = "DuplicatedSheetName",
    DuplicatedSheetId = "DuplicatedSheetId",
    ForbiddenCharactersInSheetName = "ForbiddenCharactersInSheetName",
    WrongSheetMove = "WrongSheetMove",
    WrongSheetPosition = "WrongSheetPosition",
    InvalidAnchorZone = "InvalidAnchorZone",
    SelectionOutOfBound = "SelectionOutOfBound",
    TargetOutOfSheet = "TargetOutOfSheet",
    WrongCutSelection = "WrongCutSelection",
    WrongPasteSelection = "WrongPasteSelection",
    WrongPasteOption = "WrongPasteOption",
    WrongFigurePasteOption = "WrongFigurePasteOption",
    EmptyClipboard = "EmptyClipboard",
    EmptyRange = "EmptyRange",
    InvalidRange = "InvalidRange",
    InvalidZones = "InvalidZones",
    InvalidSheetId = "InvalidSheetId",
    InvalidCellId = "InvalidCellId",
    InvalidFigureId = "InvalidFigureId",
    InputAlreadyFocused = "InputAlreadyFocused",
    MaximumRangesReached = "MaximumRangesReached",
    MinimumRangesReached = "MinimumRangesReached",
    InvalidChartDefinition = "InvalidChartDefinition",
    InvalidDataSet = "InvalidDataSet",
    InvalidLabelRange = "InvalidLabelRange",
    InvalidScorecardKeyValue = "InvalidScorecardKeyValue",
    InvalidScorecardBaseline = "InvalidScorecardBaseline",
    InvalidGaugeDataRange = "InvalidGaugeDataRange",
    EmptyGaugeRangeMin = "EmptyGaugeRangeMin",
    GaugeRangeMinNaN = "GaugeRangeMinNaN",
    EmptyGaugeRangeMax = "EmptyGaugeRangeMax",
    GaugeRangeMaxNaN = "GaugeRangeMaxNaN",
    GaugeLowerInflectionPointNaN = "GaugeLowerInflectionPointNaN",
    GaugeUpperInflectionPointNaN = "GaugeUpperInflectionPointNaN",
    InvalidAutofillSelection = "InvalidAutofillSelection",
    MinBiggerThanMax = "MinBiggerThanMax",
    LowerBiggerThanUpper = "LowerBiggerThanUpper",
    MidBiggerThanMax = "MidBiggerThanMax",
    MinBiggerThanMid = "MinBiggerThanMid",
    FirstArgMissing = "FirstArgMissing",
    SecondArgMissing = "SecondArgMissing",
    MinNaN = "MinNaN",
    MidNaN = "MidNaN",
    MaxNaN = "MaxNaN",
    ValueUpperInflectionNaN = "ValueUpperInflectionNaN",
    ValueLowerInflectionNaN = "ValueLowerInflectionNaN",
    MinInvalidFormula = "MinInvalidFormula",
    MidInvalidFormula = "MidInvalidFormula",
    MaxInvalidFormula = "MaxInvalidFormula",
    ValueUpperInvalidFormula = "ValueUpperInvalidFormula",
    ValueLowerInvalidFormula = "ValueLowerInvalidFormula",
    InvalidSortAnchor = "InvalidSortAnchor",
    InvalidSortZone = "InvalidSortZone",
    SortZoneWithArrayFormulas = "SortZoneWithArrayFormulas",
    WaitingSessionConfirmation = "WaitingSessionConfirmation",
    MergeOverlap = "MergeOverlap",
    TooManyHiddenElements = "TooManyHiddenElements",
    Readonly = "Readonly",
    InvalidViewportSize = "InvalidViewportSize",
    InvalidScrollingDirection = "InvalidScrollingDirection",
    ViewportScrollLimitsReached = "ViewportScrollLimitsReached",
    FigureDoesNotExist = "FigureDoesNotExist",
    InvalidConditionalFormatId = "InvalidConditionalFormatId",
    InvalidCellPopover = "InvalidCellPopover",
    EmptyTarget = "EmptyTarget",
    InvalidFreezeQuantity = "InvalidFreezeQuantity",
    FrozenPaneOverlap = "FrozenPaneOverlap",
    ValuesNotChanged = "ValuesNotChanged",
    InvalidFilterZone = "InvalidFilterZone",
    TableNotFound = "TableNotFound",
    TableOverlap = "TableOverlap",
    InvalidTableConfig = "InvalidTableConfig",
    InvalidTableStyle = "InvalidTableStyle",
    FilterNotFound = "FilterNotFound",
    MergeInTable = "MergeInTable",
    NonContinuousTargets = "NonContinuousTargets",
    DuplicatedFigureId = "DuplicatedFigureId",
    InvalidSelectionStep = "InvalidSelectionStep",
    DuplicatedChartId = "DuplicatedChartId",
    ChartDoesNotExist = "ChartDoesNotExist",
    InvalidHeaderIndex = "InvalidHeaderIndex",
    InvalidQuantity = "InvalidQuantity",
    MoreThanOneColumnSelected = "MoreThanOneColumnSelected",
    EmptySplitSeparator = "EmptySplitSeparator",
    SplitWillOverwriteContent = "SplitWillOverwriteContent",
    NoSplitSeparatorInSelection = "NoSplitSeparatorInSelection",
    NoActiveSheet = "NoActiveSheet",
    InvalidLocale = "InvalidLocale",
    MoreThanOneRangeSelected = "MoreThanOneRangeSelected",
    NoColumnsProvided = "NoColumnsProvided",
    ColumnsNotIncludedInZone = "ColumnsNotIncludedInZone",
    DuplicatesColumnsSelected = "DuplicatesColumnsSelected",
    InvalidHeaderGroupStartEnd = "InvalidHeaderGroupStartEnd",
    HeaderGroupAlreadyExists = "HeaderGroupAlreadyExists",
    UnknownHeaderGroup = "UnknownHeaderGroup",
    UnknownDataValidationRule = "UnknownDataValidationRule",
    UnknownDataValidationCriterionType = "UnknownDataValidationCriterionType",
    InvalidDataValidationCriterionValue = "InvalidDataValidationCriterionValue",
    InvalidNumberOfCriterionValues = "InvalidNumberOfCriterionValues",
    InvalidCopyPasteSelection = "InvalidCopyPasteSelection",
    NoChanges = "NoChanges",
    InvalidInputId = "InvalidInputId",
    SheetIsHidden = "SheetIsHidden",
    InvalidTableResize = "InvalidTableResize",
    PivotIdNotFound = "PivotIdNotFound",
    PivotIdTaken = "PivotIdTaken",
    PivotInError = "PivotInError",
    EmptyName = "EmptyName",
    ValueCellIsInvalidFormula = "ValueCellIsInvalidFormula",
    InvalidDefinition = "InvalidDefinition",
    InvalidColor = "InvalidColor",
    InvalidPivotDataSet = "InvalidPivotDataSet",
    InvalidPivotCustomField = "InvalidPivotCustomField",
    MissingFigureArguments = "MissingFigureArguments",
    InvalidCarouselItem = "InvalidCarouselItem"
}
interface CommandHandler<T> {
    allowDispatch(command: T): CommandResult | CommandResult[];
    beforeHandle(command: T): void;
    handle(command: T): void;
    finalize(): void;
}
interface CommandDispatcher {
    dispatch<T extends CommandTypes, C extends Extract<Command, {
        type: T;
    }>>(type: {} extends Omit<C, "type"> ? T : never): DispatchResult;
    dispatch<T extends CommandTypes, C extends Extract<Command, {
        type: T;
    }>>(type: T, r: Omit<C, "type">): DispatchResult;
}
interface CoreCommandDispatcher {
    dispatch<T extends CoreCommandTypes, C extends Extract<CoreCommand, {
        type: T;
    }>>(type: {} extends Omit<C, "type"> ? T : never): DispatchResult;
    dispatch<T extends CoreCommandTypes, C extends Extract<CoreCommand, {
        type: T;
    }>>(type: T, r: Omit<C, "type">): DispatchResult;
}
type CommandTypes = Command["type"];
type CoreCommandTypes = CoreCommand["type"];
type CoreViewCommand = CoreCommand | EvaluateCellsCommand | EvaluateChartsCommand | UndoCommand | RedoCommand;

/**
 * The following type is meant to be used in union with other aliases to prevent
 * Intellisense from resolving it.
 * See https://github.com/microsoft/TypeScript/issues/31940#issuecomment-841712377
 */
type Alias = {} & {};
type HeaderIndex = number & Alias;
type Pixel = number & Alias;
type UID = string & Alias;
type SetDecimalStep = 1 | -1;
type FilterId = UID & Alias;
type TableId = UID & Alias;
/**
 * CSS style color string
 * e.g. "#ABC", "#AAAFFF", "rgb(30, 80, 16)"
 */
type Color = string & Alias;
interface RGBA {
    a: number;
    r: number;
    g: number;
    b: number;
}
interface HSLA {
    a: number;
    h: number;
    s: number;
    l: number;
}
interface Link {
    readonly label: string;
    readonly url: string;
    readonly isExternal: boolean;
    /**
     * Specifies if the URL is editable by the end user.
     * Special links might not allow it.
     */
    readonly isUrlEditable: boolean;
}
interface Zone {
    left: HeaderIndex;
    right: HeaderIndex;
    top: HeaderIndex;
    bottom: HeaderIndex;
}
interface AnchorZone {
    zone: Zone;
    cell: Position;
}
interface Selection {
    anchor: AnchorZone;
    zones: Zone[];
}
type AdjacentEdge = {
    position: "left" | "top" | "bottom" | "right";
    start: HeaderIndex;
    stop: HeaderIndex;
};
interface UnboundedZone {
    top: HeaderIndex;
    bottom: HeaderIndex | undefined;
    left: HeaderIndex;
    right: HeaderIndex | undefined;
    /**
     * The hasHeader flag is used to determine if the zone has a header (eg. A2:A or C3:3).
     *
     * The main issue is that the zone A1:A and A:A have different behavior. The "correct" way to handle this would be to
     * allow the top/left to be undefined, but this make typing and using unbounded zones VERY annoying. So we use this
     * boolean instead.
     */
    hasHeader?: boolean;
}
interface ZoneDimension {
    numberOfRows: HeaderIndex;
    numberOfCols: HeaderIndex;
}
type Align = "left" | "right" | "center" | undefined;
type VerticalAlign = "top" | "middle" | "bottom" | undefined;
type Wrapping = "overflow" | "wrap" | "clip" | undefined;
interface Style {
    bold?: boolean;
    italic?: boolean;
    strikethrough?: boolean;
    underline?: boolean;
    align?: Align;
    wrapping?: Wrapping;
    verticalAlign?: VerticalAlign;
    fillColor?: Color;
    textColor?: Color;
    fontSize?: number;
    rotation?: number;
}
interface DataBarFill {
    color: Color;
    percentage: number;
}
interface UpdateCellData {
    content?: string;
    formula?: string;
    style?: Style | null;
    format?: Format;
}
interface Sheet {
    id: UID;
    name: string;
    numberOfCols: number;
    rows: Row[];
    areGridLinesVisible: boolean;
    isVisible: boolean;
    panes: PaneDivision;
    color?: Color;
}
interface CellPosition {
    col: HeaderIndex;
    row: HeaderIndex;
    sheetId: UID;
}
declare const borderStyles: readonly ["thin", "medium", "thick", "dashed", "dotted"];
type BorderStyle = (typeof borderStyles)[number];
type BorderDescr = {
    style: BorderStyle;
    color: Color;
};
/**
 * A complete border(s) data is a set of position-color-style information
 */
type BorderData = {
    position: BorderPosition;
    color?: Color;
    style?: BorderStyle;
};
interface Border {
    top?: BorderDescr;
    left?: BorderDescr;
    bottom?: BorderDescr;
    right?: BorderDescr;
}
type ReferenceDenormalizer = (range: Range, isMeta: boolean, functionName: string, paramNumber: number) => FunctionResultObject;
type EnsureRange = (range: Range, isMeta: boolean) => Matrix<FunctionResultObject>;
type GetSymbolValue = (symbolName: string) => Arg;
type FormulaToExecute = (deps: Range[], refFn: ReferenceDenormalizer, range: EnsureRange, getSymbolValue: GetSymbolValue, ctx: object) => Matrix<FunctionResultObject> | FunctionResultObject;
interface CompiledFormula {
    execute: FormulaToExecute;
    tokens: Token[];
    dependencies: string[];
    isBadExpression: boolean;
    normalizedFormula: string;
}
interface RangeCompiledFormula extends Omit<CompiledFormula, "dependencies"> {
    dependencies: Range[];
}
type Matrix<T = unknown> = T[][];
type FunctionResultObject = {
    value: CellValue;
    format?: Format;
    errorOriginPosition?: CellPosition;
    message?: string;
    origin?: CellPosition;
};
type FunctionResultNumber = {
    value: number;
    format?: string;
};
type Arg = Maybe<FunctionResultObject> | Matrix<FunctionResultObject>;
declare function isMatrix(x: any): x is Matrix<any>;
interface ClipboardCell {
    evaluatedCell: EvaluatedCell;
    position: CellPosition;
    content: string;
    style?: Style | undefined;
    format?: Format | undefined;
    tokens?: Token[];
    border?: Border;
}
interface HeaderDimensions {
    start: Pixel;
    size: Pixel;
    end: Pixel;
}
interface Row {
    cells: Record<number, UID | undefined>;
}
interface Position {
    col: HeaderIndex;
    row: HeaderIndex;
}
interface PixelPosition {
    x: Pixel;
    y: Pixel;
}
interface Merge extends Zone {
    id: number;
}
interface Highlight {
    range: Range;
    color: Color;
    interactive?: boolean;
    thinLine?: boolean;
    noFill?: boolean;
    /** transparency of the fill color (0-1) */
    fillAlpha?: number;
    noBorder?: boolean;
    dashed?: boolean;
}
interface PaneDivision {
    /** Represents the number of frozen columns */
    xSplit: number;
    /** Represents the number of frozen rows */
    ySplit: number;
}
type BorderPosition = "all" | "hv" | "h" | "v" | "external" | "left" | "top" | "right" | "bottom" | "clear";
declare const enum DIRECTION {
    UP = "up",
    DOWN = "down",
    LEFT = "left",
    RIGHT = "right"
}
type ChangeType = "REMOVE" | "RESIZE" | "MOVE" | "CHANGE" | "NONE";
type ApplyRangeChangeResult<T> = {
    changeType: ChangeType;
    range: T;
};
type ApplyFormulaRangeChangeResult = {
    changeType: ChangeType;
    formula: string;
};
type ApplyRangeChange = (range: Range) => ApplyRangeChangeResult<Range>;
type AdaptSheetName = {
    old: string;
    current: string;
};
type RangeAdapter = {
    sheetId: UID;
    sheetName: AdaptSheetName;
    applyChange: ApplyRangeChange;
};
type RangeAdapterFunctions = {
    applyChange: ApplyRangeChange;
    adaptRangeString: (defaultSheetId: UID, sheetXC: string) => ApplyRangeChangeResult<string>;
    adaptFormulaString: (defaultSheetId: UID, formula: string) => string;
};
type Dimension = "COL" | "ROW";
type ConsecutiveIndexes = HeaderIndex[];
interface RangeProvider {
    adaptRanges: (adapterFunctions: RangeAdapterFunctions, sheetId: UID, sheetName: AdaptSheetName) => void;
}
type Validation<T> = (toValidate: T) => CommandResult | CommandResult[];
type Increment = 1 | -1 | 0;
interface Ref<T> {
    el: T | null;
}
/**
 * Container for a lazy computed value
 */
interface Lazy<T> {
    /**
     * Return the computed value.
     * The value is computed only once and memoized.
     */
    (): T;
    /**
     * Map a lazy value to another lazy value.
     *
     * ```ts
     * // neither function is called here
     * const lazyValue = lazy(() => veryExpensive(...)).map((result) => alsoVeryExpensive(result));
     *
     * // both values are computed now
     * const value = lazyValue()
     * ```
     */
    map: <U>(callback: (value: T) => U) => Lazy<U>;
}
type Maybe<T> = T | undefined;
interface Cloneable<T> {
    clone: (args?: Partial<T>) => T;
}
type CSSProperties<P extends string = string> = Record<P, string | undefined>;
interface SortOptions {
    /** If true sort the headers of the range along with the rest */
    sortHeaders?: boolean;
    /** If true treat empty cells as "0" instead of undefined */
    emptyCellAsZero?: boolean;
}
interface MenuMouseEvent extends MouseEvent {
    closedMenuId?: UID;
}
type Immutable<T> = T extends ImmutablePrimitive ? T : T extends Array<infer U> ? ImmutableArray<U> : T extends Map<infer K, infer V> ? ImmutableMap<K, V> : T extends Set<infer M> ? ImmutableSet<M> : ImmutableObject<T>;
type ImmutablePrimitive = undefined | null | boolean | string | number | Function;
type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
type ImmutableObject<T> = {
    readonly [K in keyof T]: Immutable<T[K]>;
};
interface HeaderGroup {
    start: HeaderIndex;
    end: HeaderIndex;
    isFolded?: boolean;
}
type Direction = "up" | "down" | "left" | "right";
type SelectionStep = number | "end";
interface Offset {
    col: number;
    row: number;
}
type DebouncedFunction<T> = T & {
    stopDebounce: () => void;
    isDebouncePending: () => boolean;
};
interface GridClickModifiers {
    addZone: boolean;
    expandZone: boolean;
}
type ComposerFocusType = "inactive" | "cellFocus" | "contentFocus";
type EditionMode = "editing" | "selecting" | "inactive";
type SortDirection = "asc" | "desc";
interface ValueAndLabel<T = string> {
    value: T;
    label: string;
}

declare const OPERATOR_MAP: {
    "=": string;
    "+": string;
    "-": string;
    "*": string;
    "/": string;
    ">=": string;
    "<>": string;
    ">": string;
    "<=": string;
    "<": string;
    "^": string;
    "&": string;
};
declare const UNARY_OPERATOR_MAP: {
    "-": string;
    "+": string;
    "%": string;
};
declare const functionCache: {
    [key: string]: FormulaToExecute;
};
declare function compile(formula: string): CompiledFormula;
declare function compileTokens(tokens: Token[]): CompiledFormula;

interface ASTBase {
    debug?: boolean;
    tokenStartIndex: number;
    tokenEndIndex: number;
}
interface ASTNumber extends ASTBase {
    type: "NUMBER";
    value: number;
}
interface ASTReference extends ASTBase {
    type: "REFERENCE";
    value: string;
}
interface ASTString extends ASTBase {
    type: "STRING";
    value: string;
}
interface ASTBoolean extends ASTBase {
    type: "BOOLEAN";
    value: boolean;
}
interface ASTUnaryOperation extends ASTBase {
    type: "UNARY_OPERATION";
    value: any;
    operand: AST;
    postfix?: boolean;
}
interface ASTOperation extends ASTBase {
    type: "BIN_OPERATION";
    value: any;
    left: AST;
    right: AST;
}
interface ASTFuncall extends ASTBase {
    type: "FUNCALL";
    value: string;
    args: AST[];
}
interface ASTSymbol extends ASTBase {
    type: "SYMBOL";
    value: string;
}
interface ASTArray extends ASTBase {
    type: "ARRAY";
    value: AST[][];
}
interface ASTEmpty extends ASTBase {
    type: "EMPTY";
    value: "";
}
type AST = ASTOperation | ASTUnaryOperation | ASTFuncall | ASTSymbol | ASTArray | ASTNumber | ASTBoolean | ASTString | ASTReference | ASTEmpty;
declare const OP_PRIORITY: {
    "%": number;
    "^": number;
    "*": number;
    "/": number;
    "+": number;
    "-": number;
    "&": number;
    ">": number;
    "<>": number;
    ">=": number;
    "<": number;
    "<=": number;
    "=": number;
};
/**
 * Parse an expression (as a string) into an AST.
 */
declare function parse(str: string): AST;
declare function parseTokens(tokens: Token[]): AST;
/**
 * Allows to visit all nodes of an AST and apply a mapping function
 * to nodes of a specific type.
 * Useful if you want to convert some part of a formula.
 *
 * @example
 * convertAstNodes(ast, "FUNCALL", convertFormulaToExcel)
 *
 * function convertFormulaToExcel(ast: ASTFuncall) {
 *   // ...
 *   return modifiedAst
 * }
 */
declare function convertAstNodes<T extends AST["type"]>(ast: AST, type: T, fn: (ast: Extract<AST, {
    type: T;
}>) => AST): AST;
declare function iterateAstNodes(ast: AST): AST[];
declare function mapAst<T extends AST["type"]>(ast: AST, fn: (ast: Extract<AST, {
    type: T;
}>) => AST): AST;

/**
 * Take the result of the tokenizer and transform it to be usable in the
 * manipulations of range
 *
 * @param formula
 */
declare function rangeTokenize(formula: string, locale?: Locale): Token[];

declare class Registry<T> {
    content: Record<string, T>;
    add(key: string, value: T): this;
    replace(key: string, value: T): this;
    get(key: string): T;
    contains(key: string): boolean;
    getAll(): T[];
    getKeys(): string[];
    remove(key: string): void;
}

type ArgType = "ANY" | "BOOLEAN" | "NUMBER" | "STRING" | "DATE" | "RANGE" | "RANGE<BOOLEAN>" | "RANGE<NUMBER>" | "RANGE<DATE>" | "RANGE<STRING>" | "RANGE<ANY>" | "META" | "RANGE<META>";
interface ArgDefinition {
    acceptMatrix?: boolean;
    acceptMatrixOnly?: boolean;
    acceptErrors?: boolean;
    repeating?: boolean;
    optional?: boolean;
    description: string;
    name: string;
    type: ArgType[];
    default?: boolean;
    defaultValue?: any;
    proposalValues?: ArgProposal[];
}
type ArgProposal = {
    value: CellValue;
    label?: string;
};
type ComputeFunction<R> = (this: EvalContext, ...args: Arg[]) => R;
interface AddFunctionDescription {
    compute: ComputeFunction<FunctionResultObject | Matrix<FunctionResultObject> | CellValue | Matrix<CellValue>>;
    description: string;
    category?: string;
    args: ArgDefinition[];
    isExported?: boolean;
    hidden?: boolean;
}
type FunctionDescription = AddFunctionDescription & {
    name: string;
    minArgRequired: number;
    maxArgPossible: number;
    nbrArgRepeating: number;
    nbrOptionalNonRepeatingArgs: number;
};
type EvalContext = {
    __originSheetId: UID;
    __originCellPosition?: CellPosition;
    locale: Locale;
    getters: Getters;
    [key: string]: any;
    updateDependencies?: (position: CellPosition) => void;
    addDependencies?: (position: CellPosition, ranges: Range[]) => void;
    debug?: boolean;
    lookupCaches?: LookupCaches;
};
/**
 * used to cache lookup values for linear search
 **/
type LookupCaches = {
    forwardSearch: Map<unknown, Map<CellValue, number>>;
    reverseSearch: Map<unknown, Map<CellValue, number>>;
};

declare class FunctionRegistry extends Registry<FunctionDescription> {
    mapping: {
        [key: string]: ComputeFunction<Matrix<FunctionResultObject> | FunctionResultObject>;
    };
    add(name: string, addDescr: AddFunctionDescription): this;
    replace(name: string, addDescr: AddFunctionDescription): this;
}
type Functions = {
    [functionName: string]: AddFunctionDescription;
};
type Category = {
    name: string;
    functions: Functions;
};
declare const categories: Category[];

type SprintfValues = (string | String | number)[] | [{
    [key: string]: string | number;
}];
type TranslationFunction = (string: string, ...values: SprintfValues) => string;
/***
 * Allow to inject a translation function from outside o-spreadsheet. This should be called before instantiating
 * a model.
 * @param tfn the function that will do the translation
 * @param loaded a function that returns true when the translation is loaded
 */
declare function setTranslationMethod(tfn: TranslationFunction, loaded?: () => boolean): void;
/**
 * If no translation function has been set, this will mark the translation are loaded.
 *
 * By default, the translations should not be set as loaded, otherwise top-level translated constants will never be
 * translated. But if by the time the model is instantiated no custom translation function has been set, we can set
 * the default translation function as loaded so o-spreadsheet can be run in standalone with no translations.
 */
declare function setDefaultTranslationMethod(): void;
declare const _t: TranslationFunction;

type GlobalChart = typeof ChartJs & typeof ChartJs.Chart;
declare global {
    var Chart: GlobalChart | undefined;
}

declare const CellErrorType: {
    readonly NotAvailable: "#N/A";
    readonly InvalidReference: "#REF";
    readonly BadExpression: "#BAD_EXPR";
    readonly CircularDependency: "#CYCLE";
    readonly UnknownFunction: "#NAME?";
    readonly DivisionByZero: "#DIV/0!";
    readonly InvalidNumber: "#NUM!";
    readonly SpilledBlocked: "#SPILL!";
    readonly GenericError: "#ERROR";
    readonly NullError: "#NULL!";
};
type ErrorValue = (typeof CellErrorType)[keyof typeof CellErrorType];
declare const errorTypes: Set<string>;
declare class EvaluationError {
    readonly message: string;
    readonly value: string;
    constructor(message?: string, value?: string);
}
declare class BadExpressionError extends EvaluationError {
    constructor(message?: string);
}
declare class CircularDependencyError extends EvaluationError {
    constructor(message?: string);
}
declare class InvalidReferenceError extends EvaluationError {
    constructor(message?: string);
}
declare class NotAvailableError extends EvaluationError {
    constructor(message?: string);
}
declare class UnknownFunctionError extends EvaluationError {
    constructor(message?: string);
}
declare class SplillBlockedError extends EvaluationError {
    constructor(message?: string);
}
declare class DivisionByZeroError extends EvaluationError {
    constructor(message?: string);
}
declare class NumberTooLargeError extends EvaluationError {
    constructor(message?: string);
}

declare const __info__: {};

export { AST, ASTFuncall, ASTOperation, ASTString, ASTSymbol, ASTUnaryOperation, AdaptSheetName, AdjacentEdge, Alias, Align, AnchorZone, ApplyFormulaRangeChangeResult, ApplyRangeChange, ApplyRangeChangeResult, Arg, BadExpressionError, BasePlugin, Border, BorderData, BorderDescr, BorderDescrWithOpacity, BorderPosition, BorderStyle, Box, BoxTextContent, CSSProperties, CellErrorType, CellPosition, CellValue, ChangeType, CircularDependencyError, ClipboardCell, Cloneable, Color, CompiledFormula, ComposerFocusType, ConsecutiveIndexes, CoreGetters, CreateRevisionOptions, DEFAULT_LOCALE, DEFAULT_LOCALES, DIRECTION, DOMCoordinates, DOMDimension, DataBarFill, DebouncedFunction, Dimension, Direction, DivisionByZeroError, EdgeScrollInfo, EditionMode, EnsureRange, ErrorValue, EvaluationError, FilterId, Format, FormulaToExecute, FunctionCode, FunctionCodeBuilder, FunctionRegistry, FunctionResultNumber, FunctionResultObject, GetSymbolValue, GlobalChart, GridClickModifiers, GridRenderingContext, HSLA, HeaderDimensions, HeaderGroup, HeaderIndex, Highlight, HistoryChange, Image, Immutable, Increment, InvalidReferenceError, LayerName, Lazy, Link, Locale, LocaleCode, Matrix, Maybe, MenuMouseEvent, Merge, Model, NotAvailableError, NumberTooLargeError, OPERATOR_MAP, OP_PRIORITY, Offset, OperationSequenceNode, OrderedLayers, POSTFIX_UNARY_OPERATORS, PaneDivision, Pixel, PixelPosition, PluginGetters, Position, RGBA, RangeAdapter, RangeAdapterFunctions, RangeCompiledFormula, RangeProvider, Rect, Ref, ReferenceDenormalizer, Registry, RenderingBorder, RenderingBox, RenderingGridIcon, Row, Scope, ScrollDirection, Selection, SelectionStep, SetDecimalStep, Sheet, SheetDOMScrollInfo, SortDirection, SortOptions, SplillBlockedError, SpreadsheetClipboardData, StateObserver, Style, TableId, Token, TokenizingChars, Transformation, TransformationFactory, TranslationFunction, UID, UNARY_OPERATOR_MAP, UnboundedZone, UnknownFunctionError, UpdateCellData, UuidGenerator, Validation, Validator, ValueAndLabel, VerticalAlign, Viewport, WorkbookHistory, Wrapping, Zone, ZoneDimension, __info__, _t, addRenderingLayer, batched, borderStyles, buildSheetLink, categories, cellReference, chartStyleToCellStyle, clip, compile, compileTokens, concat, convertAstNodes, createEmptyStructure, debounce, deepCopy, deepEquals, deepEqualsArray, errorTypes, escapeRegExp, findNextDefinedValue, functionCache, getAddHeaderStartIndex, getCanonicalSymbolName, getFormulaNumberRegex, getFullReference, getSearchRegex, getUniqueText, getUnquotedSheetName, groupConsecutive, includesAll, insertItemsAtIndex, isBoolean, isColHeader, isColReference, isConsecutive, isDefined, isFormula, isMarkdownLink, isMatrix, isNotNull, isNumber, isNumberBetween, isObjectEmptyRecursive, isRowHeader, isRowReference, isSheetUrl, isSingleCellReference, isWebLink, iterateAstNodes, largeMax, largeMin, lazy, linkNext, loopThroughReferenceType, mapAst, markdownLink, memoize, parse, parseMarkdownLink, parseNumber, parseSheetUrl, parseTokens, percentile, range, rangeReference, rangeTokenize, removeDuplicates, removeFalsyAttributes, removeIndexesFromArray, replaceItemAtIndex, replaceNewLines, sanitizeSheetName, setDefaultTranslationMethod, setTranslationMethod, setXcToFixedReferenceType, specialWhiteSpaceRegexp, splitReference, tokenize, transpose2dPOJO, trimContent, unquote, whiteSpaceCharacters };