import { default as BalanceCard } from './components/operations/BalanceCard';
import { Component as Component_2 } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { default as CurrencySelector } from './components/ui/CurrencySelector';
import { default as CustomCheckBox } from './components/ui/CustomCheckBox';
import { default as CustomMultiSelect } from './components/ui/CustomMultiSelect';
import { default as CustomPie } from './components/ui/CustomPie';
import { default as CustomRadioButton } from './components/ui/CustomRadioButton';
import { default as CustomSelect } from './components/ui/CustomSelect';
import { default as CustomStepper } from './components/ui/CustomStepper';
import { default as CustomSwitch } from './components/ui/CustomSwitch';
import { default as CustomTextArea } from './components/ui/CustomTextArea';
import { default as CustomToast } from './components/ui/CustomToast';
import { DefineComponent } from 'vue';
import { FontAwesomeIcon } from '@fortawesome/vue-fontawesome';
import { default as MainTable } from './components/ui/MainTable';
import { default as ObservationCard } from './components/operations/ObservationCard';
import { PropType as PropType_2 } from 'vue';
import { PublicProps } from 'vue';
import { StoreDefinition } from 'pinia';
import { default as ThirdPartyCard } from './components/operations/ThirdPartyCard';

declare const __VLS_component: DefineComponent<globalThis.ExtractPropTypes<{
    visible: BooleanConstructor;
    modalClass: StringConstructor;
    closable: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:visible": (...args: any[]) => void;
}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
    visible: BooleanConstructor;
    modalClass: StringConstructor;
    closable: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
}>> & Readonly<{
    "onUpdate:visible"?: (...args: any[]) => any;
}>, {
    visible: boolean;
    closable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_component_2: DefineComponent<__VLS_Props_3, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (value: string) => any;
    tabChange: (value: string) => any;
}, string, PublicProps, Readonly<__VLS_Props_3> & Readonly<{
    "onUpdate:modelValue"?: (value: string) => any;
    onTabChange?: (value: string) => any;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_3: DefineComponent<globalThis.ExtractPropTypes<{
    cardClass: {
        type: StringConstructor;
        default: string;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
    cardClass: {
        type: StringConstructor;
        default: string;
    };
}>> & Readonly<{}>, {
    cardClass: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;

declare type __VLS_Props = {
    selectionMode?: "single" | "multiple" | "range";
    manualInput?: boolean;
    inputClass?: string;
    placeholder?: string;
    icon?: string;
    showIcon?: boolean;
    dateFormat?: string;
    showButtonBar?: boolean;
    showTime?: boolean;
    hourFormat?: "12" | "24";
    timeOnly?: boolean;
    view?: "date" | "month" | "year";
    numberOfMonths?: number;
    minDate?: Date;
    maxDate?: Date;
    inline?: boolean;
    variant?: "outlined" | "filled";
    disabled?: boolean;
    readonly?: boolean;
    invalid?: boolean;
    datePickerClass?: string;
    label?: string;
    labelClass?: string;
    allowLabelWrap?: boolean;
    required?: boolean;
};

declare type __VLS_Props_2 = {
    buttonList: Button[];
};

declare type __VLS_Props_3 = {
    tabs: TabItem[];
    modelValue?: string;
};

declare type __VLS_PublicProps = {
    modelValue?: any;
} & __VLS_Props;

declare function __VLS_template(): {
    attrs: Partial<{}>;
    slots: {
        header?(_: {}): any;
        description?(_: {}): any;
        content?(_: {}): any;
        footer?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_2(): {
    attrs: Partial<{}>;
    slots: Partial<Record<string, (_: {
        tab: TabItem;
    }) => any>>;
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_3(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;

declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;

declare type __VLS_TemplateResult_3 = ReturnType<typeof __VLS_template_3>;

declare type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_2<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_3<T, S> = T & {
    new (): {
        $slots: S;
    };
};

export declare interface accountData {
    id: number;
    accountNumber: string;
    secuency: secuencyData[];
    heritageTotal: number;
    chart: chartData[];
}

export declare interface accountOrigin {
    id: number;
    description: string;
}

export declare class accountOriginService {
    getAccountOriginList(): Promise<{
        data: accountOrigin[];
    }>;
}

export declare interface Accounts {
    id?: number;
    userId?: number;
    clientType?: any;
    currencyType?: any;
    bankName?: string;
    accountType?: any;
    accountNumber?: string;
    codSwift?: string;
    codABA?: string;
    cityBank?: string;
    countryIdBank?: any;
    addressBank?: string;
    intermediary?: any;
    intermediaryBankName?: string;
    intermediaryAccountNumber?: string;
    intermediaryCodSwift?: string;
    intermediaryCodABA?: string;
    intermediaryAddressBank?: string;
    intermediaryCountryIdBank?: any;
    intermediaryCityBank?: string;
}

export declare interface accountType {
    id: number;
    description: string;
}

export declare class accountTypeService {
    getAccountTypeList(): Promise<accountType[]>;
}

declare function adminPath_2(hostname: string): string;
export { adminPath_2 as adminPath }

export declare interface alertList {
    id: number;
    clientId: number;
    dateTime: string;
    currency: string;
    currentyPrice: string;
    alertBuyPrice: string;
    alertSellPrice: string;
    typeNotification: string;
    isActivated: string;
}

export declare type allDataTable = {
    date: string;
    client_id: number;
    id: number;
    operation: string;
    amount: string;
    third_part: string;
    beneficiary: string;
    aprove_by: string;
    receipt: string;
    status: string;
};

export declare interface AnalystCountry {
    id: number;
    status: boolean;
    name: string;
    codName: string;
    blockType: string;
}

export declare interface AnalystCurrencyType {
    id: number;
    description: boolean;
}

export declare class analystService {
    getAnalistInfo(status: number[] | null, operationType: number | null, operationAccepted?: Array<number> | null, dateTime?: [Date, Date] | null): Promise<{
        data: operations[];
    }>;
}

export declare const AutocompleteInput: DefineComponent<Props, {
    setSelecting: (value: boolean) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (value: string) => any;
    clientSelected: (client: ClientData) => any;
}, string, PublicProps, Readonly<Props> & Readonly<{
    "onUpdate:modelValue"?: (value: string) => any;
    onClientSelected?: (client: ClientData) => any;
}>, {
    modelValue: string;
    label: string;
    placeholder: string;
    inputClass: string;
    required: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;

export declare const AutocompleteRutInput: DefineComponent<Props_2, {
    setSelecting: (value: boolean) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (value: string) => any;
    clientSelected: (client: ClientData) => any;
}, string, PublicProps, Readonly<Props_2> & Readonly<{
    "onUpdate:modelValue"?: (value: string) => any;
    onClientSelected?: (client: ClientData) => any;
}>, {
    modelValue: string;
    label: string;
    placeholder: string;
    inputClass: string;
    required: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;

export declare interface AvailableFunds {
    clp: number;
    usd: number;
    eur: number;
    mutualFundsClp: number;
    mutualFundsUsd: number;
}

declare interface AvailableFunds_2 {
    CLPTotal?: number;
    USDTotal?: number;
    EURTotal?: number;
    TotalCLP?: number;
    saldoContable?: CurrencyBalance;
    saldoDisponible?: CurrencyBalance;
    saldoTransito?: CurrencyBalance;
}

declare interface Balance {
    clienteRut: string;
    secuencia: number;
    saldoContable: {
        cLP: number;
        uSD: number;
        eUR: number;
    };
    saldoDisponible: {
        cLP: number;
        uSD: number;
        eUR: number;
    };
    saldoTransito: {
        cLP: number;
        uSD: number;
        eUR: number;
    };
    cLPTotal: number;
    uSDTotal: number;
    eURTotal: number;
    totalCLP: number;
}

export { BalanceCard }

declare interface BankCCType {
    id: number;
    bancoNombre: string;
    numeroCuenta: string;
    monedaISO: string;
    rut: string;
    activo: number;
    alias?: string;
}

export declare interface bankClp {
    id: number;
    description: string;
    cod: string;
}

declare interface BankCrediCorp {
    description?: string;
    accountNumber?: string;
}

export declare interface bankData {
    id: number;
    description: string;
    accountNumber: string;
    country?: string;
    type?: string;
    codAba?: string;
    codSwift?: string;
}

export declare class bankListClpService {
    getBanksList(): Promise<{
        data: bankClp[];
    }>;
}

export declare const base64Transformer: (file: File) => Promise<string>;

declare function basePath_2(hostname: string): string;
export { basePath_2 as basePath }

export declare interface Beneficiary {
    id: number;
    error: boolean;
    isEditing: boolean;
    clientExist: boolean;
    accountRepeat: boolean;
    fullName: string;
    rut: string;
    alias?: string;
    address?: string;
    countryId?: any;
    city?: string;
    survey?: [];
    accounts?: Accounts[];
}

export declare interface beneficiary {
    id?: number;
    name?: string;
    rut?: string;
}

export declare class beneficiaryService {
    getMyAccounts(clientId: number, secuencyId: number, type: number, page: number, limit: number): Promise<{
        data: UserData[];
        totalPages: number;
    }>;
    getClientRut(rut: string | string[], secuencyId: number, type: number): Promise<{
        data: UserPersonalData[];
    }>;
    getDuplicatedAccounts(newAccounts: Beneficiary[], accountExists: UserPersonalData[]): Promise<DuplicatedAccount[]>;
    getDuplicatedOneAccount(newAccount: DuplicatedSingleAccount, rutClient: string, secuencyId: number, type: number): Promise<DuplicatedAccountResult>;
}

export declare interface Button {
    id: number;
    label: string;
    isActive: boolean;
    action: string;
}

export declare interface buttonCent {
    id: number;
    label: string;
    value: number;
    isPositive: boolean;
    isActive: boolean;
}

export declare interface CardConfig {
    label: string;
    type: number;
    key: string;
    data: fertilizerCharges | null;
}

declare interface CatalogType {
    [key: string]: CatalogValueType[] | undefined;
    formaPago?: CatalogValueType[];
    tipoMovimiento?: CatalogValueType[];
    condicionPago?: CatalogValueType[];
    tipoOperacion?: CatalogValueType[];
    relacionTercero?: CatalogValueType[];
    tipoCuenta?: CatalogValueType[];
    origenCuenta?: CatalogValueType[];
    tipoTercero?: CatalogValueType[];
}

declare interface CatalogValueType {
    id: number;
    valor: string;
}

declare interface ChartButton {
    id: number | string;
    label: string;
    class?: string;
    activeVariant?: string;
    inactiveVariant?: string;
    onClick?: (button: ChartButton) => void;
    customData?: any;
}

declare interface ChartData {
    date: number | Date;
    value: number;
}

export declare interface chartData {
    name: string;
    value: number;
    transit?: number;
    sliceSettings: sliceSettings;
}

declare interface ChartData_2 {
    name: string;
    value: number;
    transit?: number;
    sliceSettings: SliceSettings;
}

export declare interface ChartDataPoint {
    range: rangeForexGraficLine;
    clientId: number;
    data: dataForexcharLine[];
}

export declare interface clientAmount {
    id: number;
    clientId: number;
    operationType?: GeneralOperationType[];
}

export declare class clientAmountService {
    myAmountClient(clientId: number): Promise<clientAmount>;
}

export declare interface ClientData {
    id: number;
    rut: string;
    clienId?: number;
    name: string;
    clientPrice?: number;
    secuency: [];
}

export declare interface clientData {
    id: number;
    name: boolean;
    rut: string;
    bankDetails: bankData;
}

export declare interface Clientes {
    clienteId: number;
    clienteRut: string;
    clienteRazonsocial: string;
    clienterMail: string;
    clienterMail2: string;
    crTiporepresentacion: string;
    crRolesId: number;
    crTolnombre: string;
    crId: number;
}

export declare interface clientList {
    id: number;
    clientId: number;
    name: string;
    account: string;
    accountType: string;
    swift?: string;
    aba?: string;
    favorite: boolean;
    country: {
        id: number;
        name: string;
    };
    isBeneficiary: boolean;
    beneficiary?: beneficiary;
    intermediaryAccount?: intermediaryAccount;
}

/**
 * @description traido manualmente mientras se prueba la importación del portalcash-shared
 */
export declare function clientPath(hostname: any): "/portalcash/chl/corecashchile-clients" | "/corecashchile-clients";

export declare class ClientSearchService {
    private clients;
    searchClientsByName(searchText: string, limit?: number, clientId?: number): ClientData[];
    searchClientsByRut(searchText: string, limit?: number): ClientData[];
    getClientByRut(rut: string): ClientData | null;
    searchClientsAsync(searchText: string, limit?: number, clientId?: number): Promise<ClientData[]>;
    searchClientsByRutAsync(searchText: string, limit?: number): Promise<ClientData[]>;
}

declare interface ClientType {
    companyId: number;
    companyName: string;
    companyRut: string;
    userType: string;
    clientId: number;
    executiveName?: string;
    executiveEmail?: string;
    executivePhone?: string;
    bid: number;
    offer: number;
    secuency?: SecuencyData[];
    forex?: Forex;
    investments?: Investments;
    available?: AvailableFunds_2;
    inTransit?: InTransitFunds_2;
}

export declare interface clientType {
    id: number;
    description: string;
}

export declare class clientTypeService {
    getClientTypeList(): Promise<clientType[]>;
}

export declare interface closedOperationsData {
    total: number;
    totalPages: number;
    page: number;
    pageSize: number;
    operations: operationsList[];
}

export declare class ClosedOperationsService {
    getClosedOperationsFile(clientId: number, filters: any): Promise<closedOperationsData>;
    getClosedOperations(clientId: number, page: number, size: number, filters: any): Promise<{
        data: closedOperationsData;
    }>;
}

export declare function closeWebSocket(): void;

export declare type company = {
    id: number;
    companyName: string;
    rut: string;
    userType: string;
    clientId: number;
    executiveName?: string;
    executiveEmail?: string;
    executivePhone?: string;
    bid: number;
    offer: number;
    secuency?: secuencyData[];
    forex?: forex;
    investments?: investments;
    available?: AvailableFunds;
    inTransit?: InTransitFunds;
};

export declare class complianceService {
    getValidateOperations(status: Array<number>, filterClientName: string | null, filterOperationType: number | null, filterOperationState: number | null): Promise<{
        data: validateOperation[];
    }>;
    getValidateThird(status: Array<number>, filterClientName: string | null, filterThirdType: number | null, filterOperationState: number | null): Promise<{
        data: thirdOperation[];
    }>;
}

export { Component_2 as Component }

export declare function connectWebSocket(url: string): Promise<void>;

export declare interface contributionList {
    id: number;
    clientId: number;
    date: string;
    movement: Movement;
    mutualFund: string;
    quotaValue: number;
    initialQuotaValue: number;
    initialOperation: number;
    approvedBy: string;
    serie: string;
    status: Status;
    rent: number;
    comment?: string;
}

export declare interface Country {
    id: number;
    status: boolean;
    name: string;
    codName: string;
    blockType: string;
}

declare interface Country_2 {
    id: number;
    status: boolean;
    name: string;
    codName: string;
    blockType: string;
}

declare type CountryOption = {
    name: string;
    blockType?: string;
    [key: string]: any;
} | string | number | null;

export declare class countryService {
    getCountries(): Promise<{
        data: GeneralCountry[];
    }>;
}

export declare class creadiCorpService {
    getBanksList(): Promise<{
        data: credicorpBank[];
    }>;
}

export declare interface credicorpBank {
    id: number;
    description: string;
    accountNumber: string;
    type: string;
}

declare type CurrencyBalance = {
    CLP: number;
    USD: number;
    EUR: number;
};

export { CurrencySelector }

export declare class currencyService {
    getCurrencyList(): Promise<currencyType[]>;
}

declare interface CurrencyType {
    id: number;
    description: string;
}

export declare interface currencyType {
    id: number;
    description: string;
    src?: string;
}

export declare const CustomButton: DefineComponent<globalThis.ExtractPropTypes<{
    label: {
        type: StringConstructor;
        default: string;
    };
    icon: {
        type: StringConstructor;
        default: string;
    };
    iconType: {
        type: PropType_2<IconType>;
        default: string;
    };
    iconPos: {
        type: PropType_2<IconPos>;
        default: string;
    };
    iconClass: {
        type: StringConstructor;
        default: string;
    };
    customClass: {
        type: StringConstructor;
        default: string;
    };
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    enableHover: {
        type: BooleanConstructor;
        default: boolean;
    };
    variant: {
        type: PropType_2<Variant>;
        default: string;
    };
    /**Loading Props */
    loading: {
        type: BooleanConstructor;
        default: boolean;
    };
    loadingOnIcon: {
        type: BooleanConstructor;
        default: boolean;
    };
    loadingPos: {
        type: PropType_2<IconPos>;
        default: string;
    };
    loadingSelf: {
        type: BooleanConstructor;
        default: boolean;
    };
    loadingSelfTimeout: {
        type: NumberConstructor;
        default: number;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    click: (...args: any[]) => void;
}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
    label: {
        type: StringConstructor;
        default: string;
    };
    icon: {
        type: StringConstructor;
        default: string;
    };
    iconType: {
        type: PropType_2<IconType>;
        default: string;
    };
    iconPos: {
        type: PropType_2<IconPos>;
        default: string;
    };
    iconClass: {
        type: StringConstructor;
        default: string;
    };
    customClass: {
        type: StringConstructor;
        default: string;
    };
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    enableHover: {
        type: BooleanConstructor;
        default: boolean;
    };
    variant: {
        type: PropType_2<Variant>;
        default: string;
    };
    /**Loading Props */
    loading: {
        type: BooleanConstructor;
        default: boolean;
    };
    loadingOnIcon: {
        type: BooleanConstructor;
        default: boolean;
    };
    loadingPos: {
        type: PropType_2<IconPos>;
        default: string;
    };
    loadingSelf: {
        type: BooleanConstructor;
        default: boolean;
    };
    loadingSelfTimeout: {
        type: NumberConstructor;
        default: number;
    };
}>> & Readonly<{
    onClick?: (...args: any[]) => any;
}>, {
    label: string;
    disabled: boolean;
    icon: string;
    variant: Variant;
    iconType: IconType;
    iconPos: IconPos;
    iconClass: string;
    customClass: string;
    enableHover: boolean;
    loading: boolean;
    loadingOnIcon: boolean;
    loadingPos: IconPos;
    loadingSelf: boolean;
    loadingSelfTimeout: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLButtonElement>;

export { CustomCheckBox }

export declare const CustomDatePicker: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (value: any) => any;
}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
    "onUpdate:modelValue"?: (value: any) => any;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;

export declare const CustomDialog: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

export declare const CustomInfoOperationTable: DefineComponent<globalThis.ExtractPropTypes<{
    data: {
        type: () => OperationData[];
        default: () => any[];
    };
    visible: {
        type: BooleanConstructor;
        default: boolean;
    };
    header: {
        type: StringConstructor;
        default: string;
    };
    position: {
        type: ObjectConstructor;
        required: false;
    };
    observationSupervisor: {
        type: StringConstructor;
        default: any;
    };
    statusType: {
        type: StringConstructor;
        default: string;
    };
    modalClass: {
        type: StringConstructor;
        default: string;
    };
    isAbono: {
        type: BooleanConstructor;
        default: boolean;
    };
    isLastColumnColor: {
        type: BooleanConstructor;
        default: boolean;
    };
    colorLastColumn: {
        type: StringConstructor;
        default: string;
    };
    operationType: {
        type: PropType_2<TransactionSelectItem>;
        default: number;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
    data: {
        type: () => OperationData[];
        default: () => any[];
    };
    visible: {
        type: BooleanConstructor;
        default: boolean;
    };
    header: {
        type: StringConstructor;
        default: string;
    };
    position: {
        type: ObjectConstructor;
        required: false;
    };
    observationSupervisor: {
        type: StringConstructor;
        default: any;
    };
    statusType: {
        type: StringConstructor;
        default: string;
    };
    modalClass: {
        type: StringConstructor;
        default: string;
    };
    isAbono: {
        type: BooleanConstructor;
        default: boolean;
    };
    isLastColumnColor: {
        type: BooleanConstructor;
        default: boolean;
    };
    colorLastColumn: {
        type: StringConstructor;
        default: string;
    };
    operationType: {
        type: PropType_2<TransactionSelectItem>;
        default: number;
    };
}>> & Readonly<{}>, {
    data: OperationData[];
    header: string;
    visible: boolean;
    modalClass: string;
    observationSupervisor: string;
    statusType: string;
    isAbono: boolean;
    isLastColumnColor: boolean;
    colorLastColumn: string;
    operationType: TransactionSelectItem;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const CustomInput: DefineComponent<globalThis.ExtractPropTypes<{
    modelValue: {
        type: (StringConstructor | NumberConstructor)[];
        default: string;
    };
    label: StringConstructor;
    type: {
        type: StringConstructor;
        default: string;
    };
    placeholder: {
        type: StringConstructor;
        default: string;
    };
    disabled: BooleanConstructor;
    icon: {
        type: StringConstructor;
        default: string;
    };
    iconPosition: {
        type: StringConstructor;
        default: string;
        validator: (value: string) => boolean;
    };
    inputClass: {
        type: StringConstructor;
        default: string;
    };
    labelClass: {
        type: StringConstructor;
        default: string;
    };
    allowLabelWrap: {
        type: BooleanConstructor;
        default: boolean;
    };
    required: {
        type: BooleanConstructor;
        default: boolean;
    };
    error: {
        type: StringConstructor;
        default: string;
    };
    minLength: {
        type: NumberConstructor;
        default: number;
    };
    maxLength: {
        type: NumberConstructor;
        default: number;
    };
    min: {
        type: (StringConstructor | NumberConstructor)[];
        default: any;
    };
    max: {
        type: (StringConstructor | NumberConstructor)[];
        default: any;
    };
    limitNumber: {
        type: NumberConstructor;
        default: number;
    };
    exactLengths: {
        type: () => number[];
        default: () => any[];
    };
    validationMode: {
        type: StringConstructor;
        default: string;
        validator: (value: string) => boolean;
    };
    helper: StringConstructor;
    eye: {
        type: BooleanConstructor;
        default: boolean;
    };
    clearable: {
        type: BooleanConstructor;
        default: boolean;
    };
    checkInput: {
        type: BooleanConstructor;
        default: boolean;
    };
    showRequiredLabel: {
        type: BooleanConstructor;
        default: any;
    };
    noErrorContainer: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (...args: any[]) => void;
    "blur-xs": (...args: any[]) => void;
    blur: (...args: any[]) => void;
    "icon-click": (...args: any[]) => void;
}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
    modelValue: {
        type: (StringConstructor | NumberConstructor)[];
        default: string;
    };
    label: StringConstructor;
    type: {
        type: StringConstructor;
        default: string;
    };
    placeholder: {
        type: StringConstructor;
        default: string;
    };
    disabled: BooleanConstructor;
    icon: {
        type: StringConstructor;
        default: string;
    };
    iconPosition: {
        type: StringConstructor;
        default: string;
        validator: (value: string) => boolean;
    };
    inputClass: {
        type: StringConstructor;
        default: string;
    };
    labelClass: {
        type: StringConstructor;
        default: string;
    };
    allowLabelWrap: {
        type: BooleanConstructor;
        default: boolean;
    };
    required: {
        type: BooleanConstructor;
        default: boolean;
    };
    error: {
        type: StringConstructor;
        default: string;
    };
    minLength: {
        type: NumberConstructor;
        default: number;
    };
    maxLength: {
        type: NumberConstructor;
        default: number;
    };
    min: {
        type: (StringConstructor | NumberConstructor)[];
        default: any;
    };
    max: {
        type: (StringConstructor | NumberConstructor)[];
        default: any;
    };
    limitNumber: {
        type: NumberConstructor;
        default: number;
    };
    exactLengths: {
        type: () => number[];
        default: () => any[];
    };
    validationMode: {
        type: StringConstructor;
        default: string;
        validator: (value: string) => boolean;
    };
    helper: StringConstructor;
    eye: {
        type: BooleanConstructor;
        default: boolean;
    };
    clearable: {
        type: BooleanConstructor;
        default: boolean;
    };
    checkInput: {
        type: BooleanConstructor;
        default: boolean;
    };
    showRequiredLabel: {
        type: BooleanConstructor;
        default: any;
    };
    noErrorContainer: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{
    "onUpdate:modelValue"?: (...args: any[]) => any;
    "onBlur-xs"?: (...args: any[]) => any;
    onBlur?: (...args: any[]) => any;
    "onIcon-click"?: (...args: any[]) => any;
}>, {
    modelValue: string | number;
    type: string;
    placeholder: string;
    disabled: boolean;
    icon: string;
    iconPosition: string;
    inputClass: string;
    labelClass: string;
    allowLabelWrap: boolean;
    required: boolean;
    error: string;
    minLength: number;
    maxLength: number;
    min: string | number;
    max: string | number;
    limitNumber: number;
    exactLengths: number[];
    validationMode: string;
    eye: boolean;
    clearable: boolean;
    checkInput: boolean;
    showRequiredLabel: boolean;
    noErrorContainer: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;

export declare const CustomInputNumber: DefineComponent<globalThis.ExtractPropTypes<{
    modelValue: {
        type: NumberConstructor[];
        default: any;
    };
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    inputClass: {
        type: StringConstructor;
        default: string;
    };
    minFractionDigits: {
        type: NumberConstructor;
        default: number;
    };
    maxFractionDigits: {
        type: NumberConstructor;
        default: number;
    };
    fluid: {
        type: BooleanConstructor;
        default: boolean;
    };
    size: {
        type: StringConstructor;
        default: string;
    };
    variant: {
        type: StringConstructor;
        default: string;
    };
    inputId: {
        type: StringConstructor;
        default: string;
    };
    placeholder: {
        type: StringConstructor;
        default: string;
    };
    label: {
        type: StringConstructor;
        default: string;
    };
    required: {
        type: BooleanConstructor;
        default: boolean;
    };
    labelClass: {
        type: StringConstructor;
        default: string;
    };
    allowLabelWrap: {
        type: BooleanConstructor;
        default: boolean;
    };
    isCurrency: {
        type: BooleanConstructor;
        default: boolean;
    };
    currency: {
        type: StringConstructor;
        default: string;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (value: number) => any;
}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
    modelValue: {
        type: NumberConstructor[];
        default: any;
    };
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    inputClass: {
        type: StringConstructor;
        default: string;
    };
    minFractionDigits: {
        type: NumberConstructor;
        default: number;
    };
    maxFractionDigits: {
        type: NumberConstructor;
        default: number;
    };
    fluid: {
        type: BooleanConstructor;
        default: boolean;
    };
    size: {
        type: StringConstructor;
        default: string;
    };
    variant: {
        type: StringConstructor;
        default: string;
    };
    inputId: {
        type: StringConstructor;
        default: string;
    };
    placeholder: {
        type: StringConstructor;
        default: string;
    };
    label: {
        type: StringConstructor;
        default: string;
    };
    required: {
        type: BooleanConstructor;
        default: boolean;
    };
    labelClass: {
        type: StringConstructor;
        default: string;
    };
    allowLabelWrap: {
        type: BooleanConstructor;
        default: boolean;
    };
    isCurrency: {
        type: BooleanConstructor;
        default: boolean;
    };
    currency: {
        type: StringConstructor;
        default: string;
    };
}>> & Readonly<{
    "onUpdate:modelValue"?: (value: number) => any;
}>, {
    modelValue: number;
    label: string;
    placeholder: string;
    disabled: boolean;
    inputClass: string;
    labelClass: string;
    allowLabelWrap: boolean;
    required: boolean;
    size: string;
    variant: string;
    fluid: boolean;
    minFractionDigits: number;
    maxFractionDigits: number;
    inputId: string;
    isCurrency: boolean;
    currency: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;

export declare const CustomLineChart: DefineComponent<globalThis.ExtractPropTypes<{
    clientId: {
        type: (StringConstructor | NumberConstructor)[];
        default: number;
    };
    title: {
        type: StringConstructor;
        default: string;
    };
    buttons: {
        type: () => ChartButton[];
        default: () => {
            id: number;
            label: string;
            class: string;
        }[];
    };
    buttonsPosition: {
        type: () => "top" | "bottom" | "none";
        default: string;
        validator: (value: string) => boolean;
    };
    chartContainerClass: {
        type: StringConstructor;
        default: string;
    };
    chartConfig: {
        type: ObjectConstructor;
        default: () => {
            strokeWidth: number;
            strokeColor: string;
            panX: boolean;
            panY: boolean;
            wheelX: string;
            wheelY: string;
        };
    };
    useForexService: {
        type: BooleanConstructor;
        default: boolean;
    };
    customDataSource: {
        type: FunctionConstructor;
        default: any;
    };
    staticData: {
        type: () => ChartData[];
        default: () => any[];
    };
    enableDarkTheme: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    error: (error: any) => any;
    buttonClick: (button: ChartButton, range: string | number) => any;
    dataLoaded: (data: ChartData[]) => any;
    chartCreated: (chart: any) => any;
}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
    clientId: {
        type: (StringConstructor | NumberConstructor)[];
        default: number;
    };
    title: {
        type: StringConstructor;
        default: string;
    };
    buttons: {
        type: () => ChartButton[];
        default: () => {
            id: number;
            label: string;
            class: string;
        }[];
    };
    buttonsPosition: {
        type: () => "top" | "bottom" | "none";
        default: string;
        validator: (value: string) => boolean;
    };
    chartContainerClass: {
        type: StringConstructor;
        default: string;
    };
    chartConfig: {
        type: ObjectConstructor;
        default: () => {
            strokeWidth: number;
            strokeColor: string;
            panX: boolean;
            panY: boolean;
            wheelX: string;
            wheelY: string;
        };
    };
    useForexService: {
        type: BooleanConstructor;
        default: boolean;
    };
    customDataSource: {
        type: FunctionConstructor;
        default: any;
    };
    staticData: {
        type: () => ChartData[];
        default: () => any[];
    };
    enableDarkTheme: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{
    onError?: (error: any) => any;
    onButtonClick?: (button: ChartButton, range: string | number) => any;
    onDataLoaded?: (data: ChartData[]) => any;
    onChartCreated?: (chart: any) => any;
}>, {
    title: string;
    clientId: string | number;
    buttons: ChartButton[];
    buttonsPosition: "top" | "bottom" | "none";
    chartContainerClass: string;
    chartConfig: Record<string, any>;
    useForexService: boolean;
    customDataSource: Function;
    staticData: ChartData[];
    enableDarkTheme: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {
    chartDiv: HTMLDivElement;
}, HTMLDivElement>;

export declare const CustomModalConfirm: DefineComponent<globalThis.ExtractPropTypes<{
    visible: BooleanConstructor;
    closable: BooleanConstructor;
    header: StringConstructor;
    description: StringConstructor;
    modalClass: StringConstructor;
    icon: {
        type: StringConstructor;
        default: string;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:visible": (...args: any[]) => void;
    handleContinue: (...args: any[]) => void;
    handleDelete: (...args: any[]) => void;
}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
    visible: BooleanConstructor;
    closable: BooleanConstructor;
    header: StringConstructor;
    description: StringConstructor;
    modalClass: StringConstructor;
    icon: {
        type: StringConstructor;
        default: string;
    };
}>> & Readonly<{
    "onUpdate:visible"?: (...args: any[]) => any;
    onHandleContinue?: (...args: any[]) => any;
    onHandleDelete?: (...args: any[]) => any;
}>, {
    icon: string;
    visible: boolean;
    closable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const CustomModalInfoTable: DefineComponent<globalThis.ExtractPropTypes<{
    items: ObjectConstructor;
    visible: BooleanConstructor;
    closable: BooleanConstructor;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:visible": (...args: any[]) => void;
}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
    items: ObjectConstructor;
    visible: BooleanConstructor;
    closable: BooleanConstructor;
}>> & Readonly<{
    "onUpdate:visible"?: (...args: any[]) => any;
}>, {
    visible: boolean;
    closable: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const CustomMultiButton: DefineComponent<__VLS_Props_2, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    changeList: (...args: any[]) => void;
}, string, PublicProps, Readonly<__VLS_Props_2> & Readonly<{
    onChangeList?: (...args: any[]) => any;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export { CustomMultiSelect }

export declare const CustomPersonalData: DefineComponent<globalThis.ExtractPropTypes<{
    secuency: {
        type: StringConstructor;
        default: any;
    };
    companyName: {
        type: StringConstructor;
        default: string;
    };
    balance: {
        type: PropType_2<Balance[]>;
        default: () => any[];
    };
    loading: {
        type: BooleanConstructor;
        default: boolean;
        required: false;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
    "secuency-change": (value: number) => any;
}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
    secuency: {
        type: StringConstructor;
        default: any;
    };
    companyName: {
        type: StringConstructor;
        default: string;
    };
    balance: {
        type: PropType_2<Balance[]>;
        default: () => any[];
    };
    loading: {
        type: BooleanConstructor;
        default: boolean;
        required: false;
    };
}>> & Readonly<{
    "onSecuency-change"?: (value: number) => any;
}>, {
    secuency: string;
    loading: boolean;
    companyName: string;
    balance: Balance[];
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export { CustomPie }

export { CustomRadioButton }

export { CustomSelect }

export declare const CustomSelectCountry: DefineComponent<globalThis.ExtractPropTypes<{
    options: {
        type: ArrayConstructor;
        default: any[];
    };
    optionLabel: {
        type: StringConstructor;
        default: any;
    };
    optionValue: {
        type: StringConstructor;
        default: any;
    };
    placeholder: {
        type: StringConstructor;
        default: string;
    };
    selectClass: {
        type: StringConstructor;
        default: string;
    };
    labelClass: {
        type: StringConstructor;
        default: string;
    };
    size: {
        type: StringConstructor;
        default: string;
    };
    label: {
        type: StringConstructor;
        required: false;
        default: string;
    };
    required: {
        type: BooleanConstructor;
        default: boolean;
    };
    filter: {
        type: BooleanConstructor;
        default: boolean;
    };
    filterMatchMode: {
        type: () => "startsWith" | "contains" | "endsWith";
        default: string;
        validator: (value: string) => boolean;
    };
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    customOption: {
        type: BooleanConstructor;
        default: boolean;
        required: false;
    };
    baseUrl: {
        type: StringConstructor;
    };
    error: {
        type: StringConstructor;
        default: string;
    };
    helper: {
        type: StringConstructor;
        default: string;
    };
    allowLabelWrap: {
        type: BooleanConstructor;
        default: boolean;
    };
    validationMode: {
        type: () => "onChange" | "onBlur" | "manual";
        default: string;
        validator: (value: string) => boolean;
    };
    modelValue: {
        type: globalThis.PropType<CountryOption>;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:modelValue": (value: CountryOption) => any;
} & {
    change: (event: any) => any;
}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
    options: {
        type: ArrayConstructor;
        default: any[];
    };
    optionLabel: {
        type: StringConstructor;
        default: any;
    };
    optionValue: {
        type: StringConstructor;
        default: any;
    };
    placeholder: {
        type: StringConstructor;
        default: string;
    };
    selectClass: {
        type: StringConstructor;
        default: string;
    };
    labelClass: {
        type: StringConstructor;
        default: string;
    };
    size: {
        type: StringConstructor;
        default: string;
    };
    label: {
        type: StringConstructor;
        required: false;
        default: string;
    };
    required: {
        type: BooleanConstructor;
        default: boolean;
    };
    filter: {
        type: BooleanConstructor;
        default: boolean;
    };
    filterMatchMode: {
        type: () => "startsWith" | "contains" | "endsWith";
        default: string;
        validator: (value: string) => boolean;
    };
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    customOption: {
        type: BooleanConstructor;
        default: boolean;
        required: false;
    };
    baseUrl: {
        type: StringConstructor;
    };
    error: {
        type: StringConstructor;
        default: string;
    };
    helper: {
        type: StringConstructor;
        default: string;
    };
    allowLabelWrap: {
        type: BooleanConstructor;
        default: boolean;
    };
    validationMode: {
        type: () => "onChange" | "onBlur" | "manual";
        default: string;
        validator: (value: string) => boolean;
    };
    modelValue: {
        type: globalThis.PropType<CountryOption>;
    };
}>> & Readonly<{
    "onUpdate:modelValue"?: (value: CountryOption) => any;
    onChange?: (event: any) => any;
}>, {
    label: string;
    placeholder: string;
    disabled: boolean;
    labelClass: string;
    allowLabelWrap: boolean;
    required: boolean;
    error: string;
    validationMode: "onBlur" | "manual" | "onChange";
    helper: string;
    filter: boolean;
    size: string;
    options: unknown[];
    optionLabel: string;
    optionValue: string;
    filterMatchMode: "endsWith" | "startsWith" | "contains";
    selectClass: string;
    customOption: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;

export { CustomStepper }

export { CustomSwitch }

export declare const CustomTabs: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;

export { CustomTextArea }

export { CustomToast }

export declare const CustomUploadExcel: DefineComponent<globalThis.ExtractPropTypes<{
    data: {
        type: ObjectConstructor;
        required: true;
    };
    disabled: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    handleLoadData: (...args: any[]) => void;
    removeFile: (...args: any[]) => void;
    enableItem: (...args: any[]) => void;
}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
    data: {
        type: ObjectConstructor;
        required: true;
    };
    disabled: {
        type: BooleanConstructor;
        required: false;
        default: boolean;
    };
}>> & Readonly<{
    onHandleLoadData?: (...args: any[]) => any;
    onRemoveFile?: (...args: any[]) => any;
    onEnableItem?: (...args: any[]) => any;
}>, {
    disabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare interface dataForexcharLine {
    date: number;
    value: number;
}

export declare const DetailsCard: DefineComponent<globalThis.ExtractPropTypes<{
    data: {
        type: ObjectConstructor;
        default: () => void;
    };
    banksList: {
        type: ArrayConstructor;
        default: () => any[];
    };
    isAnalist: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
    data: {
        type: ObjectConstructor;
        default: () => void;
    };
    banksList: {
        type: ArrayConstructor;
        default: () => any[];
    };
    isAnalist: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{}>, {
    data: Record<string, any>;
    isAnalist: boolean;
    banksList: unknown[];
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;

declare type DollarValue = {
    value: number;
    timestamp: string;
};

export declare interface DuplicatedAccount {
    rut: string;
    fullName: string;
    accountNumber: string;
    bankName: string;
}

export declare interface DuplicatedAccountResult {
    isDuplicated: boolean;
    accountDuplicated?: Accounts;
}

export declare interface DuplicatedSingleAccount {
    bankName: string;
    accountType?: any;
    accountNumber: string;
}

export declare interface EnvConfig {
    apiURL: string;
    env: EnvName;
}

declare type EnvName = EnvNames.PROD | EnvNames.DEV;

export declare enum EnvNames {
    PROD = "production",
    DEV = "development"
}

declare interface executive {
    executiveName: string;
    executiveEmail: string;
    executivePhone: string;
}

declare type FeatureFlag = "hito_1" | "hito_2" | "hito_3";

export declare interface fertilizerCharges {
    fertilizers: number;
    charges: number;
}

export { FontAwesomeIcon }

declare type Forex = {
    heritageTotal: number;
    chart: ChartData_2[];
};

declare type forex = {
    heritageTotal: number;
    chart: chartData[];
};

export declare class ForexChartService {
    getForexChartData(clientId: number, buttonType: number, dateRange?: {
        startDate?: number;
        endDate?: number;
    }): Promise<{
        data: ChartDataPoint[];
    }>;
}

export declare type forexDataTable = {
    id: number;
    client_id: number;
    date: string;
    movement: string;
    currency: string;
    amount: string;
    exange_type: string;
    aproved_by: string;
    detail: string;
    status: string;
};

export declare interface forexList {
    id: number;
    clientId: number;
    date: string;
    movement: Movement;
    exchangeAmount: number;
    currency: Movement;
    amount: number;
    clpAmount: number;
    approvedBy: string;
    detail: string;
}

export declare class forexOperationsService {
    getUSDPoints(): Promise<mainCurrencyData>;
    getOpenPrice(): Promise<openPrice>;
    getRandomNumberInRange(min: number, max: number): number;
}

export declare class fxSpreadService {
    getSpreadList(): Promise<spreadList[]>;
    updateSpread(spread: spreadList[]): Promise<spreadList[]>;
}

export declare class fxTradingService {
    getButtonCentList(): Promise<buttonCent[]>;
    getSpotOperations(): Promise<spotOperations[]>;
    getSpotForwardOperations(): Promise<spotForwardOperations[]>;
    getOtherCurrenciesOperations(): Promise<otherCurrenciesOperations[]>;
    getManualOperations(): Promise<manualOperations[]>;
    getTradingData(): Promise<spotOperations[]>;
}

export declare interface GeneralCountry {
    id: number;
    status: boolean;
    name: string;
    codName: string;
    blockType: string;
}

export declare interface GeneralOperationType {
    name: string;
    type: string;
    amountClp: number;
    amountUsd: number;
    amountEur: number;
}

export declare const getColorClass: (value: number) => string;

export declare function getEnvConfig(): EnvConfig;

export declare class heritageChartService {
    getHeritageData(clientId: number): Promise<accountData[]>;
    getHeritageById(accountId: number): Promise<accountData | null>;
    getFirstHeritage(clientId: number): Promise<accountData | null>;
}

export declare class heritageService {
    myEmployeeList(clientId: number): Promise<company[]>;
    getEmployeeId(companyId: number): Promise<company | null>;
    getFirstEmployee(clientId: number): Promise<company | null>;
    getForexData(clientId: number): Promise<forexDataTable[]>;
    getInvestmentsData(clientId: number): Promise<investmentsDataTable[]>;
    getAllData(clientId: number): Promise<movementList[]>;
}

declare type IconPos = "left" | "right";

declare type IconType = "icon" | "image";

export declare interface IdDescription {
    id: number;
    description: string;
}

/**
 * @description Inicializa la redirección de rutas
 */
export declare function initRedirect(): void;

export declare interface intermediaryAccount {
    name: string;
    account: string;
    accountType: string;
    swift: string;
    aba: string;
}

export declare interface InTransitFunds {
    clp: number;
    usd: number;
    eur?: number | null;
    mutualFundsClp?: number | null;
    mutualFundsUsd?: number | null;
}

declare interface InTransitFunds_2 {
    clp: number;
    usd: number;
    eur?: number | null;
    mutualFundsClp?: number | null;
    mutualFundsUsd?: number | null;
}

declare type Investments = {
    heritageTotal: number;
    chart: ChartData_2[];
};

declare type investments = {
    heritageTotal: number;
    chart: chartData[];
};

export declare type investmentsDataTable = {
    id: number;
    client_id: number;
    date: string;
    movement: string;
    detail: string;
    aproved_by: string;
    amount: string;
    status: string;
};

/**
 * @description Determina si la ruta es la ruta del cliente o usuario
 * @returns {string} "clients" | "users"
 */
export declare function isClientOrUser(): "clients" | "users";

/**
 * @description Determina si la ruta es la ruta del cliente o usuario
 * @returns {string} "clients" | "users"
 */
export declare function isLocalHost(): boolean;

export declare interface lastMovement {
    id: number;
    clientId: number;
    listType: number;
    date: string;
    movement: string;
    amount?: number;
    comment?: string;
    approvedBy: string;
    currency: CurrencyType;
    operationType: operationType;
    changeTypeAmount?: number;
    amountCLP?: number;
    observation?: string;
    thirdBank?: string;
    thirdName?: string;
    details?: string;
    status: Status;
    file?: string[];
}

export declare interface legalList {
    id: number;
    clientName: string;
    clientRut: string;
    amount: number;
    currencyType: {
        id: number;
        description: string;
    };
    file: string;
    status: {
        id: number;
        description: string;
    };
    observationLegal?: string;
    isDateExecution?: boolean;
    dateExecution?: string;
    isValidDateNow: boolean;
}

export declare class LegalService {
    getLegalOperations(page: number, pageSize: number, clientNameFilter: string, currencyFilter: number | null, statusFilter: number | null): Promise<{
        data: legalList[];
        total: number;
    }>;
    getLegalOperationsByStatus(statusId?: number): Promise<{
        data: any[];
    }>;
}

export declare const MainCard: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;

export declare interface mainCurrencyData {
    alertBuyPrice: number;
    alertSellPrice: number;
    porcentualChange: string;
    dayVariation: string;
}

export { MainTable }

export declare interface manualOperations {
    rut: string;
    name: string;
    sec: string;
    time: string;
    cv: string;
    amountUSD: string;
    price: string;
    priceTrf: string;
    paymentCondition: string;
    banker: string;
}

export declare const ModalAutorization: DefineComponent<globalThis.ExtractPropTypes<{
    visible: BooleanConstructor;
    data: ObjectConstructor;
    header: StringConstructor;
    fileList: BooleanConstructor;
    description: StringConstructor;
    icon: StringConstructor;
    iconColor: StringConstructor;
    borderModal: StringConstructor;
    modalClass: StringConstructor;
    buttonType: {
        type: () => string[];
        default: () => any[];
    };
    closable: BooleanConstructor;
    realoadPage: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:visible": (...args: any[]) => void;
    onAccept: (...args: any[]) => void;
}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
    visible: BooleanConstructor;
    data: ObjectConstructor;
    header: StringConstructor;
    fileList: BooleanConstructor;
    description: StringConstructor;
    icon: StringConstructor;
    iconColor: StringConstructor;
    borderModal: StringConstructor;
    modalClass: StringConstructor;
    buttonType: {
        type: () => string[];
        default: () => any[];
    };
    closable: BooleanConstructor;
    realoadPage: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{
    "onUpdate:visible"?: (...args: any[]) => any;
    onOnAccept?: (...args: any[]) => any;
}>, {
    visible: boolean;
    closable: boolean;
    fileList: boolean;
    buttonType: string[];
    realoadPage: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const ModalAutorizationOperation: DefineComponent<globalThis.ExtractPropTypes<{
    data: {
        type: ObjectConstructor;
        default: () => {};
    };
    visible: BooleanConstructor;
    header: StringConstructor;
    description: StringConstructor;
    icon: StringConstructor;
    iconColor: StringConstructor;
    borderModal: StringConstructor;
    modalClass: StringConstructor;
    buttonType: {
        type: PropType_2<string[]>;
        default: () => any[];
    };
    closable: BooleanConstructor;
    isRejected: BooleanConstructor;
    isCircle: BooleanConstructor;
    isCorrected: BooleanConstructor;
    iconDescription: StringConstructor;
    iconDescriptionColor: StringConstructor;
    textStyle: StringConstructor;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:visible": (...args: any[]) => void;
    sendOperation: (...args: any[]) => void;
}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
    data: {
        type: ObjectConstructor;
        default: () => {};
    };
    visible: BooleanConstructor;
    header: StringConstructor;
    description: StringConstructor;
    icon: StringConstructor;
    iconColor: StringConstructor;
    borderModal: StringConstructor;
    modalClass: StringConstructor;
    buttonType: {
        type: PropType_2<string[]>;
        default: () => any[];
    };
    closable: BooleanConstructor;
    isRejected: BooleanConstructor;
    isCircle: BooleanConstructor;
    isCorrected: BooleanConstructor;
    iconDescription: StringConstructor;
    iconDescriptionColor: StringConstructor;
    textStyle: StringConstructor;
}>> & Readonly<{
    "onUpdate:visible"?: (...args: any[]) => any;
    onSendOperation?: (...args: any[]) => any;
}>, {
    data: Record<string, any>;
    visible: boolean;
    closable: boolean;
    buttonType: string[];
    isRejected: boolean;
    isCircle: boolean;
    isCorrected: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare type Money = "USD" | "CLP" | "EUR";

declare interface Movement {
    id: number;
    description: string;
}

export declare interface movementList {
    id: number;
    clientId: number;
    date: string;
    movement: Movement;
    currency: string;
    amount: number;
    beneficiary: string;
    beneficiaryBank: string;
    approvedBy?: string;
    boucherFile?: string;
    status: Status;
    comment?: string;
}

export declare class movementService {
    myMovementList(clientId: number, page: number, size: number, filters: any): Promise<{
        data: movementList[];
        total: number;
    }>;
    myContributionsList(clientId: number, page: number, size: number, filters: any): Promise<{
        data: contributionList[];
        total: number;
    }>;
    myForexList(clientId: number, page: number, size: number, filters: any): Promise<{
        data: forexList[];
        total: number;
    }>;
    getOperationTypeList(currentView: string): Promise<{
        data: operationType[];
    }>;
    getOperationStatusList(): Promise<{
        data: operationStatus[];
    }>;
    getLastMovement(clientId: number, page: number, size: number, type: number): Promise<{
        data: lastMovement[];
        total: number;
    }>;
}

export declare interface movementType {
    label: string;
    items: movementTypeItem[];
}

export declare interface movementTypeItem {
    id: number;
    description: string;
}

export declare class movementTypeService {
    getMovementTypeList(): Promise<{
        data: movementType[];
    }>;
}

export declare interface myAlertsData {
    total: number;
    totalPages: number;
    page: number;
    pageSize: number;
    alerts: alertList[];
}

export declare class MyAlertsService {
    getMyAlertsFile(clientId: number, filters: any): Promise<{
        data: myAlertsData;
    }>;
    getNotificationTypes(): Promise<typeNotification[]>;
    getMyAlerts(clientId: number, page: number, size: number, filters: any): Promise<{
        data: myAlertsData;
    }>;
}

export { ObservationCard }

export declare function onMessage(callback: (data: DollarValue) => void): void;

export declare interface openPrice {
    latestPrice: string;
    openPrice: string;
    date: string;
}

declare type Operation = "Abonos" | "Cargos" | "Transferencias";

export declare interface operation {
    typeOperation: valute;
    operation: string;
    amount: number;
    currencyValue: number;
    baseCurrency: string;
    quoteCurrency: string;
    isInstruct: boolean | null;
}

declare interface OperationData {
    correctionDate?: string;
    amount?: number;
    bankCrediCorp?: BankCrediCorp;
    analistName?: string;
    supervisorName?: string;
    [key: string]: any;
}

export declare interface operationDetails {
    correctionDate: string;
    amount?: number;
    crediCoprBank: bankData;
    analistName?: string;
    supervisorName?: string;
}

export declare interface operations {
    id: number;
    dateTime: string;
    rut: string;
    clientName: string;
    amount: number;
    amountInAccount: number;
    operationType: number;
    statusType: AnalystCurrencyType;
    observationAnalyst?: string;
    observationSupervisor?: string;
    rejectionReason?: string;
    paymentMethod: string;
    thirdPartyPayment: boolean;
    thirdPartyName?: string;
    thirdPartyRut?: string;
    clientComment?: string;
    analistName?: string;
    supervisorName?: string;
    file?: string;
    status: number;
    reference?: string;
    transactionType: number;
    currencyType: number;
    secuency: number;
    folio: number;
    client: string;
    deleteOperation?: boolean;
    commercialManager?: string;
    resourcesOrigin?: ResourcesOrigin;
    bankOriginResource?: bankData;
    crediCoprBank?: bankData;
    intermediaryBank?: bankData;
    thirdParty?: clientData;
    clientData?: clientData;
    operationDetails?: operationDetails[];
}

export declare class operationService {
    getOperationStateList(operationType: number): Promise<{
        data: survey[];
    }>;
}

export declare interface operationsList {
    id: number;
    clientId: number;
    date: string;
    operation: string;
    currency: string;
    totalAmountUSD: string;
    currencyPrice: string;
    totalAmountCLP: string;
    payCondition: string;
    client: string;
}

export declare interface operationStatus {
    id: number;
    description: string;
}

export declare interface operationType {
    id: number;
    description: string;
}

declare interface operationType_2 {
    id: number;
    description?: string;
    descriptionAdmin?: string;
}

export declare interface orderFxData {
    total: number;
    totalPages: number;
    page: number;
    pageSize: number;
    orderFx: orderFxList[];
}

export declare interface orderFxList {
    id: number;
    clientId: number;
    date: string;
    operation: string;
    currency: string;
    totalAmountUSD: string;
    currencyPrice: string;
    totalAmountCLP: string;
    payCondition: string;
    client: string;
    state: string;
}

export declare class orderFxService {
    getOrderFxFile(clientId: number, filters: any): Promise<orderFxData>;
    getOrderFx(clientId: number, page: number, size: number, filters: any): Promise<{
        data: orderFxData;
    }>;
}

export declare interface otherCurrenciesOperations {
    state: string;
    rut: string;
    name: string;
    sec: string;
    time: string;
    parity: string;
    cv: string;
    amount: string;
    priceCost: string;
    equivalentMount: string;
    amountUSD: string;
    paymentCondition: string;
    banker: string;
    folio: string;
}

export declare interface paymentMethod {
    id: number;
    description: string;
}

export declare class paymentMethodsService {
    getPaymentMethodsList(): Promise<{
        data: paymentMethod[];
    }>;
}

declare interface Permissions_2 {
    activo: number;
    nombrePermiso: string;
    nombreRol: string;
    permisoId: number;
    rolId: number;
}
export { Permissions_2 as Permissions }

declare interface Profile_2 {
    id: number;
    name: string;
    [key: string]: any;
}
export { Profile_2 as Profile }

declare interface Props {
    label?: string;
    placeholder?: string;
    inputClass?: string;
    required?: boolean;
    modelValue?: string;
    clientId?: number;
}

declare interface Props_2 {
    label?: string;
    placeholder?: string;
    inputClass?: string;
    required?: boolean;
    modelValue?: string;
}

export declare interface rangeForexGraficLine {
    id: number;
    description: string;
}

export declare function removeMessageListener(callback: (data: DollarValue) => void): void;

export declare interface reportFxData {
    total: number;
    totalPages: number;
    page: number;
    pageSize: number;
    reports: reportFxList[];
}

export declare interface reportFxList {
    id: number;
    expireAt: string;
    date: string;
    time: string;
    userRut: string;
    userName: string;
    secuence: string;
    status: string;
    state: string;
    mountUSD: number;
    priceCost: number;
    priceClient: number;
    fwdPointCost: number;
    fwdPointClient: number;
    mount: number;
    utilityPL: number;
    termDays: number;
    modality: string;
    paymentCondition: string;
    typeOperation: string;
    folio: number;
    bankerRut: string;
    bankerName: string;
    trader: string;
    operation: string;
}

export declare class ReportFxService {
    getReportFxFile(filters: any): Promise<reportFxData>;
    getBankersByName(name: string): Promise<string[]>;
    getBankersByRut(rut: string): Promise<string[]>;
    getReportFx(filters: any, page?: number, size?: number): Promise<{
        data: reportFxData;
    }>;
}

export declare interface representativeList {
    id: number;
    clientId: number;
    fullName: string;
    rut: string;
    email: string;
    phone: number;
    class?: string;
    atribute?: string;
    representantiveType: number;
}

export declare class representativeService {
    representativeList(clientId: number, representantiveType: number, currentPage: number, rowPage: number): Promise<{
        data: representativeList[];
        total: number;
    }>;
}

export declare interface ResourcesOrigin {
    id: number;
    bankDetails: bankData;
    country: AnalystCountry;
}

declare interface Response_2<T> {
    code: number;
    data: T;
    success: boolean;
}
export { Response_2 as Response }

export declare interface riskData {
    total: number;
    totalPages: number;
    page: number;
    pageSize: number;
    risks: risksList[];
}

export declare interface riskQuotaDaily {
    settlement: riskSettlement;
    req: riskReq;
}

export declare interface riskReq {
    mountValue: string;
    validity: number;
    updatedAt: string;
}

export declare interface riskSettlement {
    mountValue: string;
    validity: number;
    updatedAt: string;
}

export declare interface risksList {
    id: number;
    createdAt: string;
    updatedAt: string;
    expireAt: string;
    status: string;
    userCreate: string;
    userUpdated: string;
    segment: string;
    clientName: string;
    clientRut: string;
    quotaPortal: string;
    quotaSettlement: string;
    quotaReq: string;
    quotaDaily: riskQuotaDaily;
}

export declare interface RoleAD {
    rolid: number;
    nombrerol: string;
}

export declare function rutFormatter(rut: string): string;

declare interface SecuencyData {
    id: number;
    description: string;
    first?: boolean;
}

export declare interface secuencyData {
    id: number;
    description: string;
    first?: boolean;
}

export declare interface secundaryCurrencyData {
    latestObservedPrice: string;
    porcentualChange: string;
    dayVariation: string;
}

export declare interface SegmentItem {
    status: IdDescription;
    rut: string;
    name: string;
    sec: IdDescription;
    time: string;
    cv: IdDescription;
    amountUSD: number;
    costPrice: number;
    clientPrice: number;
    amountCLP: number;
    profit?: number;
    paymentCondition: IdDescription;
    folio: number | null;
    banker: string;
}

export declare function sendMessage(data: any): void;

export declare interface ShowTokenB2C {
    token: string;
}

export declare interface ShowUser {
    id: string;
    fullName: string;
    user: string;
}

declare type SliceSettings = {
    fill: string;
    stroke: string;
};

declare type sliceSettings = {
    fill: string;
    stroke: string;
};

export declare interface SpotCloseSegmentContent {
    totalOPDia: number;
    totalPurchaseAmount: number;
    totalSaleAmount: number;
    profit: number;
    segments: SegmentItem[];
}

export declare class spotCloseSegmentService {
    getSpotCloseSegmentData(): Promise<{
        data: SpotCloseSegmentContent;
    }>;
    getSegmentsByState(stateId: number): Promise<{
        data: SpotCloseSegmentContent;
    }>;
}

export declare class spotForwadSegmentService {
    getSpotForwardSegmentData(): Promise<{
        data: SpotForwardSegmentContent;
    }>;
}

export declare interface SpotForwardOperation {
    dinamicState: string;
    status: string;
    rut: string;
    name: string;
    sec: string;
    time: string;
    cv: string;
    amountUSD: string;
    priceCost: string;
    clientPrice: string;
    fwdPointCost: string;
    fwdPointClient: string;
    utilityPL: string;
    termDays: string;
    expirationDate: string;
    mode: string;
    banker: string;
    paymentCondition: string;
    folio: string;
}

export declare interface spotForwardOperations {
    dinamicState: string;
    status: string;
    rut: string;
    name: string;
    sec: string;
    time: string;
    cv: string;
    amountUSD: string;
    priceCost: string;
    clientPrice: string;
    fwdPointCost: string;
    fwdPointClient: string;
    utilityPL: string;
    termDays: string;
    expirationDate: string;
    mode: string;
    banker: string;
    paymentCondition: string;
    folio: string;
    puntosFwdCosto?: string;
}

export declare interface SpotForwardSegmentContent {
    success: boolean;
    code: number;
    data: SpotForwardOperation[];
}

export declare interface spotOperations {
    state?: string;
    rut: string;
    name: string;
    sec: string;
    time: string;
    cv: string;
    amountUSD: string;
    priceCost: string;
    paymentCondition?: string;
    banker: string;
    folio: string;
}

export declare interface spreadList {
    id: number;
    amount: string;
    bid: number;
    offer: number;
}

declare interface Status {
    id: number;
    description: string;
}

export declare interface statusList {
    transfers: statusType[];
    payment: statusType[];
}

/**
 * @description clase para obtener los estados de transferencias y pagos
 */
export declare class statusService {
    private data;
    /**
     * @description aplica filtros a una lista de estados
     * @param list
     * @param code
     * @param name
     * @param rol
     * @returns
     */
    private applyFilters;
    /**
     * @description obtiene los codigos de transferencias y pagos, por codigo, nombre y rol
     * @param code
     * @param name
     * @param rol
     * @param type
     * @example getOnlyCodes("XTI", "Pendiente", "Cliente")
     * @example2 getOnlyCodes("PAG", "Pagado", null, "payment")
     * @returns ['XTI', 'PAG', 'PEN']
     */
    getOnlyCodes(code?: string | null, name?: string | null, rol?: string | null, type?: "transfer" | "payment" | "all"): string[];
    /**
     * @description obtiene todos los estados, por codigo, nombre y rol
     * @param code
     * @param name
     * @param rol
     * @returns
     */
    getAll(code?: string | null, name?: string | null, rol?: string | null): statusType[];
    /**
     * @description obtiene los estados de transferencias, por codigo, nombre y rol
     * @param code  codigo de la estado
     * @param name  nombre de la estado
     * @param rol   rol del estado
     * @returns
     * @example getTransfers("XTI", "Pendiente", "Cliente")
     * @onExit [{
     *   "code": "XTI",
     *   "name": "Pendiente",
     *   "rol": ["Cliente"]
     * }]
     */
    getTransfers(code?: string | null, name?: string | null, rol?: string | null): statusType[];
    /**
     * @description obtiene los estados de pagos, por codigo, nombre y rol
     * @param code  codigo del estado
     * @param name  nombre del estado
     * @param rol   rol del estado
     * @example getPayments("XAI", "Pendiente", "Analista")
     * @returns [{
     *   "code": "XAI",
     *   "name": "Abono Ingresado",
     *   "rol": ["Cliente", "Apoderado", "Banquero"]
     * }]
     */
    getPayments(code?: string | null, name?: string | null, rol?: string | null): statusType[];
}

export declare interface statusType {
    code: string;
    name: string;
    rol: string[];
}

export declare interface survey {
    id: number;
    description: string;
}

export declare class surveyService {
    getSurveyList(): Promise<{
        data: survey[];
    }>;
}

declare interface SystemStatusItem_2 {
    id: number;
    tipoEntidad: string;
    codigoEntidad: string;
    comportamiento: string;
    activo: number;
    descripcion: string;
    fechaCreacion: string;
    fechaModificacion: string;
}
export { SystemStatusItem_2 as SystemStatusItem }

declare interface TabItem {
    title: string;
    value: string;
    content: string;
    style?: string;
    icon?: string;
}

export declare interface thirdOperation {
    id: number;
    dateTime: string;
    clientName: string;
    clientRUT: string;
    thirdName: string;
    thirdRUT: string;
    thirdType: operationType_2;
    survey: operationType_2[];
    thirdCountry: Country;
    bankAdress: string;
    bankCity: string;
    bankCountry: Country;
    blockReason?: string;
    status: operationType_2;
    reasonBlock?: string;
}

export { ThirdPartyCard }

export declare interface TradingTotalsResponse {
    purchasesUSD: number;
    salesUSD: number;
    mismatchUSD: number;
    totalPurchases: number;
    totalSales: number;
    grandTotal: number;
}

declare interface TransactionSelectItem {
    id: number;
    label: `${Operation} ${Money}`;
    money: Money;
    operation: Operation;
    operations: number[];
}

export declare class transactionService {
    getTransactionTypeList(type?: number): Promise<{
        data: survey[];
    }>;
    getOperationAbonoList(): Promise<{
        data: survey[];
    }>;
}

export declare interface transferPending {
    id: number;
    clientId: number;
    operationNumber: string;
    admissionDate: string;
    paymentDate: string;
    sourceSequence: string;
    currencyType: number;
    creator: string;
    paymentMethod: string;
    transferType: string;
    totalOperations: number;
    totalAmount?: number;
    status: {
        id: number;
        description: string;
    };
    detailData: transferPendingDetailItem[];
}

export declare interface transferPendingDetailItem {
    id: number;
    transferPendingId: number;
    beneficiary: string;
    beneficiaryRut: string;
    beneficiaryBank: string;
    beneficiaryBankAccount: string;
    beneficiarySwift?: string;
    beneficiaryAba?: string;
    intermediaryBank?: string;
    intermediaryBankAccount?: string;
    intermediarySwift?: string;
    intermediaryAba?: string;
    country: string;
    movementType: string;
    currencyType: number;
    amount: number;
    comment: string;
    status: {
        id: number;
        description: string;
    };
    file?: string;
}

export declare class transferService {
    transferAccountList(clientId: number): Promise<{
        beneficiaryList: clientList[];
        myAccountList: clientList[];
    }>;
    getTransferById(clientId: number, transferStatus: number, page?: number, size?: number): Promise<{
        data: transferPending[];
        total: number;
    }>;
}

export declare interface typeNotification {
    id: number;
    name: string;
}

declare interface UpdateStatusPayload_2 {
    ids: number[];
    activo: number;
}
export { UpdateStatusPayload_2 as UpdateStatusPayload }

export declare const UploadFileDialog: DefineComponent<globalThis.ExtractPropTypes<{
    title: StringConstructor;
    visible: BooleanConstructor;
    disabled: BooleanConstructor;
    uploadButtonLabel: {
        type: StringConstructor;
        default: string;
    };
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    "update:visible": (...args: any[]) => void;
    onFileSelected: (...args: any[]) => void;
    onUploadFile: (...args: any[]) => void;
    onExcelUpload: (...args: any[]) => void;
}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
    title: StringConstructor;
    visible: BooleanConstructor;
    disabled: BooleanConstructor;
    uploadButtonLabel: {
        type: StringConstructor;
        default: string;
    };
}>> & Readonly<{
    "onUpdate:visible"?: (...args: any[]) => any;
    onOnFileSelected?: (...args: any[]) => any;
    onOnUploadFile?: (...args: any[]) => any;
    onOnExcelUpload?: (...args: any[]) => any;
}>, {
    disabled: boolean;
    visible: boolean;
    uploadButtonLabel: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const useAccountTypesStore_2: StoreDefinition<"accountTypes", Pick<{
    accountTypes: globalThis.Ref<{
        id: number;
        description: string;
    }[], accountType[] | {
        id: number;
        description: string;
    }[]>;
    setAccountTypes: (types: accountType[]) => void;
    clearAccountTypes: () => void;
    getAccountTypes: () => accountType[];
}, "accountTypes">, Pick<{
    accountTypes: globalThis.Ref<{
        id: number;
        description: string;
    }[], accountType[] | {
        id: number;
        description: string;
    }[]>;
    setAccountTypes: (types: accountType[]) => void;
    clearAccountTypes: () => void;
    getAccountTypes: () => accountType[];
}, never>, Pick<{
    accountTypes: globalThis.Ref<{
        id: number;
        description: string;
    }[], accountType[] | {
        id: number;
        description: string;
    }[]>;
    setAccountTypes: (types: accountType[]) => void;
    clearAccountTypes: () => void;
    getAccountTypes: () => accountType[];
}, "setAccountTypes" | "clearAccountTypes" | "getAccountTypes">>;
export { useAccountTypesStore_2 as useAccountTypesStore }

declare const useAuthStore_2: StoreDefinition<"auth", Pick<{
    user: globalThis.Ref<{
        representanteId: number;
        representanteRut: string;
        representanteNombres: string;
        representanteApellidos: string;
        representanteFullName: string;
        representanteEmail: string;
        representanteTelefono: string;
        representanteDescripcion: string;
        clientes: {
            clienteId: number;
            clienteRut: string;
            clienteRazonsocial: string;
            clienterMail: string;
            clienterMail2: string;
            crTiporepresentacion: string;
            crRolesId: number;
            crTolnombre: string;
            crId: number;
        }[];
    }, UserB2C | {
        representanteId: number;
        representanteRut: string;
        representanteNombres: string;
        representanteApellidos: string;
        representanteFullName: string;
        representanteEmail: string;
        representanteTelefono: string;
        representanteDescripcion: string;
        clientes: {
            clienteId: number;
            clienteRut: string;
            clienteRazonsocial: string;
            clienterMail: string;
            clienterMail2: string;
            crTiporepresentacion: string;
            crRolesId: number;
            crTolnombre: string;
            crId: number;
        }[];
    }>;
    userAD: globalThis.Ref<{
        id: number;
        documento: string;
        nombre: string;
        email: string;
        fechacreacion: string;
        fechaCreacion?: string;
        activo: number;
        rolesidroles: number;
        rolesIdRoles?: number;
        rolid: number;
        rolesusuarioid: number[];
        nombresrolesusuario: string[];
        roles: {
            rolid: number;
            nombrerol: string;
        }[];
        clientes: {
            clienteId: number;
            clienteRut: string;
            clienteRazonsocial: string;
            clienterMail: string;
            clienterMail2: string;
            crTiporepresentacion: string;
            crRolesId: number;
            crTolnombre: string;
            crId: number;
        }[];
        nombrerol: string;
        activeroleid: number;
    }, UserAD | {
        id: number;
        documento: string;
        nombre: string;
        email: string;
        fechacreacion: string;
        fechaCreacion?: string;
        activo: number;
        rolesidroles: number;
        rolesIdRoles?: number;
        rolid: number;
        rolesusuarioid: number[];
        nombresrolesusuario: string[];
        roles: {
            rolid: number;
            nombrerol: string;
        }[];
        clientes: {
            clienteId: number;
            clienteRut: string;
            clienteRazonsocial: string;
            clienterMail: string;
            clienterMail2: string;
            crTiporepresentacion: string;
            crRolesId: number;
            crTolnombre: string;
            crId: number;
        }[];
        nombrerol: string;
        activeroleid: number;
    }>;
    secuency: globalThis.Ref<number, number>;
    secuencyList: globalThis.Ref<{
        SECUENCIA_08_DIVISAS: number;
        SECUENCIA_00_INVERSIONES: number;
        TODAS: number;
    }, {
        SECUENCIA_08_DIVISAS: number;
        SECUENCIA_00_INVERSIONES: number;
        TODAS: number;
    } | {
        SECUENCIA_08_DIVISAS: number;
        SECUENCIA_00_INVERSIONES: number;
        TODAS: number;
    }>;
    isAuthenticatedB2C: globalThis.Ref<boolean, boolean>;
    isAuthenticatedAD: globalThis.Ref<boolean, boolean>;
    token: globalThis.Ref<string, string>;
    setToken: (tkn: string, isValid: boolean, isClient?: boolean) => void;
    setSecuency: (scy: string | number) => void;
    setUser: (usr: UserB2C | UserAD, isClient?: boolean) => void;
    logoutLocal: (isClient?: boolean) => void;
}, "secuency" | "user" | "userAD" | "secuencyList" | "isAuthenticatedB2C" | "isAuthenticatedAD" | "token">, Pick<{
    user: globalThis.Ref<{
        representanteId: number;
        representanteRut: string;
        representanteNombres: string;
        representanteApellidos: string;
        representanteFullName: string;
        representanteEmail: string;
        representanteTelefono: string;
        representanteDescripcion: string;
        clientes: {
            clienteId: number;
            clienteRut: string;
            clienteRazonsocial: string;
            clienterMail: string;
            clienterMail2: string;
            crTiporepresentacion: string;
            crRolesId: number;
            crTolnombre: string;
            crId: number;
        }[];
    }, UserB2C | {
        representanteId: number;
        representanteRut: string;
        representanteNombres: string;
        representanteApellidos: string;
        representanteFullName: string;
        representanteEmail: string;
        representanteTelefono: string;
        representanteDescripcion: string;
        clientes: {
            clienteId: number;
            clienteRut: string;
            clienteRazonsocial: string;
            clienterMail: string;
            clienterMail2: string;
            crTiporepresentacion: string;
            crRolesId: number;
            crTolnombre: string;
            crId: number;
        }[];
    }>;
    userAD: globalThis.Ref<{
        id: number;
        documento: string;
        nombre: string;
        email: string;
        fechacreacion: string;
        fechaCreacion?: string;
        activo: number;
        rolesidroles: number;
        rolesIdRoles?: number;
        rolid: number;
        rolesusuarioid: number[];
        nombresrolesusuario: string[];
        roles: {
            rolid: number;
            nombrerol: string;
        }[];
        clientes: {
            clienteId: number;
            clienteRut: string;
            clienteRazonsocial: string;
            clienterMail: string;
            clienterMail2: string;
            crTiporepresentacion: string;
            crRolesId: number;
            crTolnombre: string;
            crId: number;
        }[];
        nombrerol: string;
        activeroleid: number;
    }, UserAD | {
        id: number;
        documento: string;
        nombre: string;
        email: string;
        fechacreacion: string;
        fechaCreacion?: string;
        activo: number;
        rolesidroles: number;
        rolesIdRoles?: number;
        rolid: number;
        rolesusuarioid: number[];
        nombresrolesusuario: string[];
        roles: {
            rolid: number;
            nombrerol: string;
        }[];
        clientes: {
            clienteId: number;
            clienteRut: string;
            clienteRazonsocial: string;
            clienterMail: string;
            clienterMail2: string;
            crTiporepresentacion: string;
            crRolesId: number;
            crTolnombre: string;
            crId: number;
        }[];
        nombrerol: string;
        activeroleid: number;
    }>;
    secuency: globalThis.Ref<number, number>;
    secuencyList: globalThis.Ref<{
        SECUENCIA_08_DIVISAS: number;
        SECUENCIA_00_INVERSIONES: number;
        TODAS: number;
    }, {
        SECUENCIA_08_DIVISAS: number;
        SECUENCIA_00_INVERSIONES: number;
        TODAS: number;
    } | {
        SECUENCIA_08_DIVISAS: number;
        SECUENCIA_00_INVERSIONES: number;
        TODAS: number;
    }>;
    isAuthenticatedB2C: globalThis.Ref<boolean, boolean>;
    isAuthenticatedAD: globalThis.Ref<boolean, boolean>;
    token: globalThis.Ref<string, string>;
    setToken: (tkn: string, isValid: boolean, isClient?: boolean) => void;
    setSecuency: (scy: string | number) => void;
    setUser: (usr: UserB2C | UserAD, isClient?: boolean) => void;
    logoutLocal: (isClient?: boolean) => void;
}, never>, Pick<{
    user: globalThis.Ref<{
        representanteId: number;
        representanteRut: string;
        representanteNombres: string;
        representanteApellidos: string;
        representanteFullName: string;
        representanteEmail: string;
        representanteTelefono: string;
        representanteDescripcion: string;
        clientes: {
            clienteId: number;
            clienteRut: string;
            clienteRazonsocial: string;
            clienterMail: string;
            clienterMail2: string;
            crTiporepresentacion: string;
            crRolesId: number;
            crTolnombre: string;
            crId: number;
        }[];
    }, UserB2C | {
        representanteId: number;
        representanteRut: string;
        representanteNombres: string;
        representanteApellidos: string;
        representanteFullName: string;
        representanteEmail: string;
        representanteTelefono: string;
        representanteDescripcion: string;
        clientes: {
            clienteId: number;
            clienteRut: string;
            clienteRazonsocial: string;
            clienterMail: string;
            clienterMail2: string;
            crTiporepresentacion: string;
            crRolesId: number;
            crTolnombre: string;
            crId: number;
        }[];
    }>;
    userAD: globalThis.Ref<{
        id: number;
        documento: string;
        nombre: string;
        email: string;
        fechacreacion: string;
        fechaCreacion?: string;
        activo: number;
        rolesidroles: number;
        rolesIdRoles?: number;
        rolid: number;
        rolesusuarioid: number[];
        nombresrolesusuario: string[];
        roles: {
            rolid: number;
            nombrerol: string;
        }[];
        clientes: {
            clienteId: number;
            clienteRut: string;
            clienteRazonsocial: string;
            clienterMail: string;
            clienterMail2: string;
            crTiporepresentacion: string;
            crRolesId: number;
            crTolnombre: string;
            crId: number;
        }[];
        nombrerol: string;
        activeroleid: number;
    }, UserAD | {
        id: number;
        documento: string;
        nombre: string;
        email: string;
        fechacreacion: string;
        fechaCreacion?: string;
        activo: number;
        rolesidroles: number;
        rolesIdRoles?: number;
        rolid: number;
        rolesusuarioid: number[];
        nombresrolesusuario: string[];
        roles: {
            rolid: number;
            nombrerol: string;
        }[];
        clientes: {
            clienteId: number;
            clienteRut: string;
            clienteRazonsocial: string;
            clienterMail: string;
            clienterMail2: string;
            crTiporepresentacion: string;
            crRolesId: number;
            crTolnombre: string;
            crId: number;
        }[];
        nombrerol: string;
        activeroleid: number;
    }>;
    secuency: globalThis.Ref<number, number>;
    secuencyList: globalThis.Ref<{
        SECUENCIA_08_DIVISAS: number;
        SECUENCIA_00_INVERSIONES: number;
        TODAS: number;
    }, {
        SECUENCIA_08_DIVISAS: number;
        SECUENCIA_00_INVERSIONES: number;
        TODAS: number;
    } | {
        SECUENCIA_08_DIVISAS: number;
        SECUENCIA_00_INVERSIONES: number;
        TODAS: number;
    }>;
    isAuthenticatedB2C: globalThis.Ref<boolean, boolean>;
    isAuthenticatedAD: globalThis.Ref<boolean, boolean>;
    token: globalThis.Ref<string, string>;
    setToken: (tkn: string, isValid: boolean, isClient?: boolean) => void;
    setSecuency: (scy: string | number) => void;
    setUser: (usr: UserB2C | UserAD, isClient?: boolean) => void;
    logoutLocal: (isClient?: boolean) => void;
}, "setToken" | "setSecuency" | "setUser" | "logoutLocal">>;
export { useAuthStore_2 as useAuthStore }

declare function useB2CAuth_2(isTokenValid?: boolean): {
    initB2CAuth: () => Promise<() => void>;
};
export { useB2CAuth_2 as useB2CAuth }

declare const useBankAccountsCCStore_2: StoreDefinition<"bankAccountsCC", Pick<{
    bankCC: globalThis.Ref<{
        id: number;
        bancoNombre: string;
        numeroCuenta: string;
        monedaISO: string;
        rut: string;
        activo: number;
        alias?: string;
    }[], BankCCType[] | {
        id: number;
        bancoNombre: string;
        numeroCuenta: string;
        monedaISO: string;
        rut: string;
        activo: number;
        alias?: string;
    }[]>;
}, "bankCC">, Pick<{
    bankCC: globalThis.Ref<{
        id: number;
        bancoNombre: string;
        numeroCuenta: string;
        monedaISO: string;
        rut: string;
        activo: number;
        alias?: string;
    }[], BankCCType[] | {
        id: number;
        bancoNombre: string;
        numeroCuenta: string;
        monedaISO: string;
        rut: string;
        activo: number;
        alias?: string;
    }[]>;
}, never>, Pick<{
    bankCC: globalThis.Ref<{
        id: number;
        bancoNombre: string;
        numeroCuenta: string;
        monedaISO: string;
        rut: string;
        activo: number;
        alias?: string;
    }[], BankCCType[] | {
        id: number;
        bancoNombre: string;
        numeroCuenta: string;
        monedaISO: string;
        rut: string;
        activo: number;
        alias?: string;
    }[]>;
}, never>>;
export { useBankAccountsCCStore_2 as useBankAccountsCCStore }

declare const useCatalogStore_2: StoreDefinition<"catalog", Pick<{
    catalog: globalThis.Ref<{
        [x: string]: {
            id: number;
            valor: string;
        }[];
        formaPago?: {
            id: number;
            valor: string;
        }[];
        tipoMovimiento?: {
            id: number;
            valor: string;
        }[];
        condicionPago?: {
            id: number;
            valor: string;
        }[];
        tipoOperacion?: {
            id: number;
            valor: string;
        }[];
        relacionTercero?: {
            id: number;
            valor: string;
        }[];
        tipoCuenta?: {
            id: number;
            valor: string;
        }[];
        origenCuenta?: {
            id: number;
            valor: string;
        }[];
        tipoTercero?: {
            id: number;
            valor: string;
        }[];
    }, CatalogType | {
        [x: string]: {
            id: number;
            valor: string;
        }[];
        formaPago?: {
            id: number;
            valor: string;
        }[];
        tipoMovimiento?: {
            id: number;
            valor: string;
        }[];
        condicionPago?: {
            id: number;
            valor: string;
        }[];
        tipoOperacion?: {
            id: number;
            valor: string;
        }[];
        relacionTercero?: {
            id: number;
            valor: string;
        }[];
        tipoCuenta?: {
            id: number;
            valor: string;
        }[];
        origenCuenta?: {
            id: number;
            valor: string;
        }[];
        tipoTercero?: {
            id: number;
            valor: string;
        }[];
    }>;
}, "catalog">, Pick<{
    catalog: globalThis.Ref<{
        [x: string]: {
            id: number;
            valor: string;
        }[];
        formaPago?: {
            id: number;
            valor: string;
        }[];
        tipoMovimiento?: {
            id: number;
            valor: string;
        }[];
        condicionPago?: {
            id: number;
            valor: string;
        }[];
        tipoOperacion?: {
            id: number;
            valor: string;
        }[];
        relacionTercero?: {
            id: number;
            valor: string;
        }[];
        tipoCuenta?: {
            id: number;
            valor: string;
        }[];
        origenCuenta?: {
            id: number;
            valor: string;
        }[];
        tipoTercero?: {
            id: number;
            valor: string;
        }[];
    }, CatalogType | {
        [x: string]: {
            id: number;
            valor: string;
        }[];
        formaPago?: {
            id: number;
            valor: string;
        }[];
        tipoMovimiento?: {
            id: number;
            valor: string;
        }[];
        condicionPago?: {
            id: number;
            valor: string;
        }[];
        tipoOperacion?: {
            id: number;
            valor: string;
        }[];
        relacionTercero?: {
            id: number;
            valor: string;
        }[];
        tipoCuenta?: {
            id: number;
            valor: string;
        }[];
        origenCuenta?: {
            id: number;
            valor: string;
        }[];
        tipoTercero?: {
            id: number;
            valor: string;
        }[];
    }>;
}, never>, Pick<{
    catalog: globalThis.Ref<{
        [x: string]: {
            id: number;
            valor: string;
        }[];
        formaPago?: {
            id: number;
            valor: string;
        }[];
        tipoMovimiento?: {
            id: number;
            valor: string;
        }[];
        condicionPago?: {
            id: number;
            valor: string;
        }[];
        tipoOperacion?: {
            id: number;
            valor: string;
        }[];
        relacionTercero?: {
            id: number;
            valor: string;
        }[];
        tipoCuenta?: {
            id: number;
            valor: string;
        }[];
        origenCuenta?: {
            id: number;
            valor: string;
        }[];
        tipoTercero?: {
            id: number;
            valor: string;
        }[];
    }, CatalogType | {
        [x: string]: {
            id: number;
            valor: string;
        }[];
        formaPago?: {
            id: number;
            valor: string;
        }[];
        tipoMovimiento?: {
            id: number;
            valor: string;
        }[];
        condicionPago?: {
            id: number;
            valor: string;
        }[];
        tipoOperacion?: {
            id: number;
            valor: string;
        }[];
        relacionTercero?: {
            id: number;
            valor: string;
        }[];
        tipoCuenta?: {
            id: number;
            valor: string;
        }[];
        origenCuenta?: {
            id: number;
            valor: string;
        }[];
        tipoTercero?: {
            id: number;
            valor: string;
        }[];
    }>;
}, never>>;
export { useCatalogStore_2 as useCatalogStore }

declare const useClientStore_2: StoreDefinition<"client", Pick<{
    clientId: globalThis.Ref<number, number>;
    client: globalThis.Ref<{
        companyId: number;
        companyName: string;
        companyRut: string;
        userType: string;
        clientId: number;
        executiveName?: string;
        executiveEmail?: string;
        executivePhone?: string;
        bid: number;
        offer: number;
        secuency?: {
            id: number;
            description: string;
            first?: boolean;
        }[];
        forex?: {
            heritageTotal: number;
            chart: {
                name: string;
                value: number;
                transit?: number;
                sliceSettings: {
                    fill: string;
                    stroke: string;
                };
            }[];
        };
        investments?: {
            heritageTotal: number;
            chart: {
                name: string;
                value: number;
                transit?: number;
                sliceSettings: {
                    fill: string;
                    stroke: string;
                };
            }[];
        };
        available?: {
            CLPTotal?: number;
            USDTotal?: number;
            EURTotal?: number;
            TotalCLP?: number;
            saldoContable?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
            saldoDisponible?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
            saldoTransito?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
        };
        inTransit?: {
            clp: number;
            usd: number;
            eur?: number | null;
            mutualFundsClp?: number | null;
            mutualFundsUsd?: number | null;
        };
    }, ClientType | {
        companyId: number;
        companyName: string;
        companyRut: string;
        userType: string;
        clientId: number;
        executiveName?: string;
        executiveEmail?: string;
        executivePhone?: string;
        bid: number;
        offer: number;
        secuency?: {
            id: number;
            description: string;
            first?: boolean;
        }[];
        forex?: {
            heritageTotal: number;
            chart: {
                name: string;
                value: number;
                transit?: number;
                sliceSettings: {
                    fill: string;
                    stroke: string;
                };
            }[];
        };
        investments?: {
            heritageTotal: number;
            chart: {
                name: string;
                value: number;
                transit?: number;
                sliceSettings: {
                    fill: string;
                    stroke: string;
                };
            }[];
        };
        available?: {
            CLPTotal?: number;
            USDTotal?: number;
            EURTotal?: number;
            TotalCLP?: number;
            saldoContable?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
            saldoDisponible?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
            saldoTransito?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
        };
        inTransit?: {
            clp: number;
            usd: number;
            eur?: number | null;
            mutualFundsClp?: number | null;
            mutualFundsUsd?: number | null;
        };
    }>;
    setClient: (newClient: ClientType) => void;
    getClientId: () => number;
    getClient: () => {
        companyId: number;
        companyName: string;
        companyRut: string;
        userType: string;
        clientId: number;
        executiveName?: string;
        executiveEmail?: string;
        executivePhone?: string;
        bid: number;
        offer: number;
        secuency?: {
            id: number;
            description: string;
            first?: boolean;
        }[];
        forex?: {
            heritageTotal: number;
            chart: {
                name: string;
                value: number;
                transit?: number;
                sliceSettings: {
                    fill: string;
                    stroke: string;
                };
            }[];
        };
        investments?: {
            heritageTotal: number;
            chart: {
                name: string;
                value: number;
                transit?: number;
                sliceSettings: {
                    fill: string;
                    stroke: string;
                };
            }[];
        };
        available?: {
            CLPTotal?: number;
            USDTotal?: number;
            EURTotal?: number;
            TotalCLP?: number;
            saldoContable?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
            saldoDisponible?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
            saldoTransito?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
        };
        inTransit?: {
            clp: number;
            usd: number;
            eur?: number | null;
            mutualFundsClp?: number | null;
            mutualFundsUsd?: number | null;
        };
    };
}, "clientId" | "client">, Pick<{
    clientId: globalThis.Ref<number, number>;
    client: globalThis.Ref<{
        companyId: number;
        companyName: string;
        companyRut: string;
        userType: string;
        clientId: number;
        executiveName?: string;
        executiveEmail?: string;
        executivePhone?: string;
        bid: number;
        offer: number;
        secuency?: {
            id: number;
            description: string;
            first?: boolean;
        }[];
        forex?: {
            heritageTotal: number;
            chart: {
                name: string;
                value: number;
                transit?: number;
                sliceSettings: {
                    fill: string;
                    stroke: string;
                };
            }[];
        };
        investments?: {
            heritageTotal: number;
            chart: {
                name: string;
                value: number;
                transit?: number;
                sliceSettings: {
                    fill: string;
                    stroke: string;
                };
            }[];
        };
        available?: {
            CLPTotal?: number;
            USDTotal?: number;
            EURTotal?: number;
            TotalCLP?: number;
            saldoContable?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
            saldoDisponible?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
            saldoTransito?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
        };
        inTransit?: {
            clp: number;
            usd: number;
            eur?: number | null;
            mutualFundsClp?: number | null;
            mutualFundsUsd?: number | null;
        };
    }, ClientType | {
        companyId: number;
        companyName: string;
        companyRut: string;
        userType: string;
        clientId: number;
        executiveName?: string;
        executiveEmail?: string;
        executivePhone?: string;
        bid: number;
        offer: number;
        secuency?: {
            id: number;
            description: string;
            first?: boolean;
        }[];
        forex?: {
            heritageTotal: number;
            chart: {
                name: string;
                value: number;
                transit?: number;
                sliceSettings: {
                    fill: string;
                    stroke: string;
                };
            }[];
        };
        investments?: {
            heritageTotal: number;
            chart: {
                name: string;
                value: number;
                transit?: number;
                sliceSettings: {
                    fill: string;
                    stroke: string;
                };
            }[];
        };
        available?: {
            CLPTotal?: number;
            USDTotal?: number;
            EURTotal?: number;
            TotalCLP?: number;
            saldoContable?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
            saldoDisponible?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
            saldoTransito?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
        };
        inTransit?: {
            clp: number;
            usd: number;
            eur?: number | null;
            mutualFundsClp?: number | null;
            mutualFundsUsd?: number | null;
        };
    }>;
    setClient: (newClient: ClientType) => void;
    getClientId: () => number;
    getClient: () => {
        companyId: number;
        companyName: string;
        companyRut: string;
        userType: string;
        clientId: number;
        executiveName?: string;
        executiveEmail?: string;
        executivePhone?: string;
        bid: number;
        offer: number;
        secuency?: {
            id: number;
            description: string;
            first?: boolean;
        }[];
        forex?: {
            heritageTotal: number;
            chart: {
                name: string;
                value: number;
                transit?: number;
                sliceSettings: {
                    fill: string;
                    stroke: string;
                };
            }[];
        };
        investments?: {
            heritageTotal: number;
            chart: {
                name: string;
                value: number;
                transit?: number;
                sliceSettings: {
                    fill: string;
                    stroke: string;
                };
            }[];
        };
        available?: {
            CLPTotal?: number;
            USDTotal?: number;
            EURTotal?: number;
            TotalCLP?: number;
            saldoContable?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
            saldoDisponible?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
            saldoTransito?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
        };
        inTransit?: {
            clp: number;
            usd: number;
            eur?: number | null;
            mutualFundsClp?: number | null;
            mutualFundsUsd?: number | null;
        };
    };
}, never>, Pick<{
    clientId: globalThis.Ref<number, number>;
    client: globalThis.Ref<{
        companyId: number;
        companyName: string;
        companyRut: string;
        userType: string;
        clientId: number;
        executiveName?: string;
        executiveEmail?: string;
        executivePhone?: string;
        bid: number;
        offer: number;
        secuency?: {
            id: number;
            description: string;
            first?: boolean;
        }[];
        forex?: {
            heritageTotal: number;
            chart: {
                name: string;
                value: number;
                transit?: number;
                sliceSettings: {
                    fill: string;
                    stroke: string;
                };
            }[];
        };
        investments?: {
            heritageTotal: number;
            chart: {
                name: string;
                value: number;
                transit?: number;
                sliceSettings: {
                    fill: string;
                    stroke: string;
                };
            }[];
        };
        available?: {
            CLPTotal?: number;
            USDTotal?: number;
            EURTotal?: number;
            TotalCLP?: number;
            saldoContable?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
            saldoDisponible?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
            saldoTransito?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
        };
        inTransit?: {
            clp: number;
            usd: number;
            eur?: number | null;
            mutualFundsClp?: number | null;
            mutualFundsUsd?: number | null;
        };
    }, ClientType | {
        companyId: number;
        companyName: string;
        companyRut: string;
        userType: string;
        clientId: number;
        executiveName?: string;
        executiveEmail?: string;
        executivePhone?: string;
        bid: number;
        offer: number;
        secuency?: {
            id: number;
            description: string;
            first?: boolean;
        }[];
        forex?: {
            heritageTotal: number;
            chart: {
                name: string;
                value: number;
                transit?: number;
                sliceSettings: {
                    fill: string;
                    stroke: string;
                };
            }[];
        };
        investments?: {
            heritageTotal: number;
            chart: {
                name: string;
                value: number;
                transit?: number;
                sliceSettings: {
                    fill: string;
                    stroke: string;
                };
            }[];
        };
        available?: {
            CLPTotal?: number;
            USDTotal?: number;
            EURTotal?: number;
            TotalCLP?: number;
            saldoContable?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
            saldoDisponible?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
            saldoTransito?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
        };
        inTransit?: {
            clp: number;
            usd: number;
            eur?: number | null;
            mutualFundsClp?: number | null;
            mutualFundsUsd?: number | null;
        };
    }>;
    setClient: (newClient: ClientType) => void;
    getClientId: () => number;
    getClient: () => {
        companyId: number;
        companyName: string;
        companyRut: string;
        userType: string;
        clientId: number;
        executiveName?: string;
        executiveEmail?: string;
        executivePhone?: string;
        bid: number;
        offer: number;
        secuency?: {
            id: number;
            description: string;
            first?: boolean;
        }[];
        forex?: {
            heritageTotal: number;
            chart: {
                name: string;
                value: number;
                transit?: number;
                sliceSettings: {
                    fill: string;
                    stroke: string;
                };
            }[];
        };
        investments?: {
            heritageTotal: number;
            chart: {
                name: string;
                value: number;
                transit?: number;
                sliceSettings: {
                    fill: string;
                    stroke: string;
                };
            }[];
        };
        available?: {
            CLPTotal?: number;
            USDTotal?: number;
            EURTotal?: number;
            TotalCLP?: number;
            saldoContable?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
            saldoDisponible?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
            saldoTransito?: {
                CLP: number;
                USD: number;
                EUR: number;
            };
        };
        inTransit?: {
            clp: number;
            usd: number;
            eur?: number | null;
            mutualFundsClp?: number | null;
            mutualFundsUsd?: number | null;
        };
    };
}, "setClient" | "getClientId" | "getClient">>;
export { useClientStore_2 as useClientStore }

declare const useClientTypesStore_2: StoreDefinition<"clientType", Pick<{
    clientTypes: globalThis.Ref<{
        id: number;
        description: string;
    }[], clientType[] | {
        id: number;
        description: string;
    }[]>;
    setClientTypes: (types: clientType[]) => void;
    clearClientTypes: () => void;
    getClientTypes: () => clientType[];
}, "clientTypes">, Pick<{
    clientTypes: globalThis.Ref<{
        id: number;
        description: string;
    }[], clientType[] | {
        id: number;
        description: string;
    }[]>;
    setClientTypes: (types: clientType[]) => void;
    clearClientTypes: () => void;
    getClientTypes: () => clientType[];
}, never>, Pick<{
    clientTypes: globalThis.Ref<{
        id: number;
        description: string;
    }[], clientType[] | {
        id: number;
        description: string;
    }[]>;
    setClientTypes: (types: clientType[]) => void;
    clearClientTypes: () => void;
    getClientTypes: () => clientType[];
}, "setClientTypes" | "clearClientTypes" | "getClientTypes">>;
export { useClientTypesStore_2 as useClientTypesStore }

declare const useCountryTypesStore_2: StoreDefinition<"countryType", Pick<{
    countryTypes: globalThis.Ref<{
        id: number;
        status: boolean;
        name: string;
        codName: string;
        blockType: string;
    }[], Country_2[] | {
        id: number;
        status: boolean;
        name: string;
        codName: string;
        blockType: string;
    }[]>;
    selectedCountry: globalThis.Ref<{
        id: number;
        status: boolean;
        name: string;
        codName: string;
        blockType: string;
    }, Country_2 | {
        id: number;
        status: boolean;
        name: string;
        codName: string;
        blockType: string;
    }>;
    setCountryTypes: (types: Country_2[]) => void;
    clearCountryTypes: () => void;
    setSelectedCountry: (country: Country_2 | null) => void;
    getCountryTypes: () => Country_2[];
}, "countryTypes" | "selectedCountry">, Pick<{
    countryTypes: globalThis.Ref<{
        id: number;
        status: boolean;
        name: string;
        codName: string;
        blockType: string;
    }[], Country_2[] | {
        id: number;
        status: boolean;
        name: string;
        codName: string;
        blockType: string;
    }[]>;
    selectedCountry: globalThis.Ref<{
        id: number;
        status: boolean;
        name: string;
        codName: string;
        blockType: string;
    }, Country_2 | {
        id: number;
        status: boolean;
        name: string;
        codName: string;
        blockType: string;
    }>;
    setCountryTypes: (types: Country_2[]) => void;
    clearCountryTypes: () => void;
    setSelectedCountry: (country: Country_2 | null) => void;
    getCountryTypes: () => Country_2[];
}, never>, Pick<{
    countryTypes: globalThis.Ref<{
        id: number;
        status: boolean;
        name: string;
        codName: string;
        blockType: string;
    }[], Country_2[] | {
        id: number;
        status: boolean;
        name: string;
        codName: string;
        blockType: string;
    }[]>;
    selectedCountry: globalThis.Ref<{
        id: number;
        status: boolean;
        name: string;
        codName: string;
        blockType: string;
    }, Country_2 | {
        id: number;
        status: boolean;
        name: string;
        codName: string;
        blockType: string;
    }>;
    setCountryTypes: (types: Country_2[]) => void;
    clearCountryTypes: () => void;
    setSelectedCountry: (country: Country_2 | null) => void;
    getCountryTypes: () => Country_2[];
}, "setCountryTypes" | "clearCountryTypes" | "setSelectedCountry" | "getCountryTypes">>;
export { useCountryTypesStore_2 as useCountryTypesStore }

declare function useCurrencyFormatter_2(): {
    formatPrice: (amount: number | string, currency?: string, minimumFractionDigits?: number, locale?: string) => string;
    formatPricePersonalData: (amount: number | string, currency?: "CLP" | "USD" | "EUR", locale?: string) => string;
};
export { useCurrencyFormatter_2 as useCurrencyFormatter }

declare const useCurrencyTypesStore_2: StoreDefinition<"currencyType", Pick<{
    currencyTypes: globalThis.Ref<{
        id: number;
        description: string;
        src?: string;
    }[], currencyType[] | {
        id: number;
        description: string;
        src?: string;
    }[]>;
    selectedCurrency: globalThis.Ref<{
        id: number;
        description: string;
        src?: string;
    }, currencyType | {
        id: number;
        description: string;
        src?: string;
    }>;
    setCurrencyTypes: (types: currencyType[]) => void;
    clearCurrencyTypes: () => void;
    setSelectedCurrency: (currency: currencyType | null) => void;
    getCurrencyTypes: () => currencyType[];
}, "currencyTypes" | "selectedCurrency">, Pick<{
    currencyTypes: globalThis.Ref<{
        id: number;
        description: string;
        src?: string;
    }[], currencyType[] | {
        id: number;
        description: string;
        src?: string;
    }[]>;
    selectedCurrency: globalThis.Ref<{
        id: number;
        description: string;
        src?: string;
    }, currencyType | {
        id: number;
        description: string;
        src?: string;
    }>;
    setCurrencyTypes: (types: currencyType[]) => void;
    clearCurrencyTypes: () => void;
    setSelectedCurrency: (currency: currencyType | null) => void;
    getCurrencyTypes: () => currencyType[];
}, never>, Pick<{
    currencyTypes: globalThis.Ref<{
        id: number;
        description: string;
        src?: string;
    }[], currencyType[] | {
        id: number;
        description: string;
        src?: string;
    }[]>;
    selectedCurrency: globalThis.Ref<{
        id: number;
        description: string;
        src?: string;
    }, currencyType | {
        id: number;
        description: string;
        src?: string;
    }>;
    setCurrencyTypes: (types: currencyType[]) => void;
    clearCurrencyTypes: () => void;
    setSelectedCurrency: (currency: currencyType | null) => void;
    getCurrencyTypes: () => currencyType[];
}, "setCurrencyTypes" | "clearCurrencyTypes" | "setSelectedCurrency" | "getCurrencyTypes">>;
export { useCurrencyTypesStore_2 as useCurrencyTypesStore }

declare const useExecutivesStore_2: StoreDefinition<"executive", Pick<{
    executive: globalThis.Ref<{
        executiveName: string;
        executiveEmail: string;
        executivePhone: string;
    }, executive | {
        executiveName: string;
        executiveEmail: string;
        executivePhone: string;
    }>;
}, "executive">, Pick<{
    executive: globalThis.Ref<{
        executiveName: string;
        executiveEmail: string;
        executivePhone: string;
    }, executive | {
        executiveName: string;
        executiveEmail: string;
        executivePhone: string;
    }>;
}, never>, Pick<{
    executive: globalThis.Ref<{
        executiveName: string;
        executiveEmail: string;
        executivePhone: string;
    }, executive | {
        executiveName: string;
        executiveEmail: string;
        executivePhone: string;
    }>;
}, never>>;
export { useExecutivesStore_2 as useExecutivesStore }

declare function useFeatureFlag_2(): {
    isFeatureEnabled: (feature: FeatureFlag) => boolean;
};
export { useFeatureFlag_2 as useFeatureFlag }

declare const useListPermissionStore_2: StoreDefinition<"listPermission", Pick<{
    listProfiles: globalThis.Ref<{
        [x: string]: any;
        id: number;
        name: string;
    }[], Profile_2[] | {
        [x: string]: any;
        id: number;
        name: string;
    }[]>;
    roleIdSeleccionado: globalThis.Ref<number, number>;
    listPermissionsAdmin: globalThis.Ref<{
        activo: number;
        nombrePermiso: string;
        nombreRol: string;
        permisoId: number;
        rolId: number;
    }[], Permissions_2[] | {
        activo: number;
        nombrePermiso: string;
        nombreRol: string;
        permisoId: number;
        rolId: number;
    }[]>;
    listPermissionsUsers: globalThis.Ref<{
        activo: number;
        nombrePermiso: string;
        nombreRol: string;
        permisoId: number;
        rolId: number;
    }[], Permissions_2[] | {
        activo: number;
        nombrePermiso: string;
        nombreRol: string;
        permisoId: number;
        rolId: number;
    }[]>;
    setListProfiles: (profiles: Profile_2[]) => void;
    setRoleIdSeleccionado: (roleId: number) => void;
    setListPermissionsAdmin: (permissions: Permissions_2[]) => void;
    setListPermissionsUsers: (permissions: Permissions_2[]) => void;
}, "listProfiles" | "roleIdSeleccionado" | "listPermissionsAdmin" | "listPermissionsUsers">, Pick<{
    listProfiles: globalThis.Ref<{
        [x: string]: any;
        id: number;
        name: string;
    }[], Profile_2[] | {
        [x: string]: any;
        id: number;
        name: string;
    }[]>;
    roleIdSeleccionado: globalThis.Ref<number, number>;
    listPermissionsAdmin: globalThis.Ref<{
        activo: number;
        nombrePermiso: string;
        nombreRol: string;
        permisoId: number;
        rolId: number;
    }[], Permissions_2[] | {
        activo: number;
        nombrePermiso: string;
        nombreRol: string;
        permisoId: number;
        rolId: number;
    }[]>;
    listPermissionsUsers: globalThis.Ref<{
        activo: number;
        nombrePermiso: string;
        nombreRol: string;
        permisoId: number;
        rolId: number;
    }[], Permissions_2[] | {
        activo: number;
        nombrePermiso: string;
        nombreRol: string;
        permisoId: number;
        rolId: number;
    }[]>;
    setListProfiles: (profiles: Profile_2[]) => void;
    setRoleIdSeleccionado: (roleId: number) => void;
    setListPermissionsAdmin: (permissions: Permissions_2[]) => void;
    setListPermissionsUsers: (permissions: Permissions_2[]) => void;
}, never>, Pick<{
    listProfiles: globalThis.Ref<{
        [x: string]: any;
        id: number;
        name: string;
    }[], Profile_2[] | {
        [x: string]: any;
        id: number;
        name: string;
    }[]>;
    roleIdSeleccionado: globalThis.Ref<number, number>;
    listPermissionsAdmin: globalThis.Ref<{
        activo: number;
        nombrePermiso: string;
        nombreRol: string;
        permisoId: number;
        rolId: number;
    }[], Permissions_2[] | {
        activo: number;
        nombrePermiso: string;
        nombreRol: string;
        permisoId: number;
        rolId: number;
    }[]>;
    listPermissionsUsers: globalThis.Ref<{
        activo: number;
        nombrePermiso: string;
        nombreRol: string;
        permisoId: number;
        rolId: number;
    }[], Permissions_2[] | {
        activo: number;
        nombrePermiso: string;
        nombreRol: string;
        permisoId: number;
        rolId: number;
    }[]>;
    setListProfiles: (profiles: Profile_2[]) => void;
    setRoleIdSeleccionado: (roleId: number) => void;
    setListPermissionsAdmin: (permissions: Permissions_2[]) => void;
    setListPermissionsUsers: (permissions: Permissions_2[]) => void;
}, "setListProfiles" | "setRoleIdSeleccionado" | "setListPermissionsAdmin" | "setListPermissionsUsers">>;
export { useListPermissionStore_2 as useListPermissionStore }

export declare interface User {
    id: number;
    fullName: string;
    alias: string;
    rut: string;
    role: string;
}

export declare interface UserAD {
    id: number;
    documento: string;
    nombre: string;
    email: string;
    fechacreacion: string;
    fechaCreacion?: string;
    activo: number;
    rolesidroles: number;
    rolesIdRoles?: number;
    rolid: number;
    rolesusuarioid: number[];
    nombresrolesusuario: string[];
    roles: RoleAD[];
    clientes: Clientes[];
    nombrerol: string;
    activeroleid: number;
}

export declare interface UserB2C {
    representanteId: number;
    representanteRut: string;
    representanteNombres: string;
    representanteApellidos: string;
    representanteFullName: string;
    representanteEmail: string;
    representanteTelefono: string;
    representanteDescripcion: string;
    clientes: Clientes[];
}

export declare interface UserData {
    id: number;
    clientType?: any;
    currencyType?: any;
    favorite: boolean;
    isActive: boolean;
    type: number;
    clientExist: boolean;
    fullName: string;
    rut: string;
    alias?: string;
    address?: string;
    countryId?: any;
    city?: string;
    survey?: [];
    cityBank?: string;
    accounts?: Accounts[];
}

export declare interface UserDataFile {
    file: any;
    clientType?: any;
    currencyType?: any;
    intermediary: any;
    beneficiaries: Beneficiary[];
}

export declare interface UserLogin {
    user: string;
    password: string;
}

export declare interface UserPersonalData {
    id?: number;
    fullName?: string;
    rut?: string;
    alias?: string;
    address?: string;
    countryId?: number;
    city?: string;
    bankName?: string;
    accountNumber?: string;
    accounts?: Accounts[];
}

export declare interface UserSession {
    token: string;
}

/**
 * @description traido manualmente mientras se prueba la importación del portalcash-shared
 */
export declare function usersPath(hostname: any): "/portalcash/chl/corecashchile-users" | "/corecashchile-users";

declare const useSystemStatusStore_2: StoreDefinition<"systemStatus", Pick<{
    statusItems: globalThis.Ref<{
        id: number;
        tipoEntidad: string;
        codigoEntidad: string;
        comportamiento: string;
        activo: number;
        descripcion: string;
        fechaCreacion: string;
        fechaModificacion: string;
    }[], SystemStatusItem_2[] | {
        id: number;
        tipoEntidad: string;
        codigoEntidad: string;
        comportamiento: string;
        activo: number;
        descripcion: string;
        fechaCreacion: string;
        fechaModificacion: string;
    }[]>;
    isLoading: globalThis.Ref<boolean, boolean>;
    isUpdating: globalThis.Ref<boolean, boolean>;
    setStatusItems: (items: SystemStatusItem_2[]) => void;
    setIsLoading: (value: boolean) => void;
    setIsUpdating: (value: boolean) => void;
}, "isLoading" | "statusItems" | "isUpdating">, Pick<{
    statusItems: globalThis.Ref<{
        id: number;
        tipoEntidad: string;
        codigoEntidad: string;
        comportamiento: string;
        activo: number;
        descripcion: string;
        fechaCreacion: string;
        fechaModificacion: string;
    }[], SystemStatusItem_2[] | {
        id: number;
        tipoEntidad: string;
        codigoEntidad: string;
        comportamiento: string;
        activo: number;
        descripcion: string;
        fechaCreacion: string;
        fechaModificacion: string;
    }[]>;
    isLoading: globalThis.Ref<boolean, boolean>;
    isUpdating: globalThis.Ref<boolean, boolean>;
    setStatusItems: (items: SystemStatusItem_2[]) => void;
    setIsLoading: (value: boolean) => void;
    setIsUpdating: (value: boolean) => void;
}, never>, Pick<{
    statusItems: globalThis.Ref<{
        id: number;
        tipoEntidad: string;
        codigoEntidad: string;
        comportamiento: string;
        activo: number;
        descripcion: string;
        fechaCreacion: string;
        fechaModificacion: string;
    }[], SystemStatusItem_2[] | {
        id: number;
        tipoEntidad: string;
        codigoEntidad: string;
        comportamiento: string;
        activo: number;
        descripcion: string;
        fechaCreacion: string;
        fechaModificacion: string;
    }[]>;
    isLoading: globalThis.Ref<boolean, boolean>;
    isUpdating: globalThis.Ref<boolean, boolean>;
    setStatusItems: (items: SystemStatusItem_2[]) => void;
    setIsLoading: (value: boolean) => void;
    setIsUpdating: (value: boolean) => void;
}, "setStatusItems" | "setIsLoading" | "setIsUpdating">>;
export { useSystemStatusStore_2 as useSystemStatusStore }

declare const useThemeStore_2: StoreDefinition<"theme", Pick<{
    setTheme: (theme: "light" | "dark") => void;
    currentTheme: globalThis.Ref<"light" | "dark", "light" | "dark">;
}, "currentTheme">, Pick<{
    setTheme: (theme: "light" | "dark") => void;
    currentTheme: globalThis.Ref<"light" | "dark", "light" | "dark">;
}, never>, Pick<{
    setTheme: (theme: "light" | "dark") => void;
    currentTheme: globalThis.Ref<"light" | "dark", "light" | "dark">;
}, "setTheme">>;
export { useThemeStore_2 as useThemeStore }

declare function useWindowSize_2(): {
    width: globalThis.Ref<number, number>;
    height: globalThis.Ref<number, number>;
    isMobile: globalThis.ComputedRef<boolean>;
    isTablet: globalThis.ComputedRef<boolean>;
    isDesktop: globalThis.ComputedRef<boolean>;
};
export { useWindowSize_2 as useWindowSize }

export declare const validateCheckboxSelection: (selectedValues: any[]) => string | null;

export declare const validateInputs: (data: Record<string, string | number>, requiredFields: Record<string, boolean>) => Record<string, string>;

export declare interface validateOperation {
    id: number;
    dateTime: string;
    folio: number;
    clientName?: string;
    clientRUT?: string;
    beneficiaryName?: string;
    beneficiaryRUT?: string;
    operationType?: operationType_2;
    amount: number;
    rejectionReason?: string;
    address: string;
    city: string;
    country: string;
    currencyType: operationType_2;
    status?: operationType_2;
    file: boolean;
}

export declare interface valute {
    id: number;
    description: string;
}

export declare class valuteService {
    getValuteList(typeValute: Number[] | null): Promise<{
        data: valute[];
    }>;
}

declare type Variant = "primary" | "primary_outlined" | "success" | "success_outlined" | "warning_outlined" | "upload" | "link" | "text_blue" | "blue" | "danger" | "outlined" | "icon";

export declare const version = "1.0.3";

export { }



declare module "pinia" {
  export interface DefineStoreOptionsBase<S, Store> {
    persist?: boolean | PersistedStateOptions;
  }
}