@bizdoc/core 1.14.9 → 1.14.10

package/lib/core/window-title.service.d.ts

@@ -0,0 +1,21 @@
+import { HubService } from './hub.service';
+import { BizDocConfig } from '../core/configuration';
+import { AccountService } from './account.service';
+import { TranslateService } from './translate.service';
+import * as i0 from "@angular/core";
+export declare class WindowTitleService {
+    private config;
+    private _inFocus;
+    private _isActive;
+    private _mode;
+    private _task;
+    private _message;
+    private _title;
+    private readonly _appTitle;
+    constructor(config: BizDocConfig, users: AccountService, translate: TranslateService, hub: HubService);
+    set(value: string): void;
+    private _show;
+    private _clear;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WindowTitleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WindowTitleService>;
+}

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

@@ -0,0 +1,63 @@
+import { EventEmitter, OnDestroy, OnInit, ElementRef, SimpleChanges, OnChanges } from '@angular/core';
+import { AccumulationDataLabelSettingsModel, TooltipSettingsModel, LegendSettingsModel, AccumulationChart, IPointEventArgs, IAccTextRenderEventArgs, IAccTooltipRenderEventArgs } from '@syncfusion/ej2-angular-charts';
+import { AxisClickEvent, CubeViewerComponent } from "../declarations";
+import { AxesMap, ChartType } from '../../core/models';
+import { CubeService, Point } from '../cube.service';
+import { SessionService } from '../../core/session.service';
+import { TranslateService } from '../../core/translate.service';
+import { PromptService } from '../../core/prompt.service';
+import { ScopeType } from '../../core/configuration';
+import * as i0 from "@angular/core";
+export declare class CubeAccumulationChartComponent implements OnInit, OnChanges, OnDestroy, CubeViewerComponent {
+    private _service;
+    private _sb;
+    private _translate;
+    private _elementRef;
+    private _session;
+    static nextId: number;
+    readonly id: string;
+    theme: 'Material' | 'MaterialDark';
+    accumchart: AccumulationChart;
+    startAngle: number;
+    endAngle: number;
+    innerRadius: string;
+    dataSource: Point[];
+    readonly dataLabel: AccumulationDataLabelSettingsModel;
+    readonly legendSettings: LegendSettingsModel;
+    readonly tooltip: TooltipSettingsModel;
+    private _palettes;
+    get palettes(): string[];
+    set palettes(value: string[]);
+    height: string | number;
+    width: string | number;
+    cube: string;
+    private _xAxis;
+    set xAxis(val: string | string[]);
+    filters?: AxesMap;
+    chartType?: ChartType;
+    scope: ScopeType;
+    currencyCode: string;
+    loading: boolean;
+    readonly loadingChange: EventEmitter<boolean>;
+    readonly explore: EventEmitter<AxisClickEvent>;
+    private _cube;
+    private readonly _intl;
+    private readonly _destroy;
+    /** chart ctor */
+    constructor(_service: CubeService, _sb: PromptService, _translate: TranslateService, _elementRef: ElementRef, _session: SessionService);
+    ngOnInit(): void;
+    textRender(e: IAccTextRenderEventArgs): void;
+    tooltipRender(e: IAccTooltipRenderEventArgs): void;
+    pointClick(evt: IPointEventArgs): void;
+    /**
+     *
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    resize(): void;
+    execute(): void;
+    private _draw;
+    exportToExcel(title: string): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeAccumulationChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeAccumulationChartComponent, "bizdoc-cube-accum", never, { "palettes": "palettes"; "height": "height"; "width": "width"; "cube": "cube"; "xAxis": "xAxis"; "filters": "filters"; "chartType": "chartType"; "scope": "scope"; "loading": "loading"; }, { "loadingChange": "loadingChange"; "explore": "explore"; }, never, never>;
+}

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

@@ -0,0 +1,74 @@
+import { EventEmitter, ElementRef, OnInit, OnDestroy, SimpleChanges, OnChanges } from '@angular/core';
+import { Chart, CrosshairSettingsModel } from '@syncfusion/ej2-charts';
+import { AxisModel, ChartAreaModel, TooltipSettingsModel, LegendSettingsModel, IPointEventArgs, ITooltipRenderEventArgs } from '@syncfusion/ej2-angular-charts';
+import { CubeService } from '../cube.service';
+import { AxisClickEvent, CubeViewerComponent } from "../declarations";
+import { AxesMap, ChartType, YAxis } from '../../core/models';
+import { PromptService } from '../../core/prompt.service';
+import { SessionService } from '../../core/session.service';
+import { TranslateService } from '../../core/translate.service';
+import { ScopeType } from '../../core/configuration';
+import * as i0 from "@angular/core";
+export declare class CubeChartComponent implements OnInit, OnChanges, OnDestroy, CubeViewerComponent {
+    private _service;
+    private _sb;
+    private _translate;
+    private _session;
+    private _elementRef;
+    width: string | number;
+    height: string | number;
+    cube: string;
+    private _xAxis;
+    private _cube;
+    get xAxis(): string[] | string;
+    set xAxis(value: string[] | string);
+    private _series?;
+    get series(): string[] | string;
+    set series(value: string[] | string);
+    private _indices?;
+    get indices(): string[] | string;
+    set indices(value: string[] | string);
+    filters?: AxesMap;
+    yAxis?: YAxis;
+    chartType?: ChartType;
+    indicesChartType?: ChartType;
+    scope: ScopeType;
+    currencyCode: string;
+    readonly explore: EventEmitter<AxisClickEvent>;
+    loading: boolean;
+    readonly loadingChange: EventEmitter<boolean>;
+    static nextId: number;
+    readonly id: string;
+    chart: Chart;
+    private _palettes;
+    get palettes(): string[];
+    set palettes(value: string[]);
+    readonly enableRtl: boolean;
+    readonly legendSettings: LegendSettingsModel;
+    readonly primaryXAxis: AxisModel;
+    readonly primaryYAxis: AxisModel;
+    readonly chartArea: ChartAreaModel;
+    readonly tooltip: TooltipSettingsModel;
+    readonly crosshair: CrosshairSettingsModel;
+    theme: 'Material' | 'MaterialDark';
+    private _data;
+    private readonly _intl;
+    private readonly _destroy;
+    /** chart ctor */
+    constructor(_service: CubeService, _sb: PromptService, _translate: TranslateService, _session: SessionService, _elementRef: ElementRef);
+    ngOnInit(): void;
+    /**
+     *
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    resize(): void;
+    execute(): void;
+    /** */
+    private _draw;
+    tooltipRender(e: ITooltipRenderEventArgs): void;
+    pointClick(evt: IPointEventArgs): void;
+    exportToExcel(title: string): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeChartComponent, "bizdoc-cube-chart", never, { "width": "width"; "height": "height"; "cube": "cube"; "xAxis": "xAxis"; "series": "series"; "indices": "indices"; "filters": "filters"; "yAxis": "yAxis"; "chartType": "chartType"; "indicesChartType": "indicesChartType"; "scope": "scope"; "loading": "loading"; "palettes": "palettes"; }, { "explore": "explore"; "loadingChange": "loadingChange"; }, never, never>;
+}

