@tokenops/sdk 1.0.0

package/dist/fhe-vesting/react/useAcceptVestingTransfer.d.ts

@@ -0,0 +1,12 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type ManagerHookOptions } from "./_shared.js";
+export interface UseAcceptVestingTransferArgs {
+    vestingId: Hex;
+    account?: Account | Address;
+}
+/**
+ * Accept a pending vesting transfer — called by the proposed `newRecipient`
+ * before `expiresAt`.
+ */
+export declare function useAcceptVestingTransfer(options: ManagerHookOptions): UseMutationResult<Hex, Error, UseAcceptVestingTransferArgs>;

package/dist/fhe-vesting/react/useAccessClaimableAmount.d.ts

@@ -0,0 +1,14 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import type { VestingId } from "../../core/brands.js";
+import type { EncryptedViewResult } from "../manager.js";
+import { type ManagerHookOptions } from "./_shared.js";
+export interface UseAccessClaimableAmountArgs {
+    vestingId: VestingId;
+    account?: Account | Address;
+}
+/**
+ * **Submits a transaction** to read the currently-claimable amount as an
+ * `euint128` handle. Pass `data.handle` to the Zama relayer's `userDecrypt`.
+ */
+export declare function useAccessClaimableAmount(options: ManagerHookOptions): UseMutationResult<EncryptedViewResult, Error, UseAccessClaimableAmountArgs>;

package/dist/fhe-vesting/react/useAccessSettledAmount.d.ts

@@ -0,0 +1,15 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import type { VestingId } from "../../core/brands.js";
+import type { EncryptedViewResult } from "../manager.js";
+import { type ManagerHookOptions } from "./_shared.js";
+export interface UseAccessSettledAmountArgs {
+    vestingId: VestingId;
+    account?: Account | Address;
+}
+/**
+ * **Submits a transaction** to read the already-claimed (settled) amount of a
+ * vesting as an `euint128` handle. Pass `data.handle` to the Zama relayer's
+ * `userDecrypt`.
+ */
+export declare function useAccessSettledAmount(options: ManagerHookOptions): UseMutationResult<EncryptedViewResult, Error, UseAccessSettledAmountArgs>;

package/dist/fhe-vesting/react/useAccessTotalAllocation.d.ts

@@ -0,0 +1,14 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import type { VestingId } from "../../core/brands.js";
+import type { EncryptedViewResult } from "../manager.js";
+import { type ManagerHookOptions } from "./_shared.js";
+export interface UseAccessTotalAllocationArgs {
+    vestingId: VestingId;
+    account?: Account | Address;
+}
+/**
+ * **Submits a transaction** to read the total allocation of a vesting as an
+ * `euint128` handle. Pass `data.handle` to the Zama relayer's `userDecrypt`.
+ */
+export declare function useAccessTotalAllocation(options: ManagerHookOptions): UseMutationResult<EncryptedViewResult, Error, UseAccessTotalAllocationArgs>;

package/dist/fhe-vesting/react/useAccessVestedAmount.d.ts

@@ -0,0 +1,26 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import type { VestingId } from "../../core/brands.js";
+import type { EncryptedViewResult } from "../manager.js";
+import { type ManagerHookOptions } from "./_shared.js";
+export interface UseAccessVestedAmountArgs {
+    vestingId: VestingId;
+    /** Unix timestamp (seconds) — `Math.floor(Date.now() / 1000)` for "now". */
+    timestamp: number;
+    account?: Account | Address;
+}
+/**
+ * **Submits a transaction** to read the vested amount at a given timestamp as
+ * an `euint128` handle. The contract performs `FHE.allow(handle, msg.sender)`
+ * so persistent ACL is granted to the caller; the SDK parses the handle from
+ * the receipt's `ACL.Allowed` event (NOT from simulation — that returns a
+ * different, ACL-less handle).
+ *
+ * Pass `data.handle` to the Zama relayer's `userDecrypt` to get the plaintext.
+ *
+ * @example
+ * const getVested = useAccessVestedAmount({ address: managerAddress });
+ * getVested.mutate({ vestingId, timestamp: Math.floor(Date.now() / 1000) });
+ * // getVested.data → { handle: "0x...", hash: "0x..." }
+ */
+export declare function useAccessVestedAmount(options: ManagerHookOptions): UseMutationResult<EncryptedViewResult, Error, UseAccessVestedAmountArgs>;

