monkey-style-guide 2.0.212 → 21.0.0

package/types/monkey-style-guide.d.ts

@@ -0,0 +1,2045 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, ComponentRef, InputSignal, OutputEmitterRef, AfterContentInit, AfterContentChecked, OnDestroy, ElementRef, EventEmitter, ChangeDetectorRef, OnChanges, OnInit, InputSignalWithTransform, SimpleChanges, Renderer2, AfterViewInit, QueryList, StaticProvider, Injector, InjectionToken, ViewContainerRef, ApplicationRef } from '@angular/core';
+import { NgControl, AbstractControlDirective, ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+import * as rxjs from 'rxjs';
+import { Observable, Subject, BehaviorSubject } from 'rxjs';
+import { Router } from '@angular/router';
+import * as i2 from '@angular/common';
+import { CurrencyPipe } from '@angular/common';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { OverlayRef, Overlay } from '@angular/cdk/overlay';
+import { ComponentType } from '@angular/cdk/portal';
+
+declare class MonkeyAccordionComponent {
+    open: boolean;
+    disabled: boolean;
+    set title(data: string | TemplateRef<any>);
+    titleStr: string | undefined;
+    titleRef: TemplateRef<any> | undefined;
+    protected _uid: string;
+    protected _id: string;
+    get id(): string;
+    set id(value: string);
+    constructor();
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyAccordionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyAccordionComponent, "monkey-accordion", never, { "open": { "alias": "open"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "title": { "alias": "title"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_open: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+declare class MonkeyActionBarComponent {
+    get classes(): string | undefined;
+    label: i0.InputSignal<string | undefined>;
+    position: i0.InputSignal<string | undefined>;
+    open: i0.InputSignal<boolean | undefined>;
+    protected _uid: string;
+    protected _id: string;
+    get id(): string;
+    set id(value: string);
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyActionBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyActionBarComponent, "monkey-action-bar", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+type MonkeyAlertType = 'default' | 'info' | 'success' | 'alert' | 'error';
+
+interface MonkeyAutocompleteData {
+    value: string | number | Date | Object;
+    description: string;
+}
+interface MonkeyAutocompleteResponse {
+    data: MonkeyAutocompleteData[];
+}
+
+interface GoogleApiPlacesAddressComponents {
+    longText: string;
+    shortText: string;
+    types: [
+        'street_number' | 'route' | 'sublocality_level_1' | 'sublocality' | 'political' | 'administrative_area_level_1' | 'administrative_area_level_2' | 'country' | 'postal_code'
+    ];
+    languageCode: string;
+    [key: string]: any;
+}
+interface GoogleApiPlaces {
+    formattedAddress: string;
+    addressComponents?: GoogleApiPlacesAddressComponents[];
+    adrFormatAddress?: string;
+    displayName?: {
+        text: string;
+        languageCode: string;
+    };
+}
+interface GoogleApiPlacesResponse {
+    places: GoogleApiPlaces[];
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+interface MonkeyBreadcrumb {
+    label: string;
+    path?: string;
+    callback?: Function;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+type MonkeyButtonType = 'primary' | 'secondary' | 'tertiary';
+type MonkeyButtonColor = 'default' | 'success' | 'error';
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+type MonkeyPopoverDir = 'rtl' | 'ltr' | 'trtl' | 'tltr' | 'ct' | 'cc' | 'cr' | 'rt' | 'rb' | 'lt' | 'lb';
+interface MonkeyPopoverOptions {
+    dir?: MonkeyPopoverDir;
+    minwidth?: boolean;
+    backdrop?: boolean;
+    contextmenu?: boolean;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+type MonkeySize = 'xs' | 'sm' | 'md' | 'lg';
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+interface MonkeyTableScrollConfig {
+    x?: string;
+    y?: string;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyToastRef {
+    private readonly componentRef;
+    constructor(componentRef: ComponentRef<MonkeyToastComponent>);
+    close(): void;
+}
+type MonkeyToastPosition = 'top-center' | 'top-left' | 'top-right' | 'bottom-center' | 'bottom-left' | 'bottom-right';
+type MonkeyToastType = 'default' | 'success' | 'error' | 'warning' | 'question';
+type ToastConfig = {
+    type?: MonkeyToastType;
+    icon?: string;
+    isClosable?: boolean;
+    message: string;
+    position?: MonkeyToastPosition;
+    duration?: number;
+    keepOpen?: boolean;
+    actionLabel?: string;
+    actionIcon?: string;
+    action?: () => void;
+    closeOnAction?: boolean;
+};
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyAlertComponent {
+    buttonLabel: InputSignal<string>;
+    message: InputSignal<string>;
+    title: InputSignal<string>;
+    type: InputSignal<MonkeyAlertType>;
+    onButtonClicked: OutputEmitterRef<void>;
+    protected _uid: string;
+    protected _id: string;
+    get id(): string;
+    set id(value: string);
+    constructor();
+    icon(type: MonkeyAlertType): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyAlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyAlertComponent, "monkey-alert", never, { "buttonLabel": { "alias": "buttonLabel"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": true; "isSignal": true; }; "title": { "alias": "title"; "required": true; "isSignal": true; }; "type": { "alias": "type"; "required": true; "isSignal": true; }; "id": { "alias": "id"; "required": false; }; }, { "onButtonClicked": "onButtonClicked"; }, never, never, true, never>;
+}
+
+declare abstract class MonkeyFormFieldControl {
+    readonly id: string;
+    readonly ngControl: NgControl | AbstractControlDirective | null;
+    readonly disabled: boolean;
+    readonly focused: boolean;
+    readonly stateChanges: Observable<void>;
+    readonly type?: string;
+    readonly currency?: boolean;
+    readonly percent?: boolean;
+    abstract onContainerClick(event: MouseEvent): void;
+    abstract onClear?(): void;
+    loading?: boolean;
+    disableToBeDirty?: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyFormFieldControl, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyFormFieldControl, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class MonkeyFormFieldComponent implements AfterContentInit, AfterContentChecked, OnDestroy {
+    get id(): string;
+    set id(value: string);
+    hideAction: boolean;
+    enableClear: boolean;
+    size: MonkeySize;
+    displayOnly: i0.InputSignal<boolean>;
+    onDisplayOnlyChange: i0.OutputEmitterRef<boolean>;
+    private _formFieldControl;
+    private _displayChild;
+    private _labelChildren;
+    private _helperChildren;
+    private _prefixChildren;
+    private _suffixChildren;
+    private _infoChildren;
+    private _errorChildren;
+    elementRef: ElementRef<any>;
+    private readonly _changeDetectorRef;
+    private readonly _idGenerator;
+    private readonly _labelId;
+    protected _uid: string;
+    protected _id: string;
+    private _destroyRef;
+    private _isFocused;
+    private _previousControl;
+    private _stateChanges;
+    private _valueChanges;
+    readonly currencySymbol: string | undefined;
+    readonly percentSymbol = "%";
+    hasLabel: boolean;
+    hasHelper: boolean;
+    hasPrefix: boolean;
+    hasSuffix: boolean;
+    hasInfo: boolean;
+    hasError: boolean;
+    get control(): MonkeyFormFieldControl;
+    get labelId(): string;
+    hideBorder: i0.Signal<boolean>;
+    get showHeader(): boolean;
+    get showFooter(): boolean;
+    get showInvalid(): boolean;
+    showClear: i0.Signal<boolean>;
+    get showCalendar(): boolean;
+    get showCurrency(): boolean;
+    get showPercent(): boolean;
+    get showLoading(): boolean;
+    internalDisplayOnly: i0.WritableSignal<boolean>;
+    readonly editDictionary: rxjs.Observable<any>;
+    constructor();
+    private updateFocusState;
+    private handleFormFieldControl;
+    private checkPrefixAndSuffix;
+    private initializePrefixAndSuffix;
+    private checkInfoError;
+    private initializeInfoError;
+    private initializeComponents;
+    private initializeControl;
+    private openDatePicker;
+    ngAfterContentInit(): void;
+    ngAfterContentChecked(): void;
+    ngOnDestroy(): void;
+    getFooterMessages(): 'info' | 'error' | '';
+    getSymbols(): string;
+    onClear(event: MouseEvent): void;
+    onOpenCalendar(event: MouseEvent): void;
+    onCancelDisplayOnly(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyFormFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyFormFieldComponent, "monkey-form-field", ["monkeyFormField"], { "id": { "alias": "id"; "required": false; }; "hideAction": { "alias": "hideAction"; "required": false; }; "enableClear": { "alias": "enableClear"; "required": false; }; "size": { "alias": "size"; "required": false; }; "displayOnly": { "alias": "displayOnly"; "required": false; "isSignal": true; }; }, { "onDisplayOnlyChange": "onDisplayOnlyChange"; }, ["_formFieldControl"], ["monkey-display", "monkey-helper", "monkey-prefix", "*", "monkey-suffix", "monkey-error", "monkey-info", "monkey-label"], false, never>;
+    static ngAcceptInputType_hideAction: unknown;
+    static ngAcceptInputType_enableClear: unknown;
+}
+
+type IconName = 'clear' | 'calendar' | 'arrowDown' | 'arrowRight' | 'check' | 'minus' | 'loading' | 'searchFail' | 'search' | 'addPlus' | 'googleMaps' | 'location' | 'edit';
+declare class UtilIconComponent {
+    name: i0.InputSignal<IconName>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UtilIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UtilIconComponent, "util-icon", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MonkeyFormFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyFormFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MonkeyFormFieldModule, [typeof MonkeyFormFieldComponent], [typeof i2.CommonModule, typeof UtilIconComponent], [typeof MonkeyFormFieldComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MonkeyFormFieldModule>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+declare function getCurrencySymbol(code: string): string | undefined;
+
+declare class MonkeyAutocompleteComponent implements MonkeyFormFieldControl, ControlValueAccessor, AfterContentInit, OnDestroy {
+    formField: MonkeyFormFieldComponent;
+    private changeDetectorRef;
+    placeholder: string;
+    debounce: number;
+    tabIndex: number;
+    fetchOptions: (queryOrLink: string | any) => Observable<MonkeyAutocompleteResponse>;
+    onChange: EventEmitter<any>;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    _disabled: boolean;
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    set value(value: any);
+    get value(): any;
+    _value: string | null;
+    constructor(formField: MonkeyFormFieldComponent, changeDetectorRef: ChangeDetectorRef);
+    ngControl: NgControl | null;
+    private readonly idGenerator;
+    readonly id: string;
+    readonly inputId: string;
+    focused: boolean;
+    readonly type: string;
+    readonly stateChanges: Subject<void>;
+    protected _elementRef: ElementRef<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>;
+    _onChange: any;
+    _onTouched: any;
+    get elementTarget(): any;
+    private _searchEvent;
+    private _destroyRef;
+    private _resizeObserver?;
+    initialDisplayWidth: number;
+    showPopOver: boolean;
+    options: MonkeyAutocompleteData[];
+    readonly loadingDictionary: Observable<any>;
+    readonly noDataDictionary: Observable<any>;
+    loading: boolean;
+    searchData: string;
+    optionTemplate?: TemplateRef<any>;
+    containerWrapper: ElementRef;
+    private updateWidth;
+    closePopOver: () => void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    onContainerClick(event: MouseEvent): void;
+    onClear(): void;
+    _onFocus(): void;
+    _onBlur(event: FocusEvent): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: any): void;
+    openPopOver(): void;
+    onInputChange(event: Event): void;
+    onSelect(option: MonkeyAutocompleteData): void;
+    isSelected(option: MonkeyAutocompleteData): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyAutocompleteComponent, [{ optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyAutocompleteComponent, "monkey-autocomplete", never, { "placeholder": { "alias": "placeholder"; "required": true; }; "debounce": { "alias": "debounce"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "fetchOptions": { "alias": "fetchOptions"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "onChange": "onChange"; }, ["optionTemplate"], never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+}
+
+declare class MonkeyAutocompleteAddressComponent implements MonkeyFormFieldControl, ControlValueAccessor, AfterContentInit, OnDestroy {
+    formField: MonkeyFormFieldComponent;
+    private changeDetectorRef;
+    placeholder: string;
+    debounce: number;
+    tabIndex: number;
+    onChange: EventEmitter<any>;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    _disabled: boolean;
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    set value(value: any);
+    get value(): any;
+    _value: string | null;
+    constructor(formField: MonkeyFormFieldComponent, changeDetectorRef: ChangeDetectorRef);
+    ngControl: NgControl | null;
+    private readonly idGenerator;
+    readonly id: string;
+    readonly inputId: string;
+    focused: boolean;
+    readonly type: string;
+    readonly stateChanges: Subject<void>;
+    protected _elementRef: ElementRef<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>;
+    _onChange: any;
+    _onTouched: any;
+    private readonly _addressService;
+    private _searchEvent;
+    private _destroyRef;
+    private _resizeObserver?;
+    initialDisplayWidth: number;
+    showPopOver: boolean;
+    options: GoogleApiPlaces[];
+    readonly loadingDictionary: rxjs.Observable<any>;
+    readonly noDataDictionary: rxjs.Observable<any>;
+    loading: boolean;
+    searchData: string;
+    get elementTarget(): any;
+    optionTemplate?: TemplateRef<any>;
+    containerWrapper: ElementRef;
+    private updateWidth;
+    closePopOver: () => void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    onContainerClick(event: MouseEvent): void;
+    onClear(): void;
+    _onFocus(): void;
+    _onBlur(event: FocusEvent): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: any): void;
+    openPopOver(): void;
+    onInputChange(event: Event): void;
+    onSelect(option: GoogleApiPlaces): void;
+    isSelected(option: GoogleApiPlaces): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyAutocompleteAddressComponent, [{ optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyAutocompleteAddressComponent, "monkey-autocomplete-address", never, { "placeholder": { "alias": "placeholder"; "required": true; }; "debounce": { "alias": "debounce"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "onChange": "onChange"; }, ["optionTemplate"], never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+type MonkeyAvatarSrc = {
+    iconName: string;
+} | {
+    imageUrl: string;
+} | {
+    name: string;
+};
+type MonkeyAvatarType = 'icon' | 'image' | 'name';
+declare class MonkeyAvatarComponent {
+    protected _id: any;
+    readonly size: InputSignal<MonkeySize>;
+    readonly src: InputSignal<MonkeyAvatarSrc>;
+    readonly id: InputSignal<string | undefined>;
+    avatar: string;
+    avatarType: MonkeyAvatarType;
+    get classes(): string;
+    constructor();
+    private getInitial;
+    private handleAvatarType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyAvatarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyAvatarComponent, "monkey-avatar", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "src": { "alias": "src"; "required": true; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MonkeyBadgeComponent {
+    private readonly idGenerator;
+    readonly id: string;
+    hostVariables: {};
+    set type(value: 'success' | 'alert' | 'error' | 'info' | 'default');
+    set typeColors(value: {
+        background: string;
+        color: string;
+    });
+    size: MonkeySize;
+    largePadding: boolean;
+    icon: string;
+    text: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyBadgeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyBadgeComponent, "monkey-badge", never, { "type": { "alias": "type"; "required": false; }; "typeColors": { "alias": "typeColors"; "required": false; }; "size": { "alias": "size"; "required": false; }; "largePadding": { "alias": "largePadding"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "text": { "alias": "text"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_largePadding: unknown;
+}
+
+declare class MonkeyBreadcrumbComponent {
+    first: MonkeyBreadcrumb;
+    last: MonkeyBreadcrumb;
+    colapsed: boolean;
+    protected _router: Router;
+    protected _uid: string;
+    protected _id: string;
+    get id(): string;
+    set id(value: string);
+    constructor();
+    handleNavigate(item: MonkeyBreadcrumb): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyBreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyBreadcrumbComponent, "monkey-breadcrumb", never, { "first": { "alias": "first"; "required": true; }; "last": { "alias": "last"; "required": true; }; "colapsed": { "alias": "colapsed"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_colapsed: unknown;
+}
+
+declare class MonkeyButtonComponent {
+    disabled: boolean;
+    color: MonkeyButtonColor;
+    size: MonkeySize;
+    type: MonkeyButtonType;
+    loading: boolean;
+    private readonly elementRef;
+    protected _uid: string;
+    protected _id: string;
+    get id(): string;
+    set id(value: string);
+    constructor();
+    onClick(event: MouseEvent): void;
+    get element(): HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyButtonComponent, "monkey-button", never, { "disabled": { "alias": "disabled"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "type": { "alias": "type"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, {}, never, ["[first]", "*", "[last]"], true, never>;
+}
+
+declare class MonkeyCheckboxComponent implements ControlValueAccessor, OnChanges, OnInit, Validator {
+    private infoChildren;
+    private labelChildren;
+    private helperChildren;
+    disabled: boolean;
+    indeterminate: boolean;
+    required: boolean;
+    showFooter: boolean;
+    size: 'sm' | 'md' | 'lg';
+    onChange: EventEmitter<boolean>;
+    private _destroyRef;
+    private readonly idGenerator;
+    private injector;
+    private cdr;
+    control: AbstractControl<any, any> | null | undefined;
+    readonly inputId: string;
+    value: boolean;
+    isFocused: boolean;
+    get showInvalid(): boolean;
+    get hasHeader(): boolean;
+    get isTouched(): boolean;
+    get isInvalid(): boolean;
+    ngOnInit(): void;
+    _onChange: any;
+    _onTouched: any;
+    _onValidatorChange: any;
+    ngOnChanges(changes: any): void;
+    onBlur: () => void;
+    onFocus: (event: any) => void;
+    validate(control: AbstractControl): ValidationErrors | null;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    registerOnValidatorChange(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onChangeEvent(event: Event): void;
+    getFooterMessages(): 'info' | 'error' | '';
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyCheckboxComponent, "monkey-checkbox", never, { "disabled": { "alias": "disabled"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showFooter": { "alias": "showFooter"; "required": false; }; "size": { "alias": "size"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "onChange": "onChange"; }, ["infoChildren", "labelChildren", "helperChildren"], ["monkey-label", "monkey-helper", "*", "monkey-error", "monkey-info"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_indeterminate: unknown;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_showFooter: unknown;
+}
+
+interface Calendar {
+    month: number;
+    year: number;
+}
+declare class MonkeyDateRangeComponent implements OnInit {
+    set startDate(val: string);
+    set endDate(val: string);
+    hideQuickAction: boolean;
+    hideHeader: boolean;
+    hideActions: boolean;
+    hideSecondCalendar: boolean;
+    allowFastActionOnHeader: boolean;
+    set minDate(val: Date | string);
+    set maxDate(val: Date | string);
+    onCancel: EventEmitter<any>;
+    onDate: EventEmitter<any>;
+    protected _uid: string;
+    protected _id: string;
+    get id(): string;
+    set id(value: string);
+    private _screenWidth;
+    private _allowChangeFastAction;
+    private _allowChangeSecondCalendar;
+    private readonly _today;
+    readonly i18nDictionary: rxjs.Observable<any>;
+    handledStartDate: string;
+    handledEndDate: string;
+    firstCalendar: Calendar;
+    secondCalendar: Calendar;
+    isInvalidInterval: boolean;
+    handledMinDate: string;
+    handledMaxDate: string;
+    constructor();
+    private handleInitialValues;
+    private handleProperties;
+    private handleInputChange;
+    onResize(event: any): void;
+    ngOnInit(): void;
+    onHandleDate({ startDate, endDate }: {
+        startDate: string;
+        endDate: string;
+    }): void;
+    onSubmit(): void;
+    onHandleQuickAction(event: number): void;
+    onChangeInputStartDate(event: Event): void;
+    onChangeInputEndDate(event: Event): void;
+    onDataChange(event: string, isStart: boolean): void;
+    onHandleNavigate(action: 'previous' | 'next'): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyDateRangeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyDateRangeComponent, "monkey-date-range", never, { "startDate": { "alias": "startDate"; "required": false; }; "endDate": { "alias": "endDate"; "required": false; }; "hideQuickAction": { "alias": "hideQuickAction"; "required": false; }; "hideHeader": { "alias": "hideHeader"; "required": false; }; "hideActions": { "alias": "hideActions"; "required": false; }; "hideSecondCalendar": { "alias": "hideSecondCalendar"; "required": false; }; "allowFastActionOnHeader": { "alias": "allowFastActionOnHeader"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "onCancel": "onCancel"; "onDate": "onDate"; }, never, never, true, never>;
+    static ngAcceptInputType_hideQuickAction: unknown;
+    static ngAcceptInputType_hideHeader: unknown;
+    static ngAcceptInputType_hideActions: unknown;
+    static ngAcceptInputType_hideSecondCalendar: unknown;
+    static ngAcceptInputType_allowFastActionOnHeader: unknown;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyDividerComponent {
+    size: InputSignal<MonkeySize>;
+    vertical: InputSignalWithTransform<boolean, unknown>;
+    get classes(): string;
+    protected _uid: string;
+    protected _id: string;
+    get id(): string;
+    set id(value: string);
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyDividerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyDividerComponent, "monkey-divider", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+type MonkeyDownloadButtonChangeEvent = {
+    component: MonkeyDownloadButtonComponent;
+};
+declare class MonkeyDownloadButtonComponent {
+    progress: number;
+    disabled: boolean;
+    color: MonkeyButtonColor;
+    size: MonkeySize;
+    type: MonkeyButtonType;
+    loading: boolean;
+    tabIndex: number;
+    onChange: EventEmitter<MonkeyDownloadButtonChangeEvent>;
+    protected _uid: string;
+    protected _id: string;
+    get id(): string;
+    set id(value: string);
+    get safeProgress(): number;
+    get hasProgress(): boolean;
+    get enablleMargin(): boolean;
+    constructor();
+    onDownload(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyDownloadButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyDownloadButtonComponent, "monkey-download-button", never, { "progress": { "alias": "progress"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "color": { "alias": "color"; "required": false; }; "size": { "alias": "size"; "required": false; }; "type": { "alias": "type"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "onChange": "onChange"; }, never, ["[first]", "*", "[last]"], true, never>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyFilterBarComponent implements AfterContentInit, OnDestroy, OnChanges {
+    protected _elementRef: ElementRef<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>;
+    showPopOver: boolean;
+    elementTarget: HTMLElement | null;
+    closePopOver: () => void;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    onShowPopOver(el: MonkeyButtonComponent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyFilterBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyFilterBarComponent, "monkey-filter-bar", never, {}, {}, never, never, true, never>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyIconComponent implements OnInit {
+    set icon(val: string);
+    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+    _icon: string;
+    protected _uid: string;
+    protected _id: string;
+    get id(): string;
+    set id(value: string);
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyIconComponent, "monkey-icon", never, { "icon": { "alias": "icon"; "required": false; }; "size": { "alias": "size"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MonkeyIconButtonComponent {
+    type: 'primary' | 'secondary' | 'tertiary';
+    size: 'sm' | 'md' | 'lg';
+    disabled: boolean;
+    icon: string;
+    loading: boolean;
+    protected _uid: string;
+    protected _id: string;
+    get id(): string;
+    set id(value: string);
+    constructor();
+    onClick(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyIconButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyIconButtonComponent, "monkey-icon-button", never, { "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyInputCurrencyDirective implements MonkeyFormFieldControl, OnChanges, OnInit, OnDestroy {
+    private el;
+    private renderer;
+    private currencyPipe;
+    protected _elementRef: ElementRef<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>;
+    protected _uid: string;
+    protected _id: string;
+    readonly stateChanges: Subject<void>;
+    name: string;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get id(): string;
+    set id(value: string);
+    get required(): boolean;
+    set required(value: BooleanInput);
+    protected _required: boolean | undefined;
+    protected _disabled: boolean;
+    get type(): string;
+    set type(value: string);
+    protected _type: string;
+    get currency(): boolean;
+    get percent(): boolean;
+    private readonly _changeDetectorRef;
+    private readonly _currencyCode;
+    private readonly _localeId;
+    private _destroyRef;
+    private _valueChanges;
+    private _rawValue;
+    ngControl: NgControl | null;
+    focused: boolean;
+    constructor(el: ElementRef, renderer: Renderer2, currencyPipe: CurrencyPipe);
+    private markAsUntouched;
+    private focus;
+    private formatValue;
+    private handleControlValue;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges({ disabled }: SimpleChanges): void;
+    onContainerClick(): void;
+    focusChanged(isFocused: boolean): void;
+    focusOutChanged(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyInputCurrencyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyInputCurrencyDirective, "input[monkey-input-currency]", ["monkeyInput"], { "name": { "alias": "name"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; "required": { "alias": "required"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, {}, never, never, false, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyInputDirective implements MonkeyFormFieldControl, OnChanges, OnDestroy {
+    protected _elementRef: ElementRef<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>;
+    protected _uid: string;
+    protected _id: string;
+    readonly stateChanges: Subject<void>;
+    name: string;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get id(): string;
+    set id(value: string);
+    get required(): boolean;
+    set required(value: BooleanInput);
+    protected _required: boolean | undefined;
+    protected _disabled: boolean;
+    get type(): string;
+    set type(value: string);
+    get min(): string;
+    set min(value: string);
+    get max(): string;
+    set max(value: string);
+    protected _type: string;
+    protected _min: string;
+    protected _max: string;
+    get currency(): boolean;
+    get percent(): boolean;
+    set percent(value: '');
+    protected _percent: boolean;
+    ngControl: NgControl | null;
+    focused: boolean;
+    constructor();
+    private markAsUntouched;
+    private focus;
+    ngOnDestroy(): void;
+    ngOnChanges({ disabled }: SimpleChanges): void;
+    onContainerClick(): void;
+    focusChanged(isFocused: boolean): void;
+    focusOutChanged(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyInputDirective, "input[monkey-input],textarea[monkey-input]", ["monkeyInput"], { "name": { "alias": "name"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; "required": { "alias": "required"; "required": false; }; "type": { "alias": "type"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "percent": { "alias": "percent"; "required": false; }; }, {}, never, never, false, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+declare class MonkeyInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MonkeyInputModule, [typeof MonkeyInputDirective, typeof MonkeyInputCurrencyDirective], never, [typeof MonkeyInputDirective, typeof MonkeyInputCurrencyDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MonkeyInputModule>;
+}
+
+declare class MonkeyInputCodeComponent implements ControlValueAccessor, MonkeyFormFieldControl, AfterViewInit {
+    private formField;
+    readonly stateChanges: Subject<void>;
+    readonly type: string;
+    readonly currency: boolean;
+    readonly percent: boolean;
+    readonly id: any;
+    private _onChange;
+    private _onTouched;
+    private _value;
+    ngControl: NgControl | null;
+    focused: boolean;
+    length: InputSignal<number>;
+    inputType: InputSignal<string>;
+    inputIndices: i0.Signal<string[]>;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    _disabled: boolean;
+    set value(value: any);
+    get value(): any;
+    inputs: QueryList<ElementRef<HTMLInputElement>>;
+    constructor(formField: MonkeyFormFieldComponent);
+    ngAfterViewInit(): void;
+    private _onFocus;
+    private propagateCode;
+    private focusNextInput;
+    private focusPreviousInput;
+    private setFullInputValue;
+    isInvalid(): boolean;
+    onContainerClick(): void;
+    onKeyDown(event: KeyboardEvent, index: number): void;
+    onInput(event: Event, index: number): void;
+    onPaste(event: ClipboardEvent): void;
+    onBlur(): void;
+    onFocus(event: FocusEvent): void;
+    writeValue(value: string): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyInputCodeComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyInputCodeComponent, "monkey-input-code", never, { "length": { "alias": "length"; "required": false; "isSignal": true; }; "inputType": { "alias": "inputType"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+declare class MonkeyInputDateRangeComponent implements MonkeyFormFieldControl, ControlValueAccessor, AfterContentInit, OnDestroy, OnChanges {
+    formField: MonkeyFormFieldComponent;
+    placeholder: string;
+    title: string;
+    tabIndex: number;
+    minDate: Date | string;
+    maxDate: Date | string;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    _disabled: boolean;
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    set value(value: any);
+    get value(): any;
+    _value: string | null;
+    constructor(formField: MonkeyFormFieldComponent);
+    ngControl: NgControl | null;
+    private readonly idGenerator;
+    readonly id: string;
+    focused: boolean;
+    readonly type: string;
+    readonly stateChanges: Subject<void>;
+    protected _elementRef: ElementRef<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>;
+    _onChange: any;
+    _onTouched: any;
+    showPopOver: boolean;
+    startDate: string;
+    endDate: string;
+    handledMinDate: string;
+    handledMaxDate: string;
+    get elementTarget(): any;
+    closePopOver: () => void;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    onContainerClick(event: MouseEvent): void;
+    _onFocus(): void;
+    _onBlur(): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    private handleValue;
+    private validateValue;
+    writeValue(value: any): void;
+    onOpenPopover(): void;
+    onHandleDate(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyInputDateRangeComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyInputDateRangeComponent, "monkey-input-date-range", never, { "placeholder": { "alias": "placeholder"; "required": true; }; "title": { "alias": "title"; "required": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+interface Country {
+    iso: string;
+    code: string;
+    name: string;
+    flag: string;
+}
+declare class MonkeyInputPhoneComponent implements MonkeyFormFieldControl, ControlValueAccessor, AfterContentInit, OnDestroy, OnChanges {
+    placeholder: string;
+    tabIndex: number;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    _disabled: boolean;
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    set value(value: any);
+    get value(): any;
+    _value: string | null;
+    constructor();
+    ngControl: NgControl | null;
+    private readonly idGenerator;
+    private readonly countryIsoCode;
+    private readonly locale;
+    readonly id: string;
+    readonly inputId: string;
+    focused: boolean;
+    readonly type: string;
+    readonly stateChanges: Subject<void>;
+    countries: Country[];
+    selectedCallingCode: string;
+    phoneFormatted: string;
+    phoneValid: boolean;
+    inputs: QueryList<ElementRef<HTMLInputElement>>;
+    private getCountryNameFromCode;
+    private getCountryByCallingCode;
+    private isoToFlagEmoji;
+    private getCountryFromPhoneNumber;
+    private performValue;
+    private validateValue;
+    private formatValue;
+    disableToBeDirty?: boolean | undefined;
+    _onChange: any;
+    _onTouched: any;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    onContainerClick(event: MouseEvent): void;
+    _onFocus(): void;
+    _onBlur(): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: any): void;
+    onInputChange(event: Event): void;
+    onCountryChange(): void;
+    getMaxLength(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyInputPhoneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyInputPhoneComponent, "monkey-input-phone", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+type MonkeyInputUploadChangeEvent = {
+    component: MonkeyInputUploadComponent;
+    file: File;
+};
+declare class MonkeyInputUploadComponent implements MonkeyFormFieldControl, ControlValueAccessor, AfterContentInit, OnDestroy, OnChanges {
+    fileInput: ElementRef<HTMLInputElement>;
+    progress: number;
+    placeholder: string;
+    maxSizeBytes: number;
+    allowedExtensions: string[];
+    loading: boolean;
+    tabIndex: number;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    _disabled: boolean;
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    set value(value: any);
+    get value(): any;
+    _value: null;
+    constructor();
+    onChange: EventEmitter<MonkeyInputUploadChangeEvent>;
+    ngControl: NgControl | null;
+    private readonly idGenerator;
+    readonly id: string;
+    focused: boolean;
+    readonly type: string;
+    currency: boolean;
+    readonly percent: boolean;
+    readonly stateChanges: Subject<void>;
+    private validateFileSize;
+    private validateFileExtension;
+    onContainerClick(event: MouseEvent): void;
+    _onFocus(): void;
+    _onBlur(): void;
+    disableToBeDirty?: boolean | undefined;
+    _onChange: any;
+    _onTouched: any;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: any): void;
+    reset(): void;
+    onFileSelected(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyInputUploadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyInputUploadComponent, "monkey-input-upload", never, { "progress": { "alias": "progress"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "maxSizeBytes": { "alias": "maxSizeBytes"; "required": false; }; "allowedExtensions": { "alias": "allowedExtensions"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "onChange": "onChange"; }, never, never, true, never>;
+    static ngAcceptInputType_loading: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+}
+
+declare class MonkeyModalActionsDirective {
+    mkAlign: 'start' | 'center' | 'end';
+    id: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyModalActionsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyModalActionsDirective, "monkey-modal-actions, [monkey-modal-actions]", never, { "mkAlign": { "alias": "mkAlign"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class MonkeyModalContentDirective {
+    id: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyModalContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyModalContentDirective, "monkey-modal-content, [monkey-modal-content]", never, {}, {}, never, never, false, never>;
+}
+
+declare class MonkeyModalSubtitleDirective {
+    id: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyModalSubtitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyModalSubtitleDirective, "monkey-modal-subtitle, [monkey-modal-subtitle]", never, {}, {}, never, never, false, never>;
+}
+
+declare class MonkeyModalTitleDirective {
+    id: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyModalTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyModalTitleDirective, "monkey-modal-title, [monkey-modal-title]", never, {}, {}, never, never, false, never>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyModalConfig {
+    id?: string;
+    icon?: string;
+    panelClass?: string | string[];
+    hasBackdrop?: boolean;
+    backdropClass?: string | string[];
+    disableClose?: boolean;
+    disableBackdropClose?: boolean;
+    maxWidth?: number | string;
+    maxHeight?: number | string;
+    fullscreen?: boolean;
+    position?: 'left-top' | 'center-top' | 'right-top' | 'left-center' | 'center-center' | 'right-center' | 'left-bottom' | 'center-bottom' | 'right-bottom';
+    data?: any | null;
+    closeOnNavigation?: boolean;
+    providers?: StaticProvider[];
+}
+interface MonkeyModalDefaultConfig {
+    title: string;
+    subtitle?: string;
+    content: string;
+    cancelLabel: string;
+    okLabel: string;
+}
+interface MonkeyModalConfirmationConfig {
+    title: string;
+    content: string;
+    cancelLabel: string;
+    okLabel: string;
+    type?: 'error' | 'success' | 'warning';
+    confirmColor?: 'error' | 'success' | 'theme';
+    icon?: string;
+}
+
+declare class MonkeyModalRef {
+    readonly overlayRef: OverlayRef;
+    readonly config: MonkeyModalConfig;
+    readonly id?: string;
+    readonly componentInstance: any;
+    readonly componentRef: ComponentRef<any> | null;
+    readonly icon?: string;
+    disableClose: boolean | undefined;
+    disableBackdropClose: boolean | undefined;
+    closeOnNavigation: boolean | undefined;
+    componentElement: HTMLElement;
+    readonly closed: Observable<any>;
+    readonly backdropClick: Observable<MouseEvent>;
+    readonly keydownEvents: Observable<KeyboardEvent>;
+    readonly outsidePointerEvents: Observable<MouseEvent>;
+    constructor(overlayRef: OverlayRef, config: MonkeyModalConfig);
+    close(result?: any): void;
+    afterClosed(): Observable<any>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyModalComponent implements AfterViewInit, OnDestroy {
+    private _elementRef;
+    overlayRef?: OverlayRef | undefined;
+    modalRef?: MonkeyModalRef | undefined;
+    private _navigationSubscription;
+    private _router;
+    constructor(_elementRef: ElementRef, overlayRef?: OverlayRef | undefined, modalRef?: MonkeyModalRef | undefined);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyModalComponent, [null, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyModalComponent, "monkey-modal", never, {}, {}, never, ["monkey-modal-title", "[monkey-modal-title]", "monkey-modal-subtitle", "[monkey-modal-subtitle]", "monkey-modal-content", "[monkey-modal-content]", "monkey-modal-actions", "[monkey-modal-actions]"], false, never>;
+}
+
+declare class MonkeyModalDefaultComponent {
+    config: MonkeyModalDefaultConfig;
+    private modalRef;
+    constructor(config: MonkeyModalDefaultConfig, modalRef: MonkeyModalRef);
+    onSubmit(): void;
+    onClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyModalDefaultComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyModalDefaultComponent, "monkey-modal-default", never, {}, {}, never, never, false, never>;
+}
+
+declare class MonkeyModalConfirmationComponent {
+    config: MonkeyModalConfirmationConfig;
+    private modalRef;
+    constructor(config: MonkeyModalConfirmationConfig, modalRef: MonkeyModalRef);
+    onSubmit(): void;
+    onClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyModalConfirmationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyModalConfirmationComponent, "monkey-modal-confirmation", never, {}, {}, never, never, false, never>;
+}
+
+declare class MonkeyModalModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyModalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MonkeyModalModule, [typeof MonkeyModalComponent, typeof MonkeyModalDefaultComponent, typeof MonkeyModalConfirmationComponent, typeof MonkeyModalTitleDirective, typeof MonkeyModalSubtitleDirective, typeof MonkeyModalContentDirective, typeof MonkeyModalActionsDirective], [typeof i2.CommonModule, typeof MonkeyButtonComponent, typeof MonkeyIconButtonComponent, typeof MonkeyIconComponent], [typeof MonkeyModalComponent, typeof MonkeyModalTitleDirective, typeof MonkeyModalSubtitleDirective, typeof MonkeyModalContentDirective, typeof MonkeyModalActionsDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MonkeyModalModule>;
+}
+
+declare class IdGenerator {
+    getId(prefix: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IdGenerator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IdGenerator>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyModalService {
+    protected _idGenerator: IdGenerator;
+    protected _injector: Injector;
+    protected _overlay: Overlay;
+    protected _openDialogsAtThisLevel: MonkeyModalRef[];
+    protected _parentDialog: MonkeyModalService | null;
+    protected get openDialogs(): readonly MonkeyModalRef[];
+    private getOverlayConfig;
+    private createInjector;
+    open<T>(component: ComponentType<T>, config: MonkeyModalConfig): MonkeyModalRef;
+    openDefault(params: MonkeyModalDefaultConfig, config: MonkeyModalConfig): MonkeyModalRef;
+    openConfirmation(params: MonkeyModalConfirmationConfig, config: MonkeyModalConfig): MonkeyModalRef;
+    closeAll(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyModalService>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare const MECX_MODAL_DATA: InjectionToken<any>;
+declare const MECX_MODAL_DEFAULT_CONFIG: InjectionToken<MonkeyModalDefaultConfig>;
+
+declare class MonkeyOptionComponent {
+    private readonly idGenerator;
+    _content: ElementRef<HTMLElement> | undefined;
+    readonly value: i0.InputSignal<any>;
+    disabled: boolean;
+    type: string;
+    get displayContent(): string;
+    selected: i0.InputSignal<boolean>;
+    tabIndex: number;
+    action: Function;
+    isSelected: i0.Signal<boolean>;
+    readonly id: string;
+    private _selectedState;
+    private handleAction;
+    constructor();
+    onClick(event: MouseEvent): void;
+    handleKeyDown(event: KeyboardEvent): void;
+    onSelect(select: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyOptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyOptionComponent, "monkey-option", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; "type": { "alias": "type"; "required": false; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyRadioButtonComponent implements MonkeyFormFieldControl, ControlValueAccessor, AfterContentInit {
+    private changeDetectorRef;
+    private formField;
+    options: QueryList<MonkeyOptionComponent>;
+    tabIndex: number;
+    onChange: EventEmitter<any>;
+    onSearch: EventEmitter<any>;
+    position: string;
+    size: MonkeySize;
+    get classes(): string;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    set value(value: any);
+    get value(): any;
+    _value: null;
+    private _destroyRef;
+    private readonly idGenerator;
+    ngControl: NgControl | null;
+    protected _elementRef: ElementRef<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>;
+    focused: boolean;
+    _disabled: boolean;
+    readonly id: string;
+    readonly stateChanges: Subject<void>;
+    readonly type: string;
+    constructor(changeDetectorRef: ChangeDetectorRef, formField: MonkeyFormFieldComponent);
+    private changeSelected;
+    private initializeOptions;
+    ngAfterContentInit(): void;
+    selectOption(option: MonkeyOptionComponent): void;
+    writeValue(value: any): void;
+    onContainerClick(event: MouseEvent): void;
+    _onFocus(): void;
+    _onBlur(): void;
+    _onChange: any;
+    _onTouched: any;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyRadioButtonComponent, [null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyRadioButtonComponent, "monkey-radiobutton", never, { "tabIndex": { "alias": "tabIndex"; "required": false; }; "position": { "alias": "position"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "onChange": "onChange"; "onSearch": "onSearch"; }, ["options"], ["*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+}
+
+declare class MonkeySecurityLevelComponent {
+    label: i0.InputSignal<string | undefined>;
+    score: i0.InputSignal<number>;
+    strengthLabel: i0.InputSignal<string | undefined>;
+    get class(): string;
+    protected _uid: string;
+    protected _id: string;
+    get id(): string;
+    set id(value: string);
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeySecurityLevelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeySecurityLevelComponent, "monkey-security-level", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "score": { "alias": "score"; "required": true; "isSignal": true; }; "strengthLabel": { "alias": "strengthLabel"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MonkeySelectComponent implements MonkeyFormFieldControl, ControlValueAccessor, AfterContentInit, OnInit, OnDestroy, OnChanges {
+    private overlay;
+    private changeDetectorRef;
+    private viewContainerRef;
+    private formField;
+    overlayTemplate: TemplateRef<any>;
+    overlayEl: ElementRef;
+    trigger: ElementRef;
+    options: QueryList<MonkeyOptionComponent>;
+    tabIndex: number;
+    onChange: EventEmitter<any>;
+    placeholder: string;
+    loading: boolean;
+    showSearch: boolean;
+    searchPlaceholder: string;
+    type: string;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    set value(value: any);
+    get value(): any;
+    _value: null;
+    labelSelected: string;
+    private overlayRef;
+    private _destroyRef;
+    private readonly idGenerator;
+    ngControl: NgControl | null;
+    protected _elementRef: ElementRef<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>;
+    readonly currency: boolean;
+    focused: boolean;
+    _disabled: boolean;
+    readonly id: string;
+    readonly percent: boolean;
+    readonly stateChanges: Subject<void>;
+    readonly searchHandle: EventEmitter<string>;
+    readonly searchDictionary: rxjs.Observable<any>;
+    readonly loadingDictionary: rxjs.Observable<any>;
+    showSearchNoData: boolean;
+    isOpen: boolean;
+    searchData: string;
+    constructor(overlay: Overlay, changeDetectorRef: ChangeDetectorRef, viewContainerRef: ViewContainerRef, formField: MonkeyFormFieldComponent);
+    private changeControl;
+    private changeSelected;
+    private initializeOptions;
+    private openDropdown;
+    private closeDropdown;
+    private closeOverlay;
+    private initializeWithOverlay;
+    private createOverlay;
+    private updateSelectedLabel;
+    private executeSearch;
+    private repositionScroll;
+    private getComparationValue;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    toggleDropdown(): void;
+    onAnimationEnd: (event: any) => void;
+    selectOption(option: MonkeyOptionComponent): void;
+    writeValue(value: any): void;
+    onContainerClick(event: MouseEvent): void;
+    _onFocus(): void;
+    _onBlur(): void;
+    _onChange: any;
+    _onTouched: any;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    onHandleSearch(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeySelectComponent, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeySelectComponent, "monkey-select", never, { "tabIndex": { "alias": "tabIndex"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": true; }; "loading": { "alias": "loading"; "required": false; }; "showSearch": { "alias": "showSearch"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "type": { "alias": "type"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "onChange": "onChange"; }, ["options"], ["*"], true, never>;
+    static ngAcceptInputType_loading: unknown;
+    static ngAcceptInputType_showSearch: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+}
+
+type Status = 'default' | 'success' | 'warning' | 'error' | 'question' | 'info';
+declare class MonkeyStatusComponent {
+    type: i0.InputSignal<Status>;
+    size: i0.InputSignal<MonkeySize>;
+    label: i0.InputSignal<string | undefined>;
+    get class(): string;
+    protected _uid: string;
+    protected _id: string;
+    get id(): string;
+    set id(value: string);
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyStatusComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyStatusComponent, "monkey-status", never, { "type": { "alias": "type"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MonkeyStepComponent implements AfterContentInit {
+    protected id: string;
+    subSteps: QueryList<MonkeyStepComponent>;
+    label: string;
+    step: string;
+    icon: string;
+    number: i0.WritableSignal<number | undefined>;
+    hasSubSteps: i0.WritableSignal<boolean>;
+    isSubStep: i0.WritableSignal<boolean>;
+    isCurrent: i0.WritableSignal<boolean>;
+    isComplete: i0.WritableSignal<boolean>;
+    isActive: i0.WritableSignal<boolean>;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyStepComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyStepComponent, "monkey-step", never, { "label": { "alias": "label"; "required": false; }; "step": { "alias": "step"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, {}, ["subSteps"], ["*"], false, never>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyStepperComponent implements AfterContentInit, OnChanges {
+    protected monkeyId: string;
+    steps: QueryList<MonkeyStepComponent>;
+    direction: 'horizontal' | 'vertical';
+    private _id;
+    set id(value: string);
+    get id(): string;
+    currentStep?: string | undefined;
+    ngAfterContentInit(): void;
+    ngOnChanges(): void;
+    render(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyStepperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyStepperComponent, "monkey-stepper", never, { "direction": { "alias": "direction"; "required": false; }; "id": { "alias": "id"; "required": false; }; "currentStep": { "alias": "currentStep"; "required": false; }; }, {}, ["steps"], ["*"], false, never>;
+}
+
+declare class MonkeyStepperModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyStepperModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MonkeyStepperModule, [typeof MonkeyStepperComponent, typeof MonkeyStepComponent], [typeof UtilIconComponent, typeof MonkeyIconComponent], [typeof MonkeyStepperComponent, typeof MonkeyStepComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MonkeyStepperModule>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyPaginationActionComponent {
+    disabled: boolean;
+    first: boolean;
+    last: boolean;
+    next: boolean;
+    prev: boolean;
+    onAction: EventEmitter<any>;
+    protected _uid: string;
+    protected _id: string;
+    get id(): string;
+    set id(value: string);
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyPaginationActionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyPaginationActionComponent, "monkey-pagination-action", ["monkeyPaginationAction"], { "disabled": { "alias": "disabled"; "required": false; }; "first": { "alias": "first"; "required": false; }; "last": { "alias": "last"; "required": false; }; "next": { "alias": "next"; "required": true; }; "prev": { "alias": "prev"; "required": true; }; "id": { "alias": "id"; "required": false; }; }, { "onAction": "onAction"; }, never, never, true, never>;
+}
+
+declare class MonkeyPaginationLabelComponent {
+    protected _uid: string;
+    protected _id: string;
+    get id(): string;
+    set id(value: string);
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyPaginationLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyPaginationLabelComponent, "monkey-pagination-label", ["monkeyPaginationLabel"], { "id": { "alias": "id"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyPaginationSizeComponent {
+    size: 10 | 20 | 50 | 100;
+    disabled: boolean;
+    onChange: EventEmitter<any>;
+    protected _uid: string;
+    protected _id: string;
+    sizes: number[];
+    get id(): string;
+    set id(value: string);
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyPaginationSizeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyPaginationSizeComponent, "monkey-pagination-size", ["monkeyPaginationSize"], { "size": { "alias": "size"; "required": true; }; "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "onChange": "onChange"; }, never, ["*"], true, never>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyTableComponent implements AfterContentInit, OnChanges {
+    scroll: MonkeyTableScrollConfig;
+    loading: boolean;
+    loadingRef: TemplateRef<any>;
+    sortChange: EventEmitter<any>;
+    private _headerEl;
+    private _tableHeaderEl;
+    private _tableContentEl;
+    private _tableLoadingEl;
+    private _tableScrollEl;
+    private _paginationActionChildren;
+    private _paginationSizeChildren;
+    private _sortOptions;
+    private _loadingInitialized;
+    stateChanges: EventEmitter<any>;
+    private updateScrollStyle;
+    private initializeComponents;
+    private initializeLoadingComponent;
+    ngAfterContentInit(): void;
+    updateSortableOptions(name: string, sortable: string): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyTableComponent, "monkey-table, table[monkey-table]", ["monkeyTable"], { "scroll": { "alias": "scroll"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "loadingRef": { "alias": "loadingRef"; "required": false; }; }, { "sortChange": "sortChange"; }, ["_paginationActionChildren", "_paginationSizeChildren"], ["thead", "tbody", "monkey-pagination-size", "monkey-pagination-label", "monkey-pagination-action"], false, never>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyColumnChecked implements OnInit, AfterViewInit, OnChanges, OnDestroy {
+    private el;
+    private renderer;
+    private viewContainerRef;
+    table: MonkeyTableComponent;
+    checked: boolean;
+    disabled: boolean;
+    checkedChange: EventEmitter<any>;
+    private _cdr;
+    private _injector;
+    private _subscriptions;
+    checkboxRef: ComponentRef<MonkeyCheckboxComponent>;
+    constructor(el: ElementRef, renderer: Renderer2, viewContainerRef: ViewContainerRef, table: MonkeyTableComponent);
+    private renderCheckbox;
+    private handleDisableFromStateChanges;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    initializeComponent(checked: boolean, disabled: boolean): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyColumnChecked, [null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyColumnChecked, "[mkChecked]", never, { "checked": { "alias": "mkChecked"; "required": true; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "checkedChange": "checkedChange"; }, never, never, false, never>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyColumnExpansible implements OnInit, OnDestroy {
+    private el;
+    private renderer;
+    table: MonkeyTableComponent;
+    expansionChange: EventEmitter<any>;
+    private _opened;
+    private _subscriptions;
+    private _enableAnimation;
+    disabled: boolean;
+    constructor(el: ElementRef, renderer: Renderer2, table: MonkeyTableComponent);
+    private createSvgElement;
+    ngOnInit(): void;
+    onClick(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyColumnExpansible, [null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyColumnExpansible, "[mkExpansible]", never, {}, { "expansionChange": "expansionChange"; }, never, never, false, never>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyColumnSortable implements OnInit, OnDestroy {
+    private el;
+    private renderer;
+    table: MonkeyTableComponent;
+    name: string;
+    private _sortableDirection;
+    private subscriptions;
+    get disabled(): boolean;
+    constructor(el: ElementRef, renderer: Renderer2, table: MonkeyTableComponent);
+    private createSvgElement;
+    ngOnInit(): void;
+    onClick(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyColumnSortable, [null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyColumnSortable, "[mkSortable]", never, { "name": { "alias": "mkSortable"; "required": true; }; }, {}, never, never, false, never>;
+}
+
+declare class MonkeyColumnStick {
+    position: 'left' | 'right';
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyColumnStick, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyColumnStick, "[mkStick]", never, { "position": { "alias": "mkStick"; "required": true; }; }, {}, never, never, false, never>;
+}
+
+declare class MonkeyTableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyTableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MonkeyTableModule, [typeof MonkeyTableComponent, typeof MonkeyColumnStick, typeof MonkeyColumnChecked, typeof MonkeyColumnSortable, typeof MonkeyColumnExpansible], [typeof i2.CommonModule, typeof MonkeyButtonComponent, typeof MonkeyPaginationSizeComponent, typeof MonkeyPaginationLabelComponent, typeof MonkeyPaginationActionComponent], [typeof MonkeyTableComponent, typeof MonkeyColumnStick, typeof MonkeyColumnChecked, typeof MonkeyColumnSortable, typeof MonkeyColumnExpansible]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MonkeyTableModule>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyTabLinkDirective implements OnInit {
+    private router;
+    disabled: boolean;
+    get isDisabled(): boolean;
+    get tabIndex(): 0 | -1;
+    private destroyRef;
+    private el;
+    constructor(router: Router);
+    ngOnInit(): void;
+    private updateActiveState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyTabLinkDirective, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyTabLinkDirective, "[monkey-tab-link]", never, { "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, false, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyTabComponent {
+    value: string;
+    disabled: boolean;
+    onClick: EventEmitter<string>;
+    isSelected: boolean;
+    handleClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyTabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyTabComponent, "monkey-tab", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "isSelected": { "alias": "isSelected"; "required": false; }; }, { "onClick": "onClick"; }, never, ["*"], false, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyTabsComponent implements AfterContentInit, AfterViewInit, OnDestroy, OnChanges {
+    protected monkeyId: string;
+    selected: string;
+    fullWidth: boolean;
+    position: 'start' | 'center' | 'end';
+    onChange: EventEmitter<string>;
+    tabs: QueryList<MonkeyTabComponent>;
+    tabsHeader: ElementRef<HTMLDivElement>;
+    tabsContent: ElementRef<HTMLDivElement>;
+    enabledLeftArrow: boolean;
+    enabledRightArrow: boolean;
+    hasScroll: boolean;
+    scrollPosition: number;
+    private destroyRef;
+    private resizeObserver?;
+    private updateScrollPosition;
+    private updateScrollArrows;
+    private selectTab;
+    private updateTabSelection;
+    ngOnChanges(): void;
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): void;
+    updateTabsEvents(): void;
+    scrollLeft(): void;
+    scrollRight(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyTabsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyTabsComponent, "monkey-tabs", never, { "selected": { "alias": "selected"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "position": { "alias": "position"; "required": false; }; }, { "onChange": "onChange"; }, ["tabs"], ["*"], false, never>;
+    static ngAcceptInputType_fullWidth: unknown;
+}
+
+declare class MonkeyTabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyTabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MonkeyTabsModule, [typeof MonkeyTabsComponent, typeof MonkeyTabComponent, typeof MonkeyTabLinkDirective], never, [typeof MonkeyTabsComponent, typeof MonkeyTabComponent, typeof MonkeyTabLinkDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MonkeyTabsModule>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyToastComponent {
+    private host;
+    message: string | undefined;
+    icon: string | undefined;
+    type: MonkeyToastType;
+    isClosable: boolean;
+    actionLabel: string | undefined;
+    actionIcon: string | undefined;
+    onActionClick: EventEmitter<string>;
+    onClose: EventEmitter<string>;
+    protected _uid: string;
+    protected _id: string;
+    get id(): string;
+    set id(value: string);
+    get class(): string;
+    constructor(host: ElementRef<HTMLElement>);
+    close(): void;
+    onAnimationEnd(event: AnimationEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyToastComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyToastComponent, "monkey-toast", never, { "message": { "alias": "message"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "type": { "alias": "type"; "required": false; }; "isClosable": { "alias": "isClosable"; "required": false; }; "actionLabel": { "alias": "actionLabel"; "required": false; }; "actionIcon": { "alias": "actionIcon"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "onActionClick": "onActionClick"; "onClose": "onClose"; }, never, never, true, never>;
+    static ngAcceptInputType_isClosable: unknown;
+}
+
+declare class MonkeyToggleComponent {
+    disabled: boolean;
+    size: 'lg' | 'md' | 'sm';
+    onChange: EventEmitter<any>;
+    set value(_: boolean | 'true' | 'false');
+    _checked: boolean;
+    protected _uid: string;
+    protected _id: string;
+    get id(): string;
+    set id(value: string);
+    constructor();
+    onClick(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyToggleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyToggleComponent, "monkey-toggle", never, { "disabled": { "alias": "disabled"; "required": false; }; "size": { "alias": "size"; "required": false; }; "value": { "alias": "value"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "onChange": "onChange"; }, never, never, true, never>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyToggleLineButtonComponent {
+    disabled: boolean;
+    onChange: EventEmitter<any>;
+    value: boolean | undefined;
+    checked: boolean | undefined;
+    name: string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyToggleLineButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyToggleLineButtonComponent, "monkey-toggle-line-button", never, { "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, { "onChange": "onChange"; }, never, ["*"], true, never>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyToggleLineComponent implements AfterContentInit, OnDestroy, OnChanges {
+    value: boolean | undefined;
+    name: string;
+    size: 'sm' | 'md' | 'lg';
+    disabled: boolean;
+    onChange: EventEmitter<any>;
+    private subscriptions;
+    radioButtons: QueryList<MonkeyToggleLineButtonComponent>;
+    get class(): string;
+    protected _uid: string;
+    protected _id: string;
+    get id(): string;
+    set id(value: string);
+    constructor();
+    ngAfterContentInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyToggleLineComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyToggleLineComponent, "monkey-toggle-line", never, { "value": { "alias": "value"; "required": false; }; "name": { "alias": "name"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "onChange": "onChange"; }, ["radioButtons"], ["*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+declare class MonkeyTooltipComponent {
+    private host;
+    text: string | undefined;
+    template: null | TemplateRef<HTMLElement>;
+    left: number | undefined;
+    top: number | undefined;
+    afterClose: EventEmitter<any>;
+    protected _uid: string;
+    protected _id: string;
+    get id(): string;
+    set id(value: string);
+    constructor(host: ElementRef<HTMLElement>);
+    close(): void;
+    onAnimationEnd(event: AnimationEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyTooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyTooltipComponent, "monkey-tooltip", never, { "text": { "alias": "text"; "required": false; }; "template": { "alias": "template"; "required": false; }; "left": { "alias": "left"; "required": false; }; "top": { "alias": "top"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "afterClose": "afterClose"; }, never, never, true, never>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+type Position = 'top' | 'bottom' | 'left' | 'right' | undefined;
+declare class MonkeyTooltipDirective {
+    private viewContainerRef;
+    private elementRef;
+    private appRef;
+    private document;
+    tooltipText: string | TemplateRef<HTMLElement> | undefined;
+    tooltipPosition: Position;
+    enabled: boolean;
+    private offset;
+    private tooltipComponent?;
+    private bounds;
+    constructor(viewContainerRef: ViewContainerRef, elementRef: ElementRef, appRef: ApplicationRef, document: Document);
+    private setBounds;
+    private createTooltip;
+    private positionTooltip;
+    private isOutOfBounds;
+    private positionLeft;
+    private positionRight;
+    private positionTop;
+    private positionBottom;
+    show(): void;
+    hide(): void;
+    onScroll(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyTooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyTooltipDirective, "[monkeyTooltip]", never, { "tooltipText": { "alias": "monkeyTooltip"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; "enabled": { "alias": "enabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_enabled: unknown;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyUserProfileButtonComponent {
+    protected _uid: string;
+    elementRef: ElementRef<any>;
+    size: MonkeySize;
+    name: string;
+    iconName: string;
+    protected _id: string;
+    open: boolean;
+    get id(): string;
+    set id(value: string);
+    constructor();
+    onClick(event: MouseEvent): void;
+    handleClose: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyUserProfileButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyUserProfileButtonComponent, "monkey-user-profile-button", never, { "size": { "alias": "size"; "required": false; }; "name": { "alias": "name"; "required": true; }; "iconName": { "alias": "iconName"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare class MonkeyBadgeDirective implements OnChanges {
+    private el;
+    private renderer;
+    badgePosition: 'left' | 'right';
+    badgeSize: 'sm' | 'md' | 'lg';
+    badgeHidden: boolean;
+    monkeyBadge: string;
+    badgeBackground: string | null;
+    badgeColor: string | null;
+    private badgeEl;
+    constructor(el: ElementRef, renderer: Renderer2);
+    ngOnChanges(): void;
+    private updateBadge;
+    private removeBadge;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyBadgeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyBadgeDirective, "[monkeyBadge]", never, { "badgePosition": { "alias": "badgePosition"; "required": false; }; "badgeSize": { "alias": "badgeSize"; "required": false; }; "badgeHidden": { "alias": "badgeHidden"; "required": false; }; "monkeyBadge": { "alias": "monkeyBadge"; "required": false; }; "badgeBackground": { "alias": "badgeBackground"; "required": false; }; "badgeColor": { "alias": "badgeColor"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MonkeyDisplayDirective {
+    private el;
+    private fallbackText;
+    readonly i18nDictionary: rxjs.Observable<any>;
+    displayValue: i0.InputSignal<string>;
+    private displayedText;
+    constructor(el: ElementRef<HTMLElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyDisplayDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyDisplayDirective, "monkey-display", never, { "displayValue": { "alias": "displayValue"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MonkeyErrorDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyErrorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyErrorDirective, "monkey-error", never, {}, {}, never, never, true, never>;
+}
+
+declare class MonkeyHelperDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyHelperDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyHelperDirective, "monkey-helper", never, {}, {}, never, never, true, never>;
+}
+
+declare class MonkeyInfoDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyInfoDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyInfoDirective, "monkey-info", never, {}, {}, never, never, true, never>;
+}
+
+declare class MonkeyLabelDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyLabelDirective, "monkey-label", never, {}, {}, never, never, true, never>;
+}
+
+declare class MonkeyPopoverContentComponent implements AfterViewInit {
+    private host;
+    title?: string | TemplateRef<any>;
+    content: TemplateRef<any>;
+    actions?: string | TemplateRef<any>;
+    onClose: EventEmitter<any>;
+    hideHeader: boolean;
+    hideClose: boolean;
+    hideActions: boolean;
+    enableAutofocus: boolean;
+    constructor(host: ElementRef<HTMLElement>);
+    ngAfterViewInit(): void;
+    isTemplate(value: unknown): value is TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyPopoverContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MonkeyPopoverContentComponent, "monkey-popover-content", never, { "title": { "alias": "title"; "required": false; }; "content": { "alias": "content"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; "hideHeader": { "alias": "hideHeader"; "required": false; }; "hideClose": { "alias": "hideClose"; "required": false; }; "hideActions": { "alias": "hideActions"; "required": false; }; "enableAutofocus": { "alias": "enableAutofocus"; "required": false; }; }, { "onClose": "onClose"; }, never, never, true, never>;
+    static ngAcceptInputType_hideHeader: unknown;
+    static ngAcceptInputType_hideClose: unknown;
+    static ngAcceptInputType_hideActions: unknown;
+}
+declare class MonkeyPopoverDirective implements OnDestroy {
+    private readonly _tpl;
+    private readonly _vcr;
+    private readonly _el;
+    private readonly _zone;
+    private readonly _overlay;
+    private readonly _overlayPositionBuilder;
+    private readonly _router;
+    private readonly _destroyRef;
+    private readonly _options?;
+    private _overlayRef?;
+    private _componentRef?;
+    private _positionStrategy?;
+    private _resizeObserver?;
+    private _show;
+    set popover(show: boolean);
+    get popover(): boolean;
+    closed?: (e?: MouseEvent) => void;
+    private _target?;
+    set target(value: any | undefined);
+    get target(): HTMLElement | undefined;
+    minwidth: boolean;
+    backdrop: boolean;
+    watch: boolean;
+    dir: MonkeyPopoverDir;
+    contextmenu: boolean;
+    height?: number | string;
+    title?: string | TemplateRef<unknown>;
+    actions?: string | TemplateRef<unknown>;
+    hideClose: boolean;
+    hideHeader: boolean;
+    hideActions: boolean;
+    enableAutofocus: boolean;
+    constructor();
+    ngOnDestroy(): void;
+    private closePopover;
+    private disposePopover;
+    private getPositions;
+    private createPopover;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyPopoverDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyPopoverDirective, "[monkeyPopover]", never, { "popover": { "alias": "monkeyPopover"; "required": false; }; "closed": { "alias": "monkeyPopoverClosed"; "required": false; }; "target": { "alias": "monkeyPopoverTarget"; "required": false; }; "minwidth": { "alias": "monkeyPopoverMinwidth"; "required": false; }; "backdrop": { "alias": "monkeyPopoverBackdrop"; "required": false; }; "watch": { "alias": "monkeyPopoverWatch"; "required": false; }; "dir": { "alias": "monkeyPopoverDir"; "required": false; }; "contextmenu": { "alias": "monkeyPopoverContextmenu"; "required": false; }; "height": { "alias": "monkeyPopoverHeight"; "required": false; }; "title": { "alias": "monkeyPopoverTitle"; "required": false; }; "actions": { "alias": "monkeyPopoverActions"; "required": false; }; "hideClose": { "alias": "monkeyPopoverHideClose"; "required": false; }; "hideHeader": { "alias": "monkeyPopoverHideHeader"; "required": false; }; "hideActions": { "alias": "monkeyPopoverHideActions"; "required": false; }; "enableAutofocus": { "alias": "monkeyPopoverEnableAutofocus"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_hideClose: unknown;
+    static ngAcceptInputType_hideHeader: unknown;
+    static ngAcceptInputType_hideActions: unknown;
+    static ngAcceptInputType_enableAutofocus: unknown;
+}
+
+declare class MonkeyPrefixDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyPrefixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyPrefixDirective, "monkey-prefix", never, {}, {}, never, never, true, never>;
+}
+
+declare class MonkeySuffixDirective {
+    set _hasAction(value: '');
+    hasAction: boolean;
+    action: Function | null;
+    onClick(event: PointerEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeySuffixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeySuffixDirective, "monkey-suffix", never, { "_hasAction": { "alias": "hasAction"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MonkeyEcxAddressService {
+    private readonly _http;
+    private readonly _googleApiKey;
+    private mappingData;
+    get(textQuery: string): rxjs.Observable<{
+        formattedAddress: string;
+        adrFormatAddress: string | undefined;
+        address: any;
+        addressNumber: any;
+        neighborhood: any;
+        city: any;
+        state: any;
+        country: any;
+        zipCode: any;
+    }[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxAddressService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyEcxAddressService>;
+}
+
+declare class MonkeyDictionaryService {
+    private _localeId;
+    private _destroyRef;
+    private _data$;
+    constructor();
+    private handleWrapperValues;
+    get(key: string): rxjs.Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyDictionaryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyDictionaryService>;
+}
+
+declare class MonkeyStepperService {
+    private _steppers;
+    currentStep(id: string): i0.Signal<string | undefined>;
+    setCurrentStep(id: string, step: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyStepperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyStepperService>;
+}
+
+declare class MonkeyToastService {
+    private lastToast?;
+    private overlay;
+    private getPositionStrategy;
+    show(toastConfig: ToastConfig): MonkeyToastComponent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyToastService>;
+}
+
+/** ************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ ************************* */
+
+declare const MECX_I18N_WRAPPER: InjectionToken<BehaviorSubject<string>>;
+declare const MECX_POPOVER_OPTIONS: InjectionToken<unknown>;
+declare const MECX_COUNTRY_ISO_CODE: InjectionToken<string>;
+declare const MECX_GOOGLE_API_KEY: InjectionToken<string>;
+declare function injectTokenWithWarning<T>(token: InjectionToken<T>, name?: string): T | null;
+
+export { MECX_COUNTRY_ISO_CODE, MECX_GOOGLE_API_KEY, MECX_I18N_WRAPPER, MECX_MODAL_DATA, MECX_MODAL_DEFAULT_CONFIG, MECX_POPOVER_OPTIONS, MonkeyAccordionComponent, MonkeyActionBarComponent, MonkeyAlertComponent, MonkeyAutocompleteAddressComponent, MonkeyAutocompleteComponent, MonkeyAvatarComponent, MonkeyBadgeComponent, MonkeyBadgeDirective, MonkeyBreadcrumbComponent, MonkeyButtonComponent, MonkeyCheckboxComponent, MonkeyColumnChecked, MonkeyColumnExpansible, MonkeyColumnSortable, MonkeyColumnStick, MonkeyDateRangeComponent, MonkeyDictionaryService, MonkeyDisplayDirective, MonkeyDividerComponent, MonkeyDownloadButtonComponent, MonkeyEcxAddressService, MonkeyErrorDirective, MonkeyFilterBarComponent, MonkeyFormFieldComponent, MonkeyFormFieldControl, MonkeyFormFieldModule, MonkeyHelperDirective, MonkeyIconButtonComponent, MonkeyIconComponent, MonkeyInfoDirective, MonkeyInputCodeComponent, MonkeyInputCurrencyDirective, MonkeyInputDateRangeComponent, MonkeyInputDirective, MonkeyInputModule, MonkeyInputPhoneComponent, MonkeyInputUploadComponent, MonkeyLabelDirective, MonkeyModalActionsDirective, MonkeyModalComponent, MonkeyModalConfig, MonkeyModalContentDirective, MonkeyModalModule, MonkeyModalRef, MonkeyModalService, MonkeyModalSubtitleDirective, MonkeyModalTitleDirective, MonkeyOptionComponent, MonkeyPaginationActionComponent, MonkeyPaginationLabelComponent, MonkeyPaginationSizeComponent, MonkeyPopoverContentComponent, MonkeyPopoverDirective, MonkeyPrefixDirective, MonkeyRadioButtonComponent, MonkeySecurityLevelComponent, MonkeySelectComponent, MonkeyStatusComponent, MonkeyStepComponent, MonkeyStepperComponent, MonkeyStepperModule, MonkeyStepperService, MonkeySuffixDirective, MonkeyTabComponent, MonkeyTabLinkDirective, MonkeyTableComponent, MonkeyTableModule, MonkeyTabsComponent, MonkeyTabsModule, MonkeyToastComponent, MonkeyToastRef, MonkeyToastService, MonkeyToggleComponent, MonkeyToggleLineButtonComponent, MonkeyToggleLineComponent, MonkeyTooltipComponent, MonkeyTooltipDirective, MonkeyUserProfileButtonComponent, getCurrencySymbol, injectTokenWithWarning };
+export type { GoogleApiPlaces, GoogleApiPlacesAddressComponents, GoogleApiPlacesResponse, MonkeyAlertType, MonkeyAutocompleteData, MonkeyAutocompleteResponse, MonkeyBreadcrumb, MonkeyButtonColor, MonkeyButtonType, MonkeyDownloadButtonChangeEvent, MonkeyInputUploadChangeEvent, MonkeyModalConfirmationConfig, MonkeyModalDefaultConfig, MonkeyPopoverDir, MonkeyPopoverOptions, MonkeySize, MonkeyTableScrollConfig, MonkeyToastPosition, MonkeyToastType, ToastConfig };