@zama-fhe/sdk 3.4.0-alpha.8 → 3.4.0

package/dist/esm/node/index.d.ts

@@ -1,5 +1,5 @@
-import { a as hoodi, c as sepolia, i as hardhat, n as bscTestnet, o as ingenTestnet, r as chains, s as mainnet, t as anvil } from "../index-doNE2KoX.js";
-import { It as ClearValue, Kt as FhevmRelayerSDK, Lt as DecryptPublicValuesResult, Vt as EncryptParams, n as RelayerConfig, s as GenericLogger, zt as EIP712TypedData } from "../types-CELdIAFG.js";
-import { t as cleartext } from "../cleartext-_RCZVPOe.js";
-import { i as node, n as asyncLocalStorage, r as NodeRelayerConfig, t as AsyncLocalMapStorage } from "../index-9Cn2VKDw.js";
-export { AsyncLocalMapStorage, type ClearValue, type DecryptPublicValuesResult, type EIP712TypedData, type EncryptParams, type GenericLogger, type NodeRelayerConfig, type RelayerConfig, type FhevmRelayerSDK as RelayerSDK, anvil, asyncLocalStorage, bscTestnet, chains, cleartext, hardhat, hoodi, ingenTestnet, mainnet, node, sepolia };
+import { a as hoodi, c as sepolia, d as FheChainAuth, i as hardhat, n as bscTestnet, o as ingenTestnet, r as chains, s as mainnet, t as anvil, u as FheChain } from "../index-S6_V7aAH.js";
+import { Ft as DecryptPublicValuesResult, Gt as FhevmRuntimeConfig, Kt as RelayerOptions, Lt as EIP712TypedData, Pt as ClearValue, Rt as EncryptInput, Ut as FhevmClientOptions, Vt as EncryptedValue, Wt as FhevmRelayerOptions, c as GenericStorage, n as RelayerConfig, s as GenericLogger, t as CleartextRelayerConfig, zt as EncryptParams } from "../types-CWPSTRF6.js";
+import { t as cleartext } from "../cleartext-CxlICeUh.js";
+import { i as node, n as asyncLocalStorage, r as NodeRelayerConfig, t as AsyncLocalMapStorage } from "../index-DNofJMCK.js";
+export { AsyncLocalMapStorage, type ClearValue, type CleartextRelayerConfig, type DecryptPublicValuesResult, type EIP712TypedData, type EncryptInput, type EncryptParams, type EncryptedValue, type FheChain, type FheChainAuth, type FhevmClientOptions, type FhevmRelayerOptions, type FhevmRuntimeConfig, type GenericLogger, type GenericStorage, type NodeRelayerConfig, type RelayerConfig, type RelayerOptions, anvil, asyncLocalStorage, bscTestnet, chains, cleartext, hardhat, hoodi, ingenTestnet, mainnet, node, sepolia };

package/dist/esm/node/index.js