package/dist/fhe-vesting/react/useAdminBatchDiscloseToParty.d.ts

@@ -0,0 +1,16 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import type { BatchDiscloseToPartyResult } from "../manager.js";
+import { type DisclosureType } from "../types.js";
+import { type ManagerHookOptions } from "./_shared.js";
+export interface UseAdminBatchDiscloseToPartyArgs {
+    vestingIds: readonly Hex[];
+    disclosureTypes: readonly DisclosureType[];
+    party: Address;
+    account?: Account | Address;
+}
+/**
+ * Admin variant of {@link useBatchDiscloseToParty} — caller must hold
+ * `DISCLOSURE_ADMIN_ROLE`. Same `{ hash, handles }` receipt-parsed result.
+ */
+export declare function useAdminBatchDiscloseToParty(options: ManagerHookOptions): UseMutationResult<BatchDiscloseToPartyResult, Error, UseAdminBatchDiscloseToPartyArgs>;

package/dist/fhe-vesting/react/useAdminClaim.d.ts

@@ -0,0 +1,9 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import type { ClaimArgs } from "../manager.js";
+import { type ManagerHookOptions } from "./_shared.js";
+/**
+ * Admin variant of {@link useClaim} — caller must hold `CLAIMER_ROLE`. Useful
+ * for sweep / forced-claim flows initiated by a treasury.
+ */
+export declare function useAdminClaim(options: ManagerHookOptions): UseMutationResult<Hex, Error, ClaimArgs>;

package/dist/fhe-vesting/react/useAdminDiscloseToParty.d.ts

@@ -0,0 +1,8 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { DiscloseArgs, DiscloseToPartyResult } from "../manager.js";
+import { type ManagerHookOptions } from "./_shared.js";
+/**
+ * Admin variant of {@link useDiscloseToParty} — caller must hold
+ * `DISCLOSURE_ADMIN_ROLE`. Same `{ hash, handle }` receipt-parsed result.
+ */
+export declare function useAdminDiscloseToParty(options: ManagerHookOptions): UseMutationResult<DiscloseToPartyResult, Error, DiscloseArgs>;

package/dist/fhe-vesting/react/useAdminGetClaimableAmount.d.ts

@@ -0,0 +1,13 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import type { EncryptedViewResult } from "../manager.js";
+import { type ManagerHookOptions } from "./_shared.js";
+export interface UseAdminGetClaimableAmountArgs {
+    vestingId: Hex;
+    account?: Account | Address;
+}
+/**
+ * Admin variant of {@link useGetClaimableAmount} — caller must hold
+ * `DISCLOSURE_ADMIN_ROLE`. Submits a tx; returns an `euint128` handle.
+ */
+export declare function useAdminGetClaimableAmount(options: ManagerHookOptions): UseMutationResult<EncryptedViewResult, Error, UseAdminGetClaimableAmountArgs>;

package/dist/fhe-vesting/react/useAdminGetSettledAmount.d.ts

@@ -0,0 +1,13 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import type { EncryptedViewResult } from "../manager.js";
+import { type ManagerHookOptions } from "./_shared.js";
+export interface UseAdminGetSettledAmountArgs {
+    vestingId: Hex;
+    account?: Account | Address;
+}
+/**
+ * Admin variant of {@link useGetSettledAmount} — caller must hold
+ * `DISCLOSURE_ADMIN_ROLE`. Submits a tx; returns an `euint128` handle.
+ */
+export declare function useAdminGetSettledAmount(options: ManagerHookOptions): UseMutationResult<EncryptedViewResult, Error, UseAdminGetSettledAmountArgs>;

package/dist/fhe-vesting/react/useAdminGetTokenBalance.d.ts

@@ -0,0 +1,13 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address } from "viem";
+import type { EncryptedViewResult } from "../manager.js";
+import { type ManagerHookOptions } from "./_shared.js";
+export interface UseAdminGetTokenBalanceArgs {
+    account?: Account | Address;
+}
+/**
+ * Admin: read the manager clone's confidential ERC-7984 token balance as an
+ * `euint64` handle. Submits a tx and parses the handle from the ACL `Allowed`
+ * event.
+ */
+export declare function useAdminGetTokenBalance(options: ManagerHookOptions): UseMutationResult<EncryptedViewResult, Error, UseAdminGetTokenBalanceArgs | undefined>;

