@norgate-av/ch5-crcomlib 2.17.2

package/build_bundles/amd/@types/ch5-list/ch5-list-animation.d.ts

@@ -0,0 +1,39 @@
+import { Ch5List } from "./ch5-list";
+import { Ch5ListAbstractHelper } from "./ch5-list-abstract-helper";
+import { Ch5Animation, TAnimationCallback } from "./animation/ch5-animation";
+import { TCh5ListElementOrientation } from "./interfaces/t-ch5-list";
+export declare const defaultTransitionDuration = 0;
+export type TAnimateCallback = (element: HTMLElement, currentPosition: number, mode: TCh5ListElementOrientation, previousPosition?: number, callback?: TAnimationCallback) => void;
+export declare enum EDragDirection {
+    next = 1,
+    previous = 0
+}
+export declare class Ch5ListAnimation extends Ch5ListAbstractHelper {
+    disableAnimation: boolean;
+    animationAPI: Ch5Animation;
+    animationFrame: number;
+    maxOffsetTranslate: number | undefined;
+    minOffsetTranslate: number;
+    direction: number;
+    constructor(list: Ch5List, animationApi?: Ch5Animation);
+    stop(): void;
+    onFinishAnimation(): void;
+    addAnimationApi(api: Ch5Animation): boolean;
+    startDecelerating(): void;
+    listDeceleration(): void;
+    fixOffset(coord: number): number;
+    signalScrollTo(position: number): void;
+    slideTo(coord: number): void;
+    resolveDirection(last: number, current: number): number;
+    updateDragPosition(newPosition: number, animate?: TAnimateCallback): void;
+    adjustMaxOffset(isBuffered?: boolean): number;
+    resetOffsets(): void;
+    private _infiniteLoopManager;
+    private stackInfinite;
+    private queueInfinite;
+    private _calculateNextPosition;
+    private _loop;
+    private _arrangementCondition;
+    private _computeNewPosition;
+    private _log;
+}

package/build_bundles/amd/@types/ch5-list/ch5-list-buffered-items.d.ts

@@ -0,0 +1,17 @@
+import { Ch5ListAbstractHelper } from "./ch5-list-abstract-helper";
+export interface ICh5ListBufferedItems {
+    bufferActive: boolean;
+    bufferingComplete: boolean;
+    bufferForwardStartIndex: number;
+    forwardBufferedItems: HTMLElement[];
+    bufferBackwardsStartIndex: number;
+    backwardsBufferedItems: HTMLElement[];
+}
+export declare class Ch5ListBufferedItems extends Ch5ListAbstractHelper {
+    bufferItems(skipForward?: boolean, skipBackwards?: boolean): void;
+    _appendForwardBufferedItemsToList(currentScrollPos: number, verticalDir: boolean, itemSizeOffset: number): void;
+    maybeAddBufferItems(newPosition: number): void;
+    private _bufferItemsForward;
+    private _bufferItemsBackwards;
+    private _appendBackwardsBufferedItemsToList;
+}

package/build_bundles/amd/@types/ch5-list/ch5-list-event-manager.d.ts

@@ -0,0 +1,25 @@
+import { Ch5List } from "./ch5-list";
+import { Ch5ListAbstractHelper } from "./ch5-list-abstract-helper";
+export declare const stepAllowancePx = 50;
+export declare class Ch5ListEventManager extends Ch5ListAbstractHelper {
+    protected _dragAllowanceAngle: number;
+    protected _currentDragAngle: number;
+    protected _listHasMoved: boolean;
+    private _hammer;
+    private _updateManager;
+    constructor(list: Ch5List);
+    removeEvents(additionalElement: HTMLElement): void;
+    initializeEvents(additionalElement: HTMLElement): void;
+    protected initializeTouchEvents(additionalElement: HTMLElement): void;
+    protected initializeMouseEvents(additionalElement: HTMLElement): void;
+    protected checkTouchSupport(): boolean;
+    onWindowResize(): void;
+    onPointerDown(event: MouseEvent | TouchEvent): void;
+    onPointerMove(event: MouseEvent | TouchEvent): void;
+    onPointerEnd(event: MouseEvent | TouchEvent): void;
+    onPointerCancel(): void;
+    updateDragEventListeners(element: HTMLElement): void;
+    private onOrientationChange;
+    stopPointerTracking(): void;
+    private _addTrackingPoint;
+}

