@univerjs-pro/sheets-pivot 0.4.2 → 0.5.0-alpha.0

package/lib/types/index.d.ts

@@ -1,29 +1,1158 @@
-export { applyChangeSet } from './commands/command/util';
-export { AddPivotFieldMutation } from './commands/mutations/add-pivot-field.mutation';
-export { AddPivotTableMutation } from './commands/mutations/add-pivot-table.mutation';
-export { getFieldListByArea } from './commands/mutations/change-apply-util';
-export { RemovePivotFieldMutation } from './commands/mutations/remove-pivot-field.mutation';
-export { RemovePivotTableMutation } from './commands/mutations/remove-pivot-table.mutation';
-export { RenamePivotFieldMutation } from './commands/mutations/rename-pivot-field.mutation';
-export { SetPivotCollapseMutation } from './commands/mutations/set-pivot-collapse.mutation';
-export { SetPivotFieldFormatMutation } from './commands/mutations/set-pivot-field-format.mutation';
-export { SetPivotFilterMutation } from './commands/mutations/set-pivot-filter.mutation';
-export { SetPivotOptionMutation } from './commands/mutations/set-pivot-option.mutation';
-export { SetPivotPositionMutation } from './commands/mutations/set-pivot-position.mutation';
-export { SetPivotSortMutation } from './commands/mutations/set-pivot-sort.mutation';
-export { SetPivotSubtotalTypeMutation } from './commands/mutations/set-pivot-subtotal-type.mutation';
-export { UpdateFieldPositionMutation } from './commands/mutations/update-field-position.mutation';
-export { UpdatePivotFieldSourceInfoMutation } from './commands/mutations/update-pivot-field-source-info.mutation';
-export { UpdatePivotTableSourceRangeMutation } from './commands/mutations/update-pivot-table-source.mutation';
-export { UpdateValuePositionMutation } from './commands/mutations/update-value-position.mutation';
-export { PivotTableViewDirtyMarkOperation } from './commands/operations/pivot-table-dirty-view.operation';
-export { BLANK_ROW_COUNT, getAdjustRangesPosition, PivotDisplayDataType, PositionType, SHEET_PIVOT_TABLE_PLUGIN } from './const/const';
-export { DEFAULT_PIVOT_NUMBER, defaultThemeStyle, transFromCellValue } from './const/const';
-export type { IAddPivotFieldMutationParams, IAddPivotTableCommandParams, IPivotCellPositionInfo, IPivotPanelDataInfo, IPivotPanelSourceList, IPivotPanelTableListItemBase, IPivotRangesInfo, IPivotRenderCache, IPivotTableCellData, IPivotTableConfig, IRangePosition, IRemovePivotFieldMutationParams, IRemovePivotTableMutationParams, IRenamePivotFieldMutationParams, ISetPivotCollapseMutation, ISetPivotFieldFormatMutationParams, ISetPivotFilterMutationParams, ISetPivotOptionMutationParams, ISetPivotPositionMutationParams, ISetPivotSortMutationParams, ISetPivotSubtotalTypeMutationParams, IUnitRangeNameWithSubUnitId, IUpdateFieldPositionMutationParams, IUpdatePivotFieldSourceInfoMutationParams, IUpdateValuePositionMutationParams, } from './const/type';
-export { PivotTableOperationEnum } from './const/type';
-export { SheetsPivotTableConfigModel } from './models/sheets-pivot-config-model';
-export { SheetsPivotDataSourceModel } from './models/sheets-pivot-data-source-model';
-export { SheetsPivotTableAdaptorModel } from './models/sheets-pivot-table-adaptor-model';
-export { UniverSheetsPivotTablePlugin } from './plugin';
-export { SheetsPivotRPCService } from './services/sheets-pivot-rpc.service';
-export { canUsePivot, getPivotCellInfo, getPivotInfoByLicense, getPivotTableInfo, unionPivotViewRange } from './util';
+import { AsyncInterceptorManager } from '@univerjs/core';
+import { CellValueType } from '@univerjs/core';
+import { DataField } from '@univerjs-pro/engine-pivot';
+import { DataFieldManager } from '@univerjs-pro/engine-pivot';
+import { DataSyncPrimaryController } from '@univerjs/rpc';
+import { Disposable as Disposable_2 } from '@univerjs/core';
+import { FieldsCollection } from '@univerjs-pro/engine-pivot';
+import { IAccessor } from '@univerjs/core';
+import { IAsyncInterceptor } from '@univerjs/core/common/interceptor.js';
+import { ICellData } from '@univerjs/core';
+import { ICommand } from '@univerjs/core';
+import { ICommandService } from '@univerjs/core';
+import { IConfigService } from '@univerjs/core';
+import { IDataFieldManagerBaseJSON } from '@univerjs-pro/engine-pivot';
+import { IDataFieldValue } from '@univerjs-pro/engine-pivot';
+import { IExclusiveRangeService } from '@univerjs/sheets';
+import { IFieldsCollectionJSON } from '@univerjs-pro/engine-pivot';
+import { IInterceptor } from '@univerjs/core';
+import { ILabelViewHeaderMapItem } from '@univerjs-pro/engine-pivot';
+import { IMoveRangeMutationParams } from '@univerjs/sheets';
+import { IMutation } from '@univerjs/core';
+import { IMutationInfo } from '@univerjs/core';
+import { Injector } from '@univerjs/core';
+import { InterceptorManager } from '@univerjs/core';
+import { IPivotTableChangeSet } from '@univerjs-pro/engine-pivot';
+import { IPivotTableFilterInfo } from '@univerjs-pro/engine-pivot';
+import { IPivotTableLabelFieldJSON } from '@univerjs-pro/engine-pivot';
+import { IPivotTableOptions } from '@univerjs-pro/engine-pivot';
+import { IPivotTableSnapshot } from '@univerjs-pro/engine-pivot';
+import { IPivotTableSortInfo } from '@univerjs-pro/engine-pivot';
+import { IPivotTableValueFieldJSON } from '@univerjs-pro/engine-pivot';
+import { IPivotViewCellData } from '@univerjs-pro/engine-pivot';
+import { IPivotViewInfo } from '@univerjs-pro/engine-pivot';
+import { IPivotViewJSON } from '@univerjs-pro/engine-pivot';
+import { IPivotViewValueType } from '@univerjs-pro/engine-pivot';
+import { IRange } from '@univerjs/core';
+import { IResourceManagerService } from '@univerjs/core';
+import { IRuntimeUnitDataType } from '@univerjs/engine-formula';
+import { ISetRangeValuesMutationParams } from '@univerjs/sheets';
+import { IStyleData } from '@univerjs/core';
+import { IUndoRedoCommandInfosByInterceptor } from '@univerjs/core';
+import { IUnitRangeName } from '@univerjs/core';
+import { IUniverInstanceService } from '@univerjs/core';
+import { LifecycleService } from '@univerjs/core';
+import { LocaleService } from '@univerjs/core';
+import { Nullable } from '@univerjs/core';
+import { ObjectMatrix } from '@univerjs/core';
+import { Observable } from 'rxjs';
+import { PivotCellStyleTypeEnum } from '@univerjs-pro/engine-pivot';
+import { PivotDataFieldDataTypeEnum } from '@univerjs-pro/engine-pivot';
+import { PivotSubtotalTypeEnum } from '@univerjs-pro/engine-pivot';
+import { PivotTable } from '@univerjs-pro/engine-pivot';
+import { PivotTableFiledAreaEnum } from '@univerjs-pro/engine-pivot';
+import { PivotTableValuePositionEnum } from '@univerjs-pro/engine-pivot';
+import { PivotView } from '@univerjs-pro/engine-pivot';
+import { PivotViewItem } from '@univerjs-pro/engine-pivot';
+import { Plugin as Plugin_2 } from '@univerjs/core';
+import { SheetInterceptorService } from '@univerjs/sheets';
+import { Styles } from '@univerjs/core';
+import { UniverInstanceType } from '@univerjs/core';
+import { Worksheet } from '@univerjs/core';
+
+export declare const AddPivotFieldCommand: ICommand<IAddPivotFieldCommandParams>;
+
+export declare const AddPivotFieldMutation: IMutation<IAddPivotFieldMutationParams>;
+
+export declare const AddPivotTableCommand: ICommand<IAddPivotTableCommandParams>;
+
+export declare const AddPivotTableMutation: IMutation<IAddPivotTableMutationParams>;
+
+export declare function applyChangeSet(_commandService: ICommandService, pivotInfo: IPivotHostInfo, changesets: IPivotTableChangeSet[]): {
+    redos: IMutationInfo<object>[];
+    undos: IMutationInfo<object>[];
+};
+
+export declare const BLANK_ROW_COUNT = 1;
+
+export declare function canUsePivot(ls?: string, pbk?: string): boolean;
+
+declare enum CollectionChangeEnum {
+    add = "add",
+    delete = "delete",
+    update = "update"
+}
+
+export declare const DEFAULT_PIVOT_NUMBER = 1;
+
+export declare const defaultThemeStyle: IThemeStyle;
+
+export declare function generateSetRangeValueMutations(injector: Injector, unitId: string, subUnitId: string, ranges: IRange[]): {
+    setRangeValueUndoMutation: {
+        id: string;
+        params: ISetRangeValuesMutationParams;
+    };
+    setRangeValueRedoMutation: {
+        id: string;
+        params: ISetRangeValuesMutationParams;
+    };
+    shouldClear: boolean;
+};
+
+export declare function getAdjustRangesPosition(startCell: {
+    row: number;
+    col: number;
+}, view: PivotViewItem, singleCellIsRange?: boolean, useLastRowOrCol?: boolean): IRange[];
+
+export declare function getEmptyPivotRanges(cellInfo: IPivotCellPositionInfo): {
+    startRow: number;
+    endRow: number;
+    startColumn: number;
+    endColumn: number;
+}[];
+
+export declare function getFieldListByArea(config: IPivotTableSnapshot, area: PivotTableFiledAreaEnum): string[];
+
+export declare function getInsertRowColMutations(accessor: IAccessor, view: PivotView, cellInfo: IPivotCellPositionInfo, isEmpty: boolean): {
+    undos: IMutationInfo<object>[];
+    redos: IMutationInfo<object>[];
+};
+
+export declare function getPivotCellInfo(row: number, col: number, cellInfo: Nullable<IPivotTableCellData>, pivotTable: PivotTable, pivotItemRenderCache: IPivotRenderCache): {
+    filterId: Nullable<string>;
+    info: Nullable<IPivotViewInfo>;
+    data: Nullable<IPivotTableCellData>;
+    headerInfo: Nullable<ILabelViewHeaderMapItem>;
+} | undefined;
+
+export declare function getPivotInfoByLicense(defaultPivotCount: number, ls?: string, pbk?: string): {
+    count: number;
+    timeValid: boolean;
+};
+
+export declare function getPivotTableInfo(pivotTable: PivotTable, pivotTableId: string, config: IPivotTableConfig): IPivotPanelDataInfo;
+
+export declare interface IAddPivotFieldCommandParams {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    dataFieldId: string;
+    fieldArea: PivotTableFiledAreaEnum;
+    index: number;
+}
+
+export declare interface IAddPivotFieldMutationParams {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    fieldJson: IPivotTableValueFieldJSON | IPivotTableLabelFieldJSON;
+    area: PivotTableFiledAreaEnum;
+    index: number;
+}
+
+export declare interface IAddPivotTableCommandParams {
+    positionType: PositionType;
+    pivotTableId?: string;
+    pivotTableConfig: Omit<IPivotTableConfig, 'fieldsConfig'>;
+}
+
+declare interface IAddPivotTableMutationParams {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    pivotTableConfig: IPivotTableConfig;
+    collectionConfig: IFieldsCollectionJSON;
+}
+
+declare interface ICollectionChangeInfo {
+    token: string;
+    type: CollectionChangeEnum;
+    dataRangeInfo?: IUnitRangeNameWithSubUnitId;
+    unitId?: string;
+    subUnitId?: string;
+    targetCellInfo?: IPivotCellPositionInfo;
+    oldSourceRangeInfo?: IUnitRangeNameWithSubUnitId;
+}
+
+declare interface ICurrentDataMatrix {
+    arrayFormulaCellDataMatrix: ObjectMatrix<Nullable<ICellData>> | undefined;
+    unitDataMatrix: ObjectMatrix<Nullable<ICellData>> | undefined;
+}
+
+declare interface IDataFieldManagerJSON extends IDataFieldManagerBaseJSON {
+    dataRanges: Record<string, IUnitRangeName>;
+}
+
+declare interface IFeatureDirtyRangeType {
+    [unitId: string]: Nullable<{
+        [sheetId: string]: IRange[];
+    }>;
+}
+
+declare interface IGetAddPivotFieldDataParams {
+    dataFieldId: string;
+    fieldArea: PivotTableFiledAreaEnum;
+    index: number;
+}
+
+declare interface IGetAddPivotTableDataParams {
+    sourceRangeInfo: IUnitRangeName & {
+        subUnitId: string;
+    };
+}
+
+declare interface IGetAddPivotTableWithConfigDataParams {
+    sourceRangeInfo: IUnitRangeName & {
+        subUnitId: string;
+    };
+    pivotTableIndexConfig: {
+        filters?: IPivotFieldConfig[];
+        rows?: IPivotFieldConfig[];
+        columns?: IPivotFieldConfig[];
+        values?: IValueFieldConfig[];
+    };
+}
+
+declare interface IGetMovePivotFieldDataParams {
+    fieldId: string;
+    area: PivotTableFiledAreaEnum;
+    index: number;
+}
+
+declare interface IGetPivotCollapseDataParams {
+    tableFieldId: string;
+    collapse: boolean;
+    item: string;
+}
+
+declare interface IGetPivotDataLocalMutationParams extends IPivotLocalMutationBaseParams {
+    version: string;
+    params: {
+        type: PivotDisplayDataType;
+        filter?: IGetPivotFilterPanelDataParams;
+        panel?: IGetPivotPanelDataParams;
+        addPivotField?: IGetAddPivotFieldDataParams;
+        addPivotTable?: IGetAddPivotTableDataParams;
+        movePivotField?: IGetMovePivotFieldDataParams;
+        removePivotField?: IGetRemovePivotFieldDataParams;
+        setPivotCollapse?: IGetPivotCollapseDataParams;
+        setPivotFilter?: IGetPivotFilterDataParams;
+        setPivotSort?: IGetPivotSortDataParams;
+        setPivotSetting?: IGetPivotSettingDataParams;
+        updatePivotSource?: IGetUpdatePivotSourceDataParams;
+        updateValuePosition?: IGetUpdateValuePositionDataParams;
+        addPivotTableWithConfig?: IGetAddPivotTableWithConfigDataParams;
+        drillDown?: IGetPivotDrillDownDataParams;
+    };
+}
+
+declare interface IGetPivotDrillDownDataParams {
+    tuple: string[][];
+}
+
+declare interface IGetPivotFilterDataParams {
+    tableFieldId: string;
+    items: string[];
+    isAll?: boolean;
+}
+
+declare interface IGetPivotFilterPanelDataParams {
+    row: number;
+    col: number;
+    tableFieldId?: string;
+    cellData?: IPivotTableCellData;
+    pivotItemRenderInfoCache?: IPivotRenderCache;
+}
+
+declare interface IGetPivotPanelDataParams {
+    pivotTableId: string;
+}
+
+declare interface IGetPivotSettingDataParams {
+    tableFieldId: string;
+    displayName?: string;
+    format?: string;
+    subtotalType?: PivotSubtotalTypeEnum;
+}
+
+declare interface IGetPivotSortDataParams {
+    tableFieldId: string;
+    info: IPivotTableSortInfo;
+}
+
+declare interface IGetRemovePivotFieldDataParams {
+    fieldIds: string[];
+}
+
+declare interface IGetUpdatePivotSourceDataParams {
+    dataRangeInfo: IUnitRangeNameWithSubUnitId;
+    unitId: string;
+    subUnitId: string;
+}
+
+declare interface IGetUpdateValuePositionDataParams {
+    position: PivotTableValuePositionEnum;
+    index: number;
+}
+
+export declare interface IMovePivotFieldCommandParams {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    fieldId: string;
+    area: PivotTableFiledAreaEnum;
+    index: number;
+}
+
+declare interface IPivotAddPivotTableInfo {
+    view: PivotView;
+    isEmpty: boolean;
+    fieldsConfig: IPivotTableSnapshot;
+    collectionConfig: IFieldsCollectionJSON;
+}
+
+declare interface IPivotAreaViewInfo {
+    rowInfo: Record<string, IPivotViewInfo>;
+    colInfo: Record<string, IPivotViewInfo>;
+    cornerInfo: Record<string, IPivotViewInfo>;
+}
+
+export declare interface IPivotCellPositionInfo {
+    row: number;
+    col: number;
+    unitId: string;
+    subUnitId: string;
+    sheetName?: string;
+}
+
+declare interface IPivotDisplayBaseInfo {
+    view: IPivotViewJSON;
+    changesets: IPivotTableChangeSet[];
+    isEmpty: boolean;
+    pivotTableConfig: IPivotTableConfig;
+}
+
+declare interface IPivotDisplayFilterInfo {
+    tableFieldId: string;
+    pivotTableId: string;
+    items: string[];
+    itemTypes: PivotDataFieldDataTypeEnum[];
+    filterInfo: IPivotTableFilterInfo | undefined;
+    sortInfo: IPivotTableSortInfo | undefined;
+    format: string | undefined;
+}
+
+declare type IPivotDisplayPanelInfo = IPivotPanelDataInfo;
+
+declare interface IPivotDisplayResult {
+    filter?: IPivotDisplayFilterInfo;
+    panel?: IPivotDisplayPanelInfo;
+    addPivotTable?: IPivotAddPivotTableInfo;
+    addPivotField?: IPivotDisplayBaseInfo;
+    movePivotField?: IPivotDisplayBaseInfo;
+    removePivotField?: IPivotDisplayBaseInfo;
+    setPivotCollapse?: IPivotDisplayBaseInfo;
+    setPivotFilter?: IPivotDisplayBaseInfo;
+    setPivotSort?: IPivotDisplayBaseInfo;
+    setPivotSetting?: IPivotDisplayBaseInfo;
+    updatePivotSource?: IPivotUpdatePivotSourceInfo;
+    updateValuePosition?: IPivotDisplayBaseInfo;
+    addPivotTableWithConfig?: IPivotAddPivotTableInfo & {
+        changesets: IPivotTableChangeSet[];
+    };
+    drillDown?: IPivotDrillDownInfo;
+}
+
+export declare interface IPivotDrillDownCommandParams {
+    row: number;
+    col: number;
+}
+
+declare interface IPivotDrillDownInfo {
+    indexes: number[];
+    range: IRange;
+    sourceUnitId: string;
+    sourceSubUnitId: string;
+    formatMap: Record<string, string>;
+}
+
+declare interface IPivotFieldConfig {
+    field: number;
+    selectedItems?: string[];
+}
+
+declare interface IPivotHeaderMap {
+    rowHeaderMap: Record<string, ILabelViewHeaderMapItem>;
+    colHeaderMap: Record<string, ILabelViewHeaderMapItem>;
+}
+
+declare interface IPivotHostInfo {
+    pivotTableId: string;
+    unitId: string;
+    subUnitId: string;
+}
+
+declare interface IPivotLocalMutationBaseParams {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+}
+
+declare interface IPivotMutationDirtyViewInfo {
+    unitId: string;
+    subUnitId: string;
+    token: string;
+    type: PivotTableOperationEnum;
+    pivotConfig?: IPivotTableConfig;
+}
+
+export declare interface IPivotPanelDataInfo {
+    sourceRange: IUnitRangeNameWithSubUnitId;
+    sourceList: IPivotPanelSourceList[];
+    rowFields: IPivotPanelTableListItemBase[];
+    columnFields: IPivotPanelTableListItemBase[];
+    valueFields: IPivotPanelTableListItemBase[];
+    filterFields: IPivotPanelTableListItemBase[];
+    positionInfo: IPivotTableConfig['targetCellInfo'];
+}
+
+export declare interface IPivotPanelSourceList {
+    id: string;
+    dataFieldId: string;
+    name: string;
+    type: PivotDataFieldDataTypeEnum;
+    checked: boolean;
+    pivotTableId: string;
+}
+
+export declare interface IPivotPanelTableListItemBase {
+    tableFieldId: string;
+    displayName: string;
+    dataFieldId: string;
+    format?: string;
+    subTotalType?: PivotSubtotalTypeEnum;
+}
+
+declare interface IPivotPerformCheckParams {
+    cellInfo: IPivotCellPositionInfo;
+    view: PivotView;
+    isEmpty: boolean;
+}
+
+export declare interface IPivotRangesInfo {
+    rowRanges: IRange[];
+    colRanges: IRange[];
+    cornerRanges: IRange[];
+    dataRanges: IRange[];
+    pageRanges: IRange[];
+}
+
+export declare interface IPivotRenderCache {
+    areaInfo?: IPivotAreaViewInfo;
+    rangesInfo?: IPivotRangesInfo;
+    headerMap?: IPivotHeaderMap;
+}
+
+export declare interface IPivotTableCellData {
+    v?: IPivotViewValueType;
+    /**
+     * pivot button type
+     */
+    pbt?: PivotCellStyleTypeEnum;
+    s?: string | IStyleData;
+    /**
+     * filter index
+     */
+    fi?: number;
+    t?: CellValueType;
+}
+
+export declare interface IPivotTableConfig {
+    targetCellInfo: IPivotCellPositionInfo;
+    sourceRangeInfo: IUnitRangeNameWithSubUnitId;
+    themeId?: string;
+    fieldsConfig: IPivotTableSnapshot;
+    isEmpty: boolean;
+}
+
+declare interface IPivotTableConfigChangeInfo {
+    unitId: string;
+    subUnitId: string;
+    type: PivotTableOperationEnum;
+    pivotTableId: string;
+    view?: Nullable<PivotView>;
+}
+
+declare interface IPivotTableJson {
+    dataFieldManagerConfig: Record<string, IDataFieldManagerJSON>;
+    pivotTableConfigs: Record<string, Record<string, Record<string, IPivotTableConfig>>>;
+}
+
+declare interface IPivotTableMatrixInfo {
+    matrix: ObjectMatrix<Nullable<IPivotTableCellData>>;
+    oldMatrix?: ObjectMatrix<Nullable<IPivotTableCellData>>;
+}
+
+declare interface IPivotTableRangeInfo {
+    rangeInfo?: IPivotRangesInfo;
+    oldRangeInfo?: IPivotRangesInfo;
+}
+
+declare interface IPivotTableViewDirtyMarkOperationParams {
+    [unitId: string]: {
+        [sunUnitId: string]: {
+            [token: string]: boolean;
+        };
+    };
+}
+
+declare interface IPivotUpdatePivotSourceInfo {
+    view: IPivotViewJSON;
+    changesets: IPivotTableChangeSet[];
+    isEmpty: boolean;
+    pivotTableConfig: IPivotTableConfig;
+    collectionConfig: IFieldsCollectionJSON;
+    oldCollectionConfig: IFieldsCollectionJSON;
+    deleteIds?: string[];
+}
+
+declare interface IPivotWorkerItemCache {
+    rangeCache?: IPivotRangesInfo;
+    matrix?: ObjectMatrix<Nullable<IPivotTableCellData>>;
+    oldRangeCache?: IPivotRangesInfo;
+    oldMatrix?: ObjectMatrix<Nullable<IPivotTableCellData>>;
+}
+
+export declare type IRangePosition = 'row' | 'col' | 'corner' | 'data';
+
+export declare interface IRemovePivotFieldCommandParams {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    fieldIds: string[];
+}
+
+export declare interface IRemovePivotFieldMutationParams {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    fieldId: string;
+    area: PivotTableFiledAreaEnum;
+    index: number;
+}
+
+export declare interface IRemovePivotTableMutationParams {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+}
+
+export declare interface IRenamePivotFieldMutationParams {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    name: string;
+    fieldId: string;
+}
+
+declare interface ISendPivotConfigLocalMutationParams {
+    unitId: string;
+    subUnitId: string;
+    oldSubUnitId: string;
+    pivotTableId: string;
+    pivotTableConfig: IPivotTableConfig;
+    collectionConfig: IDataFieldManagerJSON;
+}
+
+declare interface ISendPivotDataLocalMutationParams extends IPivotLocalMutationBaseParams {
+    version: string;
+    result: IPivotDisplayResult;
+}
+
+export declare interface ISetPivotCollapseCommandParams {
+    unitId: string;
+    subUnitId: string;
+    row: number;
+    col: number;
+    collapse: boolean;
+}
+
+export declare interface ISetPivotCollapseMutation {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    fieldId: string;
+    collapse: boolean;
+    item?: string;
+}
+
+export declare interface ISetPivotFieldFormatMutationParams {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    fieldId: string;
+    format: string | undefined;
+}
+
+export declare interface ISetPivotFilterCommandParams {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    tableFieldId: string;
+    items: string[];
+    isAll?: boolean;
+}
+
+export declare interface ISetPivotFilterMutationParams {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    fieldId: string;
+    filterInfo: IPivotTableFilterInfo;
+    isAll?: boolean;
+}
+
+export declare interface ISetPivotOptionMutationParams {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    options: IPivotTableOptions;
+}
+
+export declare interface ISetPivotPositionMutationParams {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    targetCellPosition: {
+        row: number;
+        col: number;
+    };
+}
+
+export declare interface ISetPivotSortCommandParams {
+    unitId: string;
+    subUnitId: string;
+    tableFieldId: string;
+    pivotTableId: string;
+    info: IPivotTableSortInfo;
+}
+
+export declare interface ISetPivotSortMutationParams {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    fieldId: string;
+    sortInfo: IPivotTableSortInfo | undefined;
+}
+
+export declare interface ISetPivotSubtotalTypeMutationParams {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    fieldId: string;
+    subtotalType: PivotSubtotalTypeEnum;
+}
+
+declare interface IThemeStyle {
+    rowStyle?: IStyleData;
+    colStyle?: IStyleData;
+    cornerStyle?: IStyleData;
+    pageStyle?: IStyleData;
+    dataStyle?: IStyleData;
+    blankStyle?: IStyleData;
+    subTotalStyle?: IStyleData;
+    leafStyle?: IStyleData;
+    grandTotal?: IStyleData;
+}
+
+export declare type IUnitRangeNameWithSubUnitId = IUnitRangeName & {
+    subUnitId: string;
+};
+
+declare interface IUniverSheetsPivotConfig {
+    notExecuteFormula?: boolean;
+}
+
+export declare interface IUpdateFieldPositionMutationParams {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    fieldId: string;
+    area: PivotTableFiledAreaEnum;
+    index: number;
+    oldArea: PivotTableFiledAreaEnum;
+    oldIndex: number;
+}
+
+declare interface IUpdateInfo {
+    collection: FieldsCollection;
+    updateDataFieldList: {
+        index: number;
+        dataField: DataField;
+    }[];
+}
+
+export declare interface IUpdatePivotFieldSettingCommandParams {
+    unitId: string;
+    subUnitId: string;
+    tableFieldId: string;
+    pivotTableId: string;
+    displayName?: string;
+    format?: string;
+    subtotalType?: PivotSubtotalTypeEnum;
+    tableFieldInfo: IPivotPanelTableListItemBase;
+    dataFieldInfo: IPivotPanelSourceList;
+}
+
+export declare interface IUpdatePivotFieldSourceInfoMutationParams {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    dataFieldId: string;
+    sourceName: string;
+    tableFieldId: string;
+}
+
+export declare interface IUpdatePivotTableSourceRangeCommandParams {
+    unitId: string;
+    subUnitId: string;
+    token: string;
+    dataRangeInfo: IUnitRangeNameWithSubUnitId;
+}
+
+declare interface IUpdatePivotTableSourceRangeMutationParams {
+    pivotTableId: string;
+    deleteIds: string[];
+    collectionJSON: IFieldsCollectionJSON;
+    dataRangeInfo: IUnitRangeNameWithSubUnitId;
+    unitId: string;
+    subUnitId: string;
+}
+
+export declare interface IUpdatePivotValuePositionCommandParams {
+    pivotTableId: string;
+    position: PivotTableValuePositionEnum;
+    index: number;
+}
+
+export declare interface IUpdateValuePositionMutationParams {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    valuePosition: PivotTableValuePositionEnum;
+    index: number;
+}
+
+declare interface IValueFieldConfig {
+    field: number;
+    subTotalType?: PivotSubtotalTypeEnum;
+    formatString?: string;
+}
+
+declare interface IViewTranslateCtx {
+    view: Nullable<PivotView>;
+    pivotTableId: string;
+    isEmpty: boolean;
+    targetCellInfo: IPivotCellPositionInfo;
+    textInfo: Record<string, string>;
+}
+
+export declare const MovePivotFieldCommand: ICommand<IMovePivotFieldCommandParams>;
+
+export declare enum PivotDisplayDataType {
+    Filter = "filter",
+    Panel = "panel",
+    AddPivotField = "addPivotField",
+    AddPivotTableWithConfig = "AddPivotTableWithConfig",
+    AddPivotTable = "addPivotTable",
+    MovePivotField = "movePivotField",
+    RemovePivotField = "removePivotField",
+    SetPivotCollapse = "setPivotCollapse",
+    SetPivotFilter = "setPivotFilter",
+    SetPivotSort = "setPivotSort",
+    SetPivotSetting = "setPivotSetting",
+    UpdatePivotSource = "updatePivotSource",
+    UpdateValuePosition = "updateValuePosition",
+    DrillDown = "drillDown"
+}
+
+export declare const PivotDrillDownCommand: ICommand<IPivotDrillDownCommandParams>;
+
+export declare enum PivotTableOperationEnum {
+    Add = "add",
+    Set = "set",
+    Delete = "delete"
+}
+
+export declare const PivotTableViewDirtyMarkOperation: IMutation<IPivotTableViewDirtyMarkOperationParams>;
+
+export declare enum PositionType {
+    Exiting = "exiting",
+    New = "new"
+}
+
+export declare const RemovePivotFieldCommand: ICommand<IRemovePivotFieldCommandParams>;
+
+export declare const RemovePivotFieldMutation: IMutation<IRemovePivotFieldMutationParams>;
+
+export declare const RemovePivotTableMutation: IMutation<IRemovePivotTableMutationParams>;
+
+export declare const RenamePivotFieldMutation: IMutation<IRenamePivotFieldMutationParams>;
+
+export declare const SetPivotCollapseCommand: ICommand<ISetPivotCollapseCommandParams>;
+
+export declare const SetPivotCollapseMutation: IMutation<ISetPivotCollapseMutation>;
+
+export declare const SetPivotFieldFormatMutation: IMutation<ISetPivotFieldFormatMutationParams>;
+
+export declare const SetPivotFilterCommand: ICommand<ISetPivotFilterCommandParams>;
+
+export declare const SetPivotFilterMutation: IMutation<ISetPivotFilterMutationParams>;
+
+export declare const SetPivotOptionMutation: IMutation<ISetPivotOptionMutationParams>;
+
+export declare const SetPivotPositionMutation: IMutation<ISetPivotPositionMutationParams>;
+
+export declare const SetPivotSortCommand: ICommand<ISetPivotSortCommandParams>;
+
+export declare const SetPivotSortMutation: IMutation<ISetPivotSortMutationParams>;
+
+export declare const SetPivotSubtotalTypeMutation: IMutation<ISetPivotSubtotalTypeMutationParams>;
+
+export declare const SHEET_PIVOT_TABLE_PLUGIN = "SHEET_PIVOT_TABLE_PLUGIN";
+
+declare class SheetsPivotDataFieldManager extends DataFieldManager {
+    /**
+     * the key is pivot table id, the value is the data range info. those data range is one-to-one with the pivot table
+     */
+    rangeKeyMap: Record<string, string>;
+    private _univerInstanceService;
+    _host: SheetsPivotDataSourceModel;
+    constructor(host: SheetsPivotDataSourceModel, univerInstanceService: IUniverInstanceService);
+    initDataRanges(): void;
+    getAutoDisplayNameFunction(): (baseName: string, subtotalType: PivotSubtotalTypeEnum) => string;
+    deleteDataField(dataFieldId: string): void;
+    removeCollectionImp(token: string): void;
+    getRangeKey(rangeInfo: IUnitRangeName, colIndex: number): string;
+    getDataFieldByRangeKey(rangeKey: string): DataField | undefined;
+    setRangeKeyMap(rangeKey: string, dataFieldId: string): void;
+    updateRangeKeyMap(oldRangeKey: string, newRangeKey: string): void;
+    addCollectionByJSON(token: string, collectionJSON: IFieldsCollectionJSON, sourceRangeInfo: IUnitRangeNameWithSubUnitId, targetCellInfo: IPivotCellPositionInfo): IUpdateInfo;
+    getRangeStartEndInfo(range: IRange, sheet: Worksheet): IRange;
+    /**
+     * - when add pivot table, we should create a collection with data range first
+     * @param {IUnitRangeName} dataRangeInfo the data range info
+     * @returns {FieldsCollection} the created collection
+     */
+    createCollectionWithDataRange(dataRangeInfo: IUnitRangeName): IUpdateInfo;
+    _getAutoName(colIndex: number): string;
+    uniqueDataFieldName(name: IDataFieldValue, colIndex: number): string;
+    getCollection(token: string): FieldsCollection;
+    addCollection(token: string, collection: FieldsCollection, sourceRangeInfo: IUnitRangeNameWithSubUnitId, targetCellInfo: IPivotCellPositionInfo): void;
+    handleMoveRange(token: string, sourceRangeInfo: IUnitRangeNameWithSubUnitId): void;
+    getPivotDirtyViewInfo(): {
+        runtimeCellData: IRuntimeUnitDataType;
+        dirtyRanges: IFeatureDirtyRangeType;
+    };
+    getUpdateRangeDeleteIds(token: string, dataRangeInfo: IUnitRangeName): string[] | undefined;
+    /**
+     * get the matrix value from different matrix, when refresh the data source of pivot table
+     * @param matrix the sheet cell matrix
+     * @param arrayFormulaCellDataMatrix the array formula cell data matrix from run time data
+     * @param unitDataMatrix the unit data matrix from runtime data
+     * @param {number} rowIndex - the row index
+     * @param {number} colIndex - the column index
+     * @returns {Nullable<ICellData>} the cell data
+     */
+    getMatrixValue(matrix: ObjectMatrix<Nullable<ICellData>>, arrayFormulaCellDataMatrix: ObjectMatrix<Nullable<ICellData>> | undefined, unitDataMatrix: ObjectMatrix<Nullable<ICellData>> | undefined, rowIndex: number, colIndex: number): Nullable<ICellData>;
+    refreshDataField(dataFieldId: string, dataRangeInfo: IUnitRangeNameWithSubUnitId, index: number, currentDataMatrix?: ICurrentDataMatrix): void;
+    refreshData(collection: FieldsCollection, list: {
+        index: number;
+        dataField: DataField;
+    }[], dataRangeInfo: IUnitRangeNameWithSubUnitId): void;
+    getRangeKeyList(dataRangeInfo: IUnitRangeName): string[];
+    /**
+     * - adjust sheet cell value to the type that pivot engine can recognize
+     * @param {Nullable<ICellData>} cellData the cell data
+     * @param {Styles} styles styles in the workbook
+     * @param {Record<string, any>} patternInfoRecord the pattern info record
+     * @returns {IDataFieldValue} the value to add into the data field
+     */
+    adjustSheetCellData(cellData: Nullable<ICellData>, styles: Styles, patternInfoRecord: Record<string, any>): IDataFieldValue;
+    getRangeData(dataRangeInfo: IUnitRangeName): {
+        header: (string | null)[];
+        data: IDataFieldValue[][];
+    };
+    toJSON(): IDataFieldManagerJSON;
+    fromJSON(jsonData: IDataFieldManagerJSON): void;
+    dispose(): void;
+}
+
+export declare class SheetsPivotDataSourceModel extends Disposable_2 {
+    private readonly _injector;
+    private readonly _univerInstanceService;
+    readonly _lifecycleService: LifecycleService;
+    private readonly _configService;
+    private readonly _commandService;
+    private _resourceManagerService;
+    private _model;
+    private _pivotTableInstanceCache;
+    private _viewData;
+    private _textInfo;
+    private _collectionChange$;
+    collectionChange$: Observable<ICollectionChangeInfo>;
+    private _viewData$;
+    viewData$: Observable<    {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    }>;
+    private _fieldsCollectionChange$;
+    fieldsCollectionChange$: Observable<Record<string, FieldsCollection>>;
+    private _dataFieldManagerCollection;
+    needSameDeleteModel: {
+        deleteUnitId: (unitId: string) => void;
+    }[];
+    /**
+     * - this property is used to store the dirty pivot table collection which need to be marked dirty when mutations is executed
+     */
+    private _queryingMap;
+    constructor(_injector: Injector, _univerInstanceService: IUniverInstanceService, _lifecycleService: LifecycleService, _configService: IConfigService, _commandService: ICommandService, _resourceManagerService: IResourceManagerService);
+    getTextInfo(): Record<string, string>;
+    setTextInfo(textInfo: Record<string, string>): void;
+    handleMoveRange(params: IMoveRangeMutationParams): void;
+    broadcastCollectionChange(info: ICollectionChangeInfo): void;
+    getDataFieldManager(unitId: string): SheetsPivotDataFieldManager;
+    getCollection(unitId: string, token: string): FieldsCollection;
+    getUpdateRangeDeleteIds(unitId: string, token: string, dataRangeInfo: IUnitRangeName): string[] | undefined;
+    private _ensurePivotMap;
+    private _updateModelCache;
+    private _deleteModelCache;
+    private _updatePivotTableInstanceCache;
+    private _deletePivotTableInstanceCache;
+    private _ensureViewDataMap;
+    updateConfig(info: ISendPivotConfigLocalMutationParams): void;
+    updateView(unitId: string, subUnitId: string, type: PivotTableOperationEnum, pivotTableId: string, view: Nullable<PivotView>, pivotConfig: Nullable<IPivotTableConfig>, collectionConfig?: IDataFieldManagerJSON, ignoreDirty?: boolean): void;
+    /**
+     * - the function is used to save the dirty view data and range for formula calculation
+     * @param {IViewTranslateCtx} ctx the dirty context
+     * @param {boolean} ignoreDirty the flag to ignore the dirty view area, only in handleSourceRangeChange , we get a dirty change from the source range change, we need ignore the dirty view area,because the dirty view area has done immediately
+     */
+    updateViewData(ctx: IViewTranslateCtx, ignoreDirty: boolean): void;
+    addPivotTable(unitId: string, subUnitId: string, pivotTableId: string, pivotTable: PivotTable, pivotTableConfig: IPivotTableConfig): void;
+    removePivotTable(unitId: string, subUnitId: string, pivotTableId: string): void;
+    setPivotTable(unitId: string, subUnitId: string, pivotTableId: string, pivotTableConfig: IPivotTableConfig): void;
+    getPivotTableConfig(unitId: string, subUnitId: string, pivotTableId: string): IPivotTableConfig | undefined;
+    /**
+     * - get the pivot table model json config
+     * @param {string} unitId
+     * @param {string} subUnitId
+     * @param {string} pivotTableId - the pivot table id
+     * @returns {IPivotTableSnapshot|undefined} the pivot table model json config
+     */
+    getPivotTableModelConfig(unitId: string, subUnitId: string, pivotTableId: string): IPivotTableSnapshot | undefined;
+    getPivotTableInstance(pivotTableId: string): PivotTable | undefined;
+    deleteUnitId(unitId: string): void;
+    addCollectionByJSON(token: string, collectionJSON: IFieldsCollectionJSON, sourceRangeInfo: IUnitRangeNameWithSubUnitId, targetCellInfo: IPivotCellPositionInfo): IUpdateInfo;
+    /**
+     * - this function just create a collection with data range info, but wil not add it to the dataFieldManager
+     */
+    createCollectionWithDataRange(dataRangeInfo: IUnitRangeNameWithSubUnitId): IUpdateInfo;
+    refreshData(collection: FieldsCollection, updateDataFieldList: {
+        index: number;
+        dataField: DataField;
+    }[], dataRangeInfo: IUnitRangeNameWithSubUnitId): void;
+    removeDataField(unitId: string, dataFieldId: string): void;
+    removeCollections(unitId: string, token: string): void;
+    getSubUnitPivotConfigs(unitId: string, subUnitId: string): Map<string, IPivotTableConfig> | undefined;
+    getTargetByPivotId(pivotTableId: string): {
+        unitId: string;
+        subUnitId: string;
+    } | null;
+    sideEffectUpdateWorkerCache(unitId: string, subUnitId: string, pivotTableId: string, workerCache?: IPivotWorkerItemCache): void;
+    dispose(): void;
+    getViewData(unitId: string, subUnitId: string, pivotTableId: string): IPivotWorkerItemCache | null;
+    addDirtyPivotTable(dirtyInfo: IPivotMutationDirtyViewInfo): void;
+    updateDirtyPivotTable(dirtyInfo: IPivotMutationDirtyViewInfo): void;
+    /**
+     * trigger the pivot table query
+     * @param dirtyInfo
+     */
+    queryDirtyPivotTable(dirtyInfo: IPivotMutationDirtyViewInfo): void;
+    toJSON(unitId: string): IPivotTableJson;
+    fromJSON(jsonData: IPivotTableJson): void;
+    private _initSnapshot;
+}
+
+export declare class SheetsPivotRPCService extends Disposable_2 {
+    private readonly _injector;
+    private readonly _commandService;
+    private _requestResolvers;
+    constructor(_injector: Injector, _commandService: ICommandService);
+    handleAsyncResponse(data: ISendPivotDataLocalMutationParams): void;
+    getPivotDisplayConfig(params: Omit<IGetPivotDataLocalMutationParams, 'version'>): Promise<ISendPivotDataLocalMutationParams>;
+    private _generateUniqueVersion;
+}
+
+export declare class SheetsPivotTableAdaptorModel extends Disposable_2 {
+    private _localeService;
+    private _injector;
+    private _sheetsPivotTableConfigModel;
+    private _univerInstanceService;
+    private readonly _exclusiveRangeService;
+    private _pivotRenderInfoCache;
+    private _pivotRenderValueMatrixCache;
+    private _markDirty$;
+    markDirty$: Observable<    {
+    unitId: string;
+    subUnitId: string;
+    }>;
+    private _viewUpdate$;
+    viewUpdate$: Observable<    {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    rangesCache: IPivotRangesInfo | undefined;
+    valueMatrix: ObjectMatrix<Nullable<IPivotTableCellData>>;
+    type: PivotTableOperationEnum;
+    }>;
+    private _textInfo;
+    constructor(_localeService: LocaleService, _injector: Injector, _sheetsPivotTableConfigModel: SheetsPivotTableConfigModel, _univerInstanceService: IUniverInstanceService, _exclusiveRangeService: IExclusiveRangeService);
+    private _initUnitDisposed;
+    private _initLocale;
+    updateRenderCache(config: IPivotTableConfigChangeInfo): {
+        rangeCache: IPivotRangesInfo | undefined;
+        matrix: ObjectMatrix<Nullable<IPivotTableCellData>>;
+    } | undefined;
+    private _updateRenderEmptyCache;
+    private _createExclusiveRange;
+    clearRenderCache(config: IPivotTableConfigChangeInfo): void;
+    private _ensurePivotItemRenderInfoCache;
+    private _ensurePivotItemRenderValueMatrixCache;
+    getPivotTableCellData(unitId: string, subUnitId: string, row: number, col: number): IPivotTableCellData | undefined;
+    getPivotTableIdByCell(unitId: string, subUnitId: string, row: number, col: number): Nullable<string>;
+    /**
+     * Get pivot table ids that intersect with the range
+     * @param {string} unitId The test unit id of range
+     * @param {string} subUnitId The sub unit id of range
+     * @param {IRange} range The range to check
+     * @returns {string[]} The pivot table ids that intersect with the range
+     */
+    getIntersectsPivotTable(unitId: string, subUnitId: string, range: IRange): string[];
+    getSubUnitPivotMatrix(unitId: string, subUnitId: string): ObjectMatrix<Nullable<IPivotTableCellData>>;
+    getPivotItemRenderInfoCache(unitId: string, subUnitId: string, pivotTableId: string): Nullable<IPivotRenderCache>;
+    deleteUnitId(unitId: string): void;
+    markDirty(unitId: string, subUnitId: string): void;
+}
+
+export declare class SheetsPivotTableConfigModel extends Disposable_2 {
+    private _injector;
+    private _commandService;
+    private _univerInstanceService;
+    private _model;
+    private _collectionConfigModel;
+    private _pivotTableRangeInfo;
+    private _pivotTableMatrixInfo;
+    private _configVersion$;
+    private _pivotInitCompleted$;
+    pivotInitCompleted$: Observable<boolean>;
+    private _pivotConfigChange$;
+    pivotConfigChange$: Observable<    {
+    unitId: string;
+    subUnitId: string;
+    pivotTableId: string;
+    pivotTableConfig: Nullable<IPivotTableConfig>;
+    }>;
+    private _textInfo;
+    configVersion$: Observable<number>;
+    constructor(_injector: Injector, _commandService: ICommandService, _univerInstanceService: IUniverInstanceService);
+    private _initUnitDisposed;
+    setPivotInitCompleted(): void;
+    private _initLocale;
+    getTextInfo(): Record<string, string>;
+    updateViewInfo(unitId: string, subUnitId: string, pivotTableId: string, valueMatrix: ObjectMatrix<Nullable<IPivotTableCellData>>, rangesCache: IPivotRangesInfo | undefined): void;
+    getPivotTableConfig(unitId: string, subUnitId: string, pivotTableId: string): Nullable<IPivotTableConfig>;
+    getTargetByPivotId(unitId: string, subUnitId: string, pivotTableId: string): Nullable<IPivotCellPositionInfo>;
+    getSubUnitPivotConfigs(unitId: string, subUnitId: string): Map<string, IPivotTableConfig> | undefined;
+    updateConfigCache(unitId: string, subUnitId: string, pivotTableId: string, pivotTableConfig: Nullable<IPivotTableConfig>): void;
+    getCollection(unitId: string, pivotTableId: string): IFieldsCollectionJSON | undefined;
+    updateCollectionConfig(unitId: string, collectionConfig: IDataFieldManagerJSON): void;
+    private _ensurePivotMap;
+    private _ensurePivotTableRangeInfo;
+    private _ensurePivotTableMatrixInfo;
+    updatePivotTableRangeInfo(unitId: string, subUnitId: string, pivotTableId: string, rangeInfo: IPivotRangesInfo | undefined): void;
+    updatePivotTableMatrixInfo(unitId: string, subUnitId: string, pivotTableId: string, matrixInfo: ObjectMatrix<Nullable<IPivotTableCellData>>): void;
+    /**
+     * - get the pivot table range info for sheet or calc engine
+     * @param {string} unitId - the unit id
+     * @param {string} subUnitId - the sub unit id
+     * @param {string} pivotTableId - the pivot table id
+     * @returns {IPivotTableRangeInfo} - the pivot table range info
+     */
+    getPivotTableRangeInfo(unitId: string, subUnitId: string, pivotTableId: string): IPivotTableRangeInfo | undefined;
+    /**
+     * - get the pivot table matrix info for sheet or calc engine
+     * @param {string} unitId - the unit id
+     * @param {string} subUnitId - the sub unit id
+     * @param {string} pivotTableId - the pivot table id
+     * @returns {IPivotTableMatrixInfo} - the pivot table matrix info
+     */
+    getPivotTableMatrixInfo(unitId: string, subUnitId: string, pivotTableId: string): IPivotTableMatrixInfo | undefined;
+    deleteUnitId(unitId: string): void;
+}
+
+export declare class SheetsPivotTableService extends Disposable_2 {
+    private _sheetInterceptorService;
+    private _sheetsPivotTableAdaptorModel;
+    readonly asyncInterceptor: AsyncInterceptorManager<{
+        PIVOT_PERFORM_CHECK: IAsyncInterceptor<boolean, IPivotPerformCheckParams>;
+    }>;
+    readonly interceptor: InterceptorManager<{
+        PIVOT_MUTATION_GENERATE: IInterceptor<IUndoRedoCommandInfosByInterceptor, IPivotPerformCheckParams>;
+    }>;
+    constructor(_sheetInterceptorService: SheetInterceptorService, _sheetsPivotTableAdaptorModel: SheetsPivotTableAdaptorModel);
+    private _init;
+    getPivotPerformCheck(params: IPivotPerformCheckParams): Promise<Nullable<boolean>>;
+    private _initViewModelBySheetInterceptor;
+}
+
+export declare function transFromCellValue(cellData: IPivotViewCellData, isValue: boolean, format: string | undefined, textInfo: Record<string, string>): IPivotViewValueType;
+
+export declare const unionPivotViewRange: (rangeInfo: IPivotRangesInfo | undefined) => IRange[];
+
+export declare class UniverSheetsPivotTablePlugin extends Plugin_2 {
+    private readonly _config;
+    readonly _injector: Injector;
+    private readonly _commandService;
+    private readonly _configService;
+    private readonly _dataSyncPrimaryController?;
+    static pluginName: string;
+    static type: UniverInstanceType;
+    constructor(_config: IUniverSheetsPivotConfig | undefined, _injector: Injector, _commandService: ICommandService, _configService: IConfigService, _dataSyncPrimaryController?: DataSyncPrimaryController | undefined);
+    _initConfig(): void;
+    onStarting(): void;
+    private _initRegisterCommand;
+    private _initTimeValid;
+}
+
+export declare const UpdateFieldPositionMutation: IMutation<IUpdateFieldPositionMutationParams>;
+
+export declare const UpdatePivotFieldSettingCommand: ICommand<IUpdatePivotFieldSettingCommandParams>;
+
+export declare const UpdatePivotFieldSourceInfoMutation: IMutation<IUpdatePivotFieldSourceInfoMutationParams>;
+
+export declare const UpdatePivotTableSourceRangeCommand: ICommand<IUpdatePivotTableSourceRangeCommandParams>;
+
+export declare const UpdatePivotTableSourceRangeMutation: IMutation<IUpdatePivotTableSourceRangeMutationParams>;
+
+export declare const UpdatePivotValuePositionCommand: ICommand<IUpdatePivotValuePositionCommandParams>;
+
+export declare const UpdateValuePositionMutation: IMutation<IUpdateValuePositionMutationParams>;
+
+export { }
+
+
+declare module '@univerjs/sheets/facade' {
+    interface FWorkbook extends IFWorkbookSheetsPivotMixin {
+    }
+}