import { AllowedComponentProps } from 'vue';
import { Component } from 'vue';
import { ComponentCustomProps } from 'vue';
import { ComponentOptionsBase } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { ComputedRef } from 'vue';
import { CreateComponentPublicInstanceWithMixins } from 'vue';
import { DefineComponent } from 'vue';
import { GlobalComponents } from 'vue';
import { GlobalDirectives } from 'vue';
import { PropType } from 'vue';
import { PublicProps } from 'vue';
import { Ref } from 'vue';
import { ShallowRef } from 'vue';
import { UnwrapRef } from 'vue';
import { VNode } from 'vue';
import { VNodeProps } from 'vue';

declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:pivotModel": (model: PivotModelInterface) => any;
    change: (model: PivotModelInterface) => any;
}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
    "onUpdate:pivotModel"?: ((model: PivotModelInterface) => any) | undefined;
    onChange?: ((model: PivotModelInterface) => any) | undefined;
}>, {
    aggregators: Record<string, AggregatorTemplate>;
    cols: string[];
    rows: string[];
    vals: string[];
    aggregatorName: string;
    sorters: any;
    valueFilter: Record<string, any>;
    rowOrder: "key_a_to_z" | "value_a_to_z" | "value_z_to_a";
    colOrder: "key_a_to_z" | "value_a_to_z" | "value_z_to_a";
    derivedAttributes: any;
    tableColorScaleGenerator: ((...args: any[]) => any) & ((...args: any[]) => any);
    heatmapMode: "full" | "col" | "row" | "";
    tableOptions: Record<string, any>;
    renderers: Record<string, RendererDefinition>;
    rendererName: string;
    locale: string;
    languagePack: Record<string, Locale>;
    attributes: string[];
    tableMaxWidth: number;
    aggregatorMap: Record<string, string>;
    hiddenAttributes: string[];
    hiddenFromAggregators: string[];
    hiddenFromDragDrop: string[];
    restrictedFromDragDrop: string[];
    hideFilterBoxOfUnusedAttributes: boolean;
    menuLimit: number;
    pivotModel: PivotModelInterface;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLTableElement>;

declare type __VLS_Props = Partial<DefaultPropsType> & {
    data: any;
    renderers: Record<string, RendererDefinition>;
    hiddenAttributes?: string[];
    hiddenFromAggregators?: string[];
    hiddenFromDragDrop?: string[];
    restrictedFromDragDrop?: string[];
    menuLimit?: number;
    pivotModel?: PivotModelInterface;
    hideFilterBoxOfUnusedAttributes?: boolean;
    aggregators?: Record<string, AggregatorTemplate>;
    aggregatorName?: string;
    heatmapMode?: 'full' | 'col' | 'row' | '';
    tableColorScaleGenerator?: (...args: any[]) => any;
    tableOptions?: Record<string, any>;
    rendererName?: string;
    locale?: string;
    languagePack?: Record<string, Locale>;
    showRowTotal?: boolean;
    showColTotal?: boolean;
    cols?: string[];
    rows?: string[];
    vals?: string[];
    attributes?: string[];
    valueFilter?: Record<string, any>;
    sorters?: any;
    derivedAttributes?: any;
    rowOrder?: 'key_a_to_z' | 'value_a_to_z' | 'value_z_to_a';
    colOrder?: 'key_a_to_z' | 'value_a_to_z' | 'value_z_to_a';
    tableMaxWidth?: number;
    aggregatorMap?: Record<string, string>;
};

declare function __VLS_template(): {
    attrs: Partial<{}>;
    slots: {
        colGroup?(_: {}): any;
        rendererCell?(_: {}): any;
        aggregatorCell?(_: {}): any;
        pvtAttr?(_: {
            attrName: string;
        }): any;
        pvtAttr?(_: {
            attrName: string;
        }): any;
        outputSlot?(_: {
            outputSlot: {
                pivotData: PivotData;
            };
        }): any;
        output?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLTableElement;
};

declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;

declare type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type AggregatorFunction = (data?: PivotDataContext, rowKey?: any[], colKey?: any[]) => AggregatorInstance;

declare interface AggregatorInstance {
    count?: number;
    sum?: number;
    vals?: number[];
    uniq?: any[];
    val?: any;
    sorter?: SortFunction;
    n?: number;
    m?: number;
    s?: number;
    sumNum?: number;
    sumDenom?: number;
    selector?: [any[], any[]];
    inner?: AggregatorInstance;
    push: (record: DataRecord) => void;
    value: () => any;
    format?: Formatter | ((x: any) => string);
    numInputs?: number;
}

declare const aggregators: Record<string, AggregatorTemplate>;

declare type AggregatorTemplate = (...args: any[]) => AggregatorFunction;

declare interface AggregatorTemplates {
    count: (formatter?: Formatter) => AggregatorTemplate;
    uniques: (fn: (uniq: any[]) => any, formatter?: Formatter) => AggregatorTemplate;
    sum: (formatter?: Formatter) => AggregatorTemplate;
    extremes: (mode: 'min' | 'max' | 'first' | 'last', formatter?: Formatter) => AggregatorTemplate;
    quantile: (q: number, formatter?: Formatter) => AggregatorTemplate;
    runningStat: (mode: 'mean' | 'var' | 'stdev', ddof?: number, formatter?: Formatter) => AggregatorTemplate;
    sumOverSum: (formatter?: Formatter) => AggregatorTemplate;
    fractionOf: (wrapped: AggregatorTemplate, type?: 'total' | 'row' | 'col', formatter?: Formatter) => AggregatorTemplate;
    countUnique: (formatter?: Formatter) => AggregatorTemplate;
    listUnique: (separator: string) => AggregatorTemplate;
    max: (formatter?: Formatter) => AggregatorTemplate;
    min: (formatter?: Formatter) => AggregatorTemplate;
    first: (formatter?: Formatter) => AggregatorTemplate;
    last: (formatter?: Formatter) => AggregatorTemplate;
    median: (formatter?: Formatter) => AggregatorTemplate;
    average: (formatter?: Formatter) => AggregatorTemplate;
    var: (ddof: number, formatter?: Formatter) => AggregatorTemplate;
    stdev: (ddof: number, formatter?: Formatter) => AggregatorTemplate;
}

declare const aggregatorTemplates: AggregatorTemplates;

declare type AttributeName = string & {
    readonly __brand: unique symbol;
};

declare type DataRecord = Record<string, RecordValue>;

declare const _default: {
    VuePivottable: DefineComponent<DefaultPropsType, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< DefaultPropsType> & Readonly<{}>, {
        aggregators: Record<string, PivotUtilities.AggregatorTemplate>;
        cols: string[];
        rows: string[];
        vals: string[];
        aggregatorName: string;
        sorters: any;
        valueFilter: Record<string, any>;
        rowOrder: "key_a_to_z" | "value_a_to_z" | "value_z_to_a";
        colOrder: "key_a_to_z" | "value_a_to_z" | "value_z_to_a";
        derivedAttributes: any;
        renderers: Record<string, RendererDefinition>;
        rendererName: string;
        locale: string;
        languagePack: Record<string, PivotUtilities.Locale>;
        tableMaxWidth: number;
        aggregatorMap: Record<string, string>;
    }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
    VuePivottableUi: {
        new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<Partial< DefaultPropsType> & {
            data: any;
            renderers: Record<string, RendererDefinition>;
            hiddenAttributes?: string[];
            hiddenFromAggregators?: string[];
            hiddenFromDragDrop?: string[];
            restrictedFromDragDrop?: string[];
            menuLimit?: number;
            pivotModel?: PivotModelInterface;
            hideFilterBoxOfUnusedAttributes?: boolean;
            aggregators?: Record<string, PivotUtilities.AggregatorTemplate>;
            aggregatorName?: string;
            heatmapMode?: "full" | "col" | "row" | "";
            tableColorScaleGenerator?: (...args: any[]) => any;
            tableOptions?: Record<string, any>;
            rendererName?: string;
            locale?: string;
            languagePack?: Record<string, PivotUtilities.Locale>;
            showRowTotal?: boolean;
            showColTotal?: boolean;
            cols?: string[];
            rows?: string[];
            vals?: string[];
            attributes?: string[];
            valueFilter?: Record<string, any>;
            sorters?: any;
            derivedAttributes?: any;
            rowOrder?: "key_a_to_z" | "value_a_to_z" | "value_z_to_a";
            colOrder?: "key_a_to_z" | "value_a_to_z" | "value_z_to_a";
            tableMaxWidth?: number;
            aggregatorMap?: Record<string, string>;
        }> & Readonly<{
            "onUpdate:pivotModel"?: ((model: PivotModelInterface) => any) | undefined;
            onChange?: ((model: PivotModelInterface) => any) | undefined;
        }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
            "update:pivotModel": (model: PivotModelInterface) => any;
            change: (model: PivotModelInterface) => any;
        }, PublicProps, {
            aggregators: Record<string, PivotUtilities.AggregatorTemplate>;
            cols: string[];
            rows: string[];
            vals: string[];
            aggregatorName: string;
            sorters: any;
            valueFilter: Record<string, any>;
            rowOrder: "key_a_to_z" | "value_a_to_z" | "value_z_to_a";
            colOrder: "key_a_to_z" | "value_a_to_z" | "value_z_to_a";
            derivedAttributes: any;
            tableColorScaleGenerator: ((...args: any[]) => any) & ((...args: any[]) => any);
            heatmapMode: "full" | "col" | "row" | "";
            tableOptions: Record<string, any>;
            renderers: Record<string, RendererDefinition>;
            rendererName: string;
            locale: string;
            languagePack: Record<string, PivotUtilities.Locale>;
            attributes: string[];
            tableMaxWidth: number;
            aggregatorMap: Record<string, string>;
            hiddenAttributes: string[];
            hiddenFromAggregators: string[];
            hiddenFromDragDrop: string[];
            restrictedFromDragDrop: string[];
            hideFilterBoxOfUnusedAttributes: boolean;
            menuLimit: number;
            pivotModel: PivotModelInterface;
        }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLTableElement, ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<Partial< DefaultPropsType> & {
            data: any;
            renderers: Record<string, RendererDefinition>;
            hiddenAttributes?: string[];
            hiddenFromAggregators?: string[];
            hiddenFromDragDrop?: string[];
            restrictedFromDragDrop?: string[];
            menuLimit?: number;
            pivotModel?: PivotModelInterface;
            hideFilterBoxOfUnusedAttributes?: boolean;
            aggregators?: Record<string, PivotUtilities.AggregatorTemplate>;
            aggregatorName?: string;
            heatmapMode?: "full" | "col" | "row" | "";
            tableColorScaleGenerator?: (...args: any[]) => any;
            tableOptions?: Record<string, any>;
            rendererName?: string;
            locale?: string;
            languagePack?: Record<string, PivotUtilities.Locale>;
            showRowTotal?: boolean;
            showColTotal?: boolean;
            cols?: string[];
            rows?: string[];
            vals?: string[];
            attributes?: string[];
            valueFilter?: Record<string, any>;
            sorters?: any;
            derivedAttributes?: any;
            rowOrder?: "key_a_to_z" | "value_a_to_z" | "value_z_to_a";
            colOrder?: "key_a_to_z" | "value_a_to_z" | "value_z_to_a";
            tableMaxWidth?: number;
            aggregatorMap?: Record<string, string>;
        }> & Readonly<{
            "onUpdate:pivotModel"?: ((model: PivotModelInterface) => any) | undefined;
            onChange?: ((model: PivotModelInterface) => any) | undefined;
        }>, {}, {}, {}, {}, {
            aggregators: Record<string, PivotUtilities.AggregatorTemplate>;
            cols: string[];
            rows: string[];
            vals: string[];
            aggregatorName: string;
            sorters: any;
            valueFilter: Record<string, any>;
            rowOrder: "key_a_to_z" | "value_a_to_z" | "value_z_to_a";
            colOrder: "key_a_to_z" | "value_a_to_z" | "value_z_to_a";
            derivedAttributes: any;
            tableColorScaleGenerator: ((...args: any[]) => any) & ((...args: any[]) => any);
            heatmapMode: "full" | "col" | "row" | "";
            tableOptions: Record<string, any>;
            renderers: Record<string, RendererDefinition>;
            rendererName: string;
            locale: string;
            languagePack: Record<string, PivotUtilities.Locale>;
            attributes: string[];
            tableMaxWidth: number;
            aggregatorMap: Record<string, string>;
            hiddenAttributes: string[];
            hiddenFromAggregators: string[];
            hiddenFromDragDrop: string[];
            restrictedFromDragDrop: string[];
            hideFilterBoxOfUnusedAttributes: boolean;
            menuLimit: number;
            pivotModel: PivotModelInterface;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & ComponentOptionsBase<Readonly<Partial< DefaultPropsType> & {
        data: any;
        renderers: Record<string, RendererDefinition>;
        hiddenAttributes?: string[];
        hiddenFromAggregators?: string[];
        hiddenFromDragDrop?: string[];
        restrictedFromDragDrop?: string[];
        menuLimit?: number;
        pivotModel?: PivotModelInterface;
        hideFilterBoxOfUnusedAttributes?: boolean;
        aggregators?: Record<string, PivotUtilities.AggregatorTemplate>;
        aggregatorName?: string;
        heatmapMode?: "full" | "col" | "row" | "";
        tableColorScaleGenerator?: (...args: any[]) => any;
        tableOptions?: Record<string, any>;
        rendererName?: string;
        locale?: string;
        languagePack?: Record<string, PivotUtilities.Locale>;
        showRowTotal?: boolean;
        showColTotal?: boolean;
        cols?: string[];
        rows?: string[];
        vals?: string[];
        attributes?: string[];
        valueFilter?: Record<string, any>;
        sorters?: any;
        derivedAttributes?: any;
        rowOrder?: "key_a_to_z" | "value_a_to_z" | "value_z_to_a";
        colOrder?: "key_a_to_z" | "value_a_to_z" | "value_z_to_a";
        tableMaxWidth?: number;
        aggregatorMap?: Record<string, string>;
    }> & Readonly<{
        "onUpdate:pivotModel"?: ((model: PivotModelInterface) => any) | undefined;
        onChange?: ((model: PivotModelInterface) => any) | undefined;
    }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
        "update:pivotModel": (model: PivotModelInterface) => any;
        change: (model: PivotModelInterface) => any;
    }, string, {
        aggregators: Record<string, PivotUtilities.AggregatorTemplate>;
        cols: string[];
        rows: string[];
        vals: string[];
        aggregatorName: string;
        sorters: any;
        valueFilter: Record<string, any>;
        rowOrder: "key_a_to_z" | "value_a_to_z" | "value_z_to_a";
        colOrder: "key_a_to_z" | "value_a_to_z" | "value_z_to_a";
        derivedAttributes: any;
        tableColorScaleGenerator: ((...args: any[]) => any) & ((...args: any[]) => any);
        heatmapMode: "full" | "col" | "row" | "";
        tableOptions: Record<string, any>;
        renderers: Record<string, RendererDefinition>;
        rendererName: string;
        locale: string;
        languagePack: Record<string, PivotUtilities.Locale>;
        attributes: string[];
        tableMaxWidth: number;
        aggregatorMap: Record<string, string>;
        hiddenAttributes: string[];
        hiddenFromAggregators: string[];
        hiddenFromDragDrop: string[];
        restrictedFromDragDrop: string[];
        hideFilterBoxOfUnusedAttributes: boolean;
        menuLimit: number;
        pivotModel: PivotModelInterface;
    }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
        $slots: {
            colGroup?(_: {}): any;
            rendererCell?(_: {}): any;
            aggregatorCell?(_: {}): any;
            pvtAttr?(_: {
                attrName: string;
            }): any;
            pvtAttr?(_: {
                attrName: string;
            }): any;
            outputSlot?(_: {
                outputSlot: {
                    pivotData: PivotUtilities.PivotData;
                };
            }): any;
            output?(_: {}): any;
        };
    });
    PivotUtilities: typeof PivotUtilities;
    Renderer: Record<string, Component>;
};
export default _default;

