import type { WalletwithdrawquotequotationResponse as WithdrawalQuotation } from '@bluvo/sdk-ts';
import { BluvoExchangeStatus, type BluvoExchangeType } from '../consts/bluvo';
import { type FunkitActiveCheckoutItem } from '../providers/FunkitCheckoutContext';
import type { FunBrokerageItemProps } from '../components/FunSelectBrokerage/FunBrokerageItem';
type SupportedExchangeOption = FunBrokerageItemProps & {
    exchange: BluvoExchangeType;
    status: BluvoExchangeStatus;
};
type BluvoCheckoutQuoteParams = {
    chainId: FunkitActiveCheckoutItem['selectedSourceAssetInfo']['chainId'];
    symbol: FunkitActiveCheckoutItem['selectedSourceAssetInfo']['symbol'];
    amount: string;
};
export type BluvoBrokerageQuote = WithdrawalQuotation & {
    availableTokenAmount: number;
};
export declare const useBluvoExchangeBalance: ({ exchange, refetchOnMount, }: {
    exchange: BluvoExchangeType | undefined;
    refetchOnMount?: boolean;
}) => {
    data: import("../domains/wallet").AssetHoldingsMap<import("../domains/wallet").BrokerageAssetHoldingsItem> | undefined;
    totalBalance: number;
    isLoading: boolean;
    isError: boolean;
};
export declare const useBluvoCheckoutQuote: () => {
    getBluvoCheckoutQuote: ({ amount, symbol, chainId, }: BluvoCheckoutQuoteParams) => Promise<BluvoBrokerageQuote | undefined>;
};
export declare const useBluvoSupportedExchanges: ({ fullInfo, iconSize, filterBy, }: {
    fullInfo?: boolean;
    iconSize?: number;
    filterBy?: BluvoExchangeStatus[];
}) => {
    exchangeOptions: ReadonlyArray<SupportedExchangeOption>;
};
export declare const useBluvo: () => {
    exchangeType: BluvoExchangeType | undefined;
    bluvoClient: {
        listExchanges: (status?: "live" | "offline" | "maintenance" | "coming_soon") => Promise<any[] | null>;
        startWithdrawalFlow: (flowOptions: import("@bluvo/sdk-ts").WithdrawalFlowOptions) => Promise<{
            machine: import("@bluvo/sdk-ts").Machine<import("@bluvo/sdk-ts").FlowState, import("@bluvo/sdk-ts").FlowActionType>;
            closeOAuthWindow: null;
        } | {
            machine: import("@bluvo/sdk-ts").Machine<import("@bluvo/sdk-ts").FlowState, import("@bluvo/sdk-ts").FlowActionType>;
            closeOAuthWindow: () => void;
        }>;
        resumeWithdrawalFlow: (flowOptions: import("@bluvo/sdk-ts").ResumeWithdrawalFlowOptions) => Promise<{
            machine: import("@bluvo/sdk-ts").Machine<import("@bluvo/sdk-ts").FlowState, import("@bluvo/sdk-ts").FlowActionType>;
            closeOAuthWindow: null;
        }>;
        silentResumeWithdrawalFlow: (flowOptions: import("@bluvo/sdk-ts").SilentResumeWithdrawalFlowOptions) => Promise<{
            machine: import("@bluvo/sdk-ts").Machine<import("@bluvo/sdk-ts").FlowState, import("@bluvo/sdk-ts").FlowActionType>;
        } | null>;
        requestQuote: (options: import("@bluvo/sdk-ts").QuoteRequestOptions) => Promise<{
            success: boolean;
            error: string;
            type?: undefined;
            rawQuote?: undefined;
            quoteData?: undefined;
            result?: undefined;
        } | {
            success: boolean;
            error: string;
            type: import("@bluvo/sdk-ts").TypeEnum2;
            rawQuote?: undefined;
            quoteData?: undefined;
            result?: undefined;
        } | {
            rawQuote: {
                id: string;
                asset: string;
                amountWithFee?: number | null;
                amountNoFee?: number | null;
                estimatedFee?: number | null;
                amountWithFeeInFiat?: number | null;
                amountNoFeeInFiat?: number | null;
                estimatedFeeInFiat?: number | null;
                destinationAddress: string;
                network?: string | null;
                tag?: string | null;
                estimatedTotal?: number;
                feeDetails?: Array<{
                    category: import("@bluvo/sdk-ts").CategoryEnum;
                    currency: string;
                    amount: number;
                    amountInFiat?: number | null;
                    fiatCurrency: string;
                }>;
                expiresAt: string;
                additionalInfo: {
                    minWithdrawal: string | null;
                    maxWithdrawal?: string | null;
                };
            };
            quoteData: {
                id: string;
                asset: string;
                amount: string;
                estimatedFee: string;
                estimatedTotal: string;
                amountWithFeeInFiat: string;
                amountNoFeeInFiat: string;
                estimatedFeeInFiat: string;
                additionalInfo: {
                    minWithdrawal: string | null;
                    maxWithdrawal?: string | null;
                };
                expiresAt: number;
            };
            success: boolean;
            result: {
                rawQuote: {
                    id: string;
                    asset: string;
                    amountWithFee?: number | null;
                    amountNoFee?: number | null;
                    estimatedFee?: number | null;
                    amountWithFeeInFiat?: number | null;
                    amountNoFeeInFiat?: number | null;
                    estimatedFeeInFiat?: number | null;
                    destinationAddress: string;
                    network?: string | null;
                    tag?: string | null;
                    estimatedTotal?: number;
                    feeDetails?: Array<{
                        category: import("@bluvo/sdk-ts").CategoryEnum;
                        currency: string;
                        amount: number;
                        amountInFiat?: number | null;
                        fiatCurrency: string;
                    }>;
                    expiresAt: string;
                    additionalInfo: {
                        minWithdrawal: string | null;
                        maxWithdrawal?: string | null;
                    };
                };
                quoteData: {
                    id: string;
                    asset: string;
                    amount: string;
                    estimatedFee: string;
                    estimatedTotal: string;
                    amountWithFeeInFiat: string;
                    amountNoFeeInFiat: string;
                    estimatedFeeInFiat: string;
                    additionalInfo: {
                        minWithdrawal: string | null;
                        maxWithdrawal?: string | null;
                    };
                    expiresAt: number;
                };
            };
            error?: undefined;
            type?: undefined;
        }>;
        executeWithdrawal: (quoteId: string) => Promise<{
            success: boolean;
            error: string;
            type?: undefined;
        } | {
            success: boolean;
            error: any;
            type: import("@bluvo/sdk-ts").TypeEnum2;
        } | {
            success: boolean;
            result: {
                success: boolean;
                error?: string;
                type?: import("@bluvo/sdk-ts").TypeEnum2;
                result?: {
                    transactionId: string;
                    [key: string]: unknown | string;
                } | {
                    bizNo: string;
                    steps: Array<{
                        type: import("@bluvo/sdk-ts").TypeEnum3;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        required: boolean;
                        metadata?: {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        };
                        [key: string]: unknown | import("@bluvo/sdk-ts").TypeEnum3 | import("@bluvo/sdk-ts").StatusEnum4 | boolean | {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        } | undefined;
                    }>;
                    relation: import("@bluvo/sdk-ts").RelationEnum;
                    mfa?: {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    };
                    [key: string]: unknown | string | Array<{
                        type: import("@bluvo/sdk-ts").TypeEnum3;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        required: boolean;
                        metadata?: {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        };
                        [key: string]: unknown | import("@bluvo/sdk-ts").TypeEnum3 | import("@bluvo/sdk-ts").StatusEnum4 | boolean | {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        } | undefined;
                    }> | import("@bluvo/sdk-ts").RelationEnum | {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    } | undefined;
                } | {
                    bizNo?: string;
                    steps?: Array<{
                        type: string;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        error?: string;
                        [key: string]: unknown | string | import("@bluvo/sdk-ts").StatusEnum4 | undefined;
                    }>;
                    mfa?: {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    };
                    [key: string]: unknown | string | Array<{
                        type: string;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        error?: string;
                        [key: string]: unknown | string | import("@bluvo/sdk-ts").StatusEnum4 | undefined;
                    }> | {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    } | undefined;
                } | {
                    valid2FAMethods: Array<string>;
                    [key: string]: unknown | Array<string>;
                } | {
                    [key: string]: unknown;
                };
            } | null | undefined;
            error?: string;
            type?: import("@bluvo/sdk-ts").TypeEnum2;
        }>;
        submit2FA: (code: string) => Promise<{
            success: boolean;
            error: string;
            type?: undefined;
        } | {
            success: boolean;
            error: any;
            type: import("@bluvo/sdk-ts").TypeEnum2;
        } | {
            success: boolean;
            result: {
                success: boolean;
                error?: string;
                type?: import("@bluvo/sdk-ts").TypeEnum2;
                result?: {
                    transactionId: string;
                    [key: string]: unknown | string;
                } | {
                    bizNo: string;
                    steps: Array<{
                        type: import("@bluvo/sdk-ts").TypeEnum3;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        required: boolean;
                        metadata?: {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        };
                        [key: string]: unknown | import("@bluvo/sdk-ts").TypeEnum3 | import("@bluvo/sdk-ts").StatusEnum4 | boolean | {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        } | undefined;
                    }>;
                    relation: import("@bluvo/sdk-ts").RelationEnum;
                    mfa?: {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    };
                    [key: string]: unknown | string | Array<{
                        type: import("@bluvo/sdk-ts").TypeEnum3;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        required: boolean;
                        metadata?: {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        };
                        [key: string]: unknown | import("@bluvo/sdk-ts").TypeEnum3 | import("@bluvo/sdk-ts").StatusEnum4 | boolean | {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        } | undefined;
                    }> | import("@bluvo/sdk-ts").RelationEnum | {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    } | undefined;
                } | {
                    bizNo?: string;
                    steps?: Array<{
                        type: string;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        error?: string;
                        [key: string]: unknown | string | import("@bluvo/sdk-ts").StatusEnum4 | undefined;
                    }>;
                    mfa?: {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    };
                    [key: string]: unknown | string | Array<{
                        type: string;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        error?: string;
                        [key: string]: unknown | string | import("@bluvo/sdk-ts").StatusEnum4 | undefined;
                    }> | {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    } | undefined;
                } | {
                    valid2FAMethods: Array<string>;
                    [key: string]: unknown | Array<string>;
                } | {
                    [key: string]: unknown;
                };
            } | null | undefined;
            error?: string;
            type?: import("@bluvo/sdk-ts").TypeEnum2;
        }>;
        submit2FAMultiStep: (stepType: "GOOGLE" | "EMAIL" | "SMS", code: string) => Promise<{
            success: boolean;
            error: string;
            type?: undefined;
            result?: undefined;
        } | {
            success: boolean;
            error: any;
            type: import("@bluvo/sdk-ts").TypeEnum2;
            result?: undefined;
        } | {
            success: boolean;
            result: {
                success: boolean;
                error?: string;
                type?: import("@bluvo/sdk-ts").TypeEnum2;
                result?: {
                    transactionId: string;
                    [key: string]: unknown | string;
                } | {
                    bizNo: string;
                    steps: Array<{
                        type: import("@bluvo/sdk-ts").TypeEnum3;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        required: boolean;
                        metadata?: {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        };
                        [key: string]: unknown | import("@bluvo/sdk-ts").TypeEnum3 | import("@bluvo/sdk-ts").StatusEnum4 | boolean | {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        } | undefined;
                    }>;
                    relation: import("@bluvo/sdk-ts").RelationEnum;
                    mfa?: {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    };
                    [key: string]: unknown | string | Array<{
                        type: import("@bluvo/sdk-ts").TypeEnum3;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        required: boolean;
                        metadata?: {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        };
                        [key: string]: unknown | import("@bluvo/sdk-ts").TypeEnum3 | import("@bluvo/sdk-ts").StatusEnum4 | boolean | {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        } | undefined;
                    }> | import("@bluvo/sdk-ts").RelationEnum | {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    } | undefined;
                } | {
                    bizNo?: string;
                    steps?: Array<{
                        type: string;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        error?: string;
                        [key: string]: unknown | string | import("@bluvo/sdk-ts").StatusEnum4 | undefined;
                    }>;
                    mfa?: {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    };
                    [key: string]: unknown | string | Array<{
                        type: string;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        error?: string;
                        [key: string]: unknown | string | import("@bluvo/sdk-ts").StatusEnum4 | undefined;
                    }> | {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    } | undefined;
                } | {
                    valid2FAMethods: Array<string>;
                    [key: string]: unknown | Array<string>;
                } | {
                    [key: string]: unknown;
                };
            } | null | undefined;
            error?: undefined;
            type?: undefined;
        }>;
        pollFaceVerification: () => Promise<{
            success: boolean;
            error: string;
            type?: undefined;
            result?: undefined;
        } | {
            success: boolean;
            error: any;
            type: import("@bluvo/sdk-ts").TypeEnum2;
            result?: undefined;
        } | {
            success: boolean;
            result: {
                success: boolean;
                error?: string;
                type?: import("@bluvo/sdk-ts").TypeEnum2;
                result?: {
                    transactionId: string;
                    [key: string]: unknown | string;
                } | {
                    bizNo: string;
                    steps: Array<{
                        type: import("@bluvo/sdk-ts").TypeEnum3;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        required: boolean;
                        metadata?: {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        };
                        [key: string]: unknown | import("@bluvo/sdk-ts").TypeEnum3 | import("@bluvo/sdk-ts").StatusEnum4 | boolean | {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        } | undefined;
                    }>;
                    relation: import("@bluvo/sdk-ts").RelationEnum;
                    mfa?: {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    };
                    [key: string]: unknown | string | Array<{
                        type: import("@bluvo/sdk-ts").TypeEnum3;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        required: boolean;
                        metadata?: {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        };
                        [key: string]: unknown | import("@bluvo/sdk-ts").TypeEnum3 | import("@bluvo/sdk-ts").StatusEnum4 | boolean | {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        } | undefined;
                    }> | import("@bluvo/sdk-ts").RelationEnum | {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    } | undefined;
                } | {
                    bizNo?: string;
                    steps?: Array<{
                        type: string;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        error?: string;
                        [key: string]: unknown | string | import("@bluvo/sdk-ts").StatusEnum4 | undefined;
                    }>;
                    mfa?: {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    };
                    [key: string]: unknown | string | Array<{
                        type: string;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        error?: string;
                        [key: string]: unknown | string | import("@bluvo/sdk-ts").StatusEnum4 | undefined;
                    }> | {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    } | undefined;
                } | {
                    valid2FAMethods: Array<string>;
                    [key: string]: unknown | Array<string>;
                } | {
                    [key: string]: unknown;
                };
            } | null | undefined;
            error?: undefined;
            type?: undefined;
        }>;
        confirmWithdrawal: () => Promise<{
            success: boolean;
            error: string;
            type?: undefined;
            result?: undefined;
        } | {
            success: boolean;
            error: any;
            type: import("@bluvo/sdk-ts").TypeEnum2;
            result?: undefined;
        } | {
            success: boolean;
            result: {
                success: boolean;
                error?: string;
                type?: import("@bluvo/sdk-ts").TypeEnum2;
                result?: {
                    transactionId: string;
                    [key: string]: unknown | string;
                } | {
                    bizNo: string;
                    steps: Array<{
                        type: import("@bluvo/sdk-ts").TypeEnum3;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        required: boolean;
                        metadata?: {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        };
                        [key: string]: unknown | import("@bluvo/sdk-ts").TypeEnum3 | import("@bluvo/sdk-ts").StatusEnum4 | boolean | {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        } | undefined;
                    }>;
                    relation: import("@bluvo/sdk-ts").RelationEnum;
                    mfa?: {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    };
                    [key: string]: unknown | string | Array<{
                        type: import("@bluvo/sdk-ts").TypeEnum3;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        required: boolean;
                        metadata?: {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        };
                        [key: string]: unknown | import("@bluvo/sdk-ts").TypeEnum3 | import("@bluvo/sdk-ts").StatusEnum4 | boolean | {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        } | undefined;
                    }> | import("@bluvo/sdk-ts").RelationEnum | {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    } | undefined;
                } | {
                    bizNo?: string;
                    steps?: Array<{
                        type: string;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        error?: string;
                        [key: string]: unknown | string | import("@bluvo/sdk-ts").StatusEnum4 | undefined;
                    }>;
                    mfa?: {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    };
                    [key: string]: unknown | string | Array<{
                        type: string;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        error?: string;
                        [key: string]: unknown | string | import("@bluvo/sdk-ts").StatusEnum4 | undefined;
                    }> | {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    } | undefined;
                } | {
                    valid2FAMethods: Array<string>;
                    [key: string]: unknown | Array<string>;
                } | {
                    [key: string]: unknown;
                };
            } | null | undefined;
            error?: undefined;
            type?: undefined;
        }>;
        retryWithdrawal: () => Promise<{
            success: boolean;
            error: string;
            type?: undefined;
        } | {
            success: boolean;
            error: any;
            type: import("@bluvo/sdk-ts").TypeEnum2;
        } | {
            success: boolean;
            result: {
                success: boolean;
                error?: string;
                type?: import("@bluvo/sdk-ts").TypeEnum2;
                result?: {
                    transactionId: string;
                    [key: string]: unknown | string;
                } | {
                    bizNo: string;
                    steps: Array<{
                        type: import("@bluvo/sdk-ts").TypeEnum3;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        required: boolean;
                        metadata?: {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        };
                        [key: string]: unknown | import("@bluvo/sdk-ts").TypeEnum3 | import("@bluvo/sdk-ts").StatusEnum4 | boolean | {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        } | undefined;
                    }>;
                    relation: import("@bluvo/sdk-ts").RelationEnum;
                    mfa?: {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    };
                    [key: string]: unknown | string | Array<{
                        type: import("@bluvo/sdk-ts").TypeEnum3;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        required: boolean;
                        metadata?: {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        };
                        [key: string]: unknown | import("@bluvo/sdk-ts").TypeEnum3 | import("@bluvo/sdk-ts").StatusEnum4 | boolean | {
                            email?: string;
                            emailSent?: boolean;
                            qrCodeUrl?: string;
                            qrCodeValidSeconds?: number;
                            [key: string]: unknown | string | boolean | number | undefined;
                        } | undefined;
                    }> | import("@bluvo/sdk-ts").RelationEnum | {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    } | undefined;
                } | {
                    bizNo?: string;
                    steps?: Array<{
                        type: string;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        error?: string;
                        [key: string]: unknown | string | import("@bluvo/sdk-ts").StatusEnum4 | undefined;
                    }>;
                    mfa?: {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    };
                    [key: string]: unknown | string | Array<{
                        type: string;
                        status: import("@bluvo/sdk-ts").StatusEnum4;
                        error?: string;
                        [key: string]: unknown | string | import("@bluvo/sdk-ts").StatusEnum4 | undefined;
                    }> | {
                        bizNo?: string;
                        verified: {
                            EMAIL?: boolean;
                            SMS?: boolean;
                            GOOGLE?: boolean;
                            FACE?: boolean;
                        };
                        attempts?: Array<{
                            method: import("@bluvo/sdk-ts").TypeEnum3;
                            status: import("@bluvo/sdk-ts").StatusEnum4;
                            createdAt: number;
                            validatedAt?: number;
                            expiresAt?: number;
                            success: boolean;
                        }>;
                        methods?: Array<{
                            method: "EMAIL";
                            email: string;
                        } | {
                            method: "SMS";
                            phoneNumber: string;
                        } | {
                            method: "GOOGLE";
                        } | {
                            method: "FACE";
                            viaMobile: boolean;
                        }>;
                    } | undefined;
                } | {
                    valid2FAMethods: Array<string>;
                    [key: string]: unknown | Array<string>;
                } | {
                    [key: string]: unknown;
                };
            } | null | undefined;
            error?: string;
            type?: import("@bluvo/sdk-ts").TypeEnum2;
        } | undefined>;
        cancel: () => void;
        refreshQRCode: () => Promise<{
            success: boolean;
            error: any;
        } | {
            success: boolean;
            error?: undefined;
        }>;
        testWithdrawalComplete: (transactionId?: string) => void;
        isIdle: boolean;
        isFlowCancelled: boolean;
        isExchangesLoading: boolean;
        isExchangesReady: boolean;
        isExchangesError: boolean;
        exchangesError: Error | null;
        isOAuthPending: boolean;
        isOAuthWaiting: boolean;
        isOAuthProcessing: boolean;
        isOAuthError: boolean;
        isOAuthFatal: boolean;
        isWalletConnectionInvalid: boolean;
        isOAuthComplete: boolean;
        isOAuthWindowBeenClosedByTheUser: boolean;
        isQRCodePending: boolean | undefined;
        isQRCodeWaiting: boolean;
        isQRCodeDisplaying: boolean;
        isQRCodeScanning: boolean;
        isQRCodeError: boolean;
        isQRCodeFatal: boolean;
        isQRCodeTimeout: boolean;
        qrCodeUrl: string | undefined;
        qrCodeExpiresAt: number | undefined;
        qrCodeStatus: import("@bluvo/sdk-ts").QRCodeStatus | undefined;
        isQRCodeFlow: boolean;
        isWalletLoading: boolean;
        isWalletError: boolean;
        isWalletReady: boolean;
        isQuoteLoading: boolean;
        isQuoteReady: boolean;
        isQuoteExpired: boolean;
        isQuoteError: boolean;
        isWithdrawing: boolean;
        isWithdrawProcessing: boolean;
        isWithdrawalComplete: boolean;
        isWithdrawBlocked: boolean;
        hasFatalError: boolean;
        requires2FA: boolean;
        requires2FAMultiStep: boolean;
        isReadyToConfirm: boolean;
        requiresSMS: boolean;
        requiresKYC: boolean;
        requiresValid2FAMethod: boolean;
        requiresEmailVerification: boolean;
        hasInsufficientBalance: boolean;
        canRetry: boolean;
        hasAmountError: boolean;
        hasAddressError: boolean;
        hasNetworkError: boolean;
        hasWalletNotFoundError: boolean;
        hasInvalidCredentialsError: boolean;
        invalid2FAAttempts: number;
        retryAttempts: number;
        maxRetryAttempts: number;
        exchanges: {
            id: string;
            name: string;
            logoUrl: string;
            status: string;
        }[];
        walletBalances: {
            asset: string;
            balance: string;
            balanceInFiat?: string;
            networks?: Array<{
                id: string;
                name: string;
                displayName: string;
                minWithdrawal: string;
                maxWithdrawal?: string;
                assetName: string;
                addressRegex?: string | null;
            }>;
            extra?: {
                slug?: string;
                assetId?: string;
            };
        }[];
        quote: {
            id: string;
            asset: string;
            amount: string;
            estimatedFee: string;
            estimatedTotal: string;
            amountWithFeeInFiat: string;
            amountNoFeeInFiat: string;
            estimatedFeeInFiat: string;
            additionalInfo: {
                minWithdrawal: string | null;
                maxWithdrawal?: string | null;
            };
            expiresAt: number;
        } | undefined;
        withdrawal: {
            id: string;
            status: string;
            transactionId?: string;
        } | undefined;
        valid2FAMethods: string[] | undefined;
        multiStep2FA: {
            bizNo: string;
            steps: Array<{
                type: "GOOGLE" | "EMAIL" | "FACE" | "SMS";
                status: "pending" | "success" | "failed";
                required: boolean;
                metadata?: {
                    email?: string;
                    emailSent?: boolean;
                    qrCodeUrl?: string;
                    qrCodeValidSeconds?: number;
                };
            }>;
            relation: "AND" | "OR";
            collectedCodes?: {
                twofa?: string;
                emailCode?: string;
                smsCode?: string;
            };
            faceQrCodeUrl?: string;
            faceQrCodeExpiresAt?: number;
            mfa?: {
                verified: {
                    GOOGLE?: boolean;
                    EMAIL?: boolean;
                    FACE?: boolean;
                    SMS?: boolean;
                };
            };
        } | undefined;
        multiStep2FASteps: {
            type: "GOOGLE" | "EMAIL" | "FACE" | "SMS";
            status: "pending" | "success" | "failed";
            required: boolean;
            metadata?: {
                email?: string;
                emailSent?: boolean;
                qrCodeUrl?: string;
                qrCodeValidSeconds?: number;
            };
        }[];
        multiStep2FABizNo: string | undefined;
        multiStep2FARelation: "AND" | "OR" | undefined;
        collectedMultiStep2FACodes: {
            twofa?: string;
            emailCode?: string;
            smsCode?: string;
        } | undefined;
        hasGoogleStep: boolean;
        hasEmailStep: boolean;
        hasFaceStep: boolean;
        hasSmsStep: boolean;
        isGoogleStepVerified: boolean;
        isEmailStepVerified: boolean;
        isFaceStepVerified: boolean;
        isSmsStepVerified: boolean;
        mfaVerified: {
            GOOGLE?: boolean;
            EMAIL?: boolean;
            FACE?: boolean;
            SMS?: boolean;
        } | undefined;
        allMultiStep2FAStepsVerified: boolean;
        faceQrCodeUrl: string | undefined;
        faceQrCodeExpiresAt: number | undefined;
        client: import("@bluvo/sdk-ts").BluvoFlowClient;
        state: import("@bluvo/sdk-ts").FlowState | null;
        send: (action: import("@bluvo/sdk-ts").FlowActionType) => void;
        isInState: (stateType: import("@bluvo/sdk-ts").FlowState["type"]) => boolean;
        hasError: boolean;
        error: Error | null | undefined;
        context: (Record<string, any> & import("@bluvo/sdk-ts").FlowContext) | undefined;
    };
    isConnected: boolean;
    walletId: string | undefined;
    authorizedConnections: Partial<Record<BluvoExchangeType, string>>;
    handleStartWithdrawal: (brokerType: BluvoExchangeType) => Promise<{
        machine: import("@bluvo/sdk-ts").Machine<import("@bluvo/sdk-ts").FlowState, import("@bluvo/sdk-ts").FlowActionType>;
        closeOAuthWindow: null;
    } | {
        machine: import("@bluvo/sdk-ts").Machine<import("@bluvo/sdk-ts").FlowState, import("@bluvo/sdk-ts").FlowActionType>;
        closeOAuthWindow: () => void;
    } | undefined>;
    quoteExpiresAt: number | undefined;
};
export {};