package/build_bundles/amd/@types/ch5-list/ch5-list-signal-manager.d.ts

@@ -0,0 +1,12 @@
+import { Ch5Signal } from "../ch5-core";
+import { Ch5ListAbstractHelper } from "./ch5-list-abstract-helper";
+import { TSignal } from '../ch5-core/types/signal.type';
+import { Ch5SignalUpdateCallback } from "../ch5-core/types/callbacks";
+export type SignalSubscription = (sigName: string | null | undefined, subscriptionKey: string) => void;
+export type SignalSubscriptionCallback = (newValue: string | number | boolean) => void;
+export declare class Ch5ListSignalManager extends Ch5ListAbstractHelper {
+    unsubscribeFromSignals(clearStringSignalSubscription: SignalSubscription): void;
+    subscribeToSignal<T extends TSignal>(type: T, signalPropName: string, signalSub: string, callback: Ch5SignalUpdateCallback<T>): string;
+    getStateFromFactory<T extends TSignal>(signalName: string, type: T): Ch5Signal<T> | null;
+    private clearSubscription;
+}

package/build_bundles/amd/@types/ch5-list/ch5-list-size-resolver.d.ts

@@ -0,0 +1,16 @@
+import { TCh5ListElementOrientation } from "./interfaces";
+export declare class Ch5ListSizeResolver {
+    elements: HTMLElement[];
+    viewPortSize: number;
+    fullListSize: number;
+    hiddenListSize: number;
+    orientation: TCh5ListElementOrientation;
+    constructor(elements: HTMLElement[], orientation: TCh5ListElementOrientation);
+    getItemsPerPage(): number;
+    getTotalSize(): number;
+    getOverflowSize(): number;
+    getFullSize(): number;
+    updateViewport(viewport: HTMLElement): void;
+    private init;
+    private getElementSize;
+}

package/build_bundles/amd/@types/ch5-list/ch5-list-template.d.ts

@@ -0,0 +1,53 @@
+import { ICh5ListItemInfo } from './ch5-list';
+import { Ch5ListAbstractHelper } from './ch5-list-abstract-helper';
+import { TAnimateCallback } from './ch5-list-animation';
+export interface ICh5ListStylesheet {
+    [key: string]: any;
+}
+export declare class Ch5ListTemplate extends Ch5ListAbstractHelper {
+    scrollbarSize: number;
+    cachedListFullSize: number | undefined;
+    endless: boolean;
+    private _tmplString;
+    private _scrollbarElement;
+    private _lastScrollbarPosition;
+    private resizeDebouncer;
+    initializationTask: number | undefined;
+    resetListLayoutTask: number | undefined;
+    set scrollbarElement(element: HTMLElement | null);
+    get scrollbarElement(): HTMLElement | null;
+    checkForTemplate(): string;
+    updateTemplateString(tmplString: string): void;
+    processTemplate(uid: string, index: number, templateVars: string | null): HTMLElement;
+    private setCustomAttributesInChildComponents;
+    listItemCSS(): {
+        display: string;
+        width: string;
+        height: string;
+    };
+    attachCSS(): void;
+    updateListMainElStyle(): void;
+    resizeList(element: HTMLElement, templateVars: string | null, resize?: boolean): void;
+    resetListLayout(): void;
+    triggerResizeDueWidthAndHeightUpdates(): void;
+    removeScrollbar(): void;
+    customScrollbar(additionalElement: HTMLElement): void;
+    updateScrollBarPosition(newPosition: number, animate?: TAnimateCallback): void;
+    setWrapperTranslateX(tx: number, animate?: TAnimateCallback): void;
+    setWrapperTranslateY(ty: number, animate?: TAnimateCallback): void;
+    setItemTranslateX(tx: number, item: ICh5ListItemInfo): void;
+    setItemTranslateY(ty: number, item: ICh5ListItemInfo): void;
+    computePage(coord: number, start?: number, end?: number): number;
+    checkAndSetSizes(): void;
+    updateViewportSize(viewportSize?: number): void;
+    resolveEndlessViewportSize(): void;
+    private resetItemsTransform;
+    private isPositionExceedingMaximumBoundary;
+    private getRelativeScrollbarPosition;
+    private computeItemLocation;
+    private processTemplateForVars;
+    private textReplace;
+    private createScrollbar;
+    private prepareStyleSheet;
+    private initListMaxWidthAndHeight;
+}