@@ -1,2 +1,2 @@
-import{t as e}from"../fhevm-relayer-Bb_-KFJA.js";import{t}from"../cleartext-DfX0GUj1.js";import{a as n,c as r,i,n as a,o,r as s,s as c,t as l}from"../chains-CLv9HEJ_.js";import{AsyncLocalStorage as u}from"node:async_hooks";function d(t){return{type:`node`,createRelayer:n=>new e({chain:n,options:t})}}var f=class{#e=new u;run(e){return this.#e.run(new Map,e)}async get(e){return this.#e.getStore()?.get(e)??null}async set(e,t){this.#e.getStore()?.set(e,t)}async delete(e){this.#e.getStore()?.delete(e)}};const p=new f;export{f as AsyncLocalMapStorage,l as anvil,p as asyncLocalStorage,a as bscTestnet,s as chains,t as cleartext,i as hardhat,n as hoodi,o as ingenTestnet,c as mainnet,d as node,r as sepolia};
+import{t as e}from"../fhevm-relayer-4Zd4QkKq.js";import{t}from"../cleartext-Qqh5JohW.js";import{a as n,c as r,i,n as a,o,r as s,s as c,t as l}from"../chains-CLv9HEJ_.js";import{AsyncLocalStorage as u}from"node:async_hooks";function d(t){return{type:`node`,createRelayer:n=>new e({chain:n,options:t})}}var f=class{#e=new u;run(e){return this.#e.run(new Map,e)}async get(e){return this.#e.getStore()?.get(e)??null}async set(e,t){this.#e.getStore()?.set(e,t)}async delete(e){this.#e.getStore()?.delete(e)}};const p=new f;export{f as AsyncLocalMapStorage,l as anvil,p as asyncLocalStorage,a as bscTestnet,s as chains,t as cleartext,i as hardhat,n as hoodi,o as ingenTestnet,c as mainnet,d as node,r as sepolia};
 //# sourceMappingURL=index.js.map

package/dist/esm/node/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["#als"],"sources":["../../../src/node/config.ts","../../../src/storage/async-local-storage.ts"],"sourcesContent":["import type { FheChain } from \"../chains/types\";\nimport type { RelayerConfig } from \"../config/types\";\nimport { FhevmRelayer } from \"../relayer/fhevm-relayer\";\nimport type { RelayerOptions } from \"../relayer/types\";\n\n/** Node transport — drives the FHE backend directly on the calling thread. */\nexport interface NodeRelayerConfig extends RelayerConfig {\n  readonly type: \"node\";\n  readonly createRelayer: (chain: FheChain) => FhevmRelayer;\n}\n\n/**\n * Node.js transport — drives `@fhevm/sdk` via {@link FhevmRelayer} on the calling thread.\n *\n * @example\n * ```ts\n * relayers: {\n *   [sepolia.id]: node({ timeout: 5 * 60_000 }),\n *   [mainnet.id]: node({ batchRpcCalls: true }),\n * }\n * ```\n */\nexport function node(options?: RelayerOptions): NodeRelayerConfig {\n  return { type: \"node\", createRelayer: (chain) => new FhevmRelayer({ chain, options }) };\n}\n","import { AsyncLocalStorage } from \"node:async_hooks\";\nimport type { GenericStorage } from \"../types\";\n\n/**\n * {@link GenericStorage} backed by Node.js {@link AsyncLocalStorage}.\n *\n * Each async context (e.g. HTTP request) gets its own isolated `Map`,\n * so credentials from one request never leak into another.\n *\n * Call {@link run} to establish a context before using the SDK:\n *\n * ```ts\n * import { asyncLocalStorage } from \"@zama-fhe/sdk/node\";\n *\n * app.post(\"/api/transfer\", (req, res) => {\n *   asyncLocalStorage.run(async () => {\n *     const sdk = new ZamaSDK({ relayer, signer, storage: asyncLocalStorage });\n *     // credentials are scoped to this request\n *   });\n * });\n * ```\n */\nexport class AsyncLocalMapStorage implements GenericStorage {\n  readonly #als = new AsyncLocalStorage<Map<string, unknown>>();\n\n  /** Execute `fn` within an isolated storage context. */\n  run<R>(fn: () => R | Promise<R>): R | Promise<R> {\n    return this.#als.run(new Map(), fn);\n  }\n\n  async get<T = unknown>(key: string): Promise<T | null> {\n    return (this.#als.getStore()?.get(key) as T) ?? null;\n  }\n\n  async set<T = unknown>(key: string, value: T): Promise<void> {\n    this.#als.getStore()?.set(key, value);\n  }\n\n  async delete(key: string): Promise<void> {\n    this.#als.getStore()?.delete(key);\n  }\n}\n\n/** Default singleton for application-wide use. */\nexport const asyncLocalStorage = new AsyncLocalMapStorage();\n"],"mappings":"+NAsBA,SAAgB,EAAK,EAA6C,CAChE,MAAO,CAAE,KAAM,OAAQ,cAAgB,GAAU,IAAI,EAAa,CAAE,QAAO,SAAQ,CAAC,CAAE,CACxF,CCFA,IAAa,EAAb,KAA4D,CAC1D,GAAgB,IAAI,EAGpB,IAAO,EAA0C,CAC/C,OAAO,KAAKA,GAAK,IAAI,IAAI,IAAO,CAAE,CACpC,CAEA,MAAM,IAAiB,EAAgC,CACrD,OAAQ,KAAKA,GAAK,SAAS,CAAC,EAAE,IAAI,CAAG,GAAW,IAClD,CAEA,MAAM,IAAiB,EAAa,EAAyB,CAC3D,KAAKA,GAAK,SAAS,CAAC,EAAE,IAAI,EAAK,CAAK,CACtC,CAEA,MAAM,OAAO,EAA4B,CACvC,KAAKA,GAAK,SAAS,CAAC,EAAE,OAAO,CAAG,CAClC,CACF,EAGA,MAAa,EAAoB,IAAI"}
+{"version":3,"file":"index.js","names":["#als"],"sources":["../../../src/node/config.ts","../../../src/storage/async-local-storage.ts"],"sourcesContent":["import type { FheChain } from \"../chains/types\";\nimport type { RelayerConfig } from \"../config/types\";\nimport { FhevmRelayer } from \"../relayer/fhevm-relayer\";\nimport type { RelayerOptions } from \"../relayer/types\";\n\n/** Node transport — drives the FHE backend directly on the calling thread. */\nexport interface NodeRelayerConfig extends RelayerConfig {\n  /** Discriminant for the node transport. */\n  readonly type: \"node\";\n  /** @internal */\n  readonly createRelayer: (chain: FheChain) => FhevmRelayer;\n}\n\n/**\n * Node.js transport — drives `@fhevm/sdk` via {@link FhevmRelayer} on the calling thread.\n *\n * @example\n * ```ts\n * relayers: {\n *   [sepolia.id]: node({ timeout: 5 * 60_000 }),\n *   [mainnet.id]: node({ batchRpcCalls: true }),\n * }\n * ```\n */\nexport function node(options?: RelayerOptions): NodeRelayerConfig {\n  return { type: \"node\", createRelayer: (chain) => new FhevmRelayer({ chain, options }) };\n}\n","import { AsyncLocalStorage } from \"node:async_hooks\";\nimport type { GenericStorage } from \"../types\";\n\n/**\n * {@link GenericStorage} backed by Node.js {@link AsyncLocalStorage}.\n *\n * Each async context (e.g. HTTP request) gets its own isolated `Map`,\n * so credentials from one request never leak into another.\n *\n * Call {@link run} to establish a context before using the SDK:\n *\n * ```ts\n * import { asyncLocalStorage } from \"@zama-fhe/sdk/node\";\n *\n * app.post(\"/api/transfer\", (req, res) => {\n *   asyncLocalStorage.run(async () => {\n *     const sdk = new ZamaSDK({ relayer, signer, storage: asyncLocalStorage });\n *     // credentials are scoped to this request\n *   });\n * });\n * ```\n */\nexport class AsyncLocalMapStorage implements GenericStorage {\n  readonly #als = new AsyncLocalStorage<Map<string, unknown>>();\n\n  /** Execute `fn` within an isolated storage context. */\n  run<R>(fn: () => R | Promise<R>): R | Promise<R> {\n    return this.#als.run(new Map(), fn);\n  }\n\n  /**\n   * Retrieve a value by key.\n   * @returns The stored value, or `null` if the key does not exist.\n   */\n  async get<T = unknown>(key: string): Promise<T | null> {\n    return (this.#als.getStore()?.get(key) as T) ?? null;\n  }\n\n  /** Store a value under the given key, overwriting any existing entry. */\n  async set<T = unknown>(key: string, value: T): Promise<void> {\n    this.#als.getStore()?.set(key, value);\n  }\n\n  /** Remove the entry for the given key (no-op if absent). */\n  async delete(key: string): Promise<void> {\n    this.#als.getStore()?.delete(key);\n  }\n}\n\n/** Default singleton for application-wide use. */\nexport const asyncLocalStorage = new AsyncLocalMapStorage();\n"],"mappings":"+NAwBA,SAAgB,EAAK,EAA6C,CAChE,MAAO,CAAE,KAAM,OAAQ,cAAgB,GAAU,IAAI,EAAa,CAAE,QAAO,SAAQ,CAAC,CAAE,CACxF,CCJA,IAAa,EAAb,KAA4D,CAC1D,GAAgB,IAAI,EAGpB,IAAO,EAA0C,CAC/C,OAAO,KAAKA,GAAK,IAAI,IAAI,IAAO,CAAE,CACpC,CAMA,MAAM,IAAiB,EAAgC,CACrD,OAAQ,KAAKA,GAAK,SAAS,CAAC,EAAE,IAAI,CAAG,GAAW,IAClD,CAGA,MAAM,IAAiB,EAAa,EAAyB,CAC3D,KAAKA,GAAK,SAAS,CAAC,EAAE,IAAI,EAAK,CAAK,CACtC,CAGA,MAAM,OAAO,EAA4B,CACvC,KAAKA,GAAK,SAAS,CAAC,EAAE,OAAO,CAAG,CAClC,CACF,EAGA,MAAa,EAAoB,IAAI"}

package/dist/esm/query/index.d.ts

@@ -1,8 +1,10 @@
-import { $ as ShieldPath, A as EncryptEndEvent, B as TransferSubmittedEvent, Bt as EncryptInput, D as DecryptErrorEvent, E as DecryptEndEvent, F as SetOperatorSubmittedEvent, Ft as TransactionResult, H as UnshieldPhase2StartedEvent, Ht as EncryptResult, I as ShieldSubmittedEvent, It as ClearValue, J as ZamaSDKEventListener, K as ZamaSDKEvent, Kt as FhevmRelayerSDK, L as TransactionErrorEvent, Lt as DecryptPublicValuesResult, M as EncryptStartEvent, N as FinalizeUnwrapSubmittedEvent, Nt as RawLog, O as DecryptStartEvent, P as RevokeDelegationSubmittedEvent, Pt as TransactionReceipt, Q as ShieldOptions, R as TransactionOperation, T as BaseEvent, U as UnshieldPhase2SubmittedEvent, Ut as EncryptedValue, V as UnshieldPhase1SubmittedEvent, Vt as EncryptParams, W as UnwrapSubmittedEvent, X as ZamaSDKEvents, Z as ApprovalStrategy, _t as UnwrapRequestedEvent, at as TransferCallbacks, c as GenericStorage, d as WalletAccount, et as TransferOptions, f as WalletAccountChange, ft as OnChainEvent, gt as UnwrapFinalizedEvent, i as ZamaConfig, it as ShieldCallbacks, j as EncryptErrorEvent, k as DelegationSubmittedEvent, nt as UnwrapResult, ot as UnshieldCallbacks, p as WalletAccountListener, q as ZamaSDKEventInput, rt as WrapOptions, tt as UnshieldOptions, u as GenericSigner, ut as ConfidentialTransferEvent, vt as WrapEvent, w as ApproveUnderlyingSubmittedEvent, z as TransferFromSubmittedEvent, zt as EIP712TypedData } from "../types-CELdIAFG.js";
-import { St as TokenWrapperPairWithMetadata, _ as BatchBalancesResult, _t as zamaQueryKeys, bt as PaginatedResult, d as ZamaSDK, dt as SerializedTransportKeyPair, g as WrappedToken, gt as SignerQueryContext, ht as decryptValuesQueryOptions, m as WrappersRegistry, mt as EncryptedInput, pt as DecryptResult, v as BatchDecryptAsOptions, vt as MutationFactoryOptions, xt as TokenWrapperPair, y as Token, yt as QueryFactoryOptions } from "../index-C4Hn6K9c.js";
-import "../index-9Cn2VKDw.js";
+import { d as FheChainAuth, u as FheChain } from "../index-S6_V7aAH.js";
+import { $ as UnshieldOptions, A as EncryptErrorEvent, B as UnshieldPhase1SubmittedEvent, Bt as EncryptResult, C as ApproveUnderlyingSubmittedEvent, D as DecryptStartEvent, E as DecryptErrorEvent, F as ShieldSubmittedEvent, Ft as DecryptPublicValuesResult, G as ZamaSDKEvent, Gt as FhevmRuntimeConfig, H as UnshieldPhase2SubmittedEvent, Ht as FhevmClient, I as TransactionErrorEvent, J as ZamaSDKEvents, K as ZamaSDKEventListener, L as TransactionOperation, Lt as EIP712TypedData, M as FinalizeUnwrapSubmittedEvent, Mt as TransactionReceipt, N as RevokeDelegationSubmittedEvent, Nt as TransactionResult, O as DelegationSubmittedEvent, P as SetOperatorSubmittedEvent, Pt as ClearValue, Q as TransferOptions, R as TransferFromSubmittedEvent, Rt as EncryptInput, S as WriteFunctionName, T as DecryptEndEvent, U as UnwrapSubmittedEvent, V as UnshieldPhase2StartedEvent, Vt as EncryptedValue, W as WrapSubmittedEvent, Wt as FhevmRelayerOptions, X as ShieldOptions, Y as ApprovalStrategy, Z as ShieldPath, _ as ReadContractConfig, b as WriteContractArgs, c as GenericStorage, ct as ConfidentialTransferEvent, d as WalletAccount, et as UnwrapResult, f as WalletAccountChange, g as ReadContractArgs, gt as WrapEvent, h as ContractAbi, ht as UnwrapRequestedEvent, i as ZamaConfig, it as UnshieldCallbacks, j as EncryptStartEvent, jt as RawLog, k as EncryptEndEvent, l as GenericProvider, m as WalletAccountStore, mt as UnwrapFinalizedEvent, nt as ShieldCallbacks, p as WalletAccountListener, qt as RelayerSDK, rt as TransferCallbacks, s as GenericLogger, tt as WrapOptions, u as GenericSigner, ut as OnChainEvent, v as ReadContractReturnType, w as BaseEvent, x as WriteContractConfig, y as ReadFunctionName, z as TransferSubmittedEvent, zt as EncryptParams } from "../types-CWPSTRF6.js";
+import { A as BatchDecryptResult, C as BatchDecryptAsOptions, Ct as QueryFactoryOptions, D as DelegationStatus, E as Delegations, Et as TokenWrapperPairWithMetadata, O as Decryption, S as BatchBalancesResult, St as MutationFactoryOptions, T as Permits, Tt as TokenWrapperPair, _t as DecryptResult, bt as SignerQueryContext, d as ZamaSDK, h as WrappersRegistryConfig, j as DelegatedDecryptOptions, k as BatchDecryptItem, m as WrappersRegistry, mt as ZamaErrorCode, p as ListPairsOptions, pt as ZamaError, vt as EncryptedInput, w as Token, wt as PaginatedResult, x as WrappedToken, xt as zamaQueryKeys, y as SerializedTransportKeyPair, yt as decryptValuesQueryOptions } from "../index-DLaQtvYu.js";
+import "../index-DNofJMCK.js";
 import { Address, Hex } from "viem";
 //#region src/query/utils.d.ts
+/** Union of TanStack Query option keys stripped by {@link filterQueryOptions}, leaving only domain parameters. */
 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
@@ -31,55 +33,88 @@ declare function filterQueryOptions<TOptions extends Record<string, unknown>>(op
 declare function hashFn(queryKey: readonly unknown[]): string;
 //#endregion
 //#region src/query/invalidation.d.ts
+/** Minimal query shape read by the invalidation predicates. */
 interface QueryLike {
+  /** The query's cache key. */
   queryKey: readonly unknown[];
 }
+/** Minimal filter shape accepted by the invalidation helpers, matching TanStack Query's `QueryFilters`. */
 interface QueryFilterLike {
+  /** Match queries whose key starts with this prefix. */
   queryKey?: readonly unknown[];
+  /** Match queries for which this returns `true`. */
   predicate?: (query: QueryLike) => boolean;
 }
+/** Minimal `QueryClient` surface used by the invalidation helpers. */
 interface QueryClientLike {
+  /** Mark matching queries stale so they refetch. */
   invalidateQueries(filters: QueryFilterLike): void | Promise<void>;
+  /** Remove matching queries from the cache entirely. */
   removeQueries(filters: QueryFilterLike): void;
 }
+/** Invalidates the caches affected by an unwrap: confidential balances, underlying allowance, and pending unshields. */
 declare function invalidateAfterUnwrap(queryClient: QueryClientLike, tokenAddress: Address): void;
+/** Invalidates the caches affected by a wrap: confidential balances and underlying allowance. */
 declare function invalidateAfterWrap(queryClient: QueryClientLike, tokenAddress: Address): void;
+/** Invalidates the confidential balance queries for a token (single-token and batched). */
 declare function invalidateBalanceQueries(queryClient: QueryClientLike, tokenAddress: Address): void;
+/** Invalidates the caches affected by a shield: confidential balances and underlying allowance. */
 declare function invalidateAfterShield(queryClient: QueryClientLike, tokenAddress: Address): void;
+/** Invalidates the caches affected by an unshield request: confidential balances, underlying allowance, and pending unshields. */
 declare function invalidateAfterUnshield(queryClient: QueryClientLike, tokenAddress: Address): void;
+/** Invalidates the pending-unshield cache once an unshield has settled on-chain. */
 declare function invalidateAfterUnshieldSettled(queryClient: QueryClientLike, tokenAddress: Address): void;
+/** Invalidates the confidential balance caches affected by a transfer. */
 declare function invalidateAfterTransfer(queryClient: QueryClientLike, tokenAddress: Address): void;
+/** Invalidates the underlying-allowance cache after approving the underlying ERC-20. */
 declare function invalidateAfterApproveUnderlying(queryClient: QueryClientLike, tokenAddress: Address): void;
+/** Invalidates the operator-status cache after changing a token operator. */
 declare function invalidateAfterSetOperator(queryClient: QueryClientLike, tokenAddress: Address): void;
+/** Invalidates any wagmi `useBalance`/`readContract` balance queries so ERC-20 balances refresh. */
 declare function invalidateWagmiBalanceQueries(queryClient: QueryClientLike): void;
+/** Clears wallet-local caches (decryption, permits) and invalidates all Zama queries — call on wallet connect/disconnect so a stale entitlement can't leak across accounts. */
 declare function invalidateWalletLifecycleQueries(queryClient: QueryClientLike): void;
 //#endregion
 //#region src/query/token-metadata.d.ts
 /** ERC-20 token metadata returned by {@link tokenMetadataQueryOptions}. */
 interface TokenMetadata {
+  /** Human-readable token name. */
   name: string;
+  /** Token ticker symbol. */
   symbol: string;
+  /** Number of decimals the token uses. */
   decimals: number;
 }
+/** Configuration for {@link tokenMetadataQueryOptions}. */
 interface TokenMetadataQueryConfig {
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
   query?: Record<string, unknown>;
 }
+/** Builds TanStack Query options for reading an ERC-20 token's name, symbol, and decimals. */
 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
+/** Configuration for {@link isConfidentialQueryOptions} and {@link isWrapperQueryOptions}. */
 interface IsConfidentialQueryConfig {
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
   query?: Record<string, unknown>;
 }
+/** Builds TanStack Query options for reading whether a token address implements the confidential (ERC-7984) token interface. */
 declare function isConfidentialQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config?: IsConfidentialQueryConfig): QueryFactoryOptions<boolean, Error, boolean, ReturnType<typeof zamaQueryKeys.isConfidential.token>>;
+/** Builds TanStack Query options for reading whether a token address is a confidential wrapper (ERC-7984 wrapper) contract. */
 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
+/** Configuration for {@link totalSupplyQueryOptions}. */
 interface TotalSupplyQueryConfig {
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
   query?: Record<string, unknown>;
 }
+/** Builds TanStack Query options for reading a token's total supply. */
 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
+/** Configuration for {@link wrapperDiscoveryQueryOptions}. */
 interface WrapperDiscoveryQueryConfig {
   /**
    * Address of any confidential token you control.
@@ -99,19 +134,27 @@ interface WrapperDiscoveryQueryConfig {
    * yet known — the query will be disabled.
    */
   registryAddress?: Address;
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
   query?: Record<string, unknown>;
 }
+/** Builds TanStack Query options for discovering the confidential wrapper address for a given ERC-20 token (resolves to `null` when none is registered). */
 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
+/** Configuration for {@link underlyingAllowanceQueryOptions}. */
 interface UnderlyingAllowanceQueryConfig {
+  /** Owner whose underlying-token allowance to read; the query stays disabled until provided. */
   owner?: Address;
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
   query?: Record<string, unknown>;
 }
+/** Builds TanStack Query options for reading the ERC-20 allowance the owner has granted a confidential wrapper on its underlying token. */
 declare function underlyingAllowanceQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config: UnderlyingAllowanceQueryConfig): QueryFactoryOptions<bigint, Error, bigint, ReturnType<typeof zamaQueryKeys.underlyingAllowance.scope>>;
 //#endregion
 //#region src/query/pending-unshield.d.ts
