import { A as TransferCallbacks, B as TransactionReceipt, D as TransferOptions, E as ShieldPath, F as WalletAccount, I as WalletAccountChange, L as WalletAccountListener, M as GenericStorage, O as UnshieldOptions, P as GenericSigner, T as ShieldOptions, V as TransactionResult, c as DelegatedUserDecryptParams, d as EncryptParams, f as EncryptResult, g as PublicDecryptResult, j as UnshieldCallbacks, k as ShieldCallbacks, l as EIP712TypedData, n as RelayerSDK, o as TransportKeyPair, p as EncryptedValue, s as ClearValue, u as EncryptInput, w as ApprovalStrategy, x as UserDecryptParams, z as RawLog } from "../relayer-cleartext-DkKKjfI6.js";
import { A as UnshieldPhase2StartedEvent, C as SetOperatorSubmittedEvent, D as TransferFromSubmittedEvent, E as TransactionOperation, F as ZamaSDKEventListener, J as UnwrapRequestedEvent, L as ZamaSDKEvents, M as UnwrapSubmittedEvent, N as ZamaSDKEvent, O as TransferSubmittedEvent, P as ZamaSDKEventInput, S as RevokeDelegationSubmittedEvent, T as TransactionErrorEvent, U as OnChainEvent, V as ConfidentialTransferEvent, Y as WrapEvent, _ as DelegationSubmittedEvent, a as ZamaConfig, b as EncryptStartEvent, f as ApproveUnderlyingSubmittedEvent, g as DecryptStartEvent, h as DecryptErrorEvent, j as UnshieldPhase2SubmittedEvent, k as UnshieldPhase1SubmittedEvent, m as DecryptEndEvent, p as BaseEvent, q as UnwrapFinalizedEvent, v as EncryptEndEvent, w as ShieldSubmittedEvent, x as FinalizeUnwrapSubmittedEvent, y as EncryptErrorEvent } from "../types-BjDu-RZg.js";
import { $ as DecryptResult, at as QueryFactoryOptions, ct as TokenWrapperPairWithMetadata, d as WrappedToken, et as EncryptedInput, f as BatchBalancesResult, it as MutationFactoryOptions, l as WrappersRegistry, m as Token, nt as SignerQueryContext, o as ZamaSDK, ot as PaginatedResult, p as BatchDecryptAsOptions, rt as zamaQueryKeys, st as TokenWrapperPair, tt as decryptValuesQueryOptions } from "../index-DoVo9J1n.js";
import { Address, Hex } from "viem";

//#region src/query/utils.d.ts
type StrippedQueryOptionKeys = "gcTime" | "staleTime" | "enabled" | "select" | "refetchInterval" | "refetchOnMount" | "refetchOnWindowFocus" | "refetchOnReconnect" | "retry" | "retryDelay" | "retryOnMount" | "queryFn" | "queryKey" | "queryKeyHashFn" | "initialData" | "initialDataUpdatedAt" | "placeholderData" | "structuralSharing" | "throwOnError" | "meta" | "query" | "pollingInterval";
/**
 * Remove TanStack behavioral options from a query config object so only domain
 * parameters remain for the lower-level factory.
 *
 * @example
 * ```ts
 * const params = filterQueryOptions({
 *   query: { enabled: false },
 *   gcTime: 60_000,
 *   owner: "0xabc",
 * });
 * // => { owner: "0xabc" }
 * ```
 */
declare function filterQueryOptions<TOptions extends Record<string, unknown>>(options: TOptions): Omit<TOptions, StrippedQueryOptionKeys>;
/**
 * Stable hash function for query keys.
 * Sorts object keys recursively and converts bigint values to strings.
 *
 * @remarks
 * bigint values are serialized as decimal strings, so `42n` and `"42"` hash to
 * the same token when they occupy the same position. This collision is accepted
 * by design for the current query-key conventions in this package.
 */
