import { PublicKeyCredentialRequestOptionsJSON, AuthenticationResponseJSON } from '@simplewebauthn/typescript-types';
import { Address, Hex } from 'viem';
import { DistributeActionInterface, FacilitatorConfig, PrexClientInterface, ProfileActionInterface, PumpumActionInterface, QuoteSwapParams } from './interfaces/prex-client-interface';
import { CreateWalletResult, DistributeRequest, GetLinkTransferResponse, LinkTransferHistoryItem, PagingOptions, PrexUser, PumActionHistory, PumToken, PumTokenPrice, SharedWalletList, SubKeyMessage, SwapHistoryItem, Token, TokenActivity, TokenDistributeRequestEntity, TokenHolder, TransferByLinkResponse, TransferHistoryItem, TransferHistoryQuery } from './types';
import { DutchOrder, SwapOrder, SwapQuoter } from '@prex0/prex-structs';
import { PublicActions } from 'viem';
import { PrexSigner } from './core/sign';
export declare class DryRunClient implements PrexClientInterface {
    tokens: Token[];
    initialState: 'loggedIn' | 'loggedOut' | 'passkeyNotAvailable';
    user?: PrexUser;
    balances: Record<Address, bigint>;
    allowances: Record<Address, bigint>;
    distributeAction: DryRunDistributeAction;
    quoter: SwapQuoter;
    constructor(tokens: Token[], initialState?: 'loggedIn' | 'loggedOut' | 'passkeyNotAvailable');
    getSigner(): PrexSigner | null;
    getPublicClient(): PublicActions | null;
    startHandler(): Promise<void>;
    fetchBalance(token: Address, _owner?: Address): Promise<{
        balance: bigint | undefined;
        allowance: bigint | undefined;
    }>;
    fetchBalanceBatch(tokens: Address[], _user?: Address): Promise<{
        token: `0x${string}`;
        balance: bigint;
        isSuccess: boolean;
    }[]>;
    transfer(_params: {
        token: Address;
        recipient: Address;
        amount: bigint;
        metadata?: Record<string, string>;
        sender?: Address;
    }): Promise<{
        hash: Hex;
    }>;
    transferByLink(_params: {
        token: Address;
        amount: bigint;
        expiration: number;
        metadata?: Record<string, string>;
        sender?: Address;
    }): Promise<TransferByLinkResponse>;
    receiveLinkTransfer(params: {
        secret: Hex;
        recipient?: Address;
    }): Promise<{
        hash: Hex;
    }>;
    getHistory(_query?: TransferHistoryQuery, _pagingOptions?: PagingOptions): Promise<TransferHistoryItem[]>;
    getOnetimeLockHistory(_query?: {
        token: Address;
    } | {
        user: Address;
    }, _pagingOptions?: PagingOptions): Promise<LinkTransferHistoryItem[]>;
    getTokenHolder(_query: {
        token: Address;
        address?: Address;
    }): Promise<TokenHolder>;
    getTokenHolders(_query: {
        token: Address;
    }, _pagingOptions?: PagingOptions): Promise<TokenHolder[]>;
    getSwapHistory(_query?: {
        user: Address;
    }, _pagingOptions?: PagingOptions): Promise<SwapHistoryItem[]>;
    mint(_options: {
        token?: Address;
        recipient: Address;
        amount: bigint;
    }): Promise<void>;
    quoteSwap(params: {
        tokenIn: Address;
        tokenOut: Address;
        amount: bigint;
        tradeType: 'EXACT_INPUT' | 'EXACT_OUTPUT';
        swapper?: Address;
        recipient?: Address;
        slippageTolerance?: bigint;
    }): Promise<{
        quote: bigint;
        route: `0x${string}`;
        order: DutchOrder;
    }>;
    swap(_order: any, _route: Hex): Promise<{
        hash: Hex;
    }>;
    distribute(): DistributeActionInterface;
    getProfileAction(): ProfileActionInterface;
    approve(_params: {
        token: Address;
        amount?: bigint;
        from?: Address;
    }): Promise<void>;
    backupByEOA(_backupAddress: Address): Promise<void>;
    backupByPasskey(_ownerIndex?: number): Promise<void>;
    registerNewPasskey(): Promise<void>;
    recoverByEOA(_backupPrivateKey: Hex): Promise<void>;
    createWallet(_options?: {
        userName?: string;
        withDeploy?: boolean;
    }): Promise<CreateWalletResult | null>;
    restoreWallet(): Promise<void>;
    deployWallet(): Promise<void>;
    updateNickName(_params: {
        nickName: string;
        from?: Address;
    }): Promise<void>;
    uploadAvatar(_params: {
        image: File;
        from?: Address;
    }): Promise<{
        path: string;
        fullPath: string;
        url: string;
    }>;
    logout(): Promise<void>;
    authenticate(_options: PublicKeyCredentialRequestOptionsJSON): Promise<AuthenticationResponseJSON>;
    executeOperation(_contracts: any): Promise<any>;
    switchChain(_chainId: number): Promise<any>;
    getChainId(): Promise<number>;
    setApiKey(_apiKey: string): void;
    setProvider(_provider: any): void;
    isPasskeyAvailable(): Promise<boolean>;
    load(): Promise<void>;
    private generateUser;
    getUser(): PrexUser | undefined;
    getLinkTransfer(_id: string): Promise<GetLinkTransferResponse>;
    getLinkTransferBySecret(_secret: string): Promise<GetLinkTransferResponse>;
    getTokenDetails(_token: Address): Promise<{
        name: string;
        symbol: string;
        decimals: number;
    }>;
    getTokenActivity(_token: Address): Promise<TokenActivity>;
    getSharedWalletAddress(_owners: Address[], _nonce: number): Promise<`0x${string}`>;
    createSharedWallet(_params: {
        name: string;
        owners: Address[];
        nonce: number;
    }): Promise<`0x${string}`>;
    addOwnerAddress(_params: {
        owner: Address;
        from?: Address;
    }): Promise<void>;
    removeOwnerAtIndex(_params: {
        index: number;
        owner: Address;
        from?: Address;
    }): Promise<void>;
    getSharedWallets(): Promise<SharedWalletList>;
    loadConfig(_chainId: number): Promise<FacilitatorConfig>;
    getProfile(_address: Address): Promise<{
        name?: string;
    }>;
    getAddressByName(_params: {
        baseName?: string;
        name: string;
    }): Promise<Address | null>;
    getPumAction(): DryRunPumpumAction;
    signWithSubKey(_params: {
        hash: Hex;
        from?: Address;
    }): Promise<{
        signature: Hex;
        message: SubKeyMessage;
        keyType: 'main' | 'sub';
    }>;
    existsSubKey(): Promise<boolean>;
    deleteSubKey(): Promise<void>;
}
declare class DryRunDistributeAction implements DistributeActionInterface {
    tokens: Token[];
    private coordinate;
    constructor(tokens: Token[]);
    submit(params: {
        token: `0x${string}`;
        amount: bigint;
        amountPerWithdrawal: bigint;
        maxAmountPerAddress?: bigint;
        expiry: bigint;
        coolTime?: bigint;
        name: string;
        coordinate?: `0x${string}`;
    }): Promise<{
        id: `0x${string}`;
        secret: `0x${string}`;
        shortCode: string;
    }>;
    generateSubSecret(id: Hex): Promise<{
        id: `0x${string}`;
        secret: string;
    }>;
    deposit({}: {
        amount: bigint;
        requestId: Hex;
    }): Promise<void>;
    cancel(_params: {
        requestId: Hex;
        from?: Address;
    }): Promise<void>;
    getRequest(_requestId: Hex, _params: {
        secret?: Hex;
        coordinate?: Hex;
    }): Promise<DistributeRequest>;
    prepareSecret(_params: {
        requestId: Hex;
        recipient?: Address;
    }): Promise<{
        secret: string;
    }>;
    prepareReceive({ requestId, }: {
        requestId: `0x${string}`;
        secret: `0x${string}`;
    }): Promise<DistributeRequest>;
    receive({ requestId, }: {
        requestId: `0x${string}`;
        sig: `0x${string}`;
        nonce: bigint;
        deadline: bigint;
        recipient: `0x${string}`;
    }): Promise<void>;
    queryRequests(): Promise<TokenDistributeRequestEntity[]>;
}
export declare class DryRunPumpumAction implements PumpumActionInterface {
    tokens: Token[];
    constructor(tokens: Token[]);
    quoteSwap(params: QuoteSwapParams): Promise<SwapOrder>;
    executeSwap(_order: SwapOrder): Promise<{
        hash: Hex;
    }>;
    issueTokens(_params: {
        name: string;
        symbol: string;
        amount: bigint;
        metadata?: string;
    }): Promise<{
        hash: Hex;
        result: Address;
    }>;
    buy(_params: {
        dai: Address;
        amount: bigint;
    }): Promise<void>;
    getPumTimeline(_pageOptions: PagingOptions): Promise<PumActionHistory[]>;
    getPumActionHistory(_user: Address, _pageOptions: PagingOptions): Promise<PumActionHistory[]>;
    getPumTokens(): Promise<PumToken[]>;
    getPumTokenPrice(_token: Address, _interval: 'HOUR' | 'DAY', _pageOptions: PagingOptions): Promise<PumTokenPrice[]>;
    getMarketInfo(_communityToken: Address): Promise<{
        reserveCT: bigint;
        reserveStable: bigint;
        sellable: boolean;
        feePercent: bigint;
    }>;
}
export {};
//# sourceMappingURL=dry-run-client.d.ts.map