import * as _tanstack_react_query from '@tanstack/react-query';
import { useQuery, QueryClient } from '@tanstack/react-query';
import { Simplify, FetchAccountConfig, Account, Address, Decoder, GetBalanceApi, SolanaClient, GetLatestBlockhashApi, FetchAccountsConfig, GetProgramAccountsApi, SolanaRpcResponse, AccountInfoWithPubkey, AccountInfoBase, AccountInfoWithBase64EncodedData, AccountInfoWithBase64EncodedZStdCompressedData, AccountInfoWithJsonData, GetRecentPrioritizationFeesApi, GetSignatureStatusesApi, Signature, GetSignaturesForAddressApi, SimulateTransactionApi, Base64EncodedWireTransaction, GetSlotApi, GetTokenAccountBalanceApi, GetTransactionApi } from 'gill';
import { Token, Mint } from 'gill/programs';
import React from 'react';
export * from '@solana/react';
export * from '@solana/wallet-standard-chains';
export * from '@solana/wallet-standard-features';
export * from '@wallet-standard/core';
export * from '@wallet-standard/react';
export * from '@wallet-standard/ui';

/**
 * @private
 */
declare const GILL_NAME = "gill";
declare const GILL_HOOK_CLIENT_KEY = "gill-client";

type OmittedUseQueryFields = "queryKey" | "queryFn";
type GillUseQueryDefaultOptions = Omit<Parameters<typeof useQuery>[0], OmittedUseQueryFields>;
type GillUseRpcHook<TConfig, TOptions extends GillUseQueryDefaultOptions = GillUseQueryDefaultOptions> = {
    /**
     * RPC configuration passed to the RPC method being called
     */
    config?: TConfig;
    /**
     * Options passed to the {@link useQuery} hook
     */
    options?: Simplify<TOptions>;
    /**
     * Signal used to abort the RPC operation
     *
     * See MDN docs for {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | AbortSignal}
     * and {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortController | AbortController}
     */
    abortSignal?: AbortSignal;
};

type RpcConfig$c = Simplify<Omit<FetchAccountConfig, "abortSignal">>;
type UseAccountResponse<TAddress extends string = string, TData extends Uint8Array | object = Uint8Array> = Account<TData, TAddress> & {
    exists: true;
};
type UseAccountInput<TConfig extends RpcConfig$c = RpcConfig$c, TAddress extends string = string, TDecodedData extends object = Uint8Array> = GillUseRpcHook<TConfig> & {
    /**
     * Address of the account to get the balance of
     */
    address: Address | TAddress;
    /**
     * Account decoder that can decode the account's `data` byte array value
     */
    decoder?: Decoder<TDecodedData>;
};
/**
 * Get the account info for an address using the Solana RPC method of
 * [`getAccountInfo`](https://solana.com/docs/rpc/http/getaccountinfo)
 */
declare function useAccount<TConfig extends RpcConfig$c = RpcConfig$c, TAddress extends string = string, TDecodedData extends object = Uint8Array>({ options, config, abortSignal, address, decoder }: UseAccountInput<TConfig, TAddress, TDecodedData>): {
    account: UseAccountResponse<TAddress, TDecodedData>;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    account: UseAccountResponse<TAddress, TDecodedData>;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    account: UseAccountResponse<TAddress, TDecodedData>;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    account: UseAccountResponse<TAddress, TDecodedData>;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    account: UseAccountResponse<TAddress, TDecodedData>;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
};

type RpcConfig$b = Simplify<Parameters<GetBalanceApi["getBalance"]>>[1];
type UseBalanceResponse = ReturnType<GetBalanceApi["getBalance"]>["value"];
type UseBalanceInput<TConfig extends RpcConfig$b = RpcConfig$b> = GillUseRpcHook<TConfig> & {
    /**
     * Address of the account to get the balance of
     */
    address: Address | string;
};
/**
 * Get an account's balance (in lamports) using the Solana RPC method of
 * [`getBalance`](https://solana.com/docs/rpc/http/getbalance)
 */
declare function useBalance<TConfig extends RpcConfig$b = RpcConfig$b>({ options, config, abortSignal, address, }: UseBalanceInput<TConfig>): {
    balance: UseBalanceResponse;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    balance: UseBalanceResponse;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    balance: UseBalanceResponse;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    balance: UseBalanceResponse;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    balance: UseBalanceResponse;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
};