+/** Configuration for {@link pendingUnshieldQueryOptions}. */
 interface PendingUnshieldQueryConfig {
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
   query?: Record<string, unknown>;
 }
 /**
@@ -125,57 +168,92 @@ interface PendingUnshieldQueryConfig {
 declare function pendingUnshieldQueryOptions(sdk: ZamaSDK, tokenAddress: Address, config?: PendingUnshieldQueryConfig): QueryFactoryOptions<Hex | null, Error, Hex | null, ReturnType<typeof zamaQueryKeys.pendingUnshield.token>>;
 //#endregion
 //#region src/query/confidential-is-operator.d.ts
+/** Configuration for {@link confidentialIsOperatorQueryOptions}. */
 interface ConfidentialIsOperatorQueryConfig {
+  /** Token holder whose operator authorization to check; the query stays disabled until provided. */
   holder?: Address;
+  /** Spender address to check for operator authorization; the query stays disabled until provided. */
   spender?: Address;
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
   query?: Record<string, unknown>;
 }
+/** Builds TanStack Query options for reading whether a spender is an authorized operator of a holder on a confidential token. */
 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
+/** Configuration for {@link confidentialBalanceQueryOptions}. */
 interface ConfidentialBalanceQueryConfig {
+  /** Address of the confidential token to read the balance of. */
   tokenAddress: Address;
+  /** Account whose confidential balance to read; the query stays disabled until provided. */
   account?: Address;
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
   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
+/** Configuration for {@link confidentialBalancesQueryOptions}. */
 interface ConfidentialBalancesQueryConfig {
+  /** Account whose confidential balances to read; the query stays disabled until provided. */
   account?: Address;
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
   query?: Record<string, unknown>;
 }
+/** Builds TanStack Query options for reading the confidential balances of several tokens for one account in a single batch. */
 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
+/** Base configuration shared by the wrappers-registry query option factories. */
 interface WrappersRegistryQueryConfig {
+  /** Registry contract address for the current chain; used as a query key discriminator. */
   registryAddress: Address | undefined;
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
   query?: Record<string, unknown>;
 }
+/** Builds TanStack Query options for reading all token wrapper pairs registered in the wrappers registry. */
 declare function tokenPairsQueryOptions(sdk: ZamaSDK, config: WrappersRegistryQueryConfig): QueryFactoryOptions<readonly TokenWrapperPair[], Error, readonly TokenWrapperPair[], ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenPairs>>;
+/** Configuration for {@link confidentialTokenAddressQueryOptions}. */
 interface ConfidentialTokenAddressQueryConfig extends WrappersRegistryQueryConfig {
+  /** Underlying ERC-20 token address whose confidential counterpart to look up. */
   tokenAddress?: Address;
 }
+/** Builds TanStack Query options for reading the confidential token address registered for a given underlying ERC-20 token. */
 declare function confidentialTokenAddressQueryOptions(sdk: ZamaSDK, config: ConfidentialTokenAddressQueryConfig): QueryFactoryOptions<readonly [boolean, Address], Error, readonly [boolean, Address], ReturnType<typeof zamaQueryKeys.wrappersRegistry.confidentialTokenAddress>>;
+/** Configuration for {@link tokenAddressQueryOptions}. */
 interface TokenAddressQueryConfig extends WrappersRegistryQueryConfig {
+  /** Confidential token address whose underlying ERC-20 counterpart to look up. */
   confidentialTokenAddress?: Address;
 }
+/** Builds TanStack Query options for reading the underlying ERC-20 token address registered for a given confidential token. */
 declare function tokenAddressQueryOptions(sdk: ZamaSDK, config: TokenAddressQueryConfig): QueryFactoryOptions<readonly [boolean, Address], Error, readonly [boolean, Address], ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenAddress>>;
+/** Builds TanStack Query options for reading the total number of token wrapper pairs in the registry. */
 declare function tokenPairsLengthQueryOptions(sdk: ZamaSDK, config: WrappersRegistryQueryConfig): QueryFactoryOptions<bigint, Error, bigint, ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenPairsLength>>;
+/** Configuration for {@link tokenPairsSliceQueryOptions}. */
 interface TokenPairsSliceQueryConfig extends WrappersRegistryQueryConfig {
+  /** Zero-based index of the first pair in the slice (inclusive). */
   fromIndex?: bigint;
+  /** Index bounding the end of the slice. */
   toIndex?: bigint;
 }
+/** Builds TanStack Query options for reading a contiguous slice of the registry's token wrapper pairs. */
 declare function tokenPairsSliceQueryOptions(sdk: ZamaSDK, config: TokenPairsSliceQueryConfig): QueryFactoryOptions<readonly TokenWrapperPair[], Error, readonly TokenWrapperPair[], ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenPairsSlice>>;
+/** Configuration for {@link tokenPairQueryOptions}. */
 interface TokenPairQueryConfig extends WrappersRegistryQueryConfig {
+  /** Zero-based index of the token wrapper pair to read. */
   index?: bigint;
 }
+/** Builds TanStack Query options for reading a single token wrapper pair by its index in the registry. */
 declare function tokenPairQueryOptions(sdk: ZamaSDK, config: TokenPairQueryConfig): QueryFactoryOptions<TokenWrapperPair, Error, TokenWrapperPair, ReturnType<typeof zamaQueryKeys.wrappersRegistry.tokenPair>>;
+/** Configuration for {@link isConfidentialTokenValidQueryOptions}. */
 interface IsConfidentialTokenValidQueryConfig extends WrappersRegistryQueryConfig {
+  /** Confidential token address to validate against the registry. */
   confidentialTokenAddress?: Address;
 }
+/** Builds TanStack Query options for checking whether a confidential token is registered and valid in the registry. */
 declare function isConfidentialTokenValidQueryOptions(sdk: ZamaSDK, config: IsConfidentialTokenValidQueryConfig): QueryFactoryOptions<boolean, Error, boolean, ReturnType<typeof zamaQueryKeys.wrappersRegistry.isConfidentialTokenValid>>;
+/** Configuration for {@link listPairsQueryOptions}. */
 interface ListPairsQueryConfig {
   /**
    * The registry address for this chain — used as a query key discriminator.
@@ -184,9 +262,13 @@ interface ListPairsQueryConfig {
    * per registry contract.
    */
   registryAddress: Address | undefined;
+  /** 1-based page number to fetch; defaults to `1`. */
   page?: number;
+  /** Number of pairs per page; defaults to `100`. */
   pageSize?: number;
+  /** When `true`, resolve each pair's on-chain metadata; defaults to `false`. */
   metadata?: boolean;
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
   query?: Record<string, unknown>;
 }
 /**
@@ -201,101 +283,132 @@ declare function listPairsQueryOptions(registry: WrappersRegistry, config: ListP
 //#region src/query/shield.d.ts
 /** Variables for {@link shieldMutationOptions}. */
 interface ShieldParams extends ShieldOptions {
+  /** Amount of the public ERC-20 to shield, in the token's base units. */
   amount: bigint;
 }
+/** Builds TanStack Query mutation options for {@link WrappedToken.shield | shielding} a public ERC-20 into its confidential form. @see {@link ShieldParams} */
 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 {
+  /** Recipient address. */
   to: Address;
+  /** Amount of tokens to transfer, in the token's base units. */
   amount: bigint;
 }
+/** Builds TanStack Query mutation options for {@link Token.confidentialTransfer | transferring} confidential tokens. @see {@link ConfidentialTransferParams} */
 declare function confidentialTransferMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.confidentialTransfer", Address], ConfidentialTransferParams, TransactionResult>;
 //#endregion
 //#region src/query/transfer-and-call.d.ts
 /** Variables for {@link confidentialTransferAndCallMutationOptions}. */
 interface ConfidentialTransferAndCallParams extends TransferOptions {
+  /** Recipient address. */
   to: Address;
+  /** Amount of tokens to transfer, in the token's base units. */
   amount: bigint;
   /** Opaque bytes forwarded to the recipient's ERC-7984 receiver hook. */
   data: Hex;
 }
+/** Builds TanStack Query mutation options for {@link Token.confidentialTransferAndCall | transferring} confidential tokens and invoking the recipient's receiver hook. @see {@link ConfidentialTransferAndCallParams} */
 declare function confidentialTransferAndCallMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.confidentialTransferAndCall", Address], ConfidentialTransferAndCallParams, TransactionResult>;
 //#endregion
 //#region src/query/transfer-from.d.ts
 /** Variables for {@link confidentialTransferFromMutationOptions}. */
 interface ConfidentialTransferFromParams {
+  /** Address to transfer from. */
   from: Address;
+  /** Recipient address. */
   to: Address;
+  /** Amount of tokens to transfer, in the token's base units. */
   amount: bigint;
   /** Optional progress callbacks for the multi-step transfer flow. */
   callbacks?: TransferCallbacks;
 }
+/** Builds TanStack Query mutation options for {@link Token.confidentialTransferFrom | transferring} confidential tokens from another account (operator flow). @see {@link ConfidentialTransferFromParams} */
 declare function confidentialTransferFromMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.confidentialTransferFrom", Address], ConfidentialTransferFromParams, TransactionResult>;
 //#endregion
 //#region src/query/transfer-from-and-call.d.ts
 /** Variables for {@link confidentialTransferFromAndCallMutationOptions}. */
 interface ConfidentialTransferFromAndCallParams {
+  /** Address to transfer from. */
   from: Address;
+  /** Recipient address. */
   to: Address;
+  /** Amount of tokens to transfer, in the token's base units. */
   amount: bigint;
   /** Opaque bytes forwarded to the recipient's ERC-7984 receiver hook. */
   data: Hex;
   /** Optional progress callbacks for the multi-step transfer flow. */
   callbacks?: TransferCallbacks;
 }
+/** Builds TanStack Query mutation options for {@link Token.confidentialTransferFromAndCall | transferring} confidential tokens from another account and invoking the recipient's receiver hook. @see {@link ConfidentialTransferFromAndCallParams} */
 declare function confidentialTransferFromAndCallMutationOptions(token: Token): MutationFactoryOptions<readonly ["zama.confidentialTransferFromAndCall", Address], ConfidentialTransferFromAndCallParams, TransactionResult>;
 //#endregion
 //#region src/query/set-operator.d.ts
 /** Variables for {@link confidentialSetOperatorMutationOptions}. */
 interface ConfidentialSetOperatorParams {
+  /** Operator address to authorize. */
   operator: Address;
+  /** Unix timestamp (seconds) when the operator authorization expires; defaults to one hour from now. */
   until?: number;
 }
+/** Builds TanStack Query mutation options for {@link Token.setOperator | authorizing} an operator on a confidential token. @see {@link ConfidentialSetOperatorParams} */
 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 of the underlying ERC-20 to approve, in its base units; omit for a max approval. */
   amount?: bigint;
 }
