@bizdoc/core 1.13.12 → 1.13.13

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").AnimationTriggerMetadata;
+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,29 @@
+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> {
+    form: FormGroup;
+    mode: ViewMode;
+    onBind(data: DocumentModel<TModel>, version?: TModel): void;
+    onMessage?(obj: any): 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> {
+    form: FormGroup;
+}
+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,111 @@
+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,
+    Expandable = 16,
+    Tab = 48,
+    Dialog = 112,
+    Dismissable = 128,
+    Toggle = 256
+}
+export declare const DEFAULT_POLICY: OpenPolicy;
+export interface BizDocChildConfig {
+    components: Type<any>[];
+}
+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,63 @@
+/// <reference types="googlemaps" />
+import { OnDestroy, OnInit, ElementRef, EventEmitter } from '@angular/core';
+import { NgControl, ControlValueAccessor, FormControl } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
+import { FocusMonitor } from '@angular/cdk/a11y';
+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;
+    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"; "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[];
+}

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

@@ -0,0 +1,82 @@
+import { ViewContainerRef, ElementRef, EventEmitter, OnDestroy, OnInit, DoCheck, Injector } from "@angular/core";
+import { ControlValueAccessor, NgControl } from "@angular/forms";
+import { Overlay } from "@angular/cdk/overlay";
+import { MatFormField, MatFormFieldControl } from "@angular/material/form-field";
+import { MatDialog } from "@angular/material/dialog";
+import { FocusMonitor } from "@angular/cdk/a11y";
+import { Directionality } from "@angular/cdk/bidi";
+import { Subject } from "rxjs";
+import { CombinationSelectedEvent, ExploreSettings } from "./combination-picker-body";
+import * as i0 from "@angular/core";
+export declare class CombinationPicker implements MatFormFieldControl<string>, ControlValueAccessor, OnInit, DoCheck, OnDestroy {
+    ngControl: NgControl;
+    private _formField;
+    private _overlay;
+    private _dialog;
+    private _vc;
+    private _injector;
+    private _fm;
+    private _elementRef;
+    private _dir;
+    private static nextId;
+    private _placeholder;
+    private _required;
+    private _disabled;
+    private _onChange;
+    private _onTouched;
+    private _value;
+    private _opened;
+    private _limit;
+    private _overlayRef;
+    private _portal;
+    private _dialogRef;
+    readonly stateChanges: Subject<void>;
+    _divider: string;
+    _displayDivider: string;
+    set limit(val: number);
+    get limit(): number;
+    cube: string;
+    exploreSettings?: ExploreSettings;
+    readonly optionSelected: EventEmitter<CombinationSelectedEvent>;
+    private _description;
+    set description(val: string);
+    get description(): string;
+    readonly descriptionChange: EventEmitter<string>;
+    readonly id: string;
+    touchUi: boolean;
+    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(evt: MouseEvent): void;
+    open(evt: Event): void;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    get value(): string | null;
+    set value(value: string | null);
+    private readonly _destroy;
+    constructor(ngControl: NgControl, _formField: MatFormField, _overlay: Overlay, _dialog: MatDialog, _vc: ViewContainerRef, _injector: Injector, _fm: FocusMonitor, _elementRef: ElementRef, _dir: Directionality);
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    _keyDown(evt: KeyboardEvent): void;
+    private _open;
+    private _attach;
+    private _reposition;
+    private _createOverlayRef;
+    private _getConnectedOverlayOrigin;
+    close(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CombinationPicker, [{ optional: true; self: true; }, { optional: true; }, null, null, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CombinationPicker, "bizdoc-combination-picker", never, { "_divider": "divider"; "_displayDivider": "displayDivider"; "limit": "limit"; "cube": "cube"; "exploreSettings": "exploreSettings"; "description": "description"; "touchUi": "touchUi"; "placeholder": "placeholder"; "required": "required"; "disabled": "disabled"; "value": "value"; }, { "optionSelected": "optionSelected"; "descriptionChange": "descriptionChange"; }, never, never>;
+}

package/lib/core/controls/combination-pool.d.ts

@@ -0,0 +1,42 @@
+import { OnInit, EventEmitter, OnDestroy } from "@angular/core";
+import { FormBuilder, FormGroup } from "@angular/forms";
+import { SessionService } from "../session.service";
+import { CubeService } from "../../cube/cube.service";
+import { CubeAxis, Cube } from "../models";
+import { MatFormFieldAppearance } from "@angular/material/form-field";
+import * as i0 from "@angular/core";
+export declare class CombinationPool implements OnInit, OnDestroy {
+    private _service;
+    private _fb;
+    private _session;
+    form: FormGroup;
+    appearance?: MatFormFieldAppearance;
+    cube: string;
+    model: {
+        [axis: string]: (string | number);
+    };
+    source: 'constraints' | 'combinations';
+    readonly modelChange: EventEmitter<{
+        [axis: string]: string | number;
+    }>;
+    _axes: CubeAxis[];
+    _cube: Cube;
+    working: boolean;
+    readonly _keys: {
+        [type: string]: string[];
+    };
+    readonly _values: {
+        [type: string]: {
+            [key: string]: any;
+        };
+    };
+    private readonly _destroy;
+    constructor(_service: CubeService, _fb: FormBuilder, _session: SessionService);
+    ngOnInit(): void;
+    private _populate;
+    clear(axis: string): void;
+    clearAll(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CombinationPool, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CombinationPool, "bizdoc-combination-pool", never, { "form": "formGroup"; "appearance": "appearance"; "cube": "cube"; "model": "model"; "source": "source"; }, { "modelChange": "modelChange"; }, never, never>;
+}