package/dist/fhe-vesting/react/useAdminGetTotalAllocation.d.ts

@@ -0,0 +1,13 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import type { EncryptedViewResult } from "../manager.js";
+import { type ManagerHookOptions } from "./_shared.js";
+export interface UseAdminGetTotalAllocationArgs {
+    vestingId: Hex;
+    account?: Account | Address;
+}
+/**
+ * Admin variant of {@link useGetTotalAllocation} — caller must hold
+ * `DISCLOSURE_ADMIN_ROLE`. Submits a tx; returns an `euint128` handle.
+ */
+export declare function useAdminGetTotalAllocation(options: ManagerHookOptions): UseMutationResult<EncryptedViewResult, Error, UseAdminGetTotalAllocationArgs>;

package/dist/fhe-vesting/react/useAdminGetVestedAmount.d.ts

@@ -0,0 +1,15 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import type { EncryptedViewResult } from "../manager.js";
+import { type ManagerHookOptions } from "./_shared.js";
+export interface UseAdminGetVestedAmountArgs {
+    vestingId: Hex;
+    timestamp: number;
+    account?: Account | Address;
+}
+/**
+ * Admin variant of {@link useGetVestedAmount} — caller must hold
+ * `DISCLOSURE_ADMIN_ROLE`. Submits a tx; returns an `euint128` handle granted
+ * to the admin caller. Pass `data.handle` to the Zama relayer's `userDecrypt`.
+ */
+export declare function useAdminGetVestedAmount(options: ManagerHookOptions): UseMutationResult<EncryptedViewResult, Error, UseAdminGetVestedAmountArgs>;

package/dist/fhe-vesting/react/useAdminPartialClaim.d.ts

@@ -0,0 +1,8 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import type { PartialClaimArgs } from "../manager.js";
+import { type ManagerHookOptions } from "./_shared.js";
+/**
+ * Admin variant of {@link usePartialClaim} — caller must hold `CLAIMER_ROLE`.
+ */
+export declare function useAdminPartialClaim(options: ManagerHookOptions): UseMutationResult<Hex, Error, PartialClaimArgs>;

package/dist/fhe-vesting/react/useAllRecipients.d.ts

@@ -0,0 +1,8 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type ManagerHookOptions } from "./_shared.js";
+/**
+ * Read the manager clone's full recipients set. For large vestings, prefer
+ * {@link useAllRecipientsSliced} to keep payloads bounded.
+ */
+export declare function useAllRecipients(options: ManagerHookOptions): UseQueryResult<readonly Address[], Error>;

package/dist/fhe-vesting/react/useAllRecipientsLength.d.ts

@@ -0,0 +1,6 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type ManagerHookOptions } from "./_shared.js";
+/**
+ * Read the total number of unique recipients on this manager clone.
+ */
+export declare function useAllRecipientsLength(options: ManagerHookOptions): UseQueryResult<bigint, Error>;

package/dist/fhe-vesting/react/useAllRecipientsSliced.d.ts

@@ -0,0 +1,13 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type ManagerHookOptions } from "./_shared.js";
+export interface UseAllRecipientsSlicedArgs extends ManagerHookOptions {
+    start?: bigint;
+    end?: bigint;
+}
+/**
+ * Read a `[start, end)` slice of the recipients set. Both `start` and `end`
+ * must be set for the query to be enabled. Pair with {@link useAllRecipientsLength}
+ * for paginated UIs.
+ */
+export declare function useAllRecipientsSliced(args: UseAllRecipientsSlicedArgs): UseQueryResult<readonly Address[], Error>;

package/dist/fhe-vesting/react/useBatchCreateVesting.d.ts

@@ -0,0 +1,24 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import type { BatchCreateVestingArgs } from "../manager.js";
+import { type ManagerHookOptions } from "./_shared.js";
+/**
+ * Batch-create confidential vesting schedules. All amounts are encrypted
+ * together under one input proof, saving gas vs. N separate `useCreateVesting`
+ * calls.
+ *
+ * Respect `useManagerMaxBatchSize` before submitting large lists.
+ *
+ * After success, invalidate `["tokenops-sdk", "fhe-vesting"]` (broad) or the
+ * narrower recipient/vesting query keys.
+ *
+ * @example
+ * const batch = useBatchCreateVesting({ address: managerAddress, encryptor: () => useZamaSDK() });
+ * batch.mutate({
+ *   items: [
+ *     { params: paramsA, amount: 100_000n },
+ *     { params: paramsB, amount: 200_000n },
+ *   ],
+ * });
+ */
+export declare function useBatchCreateVesting(options: ManagerHookOptions): UseMutationResult<Hex, Error, BatchCreateVestingArgs>;

