@chipi-stack/chipi-react/dist/hooks.d.ts

React hooks and components for Chipi SDK

import { CreateWalletParams, CreateWalletResponse, GetWalletParams, GetWalletResponse, TransferHookInput, ApproveHookInput, CreateSkuTransactionParams, SkuTransaction, GetSkusQuery, PaginatedResponse, Sku, StakeVesuUsdcHookInputParams, WithdrawVesuUsdcHookInputParams, CallAnyContractParams, RecordSendTransactionParams, Transaction, GetTokenBalanceParams, GetTokenBalanceResponse } from '@chipi-stack/types';
import * as _tanstack_react_query from '@tanstack/react-query';
import { UseQueryOptions } from '@tanstack/react-query';

type CreateWalletInput = {
    params: CreateWalletParams;
    bearerToken: string;
};
/**
 * Hook for creating a new wallet
 */
declare function useCreateWallet(): {
    createWallet: (input: CreateWalletInput) => void;
    createWalletAsync: (input: CreateWalletInput) => Promise<CreateWalletResponse>;
    data: CreateWalletResponse | undefined;
    isLoading: boolean;
    isError: boolean;
    error: Error | null;
    isSuccess: boolean;
    reset: () => void;
};

type GetWalletInput = {
    params?: GetWalletParams;
    getBearerToken?: () => Promise<string | null | undefined>;
    queryOptions?: Omit<UseQueryOptions<(GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null, Error>, "queryKey" | "queryFn">;
};
declare function useGetWallet(input?: GetWalletInput): {
    fetchWallet: (newInput: GetWalletInput) => Promise<(GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null>;
    data: (GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null;
    error: Error;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    isPlaceholderData: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<(GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<(GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null>;
} | {
    fetchWallet: (newInput: GetWalletInput) => Promise<(GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null>;
    data: (GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    isPlaceholderData: false;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<(GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<(GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null>;
} | {
    fetchWallet: (newInput: GetWalletInput) => Promise<(GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null>;
    data: undefined;
    error: Error;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<(GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<(GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null>;
} | {
    fetchWallet: (newInput: GetWalletInput) => Promise<(GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null>;
    data: undefined;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<(GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<(GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null>;
} | {
    fetchWallet: (newInput: GetWalletInput) => Promise<(GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null>;
    data: undefined;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<(GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<(GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null>;
} | {
    fetchWallet: (newInput: GetWalletInput) => Promise<(GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null>;
    data: (GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null;
    isError: false;
    error: null;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    isPlaceholderData: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<(GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<(GetWalletResponse & {
        normalizedPublicKey: string;
    }) | null>;
};

type TransferInput = {
    params: TransferHookInput;
    bearerToken: string;
};
/**
 * Hook for transferring tokens
 */
declare function useTransfer(): {
    transfer: (input: TransferInput) => void;
    transferAsync: (input: TransferInput) => Promise<string>;
    data: string | undefined;
    isLoading: boolean;
    isError: boolean;
    error: Error | null;
    isSuccess: boolean;
    reset: () => void;
};

type ApproveInput = {
    params: ApproveHookInput;
    bearerToken: string;
};
/**
 * Hook for approving token spending
 */
declare function useApprove(): {
    approve: (params: ApproveInput) => void;
    approveAsync: (params: ApproveInput) => Promise<string>;
    data: string | undefined;
    isLoading: boolean;
    isError: boolean;
    error: Error | null;
    isSuccess: boolean;
    reset: () => void;
};

type CreateSkuTransactionInput = {
    params: CreateSkuTransactionParams;
    bearerToken: string;
};
/**
 * Hook for creating SKU transactions
 */
declare function useCreateSkuTransaction(): {
    createSkuTransaction: (input: CreateSkuTransactionInput) => void;
    createSkuTransactionAsync: (input: CreateSkuTransactionInput) => Promise<SkuTransaction>;
    data: SkuTransaction | undefined;
    isLoading: boolean;
    isError: boolean;
    error: Error | null;
    isSuccess: boolean;
    reset: () => void;
};

type GetSkuTransactionByIdInput = {
    id: string;
    getBearerToken?: () => Promise<string | null | undefined>;
    queryOptions?: Omit<UseQueryOptions<SkuTransaction, Error>, 'queryKey' | 'queryFn'>;
};
declare function useGetSkuTransactionById(input?: GetSkuTransactionByIdInput): {
    fetchSkuTransactionById: (newInput: GetSkuTransactionByIdInput) => Promise<SkuTransaction>;
    data: SkuTransaction;
    error: Error;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    isPlaceholderData: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<SkuTransaction, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<SkuTransaction>;
} | {
    fetchSkuTransactionById: (newInput: GetSkuTransactionByIdInput) => Promise<SkuTransaction>;
    data: SkuTransaction;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    isPlaceholderData: false;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<SkuTransaction, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<SkuTransaction>;
} | {
    fetchSkuTransactionById: (newInput: GetSkuTransactionByIdInput) => Promise<SkuTransaction>;
    data: undefined;
    error: Error;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<SkuTransaction, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<SkuTransaction>;
} | {
    fetchSkuTransactionById: (newInput: GetSkuTransactionByIdInput) => Promise<SkuTransaction>;
    data: undefined;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<SkuTransaction, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<SkuTransaction>;
} | {
    fetchSkuTransactionById: (newInput: GetSkuTransactionByIdInput) => Promise<SkuTransaction>;
    data: undefined;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<SkuTransaction, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<SkuTransaction>;
} | {
    fetchSkuTransactionById: (newInput: GetSkuTransactionByIdInput) => Promise<SkuTransaction>;
    data: SkuTransaction;
    isError: false;
    error: null;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    isPlaceholderData: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<SkuTransaction, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<SkuTransaction>;
};

type GetSkusInput = {
    query?: GetSkusQuery;
    getBearerToken?: () => Promise<string | null | undefined>;
    queryOptions?: Omit<UseQueryOptions<PaginatedResponse<Sku>, Error>, 'queryKey' | 'queryFn'>;
};
declare function useGetSkus(input?: GetSkusInput): {
    fetchAvailableSkus: (newInput: GetSkusInput) => Promise<PaginatedResponse<Sku>>;
    data: PaginatedResponse<Sku>;
    error: Error;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    isPlaceholderData: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<Sku>, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<PaginatedResponse<Sku>>;
} | {
    fetchAvailableSkus: (newInput: GetSkusInput) => Promise<PaginatedResponse<Sku>>;
    data: PaginatedResponse<Sku>;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    isPlaceholderData: false;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<Sku>, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<PaginatedResponse<Sku>>;
} | {
    fetchAvailableSkus: (newInput: GetSkusInput) => Promise<PaginatedResponse<Sku>>;
    data: undefined;
    error: Error;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<Sku>, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<PaginatedResponse<Sku>>;
} | {
    fetchAvailableSkus: (newInput: GetSkusInput) => Promise<PaginatedResponse<Sku>>;
    data: undefined;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<Sku>, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<PaginatedResponse<Sku>>;
} | {
    fetchAvailableSkus: (newInput: GetSkusInput) => Promise<PaginatedResponse<Sku>>;
    data: undefined;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<Sku>, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<PaginatedResponse<Sku>>;
} | {
    fetchAvailableSkus: (newInput: GetSkusInput) => Promise<PaginatedResponse<Sku>>;
    data: PaginatedResponse<Sku>;
    isError: false;
    error: null;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    isPlaceholderData: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<Sku>, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<PaginatedResponse<Sku>>;
};

type StakeVesuUsdcInput = {
    params: StakeVesuUsdcHookInputParams;
    bearerToken: string;
};
/**
 * Hook for staking USDC in Vesu protocol
 */
declare function useStakeVesuUsdc(): {
    stakeVesuUsdc: (params: StakeVesuUsdcInput) => void;
    stakeVesuUsdcAsync: (params: StakeVesuUsdcInput) => Promise<string>;
    data: string | undefined;
    isLoading: boolean;
    isError: boolean;
    error: Error | null;
    isSuccess: boolean;
    reset: () => void;
};

type WithdrawVesuUsdcInput = {
    params: WithdrawVesuUsdcHookInputParams;
    bearerToken: string;
};
/**
 * Hook for withdrawing USDC from Vesu protocol
 */
declare function useWithdrawVesuUsdc(): {
    withdrawVesuUsdc: (params: WithdrawVesuUsdcInput) => void;
    withdrawVesuUsdcAsync: (params: WithdrawVesuUsdcInput) => Promise<string>;
    data: string | undefined;
    isLoading: boolean;
    isError: boolean;
    error: Error | null;
    isSuccess: boolean;
    reset: () => void;
};

type CallAnyContractInput = {
    params: CallAnyContractParams;
    bearerToken: string;
};
/**
 * Hook for calling any contract method
 */
declare function useCallAnyContract(): {
    callAnyContract: (params: CallAnyContractInput) => void;
    callAnyContractAsync: (params: CallAnyContractInput) => Promise<string>;
    data: string | undefined;
    isLoading: boolean;
    isError: boolean;
    error: Error | null;
    isSuccess: boolean;
    reset: () => void;
};

type RecordSendTransactionInput = {
    params: RecordSendTransactionParams;
    bearerToken: string;
};
declare function useRecordSendTransaction(): {
    recordSendTransaction: (input: RecordSendTransactionInput) => void;
    recordSendTransactionAsync: (input: RecordSendTransactionInput) => Promise<Transaction>;
    data: Transaction | undefined;
    isLoading: boolean;
    isError: boolean;
    error: Error | null;
    isSuccess: boolean;
    reset: () => void;
};

type GetTokenBalanceInput = {
    params?: GetTokenBalanceParams;
    getBearerToken?: () => Promise<string | null | undefined>;
    queryOptions?: Omit<UseQueryOptions<GetTokenBalanceResponse, Error>, 'queryKey' | 'queryFn'>;
};
declare function useGetTokenBalance(input?: GetTokenBalanceInput): {
    fetchTokenBalance: (newInput: GetTokenBalanceInput) => Promise<GetTokenBalanceResponse>;
    data: GetTokenBalanceResponse;
    error: Error;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    isPlaceholderData: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetTokenBalanceResponse, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<GetTokenBalanceResponse>;
} | {
    fetchTokenBalance: (newInput: GetTokenBalanceInput) => Promise<GetTokenBalanceResponse>;
    data: GetTokenBalanceResponse;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    isPlaceholderData: false;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetTokenBalanceResponse, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<GetTokenBalanceResponse>;
} | {
    fetchTokenBalance: (newInput: GetTokenBalanceInput) => Promise<GetTokenBalanceResponse>;
    data: undefined;
    error: Error;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetTokenBalanceResponse, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<GetTokenBalanceResponse>;
} | {
    fetchTokenBalance: (newInput: GetTokenBalanceInput) => Promise<GetTokenBalanceResponse>;
    data: undefined;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetTokenBalanceResponse, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<GetTokenBalanceResponse>;
} | {
    fetchTokenBalance: (newInput: GetTokenBalanceInput) => Promise<GetTokenBalanceResponse>;
    data: undefined;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetTokenBalanceResponse, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<GetTokenBalanceResponse>;
} | {
    fetchTokenBalance: (newInput: GetTokenBalanceInput) => Promise<GetTokenBalanceResponse>;
    data: GetTokenBalanceResponse;
    isError: false;
    error: null;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    isPlaceholderData: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<GetTokenBalanceResponse, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<GetTokenBalanceResponse>;
};

export { useApprove, useCallAnyContract, useCreateSkuTransaction, useCreateWallet, useGetSkuTransactionById, useGetSkus, useGetTokenBalance, useGetWallet, useRecordSendTransaction, useStakeVesuUsdc, useTransfer, useWithdrawVesuUsdc };