/// <reference types="node" resolution-mode="require"/>
import EventEmitter from 'events';
import { DataLoadServiceI, JaqlPanel, JaqlRequest } from '../data-load/types.js';
import { TreeService } from '../tree-structure/index.js';
import { HeaderTreeNode, TreeNode, TreeServiceI } from '../tree-structure/types.js';
import { DivergenceComparator } from './DivergenceComparator.js';
import { AllDataInfo, DataServiceI, InitPageData, PivotTreeNode } from './types.js';
import { PluginService } from './utils/index.js';
import { GlobalStyles, PluginConfig } from './utils/plugins/types.js';
export declare type NodesChunk = {
    list: Array<TreeNode>;
    size: number;
    ready: boolean;
    handled: boolean;
};
export declare const DEFAULT_PAGE_SIZE = 100;
export declare const EVENT_DATA_LOAD = "dataLoad";
export declare const EVENT_DATA_CHUNK_LOADED = "dataChunkLoaded";
export declare const EVENT_DATABAR_CHUNK_LOADED = "dataBarChunkLoaded";
export declare const EVENT_RANGEMINMAX_CHUNK_LOADED = "rangeMinMaxChunkLoaded";
export declare const EVENT_GRAND_CHUNK_LOADED = "grandChunkLoaded";
export declare const EVENT_DATA_FINISH_CHUNK_LOADED = "dataFinishChunkLoaded";
export declare const EVENT_FINISH_CHUNK_LOADED = "finishChunkLoaded";
export declare const EVENT_PROGRESS_ERROR = "progressError";
export declare const EVENT_HEADER_CELL_FORMAT = "headerCellFormat";
export declare const EVENT_DATA_CELL_FORMAT = "dataCellFormat";
export declare const EVENT_TOTAL_ROWS_COUNT = "totalRowsCountLoaded";
export declare const EVENT_TOTAL_COLUMNS_COUNT = "totalColumnsCountLoaded";
export declare const NODES_CHUNK_SIZE_MAX = 1000;
export declare const THROTTLE_TIME_MS = 0;
declare type Options = {
    throttle: Function;
    throttleTime: number;
    PluginService: typeof PluginService;
    skipInternalColorFormatting: boolean;
    subtotalsForSingleRow: boolean;
};
export declare type DataServiceOptions = Partial<Options>;
export declare class DataService implements DataServiceI {
    /**
     *
     *
     * @private
     * EventEmitter instance
     */
    events: EventEmitter;
    /**
     *
     *
     * @private
     *
     * DataLoadServiceI instance
     */
    loadService: DataLoadServiceI;
    /**
     *
     *
     * @private
     *
     * configuration options object
     */
    options: Options;
    /**
     *
     *
     * @private
     *
     * loaded data chunks group
     */
    tempDataChunks: Array<NodesChunk>;
    /**
     *
     * @private
     *
     * last not handled data chunks group index
     */
    lastNotHandledChunkIndex: number;
    /**
     *
     * @private
     *
     * last ready but not handled data chunks group index
     */
    lastReadyNotHandledChunkIndex: number;
    /**
     *
     * @private
     *
     * Current rows nodes
     */
    rowsGrand?: PivotTreeNode;
    /**
     *
      @private */
    rowsTreeService?: TreeServiceI;
    /**
     *
      @private */
    columnsTreeService?: TreeServiceI;
    /**
     *
      @private */
    cornerTreeService?: TreeServiceI;
    /**
      @private */
    pageSize: number;
    /**
     *
      @private */
    isPaginated: boolean;
    /**
     *
     * @private
     *
     * number of loaded pages
     */
    loadedPagesCount: number;
    /**
     *
     * @private
     *
     * state for "loadData" method
     */
    isLoadInProgress: boolean;
    /**
     *
      @private */
    loadPromiseResolve?: Function;
    /**
     *
      @private */
    loadPromiseReject?: Function;
    /**
     *
      @private */
    loadPromiseCache?: InitPageData;
    /**
     *
      @private */
    loadAllPromise?: Promise<any>;
    /**
     *
      @private */
    loadAllPromiseResolve?: Function;
    /**
     *
      @private */
    loadAllPromiseReject?: Function;
    /**
     *
     * @private
     *
     * defines if all data is loaded
     */
    isWholeDataLoaded: boolean;
    /**
     *
     * @private
     *
     * defines that data finish event is happened
     */
    hasDataFinishEvent: boolean;
    /**
     *
     * @private
     *
     * defines that data handler in progress
     */
    isDataHandlerThrottled: boolean;
    /**
     *
     * @private
     *
     * throttled data handler
     */
    onDataHandlerThrottle: (data?: any) => void;
    /**
     *
     * @private
     *
     * jaql request pure metadata
     */
    metadata: Array<JaqlPanel>;
    dataBars: Array<[string, string]> | undefined;
    rangeMinMax: Array<[string, string]> | undefined;
    /**
     *
     * @private
     *
     * service for items indexation divergence
     */
    divergenceComparator: DivergenceComparator;
    /**
     *
     * @private
     *
     * service to apply customers plugins
     */
    pluginService?: PluginService;
    /**
     *
      @private */
    rawJaql?: JaqlRequest;
    /**
     *
     * @private
     *
     * triggered events data storage
     */
    triggeredEventsData: {
        [key: string]: any;
    };
    /**
     *
     * @private
     *
     * plugins handlers
     */
    callPlugins: Array<PluginConfig>;
    /**
     *
     * @private
     *
     * plugins global styles
     */
    globalStyles?: GlobalStyles;
    /**
     *
     * @private
     *
     * actual data columns count
     */
    columnsCount?: number;
    /**
     *
     * @private
     *
     * total data columns count
     */
    totalColumnsCount?: number;
    /**
     *
     * @private
     *
     * actual data rows count
     */
    rowsCount?: number;
    /**
     *
     * @private
     *
     * total data rows count
     */
    totalRowsCount?: number;
    /**
     *
     * @private
     *
     * total CVS records count
     */
    totalRecordsCount?: number;
    /**
     *
     * @private
     *
     * is rows limit reached
     */
    limitReached?: boolean;
    constructor(loadService: DataLoadServiceI, events?: EventEmitter, options?: Partial<Options>);
    destroy(): void;
    /**
     * Subscribe to event notification
     *
     * @param {string} eventName - event name to subscribe
     * @param {Function} callback - event handler
     * @returns {void}
     */
    on(eventName: string, callback: (...args: any[]) => void): void;
    /**
     * Emits event with payload
     *
     * @param {string} eventName - event name to emit
     * @param {Array<any>} payload - event payload
     * @returns {void}
     */
    emit(eventName: string, ...payload: Array<any>): void;
    /**
     * Unsubscribe from event notification
     *
     * @param {string} eventName - event name to unsubscribe from
     * @param {Function} callback - event handler
     * @returns {void}
     */
    off(eventName: string, callback: (...args: any[]) => void): void;
    /**
     * Initialize start data loading
     *
     * @param {JaqlRequest} [jaql] - JAQL request object
     * @param {object} [options] - additional options
     * @param {number} [options.pageSize=100] - page size to wait
     * @param {boolean} [options.isPaginated=false] - defines which type of treeService to return,
     * partial or paginated
     * @param {Array<JaqlPanel>} [options.metadata] - jaql's metadata
     * @param {boolean} [options.cacheResult=false] - cache result for next call or not
     * @returns {Promise<any>} - promise with initial data to render
     */
    loadData(jaql?: JaqlRequest, options?: {
        pageSize?: number;
        isPaginated?: boolean;
        metadata?: Array<JaqlPanel>;
        cacheResult?: boolean;
    }): Promise<InitPageData>;
    /**
     * Sets Promise that resolves after all data loaded
     *
     * @returns {Promise<{ loadedRowsCount: number, totalItemsCount: number }>} - promise with
     * loaded items count
     */
    loadAllData(): Promise<AllDataInfo>;
    /**
     * public method for selecting page and setting new page size
     *
     * @param {number} selected - page number
     * @param {number} pageSize - set page size (optional)
     * @returns {Promise<{rowsTreeService, columnsTreeService, cornerTreeService, isLastPage}>}
     * - returns private method's call with panel's treeServices
     */
    getSelectedPageData(selected: number, pageSize?: number): Promise<InitPageData>;
    /**
     * public method for selecting page by indexes
     *
     * @param {number} from - first row's index
     * @param {number} to - last row's index
     * @param {boolean} lastPage - append grandTotals
     * @returns {Promise<{rowsTreeService, columnsTreeService, cornerTreeService, isLastPage}>}
     * - returns private method's call with panel's treeServices
     */
    getIndexedPageData(from: number, to: number, lastPage?: boolean): Promise<InitPageData>;
    /**
     * Returns current jaql request object
     *
     * @returns {JaqlRequest} - jaql request object
     */
    getJaql(): JaqlRequest;
    /**
     * Defines data structure
     *
     * @returns {boolean} - true - single branch tree
     */
    isSingleRowTree(): boolean;
    /**
     * Set cell process handlers
     *
     * @param {Array<PluginConfig>} handlers - object with target and handler
     * @returns {void}
     */
    setPluginHandlers(handlers: Array<PluginConfig>): void;
    /**
     * Set global styles for all cells
     *
     * @param {GlobalStyles} [styles] - object with target and handler
     * @returns {void}
     */
    setGlobalStyles(styles?: GlobalStyles): void;
    /**
     * Returns current raw jaql request object
     *
     * @returns {JaqlRequest} - composition of required jaql fields
     * @private
     */
    getRawJaql(): JaqlRequest;
    /**
     * Returns current jaql request metadata array
     *
     * @returns {Array<JaqlPanel>} - jaql request metadata
     * @private
     */
    getMetadata(): Array<JaqlPanel>;
    /**
     * Pre-process initial tree structure
     *
     * @param {Array<TreeNode>} items - items to normalize
     * @param {string} type - items types to normalize
     * @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
     */
    preProcessTree(items: TreeNode | Array<TreeNode>, type: string, options?: {
        level?: number;
        measurePath?: {
            [key: string]: string;
        };
    }): Array<PivotTreeNode>;
    /**
     * Post-process final tree structure with formatting event
     *
     * @param {PivotTreeNode} items - list of PivotTreeNode items
     * @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
     * @returns {void}
     */
    postProcessTree(items: Array<PivotTreeNode>, options?: {
        skipFormatEvent?: boolean;
        onlyFormatEvents?: boolean;
        iterateFn?: Function;
    }): void;
    /**
     * Post-process data list with formatting event
     *
     * @param {PivotTreeNode} items - list of PivotTreeNode rows items
     * @param {object} [options] - additional options
     * @param {boolean} [options.skipFormatEvent] - process data list but skip format event trigger
     * @param {boolean} [options.onlyFormatEvents] - process data list with format event
     * trigger only
     * @returns {void}
     */
    postProcessData(items: Array<PivotTreeNode>, options?: {
        skipFormatEvent?: boolean;
        onlyFormatEvents?: boolean;
    }): void;
    /**
     * 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 {TreeNode} originalData - initial data object
     * @returns {PivotTreeNode | Array<PivotTreeNode>} - normalized list of items
     */
    modifyTree(items: Array<PivotTreeNode>, type: string, originalData?: TreeNode): Array<PivotTreeNode>;
    /**
     * method calculates divergence by prev indexes
     *
     * @param {Array<PivotTreeNode>} items - data to modify divergence and apply
     * @returns {void}
     * @private
     */
    applyIndexDivergence(items: Array<PivotTreeNode>): void;
    /**
     * method creates plugin service instance for pivot
     *
     * @param {JaqlRequest} jaql - data to modify divergence and apply
     * @returns {void}
     * @private
     */
    initPluginService(jaql: JaqlRequest): void;
    /**
     * Cancel current loading process
     *
     * @returns {void}
     */
    cancelLoading(): void;
    /**
     * Returns final page size, excluding grand totals rows for example
     *
     * @returns {number} - page size
     * @private
     */
    getPageSize(): number;
    /**
     *
     * Send result for "loadData" function after promise resolve
     *
     * @param {number} loadedCount - count of already loaded rows
     * @returns {{
     *     rowsTreeService: TreeServiceI,
     *     columnsTreeService: TreeServiceI,
     *     corner: TreeNode,
     *     values: TreeNode,
     *     cellsMetadata: Map<string, Metadata>
     * }} - object with initial data
     * @private
     */
    sendInitPage(loadedCount: number): InitPageData;
    /**
     * Sets Page Size and returns Tree Services
     *
     * @param {number} selected - page number -- STARTING FROM 0
     * @param {number} [newPageSize] - set new pageSize
     * @returns {{
     *     rowsTreeService: null,
     *     columnsTreeService: TreeServiceI,
     *     cornerTreeService: TreeServiceI,
     *     isLastPage: boolean
     * }} - returns panel's treeServices
     * @private
     */
    sendPaginatedPage(selected: number, newPageSize?: number): InitPageData;
    /**
     * Returns partial tree by indexes
     *
     * @param {number} paramFrom - start index
     * @param {number} paramTo - stop index
     * @param {boolean} lastPage - append grandTotals
     * @returns {{
     *     rowsTreeService: TreeServiceI,
     *     columnsTreeService: TreeServiceI,
     *     cornerTreeService: TreeServiceI,
     *     isLastPage: boolean
     * }} - returns panel's treeServices
     * @private
     */
    sendPartialPage(paramFrom: number, paramTo: number, lastPage: boolean): InitPageData;
    /**
     *
     * Get current state of tree (not recommended to use before 'loadData')
     *
     * @returns {number} loadedCount - current loaded count of children
     * @private
     */
    getLoadedElementsCount(): number;
    /**
     * Returns total amount items count handled on back-end side
     *
     * @deprecated
     * @returns {number} - items count
     * @private
     */
    getTotalItemsCount(): number;
    /**
     * Getter for pivot table loaded columns number
     *
     * @deprecated
     * @returns {number} loadedCount - current loaded pivot table columns count
     * @private
     */
    getLoadedColumnsCount(): number;
    /**
     * Attach events to load service
     * This is a key function implementing the Observer pattern
     * DataService acts as Observer and subscribes its handlers to various
     * data loading events emitted by the load service.
     *
     *
     * @returns {void}
     * @private
     */
    attachEvent(): void;
    /**
     * Dettach events from load service
     *
     * @returns {void}
     * @private
     */
    detachEvent(): void;
    /**
     * Handler for pivot metadata received event
     *
     * @returns {void}
     */
    onMetadataHandler: () => void;
    onHeadersHandler: (data: HeaderTreeNode) => void;
    onDataHandler: (data: TreeNode | Array<TreeNode>) => void;
    onGrandHandler: (data: TreeNode) => void;
    onFinishHandler: () => void;
    onTotalRowsHandler: (data: any) => void;
    onDataBarsHandler: (chunk: any) => void;
    onRangeMinMaxHandler: (chunk: any) => void;
    onDataFinishHandler: ({ rowsCount }?: {
        rowsCount?: number | undefined;
    }) => void;
    onErrorHandler: (data: any) => void;
    /**
     * Check for enough data loaded and resolve promise of "loadData" function
     *
     * @returns {void}
     * @private
     */
    checkLoadPromise(): void;
    /**
     * @returns {void}
     * @private
     */
    clearLoadAllPromise(): void;
    /**
     * @returns {void}
     * @private
     */
    clearLoadPromise(): void;
    /**
     * Mark finish request
     *
     * @returns {void}
     * @private
     */
    finishRequest(): void;
    /**
     * Clear internal cache in case new JAQL request send
     *
     * @returns {void}
     * @private
     */
    clearCache(): void;
    static getEmptyPage(): InitPageData;
    static fillDataChunks(list: Array<NodesChunk>, node: TreeNode, firstMaxSize?: number, maxSize?: number): void;
    static cloneTreeNode<T>(obj: T, skipChildren?: boolean): T;
    /**
     * @typedef {Function} buildColumnsTreeService
     * @param {HeaderTreeNode} originalColumnsTree
     * @returns {BuildColumnsTreeServiceResult}
     */
    /**
     * @typedef {object} BuildColumnsTreeServiceResult
     * @property {TreeNode|undefined} columnsTree
     * @property {TreeService|undefined} columnsTreeService
     * @property {number} columnsCount
     * @property {number} totalColumnsCount
     */
    /**
     * Creates builder function for building columns tree service
     *
     * @param {object} handlers - build handlers
     * @param {Function} handlers.getJaql - jaql getter
     * @param {Function} [handlers.getRawJaql] - raw jaql getter
     * @param {PluginService} [handlers.pluginService] - plugin service
     * @param {Function} [handlers.applyIndexDivergence] - helper for calculation indexes divergence
     * @param {object} [events] - build event emitters
     * @param {Function} events.emitHeaderCellFormatEvent - emits EVENT_HEADER_CELL_FORMAT event
     * @returns {buildColumnsTreeService} - build function
     */
    static createColumnsTreeServiceBuilder(handlers: {
        getJaql: () => JaqlRequest;
        getRawJaql?: () => JaqlRequest;
        pluginService?: PluginService;
        applyIndexDivergence?: (items: Array<PivotTreeNode>) => void;
    }, events?: {
        emitHeaderCellFormatEvent: (item: PivotTreeNode, panel: JaqlPanel | undefined, jaql: JaqlRequest) => void;
    }): (originalColumnsTree: HeaderTreeNode) => {
        columnsTree: TreeNode | undefined;
        columnsTreeService: TreeService | undefined;
        columnsCount: number;
        totalColumnsCount: number;
    };
    /**
     * @typedef {Function} buildCornerTreeService
     * @param {HeaderTreeNode} originalColumnsTree
     * @returns {BuildCornerTreeServiceResult}
     */
    /**
     * @typedef {object} BuildCornerTreeServiceResult
     * @property {TreeNode|undefined} columnsTree
     * @property {TreeService|undefined} columnsTreeService
     * @property {number} columnsCount
     * @property {number} totalColumnsCount
     */
    /**
     * Creates builder function for building corners tree service
     *
     * @param {object} handlers - build handlers
     * @param {Function} handlers.getJaql - jaql getter
     * @param {Function} [handlers.getRawJaql] - raw jaql getter
     * @param {PluginService} [handlers.pluginService] - plugin service
     * @param {TreeServiceI} [handlers.columnsTreeService] - column tree service
     * @param {object} [events] - build event emitters
     * @param {Function} events.emitHeaderCellFormatEvent - emits EVENT_HEADER_CELL_FORMAT event
     * @returns {buildCornerTreeService} - build function
     */
    static createCornerTreeServiceBuilder(handlers: {
        getJaql: () => JaqlRequest;
        getRawJaql?: () => JaqlRequest;
        pluginService?: PluginService;
        columnsTreeService?: TreeServiceI;
    }, events?: {
        emitHeaderCellFormatEvent: (item: PivotTreeNode, panel: JaqlPanel | undefined, jaql: JaqlRequest) => void;
    }): () => {
        cornerTree: TreeNode | undefined;
        cornerTreeService: TreeService | undefined;
    };
}
export default DataService;