/**
 * Get the current Solana client (including `rpc` and `rpcSubscriptions`)
 */
declare function useSolanaClient(): SolanaClient;
/**
 * Update your Solana client (including `rpc` and `rpcSubscriptions`)
 */
declare function useUpdateSolanaClient(): _tanstack_react_query.UseMutationResult<void, Error, SolanaClient, unknown>;

type RpcConfig$a = Simplify<Parameters<GetLatestBlockhashApi["getLatestBlockhash"]>>[0];
type UseLatestBlockhashResponse = ReturnType<GetLatestBlockhashApi["getLatestBlockhash"]>["value"];
type UseLatestBlockhashInput<TConfig extends RpcConfig$a = RpcConfig$a> = GillUseRpcHook<TConfig>;
/**
 * Get the latest blockhash using the Solana RPC method of
 * [`getLatestBlockhash`](https://solana.com/docs/rpc/http/getlatestblockhash)
 *
 * To auto refetch the latest blockhash, provide a `options.refetchInterval` value
 */
declare function useLatestBlockhash<TConfig extends RpcConfig$a = RpcConfig$a>({ options, config, abortSignal, }?: UseLatestBlockhashInput<TConfig>): {
    latestBlockhash: UseLatestBlockhashResponse;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    latestBlockhash: UseLatestBlockhashResponse;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    latestBlockhash: UseLatestBlockhashResponse;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    latestBlockhash: UseLatestBlockhashResponse;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    latestBlockhash: UseLatestBlockhashResponse;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
};

type RpcConfig$9 = Simplify<Omit<FetchAccountsConfig, "abortSignal">>;
type UseMultipleAccountsInput<TConfig extends RpcConfig$9 = RpcConfig$9, TAddress extends string = string, TDecodedData extends object = Uint8Array> = GillUseRpcHook<TConfig> & {
    /**
     * List of addresses to fetch accounts for.
     */
    addresses: Address<TAddress>[];
    /**
     * Optional decoder to decode the account's `data` buffer.
     */
    decoder?: Decoder<TDecodedData>;
};
type UseMultipleAccountsResponse<TAddress extends string = string, TDecodedData extends object = Uint8Array> = {
    accounts: Account<TDecodedData, TAddress>[];
};
/**
 * Fetch multiple accounts using the Solana RPC method of
 * [`getMultipleAccounts`](https://solana.com/docs/rpc/http/getmultipleaccounts)
 *
 * Optionally provide a {@link Decoder | `decoder`} to automatically decode all Accounts using it.
 */
declare function useMultipleAccounts<TConfig extends RpcConfig$9 = RpcConfig$9, TAddress extends string = string, TDecodedData extends object = Uint8Array>({ addresses, decoder, config, options, abortSignal }: UseMultipleAccountsInput<TConfig, TAddress, TDecodedData>): UseMultipleAccountsResponse<TAddress, TDecodedData>;

type Encoding = "base64" | "base64+zstd" | "jsonParsed";
type RpcConfig$8 = Simplify<Parameters<GetProgramAccountsApi["getProgramAccounts"]>[1] & Readonly<{
    encoding?: Encoding;
}>>;
type UseProgramAccountsInput<TConfig extends RpcConfig$8 = RpcConfig$8> = GillUseRpcHook<TConfig> & {
    /**
     * Address of the program used to call
     * [`getProgramAccounts`](https://solana.com/docs/rpc/http/getprogramaccounts)
     */
    program: Address | string;
};
type UseProgramAccountsResponse<TConfig extends RpcConfig$8> = TConfig extends {
    encoding: "base64";
    withContext: true;
} ? SolanaRpcResponse<AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithBase64EncodedData>[]> : TConfig extends {
    encoding: "base64";
} ? AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithBase64EncodedData>[] : TConfig extends {
    encoding: "base64+zstd";
    withContext: true;
} ? SolanaRpcResponse<AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithBase64EncodedZStdCompressedData>[]> : TConfig extends {
    encoding: "base64+zstd";
} ? AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithBase64EncodedZStdCompressedData>[] : TConfig extends {
    encoding: "jsonParsed";
    withContext: true;
} ? SolanaRpcResponse<AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithJsonData>[]> : TConfig extends {
    encoding: "jsonParsed";
} ? AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithJsonData>[] : TConfig extends {
    withContext: true;
} ? SolanaRpcResponse<AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithBase64EncodedData>[]> : AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithBase64EncodedData>[];
/**
 * Get all the accounts owned by a `program` using the Solana RPC method of
 * [`getProgramAccounts`](https://solana.com/docs/rpc/http/getprogramaccounts)
 */
