@univerjs-pro/sheets-pivot 0.2.7

package/lib/types/models/sheets-pivot-config-model.d.ts

@@ -0,0 +1,58 @@
+import { Nullable, ObjectMatrix, Disposable, ICommandService, Injector, IUniverInstanceService } from '@univerjs/core';
+import { IDataFieldManagerJSON, IPivotRangesInfo, IPivotTableCellData, IPivotTableConfig, IPivotTableMatrixInfo, IPivotTableRangeInfo } from '../const/type';
+
+export declare class SheetsPivotTableConfigModel extends Disposable {
+    private _injector;
+    private _commandService;
+    private _univerInstanceService;
+    private _model;
+    private _collectionConfigModel;
+    private _pivotTableRangeInfo;
+    private _pivotTableMatrixInfo;
+    private _configVersion$;
+    private _pivotInitCompleted$;
+    pivotInitCompleted$: import('rxjs').Observable<boolean>;
+    private _pivotConfigChange$;
+    pivotConfigChange$: import('rxjs').Observable<{
+        unitId: string;
+        subUnitId: string;
+        pivotTableId: string;
+        pivotTableConfig: Nullable<IPivotTableConfig>;
+    }>;
+    private _textInfo;
+    configVersion$: import('rxjs').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): IPivotTableConfig | undefined;
+    getTargetByPivotId(unitId: string, subUnitId: string, pivotTableId: string): import('../const/type').IPivotCellPositionInfo | undefined;
+    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): import('@univerjs-pro/pivot-engine').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 {IPivotRangesInfo} - 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;
+}

package/lib/types/models/sheets-pivot-data-field-manager.d.ts

@@ -0,0 +1,99 @@
+import { ICellData, IRange, IUnitRangeName, IUniverInstanceService, Nullable, ObjectMatrix, Styles, Worksheet } from '@univerjs/core';
+import { IDataFieldValue, IFieldsCollectionJSON, DataField, DataFieldManager, FieldsCollection } from '@univerjs-pro/pivot-engine';
+import { IRuntimeUnitDataType } from '@univerjs/engine-formula';
+import { ICurrentDataMatrix, IDataFieldManagerJSON, IPivotCellPositionInfo, IUnitRangeNameWithSubUnitId } from '../const/type';
+import { SheetsPivotDataSourceModel } from './sheets-pivot-data-source-model';
+
+interface IFeatureDirtyRangeType {
+    [unitId: string]: Nullable<{
+        [sheetId: string]: IRange[];
+    }>;
+}
+export 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: import('@univerjs-pro/pivot-engine').PivotSubtotalTypeEnum) => string;
+    deleteDataField(dataFieldId: string): void;
+    removeCollectionImp(token: string): void;
+    getRangeKey(rangeInfo: IUnitRangeName, colIndex: number): string;
+    getDataFieldByRangeKey(rangeKey: string): DataField;
+    setRangeKeyMap(rangeKey: string, dataFieldId: string): void;
+    addCollectionByJSON(token: string, collectionJSON: IFieldsCollectionJSON, sourceRangeInfo: IUnitRangeNameWithSubUnitId, targetCellInfo: IPivotCellPositionInfo): {
+        collection: FieldsCollection;
+        updateDataFieldList: {
+            index: number;
+            dataField: DataField;
+        }[];
+    };
+    getRangeStartEndInfo(range: IRange, sheet: Worksheet): {
+        startRow: number;
+        startColumn: number;
+        endRow: number;
+        endColumn: number;
+    };
+    /**
+     * - 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): {
+        updateDataFieldList: {
+            index: number;
+            dataField: DataField;
+        }[];
+        collection: FieldsCollection;
+    };
+    _getAutoName(colIndex: number): string;
+    uniqueDataFieldName(name: IDataFieldValue, colIndex: number): string;
+    getCollection(token: string): FieldsCollection;
+    addCollection(token: string, collection: FieldsCollection, sourceRangeInfo: IUnitRangeNameWithSubUnitId, targetCellInfo: IPivotCellPositionInfo): 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): {
+        header: never[];
+        data: never[];
+    } | undefined;
+    refreshData(collection: FieldsCollection, list: {
+        index: number;
+        dataField: DataField;
+    }[], dataRangeInfo: IUnitRangeName): {
+        header: never[];
+        data: never[];
+    } | undefined;
+    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: (string | number | boolean | import('@univerjs-pro/pivot-engine').IDateValue | null | undefined)[][];
+    };
+    toJSON(): IDataFieldManagerJSON;
+    fromJSON(jsonData: IDataFieldManagerJSON): void;
+    dispose(): void;
+}
+export {};

package/lib/types/models/sheets-pivot-data-source-model.d.ts

@@ -0,0 +1,136 @@
+import { IUnitRangeName, Nullable, Disposable, ICommandService, IConfigService, Injector, IResourceManagerService, IUniverInstanceService, LifecycleService } from '@univerjs/core';
+import { DataField, FieldsCollection, IFieldsCollectionJSON, IPivotTableSnapshot, PivotView, PivotTable } from '@univerjs-pro/pivot-engine';
+import { ICollectionChangeInfo, IDataFieldManagerJSON, IPivotCellPositionInfo, IPivotMutationDirtyViewInfo, IPivotTableConfig, IPivotTableJson, IPivotWorkerItemCache, IUnitRangeNameWithSubUnitId, PivotTableOperationEnum } from '../const/type';
+import { SheetsPivotDataFieldManager } from './sheets-pivot-data-field-manager';
+import { IViewTranslateCtx } from './view-util';
+
+export declare class SheetsPivotDataSourceModel extends Disposable {
+    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$: import('rxjs').Observable<ICollectionChangeInfo>;
+    private _viewData$;
+    viewData$: import('rxjs').Observable<{
+        unitId: string;
+        subUnitId: string;
+        pivotTableId: string;
+    }>;
+    private _fieldsCollectionChange$;
+    fieldsCollectionChange$: import('rxjs').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> | {
+        'sheets-pivot.blankValue': string;
+        'sheets-pivot.columnName': string;
+        'sheets-pivot.subTotalText': string;
+        'sheets-pivot.grandTotalText': string;
+        'sheets-pivot.valueText': string;
+        'sheets-pivot.averageName': string;
+        'sheets-pivot.countName': string;
+        'sheets-pivot.countNumsName': string;
+        'sheets-pivot.maxName': string;
+        'sheets-pivot.minName': string;
+        'sheets-pivot.productName': string;
+        'sheets-pivot.stdDevName': string;
+        'sheets-pivot.stdDevpName': string;
+        'sheets-pivot.sumName': string;
+        'sheets-pivot.varName': string;
+        'sheets-pivot.varpName': string;
+        'sheets-pivot.subTotal': string;
+        'sheets-pivot.grandTotal': string;
+        'sheets-pivot.value': string;
+        'sheets-pivot.blank': string;
+        'sheets-pivot.emptyPivot.filter': string;
+        'sheets-pivot.emptyPivot.row': string;
+        'sheets-pivot.emptyPivot.column': string;
+        'sheets-pivot.emptyPivot.values': string;
+    };
+    setTextInfo(textInfo: Record<string, string>): 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;
+    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 | null;
+    /**
+     * - 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): {
+        collection: FieldsCollection;
+        updateDataFieldList: {
+            index: number;
+            dataField: DataField;
+        }[];
+    };
+    /**
+     * - this function just create a collection with data range info, but wil not add it to the dataFieldManager
+     */
+    createCollectionWithDataRange(dataRangeInfo: IUnitRangeNameWithSubUnitId): {
+        updateDataFieldList: {
+            index: number;
+            dataField: DataField;
+        }[];
+        collection: FieldsCollection;
+    };
+    refreshData(collection: FieldsCollection, updateDataFieldList: {
+        index: number;
+        dataField: DataField;
+    }[], dataRangeInfo: IUnitRangeName): 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;
+}

