import * as i0 from '@angular/core';
import { OnInit, OnDestroy, TemplateRef, ViewContainerRef, OnChanges, SimpleChanges, InjectionToken, ModuleWithProviders, PipeTransform } from '@angular/core';
import { NgModel, AbstractControl, ValidationErrors, FormGroup } from '@angular/forms';
import { CanActivate, Router, ActivatedRouteSnapshot, RouterStateSnapshot, Resolve } from '@angular/router';
import * as _ngrx_store from '@ngrx/store';
import { Action, Store, ActionReducer } from '@ngrx/store';
import { Observable, Subject, BehaviorSubject } from 'rxjs';
import { HttpErrorResponse, HttpRequest, HttpHandler, HttpEvent, HttpContextToken, HttpInterceptorFn, HttpHeaders, HttpContext, HttpParams, HttpResponse } from '@angular/common/http';
import * as i1 from '@angular/common';
import { CurrencyPipe, DatePipe } from '@angular/common';
import { SafeUrl } from '@angular/platform-browser';
import { CookieService } from 'ngx-cookie-service';

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */
interface MonkeyEcxServiceHttpResponseCredentials {
    httpCodeIgnore?: number[];
    httpCodeIgnoreRedirect?: number[];
}
interface MonkeyEcxServiceCredentials {
    id: string;
    httpResponse?: MonkeyEcxServiceHttpResponseCredentials;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare function MonkeyEcxCoreService(params: MonkeyEcxServiceCredentials): (target: Object, propertyName: string, propertyDescriptor: PropertyDescriptor) => PropertyDescriptor;

interface ErrorMessageContext {
    $implicit: string | null;
    errorMessage: string | null;
    errorParams: {
        [key: string]: string | number;
    } | null;
}
declare class MonkeyEcxErrorMessageDirective implements OnInit, OnDestroy {
    private tpl;
    private vcr;
    private _destroyRef;
    private control;
    private sub?;
    private context;
    private updateViewEvent;
    set errorMessage(control: NgModel | AbstractControl | null);
    constructor(tpl: TemplateRef<ErrorMessageContext>, vcr: ViewContainerRef);
    ngOnInit(): void;
    private subscribe;
    private updateView;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxErrorMessageDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyEcxErrorMessageDirective, "[monkeyecxErrorMessage]", never, { "errorMessage": { "alias": "monkeyecxErrorMessage"; "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 MonkeyEcxFeatureByProgramDirective implements OnInit {
    feature: string;
    private readonly _configsService;
    private readonly _elementRef;
    private readonly _changeDetectorRef;
    private init;
    private handleDisplay;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxFeatureByProgramDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyEcxFeatureByProgramDirective, "[monkeyecxFeatureByProgram]", never, { "feature": { "alias": "feature"; "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 MonkeyEcxFeatureDirective implements OnInit {
    feature?: string;
    private readonly _service;
    private readonly _elementRef;
    private readonly _changeDetectorRef;
    private readonly _destroyRef;
    private getFeature;
    private handleDisplay;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxFeatureDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyEcxFeatureDirective, "[monkeyecxFeature]", never, { "feature": { "alias": "featureName"; "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 MonkeyEcxLoadingDirective implements OnChanges {
    private templateRef;
    private viewContainer;
    private _view;
    private _loadingElement;
    private readonly elementRef;
    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
    monkeyecxLoading: boolean;
    monkeyecxLoadingSize: 'lg' | 'md' | 'sm';
    ngOnChanges(changes: SimpleChanges): void;
    updateView(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxLoadingDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyEcxLoadingDirective, "[monkeyecxLoading]", never, { "monkeyecxLoading": { "alias": "monkeyecxLoading"; "required": false; }; "monkeyecxLoadingSize": { "alias": "monkeyecxLoadingSize"; "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 MonkeyEcxSecurityDirective implements OnInit {
    roles: string[];
    byExclusion: boolean;
    private _tokenCredentials;
    private readonly _tokenStorageService;
    private readonly elementRef;
    private readonly changeDetectorRef;
    constructor();
    private getRole;
    private handleAccess;
    private handleData;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxSecurityDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MonkeyEcxSecurityDirective, "[monkeyecxSecurity]", never, { "roles": { "alias": "securityRoles"; "required": false; }; "byExclusion": { "alias": "securityByExclusion"; "required": false; }; }, {}, never, never, true, never>;
}

declare const CACHE_LOCALE_EXPIRATION_MS: number;

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */
declare enum CountryMasks {
    CPF = "000.000.000-00",
    CNPJ = "00.000.000/0000-00",
    RUT1 = "0000000-A",
    RUT2 = "00000000-A",
    RFC1 = "AAAA000000AA0",
    RFC2 = "AAA000000AA0",
    EIN = "00-0000000"
}

declare function emailValidator(control: AbstractControl): ValidationErrors | null;
declare function dateRangeValidator(control: AbstractControl): ValidationErrors | null;
declare function registerValidator(control: AbstractControl, type: string): ValidationErrors | null;
declare function dateStartEndValidator(control: AbstractControl): ValidationErrors | null;
declare function urlValidator(control: AbstractControl): ValidationErrors | null;
declare function passwordConfirmValidator(control: AbstractControl): ValidationErrors | null;
declare function trueValidator(control: AbstractControl): ValidationErrors | null;
declare function comboValidator(control: AbstractControl): ValidationErrors | null;
declare function zipCodeValidator(control: AbstractControl, country?: string): ValidationErrors | null;
declare function documentValidator(control: AbstractControl, country: string): ValidationErrors | null;
declare function minYearsValidator(param: number, control: AbstractControl): ValidationErrors | null;
declare function dateValidator(control: AbstractControl): ValidationErrors | null;
declare function valueGreaterThanZero(control: AbstractControl): ValidationErrors | null;
declare function requiredWithTrimValidator(control: AbstractControl): ValidationErrors | null;
declare function differentFromZero(control: AbstractControl): ValidationErrors | null;
declare function documentValidatorByType(type: string, control: AbstractControl): ValidationErrors | null;
declare function validateFullName(control: AbstractControl): ValidationErrors | null;
declare function containsNumber(control: AbstractControl): ValidationErrors | null;
declare class MonkeyValidators {
    static email(control: AbstractControl): ValidationErrors | null;
    static dateRange(control: AbstractControl): ValidationErrors | null;
    static unlockSponsorRegister(control: AbstractControl): ValidationErrors | null;
    static unlockBuyerRegister(control: AbstractControl): ValidationErrors | null;
    static dateStartEnd(control: AbstractControl): ValidationErrors | null;
    static url(control: AbstractControl): ValidationErrors | null;
    static passwordConfirm(control: AbstractControl): ValidationErrors | null;
    static true(control: AbstractControl): ValidationErrors | null;
    static combo(control: AbstractControl): ValidationErrors | null;
    static zipCode(control: AbstractControl): ValidationErrors | null;
    static zipCodeByCountry(country: string): (control: AbstractControl) => ValidationErrors | null;
    static documentBR(control: AbstractControl): ValidationErrors | null;
    static documentCL(control: AbstractControl): ValidationErrors | null;
    static documentMX(control: AbstractControl): ValidationErrors | null;
    static documentUS(control: AbstractControl): ValidationErrors | null;
    static date(control: AbstractControl): ValidationErrors | null;
    static minYears(param: number): ValidationErrors | null;
    static greaterThanZero(control: AbstractControl): ValidationErrors | null;
    static required(control: AbstractControl): ValidationErrors | null;
    static differentFromZero(control: AbstractControl): ValidationErrors | null;
    static documentValidatorByType(type: string): (control: AbstractControl) => ValidationErrors | null;
    static validateFullName(control: AbstractControl): ValidationErrors | null;
    static containsNumber(control: AbstractControl): ValidationErrors | null;
}

declare class MonkeyEcxAuthGuardCompany implements CanActivate {
    private readonly _authService;
    canActivate(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxAuthGuardCompany, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyEcxAuthGuardCompany>;
}

declare class MonkeyEcxAuthGuardLogin implements CanActivate {
    private readonly _authService;
    canActivate(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxAuthGuardLogin, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyEcxAuthGuardLogin>;
}

declare class MonkeyEcxCookieStorageService {
    private cookieService;
    private readonly _bootstrapService;
    constructor(cookieService: CookieService);
    setCookie(name: string, value: any): void;
    getCookie(name: string): string;
    removeCookie(name: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxCookieStorageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyEcxCookieStorageService>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */
declare class Link {
    href: string;
    type: string;
    profile: string;
    templated: boolean;
    constructor(data?: any);
}
declare class MonkeyEcxModel {
    _links: any;
    getAction(type: string, replaceOptions?: {
        from: string;
        to: string;
    }): Link | null;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare class MonkeyEcxLinksModel extends MonkeyEcxModel {
    constructor(data?: any);
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

type MonkeyEcxPaginationActions = 'first' | 'next' | 'prev' | 'last';
interface MonkeyEcxPagination {
    action: MonkeyEcxPaginationActions;
}
interface MonkeyEcxTypedLink extends Link {
    url: string;
}
interface MonkeyEcxPaginationData {
    [key: string]: MonkeyEcxTypedLink;
}
interface MonkeyEcxPaginationSortField {
    type?: string;
    format?: string;
    direction: 'desc' | 'asc';
}
interface MonkeyEcxPaginationSortData {
    [key: string]: MonkeyEcxPaginationSortField;
}
interface MonkeyEcxPage {
    size: number;
    totalElements: number;
    totalPages: number;
    number: number;
}

interface MonkeyEcxAPIResponse {
    page: {
        size: number;
        totalElements: number;
        totalPages: number;
        number: number;
    };
    _embedded: any[];
    _links: MonkeyEcxPaginationData;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */
interface MonkeyEcxGroupCompany {
    governmentId: string;
    id: string;
    role: string;
    status: string;
}
interface MonkeyEcxGroup {
    companies: MonkeyEcxGroupCompany[];
    groupId: string;
    name: string;
    role: string;
    style: 'mandril' | 'koba' | 'colobus' | 'prego' | 'saki' | 'mico-leao' | 'gibbon' | 'babuino';
}
interface MonkeyEcxMeCredentials {
    name: string;
    email: string;
    username: string;
    status: string;
    pictureURL: string;
    selectedLanguage: string;
    companies: {
        id: string;
        companyId: string;
        governmentId: string;
        program: string;
        programAdmin: boolean;
        role: string;
        type: string;
        selected: boolean;
    }[];
    programs: {
        name: string;
        ownerGovernmentId: string;
        ownerName: string;
        product: string;
        token: string;
        ownerId: string;
        type: string;
        url: string;
    }[];
    groups: MonkeyEcxGroup[];
    nickname: string;
    cellPhone: string;
    smsNotification: boolean;
    privacyPolicy: boolean;
    useTerms: boolean;
    locale: string;
    newsletter: boolean;
    others: string;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */
interface MonkeyEcxTokenCredentialsClearIgnore {
    ignore: string[];
}
type MonkeyEcxAccessHandleAccessTypes = 'BY_GROUP' | 'REFRESH_TOKEN' | 'BY_REGISTER' | 'BY_COMPANY_SETTINGS';
interface MonkeyEcxAccessHandleTokenCredentials {
    access: MonkeyEcxAccessHandleAccessTypes;
    governmentId: string;
    groupId: string;
    groupName: string;
    type: string;
    programUrl: string;
}
interface MonkeyEcxTokenCredentials {
    username: string;
    program?: string;
    accessToken?: string;
    refreshToken?: string;
    companyId?: string;
    governmentId?: string;
    companyTypeUrl?: string;
    companyType?: string;
    role?: string;
    programAdmin?: boolean | string;
    programType?: string;
    accessType?: string;
    ownerGovernmentId?: string;
    name?: string;
    status?: string;
    accessHandle?: MonkeyEcxAccessHandleTokenCredentials;
    _clearIgnore?: MonkeyEcxTokenCredentialsClearIgnore;
}

interface MonkeyEcxAuthCredentials {
    client_id?: string;
    client_secret?: string;
    grant_type?: string;
    scope?: string;
    username?: string;
    password?: string;
    access_token?: string;
    token_type?: string;
    refresh_token?: string;
    expires_in?: number;
    program?: string;
    userType?: string;
    totp_code?: string;
}
interface MonkeyEcxAuthReAuthenticateData {
    accessHandle: MonkeyEcxAccessHandleTokenCredentials;
}
type MonkeyEcxRefreshTokenStrategy = () => Observable<any>;
type MonkeyEcxRedirectLoginWelcomeBackStrategy = () => void;
interface MonkeyEcxAuthenticationService {
    handleErrorFromLogin(err: HttpErrorResponse, param: MonkeyEcxAuthCredentials): void;
    deleteToken(): void;
    saveTokenCredentials(authCredentials: MonkeyEcxAuthCredentials): void;
    getClientIdSecretByAccess(): void;
    setToken(token: Partial<MonkeyEcxTokenCredentials>): void;
    setMe(me: Partial<MonkeyEcxMeCredentials>): void;
    isAuthorized(): void;
    isCompanyAuthorized(): void;
    hadAtLeastOneLogin(): void;
    logOut(force?: boolean, redirect?: boolean, callback?: Function, doDelete?: boolean): void;
    redirectLoginWelcomeBack: MonkeyEcxRedirectLoginWelcomeBackStrategy;
    redirectApp(): void;
    handleFlowAfterLogin(): void;
    reAuthenticate(authData: MonkeyEcxAuthReAuthenticateData): void;
    login(param: MonkeyEcxAuthCredentials): void;
    refreshToken: MonkeyEcxRefreshTokenStrategy;
    me(authCredentials: MonkeyEcxAuthCredentials): void;
    saveMeCredentials(meCredentials: MonkeyEcxMeCredentials): void;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */
interface MonkeyEcxCompany {
    id: string;
    companyId: string;
    governmentId: string;
    program: string;
    programAdmin: boolean;
    role: string;
    type: string;
    selected?: boolean;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */
interface MonkeyEcxEnv {
    baseUrl: string;
    bootstrapAssets: string;
    snENDUPLuHlBxIJD7h: string;
    zi7TpJCi6JD1Kqzb4S: string;
    DBMpPL0iJZSWKZIzky: string;
    GCJfuDpr4j1xVMQtt4: string;
    iYLTsmFPXYjRhCLtnoRe: string;
    qvz2w3GII6uWTdRHV4m3: string;
    a7T3bM9qL1xZ8d: string;
    country: string;
    lang: string;
    countryTzName: string;
    dataDogApplicationId: string;
    dataDogClientToken: string;
    dataDogBrowserLogsEnable: boolean;
    environment: string;
    grant_type: string;
    launchDarklyClientSideID: string;
    localAssets: string;
    product: string;
    production: boolean;
    scope: string;
    urlAddressSearch: string;
    urlAssets: string;
    urli18nAssets: string;
    urlDomain: string;
    urlZipCodeSearch: string;
    zenDeskKey: string;
    zenDeskUrlDoc: string;
    apps?: {
        login?: string;
        soo?: string;
        caco?: string;
        monkey?: string;
    };
    paths: {
        redirectAfterLogin: string;
        redirectAfterLoginProduct: string;
        redirectApp: string;
        redirectByCompanyType: Function;
    };
    termsUrl?: {
        privacyPolicy: string;
        useTerms: string;
        mfa: string;
    };
    genericAlerts?: {
        [key: string]: {
            pathToShow: string;
            pathToEvict: string;
            name: string;
            img: string;
            startDate: string;
            endDate: string;
            noEndDate: boolean;
            cookieName: string;
        };
    };
    locale?: {
        timezoneOffset: string;
        defaultCurrency: string;
        lang: string;
        dateFormat: string;
        dateFormatSec: string;
    };
    gtm?: {
        enabled: boolean;
        key: string;
    };
    sdk?: {
        faceid: string;
    };
    braze: {
        api_key: string;
        sdk_endpoint: string;
        enableLogging: boolean;
    };
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */
interface MonkeyEcxCachedFile {
    filename: string;
    blob: Blob;
    timestamp: number;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */
interface MonkeyEcxHeaderCredentials {
    Authorization?: string;
    Program?: string;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

interface MonkeyEcxBootstrap {
    version: string;
    showNewVersion: boolean;
    pingThresholdMs: number;
    maintenance: {
        closed: boolean;
        startDate: string;
        endDate: string;
    };
    languagesAvailables: {
        lang: string;
        currency: string;
        title: string;
    }[];
    federationSettings: {
        [key: string]: {
            host: string;
            parentPath: string;
            [key: string]: string;
        };
    };
}
interface MonkeyEcxAlert {
    img: string;
    title: string;
    message: string;
    endDate: string;
    noEndDate?: boolean;
    hideClose?: boolean;
    action?: {
        href: string;
        label: string;
    };
}
interface MonkeyEcxWhiteLabel {
    program: {
        token: string;
        name: string;
        type: string;
        register: {
            seller: {
                types: string[];
                documentTypes: string[];
                legalNatures: string[];
            };
            sponsor: {
                types: string[];
            };
            buyer: {
                calculationTypes: string[];
                legalNatures: string[];
                types: string[];
            };
        };
        settings: {
            editSponsorTax: boolean;
            disableBuyerInformation: boolean;
            [key: string]: boolean;
        };
        screens: {
            login: {
                passwordStrength: {
                    WHITE_SPACE?: string;
                    DIGIT_CHARACTER?: string;
                    UPPERCASE_CHARACTER?: string;
                    LOWERCASE_CHARACTER?: string;
                    ALPHA_SEQUENCE?: string;
                    NUMBER_SEQUENCE?: string;
                    QWERTY_SEQUENCE?: string;
                    REPEAT_CHARS?: string;
                };
            };
        };
    };
    market?: {
        daysToSearch: number;
        operation: {
            currentDaysToSearch: number;
            maximumDaysToSearch: number;
        };
        hourToClose?: number;
    };
    theme?: {
        logos: {
            favicon: string;
            toolbar: string;
            login: string;
            footer: string;
        };
    };
    support?: {
        phones?: {
            attendant?: string;
            endHour: number;
            icon: string;
            numbers?: string[];
            startHour: number;
        }[];
        emails?: {
            attendant?: string;
            icon: string;
            recipients?: string[];
        }[];
        information?: {
            icon: string;
            message?: string;
            action?: string;
        };
    };
    i18n?: {
        lang?: string;
        currency?: string;
        currencies?: string[];
        'google-chart-language'?: string;
        paths: string[];
    };
    logs?: {
        enabled: boolean;
    };
    externali18n?: {
        [s: string]: any;
    };
    messages?: {
        checkoutSuccess: string[];
    };
    externalSettings?: {
        dev: {
            url: string;
            urlName: string;
        };
        hmg: {
            url: string;
            urlName: string;
        };
        prod: {
            url: string;
            urlName: string;
        };
    };
    gtm?: {
        enabled: boolean;
        key: string;
    };
    alert?: MonkeyEcxAlert;
    sso?: {
        provider: string;
        name: string;
        redirectUserSettings: string;
        options: {
            icon: string;
            label: string;
            type: string;
            title: string;
            hideRegister: boolean;
            hideCantAccess: boolean;
        }[];
    };
}
interface MonkeyEcxStyleColor {
    main: string;
    0: string;
    50: string;
    100: string;
    200: string;
    300: string;
    400: string;
    500: string;
    600: string;
    700: string;
    800: string;
    900: string;
    A100: string;
    A200: string;
    A400: string;
    A700: string;
    contrast: {
        main: string;
        50: string;
        100: string;
        200: string;
        300: string;
        400: string;
        500: string;
        600: string;
        700: string;
        800: string;
        900: string;
        A100: string;
        A200: string;
        A400: string;
        A700: string;
    };
}
interface MonkeyEcxStyleGuideFont {
    url: string;
    name: string;
}
interface MonkeyEcxStyleGuide {
    theme?: {
        title?: string;
        favicon?: string;
    };
    colors?: {
        theme: MonkeyEcxStyleColor;
        error: MonkeyEcxStyleColor;
        warning: MonkeyEcxStyleColor;
        success: MonkeyEcxStyleColor;
    };
    font?: MonkeyEcxStyleGuideFont;
    currency?: {
        code: string;
        name: string;
        locale: string;
    };
}
interface MonkeyEcxBootstrapService {
    handleMessage(message: string, type: string): void;
    handleI18N(lang: string, obj: any): void;
    finishLoading(): void;
    getEnv(): MonkeyEcxEnv;
    getDefaultProgram(): string;
    /**
     * This is a token to send every request that we want some mandatory headers
     * Like if we want to use Authorization and Program to every requests.
     * This token must have the following content:
     *
     * ### Example
     * ```
     * 'viacep.com.br/#assets.monkeyecx.com/#assets.monkey.exchange/'
     * ```
     *
     */
    getNotMandatoryUrls(): string;
    handleProgram?(token: string): string;
}

interface MonkeyEcxInterface {
    createdAt?: string;
    createUserId?: string;
    createUserIp?: string;
    updatedAt?: string;
    lastUserId?: string;
    lastUserIp?: string;
    _links?: any;
    id?: string;
    identifier?: string;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */
interface MonkeyEcxProgram {
    name: string;
    ownerGovernmentId: string;
    ownerName: string;
    product: string;
    token: string;
    ownerId: string;
    type: string;
    url: string;
}

interface MonkeyEcxPendingRequest {
    request: HttpRequest<any>;
    next: HttpHandler;
    observer: Subject<HttpEvent<any>>;
}

interface MonkeyEcxBaseResolverParams {
    pathParams: any;
    queryParams: any;
    stateData: any;
}
interface MonkeyEcxBaseResolverData {
    [field: string]: any;
}

interface MonkeyEcxServiceControl {
    isLoading: boolean;
    isExporting: boolean;
    isDeleting: boolean;
    isDownloading: boolean;
    isSubmitting: boolean;
    [key: string]: boolean;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

interface MonkeyEcxStorage {
    username: string;
    program: string;
    accessToken: string;
    refreshToken: string;
    companyId: string;
    governmentId: string;
    companyTypeUrl: string;
    companyType: string;
    role: string;
    programAdmin: boolean | string;
    programType: string;
    accessType: string;
    ownerGovernmentId: string;
    name: string;
    status: string;
    accessHandle: MonkeyEcxAccessHandleTokenCredentials;
    me: Partial<MonkeyEcxMeCredentials>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

interface MonkeyEcxConfigStore {
    actions?: {};
    selectors?: {};
}
interface MonkeyEcxCollectionStore extends MonkeyEcxConfigStore {
    actions: {
        updateControl: Action;
        updateLinks: Action;
        updatePage: Action;
        updateAll: Action;
        clear: Action;
    };
    selectors: {
        linksHasDifference?: Function;
        selectLinks: Function;
    };
}
interface MonkeyEcxEntityStore extends MonkeyEcxConfigStore {
    actions: {
        updateControl: Action;
        updateOne: Action;
    };
}
interface MonkeyEcxControlStore {
    [key: string]: any;
}
interface MonkeyEcxLinks {
    [key: string]: Link | string | undefined;
    url?: string;
}
interface MonkeyEcxStoreControl {
    isLoading: boolean;
}
interface MonkeyEcxStoreLoadParams {
    force?: boolean;
    url: string;
}
interface MonkeyEcxStoreStartParams {
    force?: boolean;
    url?: string;
    [key: string]: string | number | boolean | undefined;
}
interface MonkeyEcxStoreLoadPageParams {
    pagination: MonkeyEcxPagination;
}

declare type Token = Partial<MonkeyEcxTokenCredentials> | null;
declare type Me = Partial<MonkeyEcxMeCredentials> | null;
declare class MonkeyEcxTokenStorageService {
    private store;
    private tokenFields;
    private token$;
    private me$;
    private readonly _configService;
    constructor(store: Store);
    private setAllTokens;
    private getAllTokens;
    private setAllMe;
    private getAllMe;
    tokenHasChanged(): Observable<Token>;
    meHasChanged(): Observable<Me>;
    getToken(): MonkeyEcxTokenCredentials | null;
    getMe(): any;
    setToken(token: Token): void;
    setMe(me: Partial<MonkeyEcxMeCredentials>): void;
    clear(force?: boolean): Observable<boolean>;
    /**
     * @param fields (the name of fields you want to clear. ie: ['companyId', 'role', ...])
     */
    clearCredentials(fields?: string[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxTokenStorageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyEcxTokenStorageService>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

type index_d$4_MonkeyEcxCookieStorageService = MonkeyEcxCookieStorageService;
declare const index_d$4_MonkeyEcxCookieStorageService: typeof MonkeyEcxCookieStorageService;
type index_d$4_MonkeyEcxTokenStorageService = MonkeyEcxTokenStorageService;
declare const index_d$4_MonkeyEcxTokenStorageService: typeof MonkeyEcxTokenStorageService;
declare namespace index_d$4 {
  export {
    index_d$4_MonkeyEcxCookieStorageService as MonkeyEcxCookieStorageService,
    index_d$4_MonkeyEcxTokenStorageService as MonkeyEcxTokenStorageService,
  };
}

declare class MonkeyEcxAuthGuardByRole implements CanActivate {
    private tokenStorage;
    private router;
    private securityCredentials;
    private tokenCredentials;
    constructor(tokenStorage: MonkeyEcxTokenStorageService, router: Router);
    private navigateToErrorPage;
    private getRole;
    private allowedSecurityAccess;
    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxAuthGuardByRole, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyEcxAuthGuardByRole>;
}

declare class MonkeyEcxAuthGuard implements CanActivate {
    private readonly _authService;
    canActivate(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxAuthGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyEcxAuthGuard>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare function injectTokenWithWarning<T>(token: InjectionToken<T>, name?: string): T | null;
declare const MECX_TIMEZONEOFFSET: InjectionToken<string>;
declare const MECX_DATE_FORMAT: InjectionToken<string>;
declare const MECX_COUNTRY: InjectionToken<string>;
declare const MECX_ALPHA: InjectionToken<string>;
declare const MECX_BETA: InjectionToken<string>;
/**
 * This is a token to be used to every request context. Just for internal of core use.
 */
declare const MECX_REQUEST_ID: HttpContextToken<string>;
/**
 * This is a token to be used with a service created in the project who uses
 * this library. We always be use this service to callback the messages from intercetors or related
 *
 * ### Example
 * ```
 *  {
 *    provide: MECX_SERVICE_MESSAGE,
 *    useClass: AppServiceErrorMessage
 *  },
 * ```
 * ### Service
 * ```
 *  @Injectable()
 *  export class AppServiceErrorMessage implements MonkeyEcxServiceMessage {
 *    handleMessage(message: string, type: string): void {
 *      throw new Error('Method not implemented.');
 *    }
 *  }
 * ```
 */
declare const MECX_BOOTSTRAP_SERVICE: InjectionToken<MonkeyEcxBootstrapService>;
declare const MECX_CORE_I18N_WRAPPER: InjectionToken<BehaviorSubject<string>>;
/**
 * ```
 * providers: [
 *  {
 *    provide: MONKEY_REFRESH_TOKEN,
 *    useValue: () => {
 *      // Custom refresh logic here
 *      return http.post('/auth/refresh');
 *    }
 *  }
 *]
 * ```
 */
declare const MECX_REFRESH_TOKEN_STRATEGY: InjectionToken<MonkeyEcxRefreshTokenStrategy>;
declare const MECX_REDIRECT_LOGIN_WELCOMEBACK_STRATEGY: InjectionToken<MonkeyEcxRedirectLoginWelcomeBackStrategy>;
declare const MECX_I18N_PATH: InjectionToken<string>;
declare const MECX_I18N_ALIAS: InjectionToken<string>;

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare const monkeyEcxHttpConfigInterceptor: HttpInterceptorFn;

declare class MonkeyEcxCoreModule {
    static forRoot(): ModuleWithProviders<MonkeyEcxCoreModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxCoreModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<MonkeyEcxCoreModule, never, [typeof i1.CommonModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<MonkeyEcxCoreModule>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare class MonkeyEcxBlobSecurePipe implements PipeTransform {
    private readonly _service;
    private readonly _sanitizer;
    constructor();
    transform(url: string): Observable<SafeUrl>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxBlobSecurePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MonkeyEcxBlobSecurePipe, "monkeyecxBlobSecure", false>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare class MonkeyEcxCurrencyCodePipe implements PipeTransform {
    private readonly _defaultCurencyCode;
    transform(value: any, type?: 'symbol' | 'code'): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxCurrencyCodePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MonkeyEcxCurrencyCodePipe, "monkeyecxCurrencyCode", false>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare class MonkeyEcxDisplayFirstNamePipe implements PipeTransform {
    transform(name: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxDisplayFirstNamePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MonkeyEcxDisplayFirstNamePipe, "monkeyecxDisplayFirstName", false>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare class MonkeyEcxDisplayInitialsPipe implements PipeTransform {
    transform(name: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxDisplayInitialsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MonkeyEcxDisplayInitialsPipe, "monkeyecxDisplayInitials", false>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare class MonkeyEcxFormatAddressPipe implements PipeTransform {
    transform({ zipCode, address, neighborhood, city, state }: {
        zipCode: string;
        address: string;
        neighborhood: string;
        city: string;
        state: string;
        country: string;
    }): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxFormatAddressPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MonkeyEcxFormatAddressPipe, "monkeyecxFormatAddress", false>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare class MonkeyEcxFormatBeaufityJSONPipe implements PipeTransform {
    constructor();
    transform(value: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxFormatBeaufityJSONPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MonkeyEcxFormatBeaufityJSONPipe, "monkeyecxFormatBeautifyJSON", false>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare class MonkeyEcxFormatCurrencyPipe implements PipeTransform {
    private currencyPipe;
    private readonly _defaultCurencyCode;
    private readonly _localeId;
    constructor(currencyPipe: CurrencyPipe);
    transform(value: any, symbol?: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxFormatCurrencyPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MonkeyEcxFormatCurrencyPipe, "monkeyecxFormatCurrency", false>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare class MonkeyEcxFormatDatePipe implements PipeTransform {
    private dt;
    private readonly _dateFormat;
    private readonly _timezone;
    constructor(dt: DatePipe);
    transform(date: any | Date, format?: string): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxFormatDatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MonkeyEcxFormatDatePipe, "monkeyecxFormatDate", false>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare class MonkeyEcxFormatDocumentPipe implements PipeTransform {
    private readonly _country;
    transform(document: string, withType?: boolean): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxFormatDocumentPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MonkeyEcxFormatDocumentPipe, "monkeyecxFormatDocument", false>;
}

declare class MonkeyEcxFormatNumberPipe implements PipeTransform {
    transform(number: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxFormatNumberPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MonkeyEcxFormatNumberPipe, "monkeyecxFormatNumber", false>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare class MonkeyEcxFormatPhonePipe implements PipeTransform {
    transform(phone: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxFormatPhonePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MonkeyEcxFormatPhonePipe, "monkeyecxFormatPhone", false>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare class MonkeyEcxFormatSizePipe implements PipeTransform {
    transform(size: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxFormatSizePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MonkeyEcxFormatSizePipe, "monkeyecxFormatSize", false>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare class MonkeyEcxFormatTaxPipe implements PipeTransform {
    transform(tax: number, decimalDigits?: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxFormatTaxPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MonkeyEcxFormatTaxPipe, "monkeyecxFormatTax", false>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare class MonkeyEcxFormatDocumentTypePipe implements PipeTransform {
    private readonly _country;
    transform(document: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxFormatDocumentTypePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MonkeyEcxFormatDocumentTypePipe, "monkeyecxFormatDocumentType", false>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare class MonkeyEcxFormatValue implements PipeTransform {
    transform(number: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxFormatValue, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MonkeyEcxFormatValue, "monkeyecxFormatValue", false>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare class MonkeyEcxFormatZipCodePipe implements PipeTransform {
    transform(zipCode: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxFormatZipCodePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MonkeyEcxFormatZipCodePipe, "monkeyecxFormatZipCode", false>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare class MonkeyEcxTextTruncatePipe implements PipeTransform {
    transform(text: string, maxLength?: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxTextTruncatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MonkeyEcxTextTruncatePipe, "monkeyecxTextTruncate", false>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare class MonkeyEcxTruncateQtdPipe implements PipeTransform {
    transform(number: number, threshold: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxTruncateQtdPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MonkeyEcxTruncateQtdPipe, "monkeyecxTruncateQtd", false>;
}

declare class MonkeyEcxPipesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxPipesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<MonkeyEcxPipesModule, [typeof MonkeyEcxBlobSecurePipe, typeof MonkeyEcxDisplayFirstNamePipe, typeof MonkeyEcxDisplayInitialsPipe, typeof MonkeyEcxFormatAddressPipe, typeof MonkeyEcxFormatBeaufityJSONPipe, typeof MonkeyEcxFormatCurrencyPipe, typeof MonkeyEcxCurrencyCodePipe, typeof MonkeyEcxFormatDocumentPipe, typeof MonkeyEcxFormatDocumentTypePipe, typeof MonkeyEcxFormatNumberPipe, typeof MonkeyEcxFormatPhonePipe, typeof MonkeyEcxFormatSizePipe, typeof MonkeyEcxFormatTaxPipe, typeof MonkeyEcxFormatValue, typeof MonkeyEcxFormatZipCodePipe, typeof MonkeyEcxTextTruncatePipe, typeof MonkeyEcxTruncateQtdPipe, typeof MonkeyEcxFormatDatePipe], never, [typeof MonkeyEcxBlobSecurePipe, typeof MonkeyEcxDisplayFirstNamePipe, typeof MonkeyEcxDisplayInitialsPipe, typeof MonkeyEcxFormatAddressPipe, typeof MonkeyEcxFormatBeaufityJSONPipe, typeof MonkeyEcxFormatCurrencyPipe, typeof MonkeyEcxCurrencyCodePipe, typeof MonkeyEcxFormatDocumentPipe, typeof MonkeyEcxFormatDocumentTypePipe, typeof MonkeyEcxFormatNumberPipe, typeof MonkeyEcxFormatPhonePipe, typeof MonkeyEcxFormatSizePipe, typeof MonkeyEcxFormatTaxPipe, typeof MonkeyEcxFormatValue, typeof MonkeyEcxFormatZipCodePipe, typeof MonkeyEcxTextTruncatePipe, typeof MonkeyEcxTruncateQtdPipe, typeof MonkeyEcxFormatDatePipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<MonkeyEcxPipesModule>;
}

declare function provideDomainServiceWorker(workerUrl: string): i0.EnvironmentProviders;

declare abstract class MonkeyEcxBaseResolver implements Resolve<any> {
    readonly router: Router;
    readonly paramsSubject: BehaviorSubject<Partial<MonkeyEcxBaseResolverParams>>;
    readonly params$: Observable<Partial<MonkeyEcxBaseResolverParams>>;
    control: i0.WritableSignal<Partial<MonkeyEcxServiceControl>>;
    data: i0.WritableSignal<Partial<MonkeyEcxBaseResolverData> | null>;
    get pathParams(): any;
    get queryParams(): any;
    get stateData(): any;
    resolve(route: ActivatedRouteSnapshot): Observable<any> | Promise<any>;
    protected abstract resolveData(route: ActivatedRouteSnapshot): void;
}

declare abstract class MonkeyEcxI18nResolver implements Resolve<boolean> {
    private readonly _injector;
    private readonly _localeId;
    private readonly _bootstrapService;
    private readonly _i18nPath;
    private readonly _i18nAlias;
    private readonly _tokenStorageService;
    private static _loadedPaths;
    constructor();
    resolve(): Observable<boolean>;
    getHost(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxI18nResolver, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyEcxI18nResolver>;
}

declare class MonkeyEcxFileCacheService {
    private cache;
    private readonly EXPIRATION_MS;
    private isExpired;
    saveFile(filename: string, blob: Blob): void;
    hasFile(filename: string): boolean;
    getFile(filename: string): MonkeyEcxCachedFile | null;
    download(filename: string): void;
    deleteFile(filename: string): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxFileCacheService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyEcxFileCacheService>;
}

declare class MonkeyEcxConfigsService {
    private readonly _bootstrap$;
    private readonly _whiteLabel$;
    private readonly _styleGuide$;
    get bootstrap$(): Observable<MonkeyEcxBootstrap | null>;
    get bootstrap(): MonkeyEcxBootstrap | null;
    set bootstrap(data: MonkeyEcxBootstrap);
    get whiteLabel$(): Observable<MonkeyEcxWhiteLabel | null>;
    get whiteLabel(): MonkeyEcxWhiteLabel | null;
    set whiteLabel(data: MonkeyEcxWhiteLabel);
    get styleGuide(): Observable<MonkeyEcxStyleGuide | null>;
    set styleGuide(data: MonkeyEcxStyleGuide);
    federationSettings(key: string): {
        [key: string]: string;
        host: string;
        parentPath: string;
    } | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxConfigsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyEcxConfigsService>;
}

declare class MonkeyEcxDatadogService {
    private _allSet;
    private readonly _configService;
    private readonly _bootstrapService;
    private readonly _tokenStorageService;
    private handleValidation;
    private applyInfoToDataDog;
    apply(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxDatadogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyEcxDatadogService>;
}

declare class MonkeyEcxFeatureToggleService {
    private readonly _bootstrapService;
    private readonly _configService;
    private readonly _flagSubject$;
    private _ldClient;
    private handleValidation;
    getFlag<T = boolean>(flagName: string, defaultValue: T): T;
    get onFlags(): Observable<any>;
    apply(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxFeatureToggleService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyEcxFeatureToggleService>;
}

declare class MonkeyEcxLocaleService {
    private readonly _localeId;
    private readonly _service;
    private readonly _bootstrapService;
    private readonly _errorService;
    private readonly _configsService;
    private readonly _tokenStorageService;
    private static _loadedBundles;
    private static _loadedFromWhiteLabel;
    constructor();
    private isExpired;
    private loadFromWhitelabel;
    private loadExternal;
    private loadInternal;
    private loadByFederationSettings;
    private handleValidation;
    apply(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxLocaleService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyEcxLocaleService>;
}

declare class LService {
    private readonly _alpha;
    private readonly _beta;
    y(data: string): Promise<string>;
    private w;
    static ɵfac: i0.ɵɵFactoryDeclaration<LService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LService>;
}

declare class MonkeyEcxLoggedHandleService {
    private readonly _injector;
    constructor();
    private destroyToken;
    private destroySchedule;
    destroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxLoggedHandleService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyEcxLoggedHandleService>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

interface HttpOptions {
    headers: HttpHeaders | Record<string, string | string[]>;
    observe: 'events';
    context: HttpContext;
    params: HttpParams | Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>>;
    reportProgress: boolean;
    responseType: 'json';
    withCredentials: boolean;
    transferCache: {
        includeHeaders?: string[];
    } | boolean;
}
declare class MonkeyEcxService {
    private _http;
    private _stateService;
    private handlelize;
    internalRequestData: MonkeyEcxServiceCredentials | null;
    private getOptions;
    get<T>(url: string, options?: any): Observable<T>;
    getWithProgress<T>(url: string, options?: Partial<HttpOptions> | {}): Observable<HttpEvent<T>>;
    post<T>(url: string, params: T, options?: Partial<HttpOptions> | {}): Observable<any>;
    put<T>(url: string, params: T, options?: Partial<HttpOptions> | {}): Observable<any>;
    patch<T>(url: string, params: T, options?: Partial<HttpOptions> | {}): Observable<any>;
    delete<T>(url: string, options?: Partial<HttpOptions> | {}): Observable<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyEcxService>;
}

declare class MonkeyEcxDiscoveryParamsService {
    private router;
    constructor(router: Router);
    private getLastChild;
    setData(field: string, value: any): any;
    getData(field: string): any;
    getDataFromCurrentNavigation(field: string, router?: Router): any;
    getParam(param: string): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxDiscoveryParamsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyEcxDiscoveryParamsService>;
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

interface MonkeyEcxStartWithRequestInterface {
    data?: any;
    url: string;
    id?: string;
    params?: any;
    period?: number;
    preserveOnNavigation?: boolean;
    callback(data: any, subscriptionId: string): void;
    onError?(err: HttpErrorResponse, data?: any): void;
}
interface MonkeyEcxStartInterface {
    id?: string;
    period?: number;
    callback: Function;
    onError?: Function;
    preserveOnNavigation?: boolean;
}
declare class MonkeyEcxScheduleService {
    private readonly _router;
    private readonly _service;
    private _routerSubscription;
    private _schedules;
    private handleRoute;
    start({ callback, period, preserveOnNavigation, id }: MonkeyEcxStartInterface): void;
    startWithRequest({ id, url, data, params, period, onError, callback, preserveOnNavigation }: MonkeyEcxStartWithRequestInterface): void;
    stop(id: string): void;
    stopAll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxScheduleService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyEcxScheduleService>;
}

declare abstract class MonkeyEcxCommonsActions {
    static getActions<T>(actionName: string): {
        clear: _ngrx_store.ActionCreator<`[${string}] Clear All`, () => _ngrx_store.Action<`[${string}] Clear All`>>;
        load: _ngrx_store.ActionCreator<`[${string}] Load`, (props: MonkeyEcxStoreLoadParams) => MonkeyEcxStoreLoadParams & _ngrx_store.Action<`[${string}] Load`>>;
        start: _ngrx_store.ActionCreator<`[${string}] Start`, (props: MonkeyEcxStoreStartParams) => MonkeyEcxStoreStartParams & _ngrx_store.Action<`[${string}] Start`>>;
        loadPagination: _ngrx_store.ActionCreator<`[${string} Pagination] Load`, (props: MonkeyEcxStoreLoadPageParams) => MonkeyEcxStoreLoadPageParams & _ngrx_store.Action<`[${string} Pagination] Load`>>;
        removeOne: _ngrx_store.ActionCreator<`[${string}] Remove One`, (props: {
            data: T;
        }) => {
            data: T;
        } & _ngrx_store.Action<`[${string}] Remove One`>>;
        updateAll: _ngrx_store.ActionCreator<`[${string}] Update All`, (props: {
            data: T[];
        }) => {
            data: T[];
        } & _ngrx_store.Action<`[${string}] Update All`>>;
        updateOne: _ngrx_store.ActionCreator<`[${string}] Update One`, (props: {
            data: T;
        }) => {
            data: T;
        } & _ngrx_store.Action<`[${string}] Update One`>>;
        updateControl: _ngrx_store.ActionCreator<`[${string}] Update Control`, (props: {
            data: MonkeyEcxStoreControl;
        }) => {
            data: MonkeyEcxStoreControl;
        } & _ngrx_store.Action<`[${string}] Update Control`>>;
        updateLinks: _ngrx_store.ActionCreator<`[${string}] Update Links`, (props: {
            data: MonkeyEcxPaginationData;
        }) => {
            data: MonkeyEcxPaginationData;
        } & _ngrx_store.Action<`[${string}] Update Links`>>;
        updatePage: _ngrx_store.ActionCreator<`[${string}] Update Page`, (props: {
            data: MonkeyEcxPage;
        }) => {
            data: MonkeyEcxPage;
        } & _ngrx_store.Action<`[${string}] Update Page`>>;
    };
}

interface IReducer {
    featureKey: string;
    selectAll: any;
}
declare abstract class MonkeyEcxCommonsSelectors {
    static getSelectors<T>(reducer: IReducer): {
        selectState: _ngrx_store.MemoizedSelector<object, T, _ngrx_store.DefaultProjectorFn<T>>;
        selectAll: any;
        selectData: () => _ngrx_store.MemoizedSelector<object, any, (s1: T) => any>;
        selectControl: () => _ngrx_store.MemoizedSelector<object, any, (s1: T) => any>;
        selectLinks: () => _ngrx_store.MemoizedSelector<object, any, (s1: T) => any>;
        selectPage: () => _ngrx_store.MemoizedSelector<object, any, (s1: T) => any>;
    };
}

/**
 * Classe genérica que recebe duas interfaces como tipos genéricos.
 *
 * @typeparam T deve ser a mesma interface utilizada na Entity da Store
 * @typeparam K faz referência ao tipo de configuração.
 *
 * @description interfaces de configuração:
 * ```
 * MonkeyEcxCollectionStore e MonkeyEcxEntityStore
 * ```
 */
declare abstract class MonkeyEcxCommonsStoreService<T, K extends MonkeyEcxConfigStore> {
    protected store: Store;
    private action;
    private selector;
    readonly service: MonkeyEcxService;
    constructor(store: Store, config: K);
    private handleResponseData;
    protected updateControl(data: MonkeyEcxControlStore): void;
    protected mappingData(args: T | T[]): T | T[];
    protected update?(args: T | T[]): void;
    protected updatePage?(data: MonkeyEcxPage): void;
    protected updateLinks?(data: MonkeyEcxLinks): void;
    protected loadData(url: string, updateLinks?: boolean): Promise<void>;
    protected loadPageData(pagination: MonkeyEcxPagination): Promise<void>;
    /**
     * @description Neste método precisamos incluir a lógica para conferir se precisa limpar a
     * entidade ou não
     * E depois precisa invocar o método loadData
     * @param (url) ou de acordo com a action criada
     * @example
     * ```
     * const hasDifference = .....
     * if(hasDifference) {
     *    store.dispatch(clear)
     * }
     *
     * this.loadData(...)
     * ```
     */
    load?(args: any): void;
    loadPage?(args: any): void;
}

declare class MonkeyEcxFormValidationService {
    validateForm(form: FormGroup): boolean;
    scrollToError(): void;
    private markAllTouched;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonkeyEcxFormValidationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MonkeyEcxFormValidationService>;
}

declare const clear: _ngrx_store.ActionCreator<"[MECX Core Storage] Clear All", () => _ngrx_store.Action<"[MECX Core Storage] Clear All">>;
declare const create: _ngrx_store.ActionCreator<"[MECX Core Storage] Create", (props: {
    data: Partial<MonkeyEcxStorage>;
}) => {
    data: Partial<MonkeyEcxStorage>;
} & _ngrx_store.Action<"[MECX Core Storage] Create">>;
declare const updateControl: _ngrx_store.ActionCreator<"[MECX Core Storage] Update Control", (props: {
    data: MonkeyEcxStoreControl;
}) => {
    data: MonkeyEcxStoreControl;
} & _ngrx_store.Action<"[MECX Core Storage] Update Control">>;
declare const updateData: _ngrx_store.ActionCreator<"[MECX Core Storage] Update One", (props: {
    data: MonkeyEcxStorage;
}) => {
    data: MonkeyEcxStorage;
} & _ngrx_store.Action<"[MECX Core Storage] Update One">>;
declare const updateMe: _ngrx_store.ActionCreator<"[MECX Core Storage] Update Me", (props: {
    data: Partial<MonkeyEcxMeCredentials>;
}) => {
    data: Partial<MonkeyEcxMeCredentials>;
} & _ngrx_store.Action<"[MECX Core Storage] Update Me">>;

declare const monkeyecxStorage_actions_d_clear: typeof clear;
declare const monkeyecxStorage_actions_d_create: typeof create;
declare const monkeyecxStorage_actions_d_updateControl: typeof updateControl;
declare const monkeyecxStorage_actions_d_updateData: typeof updateData;
declare const monkeyecxStorage_actions_d_updateMe: typeof updateMe;
declare namespace monkeyecxStorage_actions_d {
  export {
    monkeyecxStorage_actions_d_clear as clear,
    monkeyecxStorage_actions_d_create as create,
    monkeyecxStorage_actions_d_updateControl as updateControl,
    monkeyecxStorage_actions_d_updateData as updateData,
    monkeyecxStorage_actions_d_updateMe as updateMe,
  };
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare namespace index_d$3 {
  export {
    monkeyecxStorage_actions_d as monkeyecxStorage,
  };
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare const seederReducer: (keys: string[]) => (reducer: ActionReducer<any>) => ActionReducer<any>;

declare const monkeyecxSeeder_reducer_d_seederReducer: typeof seederReducer;
declare namespace monkeyecxSeeder_reducer_d {
  export {
    monkeyecxSeeder_reducer_d_seederReducer as seederReducer,
  };
}

declare const featureKey = "mecx-core-storage";
interface State {
    control: {
        isLoading: boolean;
    };
    data: Partial<MonkeyEcxStorage> | null;
}
declare const initialState: State;
declare const reducer: _ngrx_store.ActionReducer<State, _ngrx_store.Action<string>>;

type monkeyecxStorage_reducer_d_State = State;
declare const monkeyecxStorage_reducer_d_featureKey: typeof featureKey;
declare const monkeyecxStorage_reducer_d_initialState: typeof initialState;
declare const monkeyecxStorage_reducer_d_reducer: typeof reducer;
declare namespace monkeyecxStorage_reducer_d {
  export { monkeyecxStorage_reducer_d_featureKey as featureKey, monkeyecxStorage_reducer_d_initialState as initialState, monkeyecxStorage_reducer_d_reducer as reducer };
  export type { monkeyecxStorage_reducer_d_State as State };
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare namespace index_d$2 {
  export {
    monkeyecxSeeder_reducer_d as fromMonkeyecxSeeder,
    monkeyecxStorage_reducer_d as fromMonkeyecxStorage,
  };
}

declare const selectState: _ngrx_store.MemoizedSelector<object, State, _ngrx_store.DefaultProjectorFn<State>>;
declare const select: _ngrx_store.MemoizedSelector<object, Partial<MonkeyEcxStorage> | null, (s1: State) => Partial<MonkeyEcxStorage> | null>;
declare const selectUser: _ngrx_store.MemoizedSelector<object, Partial<MonkeyEcxStorage> | null, (s1: State) => Partial<MonkeyEcxStorage> | null>;
declare const selectControl: _ngrx_store.MemoizedSelector<object, any, (s1: State) => any>;

declare const monkeyecxStorage_selector_d_select: typeof select;
declare const monkeyecxStorage_selector_d_selectControl: typeof selectControl;
declare const monkeyecxStorage_selector_d_selectState: typeof selectState;
declare const monkeyecxStorage_selector_d_selectUser: typeof selectUser;
declare namespace monkeyecxStorage_selector_d {
  export {
    monkeyecxStorage_selector_d_select as select,
    monkeyecxStorage_selector_d_selectControl as selectControl,
    monkeyecxStorage_selector_d_selectState as selectState,
    monkeyecxStorage_selector_d_selectUser as selectUser,
  };
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare namespace index_d$1 {
  export {
    monkeyecxStorage_selector_d as monkeyecxStorage,
  };
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

declare namespace index_d {
  export {
    index_d$3 as actions,
    index_d$2 as reducers,
    index_d$1 as selectors,
  };
}

/** ************************
 * Copyright Monkey Exchange. All Rights Reserved
 * This style guide was developed by Monkey Exchange Team
 * MIT Licence
 ************************* */

type DocumentType = 'CPF' | 'CNPJ';
type LogParams = {
    message: string;
    context?: any;
    error?: Error;
    type?: 'ok' | 'debug' | 'info' | 'notice' | 'warn' | 'error' | 'critical' | 'alert' | 'emerg';
};
declare class MonkeyEcxUtils {
    static persistNullEmptyUndefined(tp: any): boolean;
    static getDocumentType(doc: string, country?: string): "" | "CPF" | "CNPJ" | "RUT" | "RFC" | "EIN";
    static getDocumentMask(type: DocumentType, country?: string): CountryMasks;
    static getDocumentPlaceholder(type: DocumentType, country?: string): string;
    static formatDocumentWithMask(doc: string, withType?: boolean, country?: string): string;
    static cutFirstLastName(value: string, tp?: string): string;
    static isCPFCNPJValid(document: any): boolean;
    static isValidRUT(document: string): boolean;
    static isValidEIN(ein: string): boolean;
    static isValidRFC(document: string): boolean;
    static isValidUrl(txt: string): boolean;
    static isValidZipCode(zipCode: string, country?: string): boolean;
    static isValidEmail(email: string): boolean;
    static getRandomString(len: number, charSet?: string): string;
    static handleOnlyNumbers(value: any): any;
    static handleOnlyAlphaNumeric(value: any): any;
    static capitalize(value: string): string;
    static formatZipCode(zipCode: string): string;
    static formatFileSize(size: number): string;
    static sufflue(data: any[]): any[];
    static handleBlobFile(theBlob: any, fileName: string, fileType: string): any;
    static truncate(text: string, maxLength?: number): string;
    static isLocalhost(): boolean;
    static isSameOrigin(frontend: string): boolean;
    static replaceVariables(data: string, obj: any): string;
    static trimValuesToSave(obj: any, fields: string[]): any;
    static base64ToBuffer(base64: string): ArrayBuffer;
    static isValidDate(dateString: string, formats?: string[]): boolean;
    static getEmbeddedData(data: any, field: string): any[] | any;
    static getFileToDownload(resp: HttpResponse<any>, filename?: string): {
        filename: string | undefined;
        blob: Blob;
        resp: HttpResponse<any>;
    };
}
declare class MonkeyEcxLogs {
    static log(params: LogParams): void;
}

export { CACHE_LOCALE_EXPIRATION_MS, CountryMasks, LService, Link, MECX_ALPHA, MECX_BETA, MECX_BOOTSTRAP_SERVICE, MECX_CORE_I18N_WRAPPER, MECX_COUNTRY, MECX_DATE_FORMAT, MECX_I18N_ALIAS, MECX_I18N_PATH, MECX_REDIRECT_LOGIN_WELCOMEBACK_STRATEGY, MECX_REFRESH_TOKEN_STRATEGY, MECX_REQUEST_ID, MECX_TIMEZONEOFFSET, MonkeyEcxAuthGuard, MonkeyEcxAuthGuardByRole, MonkeyEcxAuthGuardCompany, MonkeyEcxAuthGuardLogin, MonkeyEcxBaseResolver, MonkeyEcxBlobSecurePipe, MonkeyEcxCommonsActions, MonkeyEcxCommonsSelectors, MonkeyEcxCommonsStoreService, MonkeyEcxConfigsService, MonkeyEcxCookieStorageService, MonkeyEcxCoreModule, MonkeyEcxCoreService, MonkeyEcxCurrencyCodePipe, MonkeyEcxDatadogService, MonkeyEcxDiscoveryParamsService, MonkeyEcxDisplayFirstNamePipe, MonkeyEcxDisplayInitialsPipe, MonkeyEcxErrorMessageDirective, MonkeyEcxFeatureByProgramDirective, MonkeyEcxFeatureDirective, MonkeyEcxFeatureToggleService, MonkeyEcxFileCacheService, MonkeyEcxFormValidationService, MonkeyEcxFormatAddressPipe, MonkeyEcxFormatBeaufityJSONPipe, MonkeyEcxFormatCurrencyPipe, MonkeyEcxFormatDatePipe, MonkeyEcxFormatDocumentPipe, MonkeyEcxFormatDocumentTypePipe, MonkeyEcxFormatNumberPipe, MonkeyEcxFormatPhonePipe, MonkeyEcxFormatSizePipe, MonkeyEcxFormatTaxPipe, MonkeyEcxFormatValue, MonkeyEcxFormatZipCodePipe, MonkeyEcxI18nResolver, MonkeyEcxLinksModel, MonkeyEcxLoadingDirective, MonkeyEcxLocaleService, MonkeyEcxLoggedHandleService, MonkeyEcxLogs, MonkeyEcxModel, MonkeyEcxPipesModule, MonkeyEcxScheduleService, MonkeyEcxSecurityDirective, MonkeyEcxService, MonkeyEcxTextTruncatePipe, MonkeyEcxTokenStorageService, MonkeyEcxTruncateQtdPipe, MonkeyEcxUtils, MonkeyValidators, comboValidator, containsNumber, dateRangeValidator, dateStartEndValidator, dateValidator, differentFromZero, documentValidator, documentValidatorByType, emailValidator, injectTokenWithWarning, minYearsValidator, monkeyEcxHttpConfigInterceptor, passwordConfirmValidator, provideDomainServiceWorker, registerValidator, requiredWithTrimValidator, index_d$4 as storage, index_d as store, trueValidator, urlValidator, validateFullName, valueGreaterThanZero, zipCodeValidator };
export type { MonkeyEcxAPIResponse, MonkeyEcxAccessHandleAccessTypes, MonkeyEcxAccessHandleTokenCredentials, MonkeyEcxAlert, MonkeyEcxAuthCredentials, MonkeyEcxAuthReAuthenticateData, MonkeyEcxAuthenticationService, MonkeyEcxBaseResolverData, MonkeyEcxBaseResolverParams, MonkeyEcxBootstrap, MonkeyEcxBootstrapService, MonkeyEcxCachedFile, MonkeyEcxCollectionStore, MonkeyEcxCompany, MonkeyEcxConfigStore, MonkeyEcxControlStore, MonkeyEcxEntityStore, MonkeyEcxEnv, MonkeyEcxGroup, MonkeyEcxGroupCompany, MonkeyEcxHeaderCredentials, MonkeyEcxInterface, MonkeyEcxLinks, MonkeyEcxMeCredentials, MonkeyEcxPage, MonkeyEcxPagination, MonkeyEcxPaginationActions, MonkeyEcxPaginationData, MonkeyEcxPaginationSortData, MonkeyEcxPaginationSortField, MonkeyEcxPendingRequest, MonkeyEcxProgram, MonkeyEcxRedirectLoginWelcomeBackStrategy, MonkeyEcxRefreshTokenStrategy, MonkeyEcxServiceControl, MonkeyEcxServiceCredentials, MonkeyEcxStorage, MonkeyEcxStoreControl, MonkeyEcxStoreLoadPageParams, MonkeyEcxStoreLoadParams, MonkeyEcxStoreStartParams, MonkeyEcxStyleColor, MonkeyEcxStyleGuide, MonkeyEcxStyleGuideFont, MonkeyEcxTokenCredentials, MonkeyEcxWhiteLabel };