declare function useProgramAccounts<TConfig extends RpcConfig$8 = RpcConfig$8>({ options, config, abortSignal, program, }: UseProgramAccountsInput<TConfig>): {
    accounts: Simplify<UseProgramAccountsResponse<TConfig>>;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    accounts: Simplify<UseProgramAccountsResponse<TConfig>>;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    accounts: Simplify<UseProgramAccountsResponse<TConfig>>;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    accounts: Simplify<UseProgramAccountsResponse<TConfig>>;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    accounts: Simplify<UseProgramAccountsResponse<TConfig>>;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
};

type UseRecentPrioritizationFeesInput = Simplify<Pick<GillUseRpcHook<{}>, "abortSignal" | "options"> & {
    addresses?: Parameters<GetRecentPrioritizationFeesApi["getRecentPrioritizationFees"]>[0];
}>;
type UseRecentPrioritizationFeesResponse = ReturnType<GetRecentPrioritizationFeesApi["getRecentPrioritizationFees"]>;
/**
 * Get the recent prioritization fees for a list of addresses using the Solana RPC method of
 * [`getRecentPrioritizationFees`](https://solana.com/docs/rpc/http/getrecentprioritizationfees)
 */
declare function useRecentPrioritizationFees({ options, abortSignal, addresses, }?: UseRecentPrioritizationFeesInput): {
    fees: UseRecentPrioritizationFeesResponse;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    fees: UseRecentPrioritizationFeesResponse;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    fees: UseRecentPrioritizationFeesResponse;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    fees: UseRecentPrioritizationFeesResponse;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    fees: UseRecentPrioritizationFeesResponse;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
};

type RpcConfig$7 = Simplify<Parameters<GetSignatureStatusesApi["getSignatureStatuses"]>[1]>;
type UseSignatureStatusesInput<TConfig extends RpcConfig$7 = RpcConfig$7> = GillUseRpcHook<TConfig> & {
    /**
     * List of signatures used to call
     * [`getSignatureStatuses`](https://solana.com/docs/rpc/http/getsignaturestatuses)
     */
    signatures: Signature[] | string[];
};
type UseSignatureStatusesResponse = ReturnType<GetSignatureStatusesApi["getSignatureStatuses"]>["value"];
/**
 * Get the statuses of signatures using the Solana RPC method of
 * [`getSignatureStatuses`](https://solana.com/docs/rpc/http/getsignaturestatuses)
 */
declare function useSignatureStatuses<TConfig extends RpcConfig$7 = RpcConfig$7>({ options, config, abortSignal, signatures, }: UseSignatureStatusesInput<TConfig>): {
    statuses: UseSignatureStatusesResponse;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    statuses: UseSignatureStatusesResponse;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    statuses: UseSignatureStatusesResponse;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    statuses: UseSignatureStatusesResponse;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    statuses: UseSignatureStatusesResponse;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
};

type RpcConfig$6 = Simplify<Parameters<GetSignaturesForAddressApi["getSignaturesForAddress"]>[1]>;
type UseSignaturesForAddressInput<TConfig extends RpcConfig$6 = RpcConfig$6> = GillUseRpcHook<TConfig> & {
    /**
     * Address of the account to fetch signatures of
     */
    address: Address | string;
};
type UseSignaturesForAddressResponse = ReturnType<GetSignaturesForAddressApi["getSignaturesForAddress"]>;
/**
 * Returns signatures for confirmed transactions that include the given address
 * in their `accountKeys` list. Returns signatures backwards in time from the
 * provided signature or most recent confirmed block using the Solana RPC method of
 * [`getSignaturesForAddress`](https://solana.com/docs/rpc/http/getsignaturesforaddress)
 */
