@aptos-labs/ts-sdk 1.33.2-sc.0 → 1.34.0

package/dist/common/index.d.ts

@@ -1,5 +1,5 @@
-import { S as Serializable, T as TransactionArgument, H as HexInput, a as Serializer, D as Deserializer, E as EntryFunctionArgument, U as Uint8, b as Uint16, c as Uint32, A as AnyNumber, d as Deserializable, e as Hex, f as AuthenticationKeyScheme, g as AccountAddress, P as PrivateKeyVariants, h as AnyPublicKeyVariant, i as EphemeralPublicKeyVariant, N as Network, C as Client, j as ClientConfig, F as FullNodeConfig, I as IndexerConfig, k as FaucetConfig, l as AptosSettings, m as EphemeralCertificateVariant, Z as ZkpVariant, L as LedgerVersionArg, n as AccountAddressInput, M as MoveModuleId, o as ScriptFunctionArgument, p as MoveFunctionId, q as MoveStructId, r as MoveValue, s as MoveFunctionGenericTypeParam, t as SigningSchemeInput, u as SigningScheme, v as AccountData, w as PaginationArgs, x as MoveModuleBytecode, y as TransactionResponse, z as MoveResource, B as TokenStandardArg, O as OrderByArg, G as GetAccountOwnedTokensQueryResponse, J as GetAccountOwnedTokensFromCollectionResponse, K as GetAccountCollectionsWithOwnedTokenResponse, Q as GetAccountCoinsDataResponse, W as WhereArg, R as GetObjectDataQueryResponse, V as GetCollectionDataResponse, X as GetTokenDataResponse, Y as GetCurrentTokenOwnershipResponse, _ as GetOwnedTokensResponse, $ as GetTokenActivityResponse, a0 as GetEventsResponse, a1 as WaitForTransactionOptions, a2 as UserTransactionResponse, a3 as MoveFunction, a4 as GetFungibleAssetMetadataResponse, a5 as GetFungibleAssetActivitiesResponse, a6 as GetCurrentFungibleAssetBalancesResponse, a7 as LedgerInfo, a8 as Block, a9 as GetChainTopUserTransactionsResponse, aa as GraphqlQuery, ab as GetProcessorStatusResponse, ac as GetANSNameResponse, ad as GetNumberOfDelegatorsResponse, ae as GetDelegatedStakingActivitiesResponse, af as PendingTransactionResponse, ag as CommittedTransactionResponse, ah as GasEstimation, ai as TableItemRequest, aj as GetTableItemsDataResponse, ak as GetTableItemsMetadataResponse, al as ClientRequest, am as ClientResponse, an as AptosRequest, ao as AptosResponse, ap as MimeType } from './accountAddress-Cf1amU98.js';
-export { aG as AccountAuthenticatorVariant, bp as AccountSignature, at as AddressInvalidReason, aH as AnySignatureVariant, aZ as BlockEndInfo, a_ as BlockEpilogueTransactionResponse, aW as BlockMetadataTransactionResponse, aM as ClientHeadersType, b6 as DecodedTableData, b7 as DeletedTableData, bM as DeriveScheme, bs as DirectWriteSet, b9 as EntryFunctionPayloadResponse, aI as EphemeralSignatureVariant, bu as Event, bt as EventGuid, bP as GenerateAccount, bN as GenerateAccountWithEd25519, bO as GenerateAccountWithSingleSignerSecp256k1Key, bc as GenesisPayload, aV as GenesisTransactionResponse, aw as HexInvalidReason, bH as MoveAbility, bB as MoveAddressType, bG as MoveFunctionVisibility, bJ as MoveModule, bC as MoveObjectType, bD as MoveOptionType, bd as MoveScriptBytecode, bK as MoveStruct, bI as MoveStructField, bE as MoveStructType, bF as MoveType, bz as MoveUint128Type, bw as MoveUint16Type, bA as MoveUint256Type, bx as MoveUint32Type, by as MoveUint64Type, bv as MoveUint8Type, bb as MultisigPayloadResponse, bV as NetworkToChainId, bS as NetworkToFaucetAPI, bQ as NetworkToIndexerAPI, bW as NetworkToNetworkName, bR as NetworkToNodeAPI, bT as NetworkToPepperAPI, bU as NetworkToProverAPI, ay as OrderBy, az as OrderByValue, au as ParsingError, av as ParsingResult, bL as RoleType, ba as ScriptPayloadResponse, aC as ScriptTransactionArgumentVariants, br as ScriptWriteSet, aX as StateCheckpointTransactionResponse, aA as TokenStandard, aF as TransactionAuthenticatorVariant, bk as TransactionEd25519Signature, bo as TransactionFeePayerSignature, bn as TransactionMultiAgentSignature, bm as TransactionMultiEd25519Signature, b8 as TransactionPayloadResponse, aD as TransactionPayloadVariants, aN as TransactionResponseType, bl as TransactionSecp256k1Signature, be as TransactionSignature, aE as TransactionVariants, aB as TypeTagVariants, aK as Uint128, aL as Uint256, aJ as Uint64, aY as ValidatorTransactionResponse, bq as WriteSet, a$ as WriteSetChange, b0 as WriteSetChangeDeleteModule, b1 as WriteSetChangeDeleteResource, b2 as WriteSetChangeDeleteTableItem, b3 as WriteSetChangeWriteModule, b4 as WriteSetChangeWriteResource, b5 as WriteSetChangeWriteTableItem, aq as ensureBoolean, ax as hexToAsciiString, aU as isBlockEpilogueTransactionResponse, aR as isBlockMetadataTransactionResponse, bf as isEd25519Signature, bi as isFeePayerSignature, aQ as isGenesisTransactionResponse, bh as isMultiAgentSignature, bj as isMultiEd25519Signature, aO as isPendingTransactionResponse, bg as isSecp256k1Signature, aS as isStateCheckpointTransactionResponse, aP as isUserTransactionResponse, aT as isValidatorTransactionResponse, ar as outOfRangeErrorMessage, as as validateNumberInRange } from './accountAddress-Cf1amU98.js';
+import { S as Serializable, T as TransactionArgument, H as HexInput, a as Serializer, D as Deserializer, E as EntryFunctionArgument, U as Uint8, b as Uint16, c as Uint32, A as AnyNumber, d as Deserializable, e as Hex, f as AuthenticationKeyScheme, g as AccountAddress, P as PrivateKeyVariants, h as AnyPublicKeyVariant, i as EphemeralPublicKeyVariant, N as Network, C as Client, j as ClientConfig, F as FullNodeConfig, I as IndexerConfig, k as FaucetConfig, l as AptosSettings, m as EphemeralCertificateVariant, Z as ZkpVariant, L as LedgerVersionArg, n as AccountAddressInput, M as MoveModuleId, o as ScriptFunctionArgument, p as MoveFunctionId, q as MoveStructId, r as MoveValue, s as MoveFunctionGenericTypeParam, t as SigningSchemeInput, u as SigningScheme, v as MoveFunction, w as AccountData, x as PaginationArgs, y as MoveModuleBytecode, z as TransactionResponse, B as MoveResource, G as TokenStandardArg, O as OrderByArg, J as GetAccountOwnedTokensQueryResponse, K as GetAccountOwnedTokensFromCollectionResponse, Q as GetAccountCollectionsWithOwnedTokenResponse, R as GetAccountCoinsDataResponse, W as WhereArg, V as GetObjectDataQueryResponse, X as GetCollectionDataResponse, Y as GetTokenDataResponse, _ as GetCurrentTokenOwnershipResponse, $ as GetOwnedTokensResponse, a0 as GetTokenActivityResponse, a1 as GetEventsResponse, a2 as WaitForTransactionOptions, a3 as UserTransactionResponse, a4 as GetFungibleAssetMetadataResponse, a5 as GetFungibleAssetActivitiesResponse, a6 as GetCurrentFungibleAssetBalancesResponse, a7 as LedgerInfo, a8 as Block, a9 as GetChainTopUserTransactionsResponse, aa as GraphqlQuery, ab as GetProcessorStatusResponse, ac as GetANSNameResponse, ad as GetNumberOfDelegatorsResponse, ae as GetDelegatedStakingActivitiesResponse, af as PendingTransactionResponse, ag as CommittedTransactionResponse, ah as GasEstimation, ai as TableItemRequest, aj as GetTableItemsDataResponse, ak as GetTableItemsMetadataResponse, al as ClientRequest, am as ClientResponse, an as AptosRequest, ao as AptosResponse, ap as MimeType } from './accountAddress-CDtCLtJA.js';
+export { aG as AccountAuthenticatorVariant, bp as AccountSignature, at as AddressInvalidReason, aH as AnySignatureVariant, aZ as BlockEndInfo, a_ as BlockEpilogueTransactionResponse, aW as BlockMetadataTransactionResponse, aM as ClientHeadersType, b6 as DecodedTableData, b7 as DeletedTableData, bM as DeriveScheme, bs as DirectWriteSet, b9 as EntryFunctionPayloadResponse, aI as EphemeralSignatureVariant, bu as Event, bt as EventGuid, bP as GenerateAccount, bN as GenerateAccountWithEd25519, bO as GenerateAccountWithSingleSignerSecp256k1Key, bc as GenesisPayload, aV as GenesisTransactionResponse, aw as HexInvalidReason, bH as MoveAbility, bB as MoveAddressType, bG as MoveFunctionVisibility, bJ as MoveModule, bC as MoveObjectType, bD as MoveOptionType, bd as MoveScriptBytecode, bK as MoveStruct, bI as MoveStructField, bE as MoveStructType, bF as MoveType, bz as MoveUint128Type, bw as MoveUint16Type, bA as MoveUint256Type, bx as MoveUint32Type, by as MoveUint64Type, bv as MoveUint8Type, bb as MultisigPayloadResponse, bV as NetworkToChainId, bS as NetworkToFaucetAPI, bQ as NetworkToIndexerAPI, bW as NetworkToNetworkName, bR as NetworkToNodeAPI, bT as NetworkToPepperAPI, bU as NetworkToProverAPI, ay as OrderBy, az as OrderByValue, au as ParsingError, av as ParsingResult, bL as RoleType, ba as ScriptPayloadResponse, aC as ScriptTransactionArgumentVariants, br as ScriptWriteSet, aX as StateCheckpointTransactionResponse, aA as TokenStandard, aF as TransactionAuthenticatorVariant, bk as TransactionEd25519Signature, bo as TransactionFeePayerSignature, bn as TransactionMultiAgentSignature, bm as TransactionMultiEd25519Signature, b8 as TransactionPayloadResponse, aD as TransactionPayloadVariants, aN as TransactionResponseType, bl as TransactionSecp256k1Signature, be as TransactionSignature, aE as TransactionVariants, aB as TypeTagVariants, aK as Uint128, aL as Uint256, aJ as Uint64, aY as ValidatorTransactionResponse, bq as WriteSet, a$ as WriteSetChange, b0 as WriteSetChangeDeleteModule, b1 as WriteSetChangeDeleteResource, b2 as WriteSetChangeDeleteTableItem, b3 as WriteSetChangeWriteModule, b4 as WriteSetChangeWriteResource, b5 as WriteSetChangeWriteTableItem, aq as ensureBoolean, ax as hexToAsciiString, aU as isBlockEpilogueTransactionResponse, aR as isBlockMetadataTransactionResponse, bf as isEd25519Signature, bi as isFeePayerSignature, aQ as isGenesisTransactionResponse, bh as isMultiAgentSignature, bj as isMultiEd25519Signature, aO as isPendingTransactionResponse, bg as isSecp256k1Signature, aS as isStateCheckpointTransactionResponse, aP as isUserTransactionResponse, aT as isValidatorTransactionResponse, ar as outOfRangeErrorMessage, as as validateNumberInRange } from './accountAddress-CDtCLtJA.js';
 import { CallArgument } from '@aptos-labs/script-composer-pack';
 export { CallArgument } from '@aptos-labs/script-composer-pack';
 import EventEmitter from 'eventemitter3';
@@ -3565,6 +3565,41 @@ declare function bigIntToBytesLE(value: bigint | number, length: number): Uint8A
  */
 declare function poseidonHash(inputs: (number | bigint | string)[]): bigint;
 