declare const _default_2: {
    data: {
        type: PropType<any>;
        required: boolean;
    };
    aggregators: {
        type: PropType<Record<string, AggregatorTemplate>>;
        default: () => Record<string, AggregatorTemplate>;
    };
    aggregatorName: {
        type: StringConstructor;
        default: string;
    };
    heatmapMode: PropType<"full" | "col" | "row" | "">;
    tableColorScaleGenerator: {
        type: FunctionConstructor;
        default: (value: number[]) => (x: number) => {
            backgroundColor: string;
        };
    };
    tableOptions: {
        type: PropType<Record<string, any>>;
        default: () => {};
    };
    renderers: {
        type: PropType<Record<string, any>>;
        default: () => {};
    };
    rendererName: {
        type: StringConstructor;
        default: string;
    };
    locale: {
        type: StringConstructor;
        default: string;
    };
    languagePack: {
        type: PropType<Record<string, any>>;
        default: () => Record<string, Locale>;
    };
    showRowTotal: {
        type: PropType<boolean>;
        default: boolean;
    };
    showColTotal: {
        type: PropType<boolean>;
        default: boolean;
    };
    cols: {
        type: PropType<string[]>;
        default: () => never[];
    };
    rows: {
        type: PropType<string[]>;
        default: () => never[];
    };
    vals: {
        type: PropType<string[]>;
        default: () => never[];
    };
    attributes: {
        type: PropType<string[]>;
        default: () => never[];
    };
    valueFilter: {
        type: PropType<Record<string, any>>;
        default: () => {};
    };
    sorters: {
        type: PropType<any>;
        default: () => {};
    };
    derivedAttributes: {
        type: PropType<any>;
        default: () => {};
    };
    rowOrder: {
        type: PropType<"key_a_to_z" | "value_a_to_z" | "value_z_to_a">;
        default: string;
        validator: (value: string) => boolean;
    };
    colOrder: {
        type: PropType<"key_a_to_z" | "value_a_to_z" | "value_z_to_a">;
        default: string;
        validator: (value: string) => boolean;
    };
    tableMaxWidth: {
        type: NumberConstructor;
        default: number;
        validator: (value: number) => boolean;
    };
};