package/dist/fhe-vesting/react/useBatchDiscloseHandlesToParty.d.ts

@@ -0,0 +1,13 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type ManagerHookOptions } from "./_shared.js";
+export interface UseBatchDiscloseHandlesToPartyArgs {
+    handles: readonly Hex[];
+    party: Address;
+    account?: Account | Address;
+}
+/**
+ * Batch variant of {@link useDiscloseHandleToParty}. The SDK throws if
+ * `handles` is empty.
+ */
+export declare function useBatchDiscloseHandlesToParty(options: ManagerHookOptions): UseMutationResult<Hex, Error, UseBatchDiscloseHandlesToPartyArgs>;

package/dist/fhe-vesting/react/useBatchDiscloseToParty.d.ts

@@ -0,0 +1,18 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import type { BatchDiscloseToPartyResult } from "../manager.js";
+import { type DisclosureType } from "../types.js";
+import { type ManagerHookOptions } from "./_shared.js";
+export interface UseBatchDiscloseToPartyArgs {
+    vestingIds: readonly Hex[];
+    disclosureTypes: readonly DisclosureType[];
+    party: Address;
+    account?: Account | Address;
+}
+/**
+ * Recipient batch-discloses N encrypted fields across N vestings to a single
+ * `party`. `vestingIds.length` must equal `disclosureTypes.length`. Returns
+ * `{ hash, handles }` — `handles[i]` is the granted `euint128` for
+ * `vestingIds[i]`, parsed from the receipt's `AmountDisclosed` events.
+ */
+export declare function useBatchDiscloseToParty(options: ManagerHookOptions): UseMutationResult<BatchDiscloseToPartyResult, Error, UseBatchDiscloseToPartyArgs>;

package/dist/fhe-vesting/react/useBatchRevokeVesting.d.ts

@@ -0,0 +1,12 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type ManagerHookOptions } from "./_shared.js";
+export interface UseBatchRevokeVestingArgs {
+    vestingIds: readonly Hex[];
+    account?: Account | Address;
+}
+/**
+ * Batch-revoke up to `maxRevokeBatchSize` vestings. Caller must hold
+ * `REVOKER_ROLE`. The SDK throws if `vestingIds` is empty.
+ */
+export declare function useBatchRevokeVesting(options: ManagerHookOptions): UseMutationResult<Hex, Error, UseBatchRevokeVestingArgs>;

package/dist/fhe-vesting/react/useCancelVestingTransfer.d.ts

@@ -0,0 +1,12 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type ManagerHookOptions } from "./_shared.js";
+export interface UseCancelVestingTransferArgs {
+    vestingId: Hex;
+    account?: Account | Address;
+}
+/**
+ * Cancel a pending vesting transfer — called by the initiator before the
+ * recipient accepts.
+ */
+export declare function useCancelVestingTransfer(options: ManagerHookOptions): UseMutationResult<Hex, Error, UseCancelVestingTransferArgs>;

package/dist/fhe-vesting/react/useClaim.d.ts

@@ -0,0 +1,19 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import type { ClaimArgs } from "../manager.js";
+import { type ManagerHookOptions } from "./_shared.js";
+/**
+ * Claim the currently-claimable amount on a vesting schedule.
+ *
+ * **For `FeeType.Gas` managers**, pass `args.value = fee` — use
+ * {@link useManagerFeeInfo} to read it. For `FeeType.DistributionToken`,
+ * omit `value`.
+ *
+ * After success, invalidate `useGetClaimableAmount` (the encrypted view) and
+ * any UI counts you computed off it.
+ *
+ * @example
+ * const claim = useClaim({ address: managerAddress });
+ * claim.mutate({ vestingId, value: gasFee });
+ */
+export declare function useClaim(options: ManagerHookOptions): UseMutationResult<Hex, Error, ClaimArgs>;

