@bizdoc/core 1.14.9 → 1.14.12

package/lib/cube/explore/explore.pane.component.d.ts

@@ -0,0 +1,30 @@
+import { AxesMap } from '../../core/models';
+import { SessionService } from '../../core/session.service';
+import { PanesRouter } from '../../core/slots/router.service';
+import { PaneRef } from '../../core/slots/pane-ref';
+import { TranslateService } from '../../core/translate.service';
+import { CubeService } from '../cube.service';
+import { ExploreItemEvent } from './explore-items.component';
+import { PromptService } from '../../core/prompt.service';
+import { ScopeType } from '../../core/configuration';
+import * as i0 from "@angular/core";
+export declare class CubeExplorePaneComponent {
+    private _pane;
+    private _sb;
+    private _session;
+    private _service;
+    private _translate;
+    private _router;
+    cube: string;
+    axes: AxesMap;
+    pageSize: number;
+    index?: string;
+    scope?: ScopeType;
+    loading: boolean;
+    private _cube;
+    constructor(_pane: PaneRef<CubeExplorePaneComponent>, _sb: PromptService, _session: SessionService, _service: CubeService, _translate: TranslateService, _router: PanesRouter);
+    resize(): void;
+    item(evt: ExploreItemEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeExplorePaneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeExplorePaneComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/cube/explore/item-resolver.service.d.ts

@@ -0,0 +1,20 @@
+import { CubeService } from '../cube.service';
+import { PaneResolve, ParamMap } from '../../core/configuration';
+import { Observable } from 'rxjs';
+import { ActivatedRouteSnapshot, Resolve, Router } from '@angular/router';
+import * as i0 from "@angular/core";
+export declare class ItemResolver implements PaneResolve<any> {
+    private _service;
+    constructor(_service: CubeService);
+    onResolve(params: ParamMap, queryParams: ParamMap): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemResolver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ItemResolver>;
+}
+export declare class ItemResolveService implements Resolve<void | any> {
+    private _service;
+    private _router;
+    constructor(_service: CubeService, _router: Router);
+    resolve(route: ActivatedRouteSnapshot): Observable<void | any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ItemResolveService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ItemResolveService>;
+}

package/lib/cube/explore/item.pane.component.d.ts

@@ -0,0 +1,13 @@
+import { OnInit } from '@angular/core';
+import { PaneRef } from '../../core/slots/pane-ref';
+import * as i0 from "@angular/core";
+/** shows an item on explore. */
+export declare class ExploreItemPaneComponent implements OnInit {
+    private _pane;
+    template: string;
+    model: any;
+    constructor(_pane: PaneRef<ExploreItemPaneComponent>);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExploreItemPaneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExploreItemPaneComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/cube/filter/filter-tags.component.exp.d.ts

@@ -0,0 +1,31 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { DatasourceService } from '../../core/datasource.service';
+import { AxesMap } from '../../core/models';
+import { SessionService } from '../../core/session.service';
+import * as i0 from "@angular/core";
+declare type Tag = {
+    /** axis name */
+    axis: string;
+    key: string | number;
+    /** filter key */
+    value: string | number;
+};
+/** accepts filters */
+export declare class FilterTagsComponent implements OnChanges {
+    private _session;
+    private _ds;
+    axes: AxesMap;
+    cube: string;
+    private _interactive;
+    get interactive(): boolean;
+    set interactive(value: boolean);
+    private _cube;
+    readonly axesChange: EventEmitter<AxesMap>;
+    tags: Tag[];
+    constructor(_session: SessionService, _ds: DatasourceService);
+    ngOnChanges(_: SimpleChanges): void;
+    remove(tag: Tag): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterTagsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterTagsComponent, "bizdoc-cube-tags", never, { "axes": "axes"; "cube": "cube"; "interactive": "interactive"; }, { "axesChange": "axesChange"; }, never, never>;
+}
+export {};

package/lib/cube/filter/filter.component.d.ts

@@ -0,0 +1,44 @@
+import { OnInit, OnDestroy, EventEmitter, OnChanges, AfterViewInit, ChangeDetectorRef, ElementRef, SimpleChanges } from '@angular/core';
+import { FormGroup, FormBuilder } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { AxesMap, CubeAxis } from '../../core/models';
+import { CubeService } from '../cube.service';
+import { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
+import { SessionService } from '../../core/session.service';
+import * as i0 from "@angular/core";
+export declare class CubeFilterComponent implements OnInit, OnChanges, AfterViewInit, OnDestroy {
+    private readonly _service;
+    private readonly _element;
+    private readonly _cd;
+    private readonly _fb;
+    private readonly _session;
+    readonly pattern: RegExp;
+    cube?: string;
+    exclude?: string[];
+    include?: string[];
+    axes: AxesMap;
+    readonly axesChange: EventEmitter<AxesMap>;
+    form: FormGroup;
+    visibleAxes: CubeAxis[];
+    readonly sources: {
+        [axis: string]: Observable<{
+            [key: string]: any;
+        }>;
+    };
+    private _cube;
+    private readonly _decendents;
+    private readonly _ancestors;
+    private readonly _destroy;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private _initialize;
+    focus(): void;
+    /** filter ctor */
+    constructor(_service: CubeService, _element: ElementRef<HTMLDivElement>, _cd: ChangeDetectorRef, _fb: FormBuilder, _session: SessionService);
+    ngAfterViewInit(): void;
+    display(keyValue: any): any;
+    change(axis: string, evt: MatAutocompleteSelectedEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeFilterComponent, "bizdoc-cube-filter", never, { "cube": "cube"; "exclude": "exclude"; "include": "include"; "axes": "axes"; }, { "axesChange": "axesChange"; }, never, never>;
+}

package/lib/cube/grid/grid.component.d.ts

@@ -0,0 +1,59 @@
+import { EventEmitter, OnInit, ElementRef, OnDestroy, SimpleChanges, OnChanges } from "@angular/core";
+import { GroupSettingsModel, Grid, AggregateColumnModel, SelectionSettingsModel, CellSelectingEventArgs, QueryCellInfoEventArgs, ColumnModel } from '@syncfusion/ej2-angular-grids';
+import { AxisClickEvent, CubeViewerComponent } from "../declarations";
+import { AxesMap } from "../../core/models";
+import { CubeService } from "../cube.service";
+import { PromptService } from "../../core/prompt.service";
+import { DatasourceService } from "../../core/datasource.service";
+import { SessionService } from "../../core/session.service";
+import * as i0 from "@angular/core";
+export declare class CubeGridComponent implements OnInit, OnChanges, CubeViewerComponent, OnDestroy {
+    private _session;
+    private _sb;
+    private _ds;
+    private _service;
+    private _elementRef;
+    width: string;
+    height: string;
+    cube: string;
+    set xAxis(val: string[] | string);
+    set series(val: string[] | string);
+    set indices(val: string[] | string);
+    filters?: AxesMap;
+    currencyCode: string;
+    readonly explore: EventEmitter<AxisClickEvent>;
+    loading: boolean;
+    readonly loadingChange: EventEmitter<boolean>;
+    private static nextId;
+    id: string;
+    grid: Grid;
+    dataSource: any[];
+    readonly groupSettings: GroupSettingsModel;
+    readonly selectionSettings: SelectionSettingsModel;
+    aggregates: {
+        columns: AggregateColumnModel[];
+    }[];
+    columns: ColumnModel[];
+    private _xAxis;
+    private _series?;
+    private _indices?;
+    private _rows;
+    private _columns;
+    private _cube;
+    private _prepare;
+    constructor(_session: SessionService, _sb: PromptService, _ds: DatasourceService, _service: CubeService, _elementRef: ElementRef);
+    ngOnInit(): void;
+    /** */
+    ngOnChanges(changes: SimpleChanges): void;
+    execute(): void;
+    private _normalize;
+    private _draw;
+    queryCellInfo(evt: QueryCellInfoEventArgs): void;
+    cellSelecting(evt: CellSelectingEventArgs): void;
+    customAggregate(_: any, column: AggregateColumnModel): number;
+    resize(): void;
+    exportToExcel(title: string): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeGridComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeGridComponent, "bizdoc-cube-grid", never, { "width": "width"; "height": "height"; "cube": "cube"; "xAxis": "xAxis"; "series": "series"; "indices": "indices"; "filters": "filters"; "loading": "loading"; }, { "explore": "explore"; "loadingChange": "loadingChange"; }, never, never>;
+}

package/lib/cube/grid/spreadsheet.component.d.ts

@@ -0,0 +1,62 @@
+import { EventEmitter, OnInit, ElementRef, OnDestroy, SimpleChanges, OnChanges } from "@angular/core";
+import { ColumnModel, RowModel, Spreadsheet, CellStyleModel, SelectEventArgs, AutoFillSettingsModel, ScrollSettingsModel } from "@syncfusion/ej2-angular-spreadsheet";
+import { AxisClickEvent, CubeViewerComponent } from "../declarations";
+import { AxesMap, YAxis } from "../../core/models";
+import { CubeService } from "../cube.service";
+import { PromptService } from "../../core/prompt.service";
+import { TranslateService } from "../../core/translate.service";
+import { DatasourceService } from "../../core/datasource.service";
+import { SessionService } from "../../core/session.service";
+import * as i0 from "@angular/core";
+export declare class CubeSpreadsheetComponent implements OnInit, CubeViewerComponent, OnChanges, OnDestroy {
+    private _session;
+    private _sb;
+    private _service;
+    private _translate;
+    private _ds;
+    private _elementRef;
+    private static nextId;
+    width: string;
+    height: string;
+    cube: string;
+    private _cube;
+    set xAxis(val: string[] | string);
+    yAxis?: YAxis;
+    set series(val: string[] | string);
+    set indices(val: string[] | string);
+    filters?: AxesMap;
+    readonly explore: EventEmitter<AxisClickEvent>;
+    loading: boolean;
+    readonly loadingChange: EventEmitter<boolean>;
+    id: string;
+    spreadsheet: Spreadsheet;
+    dataSource: RowModel[];
+    columns: ColumnModel[];
+    readonly scrollSettings: ScrollSettingsModel;
+    readonly numberStyle: CellStyleModel;
+    readonly autoFillSettings: AutoFillSettingsModel;
+    private _xAxis;
+    private _series?;
+    private _indices?;
+    private _axes;
+    private _cindices;
+    private _yrows;
+    private _xcolumns;
+    private _prepare;
+    private _numberFormat;
+    constructor(_session: SessionService, _sb: PromptService, _service: CubeService, _translate: TranslateService, _ds: DatasourceService, _elementRef: ElementRef);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    resize(): void;
+    execute(): void;
+    private _datatable;
+    private _dataseries;
+    private _draw;
+    select(evt: SelectEventArgs): void;
+    private _filly;
+    private _fillx;
+    exportToExcel(title: string): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeSpreadsheetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeSpreadsheetComponent, "bizdoc-cube-spreadsheet", never, { "width": "width"; "height": "height"; "cube": "cube"; "xAxis": "xAxis"; "yAxis": "yAxis"; "series": "series"; "indices": "indices"; "filters": "filters"; "loading": "loading"; }, { "explore": "explore"; "loadingChange": "loadingChange"; }, never, never>;
+}

package/lib/cube/matrix/matrix.base.d.ts

@@ -0,0 +1,72 @@
+import { Observable } from 'rxjs';
+import { SessionService } from '../../core/session.service';
+import { DatasourceService } from '../../core/datasource.service';
+import { CubeService, Pattern } from '../cube.service';
+import { AxesMap, Cube, CubeAxis } from '../../core/models';
+import { CubeMatrixComponent, SumSettings } from './table.component';
+import * as i0 from "@angular/core";
+export declare abstract class CubeMatrixBase {
+    protected _service: CubeService;
+    private _ds;
+    protected _session: SessionService;
+    table: CubeMatrixComponent;
+    seriesTotalLabel?: string;
+    xAxisTotalLabel?: string;
+    indexAt?: 'series' | 'xAxis';
+    placeAt?: 'leading' | 'trailing';
+    loading: boolean;
+    private _axes;
+    private _originalAxes;
+    set originalAxes(value: AxesMap);
+    get originalAxes(): AxesMap;
+    get axes(): AxesMap;
+    set axes(value: AxesMap);
+    title: string;
+    readonly sources: {
+        [axis: string]: Observable<{
+            key: string;
+            value: any;
+        }[]>;
+    };
+    /** filters */
+    readonly values: AxesMap;
+    filters: CubeAxis[];
+    patterns: Pattern[];
+    pattern: Pattern;
+    indices?: string | string[];
+    xAxis: string;
+    series: string;
+    private _cube;
+    get cube(): string;
+    set cube(value: string);
+    sum?: SumSettings | SumSettings[];
+    /** one or more axis */
+    protected aggregation?: string[] | string;
+    private _selection;
+    protected get selection(): string | string[];
+    protected set selection(value: string | string[]);
+    configuration: Cube;
+    constructor(_service: CubeService, _ds: DatasourceService, _session: SessionService);
+    private _populate;
+    /**
+     *
+     * @param axes
+     */
+    private _combine;
+    /**
+   *
+   * @param value
+   */
+    filter(name: string, value: string | number, title: string): void;
+    private _listen;
+    onFilter(axes: AxesMap): void;
+    /**
+      *
+      * @param pattern
+      */
+    aggregate(pattern: Pattern): void;
+    reset(): void;
+    refresh(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeMatrixBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CubeMatrixBase, never, never, {}, {}, never>;
+}

package/lib/cube/matrix/matrix.mobile.component.d.ts

@@ -0,0 +1,22 @@
+import { OnInit } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { SessionService } from '../../core/session.service';
+import { DatasourceService } from '../../core/datasource.service';
+import { CubeService } from '../cube.service';
+import { AxesMap } from '../../core/models';
+import { WindowTitleService } from '../../core/window-title.service';
+import { CubeMatrixBase } from './matrix.base';
+import { AxisClickEvent } from '../declarations';
+import * as i0 from "@angular/core";
+export declare class CubeMatrixMobileComponent extends CubeMatrixBase implements OnInit {
+    private _title;
+    private _route;
+    private _router;
+    /** cube-info ctor */
+    constructor(_title: WindowTitleService, _route: ActivatedRoute, _router: Router, service: CubeService, ds: DatasourceService, session: SessionService);
+    ngOnInit(): void;
+    onFilter(axes: AxesMap): void;
+    explore(evt: AxisClickEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeMatrixMobileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeMatrixMobileComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/cube/matrix/matrix.pane.component.d.ts

@@ -0,0 +1,36 @@
+import { OnInit } from '@angular/core';
+import { SessionService } from '../../core/session.service';
+import { DatasourceService } from '../../core/datasource.service';
+import { CubeService } from '../cube.service';
+import { PanesRouter } from '../../core/slots/router.service';
+import { PaneRef } from '../../core/slots/pane-ref';
+import { AxesMap } from '../../core/models';
+import { CubeMatrixBase } from './matrix.base';
+import { TranslateService } from '../../core/translate.service';
+import { AxisClickEvent } from '../declarations';
+import { SumSettings } from './table.component';
+import * as i0 from "@angular/core";
+export declare class CubeMatrixPaneComponent extends CubeMatrixBase implements OnInit {
+    private _pane;
+    private _router;
+    private _translate;
+    /** cube-info ctor */
+    constructor(_pane: PaneRef<CubeMatrixPaneComponent, Data>, _router: PanesRouter, _translate: TranslateService, service: CubeService, ds: DatasourceService, session: SessionService);
+    ngOnInit(): void;
+    onFilter(queryParams: AxesMap): void;
+    explore(evt: AxisClickEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeMatrixPaneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeMatrixPaneComponent, "ng-component", never, {}, {}, never, never>;
+}
+interface Data {
+    indices: string | string[];
+    /** */
+    aggregation: string[];
+    sum: SumSettings | SumSettings[];
+    indexAt?: 'series' | 'xAxis';
+    placeAt?: 'leading' | 'trailing';
+    selection?: string | string[];
+    xAxisTotalLabel?: string;
+    seriesTotalLabel?: string;
+}
+export {};

package/lib/cube/matrix/popup.component.d.ts

@@ -0,0 +1,21 @@
+import { OnInit } from '@angular/core';
+import { CubeService } from '../../cube/cube.service';
+import { CubeData } from '../cube-info.service';
+import { SessionService } from '../../core/session.service';
+import { DatasourceService } from '../../core/datasource.service';
+import { CubeMatrixComponent } from './table.component';
+import { PopupRef } from "../../core/popup/popup-ref";
+import { CubeMatrixBase } from './matrix.base';
+import * as i0 from "@angular/core";
+/** cube matrix component*/
+export declare class CubeMatrixPopupComponent extends CubeMatrixBase implements OnInit {
+    private _ref;
+    table: CubeMatrixComponent;
+    preloading: boolean;
+    /** filters */
+    /** cube-info ctor */
+    constructor(_ref: PopupRef, data: CubeData, service: CubeService, ds: DatasourceService, session: SessionService);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeMatrixPopupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeMatrixPopupComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/cube/matrix/table.component.d.ts

@@ -0,0 +1,100 @@
+import { ElementRef, EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { CubeService } from '../cube.service';
+import { SessionService } from '../../core/session.service';
+import { DatasourceService } from '../../core/datasource.service';
+import { PromptService } from '../../core/prompt.service';
+import { AxesMap, Cube, CubeAxis, CubeIndex } from '../../core/models';
+import { ScopeType } from '../../core/configuration';
+import { TranslateService } from '../../core/translate.service';
+import { AxisClickEvent } from '../declarations';
+import * as i0 from "@angular/core";
+/** cube matrix component*/
+export declare class CubeMatrixComponent implements OnChanges {
+    private _sb;
+    private _service;
+    private _session;
+    private _translate;
+    private _ds;
+    readonly PRECISION: string;
+    readonly LANGUAGE: string;
+    CURRENCY: string;
+    SYMBOL: string;
+    tableElement: ElementRef<HTMLTableElement>;
+    seriesTotalLabel: string;
+    xAxisTotalLabel: string;
+    _cube?: string;
+    _xAxis: string;
+    _series: string;
+    _indices?: string[] | string;
+    indexAt: 'series' | 'xAxis';
+    placeAt: 'leading' | 'trailing';
+    scope: ScopeType;
+    private _sum;
+    set sum(val: SumSettings | SumSettings[]);
+    filters: AxesMap;
+    private _interactive;
+    loading: boolean;
+    get interactive(): boolean;
+    set interactive(value: boolean);
+    readonly onExplore: EventEmitter<AxisClickEvent>;
+    readonly loadingChange: EventEmitter<boolean>;
+    rows: HeaderInfo[];
+    columns: HeaderInfo[];
+    indices: CubeIndex[];
+    data: {
+        [series: string]: {
+            [xAxis: string]: string;
+        };
+    };
+    totals: {
+        [xAxis: string]: number;
+    };
+    cube: Cube;
+    xAxis: CubeAxis;
+    series: CubeAxis;
+    private _data;
+    private _prepare;
+    constructor(_sb: PromptService, _service: CubeService, _session: SessionService, _translate: TranslateService, _ds: DatasourceService);
+    ngOnChanges(changes: SimpleChanges): void;
+    private _addindices;
+    private _addsumheaders;
+    refresh(): void;
+    private _serialize;
+    private _clone;
+    private _totals;
+    private _calculatesum;
+    private _stringify;
+    private _format;
+    explore(column: HeaderInfo, row: HeaderInfo): void;
+    export(): void;
+    _move(x: any, y: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeMatrixComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeMatrixComponent, "bizdoc-cube-matrix", never, { "seriesTotalLabel": "seriesTotalLabel"; "xAxisTotalLabel": "xAxisTotalLabel"; "_cube": "cube"; "_xAxis": "xAxis"; "_series": "series"; "_indices": "indices"; "indexAt": "indexAt"; "placeAt": "placeAt"; "scope": "scope"; "sum": "sum"; "filters": "filters"; "loading": "loading"; "interactive": "interactive"; }, { "onExplore": "explore"; "loadingChange": "loadingChange"; }, never, never>;
+}
+export declare type SumSettings = {
+    value?: string | number;
+    axis: 'series' | 'xAxis';
+    title: string;
+    format?: 'percent' | 'currency' | 'number';
+    precision?: string;
+    accumulate?: boolean;
+    explorable?: boolean;
+    calculate?: 'quarter' | 'year' | 'month' | 'accumulate' | CalculateFn;
+};
+export declare interface CalculateFn {
+    (value: string, data: {
+        [series: string]: {
+            [xAxis: string]: number;
+        };
+    }): number;
+}
+declare type HeaderInfo = {
+    key: string;
+    value: any;
+    precision?: string;
+    explorable?: boolean;
+    accumulate?: boolean;
+    sum?: SumSettings;
+    index?: CubeIndex;
+};
+export {};

package/lib/cube/parallel/item.d.ts

@@ -0,0 +1,13 @@
+import { SparklineBorderModel, SparklineMarkerSettingsModel, SparklineTooltipSettingsModel, SparklineType } from '@syncfusion/ej2-angular-charts';
+import { Series } from '../../cube/cube.service';
+/** */
+export declare class Item {
+    chartType: SparklineType;
+    data: Series;
+    palette: string[];
+    fill: string;
+    readonly markerSettings: SparklineMarkerSettingsModel;
+    readonly tooltipSettings: SparklineTooltipSettingsModel;
+    readonly border: SparklineBorderModel;
+    constructor(chartType: SparklineType, data: Series, palette: string[], fill: string);
+}

package/lib/cube/parallel/parallel.component.d.ts

@@ -0,0 +1,52 @@
+import { EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { AxisSettingsModel, IPointRegionEventArgs, SparklineType } from '@syncfusion/ej2-angular-charts';
+import { PromptService } from '../../core/prompt.service';
+import { SessionService } from '../../core/session.service';
+import { CubeService } from '../../cube/cube.service';
+import { AxesMap } from '../../core/models';
+import { Item } from './item';
+import { ScopeType } from '../../core/configuration';
+import * as i0 from "@angular/core";
+/** */
+export declare class CubeParallelComponent implements OnInit, OnChanges, OnDestroy {
+    private _sb;
+    private _service;
+    private _session;
+    filters: AxesMap;
+    xAxis: string | string[];
+    series: string | string[];
+    indices?: string | string[];
+    cube: string;
+    size: number;
+    chartType?: SparklineType;
+    scope?: ScopeType;
+    readonly onExplore: EventEmitter<ExploreEvent>;
+    theme: 'Material' | 'MaterialDark';
+    private _palettes;
+    get palettes(): string[];
+    set palettes(value: string[]);
+    items: Item[];
+    format: string;
+    readonly axisSettings: AxisSettingsModel;
+    width: string;
+    loading: boolean;
+    private _data;
+    private _cube;
+    readonly enableRtl: boolean;
+    private _primary;
+    private readonly _loading;
+    private readonly _destroy;
+    constructor(_sb: PromptService, _service: CubeService, _session: SessionService);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    private _initialize;
+    private _draw;
+    sprklineClick(item: Item, evt: IPointRegionEventArgs): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeParallelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeParallelComponent, "bizdoc-cube-parallel", never, { "filters": "filters"; "xAxis": "xAxis"; "series": "series"; "indices": "indices"; "cube": "cube"; "size": "size"; "chartType": "chartType"; "scope": "scope"; "palettes": "palettes"; }, { "onExplore": "explore"; }, never, never>;
+}
+export interface ExploreEvent {
+    axes: AxesMap;
+    index?: string;
+}