package/build_bundles/amd/@types/ch5-list/ch5-list.d.ts

@@ -0,0 +1,283 @@
+import { Ch5Common } from '../ch5-common/ch5-common';
+import { TCh5ListElementOrientation } from "./interfaces";
+import { Ch5ListTemplate } from './ch5-list-template';
+import { Ch5ListEventManager } from './ch5-list-event-manager';
+import { Ch5ListSignalManager } from './ch5-list-signal-manager';
+import { Ch5ListAnimation } from './ch5-list-animation';
+import { Ch5ListBufferedItems, ICh5ListBufferedItems } from './ch5-list-buffered-items';
+import { ICh5ListAttributes } from "./interfaces";
+import { Ch5ListSizeResolver } from './ch5-list-size-resolver';
+import { Ch5SignalElementAttributeRegistryEntries } from "../ch5-common/ch5-signal-attribute-registry";
+import { ICh5PropertySettings } from "../ch5-core/ch5-property";
+export interface ICh5ListItemInfo {
+    element: HTMLElement;
+    layoutIndex: number;
+    translateX: number;
+    translateY: number;
+}
+export declare enum Ch5ListItemAxis {
+    X = 0,
+    Y = 1
+}
+export type Ch5ListSignature = {
+    [key: string]: any;
+};
+export declare const duration = 300;
+export declare const easeMode = "ease-out";
+export declare class Ch5List extends Ch5Common implements ICh5ListAttributes {
+    static readonly ELEMENT_NAME = "ch5-list";
+    static ORIENTATION: TCh5ListElementOrientation[];
+    static readonly SIGNAL_ATTRIBUTE_TYPES: Ch5SignalElementAttributeRegistryEntries;
+    static readonly COMPONENT_DATA: any;
+    static readonly COMPONENT_PROPERTIES: ICh5PropertySettings[];
+    static ENABLED_CLASS_NAME: string;
+    static ITEMCLASS: string;
+    private _ch5Properties;
+    primaryCssClass: string;
+    _bufferedItems: ICh5ListBufferedItems;
+    _appendPosition: number;
+    _divListWidth: number;
+    _divListHeight: number;
+    itemOffsetWidth: number;
+    itemOffsetHeight: number;
+    viewportClientHeight: number;
+    viewportClientWidth: number;
+    templateHelper: Ch5ListTemplate;
+    eventManager: Ch5ListEventManager;
+    animationHelper: Ch5ListAnimation;
+    signalManager: Ch5ListSignalManager;
+    bufferdItemsHelper: Ch5ListBufferedItems;
+    divList: HTMLDivElement;
+    pointerStartTime: number;
+    pointerEndTime: number;
+    stepOnX: number;
+    stepOnY: number;
+    currentPage: number;
+    templateElement: HTMLTemplateElement;
+    sizeResolver: Ch5ListSizeResolver;
+    private _currentXPosition;
+    private _currentYPosition;
+    private _defaultScrollToTime;
+    private _size;
+    private _previousSize;
+    private _orientation;
+    private _bufferAmount;
+    private _itemHeight;
+    private _itemWidth;
+    private _minWidth;
+    private _maxWidth;
+    private _minHeight;
+    private _maxHeight;
+    private _pagedSwipe;
+    private _scrollToTime;
+    private _indexId;
+    private _direction;
+    private _templateVars;
+    private _receiveStateSize;
+    private _receiveStateSizeSub;
+    private _receiveStateScrollTo;
+    private _receiveStateScrollToSub;
+    private _receiveStateTemplateVars;
+    private _receiveStateTemplateVarsSub;
+    private _processingPan;
+    private _storedOffsetWidth;
+    private _storedOffsetHeight;
+    private _tplHtmlString;
+    private _updateTimer;
+    private _isPointerActive;
+    private _pointerId;
+    private _pointerFirstX;
+    private _pointerFirstY;
+    private _pointerLastX;
+    private _pointerLastY;
+    private _pointerCurrentX;
+    private _pointerCurrentY;
+    private _lastDraggedLayoutIndex;
+    private _trackingPointsX;
+    private _trackingPointsY;
+    private _dragTicking;
+    private _maxDecelVelocity;
+    private _minDecelVelocity;
+    private _friction;
+    private _attraction;
+    private _decelVelocity;
+    private _decelerating;
+    private _scrollToTimeReference;
+    private _initCompleted;
+    private _cachedFirstRenderVisibleItemsNr;
+    private _items;
+    private _lastViewIndex;
+    private _infiniteLoop;
+    private _wrapperTranslateX;
+    private _wrapperTranslateY;
+    private _selectedIteration;
+    private _previousEffectiveLayoutIndex;
+    private _isListVisible;
+    private receiveStateScrollToChanged;
+    static registerSignalAttributeTypes(): void;
+    static registerCustomElement(): void;
+    constructor();
+    getCssClassDisabled(): string;
+    connectedCallback(): void;
+    initializations(): void;
+    disconnectedCallback(): void;
+    unsubscribeFromSignals(): void;
+    attributeChangedCallback(attr: string, oldValue: string, newValue: string): void;
+    getItemSize(): number;
+    getItemsPerPage(): number;
+    getVisibleItemsPerPage(): number;
+    _canUseBufferAmount(firstRenderVisibleItemsNr: number): boolean;
+    getFirstRenderVisibleItemsNr(resetFirstRenderVisItemsNrCache?: boolean): number;
+    swipe(func: Promise<void>): void;
+    static get observedAttributes(): string[];
+    set currentXPosition(position: number);
+    get currentXPosition(): number;
+    set currentYPosition(position: number);
+    get currentYPosition(): number;
+    get isVertical(): boolean;
+    get isHorizontal(): boolean;
+    get size(): number | null;
+    set size(value: number | null);
+    get previousSize(): number | null;
+    set previousSize(value: number | null);
+    get orientation(): TCh5ListElementOrientation | null;
+    set orientation(value: TCh5ListElementOrientation | null);
+    get bufferAmount(): number | null;
+    set bufferAmount(value: number | null);
+    get itemHeight(): string | null;
+    set itemHeight(value: string | null);
+    get itemWidth(): string | null;
+    set itemWidth(value: string | null);
+    get minWidth(): string | null;
+    set minWidth(value: string | null);
+    get maxWidth(): string | null;
+    set maxWidth(value: string | null);
+    isLtr(): boolean;
+    private getMaxWidthInPxFromPercentage;
+    private getMaxHeightInPxFromPercentage;
+    private calculatePxSize;
+    get minHeight(): string | null;
+    set minHeight(value: string | null);
+    get maxHeight(): string | null;
+    set maxHeight(value: string | null);
+    get indexId(): string | null;
+    set indexId(value: string | null);
+    get pagedSwipe(): boolean;
+    set pagedSwipe(value: boolean);
+    set endless(value: boolean);
+    get endless(): boolean;
+    set scrollbar(value: boolean);
+    get scrollbar(): boolean;
+    get scrollToTime(): number;
+    set scrollToTime(value: number);
+    get templateVars(): string | null;
+    set templateVars(value: string | null);
+    get direction(): string | null;
+    set direction(value: string | null);
+    set isPointerActive(status: boolean);
+    get isPointerActive(): boolean;
+    set pointerId(id: number);
+    get pointerId(): number;
+    set decelerating(decelerate: boolean);
+    get decelerating(): boolean;
+    set decelVelocity(velocity: number);
+    get decelVelocity(): number;
+    get receiveStateSize(): string | null | undefined;
+    set receiveStateSize(value: string | null | undefined);
+    getLayoutInfo(): Ch5ListSizeResolver;
+    get receiveStateScrollTo(): string | null | undefined;
+    set receiveStateScrollTo(value: string | null | undefined);
+    handleScrollbar(): void;
+    private setScrollToContent;
+    get receiveStateTemplateVars(): string | null | undefined;
+    set receiveStateTemplateVars(value: string | null | undefined);
+    get receiveStateSizeSub(): string;
+    set receiveStateSizeSub(subscription: string);
+    get receiveStateScrollToSub(): string;
+    set receiveStateScrollToSub(subscription: string);
+    get receiveStateTemplateVarsSub(): string;
+    set receiveStateTemplateVarsSub(subscription: string);
+    get selected(): number;
+    set selected(index: number);
+    set disableAnimation(value: boolean);
+    get disableAnimation(): boolean;
+    get appendPosition(): number;
+    set appendPosition(position: number);
+    set pointerFirstX(pointer: number);
+    get pointerFirstX(): number;
+    set pointerLastX(pointer: number);
+    get pointerLastX(): number;
+    set pointerCurrentX(pointer: number);
+    get pointerCurrentX(): number;
+    set pointerCurrentY(pointer: number);
+    get pointerCurrentY(): number;
+    set pointerFirstY(pointer: number);
+    get pointerFirstY(): number;
+    set pointerLastY(pointer: number);
+    get pointerLastY(): number;
+    set lastDraggedLayoutIndex(index: number);
+    get lastDraggedLayoutIndex(): number;
+    set trackingPointsX(points: any[]);
+    get trackingPointsX(): any[];
+    set trackingPointsY(points: any[]);
+    get trackingPointsY(): any[];
+    set items(items: ICh5ListItemInfo[]);
+    get items(): ICh5ListItemInfo[];
+    set selectedIteration(iterationNumber: number);
+    get selectedIteration(): number;
+    set wrapperTranslateX(value: number);
+    get wrapperTranslateX(): number;
+    set wrapperTranslateY(value: number);
+    get wrapperTranslateY(): number;
+    set minDecelVelocity(value: number);
+    get minDecelVelocity(): number;
+    set maxDecelVelocity(value: number);
+    set divListWidth(value: number);
+    get divListWidth(): number;
+    set divListHeight(value: number);
+    get divListHeight(): number;
+    set lastViewIndex(index: number);
+    get lastViewIndex(): number;
+    set attraction(value: number);
+    get attraction(): number;
+    set friction(value: number);
+    get friction(): number;
+    set dragTicking(tick: boolean);
+    get dragTicking(): boolean;
+    set infiniteLoop(loop: boolean);
+    get infiniteLoop(): boolean;
+    set bufferedItems(bufferedItems: ICh5ListBufferedItems);
+    get bufferedItems(): ICh5ListBufferedItems;
+    set scrollToTimeReference(ref: number);
+    get scrollToTimeReference(): number;
+    set storedOffsetWidth(width: number);
+    get storedOffsetWidth(): number;
+    set storedOffsetHeight(height: number);
+    get storedOffsetHeight(): number;
+    previousViewChild(): void;
+    nextViewChild(): void;
+    onResizeList(): void;
+    getItemDataIndexFromLayoutIndex(layoutIndex: number): number;
+    computeNext(i: number): number;
+    computePrevious(i: number): number;
+    update(): void;
+    protected handleShow(targetElement: HTMLElement): void;
+    private isPagedSwipeCompatible;
+    protected invokePropIncompatibility(attribute: string): void;
+    private definePropIncompatibilityInfo;
+    private _getCssBiggestSizeValue;
+    private shouldUpdateListAndPosition;
+    private resetListAndPosition;
+    private _getFirstRenderedItemsNr;
+    getFirstItemSizingDetails(): ClientRect | DOMRect;
+    setCurrentPosition(position: number): void;
+    private _startReadyObserver;
+    private _getItems;
+    private _internalUpdate;
+    private _updateInfiniteLoop;
+    private _computeItemsPerViewLayout;
+    private _computeLastViewIndex;
+    private initializeAttributes;
+    private initializeEvents;
+    private removeEvents;
+}