declare function hashFn(queryKey: readonly unknown[]): string;
//#endregion
//#region src/query/invalidation.d.ts
interface QueryLike {
  queryKey: readonly unknown[];
}
interface QueryFilterLike {
  queryKey?: readonly unknown[];
  predicate?: (query: QueryLike) => boolean;
}
interface QueryClientLike {
  invalidateQueries(filters: QueryFilterLike): void | Promise<void>;
  removeQueries(filters: QueryFilterLike): void;
}
declare function invalidateAfterUnwrap(queryClient: QueryClientLike, tokenAddress: Address): void;
declare function invalidateBalanceQueries(queryClient: QueryClientLike, tokenAddress: Address): void;
declare function invalidateAfterShield(queryClient: QueryClientLike, tokenAddress: Address): void;
declare function invalidateAfterUnshield(queryClient: QueryClientLike, tokenAddress: Address): void;
declare function invalidateAfterTransfer(queryClient: QueryClientLike, tokenAddress: Address): void;
declare function invalidateAfterApproveUnderlying(queryClient: QueryClientLike, tokenAddress: Address): void;
declare function invalidateAfterSetOperator(queryClient: QueryClientLike, tokenAddress: Address): void;
declare function invalidateWagmiBalanceQueries(queryClient: QueryClientLike): void;
declare function invalidateWalletLifecycleQueries(queryClient: QueryClientLike): void;
//#endregion
//#region src/query/token-metadata.d.ts
/** ERC-20 token metadata returned by {@link tokenMetadataQueryOptions}. */
interface TokenMetadata {
  name: string;
  symbol: string;
  decimals: number;
}
interface TokenMetadataQueryConfig {
  query?: Record<string, unknown>;
}
declare function tokenMetadataQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config?: TokenMetadataQueryConfig): QueryFactoryOptions<TokenMetadata, Error, TokenMetadata, ReturnType<typeof zamaQueryKeys.tokenMetadata.token>>;
//#endregion
//#region src/query/is-confidential.d.ts
interface IsConfidentialQueryConfig {
  query?: Record<string, unknown>;
}
declare function isConfidentialQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config?: IsConfidentialQueryConfig): QueryFactoryOptions<boolean, Error, boolean, ReturnType<typeof zamaQueryKeys.isConfidential.token>>;
declare function isWrapperQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config?: IsConfidentialQueryConfig): QueryFactoryOptions<boolean, Error, boolean, ReturnType<typeof zamaQueryKeys.isWrapper.token>>;
//#endregion
//#region src/query/total-supply.d.ts
interface TotalSupplyQueryConfig {
  query?: Record<string, unknown>;
}
declare function totalSupplyQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config?: TotalSupplyQueryConfig): QueryFactoryOptions<bigint, Error, bigint, ReturnType<typeof zamaQueryKeys.totalSupply.token>>;
//#endregion
//#region src/query/wrapper-discovery.d.ts
interface WrapperDiscoveryQueryConfig {
  /**
   * Address of any confidential token you control.
   * Used to scope the query cache key and to gate whether the query
   * is enabled — it does not affect which wrapper the registry returns.
   */
  tokenAddress?: Address;
  /**
   * The ERC-20 token address to discover the confidential wrapper for.
   * The registry is resolved automatically from chain config.
   */
  erc20Address?: Address;
  /**
   * The resolved registry contract address for the current chain.
   * Included in the query key so that switching chains invalidates
   * stale cached results. Pass `undefined` when the chain ID is not
   * yet known — the query will be disabled.
   */
  registryAddress?: Address;
  query?: Record<string, unknown>;
}
declare function wrapperDiscoveryQueryOptions(registry: WrappersRegistry, config: WrapperDiscoveryQueryConfig): QueryFactoryOptions<Address | null, Error, Address | null, ReturnType<typeof zamaQueryKeys.wrapperDiscovery.token>>;
//#endregion
//#region src/query/underlying-allowance.d.ts
interface UnderlyingAllowanceQueryConfig {
  owner?: Address;
  query?: Record<string, unknown>;
}
declare function underlyingAllowanceQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config: UnderlyingAllowanceQueryConfig): QueryFactoryOptions<bigint, Error, bigint, ReturnType<typeof zamaQueryKeys.underlyingAllowance.scope>>;
//#endregion
//#region src/query/confidential-is-operator.d.ts
interface ConfidentialIsOperatorQueryConfig {
  holder?: Address;
  spender?: Address;
  query?: Record<string, unknown>;
}
declare function confidentialIsOperatorQueryOptions(sdk: ZamaSDK, tokenAddress: Address | undefined, config: ConfidentialIsOperatorQueryConfig): QueryFactoryOptions<boolean, Error, boolean, ReturnType<typeof zamaQueryKeys.confidentialIsOperator.scope>>;
//#endregion
//#region src/query/confidential-balance.d.ts
interface ConfidentialBalanceQueryConfig {
  tokenAddress: Address;
  account?: Address;
  query?: Record<string, unknown>;
}
/** Query options for a single confidential token balance. Auto-gated on `account`. */
declare function confidentialBalanceQueryOptions(token: Token, config: ConfidentialBalanceQueryConfig, signerContext?: SignerQueryContext): QueryFactoryOptions<bigint, Error, bigint, ReturnType<typeof zamaQueryKeys.confidentialBalance.owner>>;
//#endregion
//#region src/query/confidential-balances.d.ts
interface ConfidentialBalancesQueryConfig {
  account?: Address;
  query?: Record<string, unknown>;
}
declare function confidentialBalancesQueryOptions(tokens: Token[], config?: ConfidentialBalancesQueryConfig, signerContext?: SignerQueryContext): QueryFactoryOptions<BatchBalancesResult, Error, BatchBalancesResult, ReturnType<typeof zamaQueryKeys.confidentialBalances.tokens>>;
//#endregion
//#region src/query/wrappers-registry.d.ts
interface WrappersRegistryQueryConfig {
  registryAddress: Address | undefined;
  query?: Record<string, unknown>;
}
declare function tokenPairsQueryOptions(sdk: ZamaSDK, config: WrappersRegistryQueryConfig): QueryFactoryOptions<readonly TokenWrapperPair[], Error, readonly TokenWrapperPair[], ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenPairs>>;
interface ConfidentialTokenAddressQueryConfig extends WrappersRegistryQueryConfig {
  tokenAddress?: Address;
}
declare function confidentialTokenAddressQueryOptions(sdk: ZamaSDK, config: ConfidentialTokenAddressQueryConfig): QueryFactoryOptions<readonly [boolean, Address], Error, readonly [boolean, Address], ReturnType<typeof zamaQueryKeys.wrappersRegistry.confidentialTokenAddress>>;
interface TokenAddressQueryConfig extends WrappersRegistryQueryConfig {
  confidentialTokenAddress?: Address;
}
declare function tokenAddressQueryOptions(sdk: ZamaSDK, config: TokenAddressQueryConfig): QueryFactoryOptions<readonly [boolean, Address], Error, readonly [boolean, Address], ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenAddress>>;
declare function tokenPairsLengthQueryOptions(sdk: ZamaSDK, config: WrappersRegistryQueryConfig): QueryFactoryOptions<bigint, Error, bigint, ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenPairsLength>>;
interface TokenPairsSliceQueryConfig extends WrappersRegistryQueryConfig {
  fromIndex?: bigint;
  toIndex?: bigint;
}
declare function tokenPairsSliceQueryOptions(sdk: ZamaSDK, config: TokenPairsSliceQueryConfig): QueryFactoryOptions<readonly TokenWrapperPair[], Error, readonly TokenWrapperPair[], ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenPairsSlice>>;
interface TokenPairQueryConfig extends WrappersRegistryQueryConfig {
  index?: bigint;
}
declare function tokenPairQueryOptions(sdk: ZamaSDK, config: TokenPairQueryConfig): QueryFactoryOptions<TokenWrapperPair, Error, TokenWrapperPair, ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenPair>>;
interface IsConfidentialTokenValidQueryConfig extends WrappersRegistryQueryConfig {
  confidentialTokenAddress?: Address;
}
declare function isConfidentialTokenValidQueryOptions(sdk: ZamaSDK, config: IsConfidentialTokenValidQueryConfig): QueryFactoryOptions<boolean, Error, boolean, ReturnType<typeof zamaQueryKeys.wrappersRegistry.isConfidentialTokenValid>>;
interface ListPairsQueryConfig {
  /**
   * The registry address for this chain — used as a query key discriminator.
   * The registry instance already knows how to resolve the address for the
   * current chain; this field just keeps the TanStack Query cache isolated
   * per registry contract.
   */
  registryAddress: Address | undefined;
  page?: number;
  pageSize?: number;
  metadata?: boolean;
  query?: Record<string, unknown>;
}
/**
 * Query options for paginated listing of token wrapper pairs.
 *
 * Accepts a {@link WrappersRegistry} instance rather than a raw provider so that the
 * class-level TTL cache is shared across multiple `queryFn` executions. Pass
 * `sdk.registry` (the ZamaSDK lazy singleton) to ensure a single shared cache.
 */