declare interface DefaultPropsType {
    data: any;
    aggregators?: Record<string, AggregatorTemplate>;
    aggregatorName?: string;
    heatmapMode?: 'full' | 'col' | 'row' | '';
    tableColorScaleGenerator?: (...args: any[]) => any;
    tableOptions?: Record<string, any>;
    renderers?: Record<string, RendererDefinition>;
    rendererName?: string;
    locale?: string;
    languagePack?: Record<string, Locale>;
    showRowTotal?: boolean;
    showColTotal?: boolean;
    cols?: string[];
    rows?: string[];
    vals?: string[];
    attributes?: string[];
    valueFilter?: Record<string, any>;
    sorters?: any;
    derivedAttributes?: any;
    rowOrder?: 'key_a_to_z' | 'value_a_to_z' | 'value_z_to_a';
    colOrder?: 'key_a_to_z' | 'value_a_to_z' | 'value_z_to_a';
    tableMaxWidth?: number;
    aggregatorMap?: Record<string, string>;
}

declare interface Derivers {
    bin: (col: string, binWidth: number) => (record: DataRecord) => number;
    dateFormat: (col: string, formatString: string, utcOutput?: boolean, mthNames?: string[], dayNames?: string[]) => (record: DataRecord) => string;
}

declare const derivers: Derivers;

