@bizdoc/core 1.14.9 → 1.14.10

package/lib/compose/version-compare/version-compare.directive.d.ts

@@ -0,0 +1,89 @@
+import { OnInit, ElementRef, AfterViewInit, ChangeDetectorRef, ViewContainerRef, TemplateRef } from "@angular/core";
+import { DomSanitizer } from "@angular/platform-browser";
+import { FieldInfo } from "../../core/models";
+import { TranslateService } from "../../core/translate.service";
+import { VersionCompareComponent } from "./version-compare.component";
+import * as i0 from "@angular/core";
+declare enum CompareState {
+    Removed = -1,
+    Unchanged = 0,
+    Added = 1,
+    Modified = 2
+}
+export declare abstract class CompareDirectiveBase {
+    abstract get base(): any;
+    abstract get version(): any;
+    abstract get structure(): FieldInfo;
+}
+/** */
+export declare class CompareGroupDirective extends CompareDirectiveBase implements OnInit {
+    private _comparision;
+    private _context;
+    private _parent;
+    name: string;
+    private _keys;
+    private _structure;
+    private _base;
+    private _version;
+    get structure(): FieldInfo;
+    get base(): any;
+    get version(): any;
+    get keys(): string[];
+    constructor(_comparision: VersionCompareComponent, _context: CompareContextDirective, _parent: CompareGroupDirective);
+    ngOnInit(): void;
+    private _normalize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CompareGroupDirective, [{ optional: true; }, { optional: true; host: true; }, { optional: true; host: true; skipSelf: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CompareGroupDirective, "[bizdocCompareGroup],[bizdocCompareArray]", never, { "name": "bizdocCompareGroup"; }, {}, never>;
+}
+/** */
+export declare class CompareNameDirective extends CompareDirectiveBase implements OnInit, AfterViewInit {
+    private _comparision;
+    private _context;
+    private _group;
+    private _translate;
+    private _cd;
+    private _dom;
+    private _element;
+    private _name;
+    set name(val: string);
+    private _structure;
+    private _base;
+    private _version;
+    private _state;
+    get structure(): FieldInfo;
+    get base(): any;
+    get version(): any;
+    get state(): CompareState;
+    constructor(_comparision: VersionCompareComponent, _context: CompareContextDirective, _group: CompareGroupDirective, _translate: TranslateService, _cd: ChangeDetectorRef, _dom: DomSanitizer, _element: ElementRef<HTMLElement>);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    private _decorate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CompareNameDirective, [{ optional: true; }, { optional: true; host: true; }, { optional: true; host: true; }, null, null, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CompareNameDirective, "[bizdocCompareName]", never, { "name": "bizdocCompareName"; }, {}, never>;
+}
+/** */
+export declare class CompareContextDirective extends CompareDirectiveBase implements OnInit, AfterViewInit {
+    private _comparision;
+    private _group;
+    private _vc;
+    private _template;
+    private _element;
+    private _version;
+    set compareOf(val: {});
+    set context(val: {});
+    get version(): {};
+    decorate: 'group' | 'single' | 'table';
+    private _base;
+    get base(): {};
+    get structure(): FieldInfo;
+    constructor(_comparision: VersionCompareComponent, _group: CompareGroupDirective, _vc: ViewContainerRef, _template: TemplateRef<any>, _element: ElementRef<HTMLElement>);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    /** */
+    private _table;
+    /** removes repeated added and removed tags */
+    private _collapse;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CompareContextDirective, [{ optional: true; }, { optional: true; host: true; }, null, { optional: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CompareContextDirective, "[bizdocCompareContext],[bizdocCompare]", ["bizdocCompare"], { "compareOf": "bizdocCompareOf"; "context": "bizdocCompareContext"; "decorate": "bizdocCompareDecorate"; }, {}, never>;
+}
+export {};

package/lib/compose/version-compare/version.pane.component.d.ts

@@ -0,0 +1,21 @@
+import { OnInit } from '@angular/core';
+import { CalendarSpec } from "../../core/pipes/calendar.pipe";
+import { DocumentModel, Log } from '../../core/models';
+import { PanesRouter } from '../../core/slots/router.service';
+import { PaneRef } from '../../core/slots/pane-ref';
+import { TranslateService } from '../../core/translate.service';
+import * as i0 from "@angular/core";
+export declare class VersionPaneComponent implements OnInit {
+    private _pane;
+    private _translate;
+    private _router;
+    model: DocumentModel<any>;
+    log: Log;
+    versions: Log[];
+    readonly CALENDAR_SPEC: CalendarSpec;
+    constructor(_pane: PaneRef<VersionPaneComponent>, _translate: TranslateService, _router: PanesRouter);
+    ngOnInit(): void;
+    switch(time: Date): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VersionPaneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VersionPaneComponent, "bizdoc-version.pane", never, {}, {}, never, never>;
+}

package/lib/core/NgComponentOutlet.d.ts

@@ -0,0 +1,15 @@
+import { Type, Injector, ComponentFactoryResolver, ViewContainerRef, EventEmitter, OnInit } from "@angular/core";
+import * as i0 from "@angular/core";
+export declare class NgxComponentOutlet implements OnInit {
+    private _viewContainerRef;
+    private _componentFactoryResolver;
+    ngxComponentOutlet: Type<any>;
+    ngxComponentOutletInjector: Injector;
+    ngxComponentOutletContent: any[][];
+    createEvents: EventEmitter<any>;
+    private _componentRef;
+    constructor(_viewContainerRef: ViewContainerRef, _componentFactoryResolver: ComponentFactoryResolver);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxComponentOutlet, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxComponentOutlet, "ngx-component-outlet", never, { "ngxComponentOutlet": "type"; "ngxComponentOutletInjector": "injector"; "ngxComponentOutletContent": "ngxComponentOutletContent"; }, { "createEvents": "create"; }, never>;
+}

package/lib/core/account.service.d.ts

@@ -0,0 +1,18 @@
+import { HttpClient } from '@angular/common/http';
+import { UserInfo } from '../core/models';
+import { HubService } from './hub.service';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class AccountService {
+    private _http;
+    private readonly _cache;
+    constructor(_http: HttpClient, messaging: HubService);
+    getAll(ids: string[]): Observable<UserInfo[]>;
+    get(id: string): Observable<UserInfo>;
+    findAll(name?: string, options?: {
+        skip?: number;
+        take?: number;
+    }): Observable<UserInfo[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccountService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AccountService>;
+}

package/lib/core/animated-icon/animated-icon.directive.d.ts

@@ -0,0 +1,7 @@
+import { ElementRef } from "@angular/core";
+import * as i0 from "@angular/core";
+export declare class MatIconAnimate {
+    constructor(element: ElementRef<HTMLElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatIconAnimate, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatIconAnimate, "[matAnimate]", never, {}, {}, never>;
+}

package/lib/core/animations.d.ts

@@ -0,0 +1,26 @@
+export declare const expandListItemAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const listItemUpdatedAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const searchAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const deshboardAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const cardsAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const ShakeAnimation: (import("@angular/animations").AnimationStyleMetadata | import("@angular/animations").AnimationAnimateMetadata)[];
+export declare const EnterExitLeft: import("@angular/animations").AnimationTransitionMetadata[];
+export declare const EnterExitRight: import("@angular/animations").AnimationTransitionMetadata[];
+export declare const EnterExitTop: import("@angular/animations").AnimationTransitionMetadata[];
+export declare const FadeSlideInOut: import("@angular/animations").AnimationTransitionMetadata[];
+export declare const PulseAnimation: import("@angular/animations").AnimationAnimateMetadata;
+export declare const SwapAnimation: import("@angular/animations").AnimationTransitionMetadata[];
+export declare const matrixAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const swapAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const pageAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const fabAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const submenuAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const listAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const itemAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const tabsAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const tabAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const panesAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const panesTitleAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const paneAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const paramAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const queryAnimation: import("@angular/animations").AnimationTriggerMetadata;

package/lib/core/authentication.d.ts

@@ -0,0 +1,6 @@
+import { Observable } from "rxjs";
+export declare abstract class AuthenticationImpl {
+    abstract authorize(): Observable<any>;
+    abstract signOut?(): Promise<any>;
+    abstract getAccessToken(): any;
+}

package/lib/core/avatar/avatar.component.d.ts

@@ -0,0 +1,34 @@
+import { ChangeDetectorRef, OnChanges, OnDestroy, SimpleChanges } from "@angular/core";
+import { AvailabilityState, UserInfo } from "../models";
+import { HubService } from "../hub.service";
+import { ChatInfo } from "../../chat/chat-info";
+import * as i0 from "@angular/core";
+export declare class AvatarComponent implements OnChanges, OnDestroy {
+    private _hub;
+    private _cd;
+    private _chat;
+    person: UserInfo;
+    modeIcon: string;
+    modeColor: string;
+    mode: AvailabilityState;
+    image: string;
+    initials: string;
+    color: string;
+    borderColor: string;
+    private _interactive;
+    get interactive(): boolean;
+    set interactive(value: boolean);
+    private _dense;
+    get dense(): boolean;
+    set dense(value: boolean);
+    private static _userMap;
+    private readonly _destroy;
+    constructor(_hub: HubService, _cd: ChangeDetectorRef, _chat: ChatInfo);
+    chat(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private _mode;
+    private _initials;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AvatarComponent, "bizdoc-avatar", never, { "person": "person"; "interactive": "interactive"; "dense": "dense"; }, {}, never, never>;
+}

package/lib/core/base.d.ts

@@ -0,0 +1,31 @@
+import { DocumentModel } from "../core/models";
+import { FormGroup } from "@angular/forms";
+import { Observable } from "rxjs";
+export declare type ViewMode = 'compose' | 'preview' | 'print' | 'version';
+export declare type FormMode = '';
+export interface FormComponent<TModel> extends ManagedComponent<TModel> {
+    form: FormGroup;
+    mode: ViewMode;
+    onBind(data: DocumentModel<TModel>, version?: TModel): void;
+    onMessage?<T = any>(obj: T): any;
+    onSave?(): Observable<boolean> | Promise<boolean> | boolean;
+}
+export interface ReportComponent<TResult, TArgs = any, TOptions = any> {
+    onBind(data: TResult[], args?: TArgs): any;
+}
+export interface ArgumentsComponent<TArgs = any> extends ManagedComponent<TArgs> {
+    form: FormGroup;
+}
+export interface ManagedComponent<TArgs> {
+}
+export interface WidgetComponent<TResult, TArgs = any> {
+    onBind(data: TResult, args?: TArgs): any;
+}
+export interface UtilityComponent<TResult = any, TArgs = any, TOptions = any> {
+}
+export interface ExploreItemComponent<TModel> {
+    onBind(data: TModel): any;
+}
+export interface DocumentViewComponent<TResult = any, TArgs = any, TOptions = any> {
+    onBind(model: DocumentModel<any>): any;
+}

package/lib/core/colors.d.ts

@@ -0,0 +1,6 @@
+export declare const FONT_FAMILY = "Roboto, monospace, sans-serif";
+export declare const MATERIAL_PALETTES: {
+    [name: string]: {
+        [name: string]: string;
+    };
+};

package/lib/core/component-factory-resolver.d.ts

@@ -0,0 +1,12 @@
+import { ComponentFactoryResolver } from "@angular/core";
+import * as i0 from "@angular/core";
+export declare function registerComponents(components: any[]): void;
+export declare class BizDocComponentFactoryResolver {
+    private _componentFactoryResolver;
+    private _factories;
+    constructor(_componentFactoryResolver: ComponentFactoryResolver);
+    component(componentSelector: string): any;
+    resolve(componentSelector: string): import("@angular/core").ComponentFactory<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BizDocComponentFactoryResolver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BizDocComponentFactoryResolver>;
+}

package/lib/core/configuration.d.ts

@@ -0,0 +1,113 @@
+import { InjectionToken, Type } from '@angular/core';
+import { Observable } from 'rxjs';
+import { FolderColumn } from './models';
+export declare const BIZDOC_CONFIG: InjectionToken<BizDocConfig>;
+export interface PaneRoute {
+    path: string;
+    guide?: string;
+    component?: Type<any>;
+    resolve?: {
+        [key: string]: Type<PaneResolve<any>>;
+    };
+    canDismiss?: Type<CanDismiss<any>>;
+    icon?: string;
+    help?: string;
+    children?: PaneRoute[];
+    policy?: OpenPolicy;
+}
+export declare type ParamMap = {
+    [key: string]: any;
+};
+export interface PaneResolve<T> {
+    onResolve(params: ParamMap, queryParams?: ParamMap): Observable<T> | Promise<T> | T;
+}
+export interface CanDismiss<T> {
+    onDismiss(component: T): boolean | Promise<boolean> | Observable<boolean>;
+}
+export declare enum OpenPolicy {
+    Pane = 1,
+    Clear = 2,
+    Defer = 4,
+    Pinnable = 8,
+    Stretch = 16,
+    Expandable = 32,
+    Toggle = 64,
+    Tab = 128,
+    Dialog = 384,
+    Dismissable = 512
+}
+export declare const DEFAULT_POLICY: OpenPolicy;
+export interface BizDocChildConfig {
+    components: Type<any>[];
+    routes?: PaneRoute[];
+}
+export interface Theme {
+    name: string;
+    primary: string;
+    accent: string;
+    color: string;
+    dark?: boolean;
+}
+/** BizDoc app options */
+export interface BizDocConfig {
+    currencyCode?: string;
+    /** available user interface languages */
+    themes?: Theme[];
+    languages?: string[];
+    appTitle?: string;
+    firebase?: FirebaseSettings;
+    chating?: ChatSettings | boolean;
+    comments?: CommentsSettings;
+    maps?: GoogleMapsSettings | boolean;
+    formats?: FormatsSettings;
+    routes?: PaneRoute[];
+    components: Type<any>[];
+    scheduler?: SchedulerSettings | boolean;
+    folders?: FoldersSettings;
+    analysis?: AnalysisSettings | boolean;
+}
+export declare type ScopeType = 'patterns' | 'positions';
+export interface AnalysisSettings {
+}
+export interface SchedulerSettings {
+}
+export interface FoldersSettings {
+    cube?: string;
+    axes?: string[];
+    columns?: FolderColumn[];
+}
+export interface FormatsSettings {
+    date?: string;
+    dateTime?: string;
+    fractionDigits?: number;
+}
+export interface CommentsSettings {
+    preserveDraft?: boolean;
+    voting?: boolean;
+}
+export interface ChatSettings {
+    preserveDraft?: boolean;
+    app?: string | ChatLauncherFn;
+}
+export declare interface ChatLauncherFn {
+    (identity: string): void;
+}
+export interface FirebaseSettings {
+    apiKey: string;
+    vapidKey?: string;
+    projectId: string;
+    senderId: string;
+    appId: string;
+    /** millisecondes before user is prompt to approve receiving messages */
+    grace?: number;
+}
+export interface GoogleMapsSettings {
+    apiKey: string;
+}
+export interface configuration {
+}
+export interface SharedConfig {
+    maps?: GoogleMapsSettings | boolean;
+    formats?: FormatsSettings;
+    routing?: 'ng' | 'pane';
+}

package/lib/core/controls/address.input.d.ts

@@ -0,0 +1,65 @@
+/// <reference types="google.maps" />
+import { OnDestroy, OnInit, ElementRef, EventEmitter } from '@angular/core';
+import { NgControl, ControlValueAccessor, FormControl } from '@angular/forms';
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class AddressInput implements MatFormFieldControl<string>, ControlValueAccessor, OnDestroy, OnInit {
+    ngControl: NgControl;
+    private _fm;
+    private _elRef;
+    private static nextId;
+    private _placeholder;
+    private _required;
+    private _disabled;
+    private _value?;
+    private _onChange;
+    private _onTouched;
+    _addresses: google.maps.places.QueryAutocompletePrediction[];
+    readonly control: FormControl;
+    readonly stateChanges: Subject<void>;
+    readonly id: string;
+    inputElement: ElementRef;
+    readonly optionSelected: EventEmitter<AddressChangeEvent>;
+    debounce: number;
+    location?: google.maps.LatLng;
+    country?: string | string[];
+    get placeholder(): string;
+    set placeholder(plh: string);
+    focused: boolean;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    get required(): boolean;
+    set required(req: boolean);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    errorState: boolean;
+    controlType?: string;
+    describedBy: string;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(): void;
+    writeValue(val: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    get value(): string;
+    set value(val: string);
+    private _setValue;
+    onFocus(): void;
+    onBlur(): void;
+    displayFn(address: google.maps.places.QueryAutocompletePrediction | string): string;
+    selected(e: MatAutocompleteSelectedEvent): void;
+    private readonly _destroy;
+    constructor(ngControl: NgControl, _fm: FocusMonitor, _elRef: ElementRef<HTMLElement>);
+    focus(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AddressInput, [{ optional: true; self: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AddressInput, "bizdoc-address", never, { "debounce": "debounce"; "location": "location"; "country": "country"; "placeholder": "placeholder"; "required": "required"; "disabled": "disabled"; "value": "value"; }, { "optionSelected": "optionSelected"; }, never, never>;
+}
+export interface AddressChangeEvent {
+    address: string;
+    placeId: string;
+}

package/lib/core/controls/auto-complete.input.d.ts

@@ -0,0 +1,86 @@
+import { OnDestroy, OnInit, ElementRef, EventEmitter, DoCheck } from '@angular/core';
+import { NgControl, ControlValueAccessor, FormControl } from '@angular/forms';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { MatAutocompleteSelectedEvent, MatAutocompleteTrigger } from '@angular/material/autocomplete';
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { Subject, Observable } from 'rxjs';
+import { SessionService } from '../session.service';
+import { DatasourceService } from '../datasource.service';
+import { FieldInfo } from '../models';
+import * as i0 from "@angular/core";
+export declare class TypeAutocomplete implements MatFormFieldControl<string>, DoCheck, ControlValueAccessor, OnDestroy, OnInit {
+    ngControl: NgControl;
+    private _fm;
+    private _elRef;
+    private _session;
+    private _service;
+    focus(): void;
+    private static nextId;
+    private _placeholder;
+    private _required;
+    private _disabled;
+    private _value?;
+    private _onChange;
+    private _onTouched;
+    readonly _control: FormControl;
+    readonly stateChanges: Subject<void>;
+    _items$: Observable<KeyValue[]>;
+    _column: FieldInfo;
+    private _configuration;
+    inputElement: ElementRef;
+    trigger: MatAutocompleteTrigger;
+    readonly id: string;
+    _type: string;
+    private _textFormControl;
+    get placeholder(): string;
+    set placeholder(plh: string);
+    text: string;
+    readonly textChange: EventEmitter<string>;
+    readonly optionSelected: EventEmitter<AutocompleteSelectedEvent>;
+    displayFn: (item: {
+        value: any;
+    }) => any;
+    _optionSelected(e: MatAutocompleteSelectedEvent): void;
+    focused: boolean;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    get required(): boolean;
+    set required(req: boolean);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    errorState: boolean;
+    controlType?: string;
+    describedBy: string;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(): void;
+    clear(): void;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    get value(): string;
+    set value(val: string);
+    private _minimumChars;
+    set minimumChars(val: number);
+    private _setValue;
+    ngDoCheck(): void;
+    _onFocus(): void;
+    _onBlur(): void;
+    set textFormControlName(val: string);
+    set textFormControl(val: FormControl);
+    private readonly _destroy;
+    constructor(ngControl: NgControl, _fm: FocusMonitor, _elRef: ElementRef<HTMLElement>, _session: SessionService, _service: DatasourceService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TypeAutocomplete, [{ optional: true; self: true; }, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TypeAutocomplete, "bizdoc-autocomplete", never, { "_type": "type"; "placeholder": "placeholder"; "text": "text"; "required": "required"; "disabled": "disabled"; "value": "value"; "minimumChars": "minimumChars"; "textFormControlName": "textFormControlName"; "textFormControl": "textFormControl"; }, { "textChange": "textChange"; "optionSelected": "optionSelected"; }, never, never>;
+}
+interface KeyValue {
+    key: any;
+    value: any;
+}
+export interface AutocompleteSelectedEvent {
+    readonly text: string;
+    readonly value: any;
+}
+export {};

package/lib/core/controls/combination-picker-body.d.ts

@@ -0,0 +1,114 @@
+import { OnDestroy, OnInit, InjectionToken, EventEmitter, QueryList, ChangeDetectorRef } from "@angular/core";
+import { FormBuilder } from "@angular/forms";
+import { MatSelect } from "@angular/material/select";
+import { CubeAxis } from "../models";
+import { SessionService } from "../session.service";
+import { CubeService } from "../../cube/cube.service";
+import { DatasourceService } from "../datasource.service";
+import { PromptService } from "../prompt.service";
+import { CubeInfo } from "../../cube/cube-info.service";
+import { SumSettings } from "../../cube/matrix/table.component";
+import * as i0 from "@angular/core";
+export declare const COMBINATION_PICKER_BODY: InjectionToken<CombinationBodyData>;
+export interface CombinationBodyData {
+    cube: string;
+    value: string;
+    limit: number;
+    divider: string;
+    displayDivider: string;
+    exploreSettings: ExploreSettings;
+}
+export interface ExploreSettings {
+    enable?: boolean;
+    /** cube view name */
+    view?: string;
+    defaults?: {
+        [axis: string]: (string | number);
+    };
+    indices?: string[] | string;
+    /** one or more axis */
+    filters?: string[] | string;
+    xAxis: string;
+    series: string;
+    sum?: SumSettings | SumSettings[];
+    /** */
+    aggregate?: string[] | string;
+    seriesTotalLabel?: string;
+    xAxisTotalLabel?: string;
+}
+export declare type Mode = 'filter' | 'results';
+/** */
+export declare class CombinationPickerBody implements OnInit, OnDestroy {
+    private _fb;
+    private _snackbar;
+    private _accountInfo;
+    private _ds;
+    private _cd;
+    private _session;
+    private _service;
+    readonly selectionChange: EventEmitter<CombinationSelectedEvent>;
+    readonly modeChange: EventEmitter<Mode>;
+    mode: Mode;
+    axes: QueryList<MatSelect>;
+    readonly _explorable: boolean;
+    _working: boolean;
+    readonly _axes: CubeAxis[];
+    readonly _form: import("@angular/forms").FormGroup;
+    readonly _keys: {
+        [type: string]: (string | number)[];
+    };
+    readonly _values: {
+        [type: string]: {
+            [key: string]: any;
+        } | {
+            [key: number]: any;
+        };
+    };
+    _combinations: string[][];
+    private _data;
+    private _cube;
+    constructor(dialogData: CombinationBodyData, overlayData: CombinationBodyData, _fb: FormBuilder, _snackbar: PromptService, _accountInfo: CubeInfo, _ds: DatasourceService, _cd: ChangeDetectorRef, _session: SessionService, _service: CubeService);
+    ngOnInit(): void;
+    /**
+     *
+     * @param code
+     */
+    private _patchForm;
+    /**
+     *
+     * @param val
+     */
+    _switchMode(val: Mode): void;
+    /**
+     * filter */
+    _filter(): void;
+    /**
+     * item select
+     * @param code
+     */
+    _select(axes: string[]): void;
+    /**
+     *
+     * @param codes
+     */
+    _codeOf(codes: string[]): string;
+    /**
+     * translate code segments to names
+     * @param code
+     */
+    _nameOf(codes: string[]): string;
+    /**
+     * open info
+     * @param code
+     * @param evt
+     */
+    _info(codes: string[], evt: Event): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CombinationPickerBody, [{ optional: true; }, { optional: true; }, null, null, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CombinationPickerBody, "bizdoc-combination-picker-body", never, {}, {}, never, never>;
+}
+export interface CombinationSelectedEvent {
+    readonly value: string;
+    readonly description: string;
+    readonly axes: string[];
+}