+/** Builds TanStack Query mutation options for {@link WrappedToken.approveUnderlying | approving} the wrapper to spend the underlying ERC-20. @see {@link ApproveUnderlyingParams} */
 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 of tokens to unshield, in the token's base units. */
   amount: bigint;
 }
+/** Builds TanStack Query mutation options for {@link WrappedToken.unshield | unshielding} a confidential token back into its public ERC-20. @see {@link UnshieldParams} */
 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 {}
+/** Builds TanStack Query mutation options for {@link WrappedToken.unshieldAll | unshielding} the entire confidential balance back into the public ERC-20. @see {@link UnshieldAllParams} */
 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 {
+  /** Hash of the earlier unwrap request transaction to resume from. */
   unwrapTxHash: Hex;
 }
+/** Builds TanStack Query mutation options for {@link WrappedToken.resumeUnshield | resuming} an interrupted unshield from its unwrap request transaction. @see {@link ResumeUnshieldParams} */
 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 of tokens to unwrap, in the token's base units. */
   amount: bigint;
 }
+/** Builds TanStack Query mutation options for {@link WrappedToken.unwrap | unwrapping} a confidential token (request phase of the two-phase unwrap). @see {@link UnwrapParams} */
 declare function unwrapMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.unwrap", Address], UnwrapParams, UnwrapResult>;
 //#endregion
 //#region src/query/wrap.d.ts
 /** Variables for {@link wrapMutationOptions}. */
 interface WrapParams extends WrapOptions {
+  /** Amount of the public ERC-20 to wrap, in the token's base units. */
   amount: bigint;
 }