package/lib/types/models/sheets-pivot-table-adaptor-model.d.ts

@@ -0,0 +1,43 @@
+import { Nullable, Disposable, Injector, IUniverInstanceService, LocaleService, ObjectMatrix } from '@univerjs/core';
+import { IPivotRangesInfo, IPivotRenderCache, IPivotTableCellData, IPivotTableConfigChangeInfo, PivotTableOperationEnum } from '../const/type';
+import { SheetsPivotTableConfigModel } from './sheets-pivot-config-model';
+
+export declare class SheetsPivotTableAdaptorModel extends Disposable {
+    private _localeService;
+    private _injector;
+    private _sheetsPivotTableConfigModel;
+    private _univerInstanceService;
+    private _pivotRenderInfoCache;
+    private _pivotRenderValueMatrixCache;
+    private _markDirty$;
+    markDirty$: import('rxjs').Observable<{
+        unitId: string;
+        subUnitId: string;
+    }>;
+    private _viewUpdate$;
+    viewUpdate$: import('rxjs').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);
+    private _initUnitDisposed;
+    private _initLocale;
+    updateRenderCache(config: IPivotTableConfigChangeInfo): {
+        rangeCache: IPivotRangesInfo;
+        matrix: ObjectMatrix<Nullable<IPivotTableCellData>>;
+    } | undefined;
+    clearRenderCache(config: IPivotTableConfigChangeInfo): void;
+    private _ensurePivotItemRenderInfoCache;
+    private _ensurePivotItemRenderValueMatrixCache;
+    getPivotTableCellData(unitId: string, subUnitId: string, row: number, col: number): IPivotTableCellData | undefined;
+    getPivotTableIdByCell(unitId: string, subUnitId: string, startRow: number, startCol: number): string | undefined;
+    getSubUnitPivotMatrix(unitId: string, subUnitId: string): ObjectMatrix<Nullable<IPivotTableCellData>>;
+    getPivotItemRenderInfoCache(unitId: string, subUnitId: string, pivotTableId: string): IPivotRenderCache | undefined;
+    deleteUnitId(unitId: string): void;
+    markDirty(unitId: string, subUnitId: string): void;
+}

