@sisense/sdk-pivot-query-client 2.17.0

package/dist/cjs/data-handling/utils/pivotTransforms.d.ts

@@ -0,0 +1,74 @@
+import { JaqlPanel, JaqlRequest } from '../../data-load/types.js';
+import { TreeNode } from '../../tree-structure/types.js';
+import { PivotDataNode, PivotTreeNode } from '../types.js';
+export declare const insertSubTotals: (items: PivotTreeNode[], originalData: TreeNode | undefined, type: string, jaql: JaqlRequest | undefined, subtotalsForSingleRow: boolean | undefined) => Array<PivotTreeNode>;
+export declare const postProcessSubTotal: (item: PivotTreeNode, jaql?: JaqlRequest) => void;
+export declare const insertGrandTotals: (items: PivotTreeNode[], originalData: TreeNode | undefined, type: string, jaql?: JaqlRequest) => Array<PivotTreeNode>;
+export declare const postProcessGrandTotal: (item: PivotTreeNode, jaql?: JaqlRequest) => void;
+export declare const insertMeasureNodes: (items: PivotTreeNode[], originalData: TreeNode | undefined, type: string, jaql?: JaqlRequest) => Array<PivotTreeNode>;
+export declare const postProcessMeasureNode: (item: PivotTreeNode, jaql?: JaqlRequest) => void;
+export declare const applyColorFormatting: (item: PivotDataNode, rowItem: PivotTreeNode, columnItem: PivotTreeNode, measurePanel?: JaqlPanel) => void;
+/**
+ * Pre-process initial tree structure
+ *
+ * @param {Array<TreeNode>} items - items to normalize
+ * @param {string} type - items types to normalize
+ * @param {JaqlRequest} jaql - jaql request
+ * @param {object} options - additional options
+ * @param {number} [options.level=0] - tree level, for internal use only
+ * @param {object} [options.measurePath={}] - items types to normalize
+ * @returns {Array<PivotTreeNode>} - normalized list of items
+ */
+export declare const preProcessTree: (items: TreeNode | Array<TreeNode>, type: string, jaql: JaqlRequest, options?: {
+    level?: number | undefined;
+    measurePath?: {
+        [key: string]: string;
+    } | undefined;
+} | undefined) => Array<PivotTreeNode>;
+/**
+ * Post-process final tree structure with formatting event
+ *
+ * @param {PivotTreeNode} items - list of PivotTreeNode items
+ * @param {JaqlRequest} jaql - jaql request
+ * @param {object} [options] - additional options
+ * @param {boolean} [options.skipFormatEvent] - process tree but skip format event trigger
+ * @param {boolean} [options.onlyFormatEvents] - process tree with format event trigger only
+ * @param {Function} [options.iterateFn] - iterate function to call for each tree node
+ * @param {Function} [options.emitFn] - transform event emit function to call for each tree node
+ * @returns {void}
+ */
+export declare const postProcessTree: (items: Array<PivotTreeNode>, jaql: JaqlRequest, options?: {
+    skipFormatEvent?: boolean | undefined;
+    onlyFormatEvents?: boolean | undefined;
+    iterateFn?: Function | undefined;
+    emitFn?: ((item: PivotTreeNode, panel: JaqlPanel | undefined, jaql: JaqlRequest) => void) | undefined;
+} | undefined) => void;
+declare const _default: {
+    insertSubTotals: (items: PivotTreeNode<any>[], originalData: TreeNode | undefined, type: string, jaql: JaqlRequest | undefined, subtotalsForSingleRow: boolean | undefined) => PivotTreeNode<any>[];
+    postProcessSubTotal: (item: PivotTreeNode<any>, jaql?: JaqlRequest | undefined) => void;
+    insertGrandTotals: (items: PivotTreeNode<any>[], originalData: TreeNode | undefined, type: string, jaql?: JaqlRequest | undefined) => PivotTreeNode<any>[];
+    postProcessGrandTotal: (item: PivotTreeNode<any>, jaql?: JaqlRequest | undefined) => void;
+    insertMeasureNodes: (items: PivotTreeNode<any>[], originalData: TreeNode | undefined, type: string, jaql?: JaqlRequest | undefined) => PivotTreeNode<any>[];
+    postProcessMeasureNode: (item: PivotTreeNode<any>, jaql?: JaqlRequest | undefined) => void;
+    applyColorFormatting: (item: PivotDataNode<any, import("../../index.js").InputStyles<{
+        [x: string]: string | number | null | undefined;
+    }>>, rowItem: PivotTreeNode<any>, columnItem: PivotTreeNode<any>, measurePanel?: JaqlPanel | undefined) => void;
+    preProcessTree: (items: TreeNode | TreeNode[], type: string, jaql: JaqlRequest, options?: {
+        level?: number | undefined;
+        measurePath?: {
+            [key: string]: string;
+        } | undefined;
+    } | undefined) => PivotTreeNode<any>[];
+    modifyTree: (items: PivotTreeNode<any>[], type: string, jaql: JaqlRequest, options?: {
+        originalData?: TreeNode | undefined;
+        applyIndexDivergence?: ((items: PivotTreeNode<any>[]) => void) | undefined;
+        subtotalsForSingleRow?: boolean | undefined;
+    } | undefined) => PivotTreeNode<any>[];
+    postProcessTree: (items: PivotTreeNode<any>[], jaql: JaqlRequest, options?: {
+        skipFormatEvent?: boolean | undefined;
+        onlyFormatEvents?: boolean | undefined;
+        iterateFn?: Function | undefined;
+        emitFn?: ((item: PivotTreeNode<any>, panel: JaqlPanel | undefined, jaql: JaqlRequest) => void) | undefined;
+    } | undefined) => void;
+};
+export default _default;