+/**
+ * Creates an object address from creator address and seed
+ *
+ * @param creatorAddress The object creator account address
+ * @param seed The seed in either Uint8Array | string type
+ *
+ * @returns The object account address
+ * @group Implementation
+ * @category Account (On-Chain Model)
+ */
+declare const createObjectAddress: (creatorAddress: AccountAddress, seed: Uint8Array | string) => AccountAddress;
+/**
+ * Creates a resource address from creator address and seed
+ *
+ * @param creatorAddress The creator account address
+ * @param seed The seed in either Uint8Array | string type
+ *
+ * @returns The resource account address
+ * @group Implementation
+ * @category Account (On-Chain Model)
+ */
+declare const createResourceAddress: (creatorAddress: AccountAddress, seed: Uint8Array | string) => AccountAddress;
+/**
+ * Creates a token object address from creator address, collection name and token name
+ *
+ * @param creatorAddress The token creator account address
+ * @param collectionName The collection name
+ * @param tokenName The token name
+ *
+ * @returns The token account address
+ * @group Implementation
+ * @category Account (On-Chain Model)
+ */
+declare const createTokenAddress: (creatorAddress: AccountAddress, collectionName: string, tokenName: string) => AccountAddress;
+
 /**
  * Represents an account authenticator that can handle multiple authentication variants.
  * This class serves as a base for different types of account authenticators, allowing for serialization
@@ -3713,41 +3748,14 @@ declare class AccountAuthenticatorNoAccountAuthenticator extends AccountAuthenti
     serialize(serializer: Serializer): void;
     static load(deserializer: Deserializer): AccountAuthenticatorNoAccountAuthenticator;
 }
-
-/**
- * Creates an object address from creator address and seed
- *
- * @param creatorAddress The object creator account address
- * @param seed The seed in either Uint8Array | string type
- *
- * @returns The object account address
- * @group Implementation
- * @category Account (On-Chain Model)
- */
-declare const createObjectAddress: (creatorAddress: AccountAddress, seed: Uint8Array | string) => AccountAddress;
-/**
- * Creates a resource address from creator address and seed
- *
- * @param creatorAddress The creator account address
- * @param seed The seed in either Uint8Array | string type
- *
- * @returns The resource account address
- * @group Implementation
- * @category Account (On-Chain Model)
- */
-declare const createResourceAddress: (creatorAddress: AccountAddress, seed: Uint8Array | string) => AccountAddress;
-/**
- * Creates a token object address from creator address, collection name and token name
- *
- * @param creatorAddress The token creator account address
- * @param collectionName The collection name
- * @param tokenName The token name
- *
- * @returns The token account address
- * @group Implementation
- * @category Account (On-Chain Model)
- */
-declare const createTokenAddress: (creatorAddress: AccountAddress, collectionName: string, tokenName: string) => AccountAddress;
+declare class AccountAuthenticatorAbstraction extends AccountAuthenticator {
+    readonly functionInfo: string;
+    readonly signingMessageDigest: Hex;
+    readonly authenticator: Hex;
+    constructor(functionInfo: string, signingMessageDigest: HexInput, authenticator: HexInput);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): AccountAuthenticatorAbstraction;
+}
 
 /**
  * Represents a ChainId that can be serialized and deserialized.
@@ -6837,2066 +6845,70 @@ declare namespace AccountUtils {
     function fromBytes(bytes: Uint8Array): Account$1;
 }
 
-/**
- * A class to query all `Account` related queries on Aptos.
- * @group Account
- */
-declare class Account {
-    readonly config: AptosConfig;
+declare class AbstractSignature extends Signature {
+    readonly value: Hex;
+    constructor(value: HexInput);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): AbstractSignature;
+}
+declare class AbstractPublicKey extends AccountPublicKey {
+    readonly accountAddress: AccountAddress;
+    constructor(accountAddress: AccountAddress);
+    authKey(): AuthenticationKey;
+    verifySignature(args: VerifySignatureArgs): boolean;
+    serialize(serializer: Serializer): void;
+}
+
+type AbstractedAccountConstructorArgs = {
     /**
-     * Creates an instance of the Aptos client with the provided configuration.
-     *
-     * @param config - The configuration settings for the Aptos client.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * async function runExample() {
-     *     // Initialize the Aptos client with testnet configuration
-     *     const config = new AptosConfig({ network: Network.TESTNET }); // specify your own network if needed
-     *     const aptos = new Aptos(config);
-     *
-     *     console.log("Aptos client initialized:", aptos);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Account
+     * The account address of the account.
      */
-    constructor(config: AptosConfig);
+    accountAddress: AccountAddress;
     /**
-     * Queries the current state for an Aptos account given its account address.
-     *
-     * @param args - The arguments for retrieving account information.
-     * @param args.accountAddress - The Aptos account address to query.
-     * @returns The account data.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
+     * The signer function signs transactions and returns the `authenticator` bytes in the `AbstractionAuthData`.
      *
-     * async function runExample() {
-     *     // Retrieve account information for a specific address
-     *     const accountInfo = await aptos.getAccountInfo({ accountAddress: "0x1" }); // replace with a real account address
-     *     console.log(accountInfo);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Account
+     * @param digest - The SHA256 hash of the transaction signing message
+     * @returns The `authenticator` bytes that can be used to verify the signature.
      */
-    getAccountInfo(args: {
-        accountAddress: AccountAddressInput;
-    }): Promise<AccountData>;
+    signer: (digest: HexInput) => HexInput;
     /**
-     * Queries for all modules in an account given an account address.
-     * This function may call the API multiple times to auto paginate through results.
-     *
-     * @param args.accountAddress - The Aptos account address to query modules for.
-     * @param args.options.offset - The cursor to start returning results from.  Note, this is obfuscated and is not an index.
-     * @param args.options.limit - The maximum number of results to return.
-     * @param args.options.ledgerVersion - The ledger version to query; if not provided, it retrieves the latest version.
-     *
-     * @returns - The account modules associated with the specified address.
+     * The authentication function that will be used to verify the signature.
      *
      * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Fetching account modules for a specific account
-     *   const accountModules = await aptos.getAccountModules({
-     *     accountAddress: "0x1", // replace with a real account address
-     *     options: {
-     *       offset: 0, // starting from the first module
-     *       limit: 10, // limiting to 10 modules
-     *     },
-     *   });
-     *
-     *   console.log(accountModules);
-     * }
-     * runExample().catch(console.error);
+     * ```ts
+     * const authenticationFunction = `${accountAddress}::permissioned_delegation::authenticate`;
      * ```
-     * @group Account
      */
-    getAccountModules(args: {
-        accountAddress: AccountAddressInput;
-        options?: PaginationArgs & LedgerVersionArg;
-    }): Promise<MoveModuleBytecode[]>;
+    authenticationFunction: string;
+};
+declare class AbstractedAccount extends Account$1 {
+    readonly publicKey: AbstractPublicKey;
+    readonly accountAddress: AccountAddress;
+    readonly authenticationFunction: string;
+    readonly signingScheme = SigningScheme.SingleKey;
+    constructor({ signer, accountAddress, authenticationFunction }: AbstractedAccountConstructorArgs);
     /**
-     * Queries for a specific account module given an account address and module name.
-     *
-     * @param args.accountAddress - The Aptos account address.
-     * @param args.moduleName - The name of the module.
-     * @param args.options.ledgerVersion - The ledger version to query; if not provided, it will get the latest version.
-     *
-     * @returns The account module associated with the specified account address and module name.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     * Creates an `AbstractedAccount` from an `Ed25519Account` that has a permissioned signer function and
+     * using the `0x1::permissioned_delegation::authenticate` function to verify the signature.
      *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Get the account module for a specific account address and module name
-     *   const module = await aptos.getAccountModule({
-     *     accountAddress: "0x1", // replace with a real account address
-     *     moduleName: "MyModule" // specify the module name
-     *   });
-     *
-     *   console.log(module);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Account
+     * @param signer - The `Ed25519Account` that can be used to sign permissioned transactions.
+     * @returns The `AbstractedAccount`
      */
-    getAccountModule(args: {
-        accountAddress: AccountAddressInput;
-        moduleName: string;
-        options?: LedgerVersionArg;
-    }): Promise<MoveModuleBytecode>;
+    static fromPermissionedSigner({ signer, accountAddress, }: {
+        signer: Ed25519Account;
+        accountAddress?: AccountAddress;
+    }): AbstractedAccount;
+    signWithAuthenticator(message: HexInput): AccountAuthenticatorAbstraction;
+    signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorAbstraction;
+    sign: (message: HexInput) => AbstractSignature;
+    signTransaction(transaction: AnyRawTransaction): AbstractSignature;
     /**
-     * Queries account transactions given an account address.
-     * This function may call the API multiple times to auto paginate and retrieve all account transactions.
-     *
-     * @param args.accountAddress - The Aptos account address to query transactions for.
-     * @param args.options - Optional pagination arguments.
-     * @param args.options.offset - The number of transactions to start returning results from.
-     * @param args.options.limit - The maximum number of results to return.
-     *
-     * @returns The account transactions.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Fetch transactions for a specific account
-     *   const transactions = await aptos.getAccountTransactions({
-     *     accountAddress: "0x1", // replace with a real account address
-     *     options: {
-     *       offset: 0, // starting from the first transaction
-     *       limit: 10, // limiting to 10 transactions
-     *     },
-     *   });
+     * Update the signer function for the account. This can be done after asynchronous operations are complete
+     * to update the context of the signer function.
      *
-     *   console.log(transactions);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Account
+     * @param signer - The new signer function to use for the account.
      */
-    getAccountTransactions(args: {
-        accountAddress: AccountAddressInput;
-        options?: PaginationArgs;
-    }): Promise<TransactionResponse[]>;
-    /**
-     * Queries all account resources given an account address.
-     * This function may call the API multiple times to auto paginate through results.
-     *
-     * @param args.accountAddress - The Aptos account address to query resources for.
-     * @param args.options.offset - The cursor to start returning results from.  Note, this is obfuscated and is not an index.
-     * @param args.options.limit - The maximum number of results to return.
-     * @param args.options.ledgerVersion - The ledger version to query; if not provided, it will get the latest version.
-     * @returns Account resources.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Fetching account resources for a specific account address
-     *   const resources = await aptos.getAccountResources({ accountAddress: "0x1" }); // replace with a real account address
-     *   console.log(resources);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Account
-     */
-    getAccountResources(args: {
-        accountAddress: AccountAddressInput;
-        options?: PaginationArgs & LedgerVersionArg;
-    }): Promise<MoveResource[]>;
-    /**
-     * Queries a specific account resource given an account address and resource type.
-     *
-     * @template T - The typed output of the resource.
-     * @param args.accountAddress - The Aptos account address to query.
-     * @param args.resourceType - The string representation of an on-chain Move struct type, e.g., "0x1::aptos_coin::AptosCoin".
-     * @param args.options.ledgerVersion - The ledger version to query; if not provided, it will get the latest version.
-     * @returns The account resource of the specified type.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Get the account resource for a specific account address and resource type
-     *   const resource = await aptos.getAccountResource({
-     *     accountAddress: "0x1", // replace with a real account address
-     *     resourceType: "0x1::aptos_coin::AptosCoin"
-     *   });
-     *
-     *   console.log(resource);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Account
-     */
-    getAccountResource<T extends {} = any>(args: {
-        accountAddress: AccountAddressInput;
-        resourceType: MoveStructId;
-        options?: LedgerVersionArg;
-    }): Promise<T>;
-    /**
-     * Looks up the account address for a given authentication key, handling both rotated and non-rotated keys.
-     *
-     * @param args.authenticationKey - The authentication key for which to look up the account address.
-     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
-     * @param args.options.ledgerVersion - The ledger version to query; if not provided, it will get the latest version.
-     * @returns Promise<AccountAddress> - The account address associated with the authentication key.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Look up the original account address for a given authentication key
-     *   const accountAddress = await aptos.lookupOriginalAccountAddress({
-     *     authenticationKey: "0x1", // replace with a real authentication key
-     *   });
-     *
-     *   console.log("Original Account Address:", accountAddress);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Account
-     */
-    lookupOriginalAccountAddress(args: {
-        authenticationKey: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: LedgerVersionArg;
-    }): Promise<AccountAddress>;
-    /**
-     * Queries the current count of tokens owned by a specified account.
-     *
-     * @param args - The parameters for the query.
-     * @param args.accountAddress - The account address to query the token count for.
-     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
-     * @returns The current count of tokens owned by the account.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Get the count of tokens owned by the account
-     *   const tokensCount = await aptos.getAccountTokensCount({ accountAddress: "0x1" }); // replace with a real account address
-     *   console.log(`Tokens Count: ${tokensCount}`);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Account
-     */
-    getAccountTokensCount(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
-    /**
-     * Queries the tokens currently owned by a specified account, including NFTs and fungible tokens.
-     * If desired, you can filter the results by a specific token standard.
-     *
-     * @param args.accountAddress The account address for which to retrieve owned tokens.
-     * @param args.minimumLedgerVersion Optional ledger version to sync up to before querying.
-     * @param args.options.tokenStandard Optional filter for the NFT standard to query for.
-     * @param args.options.offset Optional number to start returning results from.
-     * @param args.options.limit Optional number of results to return.
-     * @param args.options.orderBy Optional order to sort the tokens by.
-     * @returns An array of tokens with their respective data.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Get the tokens owned by a specific account
-     *   const accountOwnedTokens = await aptos.getAccountOwnedTokens({
-     *     accountAddress: "0x1", // replace with a real account address
-     *     options: {
-     *       limit: 10, // specify how many tokens to return
-     *       orderBy: "created_at", // specify the order of the results
-     *     },
-     *   });
-     *
-     *   console.log(accountOwnedTokens);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Account
-     */
-    getAccountOwnedTokens(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensQueryResponse[0]>;
-    }): Promise<GetAccountOwnedTokensQueryResponse>;
-    /**
-     * Queries all current tokens of a specific collection that an account owns by the collection address.
-     * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.
-     * If you want to get only the token from a specific standard, you can pass an optional tokenStandard parameter.
-     *
-     * @param args.accountAddress - The account address we want to get the tokens for.
-     * @param args.collectionAddress - The address of the collection being queried.
-     * @param args.minimumLedgerVersion - Optional ledger version to sync up to, before querying.
-     * @param args.options.tokenStandard - The NFT standard to query for.
-     * @param args.options.offset - The number token to start returning results from.
-     * @param args.options.limit - The number of results to return.
-     * @param args.options.orderBy - The order to sort the tokens by.
-     * @returns Tokens array with the token data.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Get tokens owned by a specific account in a specific collection
-     *   const accountOwnedTokens = await aptos.getAccountOwnedTokensFromCollectionAddress({
-     *     accountAddress: "0x1", // replace with a real account address
-     *     collectionAddress: "0x2", // replace with a real collection address
-     *   });
-     *
-     *   console.log(accountOwnedTokens);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Account
-     */
-    getAccountOwnedTokensFromCollectionAddress(args: {
-        accountAddress: AccountAddressInput;
-        collectionAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensFromCollectionResponse[0]>;
-    }): Promise<GetAccountOwnedTokensFromCollectionResponse>;
-    /**
-     * Queries for all collections that an account currently has tokens for, including NFTs, fungible tokens, and soulbound tokens.
-     * If you want to filter by a specific token standard, you can pass an optional tokenStandard parameter.
-     *
-     * @param args.accountAddress - The account address we want to get the collections for.
-     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
-     * @param args.options.tokenStandard - The NFT standard to query for.
-     * @param args.options.offset - The number of the collection to start returning results from.
-     * @param args.options.limit - The number of results to return.
-     * @param args.options.orderBy - The order to sort the tokens by.
-     * @returns Collections array with the collections data.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Get account collections with owned tokens for a specific account
-     *   const accountCollectionsWithOwnedTokens = await aptos.getAccountCollectionsWithOwnedTokens({
-     *     accountAddress: "0x1", // replace with a real account address
-     *     options: {
-     *       tokenStandard: "NFT", // specify the token standard if needed
-     *       limit: 10, // specify the number of results to return
-     *     },
-     *   });
-     *
-     *   console.log(accountCollectionsWithOwnedTokens);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Account
-     */
-    getAccountCollectionsWithOwnedTokens(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountCollectionsWithOwnedTokenResponse[0]>;
-    }): Promise<GetAccountCollectionsWithOwnedTokenResponse>;
-    /**
-     * Queries the current count of transactions submitted by an account.
-     *
-     * @param args - The parameters for the query.
-     * @param args.accountAddress - The account address we want to get the total count for.
-     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
-     * @returns Current count of transactions made by an account.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Get the count of transactions for a specific account
-     *   const accountTransactionsCount = await aptos.getAccountTransactionsCount({
-     *     accountAddress: "0x1", // replace with a real account address
-     *     minimumLedgerVersion: 1, // specify your own minimum ledger version if needed
-     *   });
-     *
-     *   console.log(accountTransactionsCount);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Account
-     */
-    getAccountTransactionsCount(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
-    /**
-     * Retrieves the coins data for a specified account.
-     *
-     * @param args.accountAddress - The account address for which to retrieve the coin's data.
-     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
-     * @param args.options.offset - Optional. The number of coins to start returning results from.
-     * @param args.options.limit - Optional. The number of results to return.
-     * @param args.options.orderBy - Optional. The order to sort the coins by.
-     * @param args.options.where - Optional. Filter the results by specific criteria.
-     * @returns An array containing the coins data for the specified account.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Fetching coins data for a specific account
-     *   const accountCoinsData = await aptos.getAccountCoinsData({
-     *     accountAddress: "0x1", // replace with a real account address
-     *     options: {
-     *       limit: 10, // specify the number of results to return
-     *       orderBy: { asset_type: "asc" }, // specify the order of results
-     *     },
-     *   });
-     *
-     *   console.log(accountCoinsData);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Account
-     */
-    getAccountCoinsData(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: PaginationArgs & OrderByArg<GetAccountCoinsDataResponse[0]> & WhereArg<CurrentFungibleAssetBalancesBoolExp>;
-    }): Promise<GetAccountCoinsDataResponse>;
-    /**
-     * Retrieves the current count of an account's coins aggregated across all types.
-     *
-     * @param args The parameters for the account coins count query.
-     * @param args.accountAddress The account address we want to get the total count for.
-     * @param args.minimumLedgerVersion Optional ledger version to sync up to before querying.
-     * @returns The current count of the aggregated coins for the specified account.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Getting the account coins count for a specific account
-     *   const accountCoinsCount = await aptos.getAccountCoinsCount({ accountAddress: "0x1" }); // replace with a real account address
-     *   console.log("Account Coins Count:", accountCoinsCount);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Account
-     */
-    getAccountCoinsCount(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
-    /**
-     * Retrieves the current amount of APT for a specified account.
-     *
-     * @param args The arguments for the account query.
-     * @param args.accountAddress The account address for which to retrieve the APT amount.
-     * @param args.minimumLedgerVersion Optional ledger version to sync up to before querying.
-     * @returns The current amount of APT for the specified account.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Get the APT amount for a specific account
-     *   const accountAPTAmount = await aptos.getAccountAPTAmount({ accountAddress: "0x1" }); // replace with a real account address
-     *   console.log("Account APT Amount:", accountAPTAmount);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Account
-     */
-    getAccountAPTAmount(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
-    /**
-     * Queries the current amount of a specified coin held by an account.
-     *
-     * @param args The parameters for querying the account's coin amount.
-     * @param args.accountAddress The account address to query for the coin amount.
-     * @param args.coinType The coin type to query. Note: If not provided, it may be automatically populated if `faMetadataAddress`
-     * is specified.
-     * @param args.faMetadataAddress The fungible asset metadata address to query. Note: If not provided, it may be automatically
-     * populated if `coinType` is specified.
-     * @param args.minimumLedgerVersion Not used anymore, here for backward compatibility
-     * see https://github.com/aptos-labs/aptos-ts-sdk/pull/519, will be removed in the near future.
-     * Optional ledger version to sync up to before querying.
-     * @returns The current amount of the specified coin held by the account.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Query the account's coin amount for a specific coin type
-     *   const accountCoinAmount = await aptos.getAccountCoinAmount({
-     *     accountAddress: "0x1", // replace with a real account address
-     *     coinType: "0x1::aptos_coin::AptosCoin" // specify the coin type
-     *   });
-     *
-     *   console.log(`Account coin amount: ${accountCoinAmount}`);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Account
-     */
-    getAccountCoinAmount(args: {
-        accountAddress: AccountAddressInput;
-        coinType?: MoveStructId;
-        faMetadataAddress?: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
-    /**
-     * Queries an account's owned objects.
-     *
-     * @param args.accountAddress The account address we want to get the objects for.
-     * @param args.minimumLedgerVersion Optional ledger version to sync up to before querying.
-     * @param args.options.offset The starting position to start returning results from.
-     * @param args.options.limit The number of results to return.
-     * @param args.options.orderBy The order to sort the objects by.
-     * @returns Objects array with the object data.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Get the objects owned by the specified account
-     *   const accountOwnedObjects = await aptos.getAccountOwnedObjects({
-     *     accountAddress: "0x1", // replace with a real account address
-     *     minimumLedgerVersion: 1, // optional, specify if needed
-     *     options: {
-     *       offset: 0, // optional, specify if needed
-     *       limit: 10, // optional, specify if needed
-     *       orderBy: "created_at", // optional, specify if needed
-     *     },
-     *   });
-     *
-     *   console.log(accountOwnedObjects);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Account
-     */
-    getAccountOwnedObjects(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: PaginationArgs & OrderByArg<GetObjectDataQueryResponse[0]>;
-    }): Promise<GetObjectDataQueryResponse>;
-    /**
-     * Derives an account by providing a private key. This function resolves the provided private key type and derives the public
-     * key from it.
-     *
-     * If the privateKey is a Secp256k1 type, it derives the account using the derived public key and auth key using the SingleKey
-     * scheme locally.
-     * If the privateKey is an ED25519 type, it looks up the authentication key on chain to determine whether it is a Legacy ED25519
-     * key or a Unified ED25519 key, and then derives the account based on that.
-     *
-     * @param args - The arguments for deriving the account.
-     * @param args.privateKey - An account private key.
-     * @returns The derived Account type.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network, Ed25519PrivateKey } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *     // Deriving an account from a private key
-     *     const account = await aptos.deriveAccountFromPrivateKey({
-     *         privateKey: new Ed25519PrivateKey("0x123") // replace with a real private key
-     *     });
-     *
-     *     console.log(account);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Account
-     */
-    deriveAccountFromPrivateKey(args: {
-        privateKey: PrivateKey;
-    }): Promise<Account$1>;
-}
-
-/**
- * A class to handle all `Coin` operations.
- * @group Coin
- */
-declare class Coin {
-    readonly config: AptosConfig;
-    /**
-     * Initializes a new instance of the Aptos client with the specified configuration.
-     * This allows you to interact with the Aptos blockchain using the provided settings.
-     *
-     * @param config - The configuration settings for the Aptos client.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * async function runExample() {
-     *     // Create a new Aptos client with testnet configuration
-     *     const config = new AptosConfig({ network: Network.TESTNET });
-     *     const aptos = new Aptos(config);
-     *
-     *     console.log("Aptos client initialized:", aptos);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Coin
-     */
-    constructor(config: AptosConfig);
-    /**
-     * Generate a transfer coin transaction that can be simulated, signed, and submitted.
-     * This function helps you create a transaction to transfer a specified amount of coins
-     * from one account to another within the Aptos network.
-     *
-     * @param args The arguments for the transfer transaction.
-     * @param args.sender The sender account address.
-     * @param args.recipient The recipient account address.
-     * @param args.amount The amount of coins to transfer.
-     * @param args.coinType Optional. The coin struct type to transfer. Defaults to 0x1::aptos_coin::AptosCoin.
-     * @param args.options Optional. Additional options for generating the transaction.
-     *
-     * @returns SimpleTransaction
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Generate a transfer coin transaction
-     *   const transaction = await aptos.transferCoinTransaction({
-     *     sender: "0x1", // replace with a real sender account address
-     *     recipient: "0x2", // replace with a real recipient account address
-     *     amount: 10,
-     *   });
-     *
-     *   console.log(transaction);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Coin
-     */
-    transferCoinTransaction(args: {
-        sender: AccountAddressInput;
-        recipient: AccountAddressInput;
-        amount: AnyNumber;
-        coinType?: MoveStructId;
-        options?: InputGenerateTransactionOptions;
-    }): Promise<SimpleTransaction>;
-}
-
-/**
- * This file contains the underlying implementations for exposed API surface in
- * the {@link api/digitalAsset}. By moving the methods out into a separate file,
- * other namespaces and processes can access these methods without depending on the entire
- * digitalAsset namespace and without having a dependency cycle error.
- * @group Implementation
- */
-
-declare const PropertyTypeMap: {
-    BOOLEAN: string;
-    U8: string;
-    U16: string;
-    U32: string;
-    U64: string;
-    U128: string;
-    U256: string;
-    ADDRESS: string;
-    STRING: string;
-    ARRAY: string;
-};
-/**
- * The keys of the PropertyTypeMap, representing different property types.
- * @group Implementation
- */
-type PropertyType = keyof typeof PropertyTypeMap;
-/**
- * Accepted property value types for user input, including boolean, number, bigint, string, AccountAddress, and Uint8Array.
- * To pass in an Array, use Uint8Array type
- * for example `new MoveVector([new MoveString("hello"), new MoveString("world")]).bcsToBytes()`
- * @group Implementation
- */
-type PropertyValue = boolean | number | bigint | string | AccountAddress | Uint8Array;
-/**
- * Options for creating a collection, allowing customization of various attributes such as supply limits, mutability of metadata,
- * and royalty settings.
- *
- * @param maxSupply - Maximum number of tokens that can be minted in the collection.
- * @param mutableDescription - Indicates if the collection description can be changed after creation.
- * @param mutableRoyalty - Indicates if the royalty settings can be modified after creation.
- * @param mutableURI - Indicates if the collection URI can be updated.
- * @param mutableTokenDescription - Indicates if individual token descriptions can be modified.
- * @param mutableTokenName - Indicates if individual token names can be changed.
- * @param mutableTokenProperties - Indicates if individual token properties can be altered.
- * @param mutableTokenURI - Indicates if individual token URIs can be updated.
- * @param tokensBurnableByCreator - Indicates if the creator can burn tokens from the collection.
- * @param tokensFreezableByCreator - Indicates if the creator can freeze tokens in the collection.
- * @param royaltyNumerator - The numerator for calculating royalties.
- * @param royaltyDenominator - The denominator for calculating royalties.
- * @group Implementation
- */
-interface CreateCollectionOptions {
-    maxSupply?: AnyNumber;
-    mutableDescription?: boolean;
-    mutableRoyalty?: boolean;
-    mutableURI?: boolean;
-    mutableTokenDescription?: boolean;
-    mutableTokenName?: boolean;
-    mutableTokenProperties?: boolean;
-    mutableTokenURI?: boolean;
-    tokensBurnableByCreator?: boolean;
-    tokensFreezableByCreator?: boolean;
-    royaltyNumerator?: number;
-    royaltyDenominator?: number;
-}
-
-/**
- * A class to query all `DigitalAsset` related queries on Aptos.
- * @group DigitalAsset
- */
-declare class DigitalAsset {
-    readonly config: AptosConfig;
-    /**
-     * Initializes a new instance of the Aptos client with the specified configuration.
-     * This allows you to interact with the Aptos blockchain using the provided settings.
-     *
-     * @param config - The configuration settings for the Aptos client.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * async function runExample() {
-     *     // Create a configuration for the Aptos client
-     *     const config = new AptosConfig({ network: Network.TESTNET }); // Specify your desired network
-     *
-     *     // Initialize the Aptos client with the configuration
-     *     const aptos = new Aptos(config);
-     *
-     *     console.log("Aptos client initialized:", aptos);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    constructor(config: AptosConfig);
-    /**
-     * Queries data of a specific collection by the collection creator address and the collection name.
-     * This function is deprecated; use `getCollectionDataByCreatorAddressAndCollectionName` instead.
-     *
-     * If a creator account has two collections with the same name in v1 and v2, you can pass an optional `tokenStandard` parameter
-     * to query a specific standard.
-     *
-     * @param args - The arguments for querying the collection data.
-     * @param args.creatorAddress - The address of the collection's creator.
-     * @param args.collectionName - The name of the collection.
-     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
-     * @param args.options - Optional parameters for the query.
-     * @param args.options.tokenStandard - The token standard to query.
-     * @returns GetCollectionDataResponse - The response type containing the collection data.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Querying collection data by creator address and collection name
-     *   const collection = await aptos.getCollectionData({
-     *     creatorAddress: "0x1", // replace with a real creator address
-     *     collectionName: "myCollection", // specify your collection name
-     *   });
-     *
-     *   console.log(collection);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    getCollectionData(args: {
-        creatorAddress: AccountAddressInput;
-        collectionName: string;
-        minimumLedgerVersion?: AnyNumber;
-        options?: TokenStandardArg;
-    }): Promise<GetCollectionDataResponse>;
-    /**
-     * Queries data of a specific collection by the collection creator address and the collection name.
-     * If a creator account has multiple collections with the same name across different versions,
-     * specify the `tokenStandard` parameter to query a specific standard.
-     *
-     * @param args.creatorAddress - The address of the collection's creator.
-     * @param args.collectionName - The name of the collection.
-     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
-     * @param args.options.tokenStandard - Optional token standard to query.
-     * @returns GetCollectionDataResponse - The response type containing collection data.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Fetching collection data by creator address and collection name
-     *   const collection = await aptos.getCollectionDataByCreatorAddressAndCollectionName({
-     *     creatorAddress: "0x1", // replace with a real creator address
-     *     collectionName: "myCollection",
-     *     minimumLedgerVersion: 1, // optional, specify if needed
-     *     options: { tokenStandard: "v2" } // optional, specify if needed
-     *   });
-     *
-     *   console.log(collection);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    getCollectionDataByCreatorAddressAndCollectionName(args: {
-        creatorAddress: AccountAddressInput;
-        collectionName: string;
-        minimumLedgerVersion?: AnyNumber;
-        options?: TokenStandardArg & PaginationArgs;
-    }): Promise<GetCollectionDataResponse>;
-    /**
-     * Retrieves data for a specific collection created by a given creator address.
-     * This function allows you to query collection data while optionally specifying a minimum ledger version and pagination options.
-     *
-     * @param args.creatorAddress - The address of the collection's creator.
-     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
-     * @param args.options.tokenStandard - Optional token standard to query.
-     * @param args.options.pagination - Optional pagination arguments.
-     * @returns GetCollectionDataResponse - The response type containing collection data.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Retrieve collection data by creator address
-     *   const collectionData = await aptos.getCollectionDataByCreatorAddress({
-     *     creatorAddress: "0x1", // replace with a real creator address
-     *     minimumLedgerVersion: 1, // specify the minimum ledger version if needed
-     *     options: {
-     *       tokenStandard: "v2", // specify the token standard if needed
-     *       pagination: { limit: 10, offset: 0 } // specify pagination options if needed
-     *     }
-     *   });
-     *
-     *   console.log(collectionData);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    getCollectionDataByCreatorAddress(args: {
-        creatorAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: TokenStandardArg & PaginationArgs;
-    }): Promise<GetCollectionDataResponse>;
-    /**
-     * Queries data of a specific collection by the collection ID.
-     *
-     * @param args.collectionId - The ID of the collection, which is the same as the address of the collection object.
-     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
-     * @param args.options - Optional parameters for token standard and pagination.
-     * @returns GetCollectionDataResponse - The response type containing the collection data.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Fetching collection data by collection ID
-     *   const collection = await aptos.getCollectionDataByCollectionId({
-     *     collectionId: "0x123", // replace with a real collection ID
-     *   });
-     *
-     *   console.log(collection);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    getCollectionDataByCollectionId(args: {
-        collectionId: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: TokenStandardArg & PaginationArgs;
-    }): Promise<GetCollectionDataResponse>;
-    /**
-     * Queries the ID of a specified collection.
-     * This ID corresponds to the collection's object address in V2, while V1 does not utilize objects and lacks an address.
-     *
-     * @param args.creatorAddress - The address of the collection's creator.
-     * @param args.collectionName - The name of the collection.
-     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
-     * @param args.options.tokenStandard - The token standard to query.
-     * @returns The collection ID.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Fetching the collection ID for a specific creator and collection name
-     *   const collectionId = await aptos.getCollectionId({
-     *     creatorAddress: "0x1", // replace with a real creator address
-     *     collectionName: "myCollection"
-     *   });
-     *
-     *   console.log("Collection ID:", collectionId);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    getCollectionId(args: {
-        creatorAddress: AccountAddressInput;
-        collectionName: string;
-        minimumLedgerVersion?: AnyNumber;
-        options?: TokenStandardArg;
-    }): Promise<string>;
-    /**
-     * Retrieves digital asset data using the address of a digital asset.
-     *
-     * @param args - The parameters for the request.
-     * @param args.digitalAssetAddress - The address of the digital asset.
-     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
-     * @returns GetTokenDataResponse containing relevant data for the digital asset.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Fetching digital asset data for a specific address
-     *   const digitalAsset = await aptos.getDigitalAssetData({
-     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
-     *   });
-     *
-     *   console.log(digitalAsset);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    getDigitalAssetData(args: {
-        digitalAssetAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<GetTokenDataResponse>;
-    /**
-     * Retrieves the current ownership data of a specified digital asset using its address.
-     *
-     * @param args The parameters for the request.
-     * @param args.digitalAssetAddress The address of the digital asset.
-     * @param args.minimumLedgerVersion Optional ledger version to sync up to before querying.
-     *
-     * @returns GetCurrentTokenOwnershipResponse containing relevant ownership data of the digital asset.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Getting the current ownership of a digital asset
-     *   const digitalAssetOwner = await aptos.getCurrentDigitalAssetOwnership({
-     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
-     *   });
-     *
-     *   console.log(digitalAssetOwner);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    getCurrentDigitalAssetOwnership(args: {
-        digitalAssetAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<GetCurrentTokenOwnershipResponse>;
-    /**
-     * Retrieves the digital assets owned by a specified address.
-     *
-     * @param args.ownerAddress The address of the owner.
-     * @param args.minimumLedgerVersion Optional ledger version to sync up to before querying.
-     * @param args.options Optional pagination and ordering parameters for the response.
-     *
-     * @returns GetOwnedTokensResponse containing ownership data of the digital assets belonging to the ownerAddress.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Fetching the digital assets owned by the specified address
-     *   const digitalAssets = await aptos.getOwnedDigitalAssets({
-     *     ownerAddress: "0x1", // replace with a real account address
-     *   });
-     *
-     *   console.log(digitalAssets);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    getOwnedDigitalAssets(args: {
-        ownerAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: PaginationArgs & OrderByArg<GetOwnedTokensResponse[0]>;
-    }): Promise<GetOwnedTokensResponse>;
-    /**
-     * Retrieves the activity data for a specified digital asset using its address.
-     *
-     * @param args - The parameters for the request.
-     * @param args.digitalAssetAddress - The address of the digital asset.
-     * @param args.minimumLedgerVersion - Optional minimum ledger version to sync up to before querying.
-     * @param args.options - Optional pagination and ordering parameters.
-     *
-     * @returns A promise that resolves to the activity data related to the digital asset.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Get the activity data for a digital asset
-     *   const digitalAssetActivity = await aptos.getDigitalAssetActivity({
-     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
-     *   });
-     *
-     *   console.log(digitalAssetActivity);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    getDigitalAssetActivity(args: {
-        digitalAssetAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: PaginationArgs & OrderByArg<GetTokenActivityResponse[0]>;
-    }): Promise<GetTokenActivityResponse>;
-    /**
-     * Creates a new collection within the specified account.
-     *
-     * @param args.creator - The account of the collection's creator.
-     * @param args.description - The description of the collection.
-     * @param args.name - The name of the collection.
-     * @param args.uri - The URI to additional info about the collection.
-     * @param args.options - Optional parameters for generating the transaction.
-     *
-     * The parameters below are optional:
-     * @param args.maxSupply - Controls the max supply of the digital assets. Defaults to MAX_U64_BIG_INT.
-     * @param args.mutableDescription - Controls mutability of the collection's description. Defaults to true.
-     * @param args.mutableRoyalty - Controls mutability of the collection's royalty. Defaults to true.
-     * @param args.mutableUri - Controls mutability of the collection's URI. Defaults to true.
-     * @param args.mutableTokenDescription - Controls mutability of the digital asset's description. Defaults to true.
-     * @param args.mutableTokenName - Controls mutability of the digital asset's name. Defaults to true.
-     * @param args.mutableTokenProperties - Controls mutability of digital asset's properties. Defaults to true.
-     * @param args.mutableTokenUri - Controls mutability of the digital asset's URI. Defaults to true.
-     * @param args.tokensBurnableByCreator - Controls whether digital assets can be burnable by the creator. Defaults to true.
-     * @param args.tokensFreezableByCreator - Controls whether digital assets can be frozen by the creator. Defaults to true.
-     * @param args.royaltyNumerator - The numerator of the royalty to be paid to the creator when a digital asset is transferred.
-     * Defaults to 0.
-     * @param args.royaltyDenominator - The denominator of the royalty to be paid to the creator when a digital asset is
-     * transferred. Defaults to 1.
-     *
-     * @returns A SimpleTransaction that when submitted will create the collection.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Creating a new collection transaction
-     *   const transaction = await aptos.createCollectionTransaction({
-     *     creator: Account.generate(), // Replace with a real account
-     *     description: "A unique collection of digital assets.",
-     *     name: "My Digital Collection",
-     *     uri: "https://mycollection.com",
-     *   });
-     *
-     *   console.log("Transaction created:", transaction);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    createCollectionTransaction(args: {
-        creator: Account$1;
-        description: string;
-        name: string;
-        uri: string;
-        options?: InputGenerateTransactionOptions;
-    } & CreateCollectionOptions): Promise<SimpleTransaction>;
-    /**
-     * Create a transaction to mint a digital asset into the creator's account within an existing collection.
-     * This function helps you generate a transaction that can be simulated or submitted to the blockchain for minting a digital asset.
-     *
-     * @param args.creator - The creator of the collection.
-     * @param args.collection - The name of the collection the digital asset belongs to.
-     * @param args.description - The description of the digital asset.
-     * @param args.name - The name of the digital asset.
-     * @param args.uri - The URI to additional info about the digital asset.
-     * @param args.propertyKeys - Optional array of property keys for the digital asset.
-     * @param args.propertyTypes - Optional array of property types for the digital asset.
-     * @param args.propertyValues - Optional array of property values for the digital asset.
-     * @param args.options - Optional transaction generation options.
-     *
-     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Creating a transaction to mint a digital asset
-     *   const transaction = await aptos.mintDigitalAssetTransaction({
-     *     creator: Account.generate(), // replace with a real account
-     *     collection: "MyCollection",
-     *     description: "This is a digital asset.",
-     *     name: "MyDigitalAsset",
-     *     uri: "https://example.com/my-digital-asset",
-     *   });
-     *
-     *   console.log(transaction);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    mintDigitalAssetTransaction(args: {
-        creator: Account$1;
-        collection: string;
-        description: string;
-        name: string;
-        uri: string;
-        propertyKeys?: Array<string>;
-        propertyTypes?: Array<PropertyType>;
-        propertyValues?: Array<PropertyValue>;
-        options?: InputGenerateTransactionOptions;
-    }): Promise<SimpleTransaction>;
-    /**
-     * Transfer ownership of a non-fungible digital asset.
-     * This function allows you to transfer a digital asset only if it is not frozen, meaning the ownership transfer is not disabled.
-     *
-     * @param args The arguments for transferring the digital asset.
-     * @param args.sender The sender account of the current digital asset owner.
-     * @param args.digitalAssetAddress The address of the digital asset being transferred.
-     * @param args.recipient The account address of the recipient.
-     * @param args.digitalAssetType Optional. The type of the digital asset, defaults to "0x4::token::Token".
-     * @param args.options Optional. Additional options for generating the transaction.
-     *
-     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Transfer a digital asset
-     *   const transaction = await aptos.transferDigitalAssetTransaction({
-     *     sender: Account.generate(), // replace with a real sender account
-     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
-     *     recipient: "0x456", // replace with a real recipient account address
-     *   });
-     *
-     *   console.log(transaction);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    transferDigitalAssetTransaction(args: {
-        sender: Account$1;
-        digitalAssetAddress: AccountAddressInput;
-        recipient: AccountAddress;
-        digitalAssetType?: MoveStructId;
-        options?: InputGenerateTransactionOptions;
-    }): Promise<SimpleTransaction>;
-    /**
-     * Mint a soul bound digital asset into a recipient's account.
-     * This function allows you to create a unique digital asset that is bound to a specific account.
-     *
-     * @param args - The arguments for minting the soul bound transaction.
-     * @param args.account - The account that mints the digital asset.
-     * @param args.collection - The collection name that the digital asset belongs to.
-     * @param args.description - The digital asset description.
-     * @param args.name - The digital asset name.
-     * @param args.uri - The digital asset URL.
-     * @param args.recipient - The account address where the digital asset will be created.
-     * @param args.propertyKeys - The property keys for storing on-chain properties.
-     * @param args.propertyTypes - The type of property values.
-     * @param args.propertyValues - The property values to be stored on-chain.
-     * @param args.options - Additional options for generating the transaction.
-     *
-     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Mint a soul bound digital asset
-     *   const transaction = await aptos.mintSoulBoundTransaction({
-     *     account: Account.generate(), // Replace with a real account
-     *     collection: "collectionName",
-     *     description: "collectionDescription",
-     *     name: "digitalAssetName",
-     *     uri: "digital-asset-uri.com",
-     *     recipient: "0x123" // Replace with a real recipient account address
-     *   });
-     *
-     *   console.log(transaction);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    mintSoulBoundTransaction(args: {
-        account: Account$1;
-        collection: string;
-        description: string;
-        name: string;
-        uri: string;
-        recipient: AccountAddressInput;
-        propertyKeys?: Array<string>;
-        propertyTypes?: Array<PropertyType>;
-        propertyValues?: Array<PropertyValue>;
-        options?: InputGenerateTransactionOptions;
-    }): Promise<SimpleTransaction>;
-    /**
-     * Burn a digital asset by its creator, allowing for the removal of a specified digital asset from the blockchain.
-     *
-     * @param args The arguments for burning the digital asset.
-     * @param args.creator The creator account that is burning the digital asset.
-     * @param args.digitalAssetAddress The address of the digital asset to be burned.
-     * @param args.digitalAssetType Optional. The type of the digital asset being burned.
-     * @param args.options Optional. Additional options for generating the transaction.
-     *
-     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network, Account } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   const creator = Account.generate(); // Replace with a real creator account
-     *   const transaction = await aptos.burnDigitalAssetTransaction({
-     *     creator: creator,
-     *     digitalAssetAddress: "0x123", // Replace with a real digital asset address
-     *   });
-     *
-     *   console.log(transaction);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    burnDigitalAssetTransaction(args: {
-        creator: Account$1;
-        digitalAssetAddress: AccountAddressInput;
-        digitalAssetType?: MoveStructId;
-        options?: InputGenerateTransactionOptions;
-    }): Promise<SimpleTransaction>;
-    /**
-     * Freeze the ability to transfer a specified digital asset.
-     * This function allows the creator to restrict the transfer capability of a digital asset.
-     *
-     * @param args The arguments for freezing the digital asset transfer.
-     * @param args.creator The creator account initiating the freeze.
-     * @param args.digitalAssetAddress The address of the digital asset to be frozen.
-     * @param args.digitalAssetType Optional. The type of the digital asset being frozen.
-     * @param args.options Optional. Additional options for generating the transaction.
-     *
-     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Freeze the digital asset transfer
-     *   const transaction = await aptos.freezeDigitalAssetTransaferTransaction({
-     *     creator: Account.generate(), // Replace with a real account if needed
-     *     digitalAssetAddress: "0x123", // Replace with a real digital asset address
-     *   });
-     *
-     *   console.log(transaction);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    freezeDigitalAssetTransaferTransaction(args: {
-        creator: Account$1;
-        digitalAssetAddress: AccountAddressInput;
-        digitalAssetType?: MoveStructId;
-        options?: InputGenerateTransactionOptions;
-    }): Promise<SimpleTransaction>;
-    /**
-     * Unfreeze the ability to transfer a digital asset.
-     * This function allows the specified creator account to unfreeze the transfer of a digital asset identified by its address.
-     *
-     * @param args The parameters for unfreezing the digital asset transfer.
-     * @param args.creator The creator account that is unfreezing the digital asset transfer.
-     * @param args.digitalAssetAddress The address of the digital asset to unfreeze.
-     * @param args.digitalAssetType Optional. The type of the digital asset being unfrozen.
-     * @param args.options Optional. Additional options for generating the transaction.
-     *
-     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Unfreeze the ability to transfer a digital asset
-     *   const transaction = await aptos.unfreezeDigitalAssetTransaferTransaction({
-     *     creator: Account.generate(), // replace with a real creator account
-     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
-     *   });
-     *
-     *   console.log(transaction);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    unfreezeDigitalAssetTransaferTransaction(args: {
-        creator: Account$1;
-        digitalAssetAddress: AccountAddressInput;
-        digitalAssetType?: MoveStructId;
-        options?: InputGenerateTransactionOptions;
-    }): Promise<SimpleTransaction>;
-    /**
-     * Set the digital asset description to provide additional context or information about the asset.
-     *
-     * @param args The parameters for setting the digital asset description.
-     * @param args.creator The creator account responsible for the digital asset.
-     * @param args.description The digital asset description to be set.
-     * @param args.digitalAssetAddress The address of the digital asset.
-     * @param args.digitalAssetType Optional. The type of the digital asset.
-     * @param args.options Optional. Additional options for generating the transaction.
-     *
-     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Set the digital asset description
-     *   const transaction = await aptos.setDigitalAssetDescriptionTransaction({
-     *     creator: Account.generate(), // replace with a real account
-     *     description: "This is a digital asset description.",
-     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
-     *   });
-     *
-     *   console.log(transaction);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    setDigitalAssetDescriptionTransaction(args: {
-        creator: Account$1;
-        description: string;
-        digitalAssetAddress: AccountAddressInput;
-        digitalAssetType?: MoveStructId;
-        options?: InputGenerateTransactionOptions;
-    }): Promise<SimpleTransaction>;
-    /**
-     * Set the digital asset name, allowing you to define a name for a specific digital asset on the blockchain.
-     *
-     * @param args The parameters for setting the digital asset name.
-     * @param args.creator The creator account responsible for the transaction.
-     * @param args.name The desired name for the digital asset.
-     * @param args.digitalAssetAddress The address of the digital asset.
-     * @param args.digitalAssetType Optional. The type of the digital asset, represented as a Move struct ID.
-     * @param args.options Optional. Additional options for generating the transaction.
-     *
-     * @returns A SimpleTransaction that can be simulated or submitted to the blockchain.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network, Account } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   const creator = Account.generate(); // Generate a new account for the creator
-     *   const digitalAssetAddress = "0x123"; // replace with a real digital asset address
-     *
-     *   // Set the digital asset name
-     *   const transaction = await aptos.setDigitalAssetNameTransaction({
-     *     creator: creator,
-     *     name: "digitalAssetName",
-     *     digitalAssetAddress: digitalAssetAddress,
-     *   });
-     *
-     *   console.log(transaction);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    setDigitalAssetNameTransaction(args: {
-        creator: Account$1;
-        name: string;
-        digitalAssetAddress: AccountAddressInput;
-        digitalAssetType?: MoveStructId;
-        options?: InputGenerateTransactionOptions;
-    }): Promise<SimpleTransaction>;
-    /**
-     * Set the URI for a digital asset, allowing you to associate a unique identifier with the asset.
-     *
-     * @param args The parameters for the transaction.
-     * @param args.creator The creator account initiating the transaction.
-     * @param args.uri The digital asset URI to be set.
-     * @param args.digitalAssetAddress The address of the digital asset.
-     * @param args.digitalAssetType Optional. The type of the digital asset.
-     * @param args.options Optional. Additional options for generating the transaction.
-     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Set the URI for a digital asset
-     *   const transaction = await aptos.setDigitalAssetURITransaction({
-     *     creator: Account.generate(), // Replace with a real creator account
-     *     uri: "digital-asset-uri.com",
-     *     digitalAssetAddress: "0x123", // Replace with a real digital asset address
-     *   });
-     *
-     *   console.log(transaction);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    setDigitalAssetURITransaction(args: {
-        creator: Account$1;
-        uri: string;
-        digitalAssetAddress: AccountAddressInput;
-        digitalAssetType?: MoveStructId;
-        options?: InputGenerateTransactionOptions;
-    }): Promise<SimpleTransaction>;
-    /**
-     * Add a digital asset property to the blockchain.
-     * This function allows you to specify a new property for a digital asset, including its key, type, and value.
-     *
-     * @param args - The arguments for adding a digital asset property.
-     * @param args.creator - The account that mints the digital asset.
-     * @param args.propertyKey - The property key for storing on-chain properties.
-     * @param args.propertyType - The type of property value.
-     * @param args.propertyValue - The property value to be stored on-chain.
-     * @param args.digitalAssetAddress - The digital asset address.
-     * @param args.digitalAssetType - (Optional) The type of the digital asset.
-     * @param args.options - (Optional) Options for generating the transaction.
-     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Add a digital asset property
-     *   const transaction = await aptos.addDigitalAssetPropertyTransaction({
-     *     creator: Account.generate(), // Replace with a real account
-     *     propertyKey: "newKey",
-     *     propertyType: "BOOLEAN",
-     *     propertyValue: true,
-     *     digitalAssetAddress: "0x123", // Replace with a real digital asset address
-     *   });
-     *
-     *   console.log(transaction);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    addDigitalAssetPropertyTransaction(args: {
-        creator: Account$1;
-        propertyKey: string;
-        propertyType: PropertyType;
-        propertyValue: PropertyValue;
-        digitalAssetAddress: AccountAddressInput;
-        digitalAssetType?: MoveStructId;
-        options?: InputGenerateTransactionOptions;
-    }): Promise<SimpleTransaction>;
-    /**
-     * Remove a digital asset property from the blockchain.
-     * This function allows you to delete an existing property associated with a digital asset.
-     *
-     * @param args The parameters required to remove the digital asset property.
-     * @param args.creator The account that mints the digital asset.
-     * @param args.propertyKey The property key for storing on-chain properties.
-     * @param args.propertyType The type of property value.
-     * @param args.propertyValue The property value to be stored on-chain.
-     * @param args.digitalAssetAddress The digital asset address.
-     * @param args.digitalAssetType Optional. The type of the digital asset.
-     * @param args.options Optional. Additional options for generating the transaction.
-     *
-     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Remove a digital asset property
-     *   const transaction = await aptos.removeDigitalAssetPropertyTransaction({
-     *     creator: Account.generate(), // replace with a real account
-     *     propertyKey: "newKey",
-     *     propertyType: "BOOLEAN",
-     *     propertyValue: true,
-     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
-     *   });
-     *
-     *   console.log(transaction);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    removeDigitalAssetPropertyTransaction(args: {
-        creator: Account$1;
-        propertyKey: string;
-        propertyType: PropertyType;
-        propertyValue: PropertyValue;
-        digitalAssetAddress: AccountAddressInput;
-        digitalAssetType?: MoveStructId;
-        options?: InputGenerateTransactionOptions;
-    }): Promise<SimpleTransaction>;
-    /**
-     * Update a digital asset property on-chain.
-     *
-     * @param args The parameters for updating the digital asset property.
-     * @param args.creator The account that mints the digital asset.
-     * @param args.digitalAssetAddress The address of the digital asset.
-     * @param args.propertyKey The property key for storing on-chain properties.
-     * @param args.propertyType The type of property value.
-     * @param args.propertyValue The property value to be stored on-chain.
-     * @param args.digitalAssetType Optional. The type of the digital asset.
-     * @param args.options Optional. Additional options for generating the transaction.
-     *
-     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Update a digital asset property
-     *   const transaction = await aptos.updateDigitalAssetPropertyTransaction({
-     *     creator: Account.generate(), // replace with a real account
-     *     propertyKey: "newKey",
-     *     propertyType: "BOOLEAN",
-     *     propertyValue: false,
-     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
-     *   });
-     *
-     *   console.log(transaction);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    updateDigitalAssetPropertyTransaction(args: {
-        creator: Account$1;
-        propertyKey: string;
-        propertyType: PropertyType;
-        propertyValue: PropertyValue;
-        digitalAssetAddress: AccountAddressInput;
-        digitalAssetType?: MoveStructId;
-        options?: InputGenerateTransactionOptions;
-    }): Promise<SimpleTransaction>;
-    /**
-     * Add a typed digital asset property to the blockchain.
-     * This function allows you to define and store a specific property for a digital asset, enabling better categorization and
-     * management of digital assets.
-     *
-     * @param args - The parameters for adding the typed property.
-     * @param args.creator - The account that mints the digital asset.
-     * @param args.propertyKey - The property key for storing on-chain properties.
-     * @param args.propertyType - The type of property value.
-     * @param args.propertyValue - The property value to be stored on-chain.
-     * @param args.digitalAssetAddress - The digital asset address.
-     * @param args.digitalAssetType - The optional type of the digital asset.
-     * @param args.options - Optional transaction generation options.
-     *
-     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Adding a typed digital asset property
-     *   const transaction = await aptos.addDigitalAssetTypedPropertyTransaction({
-     *     creator: Account.generate(), // replace with a real account
-     *     propertyKey: "typedKey",
-     *     propertyType: "STRING",
-     *     propertyValue: "hello",
-     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
-     *   });
-     *
-     *   console.log(transaction);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    addDigitalAssetTypedPropertyTransaction(args: {
-        creator: Account$1;
-        propertyKey: string;
-        propertyType: PropertyType;
-        propertyValue: PropertyValue;
-        digitalAssetAddress: AccountAddressInput;
-        digitalAssetType?: MoveStructId;
-        options?: InputGenerateTransactionOptions;
-    }): Promise<SimpleTransaction>;
-    /**
-     * Update a typed digital asset property on-chain.
-     * This function allows you to modify the properties of a digital asset, enabling dynamic updates to its attributes.
-     *
-     * @param args - The arguments for updating the digital asset property.
-     * @param args.creator - The account that mints the digital asset.
-     * @param args.propertyKey - The property key for storing on-chain properties.
-     * @param args.propertyType - The type of property value.
-     * @param args.propertyValue - The property value to be stored on-chain.
-     * @param args.digitalAssetAddress - The digital asset address.
-     * @param args.digitalAssetType - (Optional) The type of the digital asset.
-     * @param args.options - (Optional) Additional options for generating the transaction.
-     *
-     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Update a typed digital asset property
-     *   const transaction = await aptos.updateDigitalAssetTypedPropertyTransaction({
-     *     creator: Account.generate(), // replace with a real account
-     *     propertyKey: "typedKey",
-     *     propertyType: "U8",
-     *     propertyValue: 2,
-     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
-     *   });
-     *
-     *   console.log(transaction);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group DigitalAsset
-     */
-    updateDigitalAssetTypedPropertyTransaction(args: {
-        creator: Account$1;
-        propertyKey: string;
-        propertyType: PropertyType;
-        propertyValue: PropertyValue;
-        digitalAssetAddress: AccountAddressInput;
-        digitalAssetType?: MoveStructId;
-        options?: InputGenerateTransactionOptions;
-    }): Promise<SimpleTransaction>;
-}
-
-/**
- * A class to query all `Event` Aptos related queries.
- * @group Event
- */
-declare class Event {
-    readonly config: AptosConfig;
-    /**
-     * Initializes a new instance of the Aptos client with the provided configuration.
-     *
-     * @param config - The configuration settings for the Aptos client.
-     * @param config.network - The network to connect to (e.g., Testnet, Mainnet).
-     * @param config.nodeUrl - The URL of the Aptos node to connect to.
-     * @param config.faucetUrl - The URL of the faucet to use for funding accounts.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * async function runExample() {
-     *     // Create a new Aptos client with Testnet configuration
-     *     const config = new AptosConfig({ network: Network.TESTNET }); // Specify your own network if needed
-     *     const aptos = new Aptos(config);
-     *
-     *     console.log("Aptos client initialized:", aptos);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Event
-     */
-    constructor(config: AptosConfig);
-    /**
-     * Retrieve module events based on a specified event type.
-     * This function allows you to query for events that are associated with a particular module event type in the Aptos blockchain.
-     *
-     * @param args - The arguments for retrieving module events.
-     * @param args.eventType - The event type to filter the results.
-     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
-     * @param args.options - Optional pagination and ordering parameters for the event results.
-     *
-     * @returns Promise<GetEventsResponse> - A promise that resolves to the retrieved events.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Retrieve module events for a specific event type
-     *   const events = await aptos.getModuleEventsByEventType({
-     *     eventType: "0x1::transaction_fee::FeeStatement", // specify the event type
-     *     minimumLedgerVersion: 1, // optional: specify minimum ledger version if needed
-     *   });
-     *
-     *   console.log(events); // log the retrieved events
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Event
-     */
-    getModuleEventsByEventType(args: {
-        eventType: MoveStructId;
-        minimumLedgerVersion?: AnyNumber;
-        options?: PaginationArgs & OrderByArg<GetEventsResponse[0]>;
-    }): Promise<GetEventsResponse>;
-    /**
-     * Retrieve events associated with a specific account address and creation number.
-     *
-     * @param args - The parameters for retrieving account events.
-     * @param args.accountAddress - The account address to query events for.
-     * @param args.creationNumber - The event creation number to filter the events.
-     * @param args.minimumLedgerVersion - Optional minimum ledger version to sync up to before querying.
-     *
-     * @returns Promise<GetEventsResponse>
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Get events for the account at creation number 0
-     *   const events = await aptos.getAccountEventsByCreationNumber({
-     *     accountAddress: "0x1", // replace with a real account address
-     *     creationNumber: 0,
-     *   });
-     *
-     *   console.log(events);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Event
-     */
-    getAccountEventsByCreationNumber(args: {
-        accountAddress: AccountAddressInput;
-        creationNumber: AnyNumber;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<GetEventsResponse>;
-    /**
-     * Retrieve events associated with a specific account address and event type.
-     *
-     * @param args.accountAddress - The account address to query events for.
-     * @param args.eventType - The type of event to filter by.
-     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
-     * @param args.options - Optional pagination and ordering parameters for the event query.
-     *
-     * @returns Promise<GetEventsResponse>
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Get events for a specific account and event type
-     *   const events = await aptos.getAccountEventsByEventType({
-     *     accountAddress: "0x1", // replace with a real account address
-     *     eventType: "0x1::transaction_fee::FeeStatement", // replace with a real event type
-     *     minimumLedgerVersion: 1, // optional, specify if needed
-     *   });
-     *
-     *   console.log(events);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Event
-     */
-    getAccountEventsByEventType(args: {
-        accountAddress: AccountAddressInput;
-        eventType: MoveStructId;
-        minimumLedgerVersion?: AnyNumber;
-        options?: PaginationArgs & OrderByArg<GetEventsResponse[0]>;
-    }): Promise<GetEventsResponse>;
-    /**
-     * Retrieve all events from the Aptos blockchain.
-     * An optional `where` clause can be provided to filter the results based on specific criteria.
-     *
-     * @param args Optional parameters for the query.
-     * @param args.minimumLedgerVersion Optional ledger version to sync up to before querying.
-     * @param args.options Optional pagination and filtering options.
-     * @param args.options.where Optional condition to filter events.
-     * @param args.options.offset Optional pagination offset.
-     * @param args.options.limit Optional maximum number of events to return.
-     * @param args.options.orderBy Optional ordering of the results.
-     *
-     * @returns GetEventsQuery response type containing the events.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Retrieve all events
-     *   const events = await aptos.getEvents();
-     *
-     *   // Retrieve events with filtering by account address
-     *   const whereCondition = {
-     *     account_address: { _eq: "0x123" }, // replace with a real account address
-     *   };
-     *   const filteredEvents = await aptos.getEvents({
-     *     options: { where: whereCondition },
-     *   });
-     *
-     *   console.log(events);
-     *   console.log(filteredEvents);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Event
-     */
-    getEvents(args?: {
-        minimumLedgerVersion?: AnyNumber;
-        options?: PaginationArgs & OrderByArg<GetEventsResponse[0]> & WhereArg<EventsBoolExp>;
-    }): Promise<GetEventsResponse>;
-}
-
-/**
- * A class to query all `Faucet` related queries on Aptos.
- * @group Faucet
- */
-declare class Faucet {
-    readonly config: AptosConfig;
-    /**
-     * Initializes a new instance of the Aptos client with the specified configuration.
-     *
-     * Note that only devnet has a publicly accessible faucet. For testnet, you must use
-     * the minting page at https://aptos.dev/network/faucet.
-     *
-     * @param config - The configuration settings for the Aptos client.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * async function runExample() {
-     *     // Create a configuration for the Aptos client
-     *     const config = new AptosConfig({ network: Network.DEVNET }); // specify your own network if needed
-     *
-     *     // Initialize the Aptos client with the configuration
-     *     const aptos = new Aptos(config);
-     *
-     *     console.log("Aptos client initialized:", aptos);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Faucet
-     */
-    constructor(config: AptosConfig);
-    /**
-     * This function creates an account if it does not exist and mints the specified amount of coins into that account.
-     *
-     * Note that only devnet has a publicly accessible faucet. For testnet, you must use
-     * the minting page at https://aptos.dev/network/faucet.
-     *
-     * @param args - The arguments for funding the account.
-     * @param args.accountAddress - The address of the account to fund.
-     * @param args.amount - The amount of tokens to fund the account with.
-     * @param args.options - Configuration options for waiting for the transaction.
-     * @returns Transaction hash of the transaction that funded the account.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.DEVNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Fund an account with a specified amount of tokens
-     *   const transaction = await aptos.fundAccount({
-     *     accountAddress: "0x1", // replace with your account address
-     *     amount: 100,
-     *   });
-     *
-     *   console.log("Transaction hash:", transaction.hash);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Faucet
-     */
-    fundAccount(args: {
-        accountAddress: AccountAddressInput;
-        amount: number;
-        options?: WaitForTransactionOptions;
-    }): Promise<UserTransactionResponse>;
+    setSigner(signer: (digest: HexInput) => HexInput): void;
 }
 
 /**
@@ -9048,21 +7060,6 @@ declare function throwTypeMismatch(expectedType: string, position: number): void
  * @category Transactions
  */
 declare function findFirstNonSignerArg(functionAbi: MoveFunction): number;
-/**
- * Splits a function identifier into its constituent parts: module address, module name, and function name.
- * This function helps in validating and extracting details from a function identifier string.
- *
- * @param functionArg - The function identifier string in the format "moduleAddress::moduleName::functionName".
- * @returns An object containing the module address, module name, and function name.
- * @throws Error if the function identifier does not contain exactly three parts.
- * @group Implementation
- * @category Transactions
- */
-declare function getFunctionParts(functionArg: MoveFunctionId): {
-    moduleAddress: string;
-    moduleName: string;
-    functionName: string;
-};
 
 /**
  * Builds a transaction payload based on the provided arguments and returns a transaction payload.
@@ -9302,178 +7299,2419 @@ declare function fetchEntryFunctionAbi(moduleAddress: string, moduleName: string
  * @group Implementation
  * @category Transactions
  */
-declare function fetchViewFunctionAbi(moduleAddress: string, moduleName: string, functionName: string, aptosConfig: AptosConfig): Promise<ViewFunctionABI>;
+declare function fetchViewFunctionAbi(moduleAddress: string, moduleName: string, functionName: string, aptosConfig: AptosConfig): Promise<ViewFunctionABI>;
+/**
+ * Converts a entry function argument into CallArgument, if necessary.
+ * This function checks the provided argument against the expected parameter type and converts it accordingly.
+ *
+ * @param functionName - The name of the function for which the argument is being converted.
+ * @param functionAbi - The ABI (Application Binary Interface) of the function, which defines its parameters.
+ * @param argument - The argument to be converted, which can be of various types. If the argument is already
+ *                   CallArgument returned from TransactionComposer it would be returned immediately.
+ * @param position - The index of the argument in the function's parameter list.
+ * @param genericTypeParams - An array of type tags for any generic type parameters.
+ */
+declare function convertCallArgument(argument: CallArgument | EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes, functionName: string, functionAbi: FunctionABI, position: number, genericTypeParams: Array<TypeTag>): CallArgument;
+/**
+ * Converts a non-BCS encoded argument into BCS encoded, if necessary.
+ * This function checks the provided argument against the expected parameter type and converts it accordingly.
+ *
+ * @param functionName - The name of the function for which the argument is being converted.
+ * @param functionAbi - The ABI (Application Binary Interface) of the function, which defines its parameters.
+ * @param arg - The argument to be converted, which can be of various types.
+ * @param position - The index of the argument in the function's parameter list.
+ * @param genericTypeParams - An array of type tags for any generic type parameters.
+ * @group Implementation
+ * @category Transactions
+ */
+declare function convertArgument(functionName: string, functionAbi: FunctionABI, arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes, position: number, genericTypeParams: Array<TypeTag>): EntryFunctionArgumentTypes;
+/**
+ * Checks if the provided argument is BCS encoded and converts it if necessary, ensuring type compatibility with the ABI.
+ * This function helps in validating and converting arguments for entry functions based on their expected types.
+ *
+ * @param arg - The argument to check or convert, which can be either a simple or entry function argument type.
+ * @param param - The expected type tag for the argument.
+ * @param position - The position of the argument in the function call.
+ * @param genericTypeParams - An array of generic type parameters that may be used for conversion.
+ * @group Implementation
+ * @category Transactions
+ */
+declare function checkOrConvertArgument(arg: SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes, param: TypeTag, position: number, genericTypeParams: Array<TypeTag>): EntryFunctionArgumentTypes;
+
+/**
+ * Derives the appropriate raw transaction type based on the provided transaction details.
+ * This function helps in identifying whether the transaction is a FeePayerRawTransaction,
+ * MultiAgentRawTransaction, or a standard RawTransaction.
+ *
+ * @param transaction - An object representing an Aptos transaction, which may include:
+ *   - feePayerAddress - The address of the fee payer (optional).
+ *   - secondarySignerAddresses - An array of secondary signer addresses (optional).
+ *   - rawTransaction - The raw transaction data.
+ *
+ * @returns FeePayerRawTransaction | MultiAgentRawTransaction | RawTransaction
+ * @group Implementation
+ * @category Transactions
+ */
+declare function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTransactionInstance;
+/**
+ * Generates the 'signing message' form of a message to be signed.
+ * This function combines a domain separator with the byte representation of the message to create a signing message.
+ *
+ * @param bytes - The byte representation of the message to be signed and sent to the chain.
+ * @param domainSeparator - A domain separator that starts with 'APTOS::'.
+ *
+ * @returns The Uint8Array of the signing message.
+ * @group Implementation
+ * @category Transactions
+ */
+declare function generateSigningMessage(bytes: Uint8Array, domainSeparator: string): Uint8Array;
+/**
+ * @deprecated
+ * Use CryptoHashable instead by having your class implement it and call hash() to get the signing message.
+ *
+ * Generates the 'signing message' form of a serializable value by serializing it and using the constructor name as the domain
+ * separator.
+ *
+ * @param serializable - An object that has a BCS serialized form.
+ *
+ * @returns The Uint8Array of the signing message.
+ * @group Implementation
+ * @category Transactions
+ */
+declare function generateSigningMessageForSerializable(serializable: Serializable): Uint8Array;
+/**
+ * Generates the 'signing message' form of a transaction by deriving the type of transaction and applying the appropriate domain
+ * separator based on the presence of a fee payer or secondary signers.
+ *
+ * @param transaction - A transaction that is to be signed, which can include a fee payer address or secondary signer addresses.
+ *
+ * @returns The Uint8Array of the signing message.
+ * @group Implementation
+ * @category Transactions
+ */
+declare function generateSigningMessageForTransaction(transaction: AnyRawTransaction): Uint8Array;
+
+/**
+ * Error types related to parsing type tags, indicating various issues encountered during the parsing process.
+ * @group Implementation
+ * @category Transactions
+ */
+declare enum TypeTagParserErrorType {
+    InvalidTypeTag = "unknown type",
+    UnexpectedGenericType = "unexpected generic type",
+    UnexpectedTypeArgumentClose = "unexpected '>'",
+    UnexpectedWhitespaceCharacter = "unexpected whitespace character",
+    UnexpectedComma = "unexpected ','",
+    TypeArgumentCountMismatch = "type argument count doesn't match expected amount",
+    MissingTypeArgumentClose = "no matching '>' for '<'",
+    MissingTypeArgument = "no type argument before ','",
+    UnexpectedPrimitiveTypeArguments = "primitive types not expected to have type arguments",
+    UnexpectedVectorTypeArgumentCount = "vector type expected to have exactly one type argument",
+    UnexpectedStructFormat = "unexpected struct format, must be of the form 0xaddress::module_name::struct_name",
+    InvalidModuleNameCharacter = "module name must only contain alphanumeric or '_' characters",
+    InvalidStructNameCharacter = "struct name must only contain alphanumeric or '_' characters",
+    InvalidAddress = "struct address must be valid"
+}
+/**
+ * Represents an error that occurs during the parsing of a type tag.
+ * This error extends the built-in Error class and provides additional context
+ * regarding the specific type tag that failed to parse and the reason for the failure.
+ *
+ * @param typeTagStr - The type tag string that failed to be parsed.
+ * @param invalidReason - The reason why the type tag string is considered invalid.
+ * @group Implementation
+ * @category Transactions
+ */
+declare class TypeTagParserError extends Error {
+    /**
+     * Constructs an error indicating a failure to parse a type tag.
+     * This error provides details about the specific type tag that could not be parsed and the reason for the failure.
+     *
+     * @param typeTagStr - The string representation of the type tag that failed to parse.
+     * @param invalidReason - The reason why the type tag is considered invalid.
+     * @group Implementation
+     * @category Transactions
+     */
+    constructor(typeTagStr: string, invalidReason: TypeTagParserErrorType);
+}
 /**
- * Converts a entry function argument into CallArgument, if necessary.
- * This function checks the provided argument against the expected parameter type and converts it accordingly.
+ * Parses a type string into a structured representation of type tags, accommodating various formats including generics and
+ * nested types.
  *
- * @param functionName - The name of the function for which the argument is being converted.
- * @param functionAbi - The ABI (Application Binary Interface) of the function, which defines its parameters.
- * @param argument - The argument to be converted, which can be of various types. If the argument is already
- *                   CallArgument returned from TransactionComposer it would be returned immediately.
- * @param position - The index of the argument in the function's parameter list.
- * @param genericTypeParams - An array of type tags for any generic type parameters.
- */
-declare function convertCallArgument(argument: CallArgument | EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes, functionName: string, functionAbi: FunctionABI, position: number, genericTypeParams: Array<TypeTag>): CallArgument;
-/**
- * Converts a non-BCS encoded argument into BCS encoded, if necessary.
- * This function checks the provided argument against the expected parameter type and converts it accordingly.
+ * This function can help you accurately interpret type strings, which can include simple types, standalone structs, and complex
+ * nested generics.
+ * It supports multiple generics, spacing within generics, and nested generics of varying depths.
+ * All types are made of a few parts they're either:
+ * 1. A simple type e.g. u8
+ * 2. A standalone struct e.g. 0x1::account::Account
+ * 3. A nested struct e.g. 0x1::coin::Coin<0x1234::coin::MyCoin>
  *
- * @param functionName - The name of the function for which the argument is being converted.
- * @param functionAbi - The ABI (Application Binary Interface) of the function, which defines its parameters.
- * @param arg - The argument to be converted, which can be of various types.
- * @param position - The index of the argument in the function's parameter list.
- * @param genericTypeParams - An array of type tags for any generic type parameters.
+ * There are a few more special cases that need to be handled, however.
+ * 1. Multiple generics e.g. 0x1::pair::Pair<u8, u16>
+ * 2. Spacing in the generics e.g. 0x1::pair::Pair< u8 , u16>
+ * 3. Nested generics of different depths e.g. 0x1::pair::Pair<0x1::coin::Coin<0x1234::coin::MyCoin>, u8>
+ * 4. Generics for types in ABIs are filled in with placeholders e.g. T1, T2, T3
+ * @param typeStr - The string representation of the type to be parsed.
+ * @param options - Optional settings for parsing behavior.
+ * @param options.allowGenerics - A flag indicating whether to allow generics in the parsing process.
+ * @returns The parsed type tag representation.
+ * @throws TypeTagParserError if the type string is malformed or does not conform to expected formats.
  * @group Implementation
  * @category Transactions
  */
-declare function convertArgument(functionName: string, functionAbi: FunctionABI, arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes, position: number, genericTypeParams: Array<TypeTag>): EntryFunctionArgumentTypes;
+declare function parseTypeTag(typeStr: string, options?: {
+    allowGenerics?: boolean;
+}): TypeTag;
+
+/**
+ * A wrapper class around TransactionComposer, which is a WASM library compiled
+ * from aptos-core/aptos-move/script-composer.
+ * This class allows the SDK caller to build a transaction that invokes multiple Move functions
+ * and allow for arguments to be passed around.
+ * */
+declare class AptosScriptComposer {
+    private config;
+    private builder?;
+    private static transactionComposer?;
+    constructor(aptosConfig: AptosConfig);
+    init(): Promise<void>;
+    addBatchedCalls(input: InputBatchedFunctionData): Promise<CallArgument[]>;
+    build(): Uint8Array;
+}
+
+declare class AccountAbstraction {
+    readonly config: AptosConfig;
+    constructor(config: AptosConfig);
+    /**
+     * Adds a dispatchable authentication function to the account.
+     *
+     * @example
+     * ```ts
+     * const txn = await aptos.abstraction.addAuthenticationFunctionTransaction({
+     *   accountAddress: alice.accountAddress,
+     *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,
+     * });
+     *
+     * const txn =  await aptos.signAndSubmitTransaction({ signer: alice, transaction});
+     * await aptos.waitForTransaction({ transactionHash: txn.hash });
+     * ```
+     *
+     * @param args.accountAddress - The account to add the authentication function to.
+     * @param args.authenticationFunction - The authentication function info to add.
+     * @param args.options - The options for the transaction.
+     * @returns A transaction to add the authentication function to the account.
+     */
+    addAuthenticationFunctionTransaction(args: {
+        accountAddress: AccountAddressInput;
+        authenticationFunction: string;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SimpleTransaction>;
+    /**
+     * Removes a dispatchable authentication function from the account.
+     *
+     * @example
+     * ```ts
+     * const txn = await aptos.abstraction.removeAuthenticationFunctionTransaction({
+     *   accountAddress: alice.accountAddress,
+     *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,
+     * });
+     *
+     * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });
+     * await aptos.waitForTransaction({ transactionHash: txn.hash });
+     * ```
+     *
+     * @param args.accountAddress - The account to remove the authentication function from.
+     * @param args.authenticationFunction - The authentication function info to remove.
+     * @param args.options - The options for the transaction.
+     * @returns A transaction to remove the authentication function from the account.
+     */
+    removeAuthenticationFunctionTransaction(args: {
+        accountAddress: AccountAddressInput;
+        authenticationFunction: string;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SimpleTransaction>;
+    /**
+     * Removes a dispatchable authenticator from the account.
+     *
+     * @example
+     * ```ts
+     * const txn = await aptos.abstraction.removeDispatchableAuthenticatorTransaction({
+     *   accountAddress: alice.accountAddress,
+     * });
+     *
+     * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });
+     * await aptos.waitForTransaction({ transactionHash: txn.hash });
+     * ```
+     *
+     * @param args.accountAddress - The account to remove the authenticator from.
+     * @param args.options - The options for the transaction.
+     * @returns A transaction to remove the authenticator from the account.
+     */
+    removeDispatchableAuthenticatorTransaction(args: {
+        accountAddress: AccountAddressInput;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SimpleTransaction>;
+    /**
+     * Gets the dispatchable authentication function for the account.
+     *
+     * @example
+     * ```ts
+     * const functionInfos = await aptos.abstraction.getAuthenticationFunction({
+     *   accountAddress: alice.accountAddress,
+     * });
+     *
+     * if (functionInfos) {
+     *   console.log(`Account ${alice.accountAddress.toString()} is using account abstraction!`);
+     * } else {
+     *   console.log(`Account ${alice.accountAddress.toString()} is not using account abstraction.`);
+     * }
+     * ```
+     *
+     * @param args.accountAddress - The account to get the dispatchable authentication function for.
+     * @returns The dispatchable authentication function for the account.
+     */
+    getAuthenticationFunction(args: {
+        accountAddress: AccountAddressInput;
+    }): Promise<{
+        moduleAddress: AccountAddress;
+        moduleName: string;
+        functionName: string;
+    }[] | undefined>;
+    /**
+     * Will return true if the account is abstracted, otherwise false.
+     *
+     * @example
+     * ```ts
+     * const isAccountAbstractionEnabled = await aptos.abstraction.isAccountAbstractionEnabled({
+     *   accountAddress: alice.accountAddress,
+     *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,
+     * });
+     * if (isAccountAbstractionEnabled) {
+     *   console.log(`Account ${alice.accountAddress.toString()} is using account abstraction!`);
+     * } else {
+     *   console.log(`Account ${alice.accountAddress.toString()} is not using account abstraction.`);
+     * }
+     * ```
+     *
+     * @param args.accountAddress - The account to check.
+     * @returns Whether the account is abstracted.
+     */
+    isAccountAbstractionEnabled: (args: {
+        accountAddress: AccountAddressInput;
+        authenticationFunction: string;
+    }) => Promise<boolean>;
+    /**
+     * Creates a transaction to enable account abstraction with the given authentication function.
+     *
+     * @example
+     * ```ts
+     * const txn = await aptos.abstraction.enableAccountAbstractionTransaction({
+     *   accountAddress: alice.accountAddress,
+     *   authenticationFunction: `{alice.accountAddress}::any_authenticator::authenticate`,
+     * });
+     *
+     * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });
+     * await aptos.waitForTransaction({ transactionHash: txn.hash });
+     * ```
+     *
+     * @param args.accountAddress - The account to enable account abstraction for.
+     * @param args.authenticationFunction - The authentication function info to use.
+     * @param args.options - The options for the transaction.
+     * @returns A transaction to enable account abstraction for the account.
+     */
+    enableAccountAbstractionTransaction: (args: {
+        accountAddress: AccountAddressInput;
+        authenticationFunction: string;
+        options?: InputGenerateTransactionOptions;
+    }) => Promise<SimpleTransaction>;
+    /**
+     * Creates a transaction to disable account abstraction. If an authentication function is provided, it will specify to
+     * remove the authentication function.
+     *
+     * @example
+     * ```ts
+     * const txn = await aptos.abstraction.disableAccountAbstractionTransaction({
+     *   accountAddress: alice.accountAddress,
+     *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,
+     * });
+     *
+     * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });
+     * await aptos.waitForTransaction({ transactionHash: txn.hash });
+     * ```
+     *
+     * @param args.accountAddress - The account to disable account abstraction for.
+     * @param args.authenticationFunction - The authentication function info to remove.
+     * @param args.options - The options for the transaction.
+     * @returns A transaction to disable account abstraction for the account.
+     */
+    disableAccountAbstractionTransaction: (args: {
+        accountAddress: AccountAddressInput;
+        authenticationFunction?: string;
+        options?: InputGenerateTransactionOptions;
+    }) => Promise<SimpleTransaction>;
+}
+
+/**
+ * A class to query all `Account` related queries on Aptos.
+ * @group Account
+ */
+declare class Account {
+    readonly config: AptosConfig;
+    abstraction: AccountAbstraction;
+    /**
+     * Creates an instance of the Aptos client with the provided configuration.
+     *
+     * @param config - The configuration settings for the Aptos client.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * async function runExample() {
+     *     // Initialize the Aptos client with testnet configuration
+     *     const config = new AptosConfig({ network: Network.TESTNET }); // specify your own network if needed
+     *     const aptos = new Aptos(config);
+     *
+     *     console.log("Aptos client initialized:", aptos);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Account
+     */
+    constructor(config: AptosConfig);
+    /**
+     * Queries the current state for an Aptos account given its account address.
+     *
+     * @param args - The arguments for retrieving account information.
+     * @param args.accountAddress - The Aptos account address to query.
+     * @returns The account data.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *     // Retrieve account information for a specific address
+     *     const accountInfo = await aptos.getAccountInfo({ accountAddress: "0x1" }); // replace with a real account address
+     *     console.log(accountInfo);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Account
+     */
+    getAccountInfo(args: {
+        accountAddress: AccountAddressInput;
+    }): Promise<AccountData>;
+    /**
+     * Queries for all modules in an account given an account address.
+     * This function may call the API multiple times to auto paginate through results.
+     *
+     * @param args.accountAddress - The Aptos account address to query modules for.
+     * @param args.options.offset - The cursor to start returning results from.  Note, this is obfuscated and is not an index.
+     * @param args.options.limit - The maximum number of results to return.
+     * @param args.options.ledgerVersion - The ledger version to query; if not provided, it retrieves the latest version.
+     *
+     * @returns - The account modules associated with the specified address.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Fetching account modules for a specific account
+     *   const accountModules = await aptos.getAccountModules({
+     *     accountAddress: "0x1", // replace with a real account address
+     *     options: {
+     *       offset: 0, // starting from the first module
+     *       limit: 10, // limiting to 10 modules
+     *     },
+     *   });
+     *
+     *   console.log(accountModules);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Account
+     */
+    getAccountModules(args: {
+        accountAddress: AccountAddressInput;
+        options?: PaginationArgs & LedgerVersionArg;
+    }): Promise<MoveModuleBytecode[]>;
+    /**
+     * Queries for a specific account module given an account address and module name.
+     *
+     * @param args.accountAddress - The Aptos account address.
+     * @param args.moduleName - The name of the module.
+     * @param args.options.ledgerVersion - The ledger version to query; if not provided, it will get the latest version.
+     *
+     * @returns The account module associated with the specified account address and module name.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Get the account module for a specific account address and module name
+     *   const module = await aptos.getAccountModule({
+     *     accountAddress: "0x1", // replace with a real account address
+     *     moduleName: "MyModule" // specify the module name
+     *   });
+     *
+     *   console.log(module);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Account
+     */
+    getAccountModule(args: {
+        accountAddress: AccountAddressInput;
+        moduleName: string;
+        options?: LedgerVersionArg;
+    }): Promise<MoveModuleBytecode>;
+    /**
+     * Queries account transactions given an account address.
+     * This function may call the API multiple times to auto paginate and retrieve all account transactions.
+     *
+     * @param args.accountAddress - The Aptos account address to query transactions for.
+     * @param args.options - Optional pagination arguments.
+     * @param args.options.offset - The number of transactions to start returning results from.
+     * @param args.options.limit - The maximum number of results to return.
+     *
+     * @returns The account transactions.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Fetch transactions for a specific account
+     *   const transactions = await aptos.getAccountTransactions({
+     *     accountAddress: "0x1", // replace with a real account address
+     *     options: {
+     *       offset: 0, // starting from the first transaction
+     *       limit: 10, // limiting to 10 transactions
+     *     },
+     *   });
+     *
+     *   console.log(transactions);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Account
+     */
+    getAccountTransactions(args: {
+        accountAddress: AccountAddressInput;
+        options?: PaginationArgs;
+    }): Promise<TransactionResponse[]>;
+    /**
+     * Queries all account resources given an account address.
+     * This function may call the API multiple times to auto paginate through results.
+     *
+     * @param args.accountAddress - The Aptos account address to query resources for.
+     * @param args.options.offset - The cursor to start returning results from.  Note, this is obfuscated and is not an index.
+     * @param args.options.limit - The maximum number of results to return.
+     * @param args.options.ledgerVersion - The ledger version to query; if not provided, it will get the latest version.
+     * @returns Account resources.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Fetching account resources for a specific account address
+     *   const resources = await aptos.getAccountResources({ accountAddress: "0x1" }); // replace with a real account address
+     *   console.log(resources);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Account
+     */
+    getAccountResources(args: {
+        accountAddress: AccountAddressInput;
+        options?: PaginationArgs & LedgerVersionArg;
+    }): Promise<MoveResource[]>;
+    /**
+     * Queries a specific account resource given an account address and resource type.
+     *
+     * @template T - The typed output of the resource.
+     * @param args.accountAddress - The Aptos account address to query.
+     * @param args.resourceType - The string representation of an on-chain Move struct type, e.g., "0x1::aptos_coin::AptosCoin".
+     * @param args.options.ledgerVersion - The ledger version to query; if not provided, it will get the latest version.
+     * @returns The account resource of the specified type.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Get the account resource for a specific account address and resource type
+     *   const resource = await aptos.getAccountResource({
+     *     accountAddress: "0x1", // replace with a real account address
+     *     resourceType: "0x1::aptos_coin::AptosCoin"
+     *   });
+     *
+     *   console.log(resource);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Account
+     */
+    getAccountResource<T extends {} = any>(args: {
+        accountAddress: AccountAddressInput;
+        resourceType: MoveStructId;
+        options?: LedgerVersionArg;
+    }): Promise<T>;
+    /**
+     * Looks up the account address for a given authentication key, handling both rotated and non-rotated keys.
+     *
+     * @param args.authenticationKey - The authentication key for which to look up the account address.
+     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
+     * @param args.options.ledgerVersion - The ledger version to query; if not provided, it will get the latest version.
+     * @returns Promise<AccountAddress> - The account address associated with the authentication key.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Look up the original account address for a given authentication key
+     *   const accountAddress = await aptos.lookupOriginalAccountAddress({
+     *     authenticationKey: "0x1", // replace with a real authentication key
+     *   });
+     *
+     *   console.log("Original Account Address:", accountAddress);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Account
+     */
+    lookupOriginalAccountAddress(args: {
+        authenticationKey: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: LedgerVersionArg;
+    }): Promise<AccountAddress>;
+    /**
+     * Queries the current count of tokens owned by a specified account.
+     *
+     * @param args - The parameters for the query.
+     * @param args.accountAddress - The account address to query the token count for.
+     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
+     * @returns The current count of tokens owned by the account.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Get the count of tokens owned by the account
+     *   const tokensCount = await aptos.getAccountTokensCount({ accountAddress: "0x1" }); // replace with a real account address
+     *   console.log(`Tokens Count: ${tokensCount}`);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Account
+     */
+    getAccountTokensCount(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<number>;
+    /**
+     * Queries the tokens currently owned by a specified account, including NFTs and fungible tokens.
+     * If desired, you can filter the results by a specific token standard.
+     *
+     * @param args.accountAddress The account address for which to retrieve owned tokens.
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to before querying.
+     * @param args.options.tokenStandard Optional filter for the NFT standard to query for.
+     * @param args.options.offset Optional number to start returning results from.
+     * @param args.options.limit Optional number of results to return.
+     * @param args.options.orderBy Optional order to sort the tokens by.
+     * @returns An array of tokens with their respective data.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Get the tokens owned by a specific account
+     *   const accountOwnedTokens = await aptos.getAccountOwnedTokens({
+     *     accountAddress: "0x1", // replace with a real account address
+     *     options: {
+     *       limit: 10, // specify how many tokens to return
+     *       orderBy: "created_at", // specify the order of the results
+     *     },
+     *   });
+     *
+     *   console.log(accountOwnedTokens);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Account
+     */
+    getAccountOwnedTokens(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensQueryResponse[0]>;
+    }): Promise<GetAccountOwnedTokensQueryResponse>;
+    /**
+     * Queries all current tokens of a specific collection that an account owns by the collection address.
+     * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.
+     * If you want to get only the token from a specific standard, you can pass an optional tokenStandard parameter.
+     *
+     * @param args.accountAddress - The account address we want to get the tokens for.
+     * @param args.collectionAddress - The address of the collection being queried.
+     * @param args.minimumLedgerVersion - Optional ledger version to sync up to, before querying.
+     * @param args.options.tokenStandard - The NFT standard to query for.
+     * @param args.options.offset - The number token to start returning results from.
+     * @param args.options.limit - The number of results to return.
+     * @param args.options.orderBy - The order to sort the tokens by.
+     * @returns Tokens array with the token data.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Get tokens owned by a specific account in a specific collection
+     *   const accountOwnedTokens = await aptos.getAccountOwnedTokensFromCollectionAddress({
+     *     accountAddress: "0x1", // replace with a real account address
+     *     collectionAddress: "0x2", // replace with a real collection address
+     *   });
+     *
+     *   console.log(accountOwnedTokens);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Account
+     */
+    getAccountOwnedTokensFromCollectionAddress(args: {
+        accountAddress: AccountAddressInput;
+        collectionAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensFromCollectionResponse[0]>;
+    }): Promise<GetAccountOwnedTokensFromCollectionResponse>;
+    /**
+     * Queries for all collections that an account currently has tokens for, including NFTs, fungible tokens, and soulbound tokens.
+     * If you want to filter by a specific token standard, you can pass an optional tokenStandard parameter.
+     *
+     * @param args.accountAddress - The account address we want to get the collections for.
+     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
+     * @param args.options.tokenStandard - The NFT standard to query for.
+     * @param args.options.offset - The number of the collection to start returning results from.
+     * @param args.options.limit - The number of results to return.
+     * @param args.options.orderBy - The order to sort the tokens by.
+     * @returns Collections array with the collections data.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Get account collections with owned tokens for a specific account
+     *   const accountCollectionsWithOwnedTokens = await aptos.getAccountCollectionsWithOwnedTokens({
+     *     accountAddress: "0x1", // replace with a real account address
+     *     options: {
+     *       tokenStandard: "NFT", // specify the token standard if needed
+     *       limit: 10, // specify the number of results to return
+     *     },
+     *   });
+     *
+     *   console.log(accountCollectionsWithOwnedTokens);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Account
+     */
+    getAccountCollectionsWithOwnedTokens(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountCollectionsWithOwnedTokenResponse[0]>;
+    }): Promise<GetAccountCollectionsWithOwnedTokenResponse>;
+    /**
+     * Queries the current count of transactions submitted by an account.
+     *
+     * @param args - The parameters for the query.
+     * @param args.accountAddress - The account address we want to get the total count for.
+     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
+     * @returns Current count of transactions made by an account.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Get the count of transactions for a specific account
+     *   const accountTransactionsCount = await aptos.getAccountTransactionsCount({
+     *     accountAddress: "0x1", // replace with a real account address
+     *     minimumLedgerVersion: 1, // specify your own minimum ledger version if needed
+     *   });
+     *
+     *   console.log(accountTransactionsCount);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Account
+     */
+    getAccountTransactionsCount(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<number>;
+    /**
+     * Retrieves the coins data for a specified account.
+     *
+     * @param args.accountAddress - The account address for which to retrieve the coin's data.
+     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
+     * @param args.options.offset - Optional. The number of coins to start returning results from.
+     * @param args.options.limit - Optional. The number of results to return.
+     * @param args.options.orderBy - Optional. The order to sort the coins by.
+     * @param args.options.where - Optional. Filter the results by specific criteria.
+     * @returns An array containing the coins data for the specified account.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Fetching coins data for a specific account
+     *   const accountCoinsData = await aptos.getAccountCoinsData({
+     *     accountAddress: "0x1", // replace with a real account address
+     *     options: {
+     *       limit: 10, // specify the number of results to return
+     *       orderBy: { asset_type: "asc" }, // specify the order of results
+     *     },
+     *   });
+     *
+     *   console.log(accountCoinsData);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Account
+     */
+    getAccountCoinsData(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & OrderByArg<GetAccountCoinsDataResponse[0]> & WhereArg<CurrentFungibleAssetBalancesBoolExp>;
+    }): Promise<GetAccountCoinsDataResponse>;
+    /**
+     * Retrieves the current count of an account's coins aggregated across all types.
+     *
+     * @param args The parameters for the account coins count query.
+     * @param args.accountAddress The account address we want to get the total count for.
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to before querying.
+     * @returns The current count of the aggregated coins for the specified account.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Getting the account coins count for a specific account
+     *   const accountCoinsCount = await aptos.getAccountCoinsCount({ accountAddress: "0x1" }); // replace with a real account address
+     *   console.log("Account Coins Count:", accountCoinsCount);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Account
+     */
+    getAccountCoinsCount(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<number>;
+    /**
+     * Retrieves the current amount of APT for a specified account.
+     *
+     * @param args The arguments for the account query.
+     * @param args.accountAddress The account address for which to retrieve the APT amount.
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to before querying.
+     * @returns The current amount of APT for the specified account.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Get the APT amount for a specific account
+     *   const accountAPTAmount = await aptos.getAccountAPTAmount({ accountAddress: "0x1" }); // replace with a real account address
+     *   console.log("Account APT Amount:", accountAPTAmount);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Account
+     */
+    getAccountAPTAmount(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<number>;
+    /**
+     * Queries the current amount of a specified coin held by an account.
+     *
+     * @param args The parameters for querying the account's coin amount.
+     * @param args.accountAddress The account address to query for the coin amount.
+     * @param args.coinType The coin type to query. Note: If not provided, it may be automatically populated if `faMetadataAddress`
+     * is specified.
+     * @param args.faMetadataAddress The fungible asset metadata address to query. Note: If not provided, it may be automatically
+     * populated if `coinType` is specified.
+     * @param args.minimumLedgerVersion Not used anymore, here for backward compatibility
+     * see https://github.com/aptos-labs/aptos-ts-sdk/pull/519, will be removed in the near future.
+     * Optional ledger version to sync up to before querying.
+     * @returns The current amount of the specified coin held by the account.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Query the account's coin amount for a specific coin type
+     *   const accountCoinAmount = await aptos.getAccountCoinAmount({
+     *     accountAddress: "0x1", // replace with a real account address
+     *     coinType: "0x1::aptos_coin::AptosCoin" // specify the coin type
+     *   });
+     *
+     *   console.log(`Account coin amount: ${accountCoinAmount}`);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Account
+     */
+    getAccountCoinAmount(args: {
+        accountAddress: AccountAddressInput;
+        coinType?: MoveStructId;
+        faMetadataAddress?: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<number>;
+    /**
+     * Queries an account's owned objects.
+     *
+     * @param args.accountAddress The account address we want to get the objects for.
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to before querying.
+     * @param args.options.offset The starting position to start returning results from.
+     * @param args.options.limit The number of results to return.
+     * @param args.options.orderBy The order to sort the objects by.
+     * @returns Objects array with the object data.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Get the objects owned by the specified account
+     *   const accountOwnedObjects = await aptos.getAccountOwnedObjects({
+     *     accountAddress: "0x1", // replace with a real account address
+     *     minimumLedgerVersion: 1, // optional, specify if needed
+     *     options: {
+     *       offset: 0, // optional, specify if needed
+     *       limit: 10, // optional, specify if needed
+     *       orderBy: "created_at", // optional, specify if needed
+     *     },
+     *   });
+     *
+     *   console.log(accountOwnedObjects);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Account
+     */
+    getAccountOwnedObjects(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & OrderByArg<GetObjectDataQueryResponse[0]>;
+    }): Promise<GetObjectDataQueryResponse>;
+    /**
+     * Derives an account by providing a private key. This function resolves the provided private key type and derives the public
+     * key from it.
+     *
+     * If the privateKey is a Secp256k1 type, it derives the account using the derived public key and auth key using the SingleKey
+     * scheme locally.
+     * If the privateKey is an ED25519 type, it looks up the authentication key on chain to determine whether it is a Legacy ED25519
+     * key or a Unified ED25519 key, and then derives the account based on that.
+     *
+     * @param args - The arguments for deriving the account.
+     * @param args.privateKey - An account private key.
+     * @returns The derived Account type.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network, Ed25519PrivateKey } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *     // Deriving an account from a private key
+     *     const account = await aptos.deriveAccountFromPrivateKey({
+     *         privateKey: new Ed25519PrivateKey("0x123") // replace with a real private key
+     *     });
+     *
+     *     console.log(account);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Account
+     */
+    deriveAccountFromPrivateKey(args: {
+        privateKey: PrivateKey;
+    }): Promise<Account$1>;
+}
+
 /**
- * Checks if the provided argument is BCS encoded and converts it if necessary, ensuring type compatibility with the ABI.
- * This function helps in validating and converting arguments for entry functions based on their expected types.
- *
- * @param arg - The argument to check or convert, which can be either a simple or entry function argument type.
- * @param param - The expected type tag for the argument.
- * @param position - The position of the argument in the function call.
- * @param genericTypeParams - An array of generic type parameters that may be used for conversion.
- * @group Implementation
- * @category Transactions
+ * A class to handle all `Coin` operations.
+ * @group Coin
  */
-declare function checkOrConvertArgument(arg: SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes, param: TypeTag, position: number, genericTypeParams: Array<TypeTag>): EntryFunctionArgumentTypes;
+declare class Coin {
+    readonly config: AptosConfig;
+    /**
+     * Initializes a new instance of the Aptos client with the specified configuration.
+     * This allows you to interact with the Aptos blockchain using the provided settings.
+     *
+     * @param config - The configuration settings for the Aptos client.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * async function runExample() {
+     *     // Create a new Aptos client with testnet configuration
+     *     const config = new AptosConfig({ network: Network.TESTNET });
+     *     const aptos = new Aptos(config);
+     *
+     *     console.log("Aptos client initialized:", aptos);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Coin
+     */
+    constructor(config: AptosConfig);
+    /**
+     * Generate a transfer coin transaction that can be simulated, signed, and submitted.
+     * This function helps you create a transaction to transfer a specified amount of coins
+     * from one account to another within the Aptos network.
+     *
+     * @param args The arguments for the transfer transaction.
+     * @param args.sender The sender account address.
+     * @param args.recipient The recipient account address.
+     * @param args.amount The amount of coins to transfer.
+     * @param args.coinType Optional. The coin struct type to transfer. Defaults to 0x1::aptos_coin::AptosCoin.
+     * @param args.options Optional. Additional options for generating the transaction.
+     *
+     * @returns SimpleTransaction
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Generate a transfer coin transaction
+     *   const transaction = await aptos.transferCoinTransaction({
+     *     sender: "0x1", // replace with a real sender account address
+     *     recipient: "0x2", // replace with a real recipient account address
+     *     amount: 10,
+     *   });
+     *
+     *   console.log(transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Coin
+     */
+    transferCoinTransaction(args: {
+        sender: AccountAddressInput;
+        recipient: AccountAddressInput;
+        amount: AnyNumber;
+        coinType?: MoveStructId;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SimpleTransaction>;
+}
 
 /**
- * Derives the appropriate raw transaction type based on the provided transaction details.
- * This function helps in identifying whether the transaction is a FeePayerRawTransaction,
- * MultiAgentRawTransaction, or a standard RawTransaction.
- *
- * @param transaction - An object representing an Aptos transaction, which may include:
- *   - feePayerAddress - The address of the fee payer (optional).
- *   - secondarySignerAddresses - An array of secondary signer addresses (optional).
- *   - rawTransaction - The raw transaction data.
- *
- * @returns FeePayerRawTransaction | MultiAgentRawTransaction | RawTransaction
+ * This file contains the underlying implementations for exposed API surface in
+ * the {@link api/digitalAsset}. By moving the methods out into a separate file,
+ * other namespaces and processes can access these methods without depending on the entire
+ * digitalAsset namespace and without having a dependency cycle error.
  * @group Implementation
- * @category Transactions
  */
-declare function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTransactionInstance;
+
+declare const PropertyTypeMap: {
+    BOOLEAN: string;
+    U8: string;
+    U16: string;
+    U32: string;
+    U64: string;
+    U128: string;
+    U256: string;
+    ADDRESS: string;
+    STRING: string;
+    ARRAY: string;
+};
 /**
- * Generates the 'signing message' form of a message to be signed.
- * This function combines a domain separator with the byte representation of the message to create a signing message.
- *
- * @param bytes - The byte representation of the message to be signed and sent to the chain.
- * @param domainSeparator - A domain separator that starts with 'APTOS::'.
- *
- * @returns The Uint8Array of the signing message.
+ * The keys of the PropertyTypeMap, representing different property types.
  * @group Implementation
- * @category Transactions
  */
-declare function generateSigningMessage(bytes: Uint8Array, domainSeparator: string): Uint8Array;
+type PropertyType = keyof typeof PropertyTypeMap;
 /**
- * @deprecated
- * Use CryptoHashable instead by having your class implement it and call hash() to get the signing message.
- *
- * Generates the 'signing message' form of a serializable value by serializing it and using the constructor name as the domain
- * separator.
- *
- * @param serializable - An object that has a BCS serialized form.
- *
- * @returns The Uint8Array of the signing message.
+ * Accepted property value types for user input, including boolean, number, bigint, string, AccountAddress, and Uint8Array.
+ * To pass in an Array, use Uint8Array type
+ * for example `new MoveVector([new MoveString("hello"), new MoveString("world")]).bcsToBytes()`
  * @group Implementation
- * @category Transactions
  */
-declare function generateSigningMessageForSerializable(serializable: Serializable): Uint8Array;
+type PropertyValue = boolean | number | bigint | string | AccountAddress | Uint8Array;
 /**
- * Generates the 'signing message' form of a transaction by deriving the type of transaction and applying the appropriate domain
- * separator based on the presence of a fee payer or secondary signers.
- *
- * @param transaction - A transaction that is to be signed, which can include a fee payer address or secondary signer addresses.
+ * Options for creating a collection, allowing customization of various attributes such as supply limits, mutability of metadata,
+ * and royalty settings.
  *
- * @returns The Uint8Array of the signing message.
+ * @param maxSupply - Maximum number of tokens that can be minted in the collection.
+ * @param mutableDescription - Indicates if the collection description can be changed after creation.
+ * @param mutableRoyalty - Indicates if the royalty settings can be modified after creation.
+ * @param mutableURI - Indicates if the collection URI can be updated.
+ * @param mutableTokenDescription - Indicates if individual token descriptions can be modified.
+ * @param mutableTokenName - Indicates if individual token names can be changed.
+ * @param mutableTokenProperties - Indicates if individual token properties can be altered.
+ * @param mutableTokenURI - Indicates if individual token URIs can be updated.
+ * @param tokensBurnableByCreator - Indicates if the creator can burn tokens from the collection.
+ * @param tokensFreezableByCreator - Indicates if the creator can freeze tokens in the collection.
+ * @param royaltyNumerator - The numerator for calculating royalties.
+ * @param royaltyDenominator - The denominator for calculating royalties.
  * @group Implementation
- * @category Transactions
  */
-declare function generateSigningMessageForTransaction(transaction: AnyRawTransaction): Uint8Array;
+interface CreateCollectionOptions {
+    maxSupply?: AnyNumber;
+    mutableDescription?: boolean;
+    mutableRoyalty?: boolean;
+    mutableURI?: boolean;
+    mutableTokenDescription?: boolean;
+    mutableTokenName?: boolean;
+    mutableTokenProperties?: boolean;
+    mutableTokenURI?: boolean;
+    tokensBurnableByCreator?: boolean;
+    tokensFreezableByCreator?: boolean;
+    royaltyNumerator?: number;
+    royaltyDenominator?: number;
+}
 
 /**
- * Error types related to parsing type tags, indicating various issues encountered during the parsing process.
- * @group Implementation
- * @category Transactions
+ * A class to query all `DigitalAsset` related queries on Aptos.
+ * @group DigitalAsset
  */
-declare enum TypeTagParserErrorType {
-    InvalidTypeTag = "unknown type",
-    UnexpectedGenericType = "unexpected generic type",
-    UnexpectedTypeArgumentClose = "unexpected '>'",
-    UnexpectedWhitespaceCharacter = "unexpected whitespace character",
-    UnexpectedComma = "unexpected ','",
-    TypeArgumentCountMismatch = "type argument count doesn't match expected amount",
-    MissingTypeArgumentClose = "no matching '>' for '<'",
-    MissingTypeArgument = "no type argument before ','",
-    UnexpectedPrimitiveTypeArguments = "primitive types not expected to have type arguments",
-    UnexpectedVectorTypeArgumentCount = "vector type expected to have exactly one type argument",
-    UnexpectedStructFormat = "unexpected struct format, must be of the form 0xaddress::module_name::struct_name",
-    InvalidModuleNameCharacter = "module name must only contain alphanumeric or '_' characters",
-    InvalidStructNameCharacter = "struct name must only contain alphanumeric or '_' characters",
-    InvalidAddress = "struct address must be valid"
+declare class DigitalAsset {
+    readonly config: AptosConfig;
+    /**
+     * Initializes a new instance of the Aptos client with the specified configuration.
+     * This allows you to interact with the Aptos blockchain using the provided settings.
+     *
+     * @param config - The configuration settings for the Aptos client.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * async function runExample() {
+     *     // Create a configuration for the Aptos client
+     *     const config = new AptosConfig({ network: Network.TESTNET }); // Specify your desired network
+     *
+     *     // Initialize the Aptos client with the configuration
+     *     const aptos = new Aptos(config);
+     *
+     *     console.log("Aptos client initialized:", aptos);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    constructor(config: AptosConfig);
+    /**
+     * Queries data of a specific collection by the collection creator address and the collection name.
+     * This function is deprecated; use `getCollectionDataByCreatorAddressAndCollectionName` instead.
+     *
+     * If a creator account has two collections with the same name in v1 and v2, you can pass an optional `tokenStandard` parameter
+     * to query a specific standard.
+     *
+     * @param args - The arguments for querying the collection data.
+     * @param args.creatorAddress - The address of the collection's creator.
+     * @param args.collectionName - The name of the collection.
+     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
+     * @param args.options - Optional parameters for the query.
+     * @param args.options.tokenStandard - The token standard to query.
+     * @returns GetCollectionDataResponse - The response type containing the collection data.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Querying collection data by creator address and collection name
+     *   const collection = await aptos.getCollectionData({
+     *     creatorAddress: "0x1", // replace with a real creator address
+     *     collectionName: "myCollection", // specify your collection name
+     *   });
+     *
+     *   console.log(collection);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    getCollectionData(args: {
+        creatorAddress: AccountAddressInput;
+        collectionName: string;
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg;
+    }): Promise<GetCollectionDataResponse>;
+    /**
+     * Queries data of a specific collection by the collection creator address and the collection name.
+     * If a creator account has multiple collections with the same name across different versions,
+     * specify the `tokenStandard` parameter to query a specific standard.
+     *
+     * @param args.creatorAddress - The address of the collection's creator.
+     * @param args.collectionName - The name of the collection.
+     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
+     * @param args.options.tokenStandard - Optional token standard to query.
+     * @returns GetCollectionDataResponse - The response type containing collection data.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Fetching collection data by creator address and collection name
+     *   const collection = await aptos.getCollectionDataByCreatorAddressAndCollectionName({
+     *     creatorAddress: "0x1", // replace with a real creator address
+     *     collectionName: "myCollection",
+     *     minimumLedgerVersion: 1, // optional, specify if needed
+     *     options: { tokenStandard: "v2" } // optional, specify if needed
+     *   });
+     *
+     *   console.log(collection);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    getCollectionDataByCreatorAddressAndCollectionName(args: {
+        creatorAddress: AccountAddressInput;
+        collectionName: string;
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg & PaginationArgs;
+    }): Promise<GetCollectionDataResponse>;
+    /**
+     * Retrieves data for a specific collection created by a given creator address.
+     * This function allows you to query collection data while optionally specifying a minimum ledger version and pagination options.
+     *
+     * @param args.creatorAddress - The address of the collection's creator.
+     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
+     * @param args.options.tokenStandard - Optional token standard to query.
+     * @param args.options.pagination - Optional pagination arguments.
+     * @returns GetCollectionDataResponse - The response type containing collection data.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Retrieve collection data by creator address
+     *   const collectionData = await aptos.getCollectionDataByCreatorAddress({
+     *     creatorAddress: "0x1", // replace with a real creator address
+     *     minimumLedgerVersion: 1, // specify the minimum ledger version if needed
+     *     options: {
+     *       tokenStandard: "v2", // specify the token standard if needed
+     *       pagination: { limit: 10, offset: 0 } // specify pagination options if needed
+     *     }
+     *   });
+     *
+     *   console.log(collectionData);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    getCollectionDataByCreatorAddress(args: {
+        creatorAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg & PaginationArgs;
+    }): Promise<GetCollectionDataResponse>;
+    /**
+     * Queries data of a specific collection by the collection ID.
+     *
+     * @param args.collectionId - The ID of the collection, which is the same as the address of the collection object.
+     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
+     * @param args.options - Optional parameters for token standard and pagination.
+     * @returns GetCollectionDataResponse - The response type containing the collection data.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Fetching collection data by collection ID
+     *   const collection = await aptos.getCollectionDataByCollectionId({
+     *     collectionId: "0x123", // replace with a real collection ID
+     *   });
+     *
+     *   console.log(collection);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    getCollectionDataByCollectionId(args: {
+        collectionId: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg & PaginationArgs;
+    }): Promise<GetCollectionDataResponse>;
+    /**
+     * Queries the ID of a specified collection.
+     * This ID corresponds to the collection's object address in V2, while V1 does not utilize objects and lacks an address.
+     *
+     * @param args.creatorAddress - The address of the collection's creator.
+     * @param args.collectionName - The name of the collection.
+     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
+     * @param args.options.tokenStandard - The token standard to query.
+     * @returns The collection ID.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Fetching the collection ID for a specific creator and collection name
+     *   const collectionId = await aptos.getCollectionId({
+     *     creatorAddress: "0x1", // replace with a real creator address
+     *     collectionName: "myCollection"
+     *   });
+     *
+     *   console.log("Collection ID:", collectionId);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    getCollectionId(args: {
+        creatorAddress: AccountAddressInput;
+        collectionName: string;
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg;
+    }): Promise<string>;
+    /**
+     * Retrieves digital asset data using the address of a digital asset.
+     *
+     * @param args - The parameters for the request.
+     * @param args.digitalAssetAddress - The address of the digital asset.
+     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
+     * @returns GetTokenDataResponse containing relevant data for the digital asset.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Fetching digital asset data for a specific address
+     *   const digitalAsset = await aptos.getDigitalAssetData({
+     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
+     *   });
+     *
+     *   console.log(digitalAsset);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    getDigitalAssetData(args: {
+        digitalAssetAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<GetTokenDataResponse>;
+    /**
+     * Retrieves the current ownership data of a specified digital asset using its address.
+     *
+     * @param args The parameters for the request.
+     * @param args.digitalAssetAddress The address of the digital asset.
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to before querying.
+     *
+     * @returns GetCurrentTokenOwnershipResponse containing relevant ownership data of the digital asset.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Getting the current ownership of a digital asset
+     *   const digitalAssetOwner = await aptos.getCurrentDigitalAssetOwnership({
+     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
+     *   });
+     *
+     *   console.log(digitalAssetOwner);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    getCurrentDigitalAssetOwnership(args: {
+        digitalAssetAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<GetCurrentTokenOwnershipResponse>;
+    /**
+     * Retrieves the digital assets owned by a specified address.
+     *
+     * @param args.ownerAddress The address of the owner.
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to before querying.
+     * @param args.options Optional pagination and ordering parameters for the response.
+     *
+     * @returns GetOwnedTokensResponse containing ownership data of the digital assets belonging to the ownerAddress.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Fetching the digital assets owned by the specified address
+     *   const digitalAssets = await aptos.getOwnedDigitalAssets({
+     *     ownerAddress: "0x1", // replace with a real account address
+     *   });
+     *
+     *   console.log(digitalAssets);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    getOwnedDigitalAssets(args: {
+        ownerAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & OrderByArg<GetOwnedTokensResponse[0]>;
+    }): Promise<GetOwnedTokensResponse>;
+    /**
+     * Retrieves the activity data for a specified digital asset using its address.
+     *
+     * @param args - The parameters for the request.
+     * @param args.digitalAssetAddress - The address of the digital asset.
+     * @param args.minimumLedgerVersion - Optional minimum ledger version to sync up to before querying.
+     * @param args.options - Optional pagination and ordering parameters.
+     *
+     * @returns A promise that resolves to the activity data related to the digital asset.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Get the activity data for a digital asset
+     *   const digitalAssetActivity = await aptos.getDigitalAssetActivity({
+     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
+     *   });
+     *
+     *   console.log(digitalAssetActivity);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    getDigitalAssetActivity(args: {
+        digitalAssetAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & OrderByArg<GetTokenActivityResponse[0]>;
+    }): Promise<GetTokenActivityResponse>;
+    /**
+     * Creates a new collection within the specified account.
+     *
+     * @param args.creator - The account of the collection's creator.
+     * @param args.description - The description of the collection.
+     * @param args.name - The name of the collection.
+     * @param args.uri - The URI to additional info about the collection.
+     * @param args.options - Optional parameters for generating the transaction.
+     *
+     * The parameters below are optional:
+     * @param args.maxSupply - Controls the max supply of the digital assets. Defaults to MAX_U64_BIG_INT.
+     * @param args.mutableDescription - Controls mutability of the collection's description. Defaults to true.
+     * @param args.mutableRoyalty - Controls mutability of the collection's royalty. Defaults to true.
+     * @param args.mutableUri - Controls mutability of the collection's URI. Defaults to true.
+     * @param args.mutableTokenDescription - Controls mutability of the digital asset's description. Defaults to true.
+     * @param args.mutableTokenName - Controls mutability of the digital asset's name. Defaults to true.
+     * @param args.mutableTokenProperties - Controls mutability of digital asset's properties. Defaults to true.
+     * @param args.mutableTokenUri - Controls mutability of the digital asset's URI. Defaults to true.
+     * @param args.tokensBurnableByCreator - Controls whether digital assets can be burnable by the creator. Defaults to true.
+     * @param args.tokensFreezableByCreator - Controls whether digital assets can be frozen by the creator. Defaults to true.
+     * @param args.royaltyNumerator - The numerator of the royalty to be paid to the creator when a digital asset is transferred.
+     * Defaults to 0.
+     * @param args.royaltyDenominator - The denominator of the royalty to be paid to the creator when a digital asset is
+     * transferred. Defaults to 1.
+     *
+     * @returns A SimpleTransaction that when submitted will create the collection.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Creating a new collection transaction
+     *   const transaction = await aptos.createCollectionTransaction({
+     *     creator: Account.generate(), // Replace with a real account
+     *     description: "A unique collection of digital assets.",
+     *     name: "My Digital Collection",
+     *     uri: "https://mycollection.com",
+     *   });
+     *
+     *   console.log("Transaction created:", transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    createCollectionTransaction(args: {
+        creator: Account$1;
+        description: string;
+        name: string;
+        uri: string;
+        options?: InputGenerateTransactionOptions;
+    } & CreateCollectionOptions): Promise<SimpleTransaction>;
+    /**
+     * Create a transaction to mint a digital asset into the creator's account within an existing collection.
+     * This function helps you generate a transaction that can be simulated or submitted to the blockchain for minting a digital asset.
+     *
+     * @param args.creator - The creator of the collection.
+     * @param args.collection - The name of the collection the digital asset belongs to.
+     * @param args.description - The description of the digital asset.
+     * @param args.name - The name of the digital asset.
+     * @param args.uri - The URI to additional info about the digital asset.
+     * @param args.propertyKeys - Optional array of property keys for the digital asset.
+     * @param args.propertyTypes - Optional array of property types for the digital asset.
+     * @param args.propertyValues - Optional array of property values for the digital asset.
+     * @param args.options - Optional transaction generation options.
+     *
+     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Creating a transaction to mint a digital asset
+     *   const transaction = await aptos.mintDigitalAssetTransaction({
+     *     creator: Account.generate(), // replace with a real account
+     *     collection: "MyCollection",
+     *     description: "This is a digital asset.",
+     *     name: "MyDigitalAsset",
+     *     uri: "https://example.com/my-digital-asset",
+     *   });
+     *
+     *   console.log(transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    mintDigitalAssetTransaction(args: {
+        creator: Account$1;
+        collection: string;
+        description: string;
+        name: string;
+        uri: string;
+        propertyKeys?: Array<string>;
+        propertyTypes?: Array<PropertyType>;
+        propertyValues?: Array<PropertyValue>;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SimpleTransaction>;
+    /**
+     * Transfer ownership of a non-fungible digital asset.
+     * This function allows you to transfer a digital asset only if it is not frozen, meaning the ownership transfer is not disabled.
+     *
+     * @param args The arguments for transferring the digital asset.
+     * @param args.sender The sender account of the current digital asset owner.
+     * @param args.digitalAssetAddress The address of the digital asset being transferred.
+     * @param args.recipient The account address of the recipient.
+     * @param args.digitalAssetType Optional. The type of the digital asset, defaults to "0x4::token::Token".
+     * @param args.options Optional. Additional options for generating the transaction.
+     *
+     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Transfer a digital asset
+     *   const transaction = await aptos.transferDigitalAssetTransaction({
+     *     sender: Account.generate(), // replace with a real sender account
+     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
+     *     recipient: "0x456", // replace with a real recipient account address
+     *   });
+     *
+     *   console.log(transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    transferDigitalAssetTransaction(args: {
+        sender: Account$1;
+        digitalAssetAddress: AccountAddressInput;
+        recipient: AccountAddress;
+        digitalAssetType?: MoveStructId;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SimpleTransaction>;
+    /**
+     * Mint a soul bound digital asset into a recipient's account.
+     * This function allows you to create a unique digital asset that is bound to a specific account.
+     *
+     * @param args - The arguments for minting the soul bound transaction.
+     * @param args.account - The account that mints the digital asset.
+     * @param args.collection - The collection name that the digital asset belongs to.
+     * @param args.description - The digital asset description.
+     * @param args.name - The digital asset name.
+     * @param args.uri - The digital asset URL.
+     * @param args.recipient - The account address where the digital asset will be created.
+     * @param args.propertyKeys - The property keys for storing on-chain properties.
+     * @param args.propertyTypes - The type of property values.
+     * @param args.propertyValues - The property values to be stored on-chain.
+     * @param args.options - Additional options for generating the transaction.
+     *
+     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Mint a soul bound digital asset
+     *   const transaction = await aptos.mintSoulBoundTransaction({
+     *     account: Account.generate(), // Replace with a real account
+     *     collection: "collectionName",
+     *     description: "collectionDescription",
+     *     name: "digitalAssetName",
+     *     uri: "digital-asset-uri.com",
+     *     recipient: "0x123" // Replace with a real recipient account address
+     *   });
+     *
+     *   console.log(transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    mintSoulBoundTransaction(args: {
+        account: Account$1;
+        collection: string;
+        description: string;
+        name: string;
+        uri: string;
+        recipient: AccountAddressInput;
+        propertyKeys?: Array<string>;
+        propertyTypes?: Array<PropertyType>;
+        propertyValues?: Array<PropertyValue>;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SimpleTransaction>;
+    /**
+     * Burn a digital asset by its creator, allowing for the removal of a specified digital asset from the blockchain.
+     *
+     * @param args The arguments for burning the digital asset.
+     * @param args.creator The creator account that is burning the digital asset.
+     * @param args.digitalAssetAddress The address of the digital asset to be burned.
+     * @param args.digitalAssetType Optional. The type of the digital asset being burned.
+     * @param args.options Optional. Additional options for generating the transaction.
+     *
+     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network, Account } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   const creator = Account.generate(); // Replace with a real creator account
+     *   const transaction = await aptos.burnDigitalAssetTransaction({
+     *     creator: creator,
+     *     digitalAssetAddress: "0x123", // Replace with a real digital asset address
+     *   });
+     *
+     *   console.log(transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    burnDigitalAssetTransaction(args: {
+        creator: Account$1;
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SimpleTransaction>;
+    /**
+     * Freeze the ability to transfer a specified digital asset.
+     * This function allows the creator to restrict the transfer capability of a digital asset.
+     *
+     * @param args The arguments for freezing the digital asset transfer.
+     * @param args.creator The creator account initiating the freeze.
+     * @param args.digitalAssetAddress The address of the digital asset to be frozen.
+     * @param args.digitalAssetType Optional. The type of the digital asset being frozen.
+     * @param args.options Optional. Additional options for generating the transaction.
+     *
+     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Freeze the digital asset transfer
+     *   const transaction = await aptos.freezeDigitalAssetTransaferTransaction({
+     *     creator: Account.generate(), // Replace with a real account if needed
+     *     digitalAssetAddress: "0x123", // Replace with a real digital asset address
+     *   });
+     *
+     *   console.log(transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    freezeDigitalAssetTransaferTransaction(args: {
+        creator: Account$1;
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SimpleTransaction>;
+    /**
+     * Unfreeze the ability to transfer a digital asset.
+     * This function allows the specified creator account to unfreeze the transfer of a digital asset identified by its address.
+     *
+     * @param args The parameters for unfreezing the digital asset transfer.
+     * @param args.creator The creator account that is unfreezing the digital asset transfer.
+     * @param args.digitalAssetAddress The address of the digital asset to unfreeze.
+     * @param args.digitalAssetType Optional. The type of the digital asset being unfrozen.
+     * @param args.options Optional. Additional options for generating the transaction.
+     *
+     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Unfreeze the ability to transfer a digital asset
+     *   const transaction = await aptos.unfreezeDigitalAssetTransaferTransaction({
+     *     creator: Account.generate(), // replace with a real creator account
+     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
+     *   });
+     *
+     *   console.log(transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    unfreezeDigitalAssetTransaferTransaction(args: {
+        creator: Account$1;
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SimpleTransaction>;
+    /**
+     * Set the digital asset description to provide additional context or information about the asset.
+     *
+     * @param args The parameters for setting the digital asset description.
+     * @param args.creator The creator account responsible for the digital asset.
+     * @param args.description The digital asset description to be set.
+     * @param args.digitalAssetAddress The address of the digital asset.
+     * @param args.digitalAssetType Optional. The type of the digital asset.
+     * @param args.options Optional. Additional options for generating the transaction.
+     *
+     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Set the digital asset description
+     *   const transaction = await aptos.setDigitalAssetDescriptionTransaction({
+     *     creator: Account.generate(), // replace with a real account
+     *     description: "This is a digital asset description.",
+     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
+     *   });
+     *
+     *   console.log(transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    setDigitalAssetDescriptionTransaction(args: {
+        creator: Account$1;
+        description: string;
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SimpleTransaction>;
+    /**
+     * Set the digital asset name, allowing you to define a name for a specific digital asset on the blockchain.
+     *
+     * @param args The parameters for setting the digital asset name.
+     * @param args.creator The creator account responsible for the transaction.
+     * @param args.name The desired name for the digital asset.
+     * @param args.digitalAssetAddress The address of the digital asset.
+     * @param args.digitalAssetType Optional. The type of the digital asset, represented as a Move struct ID.
+     * @param args.options Optional. Additional options for generating the transaction.
+     *
+     * @returns A SimpleTransaction that can be simulated or submitted to the blockchain.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network, Account } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   const creator = Account.generate(); // Generate a new account for the creator
+     *   const digitalAssetAddress = "0x123"; // replace with a real digital asset address
+     *
+     *   // Set the digital asset name
+     *   const transaction = await aptos.setDigitalAssetNameTransaction({
+     *     creator: creator,
+     *     name: "digitalAssetName",
+     *     digitalAssetAddress: digitalAssetAddress,
+     *   });
+     *
+     *   console.log(transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    setDigitalAssetNameTransaction(args: {
+        creator: Account$1;
+        name: string;
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SimpleTransaction>;
+    /**
+     * Set the URI for a digital asset, allowing you to associate a unique identifier with the asset.
+     *
+     * @param args The parameters for the transaction.
+     * @param args.creator The creator account initiating the transaction.
+     * @param args.uri The digital asset URI to be set.
+     * @param args.digitalAssetAddress The address of the digital asset.
+     * @param args.digitalAssetType Optional. The type of the digital asset.
+     * @param args.options Optional. Additional options for generating the transaction.
+     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Set the URI for a digital asset
+     *   const transaction = await aptos.setDigitalAssetURITransaction({
+     *     creator: Account.generate(), // Replace with a real creator account
+     *     uri: "digital-asset-uri.com",
+     *     digitalAssetAddress: "0x123", // Replace with a real digital asset address
+     *   });
+     *
+     *   console.log(transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    setDigitalAssetURITransaction(args: {
+        creator: Account$1;
+        uri: string;
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SimpleTransaction>;
+    /**
+     * Add a digital asset property to the blockchain.
+     * This function allows you to specify a new property for a digital asset, including its key, type, and value.
+     *
+     * @param args - The arguments for adding a digital asset property.
+     * @param args.creator - The account that mints the digital asset.
+     * @param args.propertyKey - The property key for storing on-chain properties.
+     * @param args.propertyType - The type of property value.
+     * @param args.propertyValue - The property value to be stored on-chain.
+     * @param args.digitalAssetAddress - The digital asset address.
+     * @param args.digitalAssetType - (Optional) The type of the digital asset.
+     * @param args.options - (Optional) Options for generating the transaction.
+     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Add a digital asset property
+     *   const transaction = await aptos.addDigitalAssetPropertyTransaction({
+     *     creator: Account.generate(), // Replace with a real account
+     *     propertyKey: "newKey",
+     *     propertyType: "BOOLEAN",
+     *     propertyValue: true,
+     *     digitalAssetAddress: "0x123", // Replace with a real digital asset address
+     *   });
+     *
+     *   console.log(transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    addDigitalAssetPropertyTransaction(args: {
+        creator: Account$1;
+        propertyKey: string;
+        propertyType: PropertyType;
+        propertyValue: PropertyValue;
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SimpleTransaction>;
+    /**
+     * Remove a digital asset property from the blockchain.
+     * This function allows you to delete an existing property associated with a digital asset.
+     *
+     * @param args The parameters required to remove the digital asset property.
+     * @param args.creator The account that mints the digital asset.
+     * @param args.propertyKey The property key for storing on-chain properties.
+     * @param args.propertyType The type of property value.
+     * @param args.propertyValue The property value to be stored on-chain.
+     * @param args.digitalAssetAddress The digital asset address.
+     * @param args.digitalAssetType Optional. The type of the digital asset.
+     * @param args.options Optional. Additional options for generating the transaction.
+     *
+     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Remove a digital asset property
+     *   const transaction = await aptos.removeDigitalAssetPropertyTransaction({
+     *     creator: Account.generate(), // replace with a real account
+     *     propertyKey: "newKey",
+     *     propertyType: "BOOLEAN",
+     *     propertyValue: true,
+     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
+     *   });
+     *
+     *   console.log(transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    removeDigitalAssetPropertyTransaction(args: {
+        creator: Account$1;
+        propertyKey: string;
+        propertyType: PropertyType;
+        propertyValue: PropertyValue;
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SimpleTransaction>;
+    /**
+     * Update a digital asset property on-chain.
+     *
+     * @param args The parameters for updating the digital asset property.
+     * @param args.creator The account that mints the digital asset.
+     * @param args.digitalAssetAddress The address of the digital asset.
+     * @param args.propertyKey The property key for storing on-chain properties.
+     * @param args.propertyType The type of property value.
+     * @param args.propertyValue The property value to be stored on-chain.
+     * @param args.digitalAssetType Optional. The type of the digital asset.
+     * @param args.options Optional. Additional options for generating the transaction.
+     *
+     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Update a digital asset property
+     *   const transaction = await aptos.updateDigitalAssetPropertyTransaction({
+     *     creator: Account.generate(), // replace with a real account
+     *     propertyKey: "newKey",
+     *     propertyType: "BOOLEAN",
+     *     propertyValue: false,
+     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
+     *   });
+     *
+     *   console.log(transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    updateDigitalAssetPropertyTransaction(args: {
+        creator: Account$1;
+        propertyKey: string;
+        propertyType: PropertyType;
+        propertyValue: PropertyValue;
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SimpleTransaction>;
+    /**
+     * Add a typed digital asset property to the blockchain.
+     * This function allows you to define and store a specific property for a digital asset, enabling better categorization and
+     * management of digital assets.
+     *
+     * @param args - The parameters for adding the typed property.
+     * @param args.creator - The account that mints the digital asset.
+     * @param args.propertyKey - The property key for storing on-chain properties.
+     * @param args.propertyType - The type of property value.
+     * @param args.propertyValue - The property value to be stored on-chain.
+     * @param args.digitalAssetAddress - The digital asset address.
+     * @param args.digitalAssetType - The optional type of the digital asset.
+     * @param args.options - Optional transaction generation options.
+     *
+     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Adding a typed digital asset property
+     *   const transaction = await aptos.addDigitalAssetTypedPropertyTransaction({
+     *     creator: Account.generate(), // replace with a real account
+     *     propertyKey: "typedKey",
+     *     propertyType: "STRING",
+     *     propertyValue: "hello",
+     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
+     *   });
+     *
+     *   console.log(transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    addDigitalAssetTypedPropertyTransaction(args: {
+        creator: Account$1;
+        propertyKey: string;
+        propertyType: PropertyType;
+        propertyValue: PropertyValue;
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SimpleTransaction>;
+    /**
+     * Update a typed digital asset property on-chain.
+     * This function allows you to modify the properties of a digital asset, enabling dynamic updates to its attributes.
+     *
+     * @param args - The arguments for updating the digital asset property.
+     * @param args.creator - The account that mints the digital asset.
+     * @param args.propertyKey - The property key for storing on-chain properties.
+     * @param args.propertyType - The type of property value.
+     * @param args.propertyValue - The property value to be stored on-chain.
+     * @param args.digitalAssetAddress - The digital asset address.
+     * @param args.digitalAssetType - (Optional) The type of the digital asset.
+     * @param args.options - (Optional) Additional options for generating the transaction.
+     *
+     * @returns A SimpleTransaction that can be simulated or submitted to the chain.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Update a typed digital asset property
+     *   const transaction = await aptos.updateDigitalAssetTypedPropertyTransaction({
+     *     creator: Account.generate(), // replace with a real account
+     *     propertyKey: "typedKey",
+     *     propertyType: "U8",
+     *     propertyValue: 2,
+     *     digitalAssetAddress: "0x123", // replace with a real digital asset address
+     *   });
+     *
+     *   console.log(transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group DigitalAsset
+     */
+    updateDigitalAssetTypedPropertyTransaction(args: {
+        creator: Account$1;
+        propertyKey: string;
+        propertyType: PropertyType;
+        propertyValue: PropertyValue;
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SimpleTransaction>;
 }
+
 /**
- * Represents an error that occurs during the parsing of a type tag.
- * This error extends the built-in Error class and provides additional context
- * regarding the specific type tag that failed to parse and the reason for the failure.
- *
- * @param typeTagStr - The type tag string that failed to be parsed.
- * @param invalidReason - The reason why the type tag string is considered invalid.
- * @group Implementation
- * @category Transactions
+ * A class to query all `Event` Aptos related queries.
+ * @group Event
  */
-declare class TypeTagParserError extends Error {
+declare class Event {
+    readonly config: AptosConfig;
+    /**
+     * Initializes a new instance of the Aptos client with the provided configuration.
+     *
+     * @param config - The configuration settings for the Aptos client.
+     * @param config.network - The network to connect to (e.g., Testnet, Mainnet).
+     * @param config.nodeUrl - The URL of the Aptos node to connect to.
+     * @param config.faucetUrl - The URL of the faucet to use for funding accounts.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * async function runExample() {
+     *     // Create a new Aptos client with Testnet configuration
+     *     const config = new AptosConfig({ network: Network.TESTNET }); // Specify your own network if needed
+     *     const aptos = new Aptos(config);
+     *
+     *     console.log("Aptos client initialized:", aptos);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Event
+     */
+    constructor(config: AptosConfig);
+    /**
+     * Retrieve module events based on a specified event type.
+     * This function allows you to query for events that are associated with a particular module event type in the Aptos blockchain.
+     *
+     * @param args - The arguments for retrieving module events.
+     * @param args.eventType - The event type to filter the results.
+     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
+     * @param args.options - Optional pagination and ordering parameters for the event results.
+     *
+     * @returns Promise<GetEventsResponse> - A promise that resolves to the retrieved events.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Retrieve module events for a specific event type
+     *   const events = await aptos.getModuleEventsByEventType({
+     *     eventType: "0x1::transaction_fee::FeeStatement", // specify the event type
+     *     minimumLedgerVersion: 1, // optional: specify minimum ledger version if needed
+     *   });
+     *
+     *   console.log(events); // log the retrieved events
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Event
+     */
+    getModuleEventsByEventType(args: {
+        eventType: MoveStructId;
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & OrderByArg<GetEventsResponse[0]>;
+    }): Promise<GetEventsResponse>;
     /**
-     * Constructs an error indicating a failure to parse a type tag.
-     * This error provides details about the specific type tag that could not be parsed and the reason for the failure.
+     * Retrieve events associated with a specific account address and creation number.
      *
-     * @param typeTagStr - The string representation of the type tag that failed to parse.
-     * @param invalidReason - The reason why the type tag is considered invalid.
-     * @group Implementation
-     * @category Transactions
+     * @param args - The parameters for retrieving account events.
+     * @param args.accountAddress - The account address to query events for.
+     * @param args.creationNumber - The event creation number to filter the events.
+     * @param args.minimumLedgerVersion - Optional minimum ledger version to sync up to before querying.
+     *
+     * @returns Promise<GetEventsResponse>
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Get events for the account at creation number 0
+     *   const events = await aptos.getAccountEventsByCreationNumber({
+     *     accountAddress: "0x1", // replace with a real account address
+     *     creationNumber: 0,
+     *   });
+     *
+     *   console.log(events);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Event
      */
-    constructor(typeTagStr: string, invalidReason: TypeTagParserErrorType);
+    getAccountEventsByCreationNumber(args: {
+        accountAddress: AccountAddressInput;
+        creationNumber: AnyNumber;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<GetEventsResponse>;
+    /**
+     * Retrieve events associated with a specific account address and event type.
+     *
+     * @param args.accountAddress - The account address to query events for.
+     * @param args.eventType - The type of event to filter by.
+     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
+     * @param args.options - Optional pagination and ordering parameters for the event query.
+     *
+     * @returns Promise<GetEventsResponse>
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Get events for a specific account and event type
+     *   const events = await aptos.getAccountEventsByEventType({
+     *     accountAddress: "0x1", // replace with a real account address
+     *     eventType: "0x1::transaction_fee::FeeStatement", // replace with a real event type
+     *     minimumLedgerVersion: 1, // optional, specify if needed
+     *   });
+     *
+     *   console.log(events);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Event
+     */
+    getAccountEventsByEventType(args: {
+        accountAddress: AccountAddressInput;
+        eventType: MoveStructId;
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & OrderByArg<GetEventsResponse[0]>;
+    }): Promise<GetEventsResponse>;
+    /**
+     * Retrieve all events from the Aptos blockchain.
+     * An optional `where` clause can be provided to filter the results based on specific criteria.
+     *
+     * @param args Optional parameters for the query.
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to before querying.
+     * @param args.options Optional pagination and filtering options.
+     * @param args.options.where Optional condition to filter events.
+     * @param args.options.offset Optional pagination offset.
+     * @param args.options.limit Optional maximum number of events to return.
+     * @param args.options.orderBy Optional ordering of the results.
+     *
+     * @returns GetEventsQuery response type containing the events.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Retrieve all events
+     *   const events = await aptos.getEvents();
+     *
+     *   // Retrieve events with filtering by account address
+     *   const whereCondition = {
+     *     account_address: { _eq: "0x123" }, // replace with a real account address
+     *   };
+     *   const filteredEvents = await aptos.getEvents({
+     *     options: { where: whereCondition },
+     *   });
+     *
+     *   console.log(events);
+     *   console.log(filteredEvents);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Event
+     */
+    getEvents(args?: {
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & OrderByArg<GetEventsResponse[0]> & WhereArg<EventsBoolExp>;
+    }): Promise<GetEventsResponse>;
 }
+
 /**
- * Parses a type string into a structured representation of type tags, accommodating various formats including generics and
- * nested types.
- *
- * This function can help you accurately interpret type strings, which can include simple types, standalone structs, and complex
- * nested generics.
- * It supports multiple generics, spacing within generics, and nested generics of varying depths.
- * All types are made of a few parts they're either:
- * 1. A simple type e.g. u8
- * 2. A standalone struct e.g. 0x1::account::Account
- * 3. A nested struct e.g. 0x1::coin::Coin<0x1234::coin::MyCoin>
- *
- * There are a few more special cases that need to be handled, however.
- * 1. Multiple generics e.g. 0x1::pair::Pair<u8, u16>
- * 2. Spacing in the generics e.g. 0x1::pair::Pair< u8 , u16>
- * 3. Nested generics of different depths e.g. 0x1::pair::Pair<0x1::coin::Coin<0x1234::coin::MyCoin>, u8>
- * 4. Generics for types in ABIs are filled in with placeholders e.g. T1, T2, T3
- * @param typeStr - The string representation of the type to be parsed.
- * @param options - Optional settings for parsing behavior.
- * @param options.allowGenerics - A flag indicating whether to allow generics in the parsing process.
- * @returns The parsed type tag representation.
- * @throws TypeTagParserError if the type string is malformed or does not conform to expected formats.
- * @group Implementation
- * @category Transactions
+ * A class to query all `Faucet` related queries on Aptos.
+ * @group Faucet
  */
-declare function parseTypeTag(typeStr: string, options?: {
-    allowGenerics?: boolean;
-}): TypeTag;
-
-declare class AptosScriptComposer {
-    private config;
-    private builder?;
-    private static transactionComposer?;
-    constructor(aptosConfig: AptosConfig);
-    init(): Promise<void>;
-    addBatchedCalls(input: InputBatchedFunctionData): Promise<CallArgument[]>;
-    build(): Uint8Array;
+declare class Faucet {
+    readonly config: AptosConfig;
+    /**
+     * Initializes a new instance of the Aptos client with the specified configuration.
+     *
+     * Note that only devnet has a publicly accessible faucet. For testnet, you must use
+     * the minting page at https://aptos.dev/network/faucet.
+     *
+     * @param config - The configuration settings for the Aptos client.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * async function runExample() {
+     *     // Create a configuration for the Aptos client
+     *     const config = new AptosConfig({ network: Network.DEVNET }); // specify your own network if needed
+     *
+     *     // Initialize the Aptos client with the configuration
+     *     const aptos = new Aptos(config);
+     *
+     *     console.log("Aptos client initialized:", aptos);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Faucet
+     */
+    constructor(config: AptosConfig);
+    /**
+     * This function creates an account if it does not exist and mints the specified amount of coins into that account.
+     *
+     * Note that only devnet has a publicly accessible faucet. For testnet, you must use
+     * the minting page at https://aptos.dev/network/faucet.
+     *
+     * @param args - The arguments for funding the account.
+     * @param args.accountAddress - The address of the account to fund.
+     * @param args.amount - The amount of tokens to fund the account with.
+     * @param args.options - Configuration options for waiting for the transaction.
+     * @returns Transaction hash of the transaction that funded the account.
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.DEVNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Fund an account with a specified amount of tokens
+     *   const transaction = await aptos.fundAccount({
+     *     accountAddress: "0x1", // replace with your account address
+     *     amount: 100,
+     *   });
+     *
+     *   console.log("Transaction hash:", transaction.hash);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     * @group Faucet
+     */
+    fundAccount(args: {
+        accountAddress: AccountAddressInput;
+        amount: number;
+        options?: WaitForTransactionOptions;
+    }): Promise<UserTransactionResponse>;
 }
 
 /**
@@ -12947,6 +13185,22 @@ declare const isEncodedStruct: (structObj: any) => structObj is {
     module_name: string;
     struct_name: string;
 };
+/**
+ * Splits a function identifier into its constituent parts: module address, module name, and function name.
+ * This function helps in validating and extracting details from a function identifier string.
+ *
+ * @param functionArg - The function identifier string in the format "moduleAddress::moduleName::functionName".
+ * @returns An object containing the module address, module name, and function name.
+ * @throws Error if the function identifier does not contain exactly three parts.
+ * @group Implementation
+ * @category Transactions
+ */
+declare function getFunctionParts(functionArg: MoveFunctionId): {
+    moduleAddress: string;
+    moduleName: string;
+    functionName: string;
+};
+declare function isValidFunctionInfo(functionInfo: string): boolean;
 
 /**
  * Sends a request using the specified options and returns the response.
@@ -13359,4 +13613,4 @@ declare class AptosApiError extends Error {
     constructor({ apiType, aptosRequest, aptosResponse }: AptosApiErrorOpts);
 }
 
-export { APTOS_BIP44_REGEX, APTOS_COIN, APTOS_FA, APTOS_HARDENED_REGEX, AbstractKeylessAccount, Account$1 as Account, AccountAddress, AccountAddressInput, AccountAuthenticator, AccountAuthenticatorEd25519, AccountAuthenticatorMultiEd25519, AccountAuthenticatorMultiKey, AccountAuthenticatorNoAccountAuthenticator, AccountAuthenticatorSingleKey, AccountData, AccountPublicKey, AccountSequenceNumber, AccountUtils, AnyNumber, AnyPublicKey, AnyPublicKeyVariant, type AnyRawTransaction, type AnyRawTransactionInstance, AnySignature, type AnyTransactionPayloadInstance, Aptos, AptosApiError, AptosApiType, AptosConfig, AptosRequest, AptosResponse, AptosScriptComposer, AptosSettings, AuthenticationKey, AuthenticationKeyScheme, Block, Bool, CKDPriv, ChainId, Client, ClientConfig, ClientRequest, ClientResponse, CommittedTransactionResponse, type CreateAccountFromPrivateKeyArgs, type CreateEd25519AccountFromPrivateKeyArgs, type CreateEd25519SingleKeyAccountFromPrivateKeyArgs, type CreateSingleKeyAccountFromPrivateKeyArgs, DEFAULT_MAX_GAS_AMOUNT, DEFAULT_TXN_EXP_SEC_FROM_NOW, DEFAULT_TXN_TIMEOUT_SEC, type DerivedKeys, Deserializable, type DeserializableClass, Deserializer, EPK_HORIZON_SECS, Ed25519Account, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, type Ed25519SignerConstructorArgs, type Ed25519SignerFromDerivationPathArgs, EntryFunction, type EntryFunctionABI, EntryFunctionArgument, type EntryFunctionArgumentTypes, EntryFunctionBytes, EphemeralCertificate, EphemeralCertificateVariant, EphemeralKeyPair, EphemeralPublicKey, EphemeralPublicKeyVariant, EphemeralSignature, type ExecutionFinishEventData, FIREBASE_AUTH_ISS_PATTERN, type FailureEventData, FaucetConfig, FederatedKeylessAccount, FederatedKeylessPublicKey, FeePayerRawTransaction, FixedBytes, FullNodeConfig, type FunctionABI, GasEstimation, type GenerateAccountArgs, type GenerateEd25519AccountArgs, type GenerateEd25519SingleKeyAccountArgs, type GenerateSingleKeyAccountArgs, GetANSNameResponse, GetAccountCoinsDataResponse, GetAccountCollectionsWithOwnedTokenResponse, GetAccountOwnedTokensFromCollectionResponse, GetAccountOwnedTokensQueryResponse, type GetAptosRequestOptions, GetChainTopUserTransactionsResponse, GetCollectionDataResponse, GetCurrentFungibleAssetBalancesResponse, GetCurrentTokenOwnershipResponse, GetDelegatedStakingActivitiesResponse, GetEventsResponse, GetFungibleAssetActivitiesResponse, GetFungibleAssetMetadataResponse, GetNumberOfDelegatorsResponse, GetObjectDataQueryResponse, GetOwnedTokensResponse, GetProcessorStatusResponse, type GetRequestOptions, GetTableItemsDataResponse, GetTableItemsMetadataResponse, GetTokenActivityResponse, GetTokenDataResponse, GraphqlQuery, Groth16VerificationKey, Groth16Zkp, HARDENED_OFFSET, Hex, HexInput, Identifier, IndexerConfig, type InputBatchedFunctionData, type InputEntryFunctionData, type InputEntryFunctionDataWithABI, type InputEntryFunctionDataWithRemoteABI, type InputGenerateMultiAgentRawTransactionArgs, type InputGenerateMultiAgentRawTransactionData, type InputGenerateRawTransactionArgs, type InputGenerateSingleSignerRawTransactionArgs, type InputGenerateSingleSignerRawTransactionData, type InputGenerateTransactionData, type InputGenerateTransactionOptions, type InputGenerateTransactionPayloadData, type InputGenerateTransactionPayloadDataWithABI, type InputGenerateTransactionPayloadDataWithRemoteABI, type InputMultiSigData, type InputMultiSigDataWithABI, type InputMultiSigDataWithRemoteABI, type InputScriptData, type InputSimulateTransactionData, type InputSimulateTransactionOptions, type InputSubmitTransactionData, type InputViewFunctionData, type InputViewFunctionDataWithABI, type InputViewFunctionDataWithRemoteABI, type InputViewFunctionJsonData, KeyType, KeylessAccount, KeylessConfiguration, KeylessError, KeylessErrorCategory, KeylessErrorResolutionTip, KeylessErrorType, KeylessPublicKey, KeylessSignature, type KeylessSigner, LedgerInfo, LedgerVersionArg, MAX_AUD_VAL_BYTES, MAX_COMMITED_EPK_BYTES, MAX_EXTRA_FIELD_BYTES, MAX_ISS_VAL_BYTES, MAX_JWT_HEADER_B64_BYTES, MAX_UID_KEY_BYTES, MAX_UID_VAL_BYTES, MimeType, ModuleId, MoveFunction, MoveFunctionGenericTypeParam, MoveFunctionId, MoveJWK, MoveModuleBytecode, MoveModuleId, MoveOption, MoveResource, MoveString, MoveStructId, MoveValue, MoveVector, MultiAgentRawTransaction, MultiAgentTransaction, MultiEd25519PublicKey, MultiEd25519Signature, MultiKey, MultiKeyAccount, MultiKeySignature, MultiSig, MultiSigTransactionPayload, Network, OrderByArg, PaginationArgs, PendingTransactionResponse, type PostAptosRequestOptions, type PostRequestOptions, PrivateKey, type PrivateKeyFromDerivationPathArgs, type PrivateKeyInput, PrivateKeyVariants, ProcessorType, type ProofFetchCallback, type ProofFetchEvents, type ProofFetchFailure, type ProofFetchStatus, type ProofFetchSuccess, PublicKey, RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT, RawTransaction, RawTransactionWithData, RotationProofChallenge, Script, ScriptFunctionArgument, type ScriptFunctionArgumentTypes, Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature, Serializable, Serialized, Serializer, Signature, SignedTransaction, SigningScheme, SigningSchemeInput, type SimpleEntryFunctionArgumentTypes, SimpleTransaction, SingleKeyAccount, type SingleKeySigner, type SingleKeySignerConstructorArgs, type SingleKeySignerFromDerivationPathArgs, type SingleKeySignerGenerateArgs, type SingleKeySignerOrLegacyEd25519Account, StructTag, type SuccessEventData, TableItemRequest, TokenStandardArg, TransactionAndProof, TransactionArgument, TransactionAuthenticator, TransactionAuthenticatorEd25519, TransactionAuthenticatorFeePayer, TransactionAuthenticatorMultiAgent, TransactionAuthenticatorMultiEd25519, TransactionAuthenticatorSingleSender, TransactionPayload, TransactionPayloadEntryFunction, TransactionPayloadMultiSig, TransactionPayloadScript, TransactionResponse, TransactionWorker, type TransactionWorkerEvents, TransactionWorkerEventsEnum, type TypeArgument, TypeTag, TypeTagAddress, TypeTagBool, TypeTagGeneric, TypeTagParserError, TypeTagParserErrorType, TypeTagReference, TypeTagSigner, TypeTagStruct, TypeTagU128, TypeTagU16, TypeTagU256, TypeTagU32, TypeTagU64, TypeTagU8, TypeTagVector, U128, U16, U256, U32, U64, U8, Uint16, Uint32, Uint8, UserTransactionResponse, type VerifyEd25519SignatureArgs, type VerifyMultiKeySignatureArgs, type VerifySignatureArgs, type VerifySingleKeySignatureArgs, type ViewFunctionABI, type ViewFunctionJsonPayload, WaitForTransactionOptions, WhereArg, ZeroKnowledgeSig, ZkProof, ZkpVariant, aptosCoinStructTag, aptosRequest, base64UrlDecode, bigIntToBytesLE, buildTransaction, bytesToBigIntLE, checkOrConvertArgument, convertAmountFromHumanReadableToOnChain, convertAmountFromOnChainToHumanReadable, convertArgument, convertCallArgument, convertNumber, createObjectAddress, createResourceAddress, createTokenAddress, deriveKey, deriveTransactionType, deserializeFromScriptArgument, fetchEntryFunctionAbi, fetchFunctionAbi, fetchMoveFunctionAbi, fetchViewFunctionAbi, findFirstNonSignerArg, floorToWholeHour, generateRawTransaction, generateSignedTransaction, generateSignedTransactionForSimulation, generateSigningMessage, generateSigningMessageForSerializable, generateSigningMessageForTransaction, generateTransactionPayload, generateTransactionPayloadWithABI, generateUserTransactionHash, generateViewFunctionPayload, generateViewFunctionPayloadWithABI, get, getAptosFullNode, getAptosPepperService, getAuthenticatorForSimulation, getErrorMessage, getFunctionParts, getIssAudAndUidVal, getKeylessConfig, getKeylessJWKs, hashStrToField, hashValues, isBcsAddress, isBcsBool, isBcsFixedBytes, isBcsString, isBcsU128, isBcsU16, isBcsU256, isBcsU32, isBcsU64, isBcsU8, isBool, isCanonicalEd25519Signature, isEmptyOption, isEncodedEntryFunctionArgument, isEncodedStruct, isKeylessSigner, isLargeNumber, isNumber, isScriptDataInput, isSingleKeySigner, isString, isValidBIP44Path, isValidHardenedPath, mnemonicToSeed, normalizeBundle, nowInSeconds, objectStructTag, optionStructTag, padAndPackBytesWithLen, paginateWithCursor, paginateWithObfuscatedCursor, parseEncodedStruct, parseJwtHeader, parseTypeTag, poseidonHash, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, postAptosPepperService, postAptosProvingService, promiseFulfilledStatus, request, sleep, splitPath, standardizeTypeTags, stringStructTag, throwTypeMismatch };
+export { APTOS_BIP44_REGEX, APTOS_COIN, APTOS_FA, APTOS_HARDENED_REGEX, AbstractKeylessAccount, AbstractedAccount, Account$1 as Account, AccountAddress, AccountAddressInput, AccountAuthenticator, AccountAuthenticatorAbstraction, AccountAuthenticatorEd25519, AccountAuthenticatorMultiEd25519, AccountAuthenticatorMultiKey, AccountAuthenticatorNoAccountAuthenticator, AccountAuthenticatorSingleKey, AccountData, AccountPublicKey, AccountSequenceNumber, AccountUtils, AnyNumber, AnyPublicKey, AnyPublicKeyVariant, type AnyRawTransaction, type AnyRawTransactionInstance, AnySignature, type AnyTransactionPayloadInstance, Aptos, AptosApiError, AptosApiType, AptosConfig, AptosRequest, AptosResponse, AptosScriptComposer, AptosSettings, AuthenticationKey, AuthenticationKeyScheme, Block, Bool, CKDPriv, ChainId, Client, ClientConfig, ClientRequest, ClientResponse, CommittedTransactionResponse, type CreateAccountFromPrivateKeyArgs, type CreateEd25519AccountFromPrivateKeyArgs, type CreateEd25519SingleKeyAccountFromPrivateKeyArgs, type CreateSingleKeyAccountFromPrivateKeyArgs, DEFAULT_MAX_GAS_AMOUNT, DEFAULT_TXN_EXP_SEC_FROM_NOW, DEFAULT_TXN_TIMEOUT_SEC, type DerivedKeys, Deserializable, type DeserializableClass, Deserializer, EPK_HORIZON_SECS, Ed25519Account, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, type Ed25519SignerConstructorArgs, type Ed25519SignerFromDerivationPathArgs, EntryFunction, type EntryFunctionABI, EntryFunctionArgument, type EntryFunctionArgumentTypes, EntryFunctionBytes, EphemeralCertificate, EphemeralCertificateVariant, EphemeralKeyPair, EphemeralPublicKey, EphemeralPublicKeyVariant, EphemeralSignature, type ExecutionFinishEventData, FIREBASE_AUTH_ISS_PATTERN, type FailureEventData, FaucetConfig, FederatedKeylessAccount, FederatedKeylessPublicKey, FeePayerRawTransaction, FixedBytes, FullNodeConfig, type FunctionABI, GasEstimation, type GenerateAccountArgs, type GenerateEd25519AccountArgs, type GenerateEd25519SingleKeyAccountArgs, type GenerateSingleKeyAccountArgs, GetANSNameResponse, GetAccountCoinsDataResponse, GetAccountCollectionsWithOwnedTokenResponse, GetAccountOwnedTokensFromCollectionResponse, GetAccountOwnedTokensQueryResponse, type GetAptosRequestOptions, GetChainTopUserTransactionsResponse, GetCollectionDataResponse, GetCurrentFungibleAssetBalancesResponse, GetCurrentTokenOwnershipResponse, GetDelegatedStakingActivitiesResponse, GetEventsResponse, GetFungibleAssetActivitiesResponse, GetFungibleAssetMetadataResponse, GetNumberOfDelegatorsResponse, GetObjectDataQueryResponse, GetOwnedTokensResponse, GetProcessorStatusResponse, type GetRequestOptions, GetTableItemsDataResponse, GetTableItemsMetadataResponse, GetTokenActivityResponse, GetTokenDataResponse, GraphqlQuery, Groth16VerificationKey, Groth16Zkp, HARDENED_OFFSET, Hex, HexInput, Identifier, IndexerConfig, type InputBatchedFunctionData, type InputEntryFunctionData, type InputEntryFunctionDataWithABI, type InputEntryFunctionDataWithRemoteABI, type InputGenerateMultiAgentRawTransactionArgs, type InputGenerateMultiAgentRawTransactionData, type InputGenerateRawTransactionArgs, type InputGenerateSingleSignerRawTransactionArgs, type InputGenerateSingleSignerRawTransactionData, type InputGenerateTransactionData, type InputGenerateTransactionOptions, type InputGenerateTransactionPayloadData, type InputGenerateTransactionPayloadDataWithABI, type InputGenerateTransactionPayloadDataWithRemoteABI, type InputMultiSigData, type InputMultiSigDataWithABI, type InputMultiSigDataWithRemoteABI, type InputScriptData, type InputSimulateTransactionData, type InputSimulateTransactionOptions, type InputSubmitTransactionData, type InputViewFunctionData, type InputViewFunctionDataWithABI, type InputViewFunctionDataWithRemoteABI, type InputViewFunctionJsonData, KeyType, KeylessAccount, KeylessConfiguration, KeylessError, KeylessErrorCategory, KeylessErrorResolutionTip, KeylessErrorType, KeylessPublicKey, KeylessSignature, type KeylessSigner, LedgerInfo, LedgerVersionArg, MAX_AUD_VAL_BYTES, MAX_COMMITED_EPK_BYTES, MAX_EXTRA_FIELD_BYTES, MAX_ISS_VAL_BYTES, MAX_JWT_HEADER_B64_BYTES, MAX_UID_KEY_BYTES, MAX_UID_VAL_BYTES, MimeType, ModuleId, MoveFunction, MoveFunctionGenericTypeParam, MoveFunctionId, MoveJWK, MoveModuleBytecode, MoveModuleId, MoveOption, MoveResource, MoveString, MoveStructId, MoveValue, MoveVector, MultiAgentRawTransaction, MultiAgentTransaction, MultiEd25519PublicKey, MultiEd25519Signature, MultiKey, MultiKeyAccount, MultiKeySignature, MultiSig, MultiSigTransactionPayload, Network, OrderByArg, PaginationArgs, PendingTransactionResponse, type PostAptosRequestOptions, type PostRequestOptions, PrivateKey, type PrivateKeyFromDerivationPathArgs, type PrivateKeyInput, PrivateKeyVariants, ProcessorType, type ProofFetchCallback, type ProofFetchEvents, type ProofFetchFailure, type ProofFetchStatus, type ProofFetchSuccess, PublicKey, RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT, RawTransaction, RawTransactionWithData, RotationProofChallenge, Script, ScriptFunctionArgument, type ScriptFunctionArgumentTypes, Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature, Serializable, Serialized, Serializer, Signature, SignedTransaction, SigningScheme, SigningSchemeInput, type SimpleEntryFunctionArgumentTypes, SimpleTransaction, SingleKeyAccount, type SingleKeySigner, type SingleKeySignerConstructorArgs, type SingleKeySignerFromDerivationPathArgs, type SingleKeySignerGenerateArgs, type SingleKeySignerOrLegacyEd25519Account, StructTag, type SuccessEventData, TableItemRequest, TokenStandardArg, TransactionAndProof, TransactionArgument, TransactionAuthenticator, TransactionAuthenticatorEd25519, TransactionAuthenticatorFeePayer, TransactionAuthenticatorMultiAgent, TransactionAuthenticatorMultiEd25519, TransactionAuthenticatorSingleSender, TransactionPayload, TransactionPayloadEntryFunction, TransactionPayloadMultiSig, TransactionPayloadScript, TransactionResponse, TransactionWorker, type TransactionWorkerEvents, TransactionWorkerEventsEnum, type TypeArgument, TypeTag, TypeTagAddress, TypeTagBool, TypeTagGeneric, TypeTagParserError, TypeTagParserErrorType, TypeTagReference, TypeTagSigner, TypeTagStruct, TypeTagU128, TypeTagU16, TypeTagU256, TypeTagU32, TypeTagU64, TypeTagU8, TypeTagVector, U128, U16, U256, U32, U64, U8, Uint16, Uint32, Uint8, UserTransactionResponse, type VerifyEd25519SignatureArgs, type VerifyMultiKeySignatureArgs, type VerifySignatureArgs, type VerifySingleKeySignatureArgs, type ViewFunctionABI, type ViewFunctionJsonPayload, WaitForTransactionOptions, WhereArg, ZeroKnowledgeSig, ZkProof, ZkpVariant, aptosCoinStructTag, aptosRequest, base64UrlDecode, bigIntToBytesLE, buildTransaction, bytesToBigIntLE, checkOrConvertArgument, convertAmountFromHumanReadableToOnChain, convertAmountFromOnChainToHumanReadable, convertArgument, convertCallArgument, convertNumber, createObjectAddress, createResourceAddress, createTokenAddress, deriveKey, deriveTransactionType, deserializeFromScriptArgument, fetchEntryFunctionAbi, fetchFunctionAbi, fetchMoveFunctionAbi, fetchViewFunctionAbi, findFirstNonSignerArg, floorToWholeHour, generateRawTransaction, generateSignedTransaction, generateSignedTransactionForSimulation, generateSigningMessage, generateSigningMessageForSerializable, generateSigningMessageForTransaction, generateTransactionPayload, generateTransactionPayloadWithABI, generateUserTransactionHash, generateViewFunctionPayload, generateViewFunctionPayloadWithABI, get, getAptosFullNode, getAptosPepperService, getAuthenticatorForSimulation, getErrorMessage, getFunctionParts, getIssAudAndUidVal, getKeylessConfig, getKeylessJWKs, hashStrToField, hashValues, isBcsAddress, isBcsBool, isBcsFixedBytes, isBcsString, isBcsU128, isBcsU16, isBcsU256, isBcsU32, isBcsU64, isBcsU8, isBool, isCanonicalEd25519Signature, isEmptyOption, isEncodedEntryFunctionArgument, isEncodedStruct, isKeylessSigner, isLargeNumber, isNumber, isScriptDataInput, isSingleKeySigner, isString, isValidBIP44Path, isValidFunctionInfo, isValidHardenedPath, mnemonicToSeed, normalizeBundle, nowInSeconds, objectStructTag, optionStructTag, padAndPackBytesWithLen, paginateWithCursor, paginateWithObfuscatedCursor, parseEncodedStruct, parseJwtHeader, parseTypeTag, poseidonHash, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, postAptosPepperService, postAptosProvingService, promiseFulfilledStatus, request, sleep, splitPath, standardizeTypeTags, stringStructTag, throwTypeMismatch };