declare interface FilterBoxContext {
    localeStrings: ComputedRef<any>;
    sorter: (x: string) => any;
    menuLimit: ComputedRef<number>;
}

declare type FlatKey = string & {
    readonly __brand: unique symbol;
};

declare type Formatter = (value: number) => string;

declare const getSort: (sorters: Record<string, SortFunction> | ((attr: string) => SortFunction) | null, attr: string) => SortFunction;

declare interface Locale {
    aggregators?: Record<string, AggregatorTemplate>;
    frAggregators?: Record<string, AggregatorTemplate>;
    localeStrings: LocaleStrings;
}

declare const locales: Record<string, Locale>;

declare interface LocaleStrings {
    renderError: string;
    computeError: string;
    uiRenderError: string;
    selectAll: string;
    selectNone: string;
    tooMany: string;
    filterResults: string;
    totals: string;
    vs: string;
    by: string;
    cancel: string;
    only: string;
    apply?: string;
}

declare const naturalSort: SortFunction;

declare const numberFormat: (optsIn?: NumberFormatOptions) => Formatter;

declare interface NumberFormatOptions {
    digitsAfterDecimal?: number;
    scaler?: number;
    thousandsSep?: string;
    decimalSep?: string;
    prefix?: string;
    suffix?: string;
}