declare function useSignaturesForAddress<TConfig extends RpcConfig$6 = RpcConfig$6>({ options, config, abortSignal, address, }: UseSignaturesForAddressInput<TConfig>): {
    signatures: UseSignaturesForAddressResponse;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    signatures: UseSignaturesForAddressResponse;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    signatures: UseSignaturesForAddressResponse;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    signatures: UseSignaturesForAddressResponse;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    signatures: UseSignaturesForAddressResponse;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
};

type RpcConfig$5 = Simplify<Parameters<SimulateTransactionApi["simulateTransaction"]>>[1];
type UseSimulateTransactionInput<TConfig extends RpcConfig$5 = RpcConfig$5> = Omit<GillUseRpcHook<TConfig>, "config"> & {
    transaction: Base64EncodedWireTransaction;
    /**
     * @default { replaceRecentBlockhash: true, sigVerify: false, encoding: "base64", commitment: "confirmed" }
     */
    config?: TConfig;
};
type UseSimulateTransactionResponse = ReturnType<SimulateTransactionApi["simulateTransaction"]>;
/**
 * Simulate a transaction using the Solana RPC method of
 * [`simulateTransaction`](https://solana.com/docs/rpc/http/simulatetransaction)
 */
declare function useSimulateTransaction<TConfig extends RpcConfig$5 = RpcConfig$5>({ options, config, abortSignal, transaction, }: UseSimulateTransactionInput<TConfig>): {
    simulation: UseSimulateTransactionResponse;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    simulation: UseSimulateTransactionResponse;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    simulation: UseSimulateTransactionResponse;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    simulation: UseSimulateTransactionResponse;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    simulation: UseSimulateTransactionResponse;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
};

type RpcConfig$4 = Simplify<Parameters<GetSlotApi["getSlot"]>>[0];
type UseSlotResponse = ReturnType<GetSlotApi["getSlot"]>;
type UseSlotInput<TConfig extends RpcConfig$4 = RpcConfig$4> = GillUseRpcHook<TConfig>;
/**
 * Get the current slot using the Solana RPC method of
 * [`getSlot`](https://solana.com/docs/rpc/http/getslot)
 *
 * To auto refetch the slot, provide a `options.refetchInterval` value
 */
declare function useSlot<TConfig extends RpcConfig$4 = RpcConfig$4>({ options, config, abortSignal, }?: UseSlotInput<TConfig>): {
    slot: UseSlotResponse;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    slot: UseSlotResponse;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    slot: UseSlotResponse;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    slot: UseSlotResponse;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    slot: UseSlotResponse;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
};

type RpcConfig$3 = Simplify<Parameters<GetTokenAccountBalanceApi["getTokenAccountBalance"]>>[1];
type UseTokenAccountBalanceInput<TConfig extends RpcConfig$3 = RpcConfig$3> = GillUseRpcHook<TConfig> & {
    address: Address | string;
};
type UseTokenAccountBalanceResponse = ReturnType<GetTokenAccountBalanceApi["getTokenAccountBalance"]>;
declare function useTokenAccountBalance<TConfig extends RpcConfig$3 = RpcConfig$3>({ options, config, abortSignal, address, }: UseTokenAccountBalanceInput<TConfig>): {
    balance: UseTokenAccountBalanceResponse;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    balance: UseTokenAccountBalanceResponse;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    balance: UseTokenAccountBalanceResponse;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    balance: UseTokenAccountBalanceResponse;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    balance: UseTokenAccountBalanceResponse;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
};

type RpcConfig$2 = Simplify<Omit<FetchAccountConfig, "abortSignal">>;
type UseTokenAccountResponse<TAddress extends Address = Address> = Simplify<Account<Token, TAddress> & {
    exists: true;
}>;
type TokenAccountInputWithDeclaredAta<TAddress extends Address = Address> = {
    /**
     * Address of the {@link https://solana.com/docs/tokens#associated-token-account | Token Account} to get and decode
     */
    ata: TAddress;
};
type TokenAccountInputWithDerivedAtaDetails = {
    /**
     * Address of the {@link https://solana.com/docs/tokens#token-account | Token Account}'s `mint`
     */
    mint: Address;
    /**
     * Address of the {@link https://solana.com/docs/tokens#token-account | Token Account}'s `owner`
     */
    owner: Address;
    /**
     * The {@link https://solana.com/docs/tokens#token-programs | Token Program} used to create the `mint`
     *
     * If no `tokenProgram` is provided, the hook will automatically fetch the
     * {@link https://solana.com/docs/tokens#mint-account | Mint account} to retrieve the correct Token Program address
     */
    tokenProgram?: Address;
};
type UseTokenAccountInput<TConfig extends RpcConfig$2 = RpcConfig$2, TAddress extends Address = Address> = GillUseRpcHook<TConfig> & (TokenAccountInputWithDeclaredAta<TAddress> | TokenAccountInputWithDerivedAtaDetails);
/**
 * Get and parse an owner's {@link https://solana.com/docs/tokens#token-account | Token account} for a
 * {@link https://solana.com/docs/tokens#mint-account | Mint} and {@link https://solana.com/docs/tokens#token-programs | Token Program}
 */