package/dist/fhe-vesting/react/useConfidentialVestingFactoryImplementation.d.ts

@@ -0,0 +1,11 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type BaseHookOptions } from "./_shared.js";
+/**
+ * Read the FHE-vesting factory's current `implementation()` address — the
+ * LibClone target every new manager clone delegates to.
+ *
+ * @example
+ * const { data: implementation } = useConfidentialVestingFactoryImplementation();
+ */
+export declare function useConfidentialVestingFactoryImplementation(options?: BaseHookOptions): UseQueryResult<Address, Error>;

package/dist/fhe-vesting/react/useCreateManager.d.ts

@@ -0,0 +1,32 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { CreateManagerArgs, CreateManagerResult } from "../factory.js";
+import { type BaseHookOptions } from "./_shared.js";
+/**
+ * Deploy a new `ConfidentialVestingManager` clone via the factory.
+ *
+ * **Returns only a tx hash** — not the manager address. The factory packs the
+ * deployment block number into the clone's immutable args, so the address is
+ * only knowable after the tx mines.
+ *
+ * **For the common "deploy a clone and use its address" flow, prefer
+ * {@link useCreateManagerAndGetAddress}** — same submission, but it parses the
+ * `ManagerCreated` event from the receipt and returns the address in one call.
+ *
+ * After a successful create, you should invalidate any factory-level queries
+ * that depend on per-creator state (e.g. `useFactoryCustomFee({ creator })`):
+ *
+ * ```ts
+ * const queryClient = useQueryClient();
+ * const create = useCreateManager();
+ * create.mutate(args, {
+ *   onSuccess: () => {
+ *     queryClient.invalidateQueries({ queryKey: ["tokenops-sdk", "fhe-vesting"] });
+ *   },
+ * });
+ * ```
+ *
+ * @example
+ * const create = useCreateManager();
+ * create.mutate({ token, userSalt });
+ */
+export declare function useCreateManager(options?: BaseHookOptions): UseMutationResult<CreateManagerResult, Error, CreateManagerArgs>;

package/dist/fhe-vesting/react/useCreateManagerAndGetAddress.d.ts

@@ -0,0 +1,31 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { CreateManagerResult, CreateManagerArgs } from "../factory.js";
+import { type BaseHookOptions } from "./_shared.js";
+/**
+ * **Recommended factory entry point.** Deploy a new
+ * `ConfidentialVestingManager` clone and resolve its address from the
+ * `ManagerCreated` event in the tx receipt — in one call.
+ *
+ * Internally: `createManager` → `waitForTransactionReceipt` →
+ * `parseEventLogs({ eventName: "ManagerCreated" })`.
+ *
+ * After a successful create, invalidate factory queries that depend on
+ * per-creator state:
+ *
+ * ```ts
+ * const queryClient = useQueryClient();
+ * const create = useCreateManagerAndGetAddress();
+ * create.mutate(args, {
+ *   onSuccess: ({ manager }) => {
+ *     queryClient.invalidateQueries({ queryKey: ["tokenops-sdk", "fhe-vesting"] });
+ *     navigate(`/manager/${manager}`);
+ *   },
+ * });
+ * ```
+ *
+ * @example
+ * const create = useCreateManagerAndGetAddress();
+ * create.mutate({ token, userSalt });
+ * // create.data → { hash, manager }
+ */
+export declare function useCreateManagerAndGetAddress(options?: BaseHookOptions): UseMutationResult<CreateManagerResult, Error, CreateManagerArgs>;

package/dist/fhe-vesting/react/useCreateVesting.d.ts

