@anglr/common 8.0.0-beta.20211109062458 → 8.0.0-beta.20211217111139

package/common.d.ts

@@ -1,6 +1,1371 @@
+import { ChangeDetectorRef } from '@angular/core';
+import { ClassProvider } from '@angular/core';
+import { Dictionary } from '@jscrpt/common';
+import { ElementRef } from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import { FactoryProvider } from '@angular/core';
+import { HttpEvent } from '@angular/common/http';
+import { HttpHandler } from '@angular/common/http';
+import { HttpInterceptor } from '@angular/common/http';
+import { HttpRequest } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import * as i6 from '@angular/common';
+import { InjectionToken } from '@angular/core';
+import { Injector } from '@angular/core';
+import { NgModuleRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import { OnChanges } from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import { OnInit } from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { Subject } from 'rxjs';
+import { Subscription } from 'rxjs';
+import { TemplateRef } from '@angular/core';
+import { Type } from '@angular/core';
+import { ValueProvider } from '@angular/core';
+import { ViewContainerRef } from '@angular/core';
+
 /**
- * Generated bundle index. Do not edit.
+ * Object containing additional info/data
  */
-export * from './public_api';
-export { ProgressOverlayDirective as ɵa } from './src/modules/progressIndicator/directives/progressOverlay/progressOverlay.directive';
-//# sourceMappingURL=common.d.ts.map
+export declare interface AdditionalInfo<TAdditional = any, TItem = any> {
+    /**
+     * Additional info object
+     */
+    additionalInfo?: Dictionary<TItem> & TAdditional;
+}
+
+/**
+ * Injection token used for obtaining promise that is resolved when application is first time stable
+ */
+export declare const APP_STABLE: InjectionToken<Promise<void>>;
+
+/**
+ * Directive that handles click outside of element
+ */
+export declare class ClickOutsideDirective implements OnInit, OnDestroy {
+    private _element;
+    private _document;
+    /**
+     * Variable that is used for displaying element that handles click outside
+     */
+    clickOutsideCondition: boolean;
+    /**
+     * Additional element that is checked for click
+     */
+    clickOutsideElement: HTMLElement;
+    /**
+     * Used for emitting event when click outside occurs
+     */
+    clickOutsideConditionChange: EventEmitter<boolean>;
+    constructor(_element: ElementRef<HTMLElement>, _document: Document);
+    /**
+     * Initialize component
+     */
+    ngOnInit(): void;
+    /**
+     * Called when component is destroyed
+     */
+    ngOnDestroy(): void;
+    /**
+     * Handles click outside of element
+     * @param event - Mouse event object
+     */
+    protected _handleClickOutside: (event: MouseEvent) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickOutsideDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickOutsideDirective, "[clickOutside]", never, { "clickOutsideCondition": "clickOutside"; "clickOutsideElement": "clickOutsideElement"; }, { "clickOutsideConditionChange": "clickOutsideChange"; }, never>;
+}
+
+/**
+ * Module for ClickOutside directive
+ */
+export declare class ClickOutsideModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickOutsideModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClickOutsideModule, [typeof i1_4.ClickOutsideDirective], never, [typeof i1_4.ClickOutsideDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClickOutsideModule>;
+}
+
+/**
+ * Module for common components, pipes and directives
+ */
+export declare class CommonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CommonModule, [typeof i1.NgComponentOutletEx, typeof i2.IsNaNPipe, typeof i3.IsPresentPipe, typeof i4.LocalizePipe, typeof i5.UrlEncodePipe], [typeof i6.CommonModule], [typeof i1.NgComponentOutletEx, typeof i2.IsNaNPipe, typeof i3.IsPresentPipe, typeof i5.UrlEncodePipe, typeof i4.LocalizePipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CommonModule>;
+}
+
+/**
+ * Implementation of permanent storage using cookies
+ */
+export declare class CookiePermanentStorageService implements PermanentStorage {
+    private _cookies;
+    constructor(_cookies: CookieService);
+    /**
+     * Gets value that was stored with 'name' from permanent storage
+     * @param name - Name with which was value stored
+     */
+    get<TResult>(name: string): TResult;
+    /**
+     * Sets value that will be stored with 'name'e in permanent storage
+     * @param name - Name with which will be value stored
+     * @param value - Value to be stored
+     */
+    set(name: string, value: any): void;
+    /**
+     * Sets value that will be stored with 'name' in permanent storage until expiration date
+     * @param name - Name with which will be value stored
+     * @param value - Value to be stored
+     * @param expires - Time when value should expire
+     */
+    set(name: string, value: any, expires: Date): void;
+    /**
+     * Removes value stored with 'name' from permanent storage
+     * @param name - Name of stored value that will be removed
+     */
+    remove(name: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CookiePermanentStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CookiePermanentStorageService>;
+}
+
+/**
+ * Class that is used as wrapper for working with cookies
+ */
+export declare class CookieService {
+    private _serverCookies;
+    /**
+     * Indication that current code is running in browser
+     */
+    private _isBrowser;
+    constructor(platformId: Object, _serverCookies: string);
+    /**
+     * Retrieves a single cookie by it's name
+     *
+     * @param name - Identification of the Cookie
+     * @param skipSerialization - Indication whether skip deserialization from json string
+     * @returns The Cookie's value
+     */
+    getCookie(name: string, skipSerialization?: boolean): any;
+    /**
+     * Save the Cookie
+     *
+     * @param name - Cookie's identification
+     * @param value - Cookie's value
+     * @param expires - Cookie's expiration date in days from now. If it's undefined the cookie is a session Cookie
+     * @param path - Path relative to the domain where the cookie should be avaiable. Default /
+     * @param domain - Domain where the cookie should be avaiable. Default current domain
+     * @param skipSerialization - Indication whether skip serialization to json string
+     */
+    setCookie(name: string, value: any, expires?: number, path?: string, domain?: string, skipSerialization?: boolean): void;
+    /**
+     * Removes specified Cookie
+     *
+     * @param name - Cookie's identification
+     * @param path - Path relative to the domain where the cookie should be avaiable. Default /
+     * @param domain - Domain where the cookie should be avaiable. Default current domain
+     */
+    deleteCookie(name: string, path?: string, domain?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CookieService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CookieService>;
+}
+
+/**
+ * Component used for displaying debug data
+ */
+export declare class DebugDataComponent implements OnDestroy, OnInit {
+    protected _debugDataEnabledSvc: DebugDataEnabledService;
+    protected _changeDetector: ChangeDetectorRef;
+    protected _element: ElementRef<HTMLElement>;
+    /**
+     * Subscription for changes of debug data enabled
+     */
+    protected _debugDataEnabledChangeSubscription: Subscription;
+
+    constructor(_debugDataEnabledSvc: DebugDataEnabledService, _changeDetector: ChangeDetectorRef, _element: ElementRef<HTMLElement>);
+    /**
+     * Initialize component
+     */
+    ngOnInit(): void;
+    /**
+     * Called when component is destroyed
+     */
+    ngOnDestroy(): void;
+    /**
+     * Sets enabled css class according enabled state
+     */
+    private _setEnabledCssClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DebugDataComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DebugDataComponent, "debug-data", never, {}, {}, never, ["*"]>;
+}
+
+/**
+ * Service used for handling enabled state for debug data component
+ */
+export declare class DebugDataEnabledService {
+    /**
+     * Indication whether debug data copmonent is enabled
+     */
+    private _enabled;
+    /**
+     * Subject used for emitting changes of enabled state
+     */
+    private _enabledChangeSubject;
+    /**
+     * Indication whether debug data copmonent is enabled
+     */
+    get enabled(): boolean;
+    /**
+     * Occurs when enabled state changed
+     */
+    get enabledChange(): Observable<void>;
+    /**
+     * Sets enabled state
+     * @param enabled - Indication whether will be enabled state set to true, or false, defaults to true
+     */
+    setEnabled(enabled?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DebugDataEnabledService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DebugDataEnabledService>;
+}
+
+/**
+ * Module that contains debug data component
+ */
+export declare class DebugDataModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DebugDataModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DebugDataModule, [typeof i1_3.DebugDataComponent], [typeof i6.CommonModule], [typeof i1_3.DebugDataComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DebugDataModule>;
+}
+
+/**
+ * Default notifications provider
+ */
+export declare const DEFAULT_NOTIFICATIONS: NotificationsProvider;
+
+/**
+ * Default notifications service implementation
+ */
+export declare class DefaultNotificationsService implements Notifications {
+    protected _options: NotificationsOptions;
+    /**
+     * Array of notifications
+     */
+    protected _notifications: Notification_2[];
+    /**
+     * Array of notifications timeouts
+     */
+    protected _notificationsTimeouts: number[];
+    /**
+     * Subject used for emitting changes of current notifications
+     */
+    protected _notificationsChange: Subject<void>;
+    /**
+     * Subject used for emitting event when instance is being destroyed
+     */
+    protected _destroy: Subject<void>;
+    /**
+     * Array of scoped notifications
+     */
+    protected _scopes: Dictionary<[Notifications, Subscription]>;
+    /**
+     * @inheritdoc
+     */
+    get notifications(): readonly Notification_2[];
+    /**
+     * @inheritdoc
+     */
+    get notificationsChange(): Observable<void>;
+    /**
+     * @inheritdoc
+     */
+    get destroy(): Observable<void>;
+    constructor(_options: NotificationsOptions);
+    /**
+     * @inheritdoc
+     */
+    message(message: string, severity: NotificationSeverity): Notifications;
+    /**
+     * @inheritdoc
+     */
+    default(message: string): Notifications;
+    /**
+     * @inheritdoc
+     */
+    success(message: string): Notifications;
+    /**
+     * @inheritdoc
+     */
+    error(message: string): Notifications;
+    /**
+     * @inheritdoc
+     */
+    info(message: string): Notifications;
+    /**
+     * @inheritdoc
+     */
+    warning(message: string): Notifications;
+    /**
+     * @inheritdoc
+     */
+    clearNotifications(): Notifications;
+    /**
+     * @inheritdoc
+     */
+    remove(notification: Notification_2): Notifications;
+    /**
+     * @inheritdoc
+     */
+    getScope(scopeName: string): Notifications;
+    /**
+     * @inheritdoc
+     *
+     * Call this manualy for scoped instances until this is fixed https://github.com/angular/angular/issues/28738
+     */
+    ngOnDestroy(): void;
+    /**
+     * Removes notification from array of notifications
+     * @param notification - Notification to be removed
+     * @param emitEvent - Indication whether emit event on removal
+     */
+    protected _remove(notification: Notification_2, emitEvent?: boolean): Notifications;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultNotificationsService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultNotificationsService>;
+}
+
+/**
+ * Method used for extraction of resolve method for promise
+ * @param appStablePromise - Promise which contains resolve method that is going to be extracted
+ */
+export declare function extractAppStableResolve(appStablePromise: Promise<void>): () => void;
+
+/**
+ * Globalization service for handling globalization changes
+ */
+export declare abstract class GlobalizationService {
+    /**
+     * Gets current name of locale, that is used within application
+     */
+    abstract get locale(): string;
+    /**
+     * Gets observable that emits when locale changes and change should be applied to application
+     */
+    abstract get localeChange(): Observable<void>;
+}
+
+/**
+ * Token is used to transfer http request authentication header
+ */
+export declare const HTTP_REQUEST_AUTH_HEADER: InjectionToken<string>;
+
+/**
+ * Base url when using HTTP (example: http://localhost:8888/)
+ */
+export declare const HTTP_REQUEST_BASE_URL: InjectionToken<string>;
+
+/**
+ * Token is used to transfer http request cookie header
+ */
+export declare const HTTP_REQUEST_COOKIE_HEADER: InjectionToken<string>;
+
+declare namespace i1 {
+    export {
+        NgComponentOutletEx
+    }
+}
+
+declare namespace i1_2 {
+    export {
+        ProgressIndicatorComponent
+    }
+}
+
+declare namespace i1_3 {
+    export {
+        DebugDataComponent
+    }
+}
+
+declare namespace i1_4 {
+    export {
+        ClickOutsideDirective
+    }
+}
+
+declare namespace i1_5 {
+    export {
+        MultiButtonComponent
+    }
+}
+
+declare namespace i2 {
+    export {
+        IsNaNPipe
+    }
+}
+
+declare namespace i2_2 {
+    export {
+        ProgressOverlayDirective
+    }
+}
+
+declare namespace i3 {
+    export {
+        IsPresentPipe
+    }
+}
+
+declare namespace i4 {
+    export {
+        LocalizePipe
+    }
+}
+
+declare namespace i4_2 {
+    export {
+        CommonModule
+    }
+}
+
+declare namespace i5 {
+    export {
+        UrlEncodePipe
+    }
+}
+
+/**
+ * Contains id of request, used for IgnoredInterceptorsService
+ */
+export declare interface IgnoredInterceptorId {
+    /**
+     * Identification of request
+     */
+    requestId?: string;
+}
+
+/**
+ * Service used for disabling specific http client interceptor for one call, if you add interceptor you want to disable before call it will be disabled
+ */
+export declare class IgnoredInterceptorsService {
+    /**
+     * Array of interceptors that will be ignored
+     */
+    private _ignoredInterceptors;
+    /**
+     * Clears all ignored interceptors from service
+     */
+    clear(): void;
+    /**
+     * Adds interceptor type that should be ignored for specified url
+     * @param interceptorType - Type of interceptor should be ignored
+     * @param additionalInfo - Object containing additional info - request id
+     */
+    addInterceptor<TType>(interceptorType: Type<TType>, additionalInfo: IgnoredInterceptorId): void;
+    /**
+     * Checks specified interceptor whether is ingored
+     * @param interceptorType - Type of interceptor that is checked whether is ignored
+     * @param url - Object containing request id
+     */
+    isIgnored<TType>(interceptorType: Type<TType>, requestId: IgnoredInterceptorId): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgnoredInterceptorsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IgnoredInterceptorsService>;
+}
+
+/**
+ * Returns true if object is NaN
+ */
+export declare class IsNaNPipe implements PipeTransform {
+    /**
+     * Checks whether is value NaN
+     * @param value - Value to be checked
+     */
+    transform(value: any): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsNaNPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsNaNPipe, "isNaN">;
+}
+
+/**
+ * Returns true if object is different from null or undefined
+ */
+export declare class IsPresentPipe implements PipeTransform {
+    /**
+     * Checks whether is value different from null or undefined
+     * @param value - Value to be checked
+     */
+    transform(value: any): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsPresentPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsPresentPipe, "isPresent">;
+}
+
+/**
+ * Localize strings using 'StringLocalization'
+ */
+export declare class LocalizePipe implements PipeTransform, OnInit, OnDestroy {
+    private _localizationSvc;
+    private _changeDetector;
+    /**
+     * Subscription for changes of texts
+     */
+    private _subscription;
+    constructor(_localizationSvc: StringLocalization, _changeDetector: ChangeDetectorRef);
+    /**
+     * Gets localized string for specified key, interpolation might be used
+     * @param key - Key to be localized
+     * @param interpolateParams - Optional object storing interpolation parameters
+     */
+    transform(key: string, interpolateParams?: Object): string;
+    /**
+     * Initialize component
+     */
+    ngOnInit(): void;
+    /**
+     * Called when component is destroyed
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocalizePipe, "localize">;
+}
+
+/**
+ * Contains name of progress indicator group
+ */
+export declare interface LocalProgressIndicatorName {
+    /**
+     * Name of progress indicator group
+     */
+    progressGroupName?: string;
+}
+
+/**
+ * Token used for injecting Logger implementation
+ */
+export declare const LOGGER: InjectionToken<Logger>;
+
+/**
+ * Interface for general logger
+ */
+export declare interface Logger {
+    /**
+     * Logs an event with the LogEventLevel.fatal severity.
+     * @param messageTemplate - Message template for the log event.
+     * @param properties - Properties that can be used to render the message template.
+     */
+    fatal(messageTemplate: string, ...properties: any[]): void;
+    /**
+     * Logs an event with the LogEventLevel.fatal severity.
+     * @param error - Error for the log event.
+     * @param messageTemplate - Message template for the log event.
+     * @param properties - Properties that can be used to render the message template.
+     */
+    fatal(error: Error, messageTemplate: string, ...properties: any[]): void;
+    /**
+     * Logs an event with the LogEventLevel.error severity.
+     * @param messageTemplate - Message template for the log event.
+     * @param properties - Properties that can be used to render the message template.
+     */
+    error(messageTemplate: string, ...properties: any[]): void;
+    /**
+     * Logs an event with the LogEventLevel.error severity.
+     * @param error - Error for the log event.
+     * @param messageTemplate - Message template for the log event.
+     * @param properties - Properties that can be used to render the message template.
+     */
+    error(error: Error, messageTemplate: string, ...properties: any[]): void;
+    /**
+     * Logs an event with the LogEventLevel.warning severity.
+     * @param messageTemplate - Message template for the log event.
+     * @param properties - Properties that can be used to render the message template.
+     */
+    warn(messageTemplate: string, ...properties: any[]): void;
+    /**
+     * Logs an event with the LogEventLevel.warning severity.
+     * @param error - Error for the log event.
+     * @param messageTemplate - Message template for the log event.
+     * @param properties - Properties that can be used to render the message template.
+     */
+    warn(error: Error, messageTemplate: string, ...properties: any[]): void;
+    /**
+     * Logs an event with the LogEventLevel.information severity.
+     * @param messageTemplate - Message template for the log event.
+     * @param properties - Properties that can be used to render the message template.
+     */
+    info(messageTemplate: string, ...properties: any[]): void;
+    /**
+     * Logs an event with the LogEventLevel.information severity.
+     * @param error - Error for the log event.
+     * @param messageTemplate - Message template for the log event.
+     * @param properties - Properties that can be used to render the message template.
+     */
+    info(error: Error, messageTemplate: string, ...properties: any[]): void;
+    /**
+     * Logs an event with the LogEventLevel.debug severity.
+     * @param messageTemplate - Message template for the log event.
+     * @param properties - Properties that can be used to render the message template.
+     */
+    debug(messageTemplate: string, ...properties: any[]): void;
+    /**
+     * Logs an event with the LogEventLevel.debug severity.
+     * @param error - Error for the log event.
+     * @param messageTemplate - Message template for the log event.
+     * @param properties - Properties that can be used to render the message template.
+     */
+    debug(error: Error, messageTemplate: string, ...properties: any[]): void;
+    /**
+     * Logs an event with the LogEventLevel.verbose severity.
+     * @param messageTemplate - Message template for the log event.
+     * @param properties - Properties that can be used to render the message template.
+     */
+    verbose(messageTemplate: string, ...properties: any[]): void;
+    /**
+     * Logs an event with the LogEventLevel.verbose severity.
+     * @param error - Error for the log event.
+     * @param messageTemplate - Message template for the log event.
+     * @param properties - Properties that can be used to render the message template.
+     */
+    verbose(error: Error, messageTemplate: string, ...properties: any[]): void;
+}
+
+/**
+ * Implementation of temporary storage using process memory
+ */
+export declare class MemoryTemporaryStorageService implements TemporaryStorage {
+    /**
+     * Storage used for storing values
+     */
+    private _memory;
+    /**
+     * Gets value that was stored with 'name' from temporary storage
+     * @param name - Name with which was value stored
+     */
+    get<TResult>(name: string): TResult;
+    /**
+     * Sets value that will be stored with 'name'e in temporary storage
+     * @param name - Name with which will be value stored
+     * @param value - Value to be stored
+     */
+    set(name: string, value: any): void;
+    /**
+     * Removes value stored with 'name' from temporary storage
+     * @param name - Name of stored value that will be removed
+     */
+    remove(name: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MemoryTemporaryStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MemoryTemporaryStorageService>;
+}
+
+/**
+ * Injection token for default css classes for multibutton
+ */
+export declare const MULTI_BUTTON_CSS_CLASSES: InjectionToken<MultiButtonCssClasses>;
+
+/**
+ * Component used for displaying multibutton
+ */
+export declare class MultiButtonComponent implements OnDestroy {
+    protected _document: Document;
+    protected _element: ElementRef<HTMLElement>;
+    protected _changeDetector: ChangeDetectorRef;
+    /**
+     * Used css classes within component
+     */
+    protected _usedCssClasses: MultiButtonCssClasses;
+
+
+    /**
+     * Css class applied to main displayed element
+     */
+    cssClass: string;
+    /**
+     * Css classes used within component, allows to change specific class
+     */
+    get cssClasses(): MultiButtonCssClasses;
+    set cssClasses(classes: MultiButtonCssClasses);
+    /**
+     * Occurs when user clicks on button
+     */
+    click: EventEmitter<MouseEvent>;
+    /**
+     * Template that is used for rendering sub buttons content
+     */
+    subButtonsContent: TemplateRef<void>;
+    constructor(_document: Document, _cssClasess: MultiButtonCssClasses, _element: ElementRef<HTMLElement>, _changeDetector: ChangeDetectorRef);
+    /**
+     * Called when component is destroyed
+     */
+    ngOnDestroy(): void;
+    /**
+     * Method called when sub buttons should be shown
+     */
+    showSubButtons(event: MouseEvent): void;
+    /**
+     * Handles click outside of multi button element
+     */
+    protected _handleClickOutside: () => void;
+    /**
+     * Removes event registration
+     */
+    protected _removeRegistration(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiButtonComponent, [null, { optional: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultiButtonComponent, "multi-button", never, { "cssClass": "cssClass"; "cssClasses": "cssClasses"; }, { "click": "click"; }, ["subButtonsContent"], ["*"]>;
+}
+
+/**
+ * Describes multi button css classes
+ */
+export declare interface MultiButtonCssClasses {
+    /**
+     * Main button div
+     */
+    mainButtonDiv?: string;
+    /**
+     * Main button content div
+     */
+    mainButtonContentDiv?: string;
+    /**
+     * Main button separator div
+     */
+    mainButtonSeparatorDiv?: string;
+    /**
+     * Main button click area div
+     */
+    mainButtonClickAreaDiv?: string;
+    /**
+     * Main button option div
+     */
+    mainButtonMultiOptionDiv?: string;
+    /**
+     * Div for displaying sub buttons
+     */
+    subButtonsDiv?: string;
+}
+
+/**
+ * Module containing components for displaying multi button
+ */
+export declare class MultiButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MultiButtonModule, [typeof i1_5.MultiButtonComponent], [typeof i6.CommonModule], [typeof i1_5.MultiButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MultiButtonModule>;
+}
+
+/**
+ * Instantiates a single Component type and inserts its Host View into current View.
+ */
+export declare class NgComponentOutletEx<TComponent> implements OnChanges {
+    private _viewContainerRef;
+    /**
+     * Created component reference
+     */
+    private _componentRef;
+    /**
+     * Type that should be dynamically created into current container
+     */
+    ngComponentOutletEx: Type<TComponent>;
+    /**
+     * Custom injector that will be used for newly created component
+     */
+    ngComponentOutletExInjector: Injector;
+    /**
+     * Projectable nodes that can be injected into component
+     */
+    ngComponentOutletExContent: any[][];
+    /**
+     * Occurs when component is created or destroyed, it can send instance of component, or null
+     */
+    ngComponentOutletExCreated: EventEmitter<TComponent | null>;
+    /**
+     * Instance of dynamically created component
+     */
+    get component(): TComponent | null;
+    constructor(_viewContainerRef: ViewContainerRef);
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgComponentOutletEx<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgComponentOutletEx<any>, "[ngComponentOutletEx]", ["ngComponentOutletEx"], { "ngComponentOutletEx": "ngComponentOutletEx"; "ngComponentOutletExInjector": "ngComponentOutletExInjector"; "ngComponentOutletExContent": "ngComponentOutletExContent"; }, { "ngComponentOutletExCreated": "ngComponentOutletExCreated"; }, never>;
+}
+
+/**
+ * Default implementation of StringLocalization, which uses 'key' as localization text
+ */
+export declare class NoStringLocalizationService implements StringLocalization {
+    /**
+     * Subject used for emitting when indication that locale has changes and strings should be obtained again, because they have changed
+     */
+    private _textsChangeSubject;
+    /**
+     * Occurs when indication that locale has changes and strings should be obtained again, because they have changed
+     */
+    get textsChange(): Observable<void>;
+    /**
+     * Gets localized string for specified key, interpolation might be used
+     * @param key - Key to be localized
+     * @param interpolateParams - Optional object storing interpolation parameters
+     */
+    get(key: string, interpolateParams?: Dictionary<any>): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NoStringLocalizationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NoStringLocalizationService>;
+}
+
+/**
+ * Instance of notification that is being displayed
+ */
+declare class Notification_2 {
+    private _message;
+    private _severity;
+    /**
+     * Gets message that this notification represents
+     */
+    get message(): string;
+    /**
+     * Gets severity of notification message
+     */
+    get severity(): NotificationSeverity;
+    /**
+     * Creates instance of `Notification`
+     * @param _message - Message that this notification represents
+     * @param _severity - Severity of notification message
+     */
+    constructor(_message: string, _severity: NotificationSeverity);
+}
+export { Notification_2 as Notification }
+
+/**
+ * Token used for injecting notifications service implementation
+ */
+export declare const NOTIFICATIONS: InjectionToken<Notifications>;
+
+/**
+ * Manages currently displayed notifications
+ */
+export declare interface Notifications {
+    /**
+     * Gets array of notifications
+     */
+    readonly notifications: readonly Notification_2[];
+    /**
+     * Gets observable that emits changes of current notifications
+     */
+    readonly notificationsChange: Observable<void>;
+    /**
+     * Gets observable that emits event when instance is being destroyed
+     */
+    readonly destroy: Observable<void>;
+    /**
+     * Displays message with specified severity
+     * @param message - Message to be displayed
+     * @param severity - Severity of displayed notification
+     */
+    message(message: string, severity: NotificationSeverity): Notifications;
+    /**
+     * Displays default notification
+     * @param message - Message to be displayed
+     */
+    default(message: string): Notifications;
+    /**
+     * Displays success notification
+     * @param message - Message to be displayed
+     */
+    success(message: string): Notifications;
+    /**
+     * Displays error notification
+     * @param message - Message to be displayed
+     */
+    error(message: string): Notifications;
+    /**
+     * Displays info notification
+     * @param message - Message to be displayed
+     */
+    info(message: string): Notifications;
+    /**
+     * Displays warning notification
+     * @param message - Message to be displayed
+     */
+    warning(message: string): Notifications;
+    /**
+     * Clears all displayed notifications
+     */
+    clearNotifications(): Notifications;
+    /**
+     * Removes notification
+     * @param notification - Notification to be removed
+     */
+    remove(notification: Notification_2): Notifications;
+    /**
+     * Gets scoped instance of `Notifications`
+     * @param scopeName - Name of scope to be returned
+     */
+    getScope(scopeName: string): Notifications;
+    /**
+     * Destroys service and clears all used resources
+     */
+    ngOnDestroy(): void;
+}
+
+/**
+ * Token used for injecting notifications scope name
+ */
+export declare const NOTIFICATIONS_SCOPE: InjectionToken<string>;
+
+/**
+ * Severity of notification message
+ */
+export declare enum NotificationSeverity {
+    /**
+     * Default severity of message, no special meaning
+     */
+    Default = 0,
+    /**
+     * Information severity of message
+     */
+    Info = 1,
+    /**
+     * Success severity of message
+     */
+    Success = 2,
+    /**
+     * Warning severity of message
+     */
+    Warning = 3,
+    /**
+     * Error severity of message
+     */
+    Error = 4
+}
+
+/**
+ * Configuration object that is used by `Notifications` default implementation
+ */
+export declare class NotificationsOptions {
+    /**
+     * Timeout in ms, after which will be notification closed, if set to 0, message will stay permanently until closed by user
+     */
+    timeout: number;
+    constructor(timeout?: number);
+}
+
+/**
+ * Notifications provider that allows to create scoped notifications provider
+ */
+export declare interface NotificationsProvider extends ClassProvider {
+    /**
+     * Gets scoped providers
+     */
+    scope?: NotificationsScopeProviderFactory;
+}
+
+/**
+ * Tuple that will hold notification provider and notifications scope provider
+ */
+export declare type NotificationsScopeProvider = [ValueProvider, FactoryProvider];
+
+/**
+ * Factory for creating `NotificationsScopeProvider`
+ */
+export declare interface NotificationsScopeProviderFactory {
+    /**
+     * Creates `NotificationsScopeProvider` with specified `scopeName`
+     * @param scopeName - Name of scope to be created
+     * @param token - Custom token that can be used for injecting Notifications under custom provider
+     */
+    (scopeName: string, token?: Function | Type<any> | InjectionToken<unknown>): NotificationsScopeProvider;
+    /**
+     * Creates `NotificationsScopeProvider` with random scope name
+     */
+    random?: NotificationsScopeProvider;
+}
+
+/**
+ * Token used for injecting permanent storage
+ */
+export declare const PERMANENT_STORAGE: InjectionToken<PermanentStorage>;
+
+/**
+ * Provides api for implementing permanent storage
+ */
+export declare interface PermanentStorage {
+    /**
+     * Gets value that was stored with 'name' from permanent storage
+     * @param name - Name with which was value stored
+     */
+    get<TResult>(name: string): TResult;
+    /**
+     * Sets value that will be stored with 'name'e in permanent storage
+     * @param name - Name with which will be value stored
+     * @param value - Value to be stored
+     */
+    set(name: string, value: any): void;
+    /**
+     * Sets value that will be stored with 'name' in permanent storage until expiration date
+     * @param name - Name with which will be value stored
+     * @param value - Value to be stored
+     * @param expires - Time when value should expire
+     */
+    set(name: string, value: any, expires: Date): void;
+    /**
+     * Removes value stored with 'name' from permanent storage
+     * @param name - Name of stored value that will be removed
+     */
+    remove(name: string): void;
+}
+
+/**
+ * Token used for injecting positioning service implementation
+ */
+export declare const POSITIONING: InjectionToken<Positioning>;
+
+/**
+ * Allows relative positioning of elements
+ */
+declare interface Positioning {
+}
+
+/**
+ * Progress interceptor provider
+ */
+export declare const PROGRESS_INTERCEPTOR_PROVIDER: ClassProvider;
+
+/**
+ * Component that is used for displaying global progress indicator
+ */
+export declare class ProgressIndicatorComponent implements OnDestroy {
+    private _service;
+    private _changeDetector;
+    /**
+     * Subscription for changes in ProgressIndicatorService
+     */
+    private _subscription;
+
+
+    /**
+     * Sets css classes that will be applied to indicator
+     */
+    set cssClass(cssClass: string);
+    /**
+     * Sets indication that progress indicator is running
+     */
+    private set running(value);
+    constructor(_service: ProgressIndicatorService, _changeDetector: ChangeDetectorRef);
+    /**
+     * Called when component is destroyed
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressIndicatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressIndicatorComponent, "progress-indicator", never, { "cssClass": "cssClass"; }, {}, never, never>;
+}
+
+/**
+ * Module for progress indicator
+ */
+export declare class ProgressIndicatorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressIndicatorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProgressIndicatorModule, [typeof i1_2.ProgressIndicatorComponent, typeof i2_2.ProgressOverlayDirective], [typeof i6.CommonModule, typeof i4_2.CommonModule], [typeof i1_2.ProgressIndicatorComponent, typeof i2_2.ProgressOverlayDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProgressIndicatorModule>;
+}
+
+/**
+ * Configuration object that is used by ProgressIndicatorService, overriding its properties allows you to customize configuration
+ */
+export declare class ProgressIndicatorOptions {
+    /**
+     * Timeout length after which will be progress indication displayed
+     */
+    timeout: number;
+    /**
+     * Indication whether fallback to default group name
+     */
+    fallbackToDefault: boolean;
+    constructor(timeout?: number, fallbackToDefault?: boolean);
+}
+
+/**
+ * Service that is used for displaying and hiding progress indicator
+ */
+export declare class ProgressIndicatorService {
+    private _platformId;
+    config?: ProgressIndicatorOptions;
+    /**
+     * Indication that current code is running in browser
+     */
+    private _isBrowser;
+    /**
+     * Information about running progress for each group
+     */
+    private _runningRequests;
+    /**
+     * Used for invoking stateChange when state of one of progress groups have changed, passing name of group as parameter
+     */
+    private _stateChange;
+    /**
+     * Object storing registered overlay groups
+     */
+    private _registeredOverlays;
+    /**
+     * Indications that progress is running for each group
+     */
+    running: {
+        [group: string]: boolean;
+    };
+    /**
+     * Messages for each group
+     */
+    messages: {
+        [group: string]: string[];
+    };
+    /**
+     * Occurs when state of one of progress groups have changed, passing name of group as parameter
+     */
+    get stateChange(): Observable<string>;
+    constructor(_platformId: Object, config?: ProgressIndicatorOptions);
+    /**
+     * Displays progress indicator after short delay
+     */
+    showProgress(): void;
+    /**
+     * Displays progress indicator after short delay
+     * @param name - Name of progress group (separate counter)
+     */
+    showProgress(name: string): void;
+    /**
+     * Displays progress indicator after short delay
+     * @param messages - Array of messages to display what is happening
+     */
+    showProgress(messages: string[]): void;
+    /**
+     * Displays progress indicator after short delay
+     * @param name - Name of progress group (separate counter)
+     * @param messages - Array of messages to display what is happening
+     */
+    showProgress(name: string, messages: string[]): void;
+    /**
+     * Hides progress indicator
+     */
+    hideProgress(): void;
+    /**
+     * Hides progress indicator
+     * @param name - Name of progress group (separate counter)
+     */
+    hideProgress(name: string): void;
+    /**
+     * Hides progress indicator
+     * @param force - Indication that indicator should be hidden even if some processes are running
+     */
+    hideProgress(force: boolean): void;
+    /**
+     * Hides progress indicator
+     * @param name - Name of progress group (separate counter)
+     * @param force - Indication that indicator should be hidden even if some processes are running
+     */
+    hideProgress(name: string, force: boolean): void;
+    /**
+     * Adds message to progress indicator group
+     * @param message - Message to display what is happening
+     */
+    addMessage(message: string): void;
+    /**
+     * Adds message to progress indicator group
+     * @param name - Name of progress group (separate counter)
+     * @param message - Message to display what is happening
+     */
+    addMessage(name: string, message?: string): void;
+    /**
+     * Clears all messages for progress group
+     * @param name - Name of progress group (separate counter)
+     */
+    clearMessages(name?: string): void;
+
+
+    /**
+     * Gets name of group based on existance of this group
+     * @param name - Name of group that is requested
+     */
+    private _getName;
+    /**
+     * Used for invoking 'stateChange' event
+     * @param name - Name of group which has changes its state
+     * @param value - Value whether is progress running
+     * @param messages - Messages to be displayed for this group
+     */
+    private _onRunning;
+    /**
+     * Updates state of progress indicator service
+     */
+    private _updateState;
+    /**
+     * Gets object for progress group
+     * @param name - Name of group to be obtained
+     */
+    private _getGroup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressIndicatorService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProgressIndicatorService>;
+}
+
+/**
+ * ProgressInterceptor used for intercepting http requests and displaying progress indicatior
+ */
+export declare class ProgressInterceptor implements HttpInterceptor {
+    private _indicatorSvc;
+    private _ignoredInterceptorsService?;
+    constructor(_indicatorSvc: ProgressIndicatorService, _ignoredInterceptorsService?: IgnoredInterceptorsService);
+    /**
+     * Intercepts http request
+     * @param req - Request to be intercepted
+     * @param next - Next middleware that can be called for next processing
+     */
+    intercept(req: HttpRequest<any> & AdditionalInfo<LocalProgressIndicatorName & IgnoredInterceptorId>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressInterceptor, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProgressInterceptor>;
+}
+
+/**
+ * Directive that is used for displaying progress indicator as overlay
+ */
+declare class ProgressOverlayDirective implements OnInit, OnDestroy {
+    private _service;
+    private _element;
+    private _document;
+    private _localizationSvc;
+    /**
+     * Previous css position value
+     */
+    private _notRunningCssPosition;
+    /**
+     * Previous css overflow value
+     */
+    private _notRunningOverflow;
+    /**
+     * Subscription for changes in ProgressIndicatorService
+     */
+    private _subscription;
+    /**
+     * Array of messages that should be displayed
+     */
+    private _messages;
+    /**
+     * Indication that this progress indicator is running
+     */
+    private _running;
+    /**
+     * Element that is displaying progress indicator overlay
+     */
+    private _progressElement;
+    /**
+     * Html messages element
+     */
+    private _messagesElement;
+    /**
+     * Html message elements, last three
+     */
+    private _lastThreeMessages;
+    /**
+     * Name of progress indicator group
+     */
+    name: string;
+    constructor(_service: ProgressIndicatorService, _element: ElementRef<HTMLElement>, _document: Document, _localizationSvc: StringLocalization);
+    /**
+     * Initialize component
+     */
+    ngOnInit(): void;
+    /**
+     * Called when component is destroyed
+     */
+    ngOnDestroy(): void;
+    /**
+     * Renders progress overlay
+     */
+    private _renderProgressOverlay;
+    /**
+     * Renders messages to progress overlay
+     */
+    private _renderProgressMessages;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressOverlayDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ProgressOverlayDirective, "[progressOverlay]", never, { "name": "progressOverlay"; }, {}, never>;
+}
+
+/**
+ * Runs callback function when angular module is bootstrapped and stable
+ * @param moduleRefPromise - Promise for module that was bootstrapped
+ * @param callback - Callback that is called
+ * @param angularProfiler - Indication that angular profiler should be enabled
+ */
+export declare function runWhenModuleStable(moduleRefPromise: Promise<NgModuleRef<{}>>, callback: (moduleRef: NgModuleRef<{}>) => void, angularProfiler?: boolean): void;
+
+/**
+ * Service used for transfering http status code for response
+ */
+export declare class StatusCodeService {
+    /**
+     * Current status code
+     */
+    private _statusCode?;
+    /**
+     * Gets current status code
+     */
+    get statusCode(): number | null | undefined;
+    /**
+     * Sets current status code
+     * @param code - Status code value that will be set
+     */
+    setStatusCode(code?: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StatusCodeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StatusCodeService>;
+}
+
+/**
+ * Token used for injecting StringLocalization service implementation
+ */
+export declare const STRING_LOCALIZATION: InjectionToken<StringLocalization>;
+
+/**
+ * Provides api to localize strings
+ */
+export declare interface StringLocalization {
+    /**
+     * Occurs when indication that locale has changes and strings should be obtained again, because they have changed
+     */
+    readonly textsChange: Observable<void>;
+    /**
+     * Gets localized string for specified key, interpolation might be used
+     * @param key - Key to be localized
+     * @param interpolateParams - Optional object storing interpolation parameters
+     */
+    get(key: string, interpolateParams?: Object): string;
+}
+
+/**
+ * Token used for injecting temporary storage
+ */
+export declare const TEMPORARY_STORAGE: InjectionToken<TemporaryStorage>;
+
+/**
+ * Provides api for implementing temporary storage
+ */
+export declare interface TemporaryStorage {
+    /**
+     * Gets value that was stored with 'name' from temporary storage
+     * @param name - Name with which was value stored
+     */
+    get<TResult>(name: string): TResult;
+    /**
+     * Sets value that will be stored with 'name'e in temporary storage
+     * @param name - Name with which will be value stored
+     * @param value - Value to be stored
+     */
+    set(name: string, value: any): void;
+    /**
+     * Removes value stored with 'name' from temporary storage
+     * @param name - Name of stored value that will be removed
+     */
+    remove(name: string): void;
+}
+
+/**
+ * Pipe that encodes data for url
+ */
+export declare class UrlEncodePipe implements PipeTransform {
+    /**
+     * Encodes data for URL
+     * @param value - Value to be encoded
+     */
+    transform(value: object): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UrlEncodePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<UrlEncodePipe, "urlEncode">;
+}
+
+export { }