package/build_bundles/amd/@types/ch5-list/index.d.ts

@@ -0,0 +1 @@
+export * from './ch5-list';

package/build_bundles/amd/@types/ch5-list/interfaces/i-ch5-list-attributes.d.ts

@@ -0,0 +1,21 @@
+import { ICh5CommonAttributes } from '../../ch5-common/interfaces';
+import { TCh5ListElementOrientation } from '../interfaces/t-ch5-list';
+export interface ICh5ListAttributes extends ICh5CommonAttributes {
+    size: number | null;
+    orientation: TCh5ListElementOrientation | null;
+    bufferAmount: number | null;
+    itemHeight: string | null;
+    itemWidth: string | null;
+    minWidth: string | null;
+    maxWidth: string | null;
+    minHeight: string | null;
+    maxHeight: string | null;
+    scrollToTime: number;
+    indexId: string | null;
+    scrollbar: boolean;
+    pagedSwipe: boolean;
+    endless: boolean;
+    receiveStateSize: string | null | undefined;
+    receiveStateScrollTo: string | null | undefined;
+    receiveStateTemplateVars: string | null | undefined;
+}

package/build_bundles/amd/@types/ch5-list/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./i-ch5-list-attributes";
+export * from "./t-ch5-list";

package/build_bundles/amd/@types/ch5-list/interfaces/t-ch5-list.d.ts