package/dist/cjs/data-handling/utils/pivotTransforms.js

@@ -0,0 +1,373 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postProcessTree = exports.preProcessTree = exports.applyColorFormatting = exports.postProcessMeasureNode = exports.insertMeasureNodes = exports.postProcessGrandTotal = exports.insertGrandTotals = exports.postProcessSubTotal = exports.insertSubTotals = void 0;
+const index_js_1 = require("../../tree-structure/utils/index.js");
+const constants_js_1 = require("../constants.js");
+const createPivotTreeNode_js_1 = __importDefault(require("./createPivotTreeNode.js"));
+const jaqlProcessor = __importStar(require("./jaqlProcessor.js"));
+/**
+ * Helper for checking if tree has only one branch on all it's depth levels
+ *
+ * @param {TreeNode} root - tree root node
+ * @param {string} type - tree node type, rows | columns
+ * @returns {boolean} - boolean response
+ */
+function hasTreeMultipleBranches(root, type) {
+    if (!index_js_1.treeNode.hasChildren(root)) {
+        return false;
+    }
+    let forceTotals = false;
+    if (type === constants_js_1.PanelType.COLUMNS && root && root.isPart) {
+        forceTotals = true;
+    }
+    const children = index_js_1.treeNode.getChildren(root);
+    if (children.length > 1 || forceTotals) {
+        return true;
+    }
+    const [singleChild] = children;
+    return hasTreeMultipleBranches(singleChild);
+}
+/**
+ * Helper for checking if node value is empty
+ *
+ * @param {*} value - node value
+ * @returns {boolean} - is empty flag
+ */
+function isEmptyValue(value) {
+    return value === null || value === undefined;
+}
+const insertSubTotals = (items, originalData, type, jaql, // eslint-disable-line no-unused-vars
+subtotalsForSingleRow) => {
+    const result = [];
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    items.forEach((item) => {
+        // keep original item
+        result.push(item);
+        if (index_js_1.treeNode.hasChildren(item)) {
+            const newChildrenNodes = index_js_1.treeNode.getChildren(item);
+            const newChildren = (0, exports.insertSubTotals)(newChildrenNodes, originalData, type, jaql, subtotalsForSingleRow);
+            index_js_1.treeNode.setChildren(item, newChildren);
+            // check if item has subtotal
+            let hasSubTotals = false;
+            if (subtotalsForSingleRow || hasTreeMultipleBranches(item, type)) {
+                if (type === constants_js_1.PanelType.COLUMNS) {
+                    if (typeof item.index !== 'undefined' && item.index > -1) {
+                        hasSubTotals = true;
+                    }
+                }
+                else if (type === constants_js_1.PanelType.ROWS) {
+                    if (typeof item.data !== 'undefined') {
+                        hasSubTotals = true;
+                    }
+                }
+            }
+            if (hasSubTotals) {
+                const { value, index, data, jaqlIndex, measurePath } = item;
+                let roughSubTotalItem;
+                if (type === constants_js_1.PanelType.COLUMNS) {
+                    roughSubTotalItem = index_js_1.treeNode.create(value, undefined, undefined, index);
+                }
+                else if (type === constants_js_1.PanelType.ROWS) {
+                    roughSubTotalItem = index_js_1.treeNode.create(value, undefined, data);
+                }
+                if (roughSubTotalItem) {
+                    const subTotalItem = (0, createPivotTreeNode_js_1.default)(roughSubTotalItem, type);
+                    subTotalItem.userType = constants_js_1.UserType.SUB_TOTAL;
+                    subTotalItem.jaqlIndex = jaqlIndex;
+                    subTotalItem.measurePath = measurePath;
+                    subTotalItem.master = item;
+                    result.push(subTotalItem);
+                }
+            }
+        }
+    });
+    return result;
+};
+exports.insertSubTotals = insertSubTotals;
+// eslint-disable-next-line no-unused-vars
+const postProcessSubTotal = (item, jaql) => {
+    if (item.userType === constants_js_1.UserType.SUB_TOTAL) {
+        if (item.master) {
+            item.measurePath = item.master.measurePath;
+        }
+    }
+};
+exports.postProcessSubTotal = postProcessSubTotal;
+const insertGrandTotals = (items, originalData, type, jaql) => {
+    const result = items;
+    if (type === constants_js_1.PanelType.COLUMNS && originalData) {
+        const rootItem = (0, createPivotTreeNode_js_1.default)(originalData);
+        const hasGrandTotals = typeof rootItem.index === 'number';
+        if (hasGrandTotals) {
+            const valuesTree = jaqlProcessor.getMetadataTree(jaql, constants_js_1.PanelType.MEASURES);
+            index_js_1.treeNode.getChildren(valuesTree).forEach((valueNode, i) => {
+                const roughGrandTotalItem = Object.assign(Object.assign({}, valueNode), { index: (rootItem.index || 0) + i });
+                const grandTotalItem = (0, createPivotTreeNode_js_1.default)(roughGrandTotalItem, type);
+                grandTotalItem.userType = constants_js_1.UserType.GRAND_TOTAL;
+                // set measure jaqlIndex
+                grandTotalItem.measureJaqlIndex = grandTotalItem.jaqlIndex;
+                result.push(grandTotalItem);
+            });
+        }
+    }
+    return result;
+};
+exports.insertGrandTotals = insertGrandTotals;
+// eslint-disable-next-line no-unused-vars
+const postProcessGrandTotal = (item, jaql) => {
+    if (item.userType === constants_js_1.UserType.GRAND_TOTAL) {
+        item.measurePath = undefined;
+        if (item.metadataType === constants_js_1.PanelType.ROWS) {
+            item.parent = undefined;
+            item.jaqlIndex = 0;
+        }
+    }
+};
+exports.postProcessGrandTotal = postProcessGrandTotal;
+const insertMeasureNodes = (items, originalData, type, jaql) => {
+    let result = items;
+    if (type === constants_js_1.PanelType.COLUMNS) {
+        const valuesTree = jaqlProcessor.getMetadataTree(jaql, constants_js_1.PanelType.MEASURES);
+        const count = index_js_1.treeNode.getChildLength(valuesTree);
+        const columnsOptions = { maxLevel: 0 };
+        const columnsLastLevel = index_js_1.treeNode.getLastLevelNodes(result, [], 0, columnsOptions);
+        if (count > 1) {
+            // add values nodes at the last level
+            columnsLastLevel.forEach((lastNode) => {
+                if (lastNode.userType === constants_js_1.UserType.GRAND_TOTAL) {
+                    return;
+                }
+                const lastChildren = index_js_1.treeNode.getChildren(valuesTree);
+                const lastFinalChildren = [];
+                for (let i = 0; i < lastChildren.length; i += 1) {
+                    if (typeof lastNode.maxChilds === 'number' && i >= lastNode.maxChilds) {
+                        // eslint-disable-next-line no-continue
+                        continue;
+                    }
+                    const roughMeasureItem = Object.assign(Object.assign({}, lastChildren[i]), { index: (lastNode.index || 0) + i, measurePath: lastNode.measurePath });
+                    const measureItem = (0, createPivotTreeNode_js_1.default)(roughMeasureItem, constants_js_1.PanelType.MEASURES);
+                    measureItem.userType = constants_js_1.UserType.MEASURE_BOTTOM;
+                    // set measure jaqlIndex
+                    measureItem.measureJaqlIndex = measureItem.jaqlIndex;
+                    lastFinalChildren.push(measureItem);
+                }
+                lastNode.minLevel = columnsOptions.maxLevel;
+                index_js_1.treeNode.setChildren(lastNode, lastFinalChildren);
+            });
+        }
+        else if (count === 1) {
+            // add value node at the first level
+            const valueNode = index_js_1.treeNode.getChildren(valuesTree)[0];
+            if (valueNode) {
+                const roughMeasureItem = Object.assign({}, valueNode);
+                const measureItem = (0, createPivotTreeNode_js_1.default)(roughMeasureItem, constants_js_1.PanelType.MEASURES);
+                measureItem.userType = constants_js_1.UserType.MEASURE_TOP;
+                index_js_1.treeNode.setChildren(measureItem, result);
+                result = [measureItem];
+                // set measure jaqlIndex
+                columnsLastLevel.forEach((lastNode) => {
+                    lastNode.measureJaqlIndex = valueNode.jaqlIndex;
+                });
+            }
+        }
+    }
+    return result;
+};
+exports.insertMeasureNodes = insertMeasureNodes;
+const postProcessMeasureNode = (item, jaql) => {
+    if (!index_js_1.treeNode.hasChildren(item) && typeof item.measureJaqlIndex !== 'undefined') {
+        jaqlProcessor.markSortedNode(jaql, item);
+    }
+};
+exports.postProcessMeasureNode = postProcessMeasureNode;
+const applyColorFormatting = (item, rowItem, columnItem, measurePanel) => {
+    let style = {};
+    if (rowItem.userType === constants_js_1.UserType.SUB_TOTAL ||
+        rowItem.userType === constants_js_1.UserType.GRAND_TOTAL ||
+        columnItem.userType === constants_js_1.UserType.SUB_TOTAL ||
+        columnItem.userType === constants_js_1.UserType.GRAND_TOTAL ||
+        (columnItem.parent && columnItem.parent.userType === constants_js_1.UserType.SUB_TOTAL) ||
+        (columnItem.parent && columnItem.parent.userType === constants_js_1.UserType.GRAND_TOTAL)) {
+        // ignore SUB_TOTAL & GRAND_TOTAL
+        return;
+    }
+    const colorFormat = (measurePanel && measurePanel.format && measurePanel.format.color) || null;
+    if (!colorFormat) {
+        return;
+    }
+    const { value, cf = -1 } = item;
+    if (colorFormat.type === constants_js_1.ColorFormatType.COLOR) {
+        if (colorFormat.color && colorFormat.color !== 'transparent') {
+            style.backgroundColor = colorFormat.color;
+        }
+    }
+    if (colorFormat.type === constants_js_1.ColorFormatType.CONDITION) {
+        if (colorFormat.conditions && colorFormat.conditions.length) {
+            for (let i = 0, c = colorFormat.conditions.length; i < c; i += 1) {
+                // handle empty value case
+                if (isEmptyValue(value)) {
+                    break;
+                }
+                // handle condition case
+                const conditions = colorFormat.conditions || [];
+                const { color } = conditions[i] || {};
+                if (color && cf === i) {
+                    style.backgroundColor = color;
+                    break;
+                }
+            }
+        }
+    }
+    if (Object.keys(style).length > 0) {
+        item.style = item.style || {};
+        Object.assign(item.style, style);
+    }
+    style = undefined;
+};
+exports.applyColorFormatting = applyColorFormatting;
+/**
+ * Pre-process initial tree structure
+ *
+ * @param {Array<TreeNode>} items - items to normalize
+ * @param {string} type - items types to normalize
+ * @param {JaqlRequest} jaql - jaql request
+ * @param {object} options - additional options
+ * @param {number} [options.level=0] - tree level, for internal use only
+ * @param {object} [options.measurePath={}] - items types to normalize
+ * @returns {Array<PivotTreeNode>} - normalized list of items
+ */
+const preProcessTree = (items, type, jaql, options) => {
+    const result = [];
+    const { level = 0, measurePath = {} } = options || {};
+    let finalItems;
+    if (Array.isArray(items)) {
+        finalItems = items;
+    }
+    else {
+        finalItems = index_js_1.treeNode.getChildren(items);
+    }
+    const panels = jaqlProcessor.getMetadataPanels(jaql, type);
+    const panel = panels[level];
+    const jaqlIndex = panel ? (panel.field || { index: Infinity }).index : undefined;
+    finalItems.forEach((item) => {
+        const pivotItem = (0, createPivotTreeNode_js_1.default)(item, type);
+        pivotItem.jaqlIndex = jaqlIndex;
+        if (typeof jaqlIndex !== 'undefined') {
+            pivotItem.measurePath = Object.assign(Object.assign({}, measurePath), { [jaqlIndex]: pivotItem.value });
+        }
+        // keep original item
+        result.push(pivotItem);
+        // check if item has children
+        if (index_js_1.treeNode.hasChildren(pivotItem)) {
+            const newChildrenNodes = index_js_1.treeNode.getChildren(pivotItem);
+            const childOptions = {
+                level: level + 1,
+                measurePath: pivotItem.measurePath,
+            };
+            const newChildren = (0, exports.preProcessTree)(newChildrenNodes, type, jaql, childOptions);
+            index_js_1.treeNode.setChildren(pivotItem, newChildren);
+        }
+    });
+    return result;
+};
+exports.preProcessTree = preProcessTree;
+/**
+ * Post-process final tree structure with formatting event
+ *
+ * @param {PivotTreeNode} items - list of PivotTreeNode items
+ * @param {JaqlRequest} jaql - jaql request
+ * @param {object} [options] - additional options
+ * @param {boolean} [options.skipFormatEvent] - process tree but skip format event trigger
+ * @param {boolean} [options.onlyFormatEvents] - process tree with format event trigger only
+ * @param {Function} [options.iterateFn] - iterate function to call for each tree node
+ * @param {Function} [options.emitFn] - transform event emit function to call for each tree node
+ * @returns {void}
+ */
+const postProcessTree = (items, jaql, options) => {
+    const { skipFormatEvent = false, onlyFormatEvents = false, iterateFn, emitFn } = options || {};
+    items.forEach((item) => {
+        if (iterateFn) {
+            iterateFn(item);
+        }
+        if (skipFormatEvent || !onlyFormatEvents) {
+            (0, exports.postProcessSubTotal)(item, jaql);
+            (0, exports.postProcessGrandTotal)(item, jaql);
+            (0, exports.postProcessMeasureNode)(item, jaql);
+        }
+        if (emitFn && (onlyFormatEvents || !skipFormatEvent)) {
+            const panel = jaqlProcessor.getMetadataPanelByIndex(jaql, item.jaqlIndex, item.metadataType || '');
+            emitFn(item, panel, jaql);
+        }
+        if (index_js_1.treeNode.hasChildren(item)) {
+            const itemChilds = index_js_1.treeNode.getChildren(item);
+            (0, exports.postProcessTree)(itemChilds, jaql, options);
+        }
+    });
+};
+exports.postProcessTree = postProcessTree;
+/**
+ * Modify tree structure for subtotals and grand totals and some customization
+ *
+ * @param {Array<PivotTreeNode>} items - base items to modify
+ * @param {string} type - items types to normalize
+ * @param {JaqlRequest} jaql - initial data object
+ * @param {object} [options] - modify options
+ * @param {TreeNode} [options.originalData] - initial data object
+ * @param {Function} [options.applyIndexDivergence] - helper for applying index divergence
+ * @returns {PivotTreeNode | Array<PivotTreeNode>} - normalized list of items
+ */
+const modifyTree = (items, type, jaql, options) => {
+    const { originalData, applyIndexDivergence, subtotalsForSingleRow } = options || {};
+    // items odd|even apply
+    if (applyIndexDivergence) {
+        applyIndexDivergence(items);
+    }
+    // insert subTotal
+    let modifiedItems = (0, exports.insertSubTotals)(items, originalData, type, jaql, subtotalsForSingleRow);
+    // insert grandTotal
+    modifiedItems = (0, exports.insertGrandTotals)(modifiedItems, originalData, type, jaql);
+    // measure nodes
+    modifiedItems = (0, exports.insertMeasureNodes)(modifiedItems, originalData, type, jaql);
+    index_js_1.treeNode.iterateThroughTree(modifiedItems, (item, parent) => {
+        item.parent = parent;
+    });
+    return modifiedItems;
+};
+exports.default = {
+    insertSubTotals: exports.insertSubTotals,
+    postProcessSubTotal: exports.postProcessSubTotal,
+    insertGrandTotals: exports.insertGrandTotals,
+    postProcessGrandTotal: exports.postProcessGrandTotal,
+    insertMeasureNodes: exports.insertMeasureNodes,
+    postProcessMeasureNode: exports.postProcessMeasureNode,
+    applyColorFormatting: exports.applyColorFormatting,
+    preProcessTree: exports.preProcessTree,
+    modifyTree,
+    postProcessTree: exports.postProcessTree,
+};

