@ts-core/angular 19.0.15 → 21.0.0

package/types/ts-core-angular.d.ts

@@ -0,0 +1,1824 @@
+import { Loadable, LoadableStatus, Destroyable, IDestroyable, DestroyableContainer, ClassType, ObservableData, PromiseHandler, ExtendedError, IUIDable, FilterableMapCollection, Logger, MapCollection, Transport, TransportLocal, ILogger, ITransportSettings, ITransportCommand, ITransportCommandOptions, ITransportEvent, TransportEvent, LoggerLevel } from '@ts-core/common';
+import { NativeWindowService, SettingsServiceBase, ThemeService, LanguageService, ICookieOptions, ICookieService, ILanguageServiceOptions, ThemeAssetService, IThemeServiceOptions } from '@ts-core/frontend';
+import { ILanguageLoader, LanguageLoadFunction, ILanguageProjectSettings } from '@ts-core/language';
+import { Router, ActivatedRoute, NavigationExtras, UrlTree, ActivatedRouteSnapshot, Resolve, RouterStateSnapshot, CanActivate, MaybeAsync, GuardResult, CanDeactivate, CanDeactivateFn } from '@angular/router';
+import * as i0 from '@angular/core';
+import { AfterViewInit, ElementRef, ViewContainerRef, InjectionToken, Injector, PipeTransform, ModuleWithProviders, EventEmitter, TemplateRef, EmbeddedViewRef, ChangeDetectorRef, Renderer2, RendererStyleFlags2, NgModuleFactory, Type, NgModuleRef, Compiler, RendererFactory2 } from '@angular/core';
+import { Observable, BehaviorSubject, Subscription } from 'rxjs';
+import * as i8 from '@angular/common';
+import { DatePipe } from '@angular/common';
+import * as Cookie from 'ngx-cookie';
+import { NgControl, ValidationErrors } from '@angular/forms';
+import { Moment } from 'moment';
+import { DomSanitizer, SafeHtml, SafeStyle, SafeScript, SafeUrl, SafeResourceUrl } from '@angular/platform-browser';
+import { SwUpdate, VersionReadyEvent, UnrecoverableStateEvent, VersionDetectedEvent, VersionInstallationFailedEvent, NoNewVersionDetectedEvent } from '@angular/service-worker';
+
+declare class RouterServiceBase extends Loadable<void, RouterServiceBaseEventData> {
+    protected _router: Router;
+    protected _route: ActivatedRoute;
+    protected window: NativeWindowService;
+    protected params: Map<string, string>;
+    protected extrasToApply: NavigationExtras;
+    protected isNeedUpdateExtras: boolean;
+    protected _lastUrl: string;
+    protected _previousUrl: string;
+    constructor(_router: Router, _route: ActivatedRoute, window: NativeWindowService);
+    protected initializeObservers(): void;
+    protected applyExtras(extras?: NavigationExtras): Promise<boolean>;
+    protected getQueryParams(): any;
+    protected commitStatusChangedProperties(oldStatus: LoadableStatus, newStatus: LoadableStatus): void;
+    navigate(url: string, extras?: NavigationExtras, isClearParams?: boolean): Promise<boolean>;
+    navigateToExternalUrl(url: string, target?: string): void;
+    navigateToLast(extras?: NavigationExtras): Promise<boolean>;
+    navigateIfNotLoading(url: string, extras?: NavigationExtras): Promise<boolean>;
+    reload(): void;
+    isUrlActive(item: string | UrlTree, isExact?: boolean): boolean;
+    getParams<T = any>(): T;
+    hasParam(name: string): boolean;
+    getParam<T = string>(name: string, defaultValue?: T): T;
+    setParam(name: string, value: any, extras?: NavigationExtras): void;
+    removeParam(name: string, extras?: NavigationExtras): void;
+    clearParams(extras?: NavigationExtras): void;
+    get hasParams(): boolean;
+    getFragment(snapshot?: ActivatedRouteSnapshot, defaultValue?: string): string;
+    hasFragment(snapshot?: ActivatedRouteSnapshot): boolean;
+    setFragment(value: string): Promise<boolean>;
+    get url(): string;
+    get urlTree(): UrlTree;
+    get lastUrl(): string;
+    get lastUrlTree(): UrlTree;
+    get previousUrl(): string;
+    get previousUrlTree(): UrlTree;
+    get route(): ActivatedRoute;
+    get router(): Router;
+}
+interface RouterServiceBaseEventData {
+    url: string;
+    previousUrl: string;
+}
+
+declare class PlatformService extends Destroyable {
+    private _isPlatformServer;
+    private _isPlatformBrowser;
+    constructor(platformId: string);
+    get isPlatformServer(): boolean;
+    get isPlatformBrowser(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PlatformService>;
+}
+
+interface IWindowConfig<T = any> {
+    id: string;
+    isModal: boolean;
+    isExpandable: boolean;
+    isResizeable: boolean;
+    isMinimizable: boolean;
+    isDisableClose: boolean;
+    isContentDragable: boolean;
+    x: number;
+    y: number;
+    elementMinX: number;
+    elementMaxX: number;
+    elementMinY: number;
+    elementMaxY: number;
+    elementMinWidth: number;
+    elementMaxWidth: number;
+    elementMinHeight: number;
+    elementMaxHeight: number;
+    width: string;
+    defaultWidth: number;
+    defaultMinWidth: number;
+    defaultMaxWidth: number;
+    height: string;
+    defaultHeight: number;
+    defaultMinHeight: number;
+    defaultMaxHeight: number;
+    paddingTop: number;
+    paddingLeft: number;
+    paddingRight: number;
+    paddingBottom: number;
+    propertiesId: string;
+    verticalAlign: WindowAlign;
+    horizontalAlign: WindowAlign;
+    data?: T;
+    autoFocus: string;
+    restoreFocus: boolean;
+    delayFocusTrap: boolean;
+}
+declare enum WindowAlign {
+    START = "START",
+    CENTER = "CENTER",
+    END = "END"
+}
+
+declare class WindowConfig<T = any> implements IWindowConfig<T>, IDestroyable {
+    id: string;
+    isModal: boolean;
+    isExpandable: boolean;
+    isResizeable: boolean;
+    isMinimizable: boolean;
+    isDisableClose: boolean;
+    isContentDragable: boolean;
+    x: number;
+    y: number;
+    data: T;
+    propertiesId: string;
+    width: string;
+    minWidth: number;
+    maxWidth: number;
+    defaultWidth: number;
+    defaultMinWidth: number;
+    defaultMaxWidth: number;
+    height: string;
+    minHeight: number;
+    maxHeight: number;
+    defaultHeight: number;
+    defaultMinHeight: number;
+    defaultMaxHeight: number;
+    paddingTop: number;
+    paddingLeft: number;
+    paddingRight: number;
+    paddingBottom: number;
+    autoFocus: string;
+    restoreFocus: boolean;
+    delayFocusTrap: boolean;
+    verticalAlign: WindowAlign;
+    horizontalAlign: WindowAlign;
+    protected _elementMaxX: number;
+    protected _elementMinX: number;
+    protected _elementMaxY: number;
+    protected _elementMinY: number;
+    protected _elementWidth: string;
+    protected _elementMinWidth: number;
+    protected _elementMaxWidth: number;
+    protected _elementHeight: string;
+    protected _elementMinHeight: number;
+    protected _elementMaxHeight: number;
+    constructor(isModal?: boolean, isResizeable?: boolean, width?: number, height?: number);
+    setDefaultProperties(): void;
+    destroy(): void;
+    get elementMinY(): number;
+    get elementMaxY(): number;
+    get elementMinX(): number;
+    get elementMaxX(): number;
+    get elementWidth(): string;
+    get elementMinWidth(): number;
+    get elementMaxWidth(): number;
+    get elementHeight(): string;
+    get elementMinHeight(): number;
+    get elementMaxHeight(): number;
+}
+type WindowConfigOptions<T = any> = {
+    [P in keyof WindowConfig<T>]?: any;
+};
+
+type WindowContentContainer = ElementRef | ViewContainerRef;
+declare const WINDOW_CONTENT_CONTAINER: InjectionToken<WindowContentContainer>;
+declare abstract class IWindowContent<T = any> extends DestroyableContainer implements AfterViewInit {
+    container: WindowContentContainer;
+    protected _window: IWindow<T>;
+    constructor(container: WindowContentContainer);
+    protected commitWindowProperties(): void;
+    protected commitConfigProperties(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    blink(): void;
+    shake(): void;
+    emit(event: string): void;
+    close(): void;
+    destroy(): void;
+    get data(): T;
+    get isOnTop(): boolean;
+    get isMinimized(): boolean;
+    get events(): Observable<string>;
+    set isDisabled(value: boolean);
+    get isDisabled(): boolean;
+    get element(): ElementRef;
+    get config(): IWindowConfig<T>;
+    get window(): IWindow<T>;
+    set window(value: IWindow<T>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<IWindowContent<any>, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IWindowContent<any>, "ng-component", never, { "isDisabled": { "alias": "isDisabled"; "required": false; }; "window": { "alias": "window"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_isDisabled: unknown;
+}
+
+declare abstract class IWindow<T = any> extends Destroyable {
+    abstract close(): void;
+    abstract blink(): void;
+    abstract shake(): void;
+    abstract setOnTop(): void;
+    abstract getWidth(): number;
+    abstract getHeight(): number;
+    abstract setWidth(value: number): void;
+    abstract setHeight(value: number): void;
+    abstract setSize(width: number, height: number): void;
+    abstract getX(): number;
+    abstract getY(): number;
+    abstract setX(value: number): void;
+    abstract setY(value: number): void;
+    abstract move(x: number, y: number): void;
+    abstract emit(event: string): void;
+    isOnTop: boolean;
+    isDisabled: boolean;
+    isMinimized: boolean;
+    readonly events: Observable<string>;
+    readonly container: HTMLElement;
+    readonly wrapper: HTMLElement;
+    readonly backdrop: HTMLElement;
+    readonly config: IWindowConfig<T>;
+    readonly content: IWindowContent<T>;
+}
+declare enum WindowEvent {
+    OPENED = "OPENED",
+    CLOSED = "CLOSED",
+    CONTENT_READY = "CONTENT_READY",
+    MOVED = "MOVED",
+    RESIZED = "RESIZED",
+    DISABLED_CHANGED = "DISABLED_CHANGED",
+    MINIMIZED_CHANGED = "MINIMIZED_CHANGED",
+    IS_ON_TOP_CHANGED = "IS_ON_TOP_CHANGED",
+    EXPAND = "EXPAND",
+    SET_ON_TOP = "SET_ON_TOP"
+}
+
+interface IQuestion {
+    readonly mode: QuestionMode;
+    readonly isChecked: boolean;
+    readonly text: string;
+    readonly notText: string;
+    readonly yesText: string;
+    readonly closeText: string;
+    readonly checkText: string;
+    readonly closePromise: Promise<void>;
+    readonly yesNotPromise: Promise<void>;
+}
+interface IQuestionOptions {
+    text?: string;
+    mode?: QuestionMode;
+    isChecked?: boolean;
+    yesTextId?: string;
+    notTextId?: string;
+    checkTextId?: string;
+    closeTextId?: string;
+}
+declare enum QuestionMode {
+    INFO = "INFO",
+    QUESTION = "QUESTION"
+}
+declare enum QuestionEvent {
+    YES = "YES",
+    NOT = "NOT",
+    CLOSE = "CLOSE",
+    CHECK = "CHECK",
+    UNCHECK = "UNCHECK"
+}
+
+declare enum WindowServiceEvent {
+    OPEN_STARTED = "OPEN_STARTED",
+    OPENED = "OPENED",
+    OPEN_FINISHED = "OPEN_FINISHED",
+    CLOSED = "CLOSED",
+    SETTED_ON_TOP = "SETTED_ON_TOP"
+}
+
+declare abstract class WindowService extends Destroyable {
+    abstract open<U extends IWindowContent<T>, T>(component: ClassType<U>, config: IWindowConfig<T>): U;
+    abstract get<T>(value: WindowId<T>): IWindowContent<T>;
+    abstract has<T>(value: WindowId<T>): boolean;
+    abstract setOnTop<T>(value: WindowId<T>): boolean;
+    abstract close<T>(value: WindowId<T>): void;
+    abstract closeAll(): void;
+    abstract info(translationId?: string, translation?: any, questionOptions?: IQuestionOptions, configOptions?: WindowConfigOptions): IQuestion;
+    abstract question(translationId?: string, translation?: any, questionOptions?: IQuestionOptions, configOptions?: WindowConfigOptions): IQuestion;
+    abstract get events(): Observable<ObservableData<WindowServiceEvent, IWindow>>;
+    abstract get windows(): Map<IWindowConfig, IWindowContent>;
+}
+type WindowId<T> = string | IWindowConfig<T>;
+
+declare abstract class ApplicationInitializerBase<S extends SettingsServiceBase, R extends RouterServiceBase, T = any, O extends ServerInitializeOptions<T> = ServerInitializeOptions<T>> extends Destroyable {
+    protected options?: O;
+    constructor(options?: O);
+    initialize(): Promise<void>;
+    protected initializeAsset(): Promise<void>;
+    protected initializeTheme(): Promise<void>;
+    protected initializeLanguage(): Promise<void>;
+    protected getLanguageLoader<T = any>(): Promise<ILanguageLoader<T>>;
+    protected abstract getLanguageLoadSettings<T = any>(): ILanguageLoadSettings<T>;
+    protected getConfig(): Promise<any>;
+    protected getConfigLocal<T = any>(): Promise<T>;
+    protected loadConfig<T = any>(url: string): Promise<T>;
+    protected abstract getConfigRemote<T = any>(local: any): Promise<T>;
+    protected abstract get theme(): ThemeService;
+    protected abstract get windows(): WindowService;
+    protected abstract get platform(): PlatformService;
+    protected abstract get language(): LanguageService;
+    protected abstract get router(): R;
+    protected abstract get settings(): S;
+}
+interface ILanguageLoadSettings<T = any> {
+    url: string;
+    proxy: LanguageLoadFunction<T>;
+    project: ILanguageProjectSettings;
+}
+declare abstract class ServerInitializeOptions<T = any> {
+    config: T;
+    locales: Map<string, any>;
+}
+
+declare abstract class ApplicationComponentBase extends DestroyableContainer implements AfterViewInit {
+    protected isReadyAlreadyCalled: boolean;
+    protected viewReadyDelay: number;
+    protected viewReadyPromise: PromiseHandler<void, void>;
+    constructor();
+    private makeViewReady;
+    protected checkReady(): void;
+    protected isReady(): boolean;
+    protected viewReadyHandler(): void;
+    protected abstract readyHandler(): void | Promise<void>;
+    ngAfterViewInit(): void;
+    destroy(): void;
+    get viewReady(): Promise<void>;
+    get isViewReady(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationComponentBase, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationComponentBase, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare abstract class ApplicationComponent extends ApplicationComponentBase {
+    private isLanguageLoaded;
+    protected initialize(): void;
+    protected initializeLanguage(): void;
+    protected isReady(): boolean;
+    protected languageLoadingComplete(locale: string): void;
+    protected abstract languageLoadingError(locale: string, error: Error): void;
+    protected viewReadyHandler(): void;
+    protected setLocale(item: string): void;
+    protected abstract get language(): LanguageService;
+}
+
+declare abstract class MessageComponentBase extends DestroyableContainer {
+    protected route: ActivatedRoute;
+    protected language: LanguageService;
+    text: string;
+    refreshText: string;
+    constructor(route: ActivatedRoute, language: LanguageService);
+    protected commitLanguageProperties(): void;
+    protected getText(): string;
+    protected getValue(data: any): string;
+    protected getMessageFields(): Array<string>;
+    abstract refresh(): void;
+}
+
+declare const APPLICATION_INJECTOR: (value?: Injector) => Injector;
+
+declare class AssetBackgroundDirective extends Destroyable {
+    private element;
+    private _isUrl;
+    private _isIcon;
+    private _isImage;
+    private _repeat;
+    private _extension;
+    private _background;
+    constructor(element: ElementRef);
+    protected setStyleProperties(): void;
+    private getUrl;
+    destroy(): void;
+    set isIcon(value: boolean);
+    get isIcon(): boolean;
+    set isImage(value: boolean);
+    get isImage(): boolean;
+    set isUrl(value: boolean);
+    get isUrl(): boolean;
+    set repeat(value: string);
+    get repeat(): string;
+    set extension(value: string);
+    get extension(): string;
+    set background(value: string);
+    get background(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssetBackgroundDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AssetBackgroundDirective, "[vi-asset-background]", never, { "isIcon": { "alias": "isIcon"; "required": false; }; "isImage": { "alias": "isImage"; "required": false; }; "isUrl": { "alias": "isUrl"; "required": false; }; "repeat": { "alias": "repeat"; "required": false; }; "extension": { "alias": "extension"; "required": false; }; "background": { "alias": "vi-asset-background"; "required": false; }; }, {}, never, never, false, never>;
+    static ngAcceptInputType_isIcon: unknown;
+    static ngAcceptInputType_isImage: unknown;
+    static ngAcceptInputType_isUrl: unknown;
+}
+
+declare class AssetBackgroundPipe implements PipeTransform {
+    transform(name: string, extension?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssetBackgroundPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AssetBackgroundPipe, "viAssetBackground", false>;
+}
+
+declare class AssetIconPipe implements PipeTransform {
+    transform(name: string, extension?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssetIconPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AssetIconPipe, "viAssetIcon", false>;
+}
+
+declare class AssetFilePipe implements PipeTransform {
+    transform(name: string, extension: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssetFilePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AssetFilePipe, "viAssetFile", false>;
+}
+
+declare class AssetVideoPipe implements PipeTransform {
+    transform(name: string, extension?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssetVideoPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AssetVideoPipe, "viAssetVideo", false>;
+}
+
+declare class AssetSoundPipe implements PipeTransform {
+    transform(name: string, extension?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssetSoundPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AssetSoundPipe, "viAssetSound", false>;
+}
+
+declare class AssetImagePipe implements PipeTransform {
+    transform(name: string, extension?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssetImagePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AssetImagePipe, "viAssetImage", false>;
+}
+
+declare class AssetModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssetModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AssetModule, [typeof AssetImagePipe, typeof AssetIconPipe, typeof AssetFilePipe, typeof AssetSoundPipe, typeof AssetVideoPipe, typeof AssetBackgroundPipe, typeof AssetBackgroundDirective], [typeof i8.CommonModule], [typeof AssetImagePipe, typeof AssetIconPipe, typeof AssetFilePipe, typeof AssetSoundPipe, typeof AssetVideoPipe, typeof AssetBackgroundPipe, typeof AssetBackgroundDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AssetModule>;
+}
+
+declare class CookieOptions implements ICookieOptions, Cookie.CookieOptions {
+    path?: string;
+    domain?: string;
+    expires?: string | Date;
+    secure?: boolean;
+    httpOnly?: boolean;
+    storeUnencoded?: boolean;
+}
+
+declare class CookieService extends Cookie.CookieService implements ICookieService {
+    constructor(document: Document, options: CookieOptions, isPlatformBrowser: boolean);
+    has(key: string): boolean;
+    get<T = string>(key: string, defaultValue?: T): T;
+    getObject<T = any>(key: string, defaultValue?: T): T;
+    put<T = string>(key: string, value: T, options?: CookieOptions): void;
+    putObject<T = any>(key: string, value: T, options?: CookieOptions): void;
+    update(key: string, value: string, options?: ICookieOptions): void;
+    updateObject(key: string, value: Object, options?: ICookieOptions): void;
+}
+
+declare class CookieModule {
+    static forRoot(options?: ICookieOptions): ModuleWithProviders<CookieModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CookieModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CookieModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CookieModule>;
+}
+declare function cookieServiceFactory(nativeWindow: NativeWindowService, options: ICookieOptions, platform: PlatformService): CookieService;
+declare const COOKIE_OPTIONS: InjectionToken<ICookieOptions>;
+
+declare class AspectRatioResizeDirective extends Destroyable implements AfterViewInit {
+    protected static UPDATE_DELAY: number;
+    private _ratio;
+    private _direction;
+    private sensor;
+    private element;
+    constructor(element: ElementRef);
+    private commitResizeProperties;
+    ngAfterViewInit(): void;
+    destroy(): void;
+    private get width();
+    private set width(value);
+    private get height();
+    private set height(value);
+    set direction(value: Direction);
+    get direction(): Direction;
+    set ratio(value: number);
+    get ratio(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AspectRatioResizeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AspectRatioResizeDirective, "[vi-aspect-ratio]", never, { "direction": { "alias": "vi-aspect-ratio"; "required": false; }; "ratio": { "alias": "ratio"; "required": false; }; }, {}, never, never, false, never>;
+    static ngAcceptInputType_ratio: unknown;
+}
+declare enum Direction {
+    VERTICAL = "VERTICAL",
+    HORIZONTAL = "HORIZONTAL"
+}
+
+declare class ScrollDirective extends Destroyable {
+    static INITIALIZATION_DELAY: number;
+    scrolled: EventEmitter<number>;
+    private timer;
+    protected element: HTMLElement;
+    protected isInitialized: boolean;
+    protected _scrollValue: number;
+    constructor(element: ElementRef);
+    protected initialize(): void;
+    protected scrollTo(value: number, behavior?: ScrollBehavior): void;
+    scrollHandler(): void;
+    protected scrollChangedHandler(): void;
+    protected initializeHandler: () => void;
+    protected get scrollTop(): number;
+    destroy(): void;
+    set scrollValue(value: number);
+    get scrollValue(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollDirective, "[vi-scroll]", never, { "scrollValue": { "alias": "scrollValue"; "required": false; }; }, { "scrolled": "scrolled"; }, never, never, false, never>;
+    static ngAcceptInputType_scrollValue: unknown;
+}
+
+declare class InfiniteScrollDirective extends ScrollDirective {
+    top: EventEmitter<number>;
+    bottom: EventEmitter<number>;
+    elementHeight: number;
+    protected scrollChangedHandler(): void;
+    destroy(): void;
+    protected get clientHeight(): number;
+    protected get scrollHeight(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InfiniteScrollDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InfiniteScrollDirective, "[vi-infinite-scroll]", never, { "elementHeight": { "alias": "elementHeight"; "required": false; }; }, { "top": "top"; "bottom": "bottom"; }, never, never, false, never>;
+    static ngAcceptInputType_elementHeight: unknown;
+}
+
+declare class AutoScrollBottomDirective extends InfiniteScrollDirective {
+    behavior: ScrollBehavior;
+    triggerChanged: EventEmitter<number>;
+    private _trigger;
+    private triggerTimer;
+    private triggerDelta;
+    private isScrollLocked;
+    private lastScrollHeight;
+    private isNeedScroll;
+    private isNeedRemainScroll;
+    protected initialize(): void;
+    protected checkTrigger: () => void;
+    protected scrollRemain(): void;
+    protected scrollChangedHandler(): void;
+    scrollCheck(): void;
+    scrollBottom(): void;
+    destroy(): void;
+    set trigger(value: number);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoScrollBottomDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoScrollBottomDirective, "[vi-auto-scroll-bottom]", never, { "behavior": { "alias": "behavior"; "required": false; }; "trigger": { "alias": "vi-auto-scroll-bottom"; "required": false; }; }, { "triggerChanged": "triggerChanged"; }, never, never, false, never>;
+}
+
+declare class ClickToCopyDirective extends Destroyable {
+    element: HTMLElement;
+    private selectionClearTimer;
+    protected clickHandler(event: MouseEvent): void;
+    private selectionRemove;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickToCopyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickToCopyDirective, "[vi-click-to-copy]", never, { "element": { "alias": "vi-click-to-copy"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ClickToSelectDirective extends Destroyable {
+    protected element: HTMLElement;
+    constructor(element: ElementRef);
+    protected clickHandler(event: MouseEvent): void;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickToSelectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickToSelectDirective, "[vi-click-to-select]", never, {}, {}, never, never, false, never>;
+}
+
+declare class FocusDirective<T = any> extends Destroyable {
+    private manager;
+    constructor(element: ElementRef);
+    protected focus: () => void;
+    destroy(): void;
+    set trigger(value: T);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FocusDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FocusDirective<any>, "[vi-focus]", never, { "trigger": { "alias": "vi-focus"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class SelectOnFocusDirective extends Destroyable {
+    private element;
+    constructor(element: ElementRef);
+    focusHandler(): void;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectOnFocusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectOnFocusDirective, "[vi-select-on-focus]", never, {}, {}, never, never, false, never>;
+}
+
+declare class ResizeDirective extends Destroyable {
+    resized: EventEmitter<any>;
+    isTop: boolean;
+    isLeft: boolean;
+    isRight: boolean;
+    isBottom: boolean;
+    private interactable;
+    constructor(element: ElementRef);
+    private resizeHandler;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizeDirective, "[vi-resize]", never, { "isTop": { "alias": "isTop"; "required": false; }; "isLeft": { "alias": "isLeft"; "required": false; }; "isRight": { "alias": "isRight"; "required": false; }; "isBottom": { "alias": "isBottom"; "required": false; }; }, { "resized": "resized"; }, never, never, false, never>;
+    static ngAcceptInputType_isTop: unknown;
+    static ngAcceptInputType_isLeft: unknown;
+    static ngAcceptInputType_isRight: unknown;
+    static ngAcceptInputType_isBottom: unknown;
+}
+
+declare class StructureDirective<T = any> extends Destroyable {
+    protected template: TemplateRef<T>;
+    protected container: ViewContainerRef;
+    protected view: EmbeddedViewRef<T>;
+    protected _isNeedAdd: boolean;
+    constructor(template: TemplateRef<T>, container: ViewContainerRef);
+    protected commitIsNeedAddProperties(): void;
+    destroy(): void;
+    protected set isNeedAdd(value: boolean);
+    protected get isNeedAdd(): boolean;
+}
+
+declare class ScrollCheckDirective extends Destroyable {
+    top: EventEmitter<boolean>;
+    bottom: EventEmitter<boolean>;
+    limitExceed: EventEmitter<boolean>;
+    private _scrollLimit;
+    private element;
+    private isExceedLimit;
+    delay: number;
+    offset: number;
+    constructor(element: ElementRef);
+    protected check: () => void;
+    protected get scrollValue(): number;
+    protected get scrollHeight(): number;
+    protected get clientHeight(): number;
+    set scrollLimit(value: number);
+    get scrollLimit(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollCheckDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollCheckDirective, "[vi-scroll-check]", never, { "delay": { "alias": "delay"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "scrollLimit": { "alias": "vi-scroll-check"; "required": false; }; }, { "top": "top"; "bottom": "bottom"; "limitExceed": "limitExceed"; }, never, never, false, never>;
+    static ngAcceptInputType_delay: unknown;
+    static ngAcceptInputType_offset: unknown;
+}
+
+declare class HTMLTitleDirective extends Destroyable {
+    protected element: ElementRef;
+    protected _value: string;
+    constructor(element: ElementRef);
+    protected commitValueProperties(): void;
+    destroy(): void;
+    set value(value: string);
+    get value(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HTMLTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HTMLTitleDirective, "[vi-html-title]", never, { "value": { "alias": "vi-html-title"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HTMLContentTitleDirective extends Destroyable {
+    protected element: ElementRef;
+    protected _value: string;
+    constructor(element: ElementRef);
+    protected commitValueProperties(): void;
+    destroy(): void;
+    set value(value: string);
+    get value(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HTMLContentTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HTMLContentTitleDirective, "[vi-html-content-title]", never, { "value": { "alias": "vi-html-content-title"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class IsBrowserDirective extends StructureDirective {
+    constructor(templateRef: TemplateRef<any>, container: ViewContainerRef, platform: PlatformService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsBrowserDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IsBrowserDirective, "[viIsBrowser]", never, {}, {}, never, never, false, never>;
+}
+
+declare class IsServerDirective extends StructureDirective {
+    constructor(templateRef: TemplateRef<any>, container: ViewContainerRef, platform: PlatformService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsServerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IsServerDirective, "[viIsServer]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NullEmptyValueDirective {
+    protected control: NgControl;
+    constructor(control: NgControl);
+    onEvent(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NullEmptyValueDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NullEmptyValueDirective, "input[nullEmptyValue]", never, {}, {}, never, never, false, never>;
+}
+
+declare class UppercaseValueDirective {
+    protected control: NgControl;
+    constructor(control: NgControl);
+    onEvent(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UppercaseValueDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UppercaseValueDirective, "input[uppercaseValue]", never, {}, {}, never, never, false, never>;
+}
+
+declare class LanguagePipe extends Destroyable implements PipeTransform {
+    private detection;
+    private language;
+    static removeTags(item: string): string;
+    private lastKey;
+    private lastParams;
+    private lastValue;
+    constructor(detection: ChangeDetectorRef, language: LanguageService);
+    private lastValueUpdate;
+    transform(key: string, params?: any): string;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LanguagePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LanguagePipe, "viTranslate", false>;
+}
+
+declare class LanguagePipePure extends Destroyable implements PipeTransform {
+    private language;
+    constructor(language: LanguageService);
+    transform(key: string, params?: any): string;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LanguagePipePure, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LanguagePipePure, "viTranslatePure", false>;
+}
+
+declare class LanguagePipeHas extends Destroyable implements PipeTransform {
+    private language;
+    private key;
+    private _value;
+    constructor(language: LanguageService);
+    private valueUpdate;
+    transform(key: string): boolean;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LanguagePipeHas, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LanguagePipeHas, "viTranslateHas", false>;
+}
+
+declare class LanguagePipeHasPure extends Destroyable implements PipeTransform {
+    private language;
+    constructor(language: LanguageService);
+    transform(key: string): boolean;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LanguagePipeHasPure, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LanguagePipeHasPure, "viTranslateHasPure", false>;
+}
+
+declare class LanguageToggleDirective extends Destroyable {
+    private language;
+    private settings;
+    constructor(language: LanguageService, settings: SettingsServiceBase);
+    protected clickHandler(): void;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageToggleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LanguageToggleDirective, "[vi-language-toggle]", never, {}, {}, never, never, false, never>;
+}
+
+declare class LanguageHasDirective<T = any> extends StructureDirective<T> {
+    protected language: LanguageService;
+    protected _viTranslateHas: string;
+    protected _isOnlyIfNotEmpty: boolean;
+    constructor(template: TemplateRef<T>, container: ViewContainerRef, language: LanguageService);
+    protected check(): void;
+    destroy(): void;
+    set viTranslateHas(value: string);
+    get viTranslateHas(): string;
+    set viTranslateHasIsOnlyIfNotEmpty(value: boolean);
+    get viTranslateHasIsOnlyIfNotEmpty(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageHasDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LanguageHasDirective<any>, "[viTranslateHas]", never, { "viTranslateHas": { "alias": "viTranslateHas"; "required": false; }; "viTranslateHasIsOnlyIfNotEmpty": { "alias": "viTranslateHasIsOnlyIfNotEmpty"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class LanguageDirective extends Destroyable {
+    protected element: ElementRef;
+    protected language: LanguageService;
+    isNeedTitle: boolean;
+    protected _key: string;
+    protected _params: any;
+    constructor(element: ElementRef, language: LanguageService);
+    protected translate: () => void;
+    destroy(): void;
+    set key(value: string);
+    get key(): string;
+    set params(value: any);
+    get params(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LanguageDirective, "[vi-translate]", never, { "isNeedTitle": { "alias": "isNeedTitle"; "required": false; }; "key": { "alias": "vi-translate"; "required": false; }; "params": { "alias": "params"; "required": false; }; }, {}, never, never, false, never>;
+    static ngAcceptInputType_isNeedTitle: unknown;
+}
+
+declare class LanguageModule {
+    static forRoot(options?: ILanguageServiceOptions): ModuleWithProviders<LanguageModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LanguageModule, [typeof LanguagePipe, typeof LanguagePipePure, typeof LanguagePipeHas, typeof LanguagePipeHasPure, typeof LanguageToggleDirective, typeof LanguageHasDirective, typeof LanguageDirective], [typeof CookieModule], [typeof LanguagePipe, typeof LanguagePipePure, typeof LanguagePipeHas, typeof LanguagePipeHasPure, typeof LanguageToggleDirective, typeof LanguageHasDirective, typeof LanguageDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LanguageModule>;
+}
+declare function languageServiceFactory(cookie: ICookieService, options?: ILanguageServiceOptions): LanguageService;
+declare const LANGUAGE_OPTIONS: InjectionToken<ILanguageServiceOptions>;
+
+declare abstract class LoadableResolver<T extends Loadable<U, V>, U = any, V = any> implements Resolve<void> {
+    protected service: T;
+    constructor(service: T);
+    protected resolveHandler(): void;
+    protected rejectHandler(error: ExtendedError): void;
+    resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<void>;
+}
+
+declare class LanguageRequireResolver extends LoadableResolver<LanguageService> {
+}
+
+declare class LanguageResolver extends LanguageRequireResolver {
+    constructor(service: LanguageService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageResolver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LanguageResolver>;
+}
+
+declare abstract class LoginServiceBase<E = any, U = any, V = any> extends Loadable<E | LoginServiceBaseEvent, U | V | ExtendedError> {
+    protected _sid: string;
+    protected _loginData: V;
+    protected _isLoggedIn: boolean;
+    constructor();
+    protected loginByParam<T = any>(param?: T): Promise<U>;
+    protected loginByFunction(sidReturnFunction: (...params: any[]) => Promise<U>): Promise<U>;
+    protected loginBySid(): Promise<void>;
+    protected reset(): void;
+    protected abstract loginRequest(...params: any[]): Promise<U>;
+    protected abstract loginSidRequest(): Promise<V>;
+    protected abstract logoutRequest(): Promise<void>;
+    protected abstract getSavedSid(): string;
+    protected abstract parseLoginResponse(response: U): void;
+    protected parseLoginErrorResponse(error: ExtendedError): void;
+    protected parseLogoutErrorResponse(error: ExtendedError): void;
+    protected parseLoginSidResponse(response: V): void;
+    protected parseLoginSidErrorResponse(error: ExtendedError): void;
+    abstract login(param: any): void;
+    loginByResponse(param: U): Promise<void>;
+    loginBySidIfCan(): boolean;
+    logout(): Promise<void>;
+    isCanLoginWithSid(): boolean;
+    destroy(): void;
+    get logined(): Observable<V>;
+    get logouted(): Observable<void>;
+    get sid(): string;
+    get loginData(): V;
+    get isLoggedIn(): boolean;
+}
+declare enum LoginServiceBaseEvent {
+    LOGIN_ERROR = "LOGIN_ERROR",
+    LOGIN_STARTED = "LOGIN_STARTED",
+    LOGIN_COMPLETE = "LOGIN_COMPLETE",
+    LOGIN_FINISHED = "LOGIN_FINISHED",
+    LOGOUT_STARTED = "LOGOUT_STARTED",
+    LOGOUT_FINISHED = "LOGOUT_FINISHED",
+    REGISTRATION_ERROR = "REGISTRATION_ERROR",
+    REGISTRATION_STARTED = "REGISTRATION_STARTED",
+    REGISTRATION_COMPLETE = "REGISTRATION_COMPLETE",
+    REGISTRATION_FINISHED = "REGISTRATION_FINISHED"
+}
+
+declare abstract class Loginable<T extends LoginServiceBase = LoginServiceBase, U = any, V = any> extends Loadable<U, V> {
+    protected login: T;
+    constructor(login: T);
+    protected initialize(): void;
+    protected loginedHandler(): Promise<void>;
+    protected logoutedHandler(): Promise<void>;
+    destroy(): void;
+}
+
+declare class LoginRequireResolver<U extends LoginServiceBase = LoginServiceBase, V = void> implements Resolve<V> {
+    protected login: U;
+    constructor(login: U);
+    resolve(...params: any[]): Promise<V>;
+    isLoggedIn(): boolean;
+}
+
+declare class LoginGuard<T extends LoginServiceBase = LoginServiceBase> extends LoginRequireResolver<T> implements CanActivate {
+    protected router: Router;
+    static redirectUrl: string;
+    constructor(login: T, router: Router);
+    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | UrlTree | Promise<boolean | UrlTree>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoginGuard<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoginGuard<any>>;
+}
+
+declare class LoginNotGuard<T extends LoginServiceBase = LoginServiceBase> extends LoginRequireResolver<T> implements CanActivate {
+    protected router: Router;
+    static redirectUrl: string;
+    constructor(login: T, router: Router);
+    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean | UrlTree;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoginNotGuard<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoginNotGuard<any>>;
+}
+
+declare class LoginResolver<T extends LoginServiceBase> extends LoginRequireResolver<T> {
+    constructor(login: T);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoginResolver<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoginResolver<any>>;
+}
+
+declare class LoginIfCanGuard<T extends LoginServiceBase = LoginServiceBase> extends LoginGuard<T> {
+    protected router: Router;
+    constructor(login: T, router: Router);
+    protected loginIfCan(): Promise<void>;
+    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean | UrlTree>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoginIfCanGuard<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoginIfCanGuard<any>>;
+}
+
+declare class LocalStorageService extends Destroyable {
+    protected storage: Storage;
+    constructor(storage: Storage);
+    get(key: string, defaultValue?: string): string;
+    has(key: string): boolean;
+    set(key: string, value: string): void;
+    remove(key: string): void;
+    clear(): void;
+    destroy(): void;
+    protected get length(): number;
+}
+
+interface IValueStorage<T> extends IDestroyable {
+    get(defaultValue?: T): T;
+    set(value: T): T;
+    has(): boolean;
+    destroy(): void;
+    get name(): string;
+}
+
+declare class ValueStorage<T = string> extends Destroyable implements IValueStorage<T> {
+    protected storage: LocalStorageService;
+    protected cookies: CookieService;
+    protected _name: string;
+    constructor(name: string, storage: LocalStorageService, cookies: CookieService);
+    protected serialize(value: string): T;
+    protected deserialize(value: T): string;
+    get(defaultValue?: T): T;
+    has(): boolean;
+    set(value: T): T;
+    clear(): void;
+    destroy(): void;
+    get name(): string;
+}
+
+declare class LoginTokenStorage<T = string> extends ValueStorage<T> {
+    static TOKEN_KEY: string;
+    constructor(local: LocalStorageService, cookies: CookieService);
+}
+
+declare class FocusManager extends Destroyable {
+    protected timer: any;
+    protected delay: number;
+    protected element: HTMLElement;
+    constructor(element: ElementRef, delay?: number);
+    private focusElement;
+    focus(): void;
+    destroy(): void;
+}
+
+declare class ViewUtil {
+    private static _renderer;
+    private static _document;
+    static get renderer(): Renderer2;
+    static set renderer(value: Renderer2);
+    static get document(): Document;
+    static set document(value: Document);
+    static get window(): Window;
+    private static copyToClipboard;
+    static parseElement<T extends HTMLElement = HTMLElement>(element: IViewElement<T>): T;
+    static createBase64(element: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement): string;
+    static selectContent(container: IViewElement, isNeedCopyToClipboard?: boolean): void;
+    static setBackground(container: IViewElement, image: string, repeat?: string, error?: string): void;
+    static getBackgroundUrl(item: string): string;
+    static createElement<T = any>(name: string, className?: string, innerHTML?: string): T;
+    static appendChild(parent: any, child: any): void;
+    static removeChild(parent: any, child: any): void;
+    static toggleChild(container: Node, child: Node, value: boolean): void;
+    static getStageWidth(): number;
+    static getStageHeight(): number;
+    static getCanvasContext2d(container: IViewElement<HTMLCanvasElement>, options?: CanvasRenderingContext2DSettings): CanvasRenderingContext2D;
+    static getBoundingRectangle(container: IViewElement): DOMRect;
+    static getWidth(container: IViewElement): number;
+    static setWidth(container: IViewElement, value: number, isNeedCheckLimits?: boolean): boolean;
+    static getMaxWidth(container: IViewElement): number;
+    static getMinWidth(container: IViewElement): number;
+    static getHeight(container: IViewElement): number;
+    static setHeight(container: IViewElement, value: number, isNeedCheckLimits?: boolean): boolean;
+    static getMaxHeight(container: IViewElement): number;
+    static getMinHeight(container: IViewElement): number;
+    static size(container: IViewElement, width: number, height: number, isNeedCheckLimits: boolean): void;
+    static getX(container: IViewElement): number;
+    static setX(container: IViewElement, value: number): void;
+    static getY(container: IViewElement): number;
+    static setY(container: IViewElement, value: number): void;
+    static move(container: IViewElement, x: number, y: number): void;
+    static focusInput(input: HTMLInputElement | HTMLTextAreaElement): void;
+    static addClass(container: IViewElement, name: string): void;
+    static addClasses(container: IViewElement, names: string): void;
+    static removeClass(container: IViewElement, name: string): void;
+    static removeClasses(container: IViewElement, names: string): void;
+    static hasClass(container: IViewElement, name: string): boolean;
+    static toggleClass(container: IViewElement, name: string, value: boolean): void;
+    static toggleClasses(container: IViewElement, name: string, value: boolean): void;
+    static getProperty(container: IViewElement, name: string): any;
+    static setProperty(container: IViewElement, name: string, value: any): void;
+    static removeProperty(container: IViewElement, name: string): void;
+    static getAttribute(container: IViewElement, name: string): any;
+    static removeAttribute(container: IViewElement, name: string): void;
+    static setAttribute(container: IViewElement, name: string, value: any): void;
+    static getStyle(container: IViewElement, name: string): any;
+    static setStyle(container: IViewElement, name: string, value: any, flags?: RendererStyleFlags2): void;
+    static removeStyle(container: IViewElement, name: string, flags?: RendererStyleFlags2): void;
+    static createVideo(isMute?: boolean, isInline?: boolean): HTMLVideoElement;
+    static setVideoMuteParameters(video: HTMLVideoElement, isMute?: boolean): void;
+    static setVideoInlineParameters(video: HTMLVideoElement): void;
+    static getVideoError(video: HTMLVideoElement): string;
+    static playVideo(video: HTMLVideoElement): Promise<void>;
+    static playAudio(audio: HTMLAudioElement): Promise<void>;
+    static pauseVideo(video: HTMLVideoElement): void;
+    static isVideoPlaying(video: HTMLVideoElement): boolean;
+    static loadVideo(video: HTMLVideoElement): void;
+    static stopVideoIfNeed(video: HTMLVideoElement): void;
+    static stopVideo(video: HTMLVideoElement): void;
+    static disposeVideo(video: HTMLVideoElement): void;
+    static disposeVideos(container: IViewElement): void;
+    static disposeObjects(container: IViewElement, isIEBrowser?: boolean): void;
+    static disposeObject(object: HTMLObjectElement, isIEBrowser?: boolean): void;
+}
+type IViewElement<T extends HTMLElement = HTMLElement> = HTMLElement | ElementRef<T> | ViewContainerRef;
+
+declare class ResizeManager implements IDestroyable {
+    static isSizeValid(item: ISize): boolean;
+    protected size: ISize;
+    protected sensor: ResizeObserver;
+    protected subject: BehaviorSubject<ISize>;
+    protected element: HTMLElement;
+    constructor(element: IViewElement);
+    protected handlerItem: (item: ISize) => void;
+    protected handler2: (items: Array<ResizeObserverEntry>) => void;
+    get changed(): Observable<ISize>;
+    get value(): ISize;
+    destroy(): void;
+}
+interface ISize {
+    width: number;
+    height: number;
+}
+
+declare class MenuItemBase {
+    nameId: string;
+    sortIndex: number;
+    iconId?: string;
+    protected _name: string;
+    protected _isEnabled: boolean;
+    checkEnabled: (item: MenuItemBase) => boolean;
+    constructor(nameId: string, sortIndex?: number, iconId?: string);
+    protected commitNameProperties(): void;
+    protected commitIsEnabledProperties(): void;
+    get isEnabled(): boolean;
+    set isEnabled(value: boolean);
+    get name(): string;
+    set name(value: string);
+}
+
+declare class MenuItem extends MenuItemBase {
+    flag: string;
+    select: (item: MenuItem) => void;
+    constructor(nameId?: string, sortIndex?: number, flag?: string, iconId?: string);
+}
+
+declare class MenuItems extends DestroyableContainer {
+    private language;
+    protected _items: Array<MenuItemBase>;
+    protected _enabledItems: Array<MenuItemBase>;
+    protected filterFunction: (item: MenuItemBase) => boolean;
+    constructor(language: LanguageService, filterFunction?: (item: MenuItem) => boolean, isAutoTranslate?: boolean);
+    private translateItems;
+    private translateItem;
+    private checkEnabledItems;
+    add(item: MenuItemBase): MenuItemBase;
+    remove(item: MenuItemBase): MenuItemBase;
+    checkEnabled(...args: any[]): boolean;
+    destroy(): void;
+    get items(): Array<MenuItemBase>;
+    get enabledItems(): Array<MenuItemBase>;
+}
+
+declare class NavigationMenuItem extends MenuItem {
+    url: string;
+    isActive: boolean;
+    select: (item: NavigationMenuItem) => void;
+    constructor(nameId?: string, sortIndex?: number, iconId?: string, url?: string);
+}
+
+interface IListItem<T = any> extends IUIDable {
+    label: string;
+    sortIndex: number;
+    isEnabled: boolean;
+    translationId: string;
+    data?: T;
+    iconId?: string;
+    className?: string;
+    action?: (item: IListItem, ...params: any[]) => void;
+    checkEnabled?: (item: IListItem, ...params: any[]) => boolean;
+}
+
+declare class ListItem<T = any> implements IListItem<T>, IDestroyable {
+    protected _uid: string;
+    protected _data: T;
+    protected _label: string;
+    protected _iconId: string;
+    protected _className: string;
+    protected _sortIndex: number;
+    protected _isEnabled: boolean;
+    protected _translationId: string;
+    action: (item: IListItem, ...params: any[]) => void;
+    checkEnabled: (item: IListItem, ...params: any[]) => boolean;
+    constructor(translationId: string, sortIndex?: number, data?: T, iconId?: string);
+    protected commitDataProperties(): void;
+    protected commitLabelProperties(): void;
+    protected commitIsEnabledProperties(): void;
+    protected commitClassNameProperties(): void;
+    protected commitIconIdProperties(): void;
+    protected commitSortIndexProperties(): void;
+    protected commitTranslationIdProperties(): void;
+    protected getUid(): string;
+    destroy(): void;
+    get uid(): string;
+    get sortIndex(): number;
+    set sortIndex(value: number);
+    get isEnabled(): boolean;
+    set isEnabled(value: boolean);
+    get label(): string;
+    set label(value: string);
+    get translationId(): string;
+    set translationId(value: string);
+    get iconId(): string;
+    set iconId(value: string);
+    get className(): string;
+    set className(value: string);
+    get data(): T;
+    set data(value: T);
+}
+
+declare class ListItems<U extends IListItem<V>, V = any> extends FilterableMapCollection<U> {
+    private language;
+    protected lastRefreshParams: Array<any>;
+    protected languageSubscription: Subscription;
+    protected _isAllEnabled: boolean;
+    protected _isLeastOneEnabled: boolean;
+    constructor(language: LanguageService, isAutoTranslate?: boolean);
+    protected translate: (item: U) => void;
+    protected translateItems: () => void;
+    protected translateIfNeed: (item: U) => void;
+    protected translateItemsIfNeed: () => void;
+    protected sort(): void;
+    complete(): void;
+    refresh(...params: any[]): void;
+    actionItem(item: U): void;
+    destroy(): void;
+    get isAllEnabled(): boolean;
+    get isLeastOneEnabled(): boolean;
+}
+
+interface ISelectListItem<T = any> extends IListItem<T> {
+    isSelected: boolean;
+    selectedClassName?: string;
+    checkSelected?: (item: ISelectListItem, ...params: any[]) => boolean;
+}
+
+declare class SelectListItem<T = any> extends ListItem<T> implements ISelectListItem<T> {
+    protected _isSelected: boolean;
+    protected _selectedClassName: string;
+    checkSelected?: (item: ISelectListItem, ...params: any[]) => boolean;
+    constructor(translationId: string, sortIndex: number, data: T, checkEnabled?: (item: IListItem, ...params: any[]) => boolean);
+    protected commitIsSelectProperties(): void;
+    protected commitSelectedClassNameProperties(): void;
+    destroy(): void;
+    get isSelected(): boolean;
+    set isSelected(value: boolean);
+    get selectedClassName(): string;
+    set selectedClassName(value: string);
+}
+
+declare class SelectListItems<U extends ISelectListItem<V>, V = any> extends ListItems<U, V> {
+    protected _selectedItem: U;
+    protected _selectedData: V;
+    protected _selectedIndex: number;
+    protected _changed: EventEmitter<U>;
+    constructor(language: LanguageService, isAutoTranslate?: boolean);
+    protected commitSelectedItemProperties(): void;
+    protected commitSelectedDataProperties(): void;
+    protected commitSelectedIndexProperties(): void;
+    protected selectIndexOrData(indexOrDataToSelect: number | V): void;
+    get selectedItem(): U;
+    set selectedItem(value: U);
+    get selectedIndex(): number;
+    set selectedIndex(value: number);
+    get selectedData(): V;
+    set selectedData(value: V);
+    complete(indexOrDataToSelect?: number | V): void;
+    refresh(...params: any[]): void;
+    refreshSelection(...params: any[]): void;
+    destroy(): void;
+    get changed(): EventEmitter<U>;
+}
+
+declare class RouterSelectListItems<U = string> extends SelectListItems<ISelectListItem<U>, U> {
+    protected router: RouterServiceBase;
+    isDisabled: boolean;
+    constructor(router: RouterServiceBase, language: LanguageService);
+    protected setData(): void;
+    protected setFragment(item: ISelectListItem<U>): void;
+    protected getRouterSelectedItem(): ISelectListItem<U>;
+    complete(): void;
+    destroy(): void;
+}
+
+declare class CamelCasePipe implements PipeTransform {
+    static transform(value: any): string;
+    transform(value: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CamelCasePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CamelCasePipe, "viCamelCase", false>;
+}
+
+declare class FinancePipe implements PipeTransform {
+    static DEFAULT_FORMAT: string;
+    static format(value: number | string, format: string): string;
+    static transform(value: number | string, format?: string, isNeedPlus?: boolean): string;
+    transform(value: number | string, format?: string, isNeedPlus?: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FinancePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FinancePipe, "viFinance", false>;
+}
+
+declare class MomentDateAdaptivePipe implements PipeTransform {
+    static HOUR_FORMAT: string;
+    static DAY_FORMAT: string;
+    static MONTH_FORMAT: string;
+    static YEAR_FORMAT: string;
+    static transform(value: Date | Moment): string;
+    transform(value: Date | Moment): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MomentDateAdaptivePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MomentDateAdaptivePipe, "viMomentAdaptiveDate", false>;
+}
+
+declare class MomentDateFromNowPipe implements PipeTransform {
+    static transform(value: Date | Moment, format?: string): string;
+    transform(value: Date | Moment, format?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MomentDateFromNowPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MomentDateFromNowPipe, "viMomentDateFromNow", false>;
+}
+
+declare class MomentDatePipe implements PipeTransform {
+    static DEFAULT_FORMAT: string;
+    static parseMoment(value: MomentAvailableType, format?: string): Moment;
+    static fromNow(value: MomentAvailableType, format?: string): string;
+    static toConditionValue(value: string | Date): string;
+    static transform(value: MomentAvailableType, format?: string): string;
+    transform(value: MomentAvailableType, format?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MomentDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MomentDatePipe, "viMomentDate", false>;
+}
+type MomentAvailableType = Date | Moment | string | number;
+
+declare class MomentTimePipe implements PipeTransform {
+    static DEFAULT_FORMAT: string;
+    static transform(timeMilliseconds: number, format?: string): string;
+    transform(timeMilliseconds: number, format?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MomentTimePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MomentTimePipe, "viMomentTime", false>;
+}
+
+declare class NgModelErrorPipe implements PipeTransform {
+    protected language: LanguageService;
+    transform(value: ValidationErrors): string;
+    translateError(key: string, value: any): string;
+    constructor(language: LanguageService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgModelErrorPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NgModelErrorPipe, "viNgModelError", false>;
+}
+
+declare class SanitizePipe {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(value: string, type?: string): SafeHtml | SafeStyle | SafeScript | SafeUrl | SafeResourceUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SanitizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SanitizePipe, "viSanitize", false>;
+}
+
+declare class StartCasePipe implements PipeTransform {
+    static transform(value: any): string;
+    transform(value: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StartCasePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<StartCasePipe, "viStartCase", false>;
+}
+
+declare class TruncatePipe implements PipeTransform {
+    static transform(value: any, maxLength?: number): string;
+    transform(value: any, maxLength?: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TruncatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TruncatePipe, "viTruncate", false>;
+}
+
+declare class PrettifyPipe implements PipeTransform {
+    static EMPTY_SYMBOL: string;
+    static transform(value: any): string;
+    transform(value: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrettifyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PrettifyPipe, "viPrettify", false>;
+}
+
+declare class TimePipe implements PipeTransform {
+    static DEFAULT_FORMAT: string;
+    static transform(milliseconds: number | string, format?: string): string;
+    transform(milliseconds: number | string, format?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TimePipe, "viTime", false>;
+}
+
+declare class QuestionManager extends Destroyable implements IQuestion {
+    text: string;
+    mode: QuestionMode;
+    options: IQuestionOptions;
+    notText: string;
+    yesText: string;
+    closeText: string;
+    checkText: string;
+    protected _isChecked: boolean;
+    protected _closePromise: PromiseHandler<void, void>;
+    protected _yesNotPromise: PromiseHandler<void, void>;
+    constructor(options?: IQuestionOptions);
+    closeClickHandler(): void;
+    yesClickHandler(): void;
+    notClickHandler(): void;
+    destroy(): void;
+    get yesNotPromise(): Promise<void>;
+    get closePromise(): Promise<void>;
+    get isInfo(): boolean;
+    get isQuestion(): boolean;
+    get isChecked(): boolean;
+    set isChecked(value: boolean);
+}
+
+declare class PipeServiceBase extends Destroyable {
+    language: LanguageService;
+    sanitizer: DomSanitizer;
+    private static DATE;
+    private static TIME;
+    private static FINANCE;
+    private static PRETTIFY;
+    private static TRUNCATE;
+    private static SANITIZE;
+    private static CAMEL_CASE;
+    private static MOMENT_TIME;
+    private static MOMENT_DATE;
+    private static MOMENT_DATE_FROM_NOW;
+    private static MOMENT_ADAPTIVE_DATE;
+    private _locale;
+    constructor(language: LanguageService, sanitizer: DomSanitizer);
+    protected commitLanguageProperties(): void;
+    get date(): DatePipe;
+    get time(): TimePipe;
+    get finance(): FinancePipe;
+    get truncate(): TruncatePipe;
+    get prettify(): PrettifyPipe;
+    get momentDate(): MomentDatePipe;
+    get momentDateFromNow(): MomentDateFromNowPipe;
+    get momentDateAdaptive(): MomentDateAdaptivePipe;
+    get momentTime(): MomentTimePipe;
+    get sanitize(): SanitizePipe;
+    get camelCase(): CamelCasePipe;
+    get locale(): string;
+}
+
+interface INotificationConfig<T = any> extends IWindowConfig<T> {
+    icon: string;
+    sound: string;
+    iconId: string;
+    picture: string;
+    closeDuration: number;
+    isRemoveAfterClose: boolean;
+}
+
+declare abstract class INotificationContent<T = any> extends DestroyableContainer implements AfterViewInit {
+    container: ViewContainerRef;
+    protected timer: any;
+    protected _config: INotificationConfig<T>;
+    protected _notification: INotification<T>;
+    constructor(container: ViewContainerRef);
+    protected commitNotificationProperties(): void;
+    protected commitConfigProperties(): void;
+    protected clearTimer(): void;
+    protected timerHandler: () => void;
+    close(): void;
+    remove(): void;
+    emit(event: string): void;
+    destroy(): void;
+    ngAfterViewInit(): void;
+    handleCloseClick(): void;
+    get data(): T;
+    get events(): Observable<string>;
+    get notification(): INotification<T>;
+    set notification(value: INotification<T>);
+    set config(value: INotificationConfig<T>);
+    get config(): INotificationConfig<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<INotificationContent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<INotificationContent<any>, "ng-component", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class INotification<T = any> implements IDestroyable {
+    abstract getX(): number;
+    abstract getY(): number;
+    abstract setX(value: number): void;
+    abstract setY(value: number): void;
+    abstract move(x: number, y: number): void;
+    abstract getWidth(): number;
+    abstract getHeight(): number;
+    abstract setWidth(value: number): void;
+    abstract setHeight(value: number): void;
+    abstract setSize(width: number, height: number): void;
+    abstract close(): void;
+    abstract remove(): void;
+    abstract destroy(): void;
+    abstract emit(event: string): void;
+    readonly events: Observable<string>;
+    readonly container: HTMLElement;
+    readonly config: INotificationConfig<T>;
+    readonly content: INotificationContent<T>;
+}
+declare enum NotificationEvent {
+    REMOVED = "REMOVED"
+}
+
+declare class NotificationConfig<T = any> extends WindowConfig<T> implements INotificationConfig<T> {
+    icon: string;
+    sound: string;
+    iconId: string;
+    picture: string;
+    closeDuration: number;
+    isRemoveAfterClose: boolean;
+    constructor(data?: T);
+}
+type NotificationConfigOptions<T = any> = {
+    [P in keyof NotificationConfig<T>]?: any;
+};
+
+declare enum NotificationServiceEvent {
+    OPENED = "OPENED",
+    CLOSED = "CLOSED",
+    ADDED = "ADDED",
+    REMOVED = "REMOVED"
+}
+
+declare abstract class NotificationService extends Destroyable {
+    abstract open<U extends INotificationContent<T>, T>(component: ClassType<U>, config: INotificationConfig<T>): U;
+    abstract get<T>(value: NotificationId<T>): INotificationConfig<T>;
+    abstract has<T>(value: NotificationId<T>): boolean;
+    abstract remove<T>(value: NotificationId<T>): void;
+    abstract closeAll(): void;
+    abstract close<T>(value: NotificationId<T>): INotification<T>;
+    abstract info(translationId?: string, translation?: any, questionOptions?: IQuestionOptions, configOptions?: NotificationConfigOptions): IQuestion;
+    abstract question(translationId?: string, translation?: any, questionOptions?: IQuestionOptions, configOptions?: NotificationConfigOptions): IQuestion;
+    abstract get events(): Observable<ObservableData<NotificationServiceEvent, INotificationConfig | INotification>>;
+    abstract get configs(): Array<INotificationConfig>;
+    abstract get closedConfigs(): Array<INotificationConfig>;
+    abstract get notifications(): Map<INotificationConfig, INotificationContent>;
+}
+type NotificationId<T> = string | INotificationConfig<T> | NotificationConfigOptions<T>;
+
+declare class ServiceWorkerService extends Loadable {
+    protected updates: SwUpdate;
+    protected logger: Logger;
+    protected notifications: NotificationService;
+    constructor(updates: SwUpdate, logger: Logger, notifications: NotificationService);
+    protected start(value: LoadableStatus): void;
+    protected finish(value: LoadableStatus): void;
+    protected readyHandler(event: VersionReadyEvent): Promise<void>;
+    protected unrecoverableHandler(event: UnrecoverableStateEvent): Promise<void>;
+    protected detectedHandler(event: VersionDetectedEvent): Promise<void>;
+    protected installationFailedHandler(event: VersionInstallationFailedEvent): Promise<void>;
+    protected noNewVersionDetectedHandler(event: NoNewVersionDetectedEvent): Promise<void>;
+    activateUpdate(): Promise<boolean>;
+    checkForUpdate(): Promise<boolean>;
+    get isEnabled(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ServiceWorkerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ServiceWorkerService>;
+}
+
+interface IRouterDeactivatable {
+    isForceDeactivate: boolean;
+    isCanDeactivate(currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState?: RouterStateSnapshot): MaybeAsync<GuardResult>;
+}
+
+declare class CanDeactivateGuard<T extends IRouterDeactivatable = IRouterDeactivatable> implements CanDeactivate<T> {
+    canDeactivate(component: T, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState?: RouterStateSnapshot): MaybeAsync<GuardResult>;
+}
+declare const CanDeactivateFunction: CanDeactivateFn<IRouterDeactivatable>;
+
+declare class ThemeStyleDirective extends Destroyable {
+    protected theme: ThemeService;
+    protected _key: string;
+    protected _flags: RendererStyleFlags2;
+    protected _styleName: string;
+    protected element: HTMLElement;
+    constructor(element: ElementRef, theme: ThemeService);
+    protected commitStyleProperties(name: string, value: string): void;
+    protected stylePropertiesCheck(): void;
+    protected stylePropertiesRemove(): void;
+    protected stylePropertiesAdd(): void;
+    protected isNeedStyleAdd(): boolean;
+    protected isNeedStyleRemove(): boolean;
+    destroy(): void;
+    get flags(): RendererStyleFlags2;
+    set flags(value: RendererStyleFlags2);
+    get styleName(): string;
+    set styleName(value: string);
+    get key(): string;
+    set key(value: string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeStyleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ThemeStyleDirective, "[vi-theme-style]", never, { "flags": { "alias": "flags"; "required": false; }; "styleName": { "alias": "styleName"; "required": false; }; "key": { "alias": "vi-theme-style"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ThemeStyleHoverDirective extends ThemeStyleDirective {
+    protected _isHover: boolean;
+    constructor(element: ElementRef, theme: ThemeService);
+    protected isNeedStyleAdd(): boolean;
+    protected isNeedStyleRemove(): boolean;
+    protected mouseEnter: (event: MouseEvent) => void;
+    protected mouseLeave: (event: MouseEvent) => void;
+    destroy(): void;
+    get isHover(): boolean;
+    set isHover(value: boolean);
+    get key(): string;
+    set key(value: string);
+    get styleName(): string;
+    set styleName(value: string);
+    get flags(): RendererStyleFlags2;
+    set flags(value: RendererStyleFlags2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeStyleHoverDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ThemeStyleHoverDirective, "[vi-theme-style-hover]", never, { "key": { "alias": "vi-theme-style-hover"; "required": false; }; "styleName": { "alias": "styleName"; "required": false; }; "flags": { "alias": "flags"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare abstract class ThemeAssetDirective<T extends HTMLElement = HTMLElement> extends Destroyable {
+    protected theme: ThemeService;
+    protected themeAsset: ThemeAssetService;
+    protected _name: string;
+    protected _source: string;
+    protected _extension: string;
+    protected _isFile: boolean;
+    protected _isImage: boolean;
+    protected _isVideo: boolean;
+    protected _isSound: boolean;
+    protected _isBackground: boolean;
+    protected _isIgnoreTheme: boolean;
+    protected element: T;
+    private isTriedThemeDefault;
+    constructor(element: ElementRef, theme: ThemeService, themeAsset: ThemeAssetService);
+    protected getSource(id: string): string;
+    errorLoadingHandler(event: ErrorEvent): void;
+    protected errorHandler(event: ErrorEvent): void;
+    protected setSourceProperties(): void;
+    protected setDefaultSourceProperties(): void;
+    protected getSourceId(): string;
+    protected getDefaultSourceId(): string;
+    protected abstract addSourceProperties(): void;
+    protected abstract removeSourceProperties(): void;
+    destroy(): void;
+    protected get source(): string;
+    protected set source(value: string);
+    set isSound(value: boolean);
+    get isSound(): boolean;
+    set isVideo(value: boolean);
+    get isVideo(): boolean;
+    set isFile(value: boolean);
+    get isFile(): boolean;
+    set isImage(value: boolean);
+    get isImage(): boolean;
+    set isBackground(value: boolean);
+    get isBackground(): boolean;
+    set isIgnoreTheme(value: boolean);
+    get isIgnoreTheme(): boolean;
+    get name(): string;
+    set name(value: string);
+    get extension(): string;
+    set extension(value: string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeAssetDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ThemeAssetDirective<any>, never, never, { "isSound": { "alias": "isSound"; "required": false; }; "isVideo": { "alias": "isVideo"; "required": false; }; "isFile": { "alias": "isFile"; "required": false; }; "isImage": { "alias": "isImage"; "required": false; }; "isBackground": { "alias": "isBackground"; "required": false; }; "isIgnoreTheme": { "alias": "isIgnoreTheme"; "required": false; }; "name": { "alias": "name"; "required": false; }; "extension": { "alias": "extension"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_isSound: unknown;
+    static ngAcceptInputType_isVideo: unknown;
+    static ngAcceptInputType_isFile: unknown;
+    static ngAcceptInputType_isImage: unknown;
+    static ngAcceptInputType_isBackground: unknown;
+    static ngAcceptInputType_isIgnoreTheme: unknown;
+}
+
+declare class ThemeAssetBackgroundDirective extends ThemeAssetDirective {
+    constructor(element: ElementRef, theme: ThemeService, themeAsset: ThemeAssetService);
+    protected addSourceProperties(): void;
+    protected removeSourceProperties(): void;
+    set name(value: string);
+    get name(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeAssetBackgroundDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ThemeAssetBackgroundDirective, "[vi-theme-background]", never, { "name": { "alias": "vi-theme-background"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ThemeAssetImageDirective extends ThemeAssetDirective<HTMLImageElement> {
+    constructor(element: ElementRef, theme: ThemeService, themeAsset: ThemeAssetService);
+    protected addSourceProperties(): void;
+    protected removeSourceProperties(): void;
+    set name(value: string);
+    get name(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeAssetImageDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ThemeAssetImageDirective, "[vi-theme-image]", never, { "name": { "alias": "vi-theme-image"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ThemeAssetIconDirective extends ThemeAssetDirective<HTMLImageElement> {
+    constructor(element: ElementRef, theme: ThemeService, themeAsset: ThemeAssetService);
+    protected addSourceProperties(): void;
+    protected removeSourceProperties(): void;
+    set name(value: string);
+    get name(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeAssetIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ThemeAssetIconDirective, "[vi-theme-icon]", never, { "name": { "alias": "vi-theme-icon"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ThemeToggleDirective extends Destroyable {
+    private theme;
+    constructor(theme: ThemeService);
+    protected clickHandler(): void;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeToggleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ThemeToggleDirective, "[vi-theme-toggle]", never, {}, {}, never, never, false, never>;
+}
+
+declare class ThemeModule {
+    static forRoot(options?: IThemeServiceOptions): ModuleWithProviders<ThemeModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ThemeModule, [typeof ThemeToggleDirective, typeof ThemeAssetImageDirective, typeof ThemeAssetIconDirective, typeof ThemeAssetBackgroundDirective, typeof ThemeStyleDirective, typeof ThemeStyleHoverDirective], [typeof CookieModule], [typeof ThemeToggleDirective, typeof ThemeAssetImageDirective, typeof ThemeAssetIconDirective, typeof ThemeAssetBackgroundDirective, typeof ThemeStyleDirective, typeof ThemeStyleHoverDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ThemeModule>;
+}
+declare function themeServiceFactory(nativeWindow: NativeWindowService, cookie: ICookieService, options?: IThemeServiceOptions): ThemeService;
+declare function themeAssetServiceFactory(theme: ThemeService): ThemeAssetService;
+declare const THEME_OPTIONS: InjectionToken<IThemeServiceOptions>;
+
+declare abstract class IUser<T = any> implements IDestroyable {
+    id: UserUid;
+    abstract update(data: T): void;
+    abstract destroy(): void;
+}
+type UserUid = string | number;
+
+declare abstract class UserServiceBase<U extends IUser = any, V = void, T extends LoginServiceBase = LoginServiceBase> extends Loginable<T, V | UserServiceBaseEvent, U | Partial<U>> {
+    protected _user: U;
+    protected initializeUser(data: any): Promise<void>;
+    protected deinitializeUser(): Promise<void>;
+    protected loginedHandler(): Promise<void>;
+    protected logoutedHandler(): Promise<void>;
+    protected abstract createUser(data: any): U;
+    isEquals(item: Partial<U> | UserUid): boolean;
+    update(data: any): void;
+    destroy(): void;
+    get id(): UserUid;
+    get has(): boolean;
+    get user(): U;
+    get isLogined(): boolean;
+    get logined(): Observable<U>;
+    get changed(): Observable<Partial<U>>;
+    get logouted(): Observable<void>;
+}
+declare enum UserServiceBaseEvent {
+    LOGINED = "LOGINED",
+    CHANGED = "CHANGED",
+    LOGOUTED = "LOGOUTED"
+}
+
+declare abstract class WindowBase<T = any> extends DestroyableContainer {
+    protected static parseX<T>(value: number, config: IWindowConfig<T>): number;
+    protected static parseY<T>(value: number, config: IWindowConfig<T>): number;
+    protected static parseWidth<T>(value: number, config: IWindowConfig<T>): number;
+    protected static parseHeight<T>(value: number, config: IWindowConfig<T>): number;
+    protected _x: number;
+    protected _width: number;
+    protected _y: number;
+    protected _height: number;
+    constructor();
+    protected abstract getConfig(): IWindowConfig<T>;
+    protected abstract getContainer(): HTMLElement;
+    protected setProperties(): void;
+    protected setPosition(): void;
+    protected clearSize(): void;
+    protected commitSizeProperties(): void;
+    protected commitPositionProperties(): void;
+    protected updatePosition: () => void;
+    calculateWidth(): number;
+    calculateHeight(): number;
+    protected get width(): number;
+    protected set width(value: number);
+    protected get height(): number;
+    protected set height(value: number);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get paddingTop(): number;
+    get paddingLeft(): number;
+    get paddingRight(): number;
+    get paddingBottom(): number;
+}
+
+declare class WindowClosedError extends ExtendedError<void, number> {
+    static CODE: number;
+    static MESSAGE: string;
+    constructor(message?: string, code?: number);
+}
+
+declare abstract class BottomSheetService extends Destroyable {
+    abstract open<U extends IWindowContent<T>, T>(component: ClassType<U>, config: IWindowConfig<T>): U;
+    abstract get<T>(value: WindowId<T>): IWindowContent<T>;
+    abstract has<T>(value: WindowId<T>): boolean;
+    abstract close<T>(value: WindowId<T>): void;
+    abstract closeAll(): void;
+    abstract info(translationId?: string, translation?: any, questionOptions?: IQuestionOptions, configOptions?: WindowConfigOptions): IQuestion;
+    abstract question(translationId?: string, translation?: any, questionOptions?: IQuestionOptions, configOptions?: WindowConfigOptions): IQuestion;
+    abstract setOnTop<T>(value: WindowId<T>): boolean;
+    abstract get window(): IWindow;
+    abstract get events(): Observable<ObservableData<WindowServiceEvent, IWindow>>;
+}
+
+declare class DateValueStorage extends ValueStorage<Date> {
+    defaultExpirationDelta: number;
+    protected serialize(value: string): Date;
+    protected deserialize(value: Date): string;
+    isMore(item: Date): boolean;
+    isLess(item: Date): boolean;
+    isEqual(item: Date): boolean;
+    isExpired(item: Date): boolean;
+    isExpiredFromNow(delta?: number): boolean;
+}
+
+declare class JSONValueStorage<T = any> extends ValueStorage<T> {
+    protected serialize(value: string): T;
+    protected deserialize(value: T): string;
+}
+
+declare class BooleanValueStorage extends ValueStorage<boolean> {
+    protected serialize(value: string): boolean;
+    protected deserialize(value: boolean): string;
+}
+
+declare class ClassTypeValueStorage<T> extends JSONValueStorage<T> {
+    protected classType: ClassType<T>;
+    constructor(name: string, classType: ClassType<T>, storage: LocalStorageService, cookies: CookieService);
+    protected serialize(value: string): T;
+    protected deserialize(value: T): string;
+}
+
+declare class LazyModuleLoader<T extends ILazyModuleData = ILazyModuleData> extends Loadable {
+    protected compiler: Compiler;
+    protected injector: Injector;
+    protected _modules: MapCollection<T>;
+    constructor(compiler: Compiler, injector: Injector);
+    protected load(item: T): Promise<void>;
+    protected loadReference<T>(path: LazyModulePath<T>): Promise<NgModuleRef<T>>;
+    protected isNeedLoad(item: T): boolean;
+    loadIfNeed(id: string): Promise<T>;
+    destroy(): void;
+    get modules(): MapCollection<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LazyModuleLoader<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LazyModuleLoader<any>>;
+}
+interface ILazyModuleData<T = any> {
+    id: string;
+    path?: LazyModulePath<T>;
+    reference?: NgModuleRef<T>;
+}
+type LazyModulePath<T> = () => Promise<NgModuleFactory<T> | Type<T>>;
+
+declare abstract class TransportLazyModule<T> implements ITransportLazyModuleData<T> {
+    reference: NgModuleRef<T>;
+    protected transport: Transport;
+    constructor(reference: NgModuleRef<T>, transport: Transport);
+    protected moduleLoadedDispatch(): void;
+    abstract get id(): string;
+    get events(): Array<string>;
+    get commands(): Array<string>;
+}
+interface ITransportLazyModuleData<T = any> extends ILazyModuleData<T> {
+    events?: Array<string>;
+    commands?: Array<string>;
+}
+
+declare class TransportLazy extends TransportLocal {
+    protected loader: LazyModuleLoader<ITransportLazyModuleData>;
+    constructor(logger: ILogger, loader: LazyModuleLoader<ITransportLazyModuleData>, settings?: ITransportSettings);
+    protected moduleLoadedHandler(module: ITransportLazyModuleData): void;
+    protected commandResponseRequestDispatch<U>(command: ITransportCommand<U>, options: ITransportCommandOptions, isNeedReply: boolean): Promise<void>;
+    protected eventRequestExecute<U>(event: ITransportEvent<U>): Promise<void>;
+    protected getModuleByCommand(name: string): ITransportLazyModuleData;
+    protected getModuleByEvent(name: string): ITransportLazyModuleData;
+    destroy(): void;
+}
+
+declare class TransportLazyModuleLoadedEvent<T extends ITransportLazyModuleData = ITransportLazyModuleData> extends TransportEvent<T> {
+    static readonly NAME = "TransportLazyModuleLoadedEvent";
+    constructor(request: T);
+}
+
+declare class VIModule {
+    static forRoot(options?: IVIOptions): ModuleWithProviders<VIModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VIModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VIModule, [typeof TimePipe, typeof FinancePipe, typeof SanitizePipe, typeof TruncatePipe, typeof PrettifyPipe, typeof CamelCasePipe, typeof StartCasePipe, typeof NgModelErrorPipe, typeof IsServerDirective, typeof IsBrowserDirective, typeof MomentDatePipe, typeof MomentTimePipe, typeof MomentDateFromNowPipe, typeof MomentDateAdaptivePipe, typeof FocusDirective, typeof ResizeDirective, typeof ScrollDirective, typeof ScrollCheckDirective, typeof ClickToCopyDirective, typeof SelectOnFocusDirective, typeof ClickToSelectDirective, typeof InfiniteScrollDirective, typeof NullEmptyValueDirective, typeof UppercaseValueDirective, typeof HTMLTitleDirective, typeof HTMLContentTitleDirective, typeof AutoScrollBottomDirective, typeof AspectRatioResizeDirective], [typeof CookieModule, typeof ThemeModule, typeof LanguageModule, typeof AssetModule], [typeof CookieModule, typeof ThemeModule, typeof LanguageModule, typeof AssetModule, typeof TimePipe, typeof FinancePipe, typeof SanitizePipe, typeof TruncatePipe, typeof PrettifyPipe, typeof CamelCasePipe, typeof StartCasePipe, typeof NgModelErrorPipe, typeof IsServerDirective, typeof IsBrowserDirective, typeof MomentDatePipe, typeof MomentTimePipe, typeof MomentDateFromNowPipe, typeof MomentDateAdaptivePipe, typeof FocusDirective, typeof ResizeDirective, typeof ScrollDirective, typeof ScrollCheckDirective, typeof ClickToCopyDirective, typeof SelectOnFocusDirective, typeof ClickToSelectDirective, typeof InfiniteScrollDirective, typeof NullEmptyValueDirective, typeof UppercaseValueDirective, typeof HTMLTitleDirective, typeof HTMLContentTitleDirective, typeof AutoScrollBottomDirective, typeof AspectRatioResizeDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VIModule>;
+}
+declare class IVIOptions extends ICookieOptions {
+    loggerLevel?: LoggerLevel;
+    themeOptions?: IThemeServiceOptions;
+    languageOptions?: ILanguageServiceOptions;
+}
+declare function initializerFactory(nativeWindow: NativeWindowService, rendererFactory2: RendererFactory2): ViewUtil;
+declare function loggerServiceFactory(options: IVIOptions): ILogger;
+declare function nativeWindowServiceFactory(document: Document): NativeWindowService;
+declare function localStorageServiceFactory(nativeWindow: NativeWindowService): LocalStorageService;
+declare function loginTokenStorageServiceFactory(local: LocalStorageService, cookies: CookieService): LoginTokenStorage;
+declare const VI_ANGULAR_OPTIONS: InjectionToken<IVIOptions>;
+
+export { APPLICATION_INJECTOR, ApplicationComponent, ApplicationComponentBase, ApplicationInitializerBase, AspectRatioResizeDirective, AssetBackgroundDirective, AssetBackgroundPipe, AssetFilePipe, AssetIconPipe, AssetImagePipe, AssetModule, AssetSoundPipe, AssetVideoPipe, AutoScrollBottomDirective, BooleanValueStorage, BottomSheetService, COOKIE_OPTIONS, CamelCasePipe, CanDeactivateFunction, CanDeactivateGuard, ClassTypeValueStorage, ClickToCopyDirective, ClickToSelectDirective, CookieModule, CookieOptions, CookieService, DateValueStorage, Direction, FinancePipe, FocusDirective, FocusManager, HTMLContentTitleDirective, HTMLTitleDirective, INotification, INotificationContent, IUser, IVIOptions, IWindow, IWindowContent, InfiniteScrollDirective, IsBrowserDirective, IsServerDirective, JSONValueStorage, LANGUAGE_OPTIONS, LanguageDirective, LanguageHasDirective, LanguageModule, LanguagePipe, LanguagePipeHas, LanguagePipeHasPure, LanguagePipePure, LanguageRequireResolver, LanguageResolver, LanguageToggleDirective, LazyModuleLoader, ListItem, ListItems, LoadableResolver, LocalStorageService, LoginGuard, LoginIfCanGuard, LoginNotGuard, LoginRequireResolver, LoginResolver, LoginServiceBase, LoginServiceBaseEvent, LoginTokenStorage, Loginable, MenuItem, MenuItemBase, MenuItems, MessageComponentBase, MomentDateAdaptivePipe, MomentDateFromNowPipe, MomentDatePipe, MomentTimePipe, NavigationMenuItem, NgModelErrorPipe, NotificationConfig, NotificationEvent, NotificationService, NotificationServiceEvent, NullEmptyValueDirective, PipeServiceBase, PlatformService, PrettifyPipe, QuestionEvent, QuestionManager, QuestionMode, ResizeDirective, ResizeManager, RouterSelectListItems, RouterServiceBase, SanitizePipe, ScrollCheckDirective, ScrollDirective, SelectListItem, SelectListItems, SelectOnFocusDirective, ServerInitializeOptions, ServiceWorkerService, StartCasePipe, StructureDirective, THEME_OPTIONS, ThemeAssetBackgroundDirective, ThemeAssetDirective, ThemeAssetIconDirective, ThemeAssetImageDirective, ThemeModule, ThemeStyleDirective, ThemeStyleHoverDirective, ThemeToggleDirective, TimePipe, TransportLazy, TransportLazyModule, TransportLazyModuleLoadedEvent, TruncatePipe, UppercaseValueDirective, UserServiceBase, UserServiceBaseEvent, VIModule, VI_ANGULAR_OPTIONS, ValueStorage, ViewUtil, WINDOW_CONTENT_CONTAINER, WindowAlign, WindowBase, WindowClosedError, WindowConfig, WindowEvent, WindowService, WindowServiceEvent, cookieServiceFactory, initializerFactory, languageServiceFactory, localStorageServiceFactory, loggerServiceFactory, loginTokenStorageServiceFactory, nativeWindowServiceFactory, themeAssetServiceFactory, themeServiceFactory };
+export type { ILanguageLoadSettings, ILazyModuleData, IListItem, INotificationConfig, IQuestion, IQuestionOptions, IRouterDeactivatable, ISelectListItem, ISize, ITransportLazyModuleData, IValueStorage, IViewElement, IWindowConfig, LazyModulePath, MomentAvailableType, NotificationConfigOptions, NotificationId, RouterServiceBaseEventData, UserUid, WindowConfigOptions, WindowContentContainer, WindowId };