@@ -0,0 +1 @@
+export type TCh5ListElementOrientation = 'vertical' | 'horizontal';

package/build_bundles/amd/@types/ch5-list/passiveEventListeners.d.ts

@@ -0,0 +1,3 @@
+export declare function getEvtListenerOptions(isPassive: boolean): false | {
+    passive: boolean;
+};

package/build_bundles/amd/@types/ch5-logger/appender/AbstractAppender.d.ts

@@ -0,0 +1,13 @@
+import { LogMessage } from '../helpers/index';
+import { Observable, BehaviorSubject } from 'rxjs';
+export declare abstract class AbstractAppender {
+    private _sendLogTimeOffset;
+    isInitialized: boolean;
+    isInitializedSubject: BehaviorSubject<boolean>;
+    constructor(sendLogTimeOffsetInMiliseconds: number);
+    set sendLogTimeOffset(sendLogTimeOffset: Observable<number>);
+    get sendLogTimeOffset(): Observable<number>;
+    abstract closeSocketConnection(): void;
+    abstract configObserver(config: {}, hasConfig: boolean): void;
+    abstract log(data: LogMessage): void;
+}

package/build_bundles/amd/@types/ch5-logger/appender/AppenderFactory.d.ts

@@ -0,0 +1,6 @@
+import { AppendersEnum } from '../enums/index';
+import { RemoteAppender } from './RemoteAppender';
+import { TAppenderConfig } from '../types';
+export declare class AppenderFactory {
+    getAppender(appender: AppendersEnum, sendLogTimeOffset: number | undefined, appenderConfig: TAppenderConfig): RemoteAppender;
+}