package/lib/types/models/view-util.d.ts

@@ -0,0 +1,17 @@
+import { PivotView } from '@univerjs-pro/pivot-engine';
+import { Nullable, ObjectMatrix } from '@univerjs/core';
+import { IPivotCellPositionInfo, IPivotRangesInfo, IPivotTableCellData } from '../const/type';
+
+export interface IViewTranslateCtx {
+    view: Nullable<PivotView>;
+    pivotTableId: string;
+    isEmpty: boolean;
+    targetCellInfo: IPivotCellPositionInfo;
+    textInfo: Record<string, string>;
+}
+interface IViewTranslateResult {
+    matrix: ObjectMatrix<Nullable<IPivotTableCellData>>;
+    rangesCache: IPivotRangesInfo;
+}
+export declare const adjustViewForCalcEngine: (ctx: IViewTranslateCtx) => IViewTranslateResult;
+export {};

package/lib/types/plugin.d.ts

@@ -0,0 +1,21 @@
+import { ICommandService, IConfigService, Injector, Plugin, UniverInstanceType } from '@univerjs/core';
+import { DataSyncPrimaryController } from '@univerjs/rpc';
+import { IUniverSheetsConfig } from '@univerjs/sheets';
+
+interface IUniverSheetsPivotConfig extends IUniverSheetsConfig {
+    isServer?: boolean;
+}
+export declare class UniverSheetsPivotTablePlugin extends Plugin {
+    private _config;
+    readonly _injector: Injector;
+    private readonly _commandService;
+    private readonly _configService;
+    private readonly _dataSyncPrimaryController?;
+    static pluginName: string;
+    static type: UniverInstanceType;
+    constructor(_config: IUniverSheetsPivotConfig, _injector: Injector, _commandService: ICommandService, _configService: IConfigService, _dataSyncPrimaryController?: DataSyncPrimaryController | undefined);
+    _initConfig(): void;
+    onStarting(): void;
+    private _initRegisterCommand;
+}
+export {};

package/lib/types/services/sheets-pivot-rpc.service.d.ts

@@ -0,0 +1,12 @@
+import { Disposable, ICommandService, Injector } from '@univerjs/core';
+import { IGetPivotDataLocalMutationParams, ISendPivotDataLocalMutationParams } from '../const/type';
+
+export declare class SheetsPivotRPCService extends Disposable {
+    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;
+}

package/lib/types/services/sheets-pivot-table.service.d.ts

@@ -0,0 +1,11 @@
+import { Disposable } from '@univerjs/core';
+import { SheetInterceptorService } from '@univerjs/sheets';
+import { SheetsPivotTableAdaptorModel } from '../models/sheets-pivot-table-adaptor-model';
+
+export declare class SheetsPivotTableService extends Disposable {
+    private _sheetInterceptorService;
+    private _sheetsPivotTableAdaptorModel;
+    constructor(_sheetInterceptorService: SheetInterceptorService, _sheetsPivotTableAdaptorModel: SheetsPivotTableAdaptorModel);
+    private _init;
+    private _initViewModelBySheetInterceptor;
+}

package/lib/types/util.d.ts

@@ -0,0 +1,40 @@
+import { Injector, Nullable, ObjectMatrix } from '@univerjs/core';
+import { ILabelViewHeaderMapItem, IPivotViewInfo, PivotTable, PivotSubtotalTypeEnum } from '@univerjs-pro/pivot-engine';
+import { IPivotPanelDataInfo, IPivotRangesInfo, IPivotRenderCache, IPivotTableCellData, IPivotTableConfig } from './const/type';
+import { SheetsPivotDataSourceModel } from './models/sheets-pivot-data-source-model';
+
+export declare const generateDefaultEmptyCache: (textOptions: {
+    filter: string;
+    row: string;
+    column: string;
+    values: string;
+}, startCell: {
+    row: number;
+    col: number;
+}) => {
+    matrixCache: ObjectMatrix<IPivotTableCellData>;
+    rangesCache: IPivotRangesInfo;
+};
+/**
+ * - Get the auto display name of the value field.
+ * @description - which may use prefix text like excel
+ * - the prefix text is create by subtotal type
+ * @param {string} baseName the name without prefix text
+ * @param {PivotSubtotalTypeEnum} subtotalType the type of subtotal to be displayed for this value field.
+ * @returns {string} the auto display name of the value field.
+ */
+export declare function getAutoDisplayName(this: SheetsPivotDataSourceModel, baseName: string, subtotalType: PivotSubtotalTypeEnum): string;
+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 getPivotTableInfo(pivotTable: PivotTable, pivotTableId: string, config: IPivotTableConfig): IPivotPanelDataInfo;
+export declare function flattenObject(inject: Injector, obj: {
+    [key: string]: any;
+}, parentKey?: string, result?: {
+    [key: string]: any;
+}): {
+    [key: string]: any;
+};