declare type NumericValue = number & {
    readonly __brand: unique symbol;
};

declare class PivotData {
    static defaultProps: Required<PivotDataProps>;
    props: Required<PivotDataProps>;
    aggregator: AggregatorFunction;
    tree: Record<string, Record<string, AggregatorInstance>>;
    rowKeys: any[][];
    colKeys: any[][];
    rowTotals: Record<string, AggregatorInstance>;
    colTotals: Record<string, AggregatorInstance>;
    allTotal: AggregatorInstance;
    sorted: boolean;
    filteredData: DataRecord[];
    constructor(inputProps?: Partial<PivotDataProps>);
    filter(record: DataRecord): boolean;
    forEachMatchingRecord(criteria: Record<string, any>, callback: (record: DataRecord) => void): void;
    arrSort(attrs: string[]): SortFunction;
    sortKeys(): void;
    getFilteredData(): DataRecord[];
    getColKeys(): any[][];
    getRowKeys(): any[][];
    processRecord(record: DataRecord): void;
    getAggregator(rowKey: any[], colKey: any[]): AggregatorInstance;
    static forEachRecord(input: DataRecord[] | DataRecord[][] | ((callback: (record: DataRecord) => void) => void), derivedAttributes: Record<string, (record: DataRecord) => RecordValue>, f: (record: DataRecord) => void): void;
}

