import { CosmosAddress, CosmosBalance, Config, ExecuteRoute, GetStatus, TransactionResponses, RouteRequest, RouteResponse, StatusResponse, Token, TokenBalance, TransactionResponse } from "./types";
import { TokensChains } from "./utils/TokensChains";
export declare class Squid extends TokensChains {
    private httpInstance;
    private handlers;
    initialized: boolean;
    config: Config;
    isInMaintenanceMode: boolean;
    maintenanceMessage: string | undefined;
    axelarscanURL: string | undefined;
    constructor(config?: Config);
    setConfig(config: Config): void;
    init(): Promise<void>;
    getStatus(params: GetStatus): Promise<StatusResponse>;
    getRoute(params: RouteRequest): Promise<RouteResponse>;
    executeRoute(data: ExecuteRoute): Promise<TransactionResponses>;
    private executeOnChainTx;
    private requestDepositAddress;
    private getRouteSignature;
    isRouteApproved({ route, sender, }: {
        route: RouteResponse["route"];
        sender: string;
    }): Promise<{
        isApproved: boolean;
        message: string;
    }>;
    approveRoute(data: ExecuteRoute): Promise<TransactionResponse | null>;
    getRawTxHex(data: Omit<ExecuteRoute, "signer"> & {
        nonce: number;
    }): string;
    getTokenPrice({ tokenAddress, chainId, }: {
        tokenAddress: string;
        chainId: string;
    }): Promise<number>;
    /**
     * Return tokens with USD price
     * If chainId is provided, it will return only tokens for that chain
     * if not, it will return all tokens
     * @param {chainId?: string}
     * @returns {Promise<Token[]>}
     */
    getMultipleTokensPrice({ chainId }: {
        chainId?: string;
    }): Promise<Token[]>;
    getFromAmount({ fromToken, toAmount, toToken, slippagePercentage, }: {
        fromToken: Token;
        toToken: Token;
        toAmount: string;
        slippagePercentage?: number;
    }): Promise<string>;
    getEvmBalances({ userAddress, chains, }: {
        userAddress: string;
        chains?: (string | number)[];
    }): Promise<TokenBalance[]>;
    getCosmosBalances({ addresses, chainIds, }: {
        addresses: CosmosAddress[];
        chainIds?: (string | number)[];
    }): Promise<CosmosBalance[]>;
    getAllBalances({ chainIds, cosmosAddresses, evmAddress, }: {
        chainIds?: (string | number)[];
        cosmosAddresses?: CosmosAddress[];
        evmAddress?: string;
    }): Promise<{
        cosmosBalances?: CosmosBalance[];
        evmBalances?: TokenBalance[];
    }>;
    private validateInit;
    private validateTransactionRequest;
}