@@ -0,0 +1,38 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Hex } from "viem";
+import type { CreateVestingArgs } from "../manager.js";
+import { type ManagerHookOptions } from "./_shared.js";
+/**
+ * Create a single confidential vesting schedule. The SDK encrypts the
+ * plaintext `amount` into an `externalEuint64` and submits it with an input
+ * proof — callers never handle ciphertext.
+ *
+ * **Encryptor resolution.** The hook-level `encryptor` (from
+ * `ManagerHookOptions`) is forwarded lazily to the SDK client. You can also
+ * pass `encryptor` per-mutation via `args.encryptor` to override it. If
+ * neither is present, the SDK throws `Missing encryptor — pass encryptor…`
+ * verbatim.
+ *
+ * After a successful create, invalidate read queries that depend on
+ * recipient/vesting state:
+ *
+ * ```ts
+ * const queryClient = useQueryClient();
+ * const create = useCreateVesting({ address: managerAddress });
+ * create.mutate(args, {
+ *   onSuccess: () => {
+ *     queryClient.invalidateQueries({ queryKey: ["tokenops-sdk", "fhe-vesting"] });
+ *   },
+ * });
+ * ```
+ *
+ * @example
+ * const create = useCreateVesting({ address: managerAddress, encryptor: () => useZamaSDK() });
+ * create.mutate({
+ *   params: { recipient, startTimestamp, endTimestamp, cliffSeconds: 0,
+ *             releaseIntervalSecs: 86400, timelockSeconds: 0,
+ *             initialUnlockBps: 0, cliffAmountBps: 0, isRevocable: false },
+ *   amount: 1_000_000n,
+ * });
+ */
+export declare function useCreateVesting(options: ManagerHookOptions): UseMutationResult<Hex, Error, CreateVestingArgs>;

package/dist/fhe-vesting/react/useDirectVestingTransfer.d.ts

@@ -0,0 +1,13 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type ManagerHookOptions } from "./_shared.js";
+export interface UseDirectVestingTransferArgs {
+    vestingId: Hex;
+    newOwner: Address;
+    account?: Account | Address;
+}
+/**
+ * Directly transfer a vesting to `newOwner` — one-step variant. The contract
+ * gates this on appropriate role membership.
+ */
+export declare function useDirectVestingTransfer(options: ManagerHookOptions): UseMutationResult<Hex, Error, UseDirectVestingTransferArgs>;

package/dist/fhe-vesting/react/useDisableCustomFee.d.ts

@@ -0,0 +1,14 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type BaseHookOptions } from "./_shared.js";
+export interface UseDisableCustomFeeArgs {
+    creator: Address;
+    account?: Account | Address;
+}
+/**
+ * Admin: disable the per-creator fee override for `creator`. New managers from
+ * that creator will fall back to the factory defaults.
+ *
+ * After success, invalidate `useFactoryCustomFee({ creator })`.
+ */
+export declare function useDisableCustomFee(options?: BaseHookOptions): UseMutationResult<Hex, Error, UseDisableCustomFeeArgs>;

package/dist/fhe-vesting/react/useDiscloseHandleToParty.d.ts

@@ -0,0 +1,14 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import { type ManagerHookOptions } from "./_shared.js";
+export interface UseDiscloseHandleToPartyArgs {
+    handle: Hex;
+    party: Address;
+    account?: Account | Address;
+}
+/**
+ * Grant `party` decrypt access to an arbitrary already-allowed `handle` you
+ * own. Typical use: forward a handle returned by `useGetClaimableAmount` to
+ * an auditor without leaking plaintext.
+ */
+export declare function useDiscloseHandleToParty(options: ManagerHookOptions): UseMutationResult<Hex, Error, UseDiscloseHandleToPartyArgs>;

package/dist/fhe-vesting/react/useDiscloseToParty.d.ts

@@ -0,0 +1,14 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { DiscloseArgs, DiscloseToPartyResult } from "../manager.js";
+import { type ManagerHookOptions } from "./_shared.js";
+/**
+ * Recipient discloses a single encrypted field of their own vesting to a
+ * `party` — grants ACL persistently so the party can `userDecrypt` the handle.
+ *
+ * `disclosureType` selects which field (total / settled / vested / claimable).
+ *
+ * Returns `{ hash, handle }` — `handle` is the granted `euint128`, parsed from
+ * the receipt's `AmountDisclosed` event. Pass it to the Zama relayer's
+ * `userDecrypt` from the `party` side to obtain the plaintext.
+ */
+export declare function useDiscloseToParty(options: ManagerHookOptions): UseMutationResult<DiscloseToPartyResult, Error, DiscloseArgs>;

package/dist/fhe-vesting/react/useFactoryCustomFee.d.ts