declare function listPairsQueryOptions(registry: WrappersRegistry, config: ListPairsQueryConfig): QueryFactoryOptions<PaginatedResult<TokenWrapperPair | TokenWrapperPairWithMetadata>, Error, PaginatedResult<TokenWrapperPair | TokenWrapperPairWithMetadata>, ReturnType<typeof zamaQueryKeys.wrappersRegistry.listPairs>>;
//#endregion
//#region src/query/shield.d.ts
/** Variables for {@link shieldMutationOptions}. */
interface ShieldParams extends ShieldOptions {
  amount: bigint;
}
declare function shieldMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.shield", Address], ShieldParams, TransactionResult>;
//#endregion
//#region src/query/transfer.d.ts
/** Variables for {@link confidentialTransferMutationOptions}. */
interface ConfidentialTransferParams extends TransferOptions {
  to: Address;
  amount: bigint;
}
declare function confidentialTransferMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.confidentialTransfer", Address], ConfidentialTransferParams, TransactionResult>;
//#endregion
//#region src/query/transfer-from.d.ts
/** Variables for {@link confidentialTransferFromMutationOptions}. */
interface ConfidentialTransferFromParams {
  from: Address;
  to: Address;
  amount: bigint;
  /** Optional progress callbacks for the multi-step transfer flow. */
  callbacks?: TransferCallbacks;
}
declare function confidentialTransferFromMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.confidentialTransferFrom", Address], ConfidentialTransferFromParams, TransactionResult>;
//#endregion
//#region src/query/set-operator.d.ts
/** Variables for {@link confidentialSetOperatorMutationOptions}. */
interface ConfidentialSetOperatorParams {
  operator: Address;
  until?: number;
}
declare function confidentialSetOperatorMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.confidentialSetOperator", Address], ConfidentialSetOperatorParams, TransactionResult>;
//#endregion
//#region src/query/approve-underlying.d.ts
/** Variables for {@link approveUnderlyingMutationOptions}. */
interface ApproveUnderlyingParams {
  amount?: bigint;
}
declare function approveUnderlyingMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.approveUnderlying", Address], ApproveUnderlyingParams, TransactionResult>;
//#endregion
//#region src/query/unshield.d.ts
/** Variables for {@link unshieldMutationOptions}. */
interface UnshieldParams extends UnshieldOptions {
  amount: bigint;
}
declare function unshieldMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.unshield", Address], UnshieldParams, TransactionResult>;
//#endregion
//#region src/query/unshield-all.d.ts
/** Variables for {@link unshieldAllMutationOptions}. */
interface UnshieldAllParams extends UnshieldCallbacks {}
declare function unshieldAllMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.unshieldAll", Address], UnshieldAllParams | void, TransactionResult>;
//#endregion
//#region src/query/resume-unshield.d.ts
/** Variables for {@link resumeUnshieldMutationOptions}. */
interface ResumeUnshieldParams extends UnshieldCallbacks {
  unwrapTxHash: Hex;
}
declare function resumeUnshieldMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.resumeUnshield", Address], ResumeUnshieldParams, TransactionResult>;
//#endregion
//#region src/query/unwrap.d.ts
/** Variables for {@link unwrapMutationOptions}. */
interface UnwrapParams {
  amount: bigint;
}
declare function unwrapMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.unwrap", Address], UnwrapParams, TransactionResult>;
//#endregion
//#region src/query/unwrap-all.d.ts
declare function unwrapAllMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.unwrapAll", Address], void, TransactionResult>;
//#endregion
//#region src/query/finalize-unwrap.d.ts
/** Variables for {@link finalizeUnwrapMutationOptions}. */
type FinalizeUnwrapParams = {
  /** Identifier from an `UnwrapRequested` event. */unwrapRequestId: EncryptedValue;
};
declare function finalizeUnwrapMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.finalizeUnwrap", Address], FinalizeUnwrapParams, TransactionResult>;
//#endregion
//#region src/query/encrypt.d.ts
declare function encryptMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.encrypt"], EncryptParams, EncryptResult>;
//#endregion
//#region src/query/delegated-decrypt.d.ts
interface DelegatedDecryptValuesMutationParams {
  encryptedInputs: EncryptedInput[];
  delegatorAddress: Address;
}
declare function delegatedDecryptValuesMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.delegatedDecryptValues"], DelegatedDecryptValuesMutationParams, Readonly<Record<EncryptedValue, ClearValue>>>;
//#endregion
//#region src/query/public-decrypt.d.ts
declare function decryptPublicValuesMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.decryptPublicValues"], EncryptedValue[], PublicDecryptResult>;
//#endregion
//#region src/query/grant-permit.d.ts
declare function grantPermitMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.grantPermit"], Address[], void>;
//#endregion
//#region src/query/has-permit.d.ts
interface HasPermitQueryConfig {
  /** Contract addresses to check credentials against. */
  contractAddresses: Address[];
  /**
   * Standard TanStack query options. `hasPermit` intentionally overrides cache
   * timing because permit state is wallet-local, not server state: every fetch
   * should read the SDK credential service directly.
   */
  query?: Record<string, unknown>;
}
declare function hasPermitQueryOptions(sdk: ZamaSDK, config: HasPermitQueryConfig, signerContext?: SignerQueryContext): QueryFactoryOptions<boolean, Error, boolean, ReturnType<typeof zamaQueryKeys.hasPermit.scope>>;
//#endregion
//#region src/query/revoke-permits.d.ts
/** TanStack Query mutation factory for {@link Permits.revokePermits}. */
declare function revokePermitsMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.revokePermits"], Address[] | void, void>;
//#endregion
//#region src/query/clear-credentials.d.ts
/** TanStack Query mutation factory for {@link Permits.clear}. */
declare function clearCredentialsMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.clearCredentials"], void, void>;
//#endregion
//#region src/query/delegate-decryption.d.ts
/** Variables for {@link delegateDecryptionMutationOptions}. */
interface DelegateDecryptionParams {
  delegateAddress: Address;
  expirationDate?: Date;
}
declare function delegateDecryptionMutationOptions(sdk: ZamaSDK, contractAddress: Address): MutationFactoryOptions<readonly ["zama.delegateDecryption", Address], DelegateDecryptionParams, TransactionResult>;
//#endregion
//#region src/query/decrypt-balance-as.d.ts
/** Variables for {@link decryptBalanceAsMutationOptions}. */
interface DecryptBalanceAsParams {
  delegatorAddress: Address;
  accountAddress?: Address;
}
declare function decryptBalanceAsMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.decryptBalanceAs", Address], DecryptBalanceAsParams, bigint>;
//#endregion
//#region src/query/batch-decrypt-balances-as.d.ts
/** Variables for {@link batchDecryptBalancesAsMutationOptions}. */
type BatchDecryptBalancesAsParams = BatchDecryptAsOptions;
declare function batchDecryptBalancesAsMutationOptions(tokens: Token[]): MutationFactoryOptions<readonly ["zama.batchDecryptBalancesAs", ...Address[]], BatchDecryptBalancesAsParams, Map<Address, bigint>>;
//#endregion
//#region src/query/revoke-delegation.d.ts
/** Variables for {@link revokeDelegationMutationOptions}. */
interface RevokeDelegationParams {
  delegateAddress: Address;
}
declare function revokeDelegationMutationOptions(sdk: ZamaSDK, contractAddress: Address): MutationFactoryOptions<readonly ["zama.revokeDelegation", Address], RevokeDelegationParams, TransactionResult>;
//#endregion
//#region src/query/delegation-status.d.ts
interface DelegationStatusData {
  isActive: boolean;
  expiryTimestamp: bigint;
}
interface DelegationStatusQueryConfig {
  contractAddress: Address | undefined;
  delegatorAddress?: Address;
  delegateAddress?: Address;
  query?: Record<string, unknown>;
}
declare function delegationStatusQueryOptions(sdk: ZamaSDK, config: DelegationStatusQueryConfig): QueryFactoryOptions<DelegationStatusData, Error, DelegationStatusData, ReturnType<typeof zamaQueryKeys.delegationStatus.scope>>;
//#endregion
export { type ApprovalStrategy, type ApproveUnderlyingParams, type ApproveUnderlyingSubmittedEvent, type BaseEvent, type BatchBalancesResult, type BatchDecryptAsOptions, type BatchDecryptBalancesAsParams, type ClearValue, type ConfidentialBalanceQueryConfig, type ConfidentialBalancesQueryConfig, type ConfidentialIsOperatorQueryConfig, type ConfidentialSetOperatorParams, type ConfidentialTokenAddressQueryConfig, type ConfidentialTransferEvent, type ConfidentialTransferFromParams, type ConfidentialTransferParams, type DecryptBalanceAsParams, type DecryptEndEvent, type DecryptErrorEvent, type EncryptedInput as DecryptInput, type PublicDecryptResult as DecryptPublicValuesResult, type DecryptResult, type DecryptStartEvent, type UserDecryptParams as DecryptValuesParams, type DelegateDecryptionParams, type DelegatedDecryptValuesMutationParams, type DelegatedUserDecryptParams as DelegatedDecryptValuesParams, type DelegationStatusData, type DelegationStatusQueryConfig, type DelegationSubmittedEvent, type EIP712TypedData, type EncryptEndEvent, type EncryptErrorEvent, type EncryptInput, type EncryptParams, type EncryptResult, type EncryptStartEvent, type EncryptedValue, type FinalizeUnwrapParams, type FinalizeUnwrapSubmittedEvent, type GenericSigner, type GenericStorage, type HasPermitQueryConfig, type IsConfidentialQueryConfig, type IsConfidentialTokenValidQueryConfig, type ListPairsQueryConfig, type MutationFactoryOptions, type OnChainEvent, type QueryClientLike, type QueryFactoryOptions, type QueryFilterLike, type QueryLike, type RawLog, type RelayerSDK, type ResumeUnshieldParams, type RevokeDelegationParams, type RevokeDelegationSubmittedEvent, type SetOperatorSubmittedEvent, type ShieldCallbacks, type ShieldOptions, type ShieldParams, type ShieldPath, type ShieldSubmittedEvent, type StrippedQueryOptionKeys, type Token, type TokenAddressQueryConfig, type TokenMetadata, type TokenMetadataQueryConfig, type TokenPairQueryConfig, type TokenPairsSliceQueryConfig, type TotalSupplyQueryConfig, type TransactionErrorEvent, type TransactionOperation, type TransactionReceipt, type TransactionResult, type TransferCallbacks, type TransferFromSubmittedEvent, type TransferOptions, type TransferSubmittedEvent, type TransportKeyPair, type UnderlyingAllowanceQueryConfig, type UnshieldAllParams, type UnshieldCallbacks, type UnshieldOptions, type UnshieldParams, type UnshieldPhase1SubmittedEvent, type UnshieldPhase2StartedEvent, type UnshieldPhase2SubmittedEvent, type UnwrapFinalizedEvent, type UnwrapParams, type UnwrapRequestedEvent, type UnwrapSubmittedEvent, type WalletAccount, type WalletAccountChange, type WalletAccountListener, type WrapEvent, type WrappedToken, type WrapperDiscoveryQueryConfig, type WrappersRegistryQueryConfig, type ZamaConfig, type ZamaSDK, type ZamaSDKEvent, type ZamaSDKEventInput, type ZamaSDKEventListener, ZamaSDKEvents, approveUnderlyingMutationOptions, batchDecryptBalancesAsMutationOptions, clearCredentialsMutationOptions, confidentialBalanceQueryOptions, confidentialBalancesQueryOptions, confidentialIsOperatorQueryOptions, confidentialSetOperatorMutationOptions, confidentialTokenAddressQueryOptions, confidentialTransferFromMutationOptions, confidentialTransferMutationOptions, decryptBalanceAsMutationOptions, decryptPublicValuesMutationOptions, decryptValuesQueryOptions, delegateDecryptionMutationOptions, delegatedDecryptValuesMutationOptions, delegationStatusQueryOptions, encryptMutationOptions, filterQueryOptions, finalizeUnwrapMutationOptions, grantPermitMutationOptions, hasPermitQueryOptions, hashFn, invalidateAfterApproveUnderlying, invalidateAfterSetOperator, invalidateAfterShield, invalidateAfterTransfer, invalidateAfterUnshield, invalidateAfterUnwrap, invalidateBalanceQueries, invalidateWagmiBalanceQueries, invalidateWalletLifecycleQueries, isConfidentialQueryOptions, isConfidentialTokenValidQueryOptions, isWrapperQueryOptions, listPairsQueryOptions, resumeUnshieldMutationOptions, revokeDelegationMutationOptions, revokePermitsMutationOptions, shieldMutationOptions, tokenAddressQueryOptions, tokenMetadataQueryOptions, tokenPairQueryOptions, tokenPairsLengthQueryOptions, tokenPairsQueryOptions, tokenPairsSliceQueryOptions, totalSupplyQueryOptions, underlyingAllowanceQueryOptions, unshieldAllMutationOptions, unshieldMutationOptions, unwrapAllMutationOptions, unwrapMutationOptions, wrapperDiscoveryQueryOptions, zamaQueryKeys };
//# sourceMappingURL=index.d.ts.map