package/dist/cjs/data-handling/utils/plugins/PluginService.d.ts

@@ -0,0 +1,135 @@
+import { JaqlRequest } from '../../../data-load/types.js';
+import { ListOfPanelTypes } from '../../constants.js';
+import { PivotTreeNode } from '../../types.js';
+import { CellItem, DimensionMetadata, GlobalStyles, MeasureMetadata, Metadata, PluginConfig } from './types.js';
+export declare class PluginService {
+    /**
+     * Handlers to apply for pivot cells
+     *
+     * @private
+     * */
+    plugins: Array<PluginConfig>;
+    /** @private global plugins config */
+    globalStyles?: GlobalStyles;
+    /** @private */
+    jaql: JaqlRequest;
+    /**
+     * Object to store indexes for data groups
+     */
+    private indexHelper;
+    /**
+     * Cache columns metadata after handling column tree node
+     *
+     * @private
+     * */
+    columnsMetadata: Array<{
+        metadata: Array<DimensionMetadata>;
+        type: Array<string>;
+    }>;
+    metadataCache: Map<string, Metadata>;
+    constructor(plugins: Array<any>, jaql: JaqlRequest, globalStyles?: GlobalStyles);
+    /**
+     * Get array of panels by type
+     *
+     * @param {ListOfPanelTypes} jaqlPanel - type of panels to return measures|columns|rows
+     * @returns {Array<any>} row level of measures in column tree
+     */
+    getJaqlPanels(jaqlPanel: ListOfPanelTypes): import("../../../data-load/types.js").JaqlPanel[];
+    /**
+     * Calculate level of measures in column tree
+     *
+     * @returns {number} row level of measures in column tree
+     */
+    getMeasuresLevel(): number;
+    /**
+     * Get count of row panels
+     *
+     * @returns {void}
+     */
+    getRowsColumnLength(): number;
+    /**
+     * Get count of row panels
+     *
+     * @param {Array<string>} types - array of types from current cell
+     * @returns {void}
+     */
+    getTotalTypes(types: Array<string>): Array<any>;
+    /**
+     * Calculate measure index and get panel metadata
+     *
+     * @param {number} index - measure index in row
+     * @returns {MeasureMetadata} measure metadata
+     */
+    getMeasureMetaByIndex(index: number): MeasureMetadata | undefined;
+    resetRowStartFrom(): void;
+    applyToColumns(columnTreeChildren: Array<PivotTreeNode>): void;
+    /**
+     * Apply plugins to columns values and cache metadata for measure handler
+     *
+     * @param {Array<any>} columnTreeChildren - measure index in row
+     * @param {object} indexes - measure index in row
+     * @returns {void}
+     */
+    private _applyToColumns;
+    /**
+     * Apply plugins to corner tree headers
+     *
+     * @param {any} cornerTree - measure index in row
+     * @returns {void}
+     */
+    applyToHeaders(cornerTree: PivotTreeNode): void;
+    applyToRows(rowTreeChildren: Array<PivotTreeNode>): void;
+    static getRowStartFromForPage(numberOfRows: number, numberOfMeasures: number, numberOfColumns: number): number;
+    /**
+     * Apply plugins to rows panels
+     *
+     * @param {Array<PivotTreeNode>} rowTreeChildren - measure index in row
+     * @returns {void}
+     */
+    private _applyToRows;
+    /**
+     * Apply plugins to value panels
+     *
+     * @param {Array<any>} values - measure index in row
+     * @param {object} rowData - row data
+     * @param {Array<string>} rowData.type - row types
+     * @param {Array<DimensionMetadata>} rowData.metadata - metadata of current row
+     * @param {object} indexes - parent indexes in tree
+     * @param {number} indexes.rowIndex - current row index
+     * @param {number} indexes.colIndex - colIndex of last row cell to calculate value cell index
+     * @returns {void}
+     */
+    applyToValues(values: Array<any>, rowData: {
+        type: Array<string>;
+        metadata: Array<DimensionMetadata>;
+    }, indexes: {
+        rowIndex: number;
+        colIndex: number;
+    }): void;
+    /**
+     * Add cell metadata to map for click/hover APIs
+     *
+     * @param {Metadata} metadata - cell metadata
+     * @param {CellItem} cellItem - cell content
+     * @param {number} rowIndex - cell row index
+     * @param {number} colIndex - cell column index
+     * @returns {void}
+     */
+    addToMetadata(metadata: Metadata, cellItem: CellItem, rowIndex: number, colIndex: number): void;
+    /**
+     * Apply global config to cells
+     *
+     * @param {CellItem} item - cell item to update by plugin
+     * @returns {void}
+     */
+    applyGlobal(item: CellItem): void;
+    /**
+     * Apply plugins to rows panels
+     *
+     * @param {Metadata} metadata - cell metadata
+     * @param {CellItem} item - cell item to update by plugin
+     * @returns {void}
+     */
+    apply(metadata: Metadata, item: CellItem): void;
+}
+export default PluginService;