@waterx/predict-sdk 0.1.0

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

@@ -0,0 +1,1326 @@
+/**************************************************************
+ * 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<USDX>` and credits the account via `put<USDX, 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 } from '@mysten/sui/transactions';
+export declare const ACCOUNT: MoveStruct<any, any>;
+export declare const AdminCap: MoveStruct<any, any>;
+export declare const AccountRegistry: MoveStruct<any, any>;
+export declare const BalanceKey: MoveTuple<readonly [BcsType<boolean, boolean, "bool">], "@waterx/account::account::BalanceKey<phantom T>">;
+export declare const ProtocolDataKey: MoveTuple<readonly [BcsType<boolean, boolean, "bool">], "@waterx/account::account::ProtocolDataKey<phantom PROTOCOL>">;
+export declare const Delegate: MoveStruct<any, any>;
+export declare const Account: MoveStruct<any, any>;
+export declare const DepositRequest: MoveStruct<any, any>;
+export declare const WithdrawRequest: MoveStruct<any, any>;
+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: RawTransactionArgument<string>;
+}
+export interface PauseOptions {
+    package?: string;
+    arguments: PauseArguments | [
+        registry: RawTransactionArgument<string>,
+        managerRequest: RawTransactionArgument<string>
+    ];
+}
+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 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: add witness type `P` to the protocol whitelist. Only modules whose
+ * witness type is whitelisted can call `take` / `put` and the witness-gated
+ * data-slot helpers. 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` 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 IsDepositPolicyRegisteredArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface IsDepositPolicyRegisteredOptions {
+    package?: string;
+    arguments: IsDepositPolicyRegisteredArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+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
+    ];
+}
+export declare function isWithdrawPolicyRegistered(options: IsWithdrawPolicyRegisteredOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DepositPolicyArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface DepositPolicyOptions {
+    package?: string;
+    arguments: DepositPolicyArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function depositPolicy(options: DepositPolicyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WithdrawPolicyArguments {
+    registry: RawTransactionArgument<string>;
+}
+export interface WithdrawPolicyOptions {
+    package?: string;
+    arguments: WithdrawPolicyArguments | [
+        registry: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function withdrawPolicy(options: WithdrawPolicyOptions): (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 the deposit policy for `T`. Only the module
+ * that defines `P` can construct one, so this binds `T`'s deposit flow exclusively
+ * to that module. Aborts if `T` is already registered — admin must
+ * `unregister_deposit_policy<T>` first to swap.
+ */
+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
+    ];
+}
+/**
+ * Admin: remove the deposit policy for `T`. Existing `Balance<T>` on accounts is
+ * unaffected; only new `request_deposit<T>` is blocked.
+ */
+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
+    ];
+}
+export declare function unregisterWithdrawPolicy(options: UnregisterWithdrawPolicyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CreateAccountArguments {
+    registry: RawTransactionArgument<string>;
+    senderRequest: RawTransactionArgument<string>;
+    alias: RawTransactionArgument<string>;
+}
+export interface CreateAccountOptions {
+    package?: string;
+    arguments: CreateAccountArguments | [
+        registry: RawTransactionArgument<string>,
+        senderRequest: RawTransactionArgument<string>,
+        alias: RawTransactionArgument<string>
+    ];
+}
+export declare function createAccount(options: CreateAccountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetAliasArguments {
+    registry: RawTransactionArgument<string>;
+    senderRequest: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    alias: RawTransactionArgument<string>;
+}
+export interface SetAliasOptions {
+    package?: string;
+    arguments: SetAliasArguments | [
+        registry: RawTransactionArgument<string>,
+        senderRequest: RawTransactionArgument<string>,
+        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: RawTransactionArgument<string>;
+    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: RawTransactionArgument<string>,
+        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: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    delegateAddress: RawTransactionArgument<string>;
+}
+export interface RemoveDelegateOptions {
+    package?: string;
+    arguments: RemoveDelegateArguments | [
+        registry: RawTransactionArgument<string>,
+        senderRequest: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        delegateAddress: RawTransactionArgument<string>
+    ];
+}
+export declare function removeDelegate(options: RemoveDelegateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdateDelegateArguments {
+    registry: RawTransactionArgument<string>;
+    senderRequest: RawTransactionArgument<string>;
+    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: RawTransactionArgument<string>,
+        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: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    delegateAddress: RawTransactionArgument<string>;
+    permissions: RawTransactionArgument<number>;
+}
+export interface SetDelegateProtocolPermissionOptions {
+    package?: string;
+    arguments: SetDelegateProtocolPermissionArguments | [
+        registry: RawTransactionArgument<string>,
+        senderRequest: RawTransactionArgument<string>,
+        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: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    delegateAddress: RawTransactionArgument<string>;
+}
+export interface UnsetDelegateProtocolPermissionOptions {
+    package?: string;
+    arguments: UnsetDelegateProtocolPermissionArguments | [
+        registry: RawTransactionArgument<string>,
+        senderRequest: RawTransactionArgument<string>,
+        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: RawTransactionArgument<Array<string>>;
+    extraData: RawTransactionArgument<Array<number>>;
+}
+export interface RequestDepositFromReceivingsOptions {
+    package?: string;
+    arguments: RequestDepositFromReceivingsArguments | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        receivings: RawTransactionArgument<Array<string>>,
+        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 ConsumeDepositArguments<P extends BcsType<any>> {
+    registry: RawTransactionArgument<string>;
+    req: RawTransactionArgument<string>;
+    Witness: RawTransactionArgument<P>;
+}
+export interface ConsumeDepositOptions<P extends BcsType<any>> {
+    package?: string;
+    arguments: ConsumeDepositArguments<P> | [
+        registry: RawTransactionArgument<string>,
+        req: RawTransactionArgument<string>,
+        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: RawTransactionArgument<string>;
+    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: RawTransactionArgument<string>,
+        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 (`PERM_WITHDRAW`
+ * on `T`'s account) 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: RawTransactionArgument<string>;
+    Witness: RawTransactionArgument<P>;
+}
+export interface ConsumeWithdrawOptions<P extends BcsType<any>> {
+    package?: string;
+    arguments: ConsumeWithdrawArguments<P> | [
+        registry: RawTransactionArgument<string>,
+        req: RawTransactionArgument<string>,
+        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 / `PERM_RECEIVE` delegate, 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: RawTransactionArgument<string>;
+    accountId: RawTransactionArgument<string>;
+    receiving: RawTransactionArgument<string>;
+}
+export interface ReceiveOptions {
+    package?: string;
+    arguments: ReceiveArguments | [
+        registry: RawTransactionArgument<string>,
+        senderRequest: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        receiving: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/**
+ * Account-owner drain of a TTO'd object on the account's UID. Generic over
+ * `T: key + store` — works for `Coin<X>`, NFTs, or any other transferable object
+ * externally transferred to the account address. Auth: account owner or a
+ * `PERM_RECEIVE` delegate (kept separate from `PERM_WITHDRAW` so reward-collection
+ * rights don't imply balance-drain rights). Returns the received object to the
+ * caller's PTB. Bypasses the deposit-policy flow — use this for tokens / objects
+ * that have no registered deposit policy (e.g. reward coins TTO'd via
+ * `transfer_coin` from a protocol's claim path).
+ */
+export declare function receive(options: ReceiveOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TakeArguments<P extends BcsType<any>> {
+    registry: RawTransactionArgument<string>;
+    senderRequest: RawTransactionArgument<string>;
+    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: RawTransactionArgument<string>,
+        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: RawTransactionArgument<string>;
+    Witness: RawTransactionArgument<P>;
+}
+export interface PutOptions<P extends BcsType<any>> {
+    package?: string;
+    arguments: PutArguments<P> | [
+        registry: RawTransactionArgument<string>,
+        accountId: RawTransactionArgument<string>,
+        bal: RawTransactionArgument<string>,
+        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 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: RawTransactionArgument<string>;
+}
+export interface DelegateAddressOptions {
+    package?: string;
+    arguments: DelegateAddressArguments | [
+        delegate: RawTransactionArgument<string>
+    ];
+}
+export declare function delegateAddress(options: DelegateAddressOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DelegateAliasArguments {
+    delegate: RawTransactionArgument<string>;
+}
+export interface DelegateAliasOptions {
+    package?: string;
+    arguments: DelegateAliasArguments | [
+        delegate: RawTransactionArgument<string>
+    ];
+}
+export declare function delegateAlias(options: DelegateAliasOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DelegatePermissionsArguments {
+    delegate: RawTransactionArgument<string>;
+}
+export interface DelegatePermissionsOptions {
+    package?: string;
+    arguments: DelegatePermissionsArguments | [
+        delegate: RawTransactionArgument<string>
+    ];
+}
+export declare function delegatePermissions(options: DelegatePermissionsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DelegateProtocolPermissionsArguments {
+    delegate: RawTransactionArgument<string>;
+}
+export interface DelegateProtocolPermissionsOptions {
+    package?: string;
+    arguments: DelegateProtocolPermissionsArguments | [
+        delegate: RawTransactionArgument<string>
+    ];
+}
+export declare function delegateProtocolPermissions(options: DelegateProtocolPermissionsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DelegateExpiresAtMsArguments {
+    delegate: RawTransactionArgument<string>;
+}
+export interface DelegateExpiresAtMsOptions {
+    package?: string;
+    arguments: DelegateExpiresAtMsArguments | [
+        delegate: RawTransactionArgument<string>
+    ];
+}
+export declare function delegateExpiresAtMs(options: DelegateExpiresAtMsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DepositRequestAccountIdArguments {
+    r: RawTransactionArgument<string>;
+}
+export interface DepositRequestAccountIdOptions {
+    package?: string;
+    arguments: DepositRequestAccountIdArguments | [
+        r: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function depositRequestAccountId(options: DepositRequestAccountIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DepositRequestBalanceArguments {
+    r: RawTransactionArgument<string>;
+}
+export interface DepositRequestBalanceOptions {
+    package?: string;
+    arguments: DepositRequestBalanceArguments | [
+        r: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function depositRequestBalance(options: DepositRequestBalanceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DepositRequestAmountArguments {
+    r: RawTransactionArgument<string>;
+}
+export interface DepositRequestAmountOptions {
+    package?: string;
+    arguments: DepositRequestAmountArguments | [
+        r: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function depositRequestAmount(options: DepositRequestAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DepositRequestExtraDataArguments {
+    r: RawTransactionArgument<string>;
+}
+export interface DepositRequestExtraDataOptions {
+    package?: string;
+    arguments: DepositRequestExtraDataArguments | [
+        r: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function depositRequestExtraData(options: DepositRequestExtraDataOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WithdrawRequestAccountIdArguments {
+    r: RawTransactionArgument<string>;
+}
+export interface WithdrawRequestAccountIdOptions {
+    package?: string;
+    arguments: WithdrawRequestAccountIdArguments | [
+        r: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function withdrawRequestAccountId(options: WithdrawRequestAccountIdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WithdrawRequestBalanceArguments {
+    r: RawTransactionArgument<string>;
+}
+export interface WithdrawRequestBalanceOptions {
+    package?: string;
+    arguments: WithdrawRequestBalanceArguments | [
+        r: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function withdrawRequestBalance(options: WithdrawRequestBalanceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WithdrawRequestAmountArguments {
+    r: RawTransactionArgument<string>;
+}
+export interface WithdrawRequestAmountOptions {
+    package?: string;
+    arguments: WithdrawRequestAmountArguments | [
+        r: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function withdrawRequestAmount(options: WithdrawRequestAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WithdrawRequestRecipientArguments {
+    r: RawTransactionArgument<string>;
+}
+export interface WithdrawRequestRecipientOptions {
+    package?: string;
+    arguments: WithdrawRequestRecipientArguments | [
+        r: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function withdrawRequestRecipient(options: WithdrawRequestRecipientOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WithdrawRequestExtraDataArguments {
+    r: RawTransactionArgument<string>;
+}
+export interface WithdrawRequestExtraDataOptions {
+    package?: string;
+    arguments: WithdrawRequestExtraDataArguments | [
+        r: RawTransactionArgument<string>
+    ];
+    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;