@bizdoc/core 1.13.12 → 1.13.16

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

@@ -0,0 +1,88 @@
+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>);
+    hasVersion(item: Attachment): boolean;
+    getVersions(item: Attachment): Attachment[];
+    download(item: AttachmentExtra): void;
+    previewOrDownload(item: AttachmentExtra): void;
+    canPreview(item: AttachmentExtra): boolean;
+    canEdit(item: AttachmentExtra): boolean;
+    openPreview(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;
+    prompt(): void;
+    private _prompt;
+    _change(evt: InputEvent): void;
+    private _createItem;
+    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, DoCheck } 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, DoCheck, OnDestroy {
+    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;
+    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>;
+    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>;
+    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;
+    ngDoCheck(): 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,50 @@
+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;
+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;
+        sum(predicate: (i: T) => number): number;
+        max(predicate: (i: T) => number): number;
+    }
+    interface String {
+        formatArgs(...args: any[]): string;
+        normalize(): string;
+    }
+    interface Object {
+        deepAssign(val1: any, val2: any): any;
+    }
+}
+/**
+ *
+ * @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 i
+     */
+    private _move;
+    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,32 @@
+import { Injector } from '@angular/core';
+import { Overlay } 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 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): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GuideService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GuideService>;
+}

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

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

@@ -0,0 +1,133 @@
+import { Comment, Notification, Chat, AvailabilityState, RecipientModel } from './models';
+import { HubConnectionState } from '@microsoft/signalr';
+import { AuthenticationImpl } from './authentication';
+import * as i0 from "@angular/core";
+/** Listen to hub contracts */
+export declare class HubService {
+    private _auth;
+    private _connection;
+    private readonly _state;
+    readonly state$: import("rxjs").Observable<HubConnectionState>;
+    private readonly _configurationChange;
+    private readonly _newMail;
+    private readonly _newChat;
+    private readonly _newComment;
+    private readonly _commentUpdate;
+    private readonly _commentDelete;
+    private readonly _updateMail;
+    private readonly _mailDelete;
+    private readonly _mailHeaderUpdate;
+    private readonly _newNotify;
+    private readonly _updateNotify;
+    private readonly _profileChange;
+    private readonly _editing;
+    private readonly _commentTyping;
+    private readonly _chatTyping;
+    private readonly _chatWathermark;
+    private readonly _voted;
+    private readonly _jobProgress;
+    private readonly _reportProgress;
+    private readonly _callback;
+    readonly configurationChange$: import("rxjs").Observable<void>;
+    readonly jobProgress$: import("rxjs").Observable<JobProgressEvent>;
+    readonly reportProgress$: import("rxjs").Observable<ReportProgressEvent>;
+    readonly callback$: import("rxjs").Observable<CallbackEvent>;
+    readonly vote$: import("rxjs").Observable<VoteEvent>;
+    readonly chatTyping$: import("rxjs").Observable<ChatTypingEvent>;
+    readonly chatWatermark$: import("rxjs").Observable<ChatWatermarkEvent>;
+    readonly commentTyping$: import("rxjs").Observable<CommentTypingEvent>;
+    readonly editing$: import("rxjs").Observable<EditingEvent>;
+    readonly commentUpdate$: import("rxjs").Observable<CommentEvent>;
+    readonly commentDelete$: import("rxjs").Observable<CommentDeleteEvent>;
+    /** new notification */
+    readonly notify$: import("rxjs").Observable<NotificationEvent>;
+    readonly chat$: import("rxjs").Observable<ChatEvent>;
+    readonly updateNotify$: import("rxjs").Observable<NotificationEvent>;
+    /** new mail */
+    readonly new$: import("rxjs").Observable<NewMailEvent>;
+    /** mail update */
+    readonly update$: import("rxjs").Observable<MailUpdateEvent>;
+    readonly updateMailHeader$: import("rxjs").Observable<MailUpdateEvent>;
+    readonly delete$: import("rxjs").Observable<MailDeleteEvent>;
+    readonly comment$: import("rxjs").Observable<CommentEvent>;
+    readonly profileChange$: import("rxjs").Observable<UserInfoEvent>;
+    constructor(_auth: AuthenticationImpl);
+    get state(): HubConnectionState;
+    get connectionId(): string;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HubService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HubService>;
+}
+export interface NewMailEvent {
+    userId: string;
+    model: RecipientModel<any>;
+}
+export interface MailUpdateEvent {
+    model: RecipientModel<any>;
+    userId: string;
+    time: Date;
+    originalRead?: boolean;
+}
+export interface ChatEvent {
+    contactId: string;
+    model: Chat;
+}
+export interface ChatTypingEvent {
+    contactId: string;
+}
+export interface ChatWatermarkEvent {
+    contactId: string;
+    time: Date;
+}
+export interface CommentTypingEvent {
+    id: number;
+    userId: string;
+}
+export interface EditingEvent {
+    id: number;
+    userId: string;
+}
+export interface MailDeleteEvent {
+    id: number;
+}
+export interface CommentEvent {
+    id: number;
+    model: Comment;
+}
+export interface CommentDeleteEvent {
+    id: number;
+    commentId: number;
+}
+export interface VoteEvent {
+    id: number;
+    commentId: number;
+    votes?: number;
+    userId: string;
+    vote?: number;
+}
+export interface NotificationEvent {
+    originalRead?: boolean;
+    model: Notification;
+}
+export interface UserInfoEvent {
+    userId: string;
+    mode: AvailabilityState;
+}
+export interface CallbackEvent {
+    message: any;
+}
+export interface JobProgressEvent {
+    jobId: string;
+    event: JobProgress;
+}
+export interface ReportProgressEvent {
+    name: string;
+    progress: number;
+}
+export interface JobProgress {
+    value: number;
+    file?: string;
+    message?: string;
+    buferringValue?: number;
+}

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

@@ -0,0 +1,29 @@
+import { OnChanges } from '@angular/core';
+import { SessionService } from '../session.service';
+import { TranslateService } from '../translate.service';
+import { AccountService } from '../account.service';
+import { BizDocConfig } from '../../core/configuration';
+import { ChatInfo } from '../../chat/chat-info';
+import * as i0 from "@angular/core";
+export declare class IdentityName implements OnChanges {
+    private _session;
+    private _translate;
+    private _chat;
+    private _accounts;
+    identity: string;
+    by?: string;
+    chating?: 'none' | 'room' | 'full';
+    isMe: boolean;
+    name: string;
+    /** identity ctor */
+    constructor(_session: SessionService, _translate: TranslateService, config: BizDocConfig, _chat: ChatInfo, _accounts: AccountService);
+    ngOnChanges(): void;
+    private _formatUserElement;
+    /**
+     * Chat
+     * @param e
+     */
+    chat(e: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IdentityName, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IdentityName, "bizdoc-identity-name", never, { "identity": "identity"; "by": "by"; "chating": "chating"; }, {}, never, never>;
+}