declare interface PivotDataContext {
    getAggregator: (rowKey: any[], colKey: any[]) => AggregatorInstance;
}

declare interface PivotDataContext_2 {
    pivotData: ShallowRef<PivotData | null>;
    rowKeys: ComputedRef<any[][]>;
    colKeys: ComputedRef<any[][]>;
    colAttrs: ComputedRef<string[]>;
    rowAttrs: ComputedRef<string[]>;
    getAggregator: (rowKey: any[], colKey: any[]) => any;
    grandTotalAggregator: ComputedRef<any>;
    spanSize: (arr: any[][], i: number, j: number) => number;
    valueCellColors: (rowKey: any[], colKey: any[], value: any) => any;
    rowTotalColors: (value: any) => any;
    colTotalColors: (value: any) => any;
    error: Ref<string | null>;
}

declare interface PivotDataProps {
    data: DataRecord[] | DataRecord[][] | ((callback: (record: DataRecord) => void) => void);
    aggregators?: Record<string, AggregatorTemplate>;
    cols?: string[];
    rows?: string[];
    vals?: string[];
    aggregatorName?: string;
    sorters?: Record<string, SortFunction> | ((attr: string) => SortFunction);
    valueFilter?: Record<string, Record<string, boolean>>;
    rowOrder?: 'key_a_to_z' | 'key_z_to_a' | 'value_a_to_z' | 'value_z_to_a';
    colOrder?: 'key_a_to_z' | 'key_z_to_a' | 'value_a_to_z' | 'value_z_to_a';
    derivedAttributes?: Record<string, (record: DataRecord) => RecordValue>;
}

declare interface PivotModelInterface {
    rows: string[];
    cols: string[];
    vals: string[];
    aggregatorName: string;
    rendererName: string;
    heatmapMode?: 'full' | 'col' | 'row' | '';
    valueFilter: Record<string, any>;
    rowOrder: 'key_a_to_z' | 'value_a_to_z' | 'value_z_to_a';
    colOrder: 'key_a_to_z' | 'value_a_to_z' | 'value_z_to_a';
    timestamp?: number;
    version?: string;
}

declare namespace PivotUtilities {
    export {
        _default_2 as defaultProps,
        redColorScaleGenerator,
        NumberFormatOptions,
        Formatter,
        SortFunction,
        RecordValue,
        DataRecord,
        AggregatorInstance,
        AggregatorFunction,
        AggregatorTemplate,
        AggregatorTemplates,
        PivotDataProps,
        PivotDataContext,
        LocaleStrings,
        Locale,
        Derivers,
        AttributeName,
        FlatKey,
        NumericValue,
        aggregatorTemplates,
        aggregators,
        derivers,
        locales,
        naturalSort,
        numberFormat,
        getSort,
        sortAs,
        PivotData
    }
}
export { PivotUtilities }

export declare function provideFilterBox(props: ProvideFilterBoxProps): void;

declare type ProvideFilterBoxProps = Pick<DefaultPropsType, 'sorters'> & {
    menuLimit: number;
    languagePack: Record<string, Locale>;
    locale: string;
};

export declare function providePivotData(props: ProvidePivotDataProps): PivotDataContext_2;

declare interface ProvidePivotDataProps {
    [key: string]: any;
}

declare type RecordValue = string | number;

declare function redColorScaleGenerator(values: number[]): (x: number) => {
    backgroundColor: string;
};

export declare const Renderer: Record<string, Component>;