+/** Builds TanStack Query mutation options for {@link WrappedToken.wrap | wrapping} a public ERC-20 into its confidential form. @see {@link WrapParams} */
 declare function wrapMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.wrap", Address], WrapParams, TransactionResult>;
 //#endregion
 //#region src/query/unwrap-all.d.ts
+/** Builds TanStack Query mutation options for {@link WrappedToken.unwrapAll | unwrapping} the entire confidential balance. */
 declare function unwrapAllMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.unwrapAll", Address], void, UnwrapResult>;
 //#endregion
 //#region src/query/finalize-unwrap.d.ts
@@ -304,25 +417,34 @@ type FinalizeUnwrapParams = {
   /** Identifier from an `UnwrapRequested` event. */
   unwrapRequestId: EncryptedValue;
 };
+/** Builds TanStack Query mutation options for {@link WrappedToken.finalizeUnwrap | finalizing} a previously requested unwrap. @see {@link FinalizeUnwrapParams} */
 declare function finalizeUnwrapMutationOptions(token: WrappedToken): MutationFactoryOptions<readonly ["zama.finalizeUnwrap", Address], FinalizeUnwrapParams, TransactionResult>;
 //#endregion
 //#region src/query/encrypt.d.ts
+/** Builds TanStack Query mutation options for {@link ZamaSDK.encrypt | encrypting} plaintext inputs into an encrypted payload. */
 declare function encryptMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.encrypt"], EncryptParams, EncryptResult>;
 //#endregion
 //#region src/query/delegated-decrypt.d.ts