@@ -0,0 +1,17 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type CustomFee } from "../types.js";
+import { type BaseHookOptions } from "./_shared.js";
+export interface UseFactoryCustomFeeArgs extends BaseHookOptions {
+    /** Address whose per-creator fee override to read. Hook is disabled until set. */
+    creator?: Address;
+}
+/**
+ * Read the per-creator fee override set on the factory for `creator`. Returns
+ * `{ enabled: false, ... }` when no override exists.
+ *
+ * @example
+ * const { data: customFee } = useFactoryCustomFee({ creator });
+ * if (customFee?.enabled) { ... use customFee.gasFee/tokenFee ... }
+ */
+export declare function useFactoryCustomFee(args?: UseFactoryCustomFeeArgs): UseQueryResult<CustomFee, Error>;

package/dist/fhe-vesting/react/useFactoryDefaultFeeType.d.ts

@@ -0,0 +1,11 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type FeeType } from "../types.js";
+import { type BaseHookOptions } from "./_shared.js";
+/**
+ * Read the factory-wide default fee model (`FeeType.Gas` or
+ * `FeeType.DistributionToken`) applied to newly-created manager clones.
+ *
+ * @example
+ * const { data: defaultFeeType } = useFactoryDefaultFeeType();
+ */
+export declare function useFactoryDefaultFeeType(options?: BaseHookOptions): UseQueryResult<FeeType, Error>;

package/dist/fhe-vesting/react/useFactoryDefaultGasFee.d.ts

@@ -0,0 +1,10 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type BaseHookOptions } from "./_shared.js";
+/**
+ * Read the factory-wide default gas fee (in wei) — applied to new
+ * `FeeType.Gas` manager clones at deployment.
+ *
+ * @example
+ * const { data: defaultGasFee } = useFactoryDefaultGasFee();
+ */
+export declare function useFactoryDefaultGasFee(options?: BaseHookOptions): UseQueryResult<bigint, Error>;

package/dist/fhe-vesting/react/useFactoryDefaultTokenFee.d.ts

@@ -0,0 +1,10 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type BaseHookOptions } from "./_shared.js";
+/**
+ * Read the factory-wide default token fee in basis points — applied to new
+ * `FeeType.DistributionToken` manager clones at deployment.
+ *
+ * @example
+ * const { data: defaultTokenFee } = useFactoryDefaultTokenFee();
+ */
+export declare function useFactoryDefaultTokenFee(options?: BaseHookOptions): UseQueryResult<bigint, Error>;

package/dist/fhe-vesting/react/useFactoryFeeCollector.d.ts

@@ -0,0 +1,10 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import { type BaseHookOptions } from "./_shared.js";
+/**
+ * Read the factory's current fee collector address.
+ *
+ * @example
+ * const { data: feeCollector } = useFactoryFeeCollector();
+ */
+export declare function useFactoryFeeCollector(options?: BaseHookOptions): UseQueryResult<Address, Error>;

package/dist/fhe-vesting/react/useFactoryInitCodeHash.d.ts

@@ -0,0 +1,18 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address, Hex } from "viem";
+import { type BaseHookOptions } from "./_shared.js";
+export interface UseFactoryInitCodeHashArgs extends BaseHookOptions {
+    token?: Address;
+    deployer?: Address;
+    splitEnabled?: boolean;
+    pausableEnabled?: boolean;
+}
+/**
+ * Read the init-code hash the factory would use to CREATE2 a manager clone
+ * with the given `token` + `deployer` (+ optional immutable flags). Mirrors
+ * Solidity's `getInitCodeHash` / `getInitCodeHashWithOptions` selector.
+ *
+ * @example
+ * const { data: initCodeHash } = useFactoryInitCodeHash({ token, deployer });
+ */
+export declare function useFactoryInitCodeHash(args?: UseFactoryInitCodeHashArgs): UseQueryResult<Hex, Error>;

package/dist/fhe-vesting/react/useGetClaimableAmount.d.ts

@@ -0,0 +1,13 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import type { Account, Address, Hex } from "viem";
+import type { EncryptedViewResult } from "../manager.js";
+import { type ManagerHookOptions } from "./_shared.js";
+export interface UseGetClaimableAmountArgs {
+    vestingId: Hex;
+    account?: Account | Address;
+}
+/**
+ * **Submits a transaction** to read the currently-claimable amount as an
+ * `euint128` handle. Pass `data.handle` to the Zama relayer's `userDecrypt`.
+ */
+export declare function useGetClaimableAmount(options: ManagerHookOptions): UseMutationResult<EncryptedViewResult, Error, UseGetClaimableAmountArgs>;