package/lib/cube/cube-info.service.d.ts

@@ -0,0 +1,77 @@
+import { ElementRef } from "@angular/core";
+import { AxesMap } from "../core/models";
+import { SessionService } from "../core/session.service";
+import { BizDocComponentFactoryResolver } from "../core/component-factory-resolver";
+import { CubeService } from "./cube.service";
+import { Popup } from "../core/popup/popup.service";
+import { RouterImpl } from "../core/router";
+import { SumSettings } from "./matrix/table.component";
+import { ScopeType } from "../core/configuration";
+import * as i0 from "@angular/core";
+export interface CubeData {
+    axes: AxesMap;
+    options?: CubeDataOptions;
+}
+export interface CubeDataOptions {
+    cube?: string;
+    /** columns axes */
+    xAxis: string;
+    /** rows axes */
+    series: string;
+    /** one or more index name */
+    indices?: string[] | string;
+    view?: string;
+    /** one or more axis */
+    filters?: string[] | string;
+    /** axes to exclude */
+    aggregate?: string[] | string;
+    /** summary rows / columns */
+    sum?: SumSettings | SumSettings[];
+    seriesTotalLabel?: string;
+    xAxisTotalLabel?: string;
+    indexAt?: 'series' | 'xAxis';
+    placeAt?: 'leading' | 'trailing';
+}
+export interface ExploreOptions {
+    cube?: string;
+    index?: string;
+    scope?: ScopeType;
+    base?: {
+        [axis: string]: (string | number);
+    } | Array<string | number>;
+}
+/** opens cube preview and explore */
+export declare class CubeInfo {
+    private _session;
+    private _service;
+    private _router;
+    private _popup;
+    private _cf;
+    constructor(_session: SessionService, _service: CubeService, _router: RouterImpl, _popup: Popup, _cf: BizDocComponentFactoryResolver);
+    navigate(axes: Array<string | number> | {
+        [axis: string]: (string | number);
+    }, options?: CubeDataOptions): void;
+    /**
+     *
+     * @param axes
+     * @param options
+     */
+    popup(axes: Array<string | number> | {
+        [axis: string]: (string | number);
+    }, element: HTMLElement | ElementRef, options?: CubeDataOptions): void;
+    /**
+     *
+     * @param axes
+     * @param options
+     */
+    explore(axes: AxesMap | Array<string | number>, options?: ExploreOptions): void;
+    /**
+     * axes as map
+     * @param cube
+     * @param axes
+     */
+    private _mapAxes;
+    private _open;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeInfo, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CubeInfo>;
+}