+/** Variables for {@link delegatedDecryptValuesMutationOptions}. */
 interface DelegatedDecryptValuesMutationParams {
+  /** Encrypted values (with their contract addresses) to decrypt. */
   encryptedInputs: EncryptedInput[];
+  /** Address of the account that delegated decryption rights to the connected wallet. */
   delegatorAddress: Address;
 }
+/** Builds TanStack Query mutation options for {@link Decryption.delegatedDecryptValues | decrypting} encrypted values via delegated decryption credentials. @see {@link DelegatedDecryptValuesMutationParams} */
 declare function delegatedDecryptValuesMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.delegatedDecryptValues"], DelegatedDecryptValuesMutationParams, Readonly<Record<EncryptedValue, ClearValue>>>;
 //#endregion
 //#region src/query/public-decrypt.d.ts
+/** Builds TanStack Query mutation options for {@link Decryption.decryptPublicValues | publicly decrypting} encrypted values, caching each clear result. */
 declare function decryptPublicValuesMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.decryptPublicValues"], EncryptedValue[], DecryptPublicValuesResult>;
 //#endregion
 //#region src/query/grant-permit.d.ts
+/** Builds TanStack Query mutation options for {@link Permits.grantPermit | granting} decryption permits for the given contract addresses. */
 declare function grantPermitMutationOptions(sdk: ZamaSDK): MutationFactoryOptions<readonly ["zama.grantPermit"], Address[], void>;
 //#endregion
 //#region src/query/has-permit.d.ts
