@bizdoc/core 1.14.9 → 1.14.10

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

@@ -0,0 +1,103 @@
+import { EventEmitter, OnChanges, OnDestroy, ElementRef, OnInit, SimpleChanges } from '@angular/core';
+import { Direction } from '@angular/cdk/bidi';
+import { DisplayOptionModel, PivotView, CellClickEventArgs } from '@syncfusion/ej2-pivotview';
+import { ChartSettingsModel } from '@syncfusion/ej2-pivotview/src/pivotview/model/chartsettings-model';
+import { DataSourceSettingsModel, FieldOptionsModel, FormatSettingsModel } from "@syncfusion/ej2-pivotview/src/pivotview/model/datasourcesettings-model";
+import { GridSettingsModel } from "@syncfusion/ej2-pivotview/src/pivotview/model/gridsettings-model";
+import { IPointEventArgs } from '@syncfusion/ej2-angular-charts';
+import { Tooltip } from '@syncfusion/ej2-popups';
+import { AxesMap, ChartType, YAxis } from '../../core/models';
+import { AxisClickEvent, CubeViewerComponent } from "../declarations";
+import { CubeService } from '../cube.service';
+import { PromptService } from '../../core/prompt.service';
+import { SessionService } from '../../core/session.service';
+import { TranslateService } from '../../core/translate.service';
+import * as i0 from "@angular/core";
+export declare class CubePivotComponent implements CubeViewerComponent, OnInit, OnChanges, OnDestroy {
+    private _service;
+    private _session;
+    private _translate;
+    private _sb;
+    private _elementRef;
+    width: string | number;
+    height: string;
+    cube: string;
+    private _xAxis;
+    tooltip: Tooltip;
+    get xAxis(): string[] | string;
+    set xAxis(value: string[] | string);
+    yAxis?: YAxis;
+    private _series?;
+    get series(): string[] | string;
+    set series(value: string[] | string);
+    private _indices?;
+    get indices(): string[] | string;
+    set indices(value: string[] | string);
+    filters?: AxesMap;
+    chartType?: ChartType;
+    indicesChartType?: ChartType;
+    currencyCode: string;
+    private _palettes;
+    get palettes(): string[];
+    set palettes(value: string[]);
+    readonly explore: EventEmitter<AxisClickEvent>;
+    loading: boolean;
+    readonly loadingChange: EventEmitter<boolean>;
+    static nextId: number;
+    readonly id: string;
+    pivot: PivotView;
+    displayOption: DisplayOptionModel;
+    chartSettings: ChartSettingsModel;
+    dataSource: DataSourceSettingsModel;
+    readonly formatSettings: FormatSettingsModel[];
+    values: FieldOptionsModel[];
+    private readonly conditionalFormatSettings;
+    readonly gridSettings: GridSettingsModel;
+    dir: Direction;
+    private _cube;
+    private _data;
+    private readonly _intl;
+    private readonly emptyCellsTextContent;
+    private readonly _destroy;
+    /** pivot ctor */
+    constructor(_service: CubeService, _session: SessionService, _translate: TranslateService, _sb: PromptService, _elementRef: ElementRef);
+    ngOnInit(): void;
+    private _getIndexTitle;
+    private _getAxisTitle;
+    /**
+     *
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    execute(): void;
+    /**
+     *
+     * @param xAxis
+     * @param series
+     * @param data
+     */
+    private _presets;
+    /**
+     *
+     * @param evt
+     */
+    cellClick(evt: CellClickEventArgs): void;
+    /**
+     * axes from headers
+     * @param columnHeaders
+     * @param rowHeaders
+     */
+    private _parseAxes;
+    /**
+     * chart
+     * @param e
+     */
+    pointClick(e: IPointEventArgs): void;
+    exportToExcel(title: string): Promise<void>;
+    private _exportExcel;
+    private _draw;
+    dataBound(_: any): void;
+    resize(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubePivotComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubePivotComponent, "bizdoc-cube-pivot", never, { "width": "width"; "height": "height"; "cube": "cube"; "xAxis": "xAxis"; "yAxis": "yAxis"; "series": "series"; "indices": "indices"; "filters": "filters"; "chartType": "chartType"; "indicesChartType": "indicesChartType"; "palettes": "palettes"; "loading": "loading"; }, { "explore": "explore"; "loadingChange": "loadingChange"; }, never, never>;
+}

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

@@ -0,0 +1,81 @@
+import { EventEmitter, OnChanges, SimpleChanges } from "@angular/core";
+import { SessionService } from "../../core/session.service";
+import { CubeService } from "../../cube/cube.service";
+import { DatasourceService } from "../../core/datasource.service";
+import { PromptService } from "../../core/prompt.service";
+import { AxesMap, CubeAxis } from "../../core/models";
+import { ScopeType } from "../../core/configuration";
+import * as i0 from "@angular/core";
+export declare class CubeSumComponent implements OnChanges {
+    private _ds;
+    private _service;
+    private _sb;
+    private _session;
+    xAxis: string;
+    periodPolicy?: 'Strict' | 'Fish';
+    parentAxis: string;
+    filters: AxesMap;
+    cube: string;
+    indices: string[] | string;
+    scope: ScopeType;
+    readonly onExplore: EventEmitter<ExploreEvent>;
+    back: boolean;
+    forward: boolean;
+    primaryAxis: CubeAxis;
+    next: Level;
+    current: Level;
+    prev: Level;
+    help: string;
+    currencyCode: string;
+    digitsInfo: string;
+    loading: boolean;
+    readonly Math: Math;
+    private _cube;
+    private _parentAxis;
+    private _results;
+    private _scoperesults;
+    private _scope;
+    constructor(_ds: DatasourceService, _service: CubeService, _sb: PromptService, _session: SessionService);
+    ngOnChanges(_: SimpleChanges): void;
+    private _strict;
+    private _handleErr;
+    private _fish;
+    getAggregateLabel(): Promise<string>;
+    private _calculate;
+    goprev(): Promise<void>;
+    private _seek;
+    gonext(): Promise<void>;
+    private _parallel;
+    /**
+     *
+     * @param level
+     * @param index
+     */
+    explore(level: Level, index?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeSumComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeSumComponent, "bizdoc-cube-sum", never, { "xAxis": "xAxis"; "periodPolicy": "periodPolicy"; "parentAxis": "parentAxis"; "filters": "filters"; "cube": "cube"; "indices": "indices"; "scope": "scope"; }, { "onExplore": "explore"; }, never, never>;
+}
+export interface ExploreEvent {
+    axes: AxesMap;
+    index?: string;
+}
+export declare type Level = {
+    indices: {
+        name: string;
+        title: string;
+        value: number;
+    }[];
+    value: number;
+    title: string;
+    axis: string;
+    /** parent axis */
+    scope?: string;
+    animation: {
+        value: number;
+        params: {
+            startWidth: number;
+        };
+    };
+    chain?: Level;
+    percent: number;
+};

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

@@ -0,0 +1,39 @@
+import { AxesMap, Cube, CubeView } from '../core/models';
+import { CubeService, Pattern } from './cube.service';
+import { SessionService } from '../core/session.service';
+import { GuideService } from '../core/guide/guide.service';
+import { CubeViewComponent } from './cube-view.component';
+import { RouterImpl } from '../core/router';
+import * as i0 from "@angular/core";
+export declare abstract class ViewBase {
+    protected _session: SessionService;
+    protected _router: RouterImpl;
+    protected _service: CubeService;
+    private _guide;
+    viewPane: CubeViewComponent;
+    patterns: Pattern[];
+    pattern: Pattern;
+    private _cube;
+    get cube(): Cube;
+    set cube(value: Cube);
+    private _view;
+    get view(): CubeView;
+    set view(value: CubeView);
+    exclude: string[];
+    private _axes;
+    get axes(): AxesMap;
+    set axes(value: AxesMap);
+    anyAxes: boolean;
+    anyFilters: boolean;
+    loading: boolean;
+    private _originalAxes;
+    get originalAxes(): AxesMap;
+    set originalAxes(value: AxesMap);
+    constructor(_session: SessionService, _router: RouterImpl, _service: CubeService, _guide: GuideService);
+    patternChange(pattern: Pattern): void;
+    clearFilter(): void;
+    navigate(queryParams: any): void;
+    guide(evt?: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ViewBase, never, never, {}, {}, never>;
+}

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

@@ -0,0 +1,46 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { MatSidenav } from '@angular/material/sidenav';
+import { AxesMap } from '../core/models';
+import { CubeService } from './cube.service';
+import { SessionService } from '../core/session.service';
+import { GuideService } from '../core/guide/guide.service';
+import { WindowTitleService } from '../core/window-title.service';
+import { CubeViewComponent } from './cube-view.component';
+import { ExploreItemEvent, ExploreItemsComponent } from './explore/explore-items.component';
+import { AxisClickEvent } from './declarations';
+import { ViewBase } from './view-base';
+import { RouterImpl } from '../core/router';
+import { PromptService } from '../core/prompt.service';
+import * as i0 from "@angular/core";
+export declare class CubeMobileViewComponent extends ViewBase implements OnInit, OnDestroy {
+    private _sb;
+    private _title;
+    private _route;
+    mode: 'filter' | 'explore' | 'item';
+    viewPane: CubeViewComponent;
+    drawer: MatSidenav;
+    explorePane: ExploreItemsComponent;
+    index: string;
+    loading: boolean;
+    template: string;
+    item: any;
+    private _navigating;
+    private readonly _destroy;
+    pageSize: number;
+    /** cube ctor */
+    constructor(session: SessionService, router: RouterImpl, service: CubeService, guide: GuideService, _sb: PromptService, _title: WindowTitleService, _route: ActivatedRoute);
+    ngOnInit(): void;
+    exploreItem(evt: ExploreItemEvent): void;
+    toggleFilter(): void;
+    /**
+     *
+     * @param evt
+     */
+    explore(evt: AxisClickEvent): void;
+    resize(): void;
+    filterChange(axes: AxesMap): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeMobileViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeMobileViewComponent, "ng-component", never, {}, {}, never, never>;
+}

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

@@ -0,0 +1,27 @@
+import { OnInit } from '@angular/core';
+import { CubeService } from './cube.service';
+import { SessionService } from '../core/session.service';
+import { GuideService } from '../core/guide/guide.service';
+import { CubeViewComponent } from './cube-view.component';
+import { PaneRef } from '../core/slots/pane-ref';
+import { Popup } from '../core/popup/popup.service';
+import { RouterImpl } from '../core/router';
+import { ViewBase } from './view-base';
+import { AxisClickEvent } from './declarations';
+import * as i0 from "@angular/core";
+export declare class CubeViewPaneComponent extends ViewBase implements OnInit {
+    private _pane;
+    private _popup;
+    viewPane: CubeViewComponent;
+    constructor(session: SessionService, _pane: PaneRef<CubeViewPaneComponent>, _popup: Popup, router: RouterImpl, service: CubeService, guide: GuideService);
+    ngOnInit(): void;
+    /**
+     *
+     * @param evt
+     */
+    explore(evt: AxisClickEvent): void;
+    filterToggle(evt: Event): void;
+    guide(evt?: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeViewPaneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeViewPaneComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/dashboard/actions/actions.widget.d.ts

@@ -0,0 +1,39 @@
+import { OnDestroy, ElementRef } from '@angular/core';
+import { WidgetComponent } from '../../core/base';
+import { IAccTooltipRenderEventArgs, AccumulationChart, LegendSettingsModel, AccumulationDataLabelSettingsModel, AnimationModel, TooltipSettingsModel } from '@syncfusion/ej2-angular-charts';
+import { SessionService } from '../../core/session.service';
+import { WidgetRef } from "../widget-ref";
+import * as i0 from "@angular/core";
+export declare class ActionsWidget implements WidgetComponent<PerformanceData[]>, OnDestroy {
+    private _session;
+    private _elementRef;
+    static nextId: number;
+    readonly id: string;
+    chart: AccumulationChart;
+    data: PerformanceData[];
+    theme: 'Material' | 'MaterialDark';
+    palettes: string[];
+    readonly tooltip: TooltipSettingsModel;
+    readonly legendSettings: LegendSettingsModel;
+    readonly animation: AnimationModel;
+    readonly dataLabel: AccumulationDataLabelSettingsModel;
+    height: string;
+    width: string;
+    private readonly _map;
+    private readonly _destroy;
+    constructor(widgetRef: WidgetRef, _session: SessionService, _elementRef: ElementRef);
+    onBind(data: PerformanceData[]): void;
+    private _draw;
+    tooltipRender(e: IAccTooltipRenderEventArgs): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionsWidget, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActionsWidget, "ng-component", never, {}, {}, never, never>;
+}
+interface PerformanceData {
+    text: string;
+    actionId: string;
+    count: number;
+    /** seconds */
+    duration: number;
+}
+export {};

package/lib/dashboard/cube/accum-cube.widget.d.ts

@@ -0,0 +1,33 @@
+import { OnDestroy, ElementRef } from '@angular/core';
+import { LegendSeriesModel, TooltipSettingsModel, AccumulationChart, AccumulationDataLabelSettingsModel, AnimationModel, IAccTooltipRenderEventArgs, IPointEventArgs } from '@syncfusion/ej2-angular-charts';
+import { CubeAnalysisBase, Options } from './cube-analysis.base';
+import { DatasourceService } from '../../core/datasource.service';
+import { SessionService } from '../../core/session.service';
+import { CubeService, Series, Point } from '../../cube/cube.service';
+import { WidgetRef } from "../widget-ref";
+import { Dimentions } from '../../core/models';
+import { CubeInfo } from '../../cube/cube-info.service';
+import * as i0 from "@angular/core";
+export declare class CubeAccumAnalysisWidget extends CubeAnalysisBase implements OnDestroy {
+    private _elementRef;
+    chart: AccumulationChart;
+    data: Point[];
+    startAngle: number;
+    endAngle: number;
+    innerRadius: string;
+    readonly dataLabel: AccumulationDataLabelSettingsModel;
+    readonly legend: LegendSeriesModel;
+    readonly tooltip: TooltipSettingsModel;
+    readonly animation: AnimationModel;
+    readonly enableRtl: boolean;
+    constructor(ref: WidgetRef<Options>, info: CubeInfo, session: SessionService, ds: DatasourceService, cube: CubeService, _elementRef: ElementRef);
+    onLoad(data: Series[]): void;
+    onResize(dim: Dimentions): void;
+    onThemeChange(): void;
+    tooltipRender(e: IAccTooltipRenderEventArgs): void;
+    private _draw;
+    pointClick(evt: IPointEventArgs): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeAccumAnalysisWidget, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeAccumAnalysisWidget, "bizdoc-accum-cube-analysis", never, {}, {}, never, never>;
+}

package/lib/dashboard/cube/compare.widget.d.ts

@@ -0,0 +1,53 @@
+import { OnDestroy, ElementRef } from "@angular/core";
+import { Chart, AxisModel, CrosshairSettingsModel, TooltipSettingsModel, SeriesModel, LegendSeriesModel, RowModel, MarginModel, ZoomSettingsModel, ChartAreaModel, ISharedTooltipRenderEventArgs } from "@syncfusion/ej2-angular-charts";
+import { WidgetComponent } from "../../core/base";
+import { TranslateService } from "../../core/translate.service";
+import { SessionService } from "../../core/session.service";
+import { DatasourceService } from "../../core/datasource.service";
+import { WidgetRef } from "../widget-ref";
+import * as i0 from "@angular/core";
+/** */
+export declare class CubeCompareWidget implements WidgetComponent<Model[]>, OnDestroy {
+    private _translate;
+    private _widgetRef;
+    private _elementRef;
+    private _type;
+    private _session;
+    static nextId: number;
+    readonly id: string;
+    palettes: string[];
+    chart: Chart;
+    theme: 'Material' | 'MaterialDark';
+    readonly enableRtl: boolean;
+    readonly rows: RowModel[];
+    readonly axes: AxisModel[];
+    readonly chartArea: ChartAreaModel;
+    readonly zoomSettings: ZoomSettingsModel;
+    readonly primaryXAxis: AxisModel;
+    readonly crosshair: CrosshairSettingsModel;
+    readonly tooltip: TooltipSettingsModel;
+    readonly legend: LegendSeriesModel;
+    readonly primaryYAxis: AxisModel;
+    readonly margin: MarginModel;
+    series: SeriesModel[];
+    height: string;
+    private readonly _destroy;
+    constructor(_translate: TranslateService, _widgetRef: WidgetRef, _elementRef: ElementRef, _type: DatasourceService, _session: SessionService);
+    onBind(data: Model[]): Promise<void>;
+    private _draw;
+    sharedTooltipRender(evt: ISharedTooltipRenderEventArgs): void;
+    private _prepare;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeCompareWidget, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeCompareWidget, "ng-component", never, {}, {}, never, never>;
+}
+interface Model {
+    points: Point[];
+    series: string;
+}
+interface Point {
+    date: Date;
+    duration: number;
+    count: number;
+}
+export {};

package/lib/dashboard/cube/cube-analysis.base.d.ts

@@ -0,0 +1,59 @@
+import { OnDestroy } from '@angular/core';
+import { Subject } from 'rxjs';
+import { Internationalization } from '@syncfusion/ej2-base';
+import { WidgetComponent } from '../../core/base';
+import { AxesMap, ChartType, Cube } from '../../core/models';
+import { SessionService } from '../../core/session.service';
+import { DatasourceService } from '../../core/datasource.service';
+import { CubeService, Series } from '../../cube/cube.service';
+import { WidgetRef } from "../widget-ref";
+import { CubeInfo } from '../../cube/cube-info.service';
+import { ScopeType } from '../../core/configuration';
+import * as i0 from "@angular/core";
+export declare abstract class CubeAnalysisBase implements WidgetComponent<Series[]>, OnDestroy {
+    private _info;
+    protected _session: SessionService;
+    private _ds;
+    protected _service: CubeService;
+    static nextId: number;
+    readonly id: string;
+    palettes: string[];
+    theme: 'Material' | 'MaterialDark';
+    height: string;
+    width: string;
+    readonly currencyCode: string;
+    protected _cube: Cube;
+    protected _options: Options;
+    protected _data: Series[];
+    private _series;
+    private _xAxis;
+    protected get series(): string[];
+    protected get xAxis(): string[];
+    private readonly _axisTypeMap;
+    protected readonly _intl: Internationalization;
+    protected readonly _destroy: Subject<void>;
+    constructor(ref: WidgetRef<Options>, _info: CubeInfo, _session: SessionService, _ds: DatasourceService, _service: CubeService);
+    protected explore(axes: AxesMap, options?: {
+        index?: string;
+    }): void;
+    abstract onResize(dim: {
+        height: number;
+        width: number;
+    }): any;
+    onBind(data: Series[]): void;
+    abstract onLoad(data: Series[]): any;
+    abstract onThemeChange(): any;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeAnalysisBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CubeAnalysisBase, never, never, {}, {}, never>;
+}
+export interface Options {
+    scope?: ScopeType;
+    chartType?: ChartType;
+    indicesChartType?: ChartType;
+    cube?: string;
+    xAxis?: string[] | string;
+    exclude?: string[] | string;
+    series?: string[] | string;
+    indices?: string[] | string;
+}

package/lib/dashboard/cube/cube-analysis.widget.d.ts

@@ -0,0 +1,17 @@
+import { ViewContainerRef, OnInit, ComponentFactoryResolver, Injector } from '@angular/core';
+import { WidgetRef } from "../widget-ref";
+import { WidgetComponent } from '../../core/base';
+import { Options } from './cube-analysis.base';
+import * as i0 from "@angular/core";
+export declare class CubeAnalysisWidget implements WidgetComponent<any>, OnInit {
+    private _ref;
+    private _resolver;
+    private _injector;
+    private _vc;
+    private _instance;
+    constructor(_ref: WidgetRef<Options>, _resolver: ComponentFactoryResolver, _injector: Injector, _vc: ViewContainerRef);
+    ngOnInit(): void;
+    onBind(data: any, args?: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeAnalysisWidget, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeAnalysisWidget, "ng-component", never, {}, {}, never, never>;
+}

package/lib/dashboard/cube/cube-chart.widget.d.ts

@@ -0,0 +1,32 @@
+import { ElementRef } from '@angular/core';
+import { SessionService } from '../../core/session.service';
+import { Chart, AxisModel, MarkerOptionsModel, LegendSeriesModel, TooltipSettingsModel, ChartSeriesType, AnimationModel, ITooltipRenderEventArgs, IPointEventArgs } from '@syncfusion/ej2-angular-charts';
+import { CubeAnalysisBase } from './cube-analysis.base';
+import { DatasourceService } from '../../core/datasource.service';
+import { WidgetRef } from "../widget-ref";
+import { TranslateService } from '../../core/translate.service';
+import { CubeService, Series } from '../../cube/cube.service';
+import { CubeInfo } from '../../cube/cube-info.service';
+import * as i0 from "@angular/core";
+export declare class CubeChartAnalysisWidget extends CubeAnalysisBase {
+    private _elementRef;
+    private _translate;
+    chart: Chart;
+    readonly type: ChartSeriesType;
+    readonly indexType: ChartSeriesType;
+    readonly marker: MarkerOptionsModel;
+    readonly primaryXAxis: AxisModel;
+    readonly primaryYAxis: AxisModel;
+    readonly tooltip: TooltipSettingsModel;
+    readonly legend: LegendSeriesModel;
+    readonly animation: AnimationModel;
+    constructor(ref: WidgetRef, session: SessionService, ds: DatasourceService, cube: CubeService, info: CubeInfo, _elementRef: ElementRef, _translate: TranslateService);
+    onLoad(data: Series[]): void;
+    pointClick(evt: IPointEventArgs): void;
+    onThemeChange(): void;
+    onResize(): void;
+    tooltipRender(e: ITooltipRenderEventArgs): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeChartAnalysisWidget, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeChartAnalysisWidget, "bizdoc-cube-chart-analysis", never, {}, {}, never, never>;
+}

package/lib/dashboard/cube/documents.widget.d.ts

@@ -0,0 +1,30 @@
+import { MatTableDataSource } from '@angular/material/table';
+import { MatSort } from '@angular/material/sort';
+import { WidgetComponent } from '../../core/base';
+import { WidgetRef } from '../widget-ref';
+import { RouterImpl } from '../../core/router';
+import { MailboxService } from '../../core/mailbox.service';
+import { PromptService } from '../../core/prompt.service';
+import * as i0 from "@angular/core";
+export declare class CubeDocumentsWidget implements WidgetComponent<MailInfo[]> {
+    private _router;
+    private _mailbox;
+    private _sb;
+    dataSource: MatTableDataSource<MailInfo>;
+    sort: MatSort;
+    height: string;
+    loading: boolean;
+    readonly columns: string[];
+    constructor(_router: RouterImpl, _mailbox: MailboxService, _sb: PromptService, widgetRef: WidgetRef);
+    onBind(data: MailInfo[]): void;
+    open(item: MailInfo): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeDocumentsWidget, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeDocumentsWidget, "ng-component", never, {}, {}, never, never>;
+}
+interface MailInfo {
+    id: number;
+    number?: string;
+    subject?: string;
+    state: string;
+}
+export {};

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

@@ -0,0 +1,22 @@
+import { OnInit } from '@angular/core';
+import { FormBuilder, FormGroup } from '@angular/forms';
+import { WidgetRef } from '../../widget-ref';
+import { Options } from '../cube-analysis.base';
+import { ArgumentsComponent } from '../../../core/base';
+import { SessionService } from '../../../core/session.service';
+import * as i0 from "@angular/core";
+export declare class CubeWidgetFilterComponent implements OnInit, ArgumentsComponent {
+    private readonly _widgetRef;
+    private _session;
+    private readonly _fb;
+    form: FormGroup;
+    readonly exclude: string[];
+    cube: string;
+    axes: {};
+    /** filter ctor */
+    constructor(_widgetRef: WidgetRef<Options>, _session: SessionService, _fb: FormBuilder);
+    ngOnInit(): void;
+    valuesChange(axes: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CubeWidgetFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CubeWidgetFilterComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/dashboard/dashboard.component.d.ts

@@ -0,0 +1,24 @@
+import { OnDestroy } from '@angular/core';
+import { SessionService } from '../core/session.service';
+import { Widget } from '../core/models';
+import { MediaObserver } from '@angular/flex-layout';
+import { WindowTitleService } from '../core/window-title.service';
+import { TranslateService } from '../core/translate.service';
+import { GuideService } from '../core/guide/guide.service';
+import { WidgetItemComponent } from './widget-item.component';
+import { PaneRef } from '../core/slots/pane-ref';
+import { QueryList } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class DashboardComponent implements OnDestroy {
+    private _guide;
+    components: QueryList<WidgetItemComponent>;
+    private readonly _destroy;
+    /** dashboard ctor */
+    readonly widgets: Widget[];
+    cols: number;
+    constructor(_guide: GuideService, observableMedia: MediaObserver, session: SessionService, pane: PaneRef, title: WindowTitleService, translate: TranslateService);
+    guide(name: string): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardComponent, [null, null, null, { optional: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DashboardComponent, "bizdoc-dashboard", never, {}, {}, never, never>;
+}

package/lib/dashboard/dashboard.pane.component.d.ts

@@ -0,0 +1,8 @@
+import { PaneRef } from '../core/slots/pane-ref';
+import { TranslateService } from '../core/translate.service';
+import * as i0 from "@angular/core";
+export declare class DashboardPaneComponent {
+    constructor(pane: PaneRef, translate: TranslateService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardPaneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DashboardPaneComponent, "ng-component", never, {}, {}, never, never>;
+}