package/lib/cube/cube-menu.component.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from '@angular/core';
+import { Cube } from '../core/models';
+import { SessionService } from '../core/session.service';
+import * as i0 from "@angular/core";
+export declare class CubeMenuComponent {
+    collapsed: boolean;
+    readonly change: EventEmitter<any>;
+    cubes: Cube[];
+    constructor(session: SessionService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeMenuComponent, "bizdoc-cube-menu", never, { "collapsed": "collapsed"; }, { "change": "change"; }, never, never>;
+}

package/lib/cube/cube-view.component.d.ts

@@ -0,0 +1,31 @@
+import { AfterViewInit, ComponentFactoryResolver, EventEmitter, OnChanges, OnInit, SimpleChanges, ViewContainerRef } from '@angular/core';
+import { AxesMap, Cube, CubeView } from '../core/models';
+import { AxisClickEvent } from './declarations';
+import * as i0 from "@angular/core";
+/** */
+export declare class CubeViewComponent implements OnInit, OnChanges, AfterViewInit {
+    private _viewContainer;
+    private _factoryResolver;
+    filters: AxesMap;
+    readonly explore: EventEmitter<AxisClickEvent>;
+    cube: Cube;
+    view: CubeView;
+    loading: boolean;
+    readonly loadingChange: EventEmitter<boolean>;
+    private _instance;
+    private readonly _resizing;
+    private readonly _viewDestroy;
+    constructor(_viewContainer: ViewContainerRef, _factoryResolver: ComponentFactoryResolver);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private _createView;
+    private _attach;
+    resize(): void;
+    private _dim;
+    refresh(): void;
+    exportToExcel(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeViewComponent, "bizdoc-cube-view", never, { "filters": "filters"; "cube": "cube"; "view": "view"; "loading": "loading"; }, { "explore": "explore"; "loadingChange": "loadingChange"; }, never, never>;
+}

package/lib/cube/cube.service.d.ts

@@ -0,0 +1,268 @@
+import { HttpClient, HttpErrorResponse } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { BizDocConfig, ParamMap, ScopeType } from '../core/configuration';
+import { FieldInfo, AxisType, AxesMap } from '../core/models';
+import { SessionService } from '../core/session.service';
+import { DatasourceService } from '../core/datasource.service';
+import * as i0 from "@angular/core";
+export declare const ACCOUNT_DELIMITER = ".", DEFAULT_CURRENCY = "USD";
+/** in case xAxis or series is given more than one axis,
+ * the value returned is combined of values seperated by this character. */
+export declare const AXES_CODE_DIVIDER = "__";
+export declare const AXES_LABEL_DIVIDER = "-";
+/** represents a place in pattern to be replaced by base axis. */
+export declare const AXIS_MAP_CHAR = "#", AXIS_MAP_AS_IS = "*";
+export declare const AXIS_SPECIAL_CHARS: RegExp;
+/** allowed characters for axis value / collection / range / pattern. */
+export declare const AXIS_VALUE_PATTERN: RegExp;
+export declare const CLDR_FILES: string[];
+/** query cube */
+export declare class CubeService {
+    private _config;
+    private _http;
+    private _type;
+    private _session;
+    private readonly _cache;
+    constructor(_config: BizDocConfig, _http: HttpClient, _type: DatasourceService, _session: SessionService);
+    private _cacheOr;
+    /** system currency */
+    get numberFormat(): string;
+    get currencyCode(): string;
+    get digitsInfo(): string;
+    get fractionDigits(): number;
+    /**
+     * query cube by axes, series and indices
+     * @param cube name
+     * @param xAxis group by one or more axis
+     * @param options
+     */
+    series(cube: string, xAxis: string | string[], options?: {
+        /** group series by one or more axis */
+        series?: string | string[];
+        /** include one or more index series */
+        indices?: string | string[];
+        groupIndices?: boolean;
+        inverseIndices?: boolean;
+        /** axes */
+        filters?: {
+            [axis: string]: AxisType;
+        };
+        scope?: ScopeType;
+        /** replace base */
+        base?: {
+            [axis: string]: (string | number);
+        } | Array<string | number>;
+    }): Observable<Series[]>;
+    /**
+     * aggregate cube to flat collection of columns and value(s)
+     * @param cube name
+     * @param columns
+     * @param options
+     */
+    table(cube: string, columns: string[], options?: {
+        /** axes */
+        filters?: AxesMap;
+        /** include one or more index values */
+        indices?: string | string[];
+        scope?: ScopeType;
+    }): Observable<{
+        value: number;
+    }[]>;
+    /**
+     * information on expected explore type
+     * @param cube name
+     * @param axes filters
+     * @param options
+     */
+    resolve(cube: string, axes: {
+        [key: string]: AxisType;
+    }, options?: {
+        /** replace base */
+        base?: {
+            [axis: string]: (string | number);
+        } | Array<string | number>;
+    }): Observable<ExploreType>;
+    /**
+     * information on expected explore type
+     * @param cube name
+     * @param index name
+     */
+    resolveIndex(cube: string, index: string): Observable<ExploreType>;
+    /**
+     * explore items by axis
+     * @param cube name
+     * @param axes filters
+     * @param options
+     */
+    explore(cube: string, axes: {
+        [key: string]: AxisType;
+    }, options?: {
+        /** restrict results to user patterns or positions */
+        scope?: ScopeType;
+        /** replace base */
+        base?: {
+            [axis: string]: (string | number);
+        } | Array<string | number>;
+    }): Observable<any[]>;
+    /**
+     *
+     * @param axes
+     * @param cube
+     */
+    nameOf(axes: AxesMap, cube: string): Observable<string>;
+    /**
+     * explore indices by axis
+     * @param cube name
+     * @param index name
+     * @param axes filters
+     * @param options
+     */
+    indices(cube: string, index: string, axes: {
+        [axis: string]: AxisType;
+    }, options?: {
+        /** restrict results to user patterns or positions */
+        scope?: ScopeType;
+        base?: {
+            [axis: string]: (string | number);
+        } | Array<string | number>;
+    }): Observable<any[]>;
+    /**
+     * get explore item by axis and key(s)
+     * @param cube
+     * @param axes
+     * @param keys
+     * @param options
+     */
+    item(cube: string, axes: {
+        [axis: string]: AxisType;
+    }, keys: (string | number)[] | string | number, options?: {
+        /** replace base */
+        base?: {
+            [axis: string]: (string | number);
+        } | Array<string | number>;
+    }): Observable<any>;
+    /**
+     *
+     * @param cube name
+     * @param axes condition
+     */
+    constraints(cube: string, axes?: {
+        [key: string]: AxisType;
+    }, options?: {
+        source: 'constraints' | 'combinations';
+    }): Observable<{
+        [dataType: string]: {
+            [key: string]: any;
+        };
+    }>;
+    /**
+     *
+     * @param cube name
+     * @param axis name
+     */
+    values(cube: string, axis: string, dependencies?: ParamMap): Observable<{
+        [key: string]: any;
+    }>;
+    /**
+     * get axis combinations
+     * @param cube name
+     * @param axes filters
+     * @param options
+     */
+    combinations(cube: string, axes?: {
+        [key: string]: AxisType;
+    }, options?: {
+        /** top */
+        take?: number;
+        /** process in background */
+        progress?: boolean;
+    }): Observable<string[][]>;
+    /**
+     *
+     * @param value
+     * @param options
+     */
+    search(value: string, options: {
+        take?: number;
+    }): Observable<{
+        cube: string;
+        axis: string;
+        key: any;
+        value: any;
+    }[]>;
+    /**
+     * get segments
+     * @param cube
+     */
+    segments(cube: string, name: string): Observable<SegmentMap>;
+    /**
+     * get user patterns
+     * @param cube
+     */
+    patterns(cube: string): Observable<Pattern[]>;
+    /** get currencies */
+    currencies(): Observable<Currency[]>;
+    /**
+     * get exchange rate
+     * @param currencyCode
+     * @param date
+     */
+    exchangeRate(currencyCode: string, date?: Date): Observable<number>;
+    /**
+    * replaces * or # with origin axis at char place
+    * @param cube name
+    * @param axes map
+    * @param base origin
+    */
+    base(cube: string, axes: AxesMap, base: Array<string | number> | AxesMap): void;
+    /**
+     * adds values to source keys
+     * @param cube
+     * @param xAxis
+     * @param series
+     */
+    private _decorate;
+    /**
+     * adds values to source keys
+     * @param cube
+     */
+    private _decorateTable;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CubeService>;
+}
+export declare function progress(time?: number): (source: Observable<any>) => Observable<boolean>;
+/** modelize cube results as nested maps */
+export declare function modelize(): (source: Observable<Series[]>) => Observable<{
+    [key: string]: {
+        [key: string]: number;
+    };
+}>;
+export interface ExploreType {
+    columns: FieldInfo[];
+    template?: string;
+    fields?: FieldInfo[];
+}
+export interface Series {
+    points: Point[];
+    name?: string;
+    index?: string;
+    title?: string;
+}
+export interface Point {
+    x: string;
+    y: number;
+    name?: string;
+}
+export interface Currency {
+    code: string;
+    name: string;
+    symbol: string;
+}
+export declare type SegmentMap = {
+    [code: string]: string;
+};
+export interface Pattern {
+    title: string;
+    axes: AxesMap;
+}
+export declare function errResource(error: HttpErrorResponse): "Unauthorized" | "LicenseErr" | "NotAcceptable";

package/lib/cube/declarations.d.ts

@@ -0,0 +1,23 @@
+import { EventEmitter, OnChanges } from '@angular/core';
+import { AxesMap } from '../core/models';
+export interface AxisClickEvent {
+    axes: AxesMap;
+    /** index name */
+    index?: string;
+}
+/** */
+export interface CubeViewerComponent extends OnChanges {
+    exportToExcel(title: string): any;
+    execute(): any;
+    resize(): any;
+    explore?: EventEmitter<AxisClickEvent>;
+    loading: boolean;
+    loadingChange: EventEmitter<boolean>;
+    height: string | number;
+    width?: string | number;
+    cube: string;
+    xAxis: string[] | string;
+    series?: string[] | string;
+    indices?: string[] | string;
+    filters?: AxesMap;
+}

package/lib/cube/explore/document-item.component.d.ts

@@ -0,0 +1,16 @@
+import { DocumentModel } from '../../core/models';
+import { ExploreItemComponent } from '../../core/base';
+import { PaneRef } from '../../core/slots/pane-ref';
+import { ExploreItemPaneComponent } from './item.pane.component';
+import { SessionService } from '../../core/session.service';
+import * as i0 from "@angular/core";
+/** preview of cube explore item for form */
+export declare class ExploreDocumentComponent implements ExploreItemComponent<DocumentModel<any>> {
+    private _pane;
+    private _session;
+    model: DocumentModel<any>;
+    constructor(_pane: PaneRef<ExploreItemPaneComponent>, _session: SessionService);
+    onBind(data: DocumentModel<any>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExploreDocumentComponent, [{ optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExploreDocumentComponent, "ng-component", never, {}, {}, never, never>;
+}

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

@@ -0,0 +1,14 @@
+import { ViewContainerRef, AfterViewInit } from '@angular/core';
+import { BizDocComponentFactoryResolver } from '../../core/component-factory-resolver';
+import * as i0 from "@angular/core";
+/** shows an item on explore. */
+export declare class ExploreItemImplComponent implements AfterViewInit {
+    private _vc;
+    private _resolver;
+    template: string;
+    model: any;
+    constructor(_vc: ViewContainerRef, _resolver: BizDocComponentFactoryResolver);
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExploreItemImplComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExploreItemImplComponent, "bizdoc-cube-item", never, { "template": "template"; "model": "model"; }, {}, never, never>;
+}

package/lib/cube/explore/explore-items.component.d.ts

@@ -0,0 +1,57 @@
+import { OnChanges, SimpleChanges, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { MatTableDataSource } from '@angular/material/table';
+import { MatSort } from '@angular/material/sort';
+import { MatPaginator } from '@angular/material/paginator';
+import { FieldInfo, AxesMap } from '../../core/models';
+import { CubeService } from '../cube.service';
+import { PromptService } from '../../core/prompt.service';
+import { TranslateService } from '../../core/translate.service';
+import { SessionService } from '../../core/session.service';
+import { ScopeType } from '../../core/configuration';
+import * as i0 from "@angular/core";
+export declare class ExploreItemsComponent implements OnInit, OnChanges, OnDestroy {
+    private _service;
+    private _sb;
+    private _session;
+    private _translate;
+    readonly CURRENCY_FORMAT: string;
+    private _pageSize;
+    private _data;
+    get pageSize(): number;
+    set pageSize(value: number);
+    cube: string;
+    index?: string;
+    scope?: ScopeType;
+    axes: AxesMap;
+    readonly explore: EventEmitter<ExploreItemEvent>;
+    readonly load: EventEmitter<any>;
+    dataSource: MatTableDataSource<any>;
+    loading: boolean;
+    readonly loadingChange: EventEmitter<boolean>;
+    sort: MatSort;
+    paginator: MatPaginator;
+    columns: FieldInfo[];
+    selectable: boolean;
+    displayedColumns: string[];
+    currencyCode: string;
+    private readonly _loading$;
+    private _template;
+    private _cube;
+    /** drill-down ctor */
+    constructor(_service: CubeService, _sb: PromptService, _session: SessionService, _translate: TranslateService);
+    ngOnInit(): void;
+    refresh(): void;
+    ngOnChanges(_: SimpleChanges): void;
+    /** */
+    private _view;
+    private _datasource;
+    expand(item: any): void;
+    exportExcel(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExploreItemsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExploreItemsComponent, "bizdoc-cube-explore", never, { "pageSize": "pageSize"; "cube": "cube"; "index": "index"; "scope": "scope"; "axes": "axes"; "loading": "loading"; }, { "explore": "explore"; "load": "load"; "loadingChange": "loadingChange"; }, never, never>;
+}
+export interface ExploreItemEvent {
+    keys: (string | number)[];
+    template: string;
+}