+/** Configuration for {@link hasPermitQueryOptions}. */
 interface HasPermitQueryConfig {
   /** Contract addresses to check credentials against. */
   contractAddresses: Address[];
@@ -333,6 +455,7 @@ interface HasPermitQueryConfig {
    */
   query?: Record<string, unknown>;
 }
+/** Builds TanStack Query options for reading whether the connected wallet holds a valid decryption permit for the given contracts. */
 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
@@ -346,43 +469,54 @@ declare function clearCredentialsMutationOptions(sdk: ZamaSDK): MutationFactoryO
 //#region src/query/delegate-decryption.d.ts
 /** Variables for {@link delegateDecryptionMutationOptions}. */
 interface DelegateDecryptionParams {
+  /** Address to grant delegated decryption rights to. */
   delegateAddress: Address;
+  /** When the delegation expires; omit for no expiry. */
   expirationDate?: Date;
 }
+/** Builds TanStack Query mutation options for {@link Delegations.delegateDecryption | granting} delegated decryption rights on a contract. @see {@link DelegateDecryptionParams} */
 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 {
+  /** Address of the account that delegated decryption rights to the connected wallet. */
   delegatorAddress: Address;
+  /** Account whose on-chain balance to read; defaults to the delegator address. */
   accountAddress?: Address;
 }
+/** Builds TanStack Query mutation options for {@link Token.decryptBalanceAs | decrypting} a balance via delegated decryption credentials. @see {@link DecryptBalanceAsParams} */
 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;
+/** Builds TanStack Query mutation options for {@link Token.batchDecryptBalancesAs | decrypting} multiple token balances via delegated decryption credentials. @see {@link BatchDecryptBalancesAsParams} */
 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 {
+  /** Address whose delegated decryption rights to revoke. */
   delegateAddress: Address;
 }
+/** Builds TanStack Query mutation options for {@link Delegations.revokeDelegation | revoking} delegated decryption rights on a contract. @see {@link RevokeDelegationParams} */
 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;
-}
+/** Configuration for {@link delegationStatusQueryOptions}. */
 interface DelegationStatusQueryConfig {
+  /** Contract the delegation applies to; pass `undefined` to keep the query disabled. */
   contractAddress: Address | undefined;
+  /** Address granting the delegated decryption rights; the query stays disabled until provided. */
   delegatorAddress?: Address;
+  /** Address receiving the delegated decryption rights; the query stays disabled until provided. */
   delegateAddress?: Address;
+  /** Additional TanStack Query options merged into the generated query (e.g. `staleTime`, `enabled`). */
   query?: Record<string, unknown>;
 }