declare interface RendererDefinition {
    name: string;
    props?: Record<string, any>;
    setup: (props: any) => () => VNode;
}

declare const sortAs: (order: any[]) => SortFunction;

declare type SortFunction = (a: any, b: any) => number;

export declare function useMaterializeInput(dataSource: Ref<any>, options: UseMaterializeInputOptions): UseMaterializeInputReturn;

declare interface UseMaterializeInputOptions {
    derivedAttributes: Ref<Record<string, (record: Record<string, any>) => any>>;
}

declare interface UseMaterializeInputReturn {
    rawData: Ref<any>;
    allFilters: ShallowRef<Record<string, Record<string, number>>>;
    materializedInput: ShallowRef<any[]>;
    processData: (data: any) => {
        AllFilters: Record<string, Record<string, number>>;
        materializedInput: any[];
    } | void;
}

export declare function usePivotData(props: ProvidePivotDataProps): {
    pivotData: ShallowRef<PivotData | null, PivotData | null>;
    error: Ref<string | null, string | null>;
};

export declare function usePivotUiState(): {
    state: {
        unusedOrder: string[];
        zIndices: Record<string, number>;
        maxZIndex: number;
        openStatus: Record<string, boolean>;
    };
    onMoveFilterBoxToTop: (attributeName: string) => void;
    onUpdateOpenStatus: ({ key, value }: {
        key: string;
        value: boolean;
    }) => void;
    onUpdateUnusedOrder: (newOrder: string[]) => void;
};

export declare function usePropsState<T extends UsePropsStateProps>(initialProps: T, emit?: (event: string, payload: any) => void): UsePropsStateReturn<T>;

declare type UsePropsStateProps = Pick<DefaultPropsType, 'aggregators' | 'languagePack' | 'locale' | 'valueFilter' | 'rendererName' | 'heatmapMode' | 'aggregatorName' | 'rowOrder' | 'colOrder' | 'vals' | 'rows' | 'cols'> & {
    data?: any;
    renderers?: any;
    hiddenAttributes?: string[];
    hiddenFromAggregators?: string[];
    hiddenFromDragDrop?: string[];
    restrictedFromDragDrop?: string[];
    hideFilterBoxOfUnusedAttributes?: boolean;
    tableOptions?: any;
    showRowTotal?: boolean;
    showColTotal?: boolean;
    attributes?: string[];
    sorters?: any;
    derivedAttributes?: any;
    tableMaxWidth?: number;
    allFilters?: any;
    materializedInput?: any;
};

declare interface UsePropsStateReturn<T extends UsePropsStateProps> {
    state: UnwrapRef<T>;
    localeStrings: ComputedRef<Record<string, string> | LocaleStrings>;
    updateState: (key: keyof T, value: any) => void;
    updateMultiple: (updates: Partial<T> & {
        allFilters?: any;
        materializedInput?: any;
    }) => void;
    onUpdateValueFilter: (payload: {
        key: string;
        value: any;
    }) => void;
    onUpdateRendererName: (rendererName: string) => void;
    onUpdateAggregatorName: (aggregatorName: string) => void;
    onUpdateRowOrder: (rowOrder: string) => void;
    onUpdateColOrder: (colOrder: string) => void;
    onUpdateVals: (vals: any[]) => void;
    onDraggedAttribute: (payload: {
        key: keyof T;
        value: any;
    }) => void;
    cleanup?: () => void;
}

export declare function useProvideFilterBox(): FilterBoxContext | undefined;

export declare function useProvidePivotData(): PivotDataContext_2;

export declare const VuePivottable: DefineComponent<DefaultPropsType, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DefaultPropsType> & Readonly<{}>, {
    aggregators: Record<string, AggregatorTemplate>;
    cols: string[];
    rows: string[];
    vals: string[];
    aggregatorName: string;
    sorters: any;
    valueFilter: Record<string, any>;
    rowOrder: "key_a_to_z" | "value_a_to_z" | "value_z_to_a";
    colOrder: "key_a_to_z" | "value_a_to_z" | "value_z_to_a";
    derivedAttributes: any;
    renderers: Record<string, RendererDefinition>;
    rendererName: string;
    locale: string;
    languagePack: Record<string, Locale>;
    tableMaxWidth: number;
    aggregatorMap: Record<string, string>;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const VuePivottableUi: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

export { }