@waterx/sdk 3.0.1 → 3.0.3

package/dist/cjs/src/generated/waterx_account/account.d.ts

@@ -0,0 +1,1906 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * Generalized multi-account framework for the WaterX ecosystem.
+ *
+ * Pure custody layer. Accounts hold per-T `Balance<T>` as dynamic fields keyed by
+ * `BalanceKey<T>()`, with a `VecMap<TypeName, u64>` mirror on each `Account` for
+ * fast enumeration. External flow in/out is mediated by hot-potato
+ * `DepositRequest<T>` / `WithdrawRequest<T>` that the framework issues; a
+ * registered policy module destroys the potato with its own witness and decides
+ * what final asset to put back into the account (e.g. a PSM policy turns
+ * `Coin<USDC>` into `Balance<USD>` and credits the account via `put<USD, P>`).
+ *
+ * Internal protocol ↔ account flow stays witness-gated via `take<T, P>` /
+ * `put<T, P>` with no policy registration involved — the protocol module's witness
+ * is the only authority needed, since only that module can construct a value of
+ * its witness type.
+ *
+ * Types of T:
+ *
+ * - Has registered deposit policy → `request_deposit<T>` works.
+ * - Has registered withdraw policy → `request_withdraw<T>` works.
+ * - Neither → "Parkable". Coins can sit on the account address via
+ *   `transfer_coin<T>` or external `transfer::public_transfer`, but nothing the
+ *   framework does will fold them into the account until a policy is registered
+ *   (or owner drains via `receive_coin`).
+ */
+import { MoveStruct, MoveTuple, type RawTransactionArgument } from '../utils/index.ts';
+import { type BcsType } from '@mysten/sui/bcs';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
+export declare const ACCOUNT: MoveStruct<{
+    dummy_field: BcsType<boolean, boolean, "bool">;
+}, "@waterx/account::account::ACCOUNT">;
+export declare const AdminCap: MoveStruct<{
+    id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "@waterx/account::account::AdminCap">;
+export declare const WaterXAccount: MoveStruct<{
+    dummy_field: BcsType<boolean, boolean, "bool">;
+}, "@waterx/account::account::WaterXAccount">;
+export declare const AccountRegistry: MoveStruct<{
+    id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /**
+     * `ObjectTable` (not plain `Table`) so each `Account` retains a distinct on-chain
+     * address that off-chain callers can query directly via `getObject(account_id)`
+     * instead of walking dynamic-field handles on the registry UID.
+     */
+    accounts: MoveStruct<{
+        id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        size: BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::object_table::ObjectTable<phantom K, phantom V>">;
+    owner_index: MoveStruct<{
+        id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        size: BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::table::Table<phantom K, phantom V>">;
+    /**
+     * Admin-managed whitelist of protocol witness types allowed to move funds
+     * (`take<T, P>` / `put<T, P>`) and mutate per-account protocol data
+     * (`new_data<P, D>` / `borrow_data_mut<P, D>` / `remove_data<P, D>`). For each
+     * whitelisted `P`, the value is the set of asset types `T` that protocol is
+     * allowed to draw via `take<T, P>` — admin opts each pair in via two phases:
+     * `whitelist_protocol<P>(registry, &AdminCap)` registers `P` with an empty asset
+     * set, then `allow_protocol_asset<P, T>(registry,  &AdminCap)` adds each T.
+     *
+     * Gates:
+     *
+     * - `take<T, P>` requires both `P` whitelisted AND `T` in `protocol_whitelist[P]`
+     *   (plus per-account auth on the caller).
+     * - `put<T, P>` requires only `P` whitelisted. The T-gate stays open even after
+     *   `disallow_protocol_asset<P, T>`, so existing positions can always close.
+     * - `new_data<P, _>` / `borrow_data_mut<P, _>` / `remove_data<P, _>` require only
+     *   `P` whitelisted.
+     */
+    protocol_whitelist: MoveStruct<{
+        contents: BcsType<{
+            key: {
+                name: string;
+            };
+            value: {
+                [x: string]: unknown;
+            };
+        }[], Iterable<{
+            key: {
+                name: string;
+            };
+            value: {
+                [x: string]: unknown;
+            };
+        }> & {
+            length: number;
+        }, string>;
+    }, `0x2::vec_map::VecMap<std::type_name::TypeName, ${any}>`>;
+    /**
+     * `T → registered DepositPolicy witness TypeName`. Presence means
+     * `request_deposit<T>` / `request_deposit_from_receivings<T>` are permitted; only
+     * the module that defines the registered witness type can call
+     * `consume_deposit<T, P>` to unwrap the resulting `DepositRequest<T>`. Deposit
+     * policy registration is independent of `protocol_whitelist` — a policy can be the
+     * _consumer_ of a request without being allowed to `take`/`put`.
+     * `T → set of DepositPolicy witness TypeNames`. Multiple policies can be
+     * registered per T to support extension (a new policy added alongside the old) and
+     * migration (both coexist while consumers switch). `request_deposit<T>` requires
+     * the set to be non-empty; `consume_deposit<T, P>` requires P to be in the set.
+     */
+    deposit_policies: MoveStruct<{
+        contents: BcsType<{
+            key: {
+                name: string;
+            };
+            value: {
+                [x: string]: unknown;
+            };
+        }[], Iterable<{
+            key: {
+                name: string;
+            };
+            value: {
+                [x: string]: unknown;
+            };
+        }> & {
+            length: number;
+        }, string>;
+    }, `0x2::vec_map::VecMap<std::type_name::TypeName, ${any}>`>;
+    /**
+     * `T → set of WithdrawPolicy witness TypeNames`. Symmetric to `deposit_policies`
+     * for `request_withdraw<T>` / `consume_withdraw`.
+     */
+    withdraw_policies: MoveStruct<{
+        contents: BcsType<{
+            key: {
+                name: string;
+            };
+            value: {
+                [x: string]: unknown;
+            };
+        }[], Iterable<{
+            key: {
+                name: string;
+            };
+            value: {
+                [x: string]: unknown;
+            };
+        }> & {
+            length: number;
+        }, string>;
+    }, `0x2::vec_map::VecMap<std::type_name::TypeName, ${any}>`>;
+    /**
+     * Per-T aggregate of `Balance<T>` currently held inside accounts. Incremented in
+     * `put<T, P>`, decremented in `take<T, P>` and `request_withdraw<T>`. Does _not_
+     * include balance held by protocols (after `take`) or sitting in flight inside a
+     * `DepositRequest` / `WithdrawRequest` hot potato.
+     */
+    balances: MoveStruct<{
+        contents: BcsType<{
+            key: {
+                name: string;
+            };
+            value: string;
+        }[], Iterable<{
+            key: {
+                name: string;
+            };
+            value: string | number | bigint;
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<std::type_name::TypeName, u64>">;
+    allowed_versions: MoveStruct<any, any>;
+    managers: MoveStruct<any, any>;
+    paused: BcsType<boolean, boolean, "bool">;
+}, "@waterx/account::account::AccountRegistry">;
+export declare const VaultKey: MoveTuple<readonly [BcsType<boolean, boolean, "bool">], "@waterx/account::account::VaultKey<phantom T>">;
+export declare const Vault: MoveStruct<{
+    balance: MoveStruct<{
+        value: BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::balance::Balance<phantom T>">;
+    sheet: MoveStruct<{
+        credits: MoveStruct<{
+            contents: BcsType<{
+                key: [{
+                    name: string;
+                }];
+                value: {
+                    value: string;
+                };
+            }[], Iterable<{
+                key: readonly [{
+                    name: string;
+                }];
+                value: {
+                    value: string | number | bigint;
+                };
+            }> & {
+                length: number;
+            }, string>;
+        }, "0x2::vec_map::VecMap<bucket_v2_framework::sheet::Entity, bucket_v2_framework::liability::Credit<phantom T>>">;
+        debts: MoveStruct<{
+            contents: BcsType<{
+                key: [{
+                    name: string;
+                }];
+                value: {
+                    value: string;
+                };
+            }[], Iterable<{
+                key: readonly [{
+                    name: string;
+                }];
+                value: {
+                    value: string | number | bigint;
+                };
+            }> & {
+                length: number;
+            }, string>;
+        }, "0x2::vec_map::VecMap<bucket_v2_framework::sheet::Entity, bucket_v2_framework::liability::Debt<phantom T>>">;
+        blacklist: MoveStruct<any, any>;
+    }, "bucket_v2_framework::sheet::Sheet<phantom CoinType, phantom SelfEntity>">;
+}, "@waterx/account::account::Vault<phantom T>">;
+export declare const ProtocolDataKey: MoveTuple<readonly [BcsType<boolean, boolean, "bool">], "@waterx/account::account::ProtocolDataKey<phantom PROTOCOL>">;
+export declare const Delegate: MoveStruct<{
+    delegate_address: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    alias: BcsType<string, string, "string">;
+    /**
+     * Framework-level action bitmap (`PERM_WITHDRAW`, `PERM_RECEIVE`,
+     * `PERM_MANAGE_DELEGATES`). **Vestigial — retained for ABI/bitmap stability but no
+     * longer the live authority for any path.** All three bits now gate nothing: the
+     * funds-out paths (`request_withdraw` / `withdraw_from_funds` / `receive`) and
+     * delegate-perm management (`set/unset_delegate_protocol_permission`) are
+     * owner-only. Delegate authority lives entirely in `protocol_permissions` below
+     * plus the per-account `take`/`put` gate. `effective_permissions` /
+     * `has_permission` remain as public views but no internal path consults them.
+     */
+    permissions: BcsType<number, number, "u32">;
+    /**
+     * Per-protocol bitmap. Missing key → delegate cannot drive that protocol. Each
+     * protocol's module interprets its own bits. Owner always has `PERM_ALL` per
+     * protocol regardless of this field.
+     */
+    protocol_permissions: MoveStruct<{
+        contents: BcsType<{
+            key: {
+                name: string;
+            };
+            value: number;
+        }[], Iterable<{
+            key: {
+                name: string;
+            };
+            value: number;
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<std::type_name::TypeName, u32>">;
+    expires_at_ms: BcsType<string | null, string | number | bigint | null | undefined, "Option<u64>">;
+}, "@waterx/account::account::Delegate">;
+export declare const Account: MoveStruct<{
+    id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    owner_address: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    alias: BcsType<string, string, "string">;
+    delegates: BcsType<{
+        delegate_address: string;
+        alias: string;
+        permissions: number;
+        protocol_permissions: {
+            contents: {
+                key: {
+                    name: string;
+                };
+                value: number;
+            }[];
+        };
+        expires_at_ms: string | null;
+    }[], Iterable<{
+        delegate_address: string | Uint8Array<ArrayBufferLike>;
+        alias: string;
+        permissions: number;
+        protocol_permissions: {
+            contents: Iterable<{
+                key: {
+                    name: string;
+                };
+                value: number;
+            }> & {
+                length: number;
+            };
+        };
+        expires_at_ms: string | number | bigint | null | undefined;
+    }> & {
+        length: number;
+    }, string>;
+    /**
+     * Mirror of the per-T `Balance<T>` values stored as dynamic fields under
+     * `BalanceKey<T>()` on this UID. Always equals the matching stored balance's
+     * `value()`.
+     */
+    balances: MoveStruct<{
+        contents: BcsType<{
+            key: {
+                name: string;
+            };
+            value: string;
+        }[], Iterable<{
+            key: {
+                name: string;
+            };
+            value: string | number | bigint;
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<std::type_name::TypeName, u64>">;
+}, "@waterx/account::account::Account">;
+export declare const DepositRequest: MoveStruct<{
+    account_id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    balance: MoveStruct<{
+        value: BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::balance::Balance<phantom T>">;
+    extra_data: BcsType<number[], Iterable<number> & {
+        length: number;
+    }, string>;
+}, "@waterx/account::account::DepositRequest<phantom T>">;
+export declare const WithdrawRequest: MoveStruct<{
+    account_id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    balance: MoveStruct<{
+        value: BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::balance::Balance<phantom T>">;
+    recipient: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    extra_data: BcsType<number[], Iterable<number> & {
+        length: number;
+    }, string>;
+}, "@waterx/account::account::WithdrawRequest<phantom T>">;
+export declare const PausedProtocolsKey: MoveTuple<readonly [BcsType<boolean, boolean, "bool">], "@waterx/account::account::PausedProtocolsKey">;
+export declare const AccountKey: MoveStruct<{
+    owner: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    index: BcsType<string, string | number | bigint, "u64">;
+}, "@waterx/account::account::AccountKey">;
+export interface PermNoneOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function permNone(options?: PermNoneOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PermWithdrawOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function permWithdraw(options?: PermWithdrawOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PermManageDelegatesOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function permManageDelegates(options?: PermManageDelegatesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PermReceiveOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function permReceive(options?: PermReceiveOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PermAllOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function permAll(options?: PermAllOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AliasMaxLengthOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function aliasMaxLength(options?: AliasMaxLengthOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MaxAccountsPerOwnerOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function maxAccountsPerOwner(options?: MaxAccountsPerOwnerOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MaxDelegatesPerAccountOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function maxDelegatesPerAccount(options?: MaxDelegatesPerAccountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MaxProtocolPermsPerDelegateOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function maxProtocolPermsPerDelegate(options?: MaxProtocolPermsPerDelegateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AssertVersionArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface AssertVersionOptions {
+    package?: string;
+    arguments: AssertVersionArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+}
+export declare function assertVersion(options: AssertVersionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsVersionAllowedArguments {
+    registry: RawTransactionArgument<string>;
+    v: RawTransactionArgument<number>;
+}
+export interface IsVersionAllowedOptions {
+    package?: string;
+    arguments: IsVersionAllowedArguments | [
+        registry: RawTransactionArgument<string>,
+        v: RawTransactionArgument<number>
+    ];
+}
+export declare function isVersionAllowed(options: IsVersionAllowedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AllowVersionArguments {
+    registry: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+    v: RawTransactionArgument<number>;
+}
+export interface AllowVersionOptions {
+    package?: string;
+    arguments: AllowVersionArguments | [
+        registry: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>,
+        v: RawTransactionArgument<number>
+    ];
+}
+export declare function allowVersion(options: AllowVersionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DisallowVersionArguments {
+    registry: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+    v: RawTransactionArgument<number>;
+}
+export interface DisallowVersionOptions {
+    package?: string;
+    arguments: DisallowVersionArguments | [
+        registry: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>,
+        v: RawTransactionArgument<number>
+    ];
+}
+export declare function disallowVersion(options: DisallowVersionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsPausedArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface IsPausedOptions {
+    package?: string;
+    arguments: IsPausedArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+}
+export declare function isPaused(options: IsPausedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AssertNotPausedArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface AssertNotPausedOptions {
+    package?: string;
+    arguments: AssertNotPausedArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+}
+export declare function assertNotPaused(options: AssertNotPausedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PauseArguments {
+    registry: RawTransactionArgument<string>;
+    managerRequest: TransactionArgument;
+}
+export interface PauseOptions {
+    package?: string;
+    arguments: PauseArguments | [
+        registry: RawTransactionArgument<string>,
+        managerRequest: TransactionArgument
+    ];
+}
+export declare function pause(options: PauseOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnpauseArguments {
+    registry: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+}
+export interface UnpauseOptions {
+    package?: string;
+    arguments: UnpauseArguments | [
+        registry: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>
+    ];
+}
+export declare function unpause(options: UnpauseOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsManagerArguments {
+    registry: RawTransactionArgument<string>;
+    addr: RawTransactionArgument<string>;
+}
+export interface IsManagerOptions {
+    package?: string;
+    arguments: IsManagerArguments | [
+        registry: RawTransactionArgument<string>,
+        addr: RawTransactionArgument<string>
+    ];
+}
+export declare function isManager(options: IsManagerOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ManagersArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface ManagersOptions {
+    package?: string;
+    arguments: ManagersArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+}
+export declare function managers(options: ManagersOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AddManagerArguments {
+    registry: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+    manager: RawTransactionArgument<string>;
+}
+export interface AddManagerOptions {
+    package?: string;
+    arguments: AddManagerArguments | [
+        registry: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>,
+        manager: RawTransactionArgument<string>
+    ];
+}
+export declare function addManager(options: AddManagerOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RemoveManagerArguments {
+    registry: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+    manager: RawTransactionArgument<string>;
+}
+export interface RemoveManagerOptions {
+    package?: string;
+    arguments: RemoveManagerArguments | [
+        registry: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>,
+        manager: RawTransactionArgument<string>
+    ];
+}
+export declare function removeManager(options: RemoveManagerOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsProtocolWhitelistedArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface IsProtocolWhitelistedOptions {
+    package?: string;
+    arguments: IsProtocolWhitelistedArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function isProtocolWhitelisted(options: IsProtocolWhitelistedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsProtocolAssetAllowedArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface IsProtocolAssetAllowedOptions {
+    package?: string;
+    arguments: IsProtocolAssetAllowedArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function isProtocolAssetAllowed(options: IsProtocolAssetAllowedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ProtocolWhitelistArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface ProtocolWhitelistOptions {
+    package?: string;
+    arguments: ProtocolWhitelistArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+}
+export declare function protocolWhitelist(options: ProtocolWhitelistOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WhitelistProtocolArguments {
+    registry: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+}
+export interface WhitelistProtocolOptions {
+    package?: string;
+    arguments: WhitelistProtocolArguments | [
+        registry: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin: register witness type `P` with an empty asset set. After this, admin must
+ * call `allow_protocol_asset<P, T>` for each T the protocol may draw. Strict —
+ * aborts if `P` is already listed.
+ */
+export declare function whitelistProtocol(options: WhitelistProtocolOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DelistProtocolArguments {
+    registry: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+}
+export interface DelistProtocolOptions {
+    package?: string;
+    arguments: DelistProtocolArguments | [
+        registry: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin: remove witness type `P` (and its entire asset set) from the protocol
+ * whitelist. After this, every `take<T, P>` / `put<T, P>` and witness-gated
+ * data-slot call aborts. Existing data slots and protocol-held balances are
+ * untouched — only future calls are blocked, so admin can pause a misbehaving
+ * protocol without stranding state on accounts.
+ */
+export declare function delistProtocol(options: DelistProtocolOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PauseProtocolArguments {
+    registry: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+}
+export interface PauseProtocolOptions {
+    package?: string;
+    arguments: PauseProtocolArguments | [
+        registry: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Admin: pause protocol `P` WITHOUT delisting it. A paused protocol cannot
+ * `take<_, P>` (new outbound debits) or `new_data<P, _>` (new account state), but
+ * `put<_, P>`, `borrow_data_mut<P, _>`, and `remove_data<P, _>` keep working — so
+ * in-flight refunds, claims, and close/cleanup can complete. Use this instead of
+ * `delist_protocol` for emergency stops; delisting blocks the exit paths too and
+ * strands active per-account state (see audit M09).
+ */
+export declare function pauseProtocol(options: PauseProtocolOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnpauseProtocolArguments {
+    registry: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+}
+export interface UnpauseProtocolOptions {
+    package?: string;
+    arguments: UnpauseProtocolArguments | [
+        registry: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Admin: lift a `pause_protocol<P>`. Idempotent on a non-paused protocol. */
+export declare function unpauseProtocol(options: UnpauseProtocolOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsProtocolPausedArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface IsProtocolPausedOptions {
+    package?: string;
+    arguments: IsProtocolPausedArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function isProtocolPaused(options: IsProtocolPausedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AllowProtocolAssetArguments {
+    registry: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+}
+export interface AllowProtocolAssetOptions {
+    package?: string;
+    arguments: AllowProtocolAssetArguments | [
+        registry: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Admin: add asset type `T` to protocol `P`'s allowed-asset set. After this,
+ * `take<T, P>` is permitted (subject to per-account auth). Aborts if `P` is not
+ * whitelisted or if `T` is already in the set.
+ */
+export declare function allowProtocolAsset(options: AllowProtocolAssetOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DisallowProtocolAssetArguments {
+    registry: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+}
+export interface DisallowProtocolAssetOptions {
+    package?: string;
+    arguments: DisallowProtocolAssetArguments | [
+        registry: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Admin: remove asset type `T` from protocol `P`'s allowed-asset set. Blocks
+ * future `take<T, P>` calls but `put<T, P>` on `T` stays open so existing
+ * positions can always close. Aborts if `P` is not whitelisted or if `T` is not in
+ * the set.
+ */
+export declare function disallowProtocolAsset(options: DisallowProtocolAssetOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsDepositPolicyRegisteredArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface IsDepositPolicyRegisteredOptions {
+    package?: string;
+    arguments: IsDepositPolicyRegisteredArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Returns true if `T` has at least one deposit policy registered. Used by
+ * `request_deposit<T>` to gate inflow and by `withdraw_from_funds<T>` to refuse
+ * policy-managed types.
+ */
+export declare function isDepositPolicyRegistered(options: IsDepositPolicyRegisteredOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsWithdrawPolicyRegisteredArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface IsWithdrawPolicyRegisteredOptions {
+    package?: string;
+    arguments: IsWithdrawPolicyRegisteredArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** Returns true if `T` has at least one withdraw policy registered. */
+export declare function isWithdrawPolicyRegistered(options: IsWithdrawPolicyRegisteredOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsDepositPolicyRegisteredForArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface IsDepositPolicyRegisteredForOptions {
+    package?: string;
+    arguments: IsDepositPolicyRegisteredForArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Returns true if the specific witness `P` is one of T's registered deposit
+ * policies. `consume_deposit<T, P>` aborts `EPolicyMismatch` when this would
+ * return false.
+ */
+export declare function isDepositPolicyRegisteredFor(options: IsDepositPolicyRegisteredForOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsWithdrawPolicyRegisteredForArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface IsWithdrawPolicyRegisteredForOptions {
+    package?: string;
+    arguments: IsWithdrawPolicyRegisteredForArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function isWithdrawPolicyRegisteredFor(options: IsWithdrawPolicyRegisteredForOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DepositPoliciesForArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface DepositPoliciesForOptions {
+    package?: string;
+    arguments: DepositPoliciesForArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Returns the full set of deposit-policy witness typenames registered for `T`, as
+ * a `vector<TypeName>` copy (TypeName is `copy + drop +  store`, so this is
+ * cheap). Aborts if T has no policies. Off-chain consumers wanting iteration
+ * without the copy should walk the full `deposit_policies()` map instead.
+ */
+export declare function depositPoliciesFor(options: DepositPoliciesForOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WithdrawPoliciesForArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface WithdrawPoliciesForOptions {
+    package?: string;
+    arguments: WithdrawPoliciesForArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function withdrawPoliciesFor(options: WithdrawPoliciesForOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DepositPoliciesArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface DepositPoliciesOptions {
+    package?: string;
+    arguments: DepositPoliciesArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+}
+export declare function depositPolicies(options: DepositPoliciesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WithdrawPoliciesArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface WithdrawPoliciesOptions {
+    package?: string;
+    arguments: WithdrawPoliciesArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+}
+export declare function withdrawPolicies(options: WithdrawPoliciesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RegisterDepositPolicyArguments {
+    registry: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+}
+export interface RegisterDepositPolicyOptions {
+    package?: string;
+    arguments: RegisterDepositPolicyArguments | [
+        registry: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Admin: register witness type `P` as a deposit policy for `T`. Multiple policies
+ * can coexist per T to support extension (a new module added alongside the old)
+ * and migration (consumers switch one at a time). Idempotent — adding an
+ * already-registered `(T, P)` pair is a silent no-op so admin can re-run deploy
+ * scripts safely.
+ */
+export declare function registerDepositPolicy(options: RegisterDepositPolicyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RegisterWithdrawPolicyArguments {
+    registry: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+}
+export interface RegisterWithdrawPolicyOptions {
+    package?: string;
+    arguments: RegisterWithdrawPolicyArguments | [
+        registry: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function registerWithdrawPolicy(options: RegisterWithdrawPolicyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnregisterDepositPolicyArguments {
+    registry: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+}
+export interface UnregisterDepositPolicyOptions {
+    package?: string;
+    arguments: UnregisterDepositPolicyArguments | [
+        registry: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Admin: remove `P` from T's deposit-policy set. Other registered policies for `T`
+ * keep working. If `P` is the last entry, the `T` key is cleaned up so
+ * `is_deposit_policy_registered<T>` returns false. Aborts if `(T, P)` isn't
+ * registered.
+ */
+export declare function unregisterDepositPolicy(options: UnregisterDepositPolicyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnregisterWithdrawPolicyArguments {
+    registry: RawTransactionArgument<string>;
+    _: RawTransactionArgument<string>;
+}
+export interface UnregisterWithdrawPolicyOptions {
+    package?: string;
+    arguments: UnregisterWithdrawPolicyArguments | [
+        registry: RawTransactionArgument<string>,
+        _: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function unregisterWithdrawPolicy(options: UnregisterWithdrawPolicyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CreateAccountArguments {
+    registry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    alias: RawTransactionArgument<string>;
+}
+export interface CreateAccountOptions {
+    package?: string;
+    arguments: CreateAccountArguments | [
+        registry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        alias: RawTransactionArgument<string>
+    ];
+}
+export declare function createAccount(options: CreateAccountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DeriveAccountAddressArguments {
+    registry: RawTransactionArgument<string>;
+    owner: RawTransactionArgument<string>;
+    index: RawTransactionArgument<number | bigint>;
+}
+export interface DeriveAccountAddressOptions {
+    package?: string;
+    arguments: DeriveAccountAddressArguments | [
+        registry: RawTransactionArgument<string>,
+        owner: RawTransactionArgument<string>,
+        index: RawTransactionArgument<number | bigint>
+    ];
+}
+/**
+ * Off-chain view: compute the address a future `create_account` call will produce
+ * for `(owner, index)`. Mirrors `derived_object::derive_address` keyed on
+ * `AccountKey`. Useful for SDKs that want to address an account before it exists,
+ * or to discover all of an owner's accounts by iterating index from 0 up to
+ * `MAX_ACCOUNTS_PER_OWNER` and checking `has_account` against each derived
+ * address.
+ */
+export declare function deriveAccountAddress(options: DeriveAccountAddressOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetAliasArguments {
+    registry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    alias: RawTransactionArgument<string>;
+}
+export interface SetAliasOptions {
+    package?: string;
+    arguments: SetAliasArguments | [
+        registry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        alias: RawTransactionArgument<string>
+    ];
+}
+export declare function setAlias(options: SetAliasOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AddDelegateArguments {
+    registry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    delegateAddress: RawTransactionArgument<string>;
+    alias: RawTransactionArgument<string>;
+    permissions: RawTransactionArgument<number>;
+    expiresAtMs: RawTransactionArgument<number | bigint | null>;
+}
+export interface AddDelegateOptions {
+    package?: string;
+    arguments: AddDelegateArguments | [
+        registry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        delegateAddress: RawTransactionArgument<string>,
+        alias: RawTransactionArgument<string>,
+        permissions: RawTransactionArgument<number>,
+        expiresAtMs: RawTransactionArgument<number | bigint | null>
+    ];
+}
+export declare function addDelegate(options: AddDelegateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RemoveDelegateArguments {
+    registry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    delegateAddress: RawTransactionArgument<string>;
+}
+export interface RemoveDelegateOptions {
+    package?: string;
+    arguments: RemoveDelegateArguments | [
+        registry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        delegateAddress: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Owner-only for live delegates; permissionless once the delegate has passed its
+ * `expires_at_ms`. Lets a keeper / bot prune dead entries without bothering the
+ * owner — an expired delegate carries no authority, so removing it is purely
+ * janitorial.
+ */
+export declare function removeDelegate(options: RemoveDelegateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdateDelegateArguments {
+    registry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    delegateAddress: RawTransactionArgument<string>;
+    alias: RawTransactionArgument<string>;
+    permissions: RawTransactionArgument<number>;
+    expiresAtMs: RawTransactionArgument<number | bigint | null>;
+}
+export interface UpdateDelegateOptions {
+    package?: string;
+    arguments: UpdateDelegateArguments | [
+        registry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        delegateAddress: RawTransactionArgument<string>,
+        alias: RawTransactionArgument<string>,
+        permissions: RawTransactionArgument<number>,
+        expiresAtMs: RawTransactionArgument<number | bigint | null>
+    ];
+}
+export declare function updateDelegate(options: UpdateDelegateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetDelegateProtocolPermissionArguments {
+    registry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    delegateAddress: RawTransactionArgument<string>;
+    permissions: RawTransactionArgument<number>;
+}
+export interface SetDelegateProtocolPermissionOptions {
+    package?: string;
+    arguments: SetDelegateProtocolPermissionArguments | [
+        registry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        delegateAddress: RawTransactionArgument<string>,
+        permissions: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function setDelegateProtocolPermission(options: SetDelegateProtocolPermissionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnsetDelegateProtocolPermissionArguments {
+    registry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    delegateAddress: RawTransactionArgument<string>;
+}
+export interface UnsetDelegateProtocolPermissionOptions {
+    package?: string;
+    arguments: UnsetDelegateProtocolPermissionArguments | [
+        registry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        delegateAddress: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function unsetDelegateProtocolPermission(options: UnsetDelegateProtocolPermissionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RequestDepositArguments {
+    registry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    coin: RawTransactionArgument<string>;
+    extraData: RawTransactionArgument<Array<number>>;
+}
+export interface RequestDepositOptions {
+    package?: string;
+    arguments: RequestDepositArguments | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        coin: RawTransactionArgument<string>,
+        extraData: RawTransactionArgument<Array<number>>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Wraps an in-PTB `Coin<T>` into a `DepositRequest<T>` for the account.
+ * Permissionless — anyone can pay into any account, since the policy (not the
+ * framework) decides what the eventual credited asset is. `T` must have a
+ * registered deposit policy; aborts otherwise.
+ */
+export declare function requestDeposit(options: RequestDepositOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RequestDepositFromReceivingsArguments {
+    registry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    receivings: TransactionArgument;
+    extraData: RawTransactionArgument<Array<number>>;
+}
+export interface RequestDepositFromReceivingsOptions {
+    package?: string;
+    arguments: RequestDepositFromReceivingsArguments | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        receivings: TransactionArgument,
+        extraData: RawTransactionArgument<Array<number>>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Drains `Receiving<Coin<T>>` entries addressed to the account's UID into a single
+ * merged `Coin<T>` and wraps it as a `DepositRequest<T>`. Used when a user (or
+ * anyone) previously `transfer_coin`-ed a `Coin<T>` onto the account address and
+ * now wants to fold it into custody. Permissionless for the same reason as
+ * `request_deposit<T>`.
+ */
+export declare function requestDepositFromReceivings(options: RequestDepositFromReceivingsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RequestDepositFromFundsArguments {
+    registry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    accumulatorRoot: RawTransactionArgument<string>;
+    extraData: RawTransactionArgument<Array<number>>;
+}
+export interface RequestDepositFromFundsOptions {
+    package?: string;
+    arguments: RequestDepositFromFundsArguments | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        accumulatorRoot: RawTransactionArgument<string>,
+        extraData: RawTransactionArgument<Array<number>>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Drains every `Balance<T>` sitting at the account's UID-derived address in Sui's
+ * native funds accumulator and wraps the total into a single `DepositRequest<T>`.
+ * Useful for accounts that receive `Coin<T>` via `0x2::balance::send_funds<T>` (or
+ * any path that lands T at `account_id.to_address()` directly) and want it folded
+ * into framework custody through the deposit-policy pipeline.
+ *
+ * The total drained equals `settled_funds_value<T>(root, addr)` as of the last
+ * consensus commit — within the writing PTB itself, that read returns the pre-tx
+ * value, so SDKs should treat this as a between-tx drain. Permissionless
+ * (crediting an account is always allowed), pause-free, requires `T` to have a
+ * registered deposit policy. Returns a deposit request even when the address holds
+ * zero T (the carried balance is `Balance::zero()` in that case) — callers can
+ * short-circuit off-chain by checking `settled_funds_value` first.
+ */
+export declare function requestDepositFromFunds(options: RequestDepositFromFundsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ConsumeDepositArguments<P extends BcsType<any>> {
+    registry: RawTransactionArgument<string>;
+    req: TransactionArgument;
+    Witness: RawTransactionArgument<P>;
+}
+export interface ConsumeDepositOptions<P extends BcsType<any>> {
+    package?: string;
+    arguments: ConsumeDepositArguments<P> | [
+        registry: RawTransactionArgument<string>,
+        req: TransactionArgument,
+        Witness: RawTransactionArgument<P>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Policy-side unwrap. Verifies that `P` is the registered deposit policy for `T`,
+ * then destructures the hot potato. The policy module is responsible for what
+ * happens next — typically swap / convert `Balance<T>` to some `Balance<T_OUT>`
+ * and call `put<T_OUT, P>` to credit the account.
+ */
+export declare function consumeDeposit<P extends BcsType<any>>(options: ConsumeDepositOptions<P>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RequestWithdrawArguments {
+    registry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    amount: RawTransactionArgument<number | bigint>;
+    recipient: RawTransactionArgument<string>;
+    extraData: RawTransactionArgument<Array<number>>;
+}
+export interface RequestWithdrawOptions {
+    package?: string;
+    arguments: RequestWithdrawArguments | [
+        registry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        amount: RawTransactionArgument<number | bigint>,
+        recipient: RawTransactionArgument<string>,
+        extraData: RawTransactionArgument<Array<number>>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Debits `amount` of the account's stored `Balance<T>` and packages it into a
+ * `WithdrawRequest<T>` for the registered withdraw policy. Auth (owner-only — see
+ * the gate below; `PERM_WITHDRAW` delegates are rejected) and pause are checked
+ * here, not in `consume_withdraw`.
+ */
+export declare function requestWithdraw(options: RequestWithdrawOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ConsumeWithdrawArguments<P extends BcsType<any>> {
+    registry: RawTransactionArgument<string>;
+    req: TransactionArgument;
+    Witness: RawTransactionArgument<P>;
+}
+export interface ConsumeWithdrawOptions<P extends BcsType<any>> {
+    package?: string;
+    arguments: ConsumeWithdrawArguments<P> | [
+        registry: RawTransactionArgument<string>,
+        req: TransactionArgument,
+        Witness: RawTransactionArgument<P>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Policy-side unwrap. Verifies that `P` is the registered withdraw policy for `T`,
+ * then destructures the hot potato. The policy module decides what to do with the
+ * `Balance<T>` (transfer to `recipient` as `Coin<T>`, swap to another asset and
+ * transfer, queue for later settlement, etc.).
+ */
+export declare function consumeWithdraw<P extends BcsType<any>>(options: ConsumeWithdrawOptions<P>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TransferCoinArguments {
+    registry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    coin: RawTransactionArgument<string>;
+}
+export interface TransferCoinOptions {
+    package?: string;
+    arguments: TransferCoinArguments | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        coin: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * TTOs a `Coin<T>` to the account's UID address. The coin sits there until someone
+ * calls `request_deposit_from_receivings<T>` (which requires a registered deposit
+ * policy that then folds the coin into the account's stored balance) or
+ * `receive<Coin<T>>` (owner-only, no policy needed). Useful for async / cross-PTB
+ * deposits and for routing protocol payouts (e.g. reward claims) into an account
+ * when `T` has no deposit policy.
+ */
+export declare function transferCoin(options: TransferCoinOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ReceiveArguments {
+    registry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    receiving: TransactionArgument;
+}
+export interface ReceiveOptions {
+    package?: string;
+    arguments: ReceiveArguments | [
+        registry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        receiving: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Account-owner drain of a TTO'd object on the account's UID. Generic over
+ * `T: key + store` — works for NFTs, reward objects, or `Coin<X>` where `X` has no
+ * registered deposit policy.
+ *
+ * **Policy-managed Coin<X> is rejected.** If `T == Coin<X>` and `X` has a deposit
+ * policy registered, this aborts `EUseRequestDepositInstead` to keep policy-routed
+ * inflow on the deposit-policy pipeline — bypassing via `receive` would skip the
+ * conversion / authorization the policy is supposed to enforce. Use
+ * `request_deposit_from_receivings<X>` or `request_deposit_from_funds<X>` for
+ * inflow when X has a deposit policy.
+ *
+ * Auth: account owner only. Receiving a TTO'd object hands it to the caller's PTB
+ * — an off-platform exfil path — so a delegate can never drive it, even one
+ * holding `PERM_RECEIVE`. The `PERM_RECEIVE` bit is retained for ABI stability but
+ * no longer gates any path. Returns the received object to the caller's PTB.
+ */
+export declare function receive(options: ReceiveOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WithdrawFromFundsArguments {
+    registry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    accumulatorRoot: RawTransactionArgument<string>;
+}
+export interface WithdrawFromFundsOptions {
+    package?: string;
+    arguments: WithdrawFromFundsArguments | [
+        registry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        accumulatorRoot: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Drains every `Balance<T>` sitting at the account's UID-derived address in Sui's
+ * native funds accumulator and returns it directly as a `Balance<T>`. Symmetric to
+ * `request_deposit_from_funds<T>`, but explicitly for `T` that has **no**
+ * registered deposit policy — policy-managed inflow must route through the
+ * deposit-policy pipeline instead. The intent is to let the account owner pull
+ * policy-less inflow (reward tokens TTO'd via `send_funds`, miscellaneous
+ * `Balance<T>` the SDK parked at the address) straight out.
+ *
+ * Auth: same as `request_withdraw<T>` — owner-only. A delegate is rejected even
+ * one holding `PERM_WITHDRAW` (the bit no longer gates this path; retained for ABI
+ * stability only). Aborts `EUseRequestDepositInstead` if `T` has a deposit policy
+ * registered. Pause-gated. Returns `Balance::zero<T>()` when the address holds no
+ * T.
+ */
+export declare function withdrawFromFunds(options: WithdrawFromFundsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TakeArguments<P extends BcsType<any>> {
+    registry: RawTransactionArgument<string>;
+    senderRequest: TransactionArgument;
+    accountId: RawTransactionArgument<string>;
+    amount: RawTransactionArgument<number | bigint>;
+    Witness: RawTransactionArgument<P>;
+}
+export interface TakeOptions<P extends BcsType<any>> {
+    package?: string;
+    arguments: TakeArguments<P> | [
+        registry: RawTransactionArgument<string>,
+        senderRequest: TransactionArgument,
+        accountId: RawTransactionArgument<string>,
+        amount: RawTransactionArgument<number | bigint>,
+        Witness: RawTransactionArgument<P>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Splits `amount` of `Balance<T>` off `account_id` for protocol `P` to use. Three
+ * gates compose:
+ *
+ * 1.  **Witness privacy.** Only the module that defines `P` can produce a value of
+ *     `P`, so only that module can call `take<T, P>`.
+ * 2.  **Protocol whitelist.** `P` must be in `protocol_whitelist` (admin-managed).
+ *     Stops any deployed module that happens to own a `drop` witness from draining
+ *     accounts.
+ * 3.  **Per-account auth.** `sender_request.address()` must be the account's owner
+ *     OR a non-expired delegate — even a legitimate whitelisted protocol cannot
+ *     move funds out of an account that doesn't know the caller. This mirrors EOA
+ *     semantics: the account never pays out without the owner (or a delegated key)
+ *     signing. Per-action bit semantics on `protocol_permissions[P]` remain the
+ *     protocol's responsibility on top of this.
+ *
+ * No deposit/withdraw policy is consulted — `take` / `put` are the
+ * protocol↔account flow and orthogonal to the external deposit/withdraw path that
+ * policies own.
+ */
+export declare function take<P extends BcsType<any>>(options: TakeOptions<P>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PutArguments<P extends BcsType<any>> {
+    registry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    bal: TransactionArgument;
+    Witness: RawTransactionArgument<P>;
+}
+export interface PutOptions<P extends BcsType<any>> {
+    package?: string;
+    arguments: PutArguments<P> | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        bal: TransactionArgument,
+        Witness: RawTransactionArgument<P>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+/**
+ * Joins `bal` into `account_id`'s stored `Balance<T>`. Symmetric to `take<T, P>`.
+ * Zero-value balances are silently destroyed.
+ */
+export declare function put<P extends BcsType<any>>(options: PutOptions<P>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface HasAccountArguments {
+    registry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+}
+export interface HasAccountOptions {
+    package?: string;
+    arguments: HasAccountArguments | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>
+    ];
+}
+export declare function hasAccount(options: HasAccountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsAccountAuthorizedArguments {
+    registry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    addr: RawTransactionArgument<string>;
+    nowMs: RawTransactionArgument<number | bigint>;
+}
+export interface IsAccountAuthorizedOptions {
+    package?: string;
+    arguments: IsAccountAuthorizedArguments | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        addr: RawTransactionArgument<string>,
+        nowMs: RawTransactionArgument<number | bigint>
+    ];
+}
+/**
+ * Returns `true` when `addr` is the account's owner or a non-expired delegate,
+ * regardless of permission bits. The framework's "is this address known to the
+ * account?" gate — per-action bit semantics are the protocol's responsibility on
+ * top of this.
+ */
+export declare function isAccountAuthorized(options: IsAccountAuthorizedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsAccountOwnerArguments {
+    registry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    addr: RawTransactionArgument<string>;
+}
+export interface IsAccountOwnerOptions {
+    package?: string;
+    arguments: IsAccountOwnerArguments | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        addr: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Returns `true` only when `addr` is the account's **owner** — delegates are
+ * excluded regardless of their permission bits or expiry. Protocols use this for
+ * owner-only actions that must never be delegate-driven (e.g. collateral
+ * withdrawal): defense-in-depth so a phished or compromised delegate key can never
+ * move funds, only the owner's own signature can. Contrast `is_account_authorized`
+ * (owner OR live delegate).
+ */
+export declare function isAccountOwner(options: IsAccountOwnerOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AccountCountArguments {
+    registry: RawTransactionArgument<string>;
+    owner: RawTransactionArgument<string>;
+}
+export interface AccountCountOptions {
+    package?: string;
+    arguments: AccountCountArguments | [
+        registry: RawTransactionArgument<string>,
+        owner: RawTransactionArgument<string>
+    ];
+}
+export declare function accountCount(options: AccountCountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AccountIdsArguments {
+    registry: RawTransactionArgument<string>;
+    owner: RawTransactionArgument<string>;
+}
+export interface AccountIdsOptions {
+    package?: string;
+    arguments: AccountIdsArguments | [
+        registry: RawTransactionArgument<string>,
+        owner: RawTransactionArgument<string>
+    ];
+}
+export declare function accountIds(options: AccountIdsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface EffectivePermissionsArguments {
+    registry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    addr: RawTransactionArgument<string>;
+    nowMs: RawTransactionArgument<number | bigint>;
+}
+export interface EffectivePermissionsOptions {
+    package?: string;
+    arguments: EffectivePermissionsArguments | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        addr: RawTransactionArgument<string>,
+        nowMs: RawTransactionArgument<number | bigint>
+    ];
+}
+/**
+ * Framework-level effective permissions (used by `request_withdraw`). Owner →
+ * `PERM_ALL`. Delegate → its `permissions` bitmap unless expired. Stranger →
+ * `PERM_NONE`.
+ */
+export declare function effectivePermissions(options: EffectivePermissionsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface HasPermissionArguments {
+    registry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    addr: RawTransactionArgument<string>;
+    permission: RawTransactionArgument<number>;
+    nowMs: RawTransactionArgument<number | bigint>;
+}
+export interface HasPermissionOptions {
+    package?: string;
+    arguments: HasPermissionArguments | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        addr: RawTransactionArgument<string>,
+        permission: RawTransactionArgument<number>,
+        nowMs: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function hasPermission(options: HasPermissionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface EffectiveProtocolPermissionsArguments {
+    registry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    addr: RawTransactionArgument<string>;
+    nowMs: RawTransactionArgument<number | bigint>;
+}
+export interface EffectiveProtocolPermissionsOptions {
+    package?: string;
+    arguments: EffectiveProtocolPermissionsArguments | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        addr: RawTransactionArgument<string>,
+        nowMs: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Per-protocol effective permissions (used by protocol modules). Owner →
+ * `PERM_ALL` for any protocol. Delegate → the bitmap stored at
+ * `protocol_permissions[TypeName(PROTOCOL)]`, or `PERM_NONE` if absent or expired.
+ * Stranger → `PERM_NONE`.
+ */
+export declare function effectiveProtocolPermissions(options: EffectiveProtocolPermissionsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface HasProtocolPermissionArguments {
+    registry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    addr: RawTransactionArgument<string>;
+    permission: RawTransactionArgument<number>;
+    nowMs: RawTransactionArgument<number | bigint>;
+}
+export interface HasProtocolPermissionOptions {
+    package?: string;
+    arguments: HasProtocolPermissionArguments | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        addr: RawTransactionArgument<string>,
+        permission: RawTransactionArgument<number>,
+        nowMs: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function hasProtocolPermission(options: HasProtocolPermissionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AccountBalanceArguments {
+    registry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+}
+export interface AccountBalanceOptions {
+    package?: string;
+    arguments: AccountBalanceArguments | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function accountBalance(options: AccountBalanceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AccountBalancesArguments {
+    registry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+}
+export interface AccountBalancesOptions {
+    package?: string;
+    arguments: AccountBalancesArguments | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>
+    ];
+}
+export declare function accountBalances(options: AccountBalancesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BalanceArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface BalanceOptions {
+    package?: string;
+    arguments: BalanceArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Total `Balance<T>` currently held across all accounts. Counter; not derived from
+ * iterating accounts. Excludes balance held by protocols (after `take`) and
+ * balance sitting in hot-potato requests in flight.
+ */
+export declare function balance(options: BalanceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AccountOwnerArguments {
+    account: RawTransactionArgument<string>;
+}
+export interface AccountOwnerOptions {
+    package?: string;
+    arguments: AccountOwnerArguments | [
+        account: RawTransactionArgument<string>
+    ];
+}
+export declare function accountOwner(options: AccountOwnerOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AccountAliasArguments {
+    account: RawTransactionArgument<string>;
+}
+export interface AccountAliasOptions {
+    package?: string;
+    arguments: AccountAliasArguments | [
+        account: RawTransactionArgument<string>
+    ];
+}
+export declare function accountAlias(options: AccountAliasOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AccountIdArguments {
+    account: RawTransactionArgument<string>;
+}
+export interface AccountIdOptions {
+    package?: string;
+    arguments: AccountIdArguments | [
+        account: RawTransactionArgument<string>
+    ];
+}
+export declare function accountId(options: AccountIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AccountAddressArguments {
+    account: RawTransactionArgument<string>;
+}
+export interface AccountAddressOptions {
+    package?: string;
+    arguments: AccountAddressArguments | [
+        account: RawTransactionArgument<string>
+    ];
+}
+export declare function accountAddress(options: AccountAddressOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AccountDelegatesArguments {
+    account: RawTransactionArgument<string>;
+}
+export interface AccountDelegatesOptions {
+    package?: string;
+    arguments: AccountDelegatesArguments | [
+        account: RawTransactionArgument<string>
+    ];
+}
+export declare function accountDelegates(options: AccountDelegatesOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AccountBalancesFieldArguments {
+    account: RawTransactionArgument<string>;
+}
+export interface AccountBalancesFieldOptions {
+    package?: string;
+    arguments: AccountBalancesFieldArguments | [
+        account: RawTransactionArgument<string>
+    ];
+}
+export declare function accountBalancesField(options: AccountBalancesFieldOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DelegateAddressArguments {
+    delegate: TransactionArgument;
+}
+export interface DelegateAddressOptions {
+    package?: string;
+    arguments: DelegateAddressArguments | [
+        delegate: TransactionArgument
+    ];
+}
+export declare function delegateAddress(options: DelegateAddressOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DelegateAliasArguments {
+    delegate: TransactionArgument;
+}
+export interface DelegateAliasOptions {
+    package?: string;
+    arguments: DelegateAliasArguments | [
+        delegate: TransactionArgument
+    ];
+}
+export declare function delegateAlias(options: DelegateAliasOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DelegatePermissionsArguments {
+    delegate: TransactionArgument;
+}
+export interface DelegatePermissionsOptions {
+    package?: string;
+    arguments: DelegatePermissionsArguments | [
+        delegate: TransactionArgument
+    ];
+}
+export declare function delegatePermissions(options: DelegatePermissionsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DelegateProtocolPermissionsArguments {
+    delegate: TransactionArgument;
+}
+export interface DelegateProtocolPermissionsOptions {
+    package?: string;
+    arguments: DelegateProtocolPermissionsArguments | [
+        delegate: TransactionArgument
+    ];
+}
+export declare function delegateProtocolPermissions(options: DelegateProtocolPermissionsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DelegateExpiresAtMsArguments {
+    delegate: TransactionArgument;
+}
+export interface DelegateExpiresAtMsOptions {
+    package?: string;
+    arguments: DelegateExpiresAtMsArguments | [
+        delegate: TransactionArgument
+    ];
+}
+export declare function delegateExpiresAtMs(options: DelegateExpiresAtMsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DepositRequestAccountIdArguments {
+    r: TransactionArgument;
+}
+export interface DepositRequestAccountIdOptions {
+    package?: string;
+    arguments: DepositRequestAccountIdArguments | [
+        r: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function depositRequestAccountId(options: DepositRequestAccountIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DepositRequestBalanceArguments {
+    r: TransactionArgument;
+}
+export interface DepositRequestBalanceOptions {
+    package?: string;
+    arguments: DepositRequestBalanceArguments | [
+        r: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function depositRequestBalance(options: DepositRequestBalanceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DepositRequestAmountArguments {
+    r: TransactionArgument;
+}
+export interface DepositRequestAmountOptions {
+    package?: string;
+    arguments: DepositRequestAmountArguments | [
+        r: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function depositRequestAmount(options: DepositRequestAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DepositRequestExtraDataArguments {
+    r: TransactionArgument;
+}
+export interface DepositRequestExtraDataOptions {
+    package?: string;
+    arguments: DepositRequestExtraDataArguments | [
+        r: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function depositRequestExtraData(options: DepositRequestExtraDataOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WithdrawRequestAccountIdArguments {
+    r: TransactionArgument;
+}
+export interface WithdrawRequestAccountIdOptions {
+    package?: string;
+    arguments: WithdrawRequestAccountIdArguments | [
+        r: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function withdrawRequestAccountId(options: WithdrawRequestAccountIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WithdrawRequestBalanceArguments {
+    r: TransactionArgument;
+}
+export interface WithdrawRequestBalanceOptions {
+    package?: string;
+    arguments: WithdrawRequestBalanceArguments | [
+        r: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function withdrawRequestBalance(options: WithdrawRequestBalanceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WithdrawRequestAmountArguments {
+    r: TransactionArgument;
+}
+export interface WithdrawRequestAmountOptions {
+    package?: string;
+    arguments: WithdrawRequestAmountArguments | [
+        r: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function withdrawRequestAmount(options: WithdrawRequestAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WithdrawRequestRecipientArguments {
+    r: TransactionArgument;
+}
+export interface WithdrawRequestRecipientOptions {
+    package?: string;
+    arguments: WithdrawRequestRecipientArguments | [
+        r: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function withdrawRequestRecipient(options: WithdrawRequestRecipientOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WithdrawRequestExtraDataArguments {
+    r: TransactionArgument;
+}
+export interface WithdrawRequestExtraDataOptions {
+    package?: string;
+    arguments: WithdrawRequestExtraDataArguments | [
+        r: TransactionArgument
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function withdrawRequestExtraData(options: WithdrawRequestExtraDataOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NewDataArguments<PROTOCOL extends BcsType<any>, ProtocolData extends BcsType<any>> {
+    registry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    Witness: RawTransactionArgument<PROTOCOL>;
+    data: RawTransactionArgument<ProtocolData>;
+}
+export interface NewDataOptions<PROTOCOL extends BcsType<any>, ProtocolData extends BcsType<any>> {
+    package?: string;
+    arguments: NewDataArguments<PROTOCOL, ProtocolData> | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        Witness: RawTransactionArgument<PROTOCOL>,
+        data: RawTransactionArgument<ProtocolData>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function newData<PROTOCOL extends BcsType<any>, ProtocolData extends BcsType<any>>(options: NewDataOptions<PROTOCOL, ProtocolData>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowDataArguments {
+    registry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+}
+export interface BorrowDataOptions {
+    package?: string;
+    arguments: BorrowDataArguments | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function borrowData(options: BorrowDataOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowDataMutArguments<PROTOCOL extends BcsType<any>> {
+    registry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    Witness: RawTransactionArgument<PROTOCOL>;
+}
+export interface BorrowDataMutOptions<PROTOCOL extends BcsType<any>> {
+    package?: string;
+    arguments: BorrowDataMutArguments<PROTOCOL> | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        Witness: RawTransactionArgument<PROTOCOL>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function borrowDataMut<PROTOCOL extends BcsType<any>>(options: BorrowDataMutOptions<PROTOCOL>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface HasDataArguments {
+    registry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+}
+export interface HasDataOptions {
+    package?: string;
+    arguments: HasDataArguments | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function hasData(options: HasDataOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RemoveDataArguments<PROTOCOL extends BcsType<any>> {
+    registry: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    Witness: RawTransactionArgument<PROTOCOL>;
+}
+export interface RemoveDataOptions<PROTOCOL extends BcsType<any>> {
+    package?: string;
+    arguments: RemoveDataArguments<PROTOCOL> | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        Witness: RawTransactionArgument<PROTOCOL>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function removeData<PROTOCOL extends BcsType<any>>(options: RemoveDataOptions<PROTOCOL>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;