-declare function delegationStatusQueryOptions(sdk: ZamaSDK, config: DelegationStatusQueryConfig): QueryFactoryOptions<DelegationStatusData, Error, DelegationStatusData, ReturnType<typeof zamaQueryKeys.delegationStatus.scope>>;
+/** Builds TanStack Query options for reading the decryption-delegation status between a delegator and a delegate on a contract. */
+declare function delegationStatusQueryOptions(sdk: ZamaSDK, config: DelegationStatusQueryConfig): QueryFactoryOptions<DelegationStatus, Error, DelegationStatus, 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 ConfidentialTransferAndCallParams, type ConfidentialTransferEvent, type ConfidentialTransferFromAndCallParams, type ConfidentialTransferFromParams, type ConfidentialTransferParams, type DecryptBalanceAsParams, type DecryptEndEvent, type DecryptErrorEvent, type EncryptedInput as DecryptInput, type DecryptPublicValuesResult, type DecryptResult, type DecryptStartEvent, type DelegateDecryptionParams, type DelegatedDecryptValuesMutationParams, 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 PendingUnshieldQueryConfig, type QueryClientLike, type QueryFactoryOptions, type QueryFilterLike, type QueryLike, type RawLog, type FhevmRelayerSDK as RelayerSDK, type ResumeUnshieldParams, type RevokeDelegationParams, type RevokeDelegationSubmittedEvent, type SerializedTransportKeyPair, type SetOperatorSubmittedEvent, type ShieldCallbacks, type ShieldOptions, type ShieldParams, type ShieldPath, type ShieldSubmittedEvent, type SignerQueryContext, 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 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 WrapParams, 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, confidentialTransferAndCallMutationOptions, confidentialTransferFromAndCallMutationOptions, confidentialTransferFromMutationOptions, confidentialTransferMutationOptions, decryptBalanceAsMutationOptions, decryptPublicValuesMutationOptions, decryptValuesQueryOptions, delegateDecryptionMutationOptions, delegatedDecryptValuesMutationOptions, delegationStatusQueryOptions, encryptMutationOptions, filterQueryOptions, finalizeUnwrapMutationOptions, grantPermitMutationOptions, hasPermitQueryOptions, hashFn, invalidateAfterApproveUnderlying, invalidateAfterSetOperator, invalidateAfterShield, invalidateAfterTransfer, invalidateAfterUnshield, invalidateAfterUnshieldSettled, invalidateAfterUnwrap, invalidateAfterWrap, invalidateBalanceQueries, invalidateWagmiBalanceQueries, invalidateWalletLifecycleQueries, isConfidentialQueryOptions, isConfidentialTokenValidQueryOptions, isWrapperQueryOptions, listPairsQueryOptions, pendingUnshieldQueryOptions, resumeUnshieldMutationOptions, revokeDelegationMutationOptions, revokePermitsMutationOptions, shieldMutationOptions, tokenAddressQueryOptions, tokenMetadataQueryOptions, tokenPairQueryOptions, tokenPairsLengthQueryOptions, tokenPairsQueryOptions, tokenPairsSliceQueryOptions, totalSupplyQueryOptions, underlyingAllowanceQueryOptions, unshieldAllMutationOptions, unshieldMutationOptions, unwrapAllMutationOptions, unwrapMutationOptions, wrapMutationOptions, wrapperDiscoveryQueryOptions, zamaQueryKeys };
+export { type ApprovalStrategy, type ApproveUnderlyingParams, type ApproveUnderlyingSubmittedEvent, type BaseEvent, type BatchBalancesResult, type BatchDecryptAsOptions, type BatchDecryptBalancesAsParams, type BatchDecryptItem, type BatchDecryptResult, type ClearValue, type ConfidentialBalanceQueryConfig, type ConfidentialBalancesQueryConfig, type ConfidentialIsOperatorQueryConfig, type ConfidentialSetOperatorParams, type ConfidentialTokenAddressQueryConfig, type ConfidentialTransferAndCallParams, type ConfidentialTransferEvent, type ConfidentialTransferFromAndCallParams, type ConfidentialTransferFromParams, type ConfidentialTransferParams, type ContractAbi, type DecryptBalanceAsParams, type DecryptEndEvent, type DecryptErrorEvent, type EncryptedInput as DecryptInput, type DecryptPublicValuesResult, type DecryptResult, type DecryptStartEvent, type Decryption, type DelegateDecryptionParams, type DelegatedDecryptOptions, type DelegatedDecryptValuesMutationParams, type DelegationStatus, type DelegationStatusQueryConfig, type DelegationSubmittedEvent, type Delegations, type EIP712TypedData, type EncryptEndEvent, type EncryptErrorEvent, type EncryptInput, type EncryptParams, type EncryptResult, type EncryptStartEvent, type EncryptedValue, type FheChain, type FheChainAuth, type FhevmClient, type FhevmRelayerOptions, type FhevmRuntimeConfig, type FinalizeUnwrapParams, type FinalizeUnwrapSubmittedEvent, type GenericLogger, type GenericProvider, type GenericSigner, type GenericStorage, type HasPermitQueryConfig, type IsConfidentialQueryConfig, type IsConfidentialTokenValidQueryConfig, type ListPairsOptions, type ListPairsQueryConfig, type MutationFactoryOptions, type OnChainEvent, type PaginatedResult, type PendingUnshieldQueryConfig, type Permits, type QueryClientLike, type QueryFactoryOptions, type QueryFilterLike, type QueryLike, type RawLog, type ReadContractArgs, type ReadContractConfig, type ReadContractReturnType, type ReadFunctionName, type RelayerSDK, type ResumeUnshieldParams, type RevokeDelegationParams, type RevokeDelegationSubmittedEvent, type SerializedTransportKeyPair, type SetOperatorSubmittedEvent, type ShieldCallbacks, type ShieldOptions, type ShieldParams, type ShieldPath, type ShieldSubmittedEvent, type SignerQueryContext, type StrippedQueryOptionKeys, type Token, type TokenAddressQueryConfig, type TokenMetadata, type TokenMetadataQueryConfig, type TokenPairQueryConfig, type TokenPairsSliceQueryConfig, type TokenWrapperPair, type TokenWrapperPairWithMetadata, type TotalSupplyQueryConfig, type TransactionErrorEvent, type TransactionOperation, type TransactionReceipt, type TransactionResult, type TransferCallbacks, type TransferFromSubmittedEvent, type TransferOptions, type TransferSubmittedEvent, type UnderlyingAllowanceQueryConfig, type UnshieldAllParams, type UnshieldCallbacks, type UnshieldOptions, type UnshieldParams, type UnshieldPhase1SubmittedEvent, type UnshieldPhase2StartedEvent, type UnshieldPhase2SubmittedEvent, type UnwrapFinalizedEvent, type UnwrapParams, type UnwrapRequestedEvent, type UnwrapResult, type UnwrapSubmittedEvent, type WalletAccount, type WalletAccountChange, type WalletAccountListener, type WalletAccountStore, type WrapEvent, type WrapOptions, type WrapParams, type WrapSubmittedEvent, type WrappedToken, type WrapperDiscoveryQueryConfig, type WrappersRegistry, type WrappersRegistryConfig, type WrappersRegistryQueryConfig, type WriteContractArgs, type WriteContractConfig, type WriteFunctionName, type ZamaConfig, type ZamaError, type ZamaErrorCode, type ZamaSDK, type ZamaSDKEvent, type ZamaSDKEventListener, ZamaSDKEvents, approveUnderlyingMutationOptions, batchDecryptBalancesAsMutationOptions, clearCredentialsMutationOptions, confidentialBalanceQueryOptions, confidentialBalancesQueryOptions, confidentialIsOperatorQueryOptions, confidentialSetOperatorMutationOptions, confidentialTokenAddressQueryOptions, confidentialTransferAndCallMutationOptions, confidentialTransferFromAndCallMutationOptions, confidentialTransferFromMutationOptions, confidentialTransferMutationOptions, decryptBalanceAsMutationOptions, decryptPublicValuesMutationOptions, decryptValuesQueryOptions, delegateDecryptionMutationOptions, delegatedDecryptValuesMutationOptions, delegationStatusQueryOptions, encryptMutationOptions, filterQueryOptions, finalizeUnwrapMutationOptions, grantPermitMutationOptions, hasPermitQueryOptions, hashFn, invalidateAfterApproveUnderlying, invalidateAfterSetOperator, invalidateAfterShield, invalidateAfterTransfer, invalidateAfterUnshield, invalidateAfterUnshieldSettled, invalidateAfterUnwrap, invalidateAfterWrap, invalidateBalanceQueries, invalidateWagmiBalanceQueries, invalidateWalletLifecycleQueries, isConfidentialQueryOptions, isConfidentialTokenValidQueryOptions, isWrapperQueryOptions, listPairsQueryOptions, pendingUnshieldQueryOptions, resumeUnshieldMutationOptions, revokeDelegationMutationOptions, revokePermitsMutationOptions, shieldMutationOptions, tokenAddressQueryOptions, tokenMetadataQueryOptions, tokenPairQueryOptions, tokenPairsLengthQueryOptions, tokenPairsQueryOptions, tokenPairsSliceQueryOptions, totalSupplyQueryOptions, underlyingAllowanceQueryOptions, unshieldAllMutationOptions, unshieldMutationOptions, unwrapAllMutationOptions, unwrapMutationOptions, wrapMutationOptions, wrapperDiscoveryQueryOptions, zamaQueryKeys };
 //# sourceMappingURL=index.d.ts.map