package/build_bundles/amd/@types/ch5-logger/appender/RemoteAppender.d.ts

@@ -0,0 +1,18 @@
+import { AbstractAppender } from "./AbstractAppender";
+import { LogMessage } from "../helpers/index";
+import { Logger } from "../logger";
+import { TAppenderConfig } from "../types";
+export declare class RemoteAppender extends AbstractAppender {
+    private static _instance;
+    private webSocket;
+    private _requestService;
+    private _address;
+    static getInstance(sendLogTimeOffsetInMilliseconds: number, appenderConfig: TAppenderConfig): RemoteAppender;
+    closeSocketConnection(): void;
+    private constructor();
+    log(data: LogMessage): void;
+    resetIP(hostname: string, port: string, secure?: boolean): void;
+    private setIP;
+    configObserver(helper: Logger, hasFilterConfig: boolean): void;
+    protected initializeRequest(uri: string): void;
+}

package/build_bundles/amd/@types/ch5-logger/enums/index.d.ts

@@ -0,0 +1,13 @@
+export declare enum LogLevelEnum {
+    default = 0,
+    info = 1,
+    warning = 2,
+    error = 3
+}
+export declare enum AppendersEnum {
+    remote = "remote",
+    console = "console"
+}
+export declare enum LogEndpointsEnum {
+    log = "log"
+}

package/build_bundles/amd/@types/ch5-logger/helpers/LogMessage.d.ts

@@ -0,0 +1,12 @@
+import { TDataLog } from '../types/index';
+import { LogLevelEnum } from '../enums/index';
+import { LogMessagesFilter } from './LogMessagesFilter';
+export declare class LogMessage {
+    date: Date;
+    readonly level: LogLevelEnum;
+    readonly message: string;
+    readonly source: string;
+    constructor(data: TDataLog, logFilter: LogMessagesFilter);
+    protected getStringTime(): string;
+    toString(): string;
+}

package/build_bundles/amd/@types/ch5-logger/helpers/LogMessagesFilter.d.ts

@@ -0,0 +1,17 @@
+import { TDataLog } from '../types';
+import { LogLevelEnum } from '../enums';
+export declare class LogMessagesFilter {
+    private _regularExpression;
+    level: LogLevelEnum;
+    source: string;
+    static getDefaultLevel(): LogLevelEnum;
+    constructor(level?: LogLevelEnum, source?: string, regexStr?: string);
+    get regularExpression(): string;
+    set regularExpression(value: string);
+    undateSourceFromConfig(): void;
+    clearFilter(): void;
+    applyFilter(data: TDataLog): boolean;
+    isMatchingFilterLevel(dataLevel: LogLevelEnum): boolean;
+    isMatchingFilterRegex(message: string): boolean;
+    isMatchingFilterSource(dataSource: string): boolean;
+}