declare function useTokenAccount<TConfig extends RpcConfig$2 = RpcConfig$2, TAddress extends Address = Address>({ options, config, abortSignal, ...tokenAccountOptions }: UseTokenAccountInput<TConfig, TAddress>): {
    account: UseTokenAccountResponse<TAddress>;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    account: UseTokenAccountResponse<TAddress>;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    account: UseTokenAccountResponse<TAddress>;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    account: UseTokenAccountResponse<TAddress>;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    account: UseTokenAccountResponse<TAddress>;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
};

type RpcConfig$1 = Simplify<Omit<FetchAccountConfig, "abortSignal">>;
type UseTokenMintResponse<TAddress extends string = string> = Simplify<Account<Mint, TAddress> & {
    exists: true;
}>;
type UseTokenMintInput<TConfig extends RpcConfig$1 = RpcConfig$1, TAddress extends string = string> = GillUseRpcHook<TConfig> & {
    /**
     * Address of the Mint account to get and decode
     */
    mint: Address<TAddress> | TAddress;
};
/**
 * Get and parse a token's {@link https://solana.com/docs/tokens#mint-account | Mint account}
 */
declare function useTokenMint<TConfig extends RpcConfig$1 = RpcConfig$1, TAddress extends string = string>({ options, config, abortSignal, mint, }: UseTokenMintInput<TConfig, TAddress>): {
    account: UseTokenMintResponse<TAddress>;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    account: UseTokenMintResponse<TAddress>;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    account: UseTokenMintResponse<TAddress>;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    account: UseTokenMintResponse<TAddress>;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    account: UseTokenMintResponse<TAddress>;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
};

type RpcConfig = Simplify<Parameters<GetTransactionApi["getTransaction"]>[1]>;
type UseTransactionResponse = ReturnType<GetTransactionApi["getTransaction"]>;
type UseTransactionInput<TConfig extends RpcConfig = RpcConfig> = GillUseRpcHook<TConfig> & {
    /**
     * Transaction signature as a base-58 encoded string
     */
    signature: Signature | string;
};
/**
 * Get transaction details for a confirmed transaction using the Solana RPC method of
 * [`getTransaction`](https://solana.com/docs/rpc/http/gettransaction)
 *
 * Default `config` includes:
 * - `maxSupportedTransactionVersion` of `0`
 * - `encoding` of `json`
 */
declare function useTransaction<TConfig extends RpcConfig = RpcConfig>({ options, config, abortSignal, signature, }: UseTransactionInput<TConfig>): {
    transaction: UseTransactionResponse;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    transaction: UseTransactionResponse;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    transaction: UseTransactionResponse;
    error: unknown;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    transaction: UseTransactionResponse;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
} | {
    transaction: UseTransactionResponse;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: unknown;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isPlaceholderData: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<unknown, unknown>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<unknown>;
};

/**
 * Provider to utilize gill hooks for Solana
 */
declare function SolanaProvider({ client, children, queryClient, }: {
    client: SolanaClient;
    children: React.ReactNode;
    queryClient?: QueryClient;
}): React.JSX.Element;

export { GILL_HOOK_CLIENT_KEY, GILL_NAME, SolanaProvider, useAccount, useBalance, useLatestBlockhash, useMultipleAccounts, useProgramAccounts, useRecentPrioritizationFees, useSignatureStatuses, useSignaturesForAddress, useSimulateTransaction, useSlot, useSolanaClient, useTokenAccount, useTokenAccountBalance, useTokenMint, useTransaction, useUpdateSolanaClient };