import { Address, ContractFunctionParameters, Hex } from 'viem';
import { AuthenticationResponseJSON, PublicKeyCredentialRequestOptionsJSON } from '@simplewebauthn/typescript-types';
import { CreateWalletResult, LinkTransferHistoryItem, PagingOptions, SwapHistoryItem, TransferHistoryItem, TransferByLinkResponse, DistributeRequest, GetLinkTransferResponse, TokenDistributeRequestEntity, SharedWalletList, TransferHistoryQuery, TokenHolder, TokenActivity, PumToken, PumActionHistory, PumTokenPrice, SubKeyMessage } from '../types';
import { DutchOrder, FeeTier, SwapOrder } from '@prex0/prex-structs';
import { TransferOptions } from '../actions/transfer';
import { PrexSigner } from '../core/sign';
import { PublicActions } from 'viem';
export type FacilitatorConfig = {
    feeTiers: FeeTier[];
    maxFeePerGas: string;
    maxPriorityFeePerGas: string;
};
export interface PrexClientInterface {
    balances: Record<Address, bigint>;
    allowances: Record<Address, bigint>;
    getSigner(): PrexSigner | null;
    getPublicClient(): PublicActions | null;
    startHandler(): Promise<void>;
    load(): Promise<void>;
    getLinkTransfer(id: string): Promise<GetLinkTransferResponse | null>;
    getLinkTransferBySecret(secret: string): Promise<GetLinkTransferResponse | null>;
    getUser(): any;
    fetchBalance(token: Address, owner?: Address): Promise<{
        balance: bigint | undefined;
        allowance: bigint | undefined;
    }>;
    fetchBalanceBatch(tokens: Address[], user?: Address): Promise<{
        token: Address;
        balance: bigint | undefined;
        isSuccess: boolean;
    }[]>;
    transfer(params: {
        token: Address;
        recipient: Address;
        amount: bigint;
        metadata?: Record<string, string>;
        sender?: Address;
    }, options?: TransferOptions): 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?: {
        user: Address;
    } | {
        token: Address;
    }, pagingOptions?: PagingOptions): Promise<LinkTransferHistoryItem[]>;
    getTokenHolders(query: {
        token: Address;
    }, pagingOptions?: PagingOptions): Promise<TokenHolder[]>;
    getTokenHolder(query: {
        token: Address;
        address?: Address;
    }): 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: Hex;
        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({ nickName, from, }: {
        nickName: string;
        from?: Address;
    }): Promise<void>;
    uploadAvatar({ image, from }: {
        image: File;
        from?: Address;
    }): Promise<{
        path: string;
        fullPath: string;
        url: string;
    }>;
    logout(): Promise<void>;
    authenticate(options: PublicKeyCredentialRequestOptionsJSON): Promise<AuthenticationResponseJSON>;
    executeOperation(contracts: ContractFunctionParameters, from?: Address): Promise<{
        hash: `0x${string}`;
    }>;
    switchChain(chainId: number): Promise<any>;
    getChainId(): Promise<number>;
    setApiKey(apiKey: string): void;
    setProvider(provider: any): void;
    isPasskeyAvailable(): Promise<boolean>;
    getTokenDetails(token: Address): Promise<{
        name: string;
        symbol: string;
        decimals: number;
    }>;
    getTokenActivity(token: Address): Promise<TokenActivity>;
    getSharedWalletAddress(owners: Address[], nonce: number): Promise<Address>;
    createSharedWallet({ name, owners, nonce, }: {
        name: string;
        owners: Address[];
        nonce: number;
    }): Promise<Address>;
    addOwnerAddress({ owner, from, }: {
        owner: Address;
        from?: Address;
    }): Promise<void>;
    removeOwnerAtIndex({ index, owner, from, }: {
        index: number;
        owner: Address;
        from?: Address;
    }): Promise<void>;
    getSharedWallets(): Promise<SharedWalletList>;
    loadConfig(chainId: number): Promise<FacilitatorConfig>;
    getProfile(address: Address): Promise<{
        name?: string;
    }>;
    getAddressByName({ baseName, name, }: {
        baseName?: string;
        name: string;
    }): Promise<Address | null>;
    getPumAction(): PumpumActionInterface;
    signWithSubKey(params: {
        hash: Hex;
        from?: Address;
    }): Promise<{
        signature: Hex;
        message: SubKeyMessage;
        keyType: 'main' | 'sub';
    }>;
    existsSubKey(): Promise<boolean>;
    deleteSubKey(): Promise<void>;
}
export interface ProfileActionInterface {
    updateProfile({ domain, name, avatar, metadata, from, }: {
        domain?: number;
        name: string;
        avatar: File;
        metadata: Hex;
        from?: Address;
    }): Promise<void>;
    updateName({ domain, name, from, }: {
        domain?: number;
        name: string;
        from?: Address;
    }): Promise<void>;
    updateAvatar({ avatar, from, }: {
        avatar: File;
        from?: Address;
    }): Promise<void>;
    getProfile(address: Address): Promise<{
        domain: bigint;
        name: string;
        pictureHash: Hex;
        metadata: Hex;
    }>;
    uploadAvatar({ image, from }: {
        image: File;
        from?: Address;
    }): Promise<{
        path: string;
        fullPath: string;
        url: string;
    }>;
    copyAvatar({ pictureUrl, from, }: {
        pictureUrl: string;
        from?: Address;
    }): Promise<{
        path: string;
        fullPath: string;
        url: string;
    }>;
}
export interface DistributeActionInterface {
    submit(params: {
        token: Address;
        amount: bigint;
        amountPerWithdrawal: bigint;
        maxAmountPerAddress?: bigint;
        expiry: bigint;
        coolTime?: bigint;
        name: string;
        coordinate?: Hex;
        sender?: Address;
        registerPath?: string;
    }): Promise<{
        id: string;
        secret: string;
        shortCode: string;
    }>;
    generateSubSecret(id: Hex): Promise<{
        id: string;
        secret: string;
    }>;
    deposit(params: {
        amount: bigint;
        requestId: Hex;
        sender?: Address;
    }): Promise<void>;
    cancel(params: {
        requestId: Hex;
        from?: Address;
    }): Promise<void>;
    prepareSecret(params: {
        path: string;
        auth?: string;
        requestId: Hex;
        shortCode: string;
        recipient?: Address;
    }): Promise<{
        secret: string;
    }>;
    prepareReceive(params: {
        requestId: Hex;
        secret: string;
        recipient?: Address;
    }): Promise<DistributeRequest>;
    receive(params: {
        requestId: Hex;
    }): Promise<void>;
    queryRequests(query?: {
        user: Address;
    }, pagingOptions?: PagingOptions): Promise<TokenDistributeRequestEntity[]>;
    getRequest(id: Hex, { secret, coordinate, }: {
        secret?: Hex;
        coordinate?: Hex;
    }): Promise<DistributeRequest>;
}
export interface QuoteSwapParams {
    tokenIn: Address;
    tokenOut: Address;
    amount: bigint;
    tradeType: 'EXACT_INPUT' | 'EXACT_OUTPUT';
    swapper: Address;
    recipient: Address;
    slippageTolerance?: bigint;
}
export interface PumpumActionInterface {
    quoteSwap(quoteParams: 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>;
    getPumTokens(): Promise<PumToken[]>;
    getPumTimeline(pageOptions: PagingOptions): Promise<PumActionHistory[]>;
    getPumActionHistory(user: Address, pageOptions: PagingOptions): Promise<PumActionHistory[]>;
    getPumTokenPrice(token: Address, interval: 'HOUR' | 'DAY', pageOptions: PagingOptions): Promise<PumTokenPrice[]>;
    getMarketInfo(communityToken: Address): Promise<{
        reserveCT: bigint;
        reserveStable: bigint;
        sellable: boolean;
        feePercent: bigint;
    }>;
}
//# sourceMappingURL=prex-client-interface.d.ts.map