package/build_bundles/amd/@types/ch5-logger/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './LogMessage';
+export * from './LogMessagesFilter';

package/build_bundles/amd/@types/ch5-logger/index.d.ts

@@ -0,0 +1,3 @@
+export * from './helpers/index';
+export * from './logger/index';
+export * from './utility/index';

package/build_bundles/amd/@types/ch5-logger/logger/Logger.d.ts

@@ -0,0 +1,33 @@
+import { AbstractAppender } from "../appender/AbstractAppender";
+import { TLogMessageType } from "../types/index";
+import { LogMessage } from "../helpers/index";
+import { LogLevelEnum } from "../enums/index";
+import { LogMessagesFilter } from "../helpers/LogMessagesFilter";
+import { BehaviorSubject } from 'rxjs';
+export declare class Logger {
+    private static _instance;
+    private _subscribeDockerStatus;
+    private _appender;
+    private _logFilter;
+    private _messagesQueue;
+    private originalConsole;
+    static getInstance(appender: AbstractAppender, logFilter?: LogMessagesFilter): Logger;
+    private disconnect;
+    private constructor();
+    get subscribeDockerStatus(): BehaviorSubject<string>;
+    set subscribeDockerStatus(value: BehaviorSubject<string>);
+    set logFilter(logFilter: LogMessagesFilter);
+    get logFilter(): LogMessagesFilter;
+    log(...message: TLogMessageType): void;
+    info(...message: TLogMessageType): void;
+    warn(message: string): void;
+    error(message: string, line?: number): void;
+    windowErrorListener(error: ErrorEvent | CustomEvent): void;
+    restoreConsole(): void;
+    addWindowErrorListener(): void;
+    set appender(appender: AbstractAppender);
+    get appender(): AbstractAppender;
+    protected formatMessage(level: LogLevelEnum, message: string): LogMessage;
+    private checkAndAppendMessages;
+    private queueMessage;
+}

package/build_bundles/amd/@types/ch5-logger/logger/index.d.ts

@@ -0,0 +1 @@
+export { Logger } from './Logger';

package/build_bundles/amd/@types/ch5-logger/services/RequestService.d.ts

@@ -0,0 +1,11 @@
+import { AxiosResponse } from "axios";
+import { LogMessage, LogMessagesFilter } from "../helpers/index";
+export declare class RequestService {
+    private _uri;
+    private _requestAPI;
+    constructor(uri: string);
+    post(endpoint: string, data: LogMessage): Promise<boolean>;
+    get(endpoint: string): Promise<AxiosResponse<LogMessagesFilter>> | boolean;
+    set uri(uri: string);
+    get uri(): string;
+}

package/build_bundles/amd/@types/ch5-logger/services/index.d.ts

@@ -0,0 +1 @@
+export * from './RequestService';

package/build_bundles/amd/@types/ch5-logger/types/index.d.ts

@@ -0,0 +1,12 @@
+import { LogLevelEnum } from '../enums/index';
+export type TDataLog = {
+    level: LogLevelEnum;
+    source: string;
+    message: string;
+};
+export type TLogMessageType = any[];
+export type TAppenderConfig = {
+    hostname: string;
+    port: string;
+    secure: boolean;
+};

package/build_bundles/amd/@types/ch5-logger/utility/getLogger.d.ts

@@ -0,0 +1,4 @@
+import { Logger } from '../logger/index';
+import { AbstractAppender } from '../appender/AbstractAppender';
+import { LogMessagesFilter } from '../helpers/LogMessagesFilter';
+export declare function getLogger(appender: AbstractAppender, overrideGlobalConsole?: boolean, logFilter?: LogMessagesFilter): Logger;

package/build_bundles/amd/@types/ch5-logger/utility/getRemoteAppender.d.ts

@@ -0,0 +1,2 @@
+import { RemoteAppender } from '../appender/RemoteAppender';
+export declare function getRemoteAppender(hostname: string, port: string, secure: boolean): RemoteAppender;