@bizdoc/core 1.14.9 → 1.14.10

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>;
+}

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

@@ -0,0 +1,99 @@
+import { ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { NgControl, ControlValueAccessor } from '@angular/forms';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { DomSanitizer } from '@angular/platform-browser';
+import { Subject } from 'rxjs';
+import { AttachmentInfo } from '../info/attachment-info.service';
+import { AttachmentExtra, MailboxService } from '../mailbox.service';
+import { Attachment, RecipientModel } from '../models';
+import { PromptService } from '../prompt.service';
+import { SessionService } from '../session.service';
+import { TranslateService } from '../translate.service';
+import * as i0 from "@angular/core";
+export declare class FileInput implements MatFormFieldControl<number | number[]>, ControlValueAccessor, OnInit, OnDestroy {
+    private _dropableElement;
+    private _mailbox;
+    private _sanitizer;
+    private _attachmentInfo;
+    private _translate;
+    private _session;
+    private _sb;
+    ngControl: NgControl;
+    private _model;
+    private static nextId;
+    readonly id: string;
+    readonly stateChanges: Subject<void>;
+    private _multiple;
+    get multiple(): boolean;
+    set multiple(value: boolean);
+    accept: any;
+    icon: string;
+    _input: ElementRef<HTMLInputElement>;
+    items: AttachmentExtra[];
+    private _placeholder;
+    private _required;
+    private _disabled;
+    private _onChange;
+    private _onTouched;
+    private _value;
+    private readonly _dragDrop;
+    private readonly _pending;
+    constructor(_dropableElement: ElementRef, _mailbox: MailboxService, _sanitizer: DomSanitizer, _attachmentInfo: AttachmentInfo, _translate: TranslateService, _session: SessionService, _sb: PromptService, ngControl: NgControl, _model: RecipientModel<any>);
+    hasVersions(item: Attachment): boolean;
+    getVersions(item: Attachment): Attachment[];
+    download(item: AttachmentExtra): void;
+    previewOrDownload(item: AttachmentExtra): void;
+    canEdit(item: AttachmentExtra): boolean;
+    apreview(item: AttachmentExtra): void;
+    cancel(item: AttachmentExtra): void;
+    checkIn(item: AttachmentExtra): void;
+    checkOut(item: AttachmentExtra): void;
+    discard(item: AttachmentExtra): void;
+    private _handleError;
+    ngOnInit(): void;
+    handleDocumentDrop(event: KeyboardEvent): void;
+    handleDrop(event: DragEvent): void;
+    handleEnter(event: DragEvent): void;
+    handleLeave(event: DragEvent): void;
+    handleOver(event: DragEvent): void;
+    writeValue(val: number | number[]): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    get value(): number | number[];
+    set value(val: number | number[]);
+    get placeholder(): string;
+    set placeholder(plh: string);
+    focused: boolean;
+    get empty(): boolean;
+    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;
+    open(): void;
+    private _prompt;
+    /**
+     *
+     * @param evt
+     */
+    _change(evt: InputEvent): void;
+    /**
+     *
+     * @param attachment
+     */
+    private _createItem;
+    /**
+     *
+     * @param files
+     */
+    private _upload;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileInput, [null, null, null, null, null, null, null, { optional: true; self: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileInput, "bizdoc-file-upload", never, { "multiple": "multiple"; "accept": "accept"; "icon": "icon"; "value": "value"; "placeholder": "placeholder"; "required": "required"; "disabled": "disabled"; }, {}, never, never>;
+}

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

@@ -0,0 +1,84 @@
+import { OnDestroy, OnInit, ElementRef, EventEmitter } from '@angular/core';
+import { NgControl, ControlValueAccessor, FormControl } from '@angular/forms';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { MatSelect } from '@angular/material/select';
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { Subject, Observable } from 'rxjs';
+import { FieldInfo } from '../models';
+import { SessionService } from '../session.service';
+import { DatasourceService } from '../datasource.service';
+import { ScopeType } from '../configuration';
+import * as i0 from "@angular/core";
+export declare class TypeSelect implements MatFormFieldControl<string | string[]>, ControlValueAccessor, OnInit, OnDestroy {
+    ngControl: NgControl;
+    private _fm;
+    private _elRef;
+    private _session;
+    private _service;
+    private static nextId;
+    private _placeholder;
+    private _required;
+    private _disabled;
+    private _value?;
+    private _onChange;
+    private _onTouched;
+    private _multiple;
+    readonly _control: FormControl;
+    _items$: Observable<KeyValue[]>;
+    _column: FieldInfo;
+    private _configuration;
+    readonly stateChanges: Subject<void>;
+    inputElement: MatSelect;
+    id: string;
+    type: string;
+    scope: ScopeType;
+    readonly selectionChange: EventEmitter<SelectEvent>;
+    touched: boolean;
+    set multiple(val: boolean);
+    get multiple(): 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(val: boolean);
+    text: string;
+    readonly textChange: EventEmitter<string>;
+    get errorState(): boolean;
+    controlType?: string;
+    describedBy: string;
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(): void;
+    writeValue(val: any): void;
+    private _setValue;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    get value(): string | string[];
+    set value(val: string | string[]);
+    _onFocus(): void;
+    _onBlur(): void;
+    focus(): void;
+    _compareWithKey(option1: KeyValue, option2: KeyValue): boolean;
+    private readonly _destroy;
+    constructor(ngControl: NgControl, _fm: FocusMonitor, _elRef: ElementRef<HTMLElement>, _session: SessionService, _service: DatasourceService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TypeSelect, [{ optional: true; self: true; }, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TypeSelect, "bizdoc-select", never, { "type": "type"; "scope": "scope"; "multiple": "multiple"; "placeholder": "placeholder"; "required": "required"; "disabled": "disabled"; "text": "text"; "value": "value"; }, { "selectionChange": "selectionChange"; "textChange": "textChange"; }, never, never>;
+}
+interface KeyValue {
+    key: any;
+    value: any;
+}
+export interface SelectEvent {
+    readonly value?: any;
+    readonly text?: string;
+    readonly item?: any;
+    readonly values?: any[];
+    readonly items?: any[];
+}
+export {};

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

@@ -0,0 +1,52 @@
+import { OnInit, OnDestroy, ElementRef } from "@angular/core";
+import { FormControl, ControlValueAccessor, NgControl } from "@angular/forms";
+import { MatFormFieldControl } from "@angular/material/form-field";
+import { FocusMonitor } from "@angular/cdk/a11y";
+import { Subject } from "rxjs";
+import * as i0 from "@angular/core";
+export declare class TimePicker implements ControlValueAccessor, MatFormFieldControl<string>, OnInit, OnDestroy {
+    private _focusMonitor;
+    private _elementRef;
+    ngControl: NgControl;
+    private static nextId;
+    readonly controlType = "time-picker";
+    readonly id: string;
+    focused: boolean;
+    errorState: boolean;
+    describedBy: string;
+    onChange: (_: any) => void;
+    onTouched: () => void;
+    private _dateControl;
+    get empty(): boolean;
+    get shouldLabelFloat(): boolean;
+    dateControlName: string;
+    get placeholder(): string;
+    set placeholder(value: string);
+    private _placeholder;
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    readonly control: FormControl;
+    readonly stateChanges: Subject<void>;
+    readonly options: string[];
+    get value(): string | null;
+    set value(val: string | null);
+    private _setValue;
+    private readonly _destroy;
+    constructor(_focusMonitor: FocusMonitor, _elementRef: ElementRef<HTMLElement>, ngControl: NgControl);
+    setDescribedByIds(ids: string[]): void;
+    onContainerClick(event: MouseEvent): void;
+    writeValue(val: string | null): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    ngOnInit(): void;
+    private _appendTime;
+    private _validate;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimePicker, [null, null, { optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimePicker, "mat-time-picker", never, { "dateControlName": "dateControlName"; "placeholder": "placeholder"; "required": "required"; "disabled": "disabled"; "value": "value"; }, {}, never, never>;
+}

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

@@ -0,0 +1,55 @@
+import { OnDestroy, ElementRef, OnInit } from '@angular/core';
+import { NgControl, ControlValueAccessor, FormBuilder } from '@angular/forms';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/** */
+export declare class Timespan {
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    constructor(days?: number, hours?: number, minutes?: number);
+}
+export declare class TimespanInput implements MatFormFieldControl<string>, ControlValueAccessor, OnDestroy, OnInit {
+    ngControl: NgControl;
+    private _fb;
+    private _fm;
+    private _elRef;
+    private static nextId;
+    private _placeholder;
+    private _required;
+    private _disabled;
+    private _onChange;
+    private _onTouched;
+    readonly parts: import("@angular/forms").FormGroup;
+    readonly stateChanges: Subject<void>;
+    readonly id: 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;
+    focus(): void;
+    onContainerClick(event: MouseEvent): 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, _fb: FormBuilder, _fm: FocusMonitor, _elRef: ElementRef<HTMLElement>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimespanInput, [{ optional: true; self: true; }, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimespanInput, "bizdoc-timespan-input", never, { "placeholder": "placeholder"; "required": "required"; "disabled": "disabled"; "value": "value"; }, {}, never, never>;
+}

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

@@ -0,0 +1,46 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { ParamMap } from './configuration';
+import * as i0 from "@angular/core";
+/** */
+export declare class DatasourceService {
+    private _http;
+    keys(type: string): Observable<string[]>;
+    private _cache;
+    constructor(_http: HttpClient);
+    /**
+     *
+     * @param type
+     * @param key
+     */
+    get(type: string, key: string): Observable<any>;
+    /**
+     *
+     * @param type
+     * @param value
+     */
+    keyOf(type: string, value: any): Observable<any>;
+    /**
+     *
+     * @param type
+     * @param params
+     */
+    map(type: string, queryParams?: string | number | ParamMap): Observable<{
+        [name: string]: any;
+    }>;
+    /**
+     *
+     * @param type
+     * @param params
+     */
+    all(type: string, queryParams?: string | number | ParamMap): Observable<{
+        key: string;
+        value: any;
+    }[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatasourceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DatasourceService>;
+}
+export interface Options {
+    params?: any;
+    dependencies?: ParamMap;
+}

package/lib/core/decorators.d.ts

@@ -0,0 +1,17 @@
+export declare const REGISTRY: {
+    [name: string]: any;
+};
+/**
+ * @link BizDocComponentFactoryResolver
+ * @param args
+ */
+export declare function BizDoc(args: ComponentType): (cls: any) => any;
+export interface ComponentType {
+    selector: string;
+}
+/**
+ * gets a decorator of the requested type off of the given decorated type
+ * @param decoratedType to get decorator annotations off of
+ * @param decoratorType to search for out of all the decorators on decoratedType
+ * @returns decorator from the decoratedType of the decoratorType
+ */

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

@@ -0,0 +1,17 @@
+import { SessionService } from './session.service';
+import { FirebaseSettings } from '../core/configuration';
+export declare enum FirebaseState {
+    Activated = 0
+}
+export declare class FirebaseService {
+    private _config;
+    private _session;
+    private _messaging;
+    private _token;
+    private _state;
+    constructor(_config: FirebaseSettings, _session: SessionService);
+    get state(): FirebaseState;
+    activate(): void;
+    close(): Promise<any>;
+    private _activate;
+}

package/lib/core/functions.d.ts

@@ -0,0 +1,54 @@
+export declare type MaterialMode = 50 | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | 'A100' | 'A200' | 'A400' | 'A700';
+export declare function mapToArray(map: {
+    [key: string]: any;
+}): {
+    key: string;
+    value: any;
+}[];
+export declare function isImage(contentType: string): boolean;
+export declare function cleanup(params: any): any;
+export declare function outOfBound(element: HTMLElement): boolean;
+export declare function isMobile(): boolean;
+export declare function isFunction(val: any): val is Function;
+export declare function isBoolean(val: any): val is boolean;
+export declare function isObject(val: any): boolean;
+export declare function isPrimitive(val: any): boolean;
+export declare function isPromise(obj: any): obj is Promise<any>;
+export declare function isDate(val: any): val is Date;
+export declare function isArray(val: any): val is Array<any>;
+export declare function isString(val: any): val is string;
+export declare function getWarn(mode?: MaterialMode): string;
+export declare function playAudio(name: 'notification_simple-01' | 'alert_error-03'): void;
+/**
+ *
+ * @param o1
+ * @param o2
+ */
+export declare function deepAssign(o1: any, o2: any): any;
+declare global {
+    interface String {
+        decodeId: () => number;
+    }
+    interface Number {
+        encodeId: () => string;
+    }
+}
+declare global {
+    interface Array<T> {
+        remove(item: T): T[];
+        last(): T;
+        average(predicate: (i: T) => number): number;
+        distinct<M>(predicate: (i: T) => M): Set<M>;
+        sum(predicate: (i: T) => number): number;
+        max(predicate: (i: T) => number): number;
+    }
+    interface String {
+        formatArgs(...args: any[]): string;
+        normalize(): string;
+    }
+}
+/**
+ *
+ * @param args
+ */
+export declare function queryParams(args: any): {};

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

@@ -0,0 +1,31 @@
+import { OnInit, InjectionToken } from '@angular/core';
+import { Overlay, OverlayRef } from "@angular/cdk/overlay";
+import { GuideStep, Guide } from '../models';
+import { Router } from '@angular/router';
+import { SessionService } from '../session.service';
+import * as i0 from "@angular/core";
+export declare const TOUR_TOKEN: InjectionToken<Guide>;
+export declare class GuideComponent implements OnInit {
+    private _data;
+    private _session;
+    private _overlay;
+    private _ngRouter;
+    private _overlayRef;
+    step: GuideStep;
+    index: number;
+    readonly count: number;
+    working: boolean;
+    constructor(_data: Guide, _session: SessionService, _overlay: Overlay, _ngRouter: Router, _overlayRef: OverlayRef);
+    ngOnInit(): void;
+    /**
+     *
+     * @param steps
+     */
+    private _moveBy;
+    keydown(evt: KeyboardEvent): void;
+    next(): void;
+    prev(): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GuideComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GuideComponent, "ng-component", never, {}, {}, never, never>;
+}

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

@@ -0,0 +1,38 @@
+import { Injector } from '@angular/core';
+import { Overlay, OverlayRef } from "@angular/cdk/overlay";
+import { BizDocConfig } from '../configuration';
+import { Guide } from '../models';
+import { SessionService } from '../session.service';
+import { TranslateService } from '../translate.service';
+import * as i0 from "@angular/core";
+export declare class GuideRef {
+    private _guide;
+    private _overlayRef;
+    constructor(_guide: Guide, _overlayRef: OverlayRef);
+    closed(): import("rxjs").Observable<void>;
+}
+/** */
+export declare class GuideService {
+    private _overlay;
+    private _injector;
+    private _session;
+    private _translate;
+    private _config;
+    private _guides;
+    constructor(_overlay: Overlay, _injector: Injector, _session: SessionService, _translate: TranslateService, _config: BizDocConfig);
+    /** */
+    private _intro;
+    get guides(): Guide[];
+    /**
+     *
+     * @param name
+     */
+    seen(name: string): boolean;
+    /**
+     *
+     * @param options
+     */
+    start(options: Guide | string): GuideRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GuideService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GuideService>;
+}

package/lib/core/guide/help-tip.component.d.ts

@@ -0,0 +1,16 @@
+import { OnInit } from '@angular/core';
+import { GuideService } from './guide.service';
+import * as i0 from "@angular/core";
+/**  */
+export declare class HelpTipComponent implements OnInit {
+    private _guide;
+    name: string;
+    _message: string;
+    showTip: boolean;
+    constructor(_guide: GuideService);
+    ngOnInit(): void;
+    open(evt: MouseEvent): void;
+    dismiss(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HelpTipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HelpTipComponent, "bizdoc-help-tip", never, { "name": "name"; }, {}, never, never>;
+}

package/lib/core/http.interceptor.d.ts

@@ -0,0 +1,21 @@
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { HubService } from './hub.service';
+import { SessionService } from './session.service';
+import { AuthenticationImpl } from './authentication';
+import { RouterImpl } from './router';
+import * as i0 from "@angular/core";
+export declare class AppHttpInterceptor implements HttpInterceptor {
+    private _session;
+    private _router;
+    private _auth;
+    private _messaging;
+    private readonly _ongoing;
+    private _authenticating;
+    readonly active$: Observable<boolean>;
+    private _baseUrl;
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    constructor(baseUrl: string, _session: SessionService, _router: RouterImpl, _auth: AuthenticationImpl, _messaging: HubService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppHttpInterceptor, [{ optional: true; }, null, null, null, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppHttpInterceptor>;
+}