@aptos-labs/ts-sdk 1.29.1 → 1.31.0

package/dist/common/{accountAddress-DUCC2ffJ.d.ts → accountAddress-DnSqjhSl.d.ts}

@@ -3,6 +3,9 @@ declare const NetworkToNodeAPI: Record<string, string>;
 declare const NetworkToFaucetAPI: Record<string, string>;
 declare const NetworkToPepperAPI: Record<string, string>;
 declare const NetworkToProverAPI: Record<string, string>;
+/**
+ * Different network environments for connecting to services, ranging from production to development setups.
+ */
 declare enum Network {
     MAINNET = "mainnet",
     TESTNET = "testnet",
@@ -449,25 +452,85 @@ type GetTokenDataQuery = {
  * that calls the function that queries the server (usually under the /api/ folder)
  */
 type GetObjectDataQueryResponse = GetObjectDataQuery["current_objects"];
+/**
+ * The response structure for querying tokens owned by an account.
+ */
 type GetAccountOwnedTokensQueryResponse = GetAccountOwnedTokensQuery["current_token_ownerships_v2"];
+/**
+ * The response containing the current token ownerships for an account from a specific collection.
+ */
 type GetAccountOwnedTokensFromCollectionResponse = GetAccountOwnedTokensFromCollectionQuery["current_token_ownerships_v2"];
+/**
+ * The response structure for retrieving account collections associated with owned tokens.
+ */
 type GetAccountCollectionsWithOwnedTokenResponse = GetAccountCollectionsWithOwnedTokensQuery["current_collection_ownership_v2_view"];
+/**
+ * The current balances of fungible assets for an account.
+ */
 type GetAccountCoinsDataResponse = GetAccountCoinsDataQuery["current_fungible_asset_balances"];
+/**
+ * The response structure for retrieving user transactions from the top of the blockchain.
+ */
 type GetChainTopUserTransactionsResponse = GetChainTopUserTransactionsQuery["user_transactions"];
+/**
+ * The response containing the events from the GetEventsQuery.
+ */
 type GetEventsResponse = GetEventsQuery["events"];
+/**
+ * The number of active delegators per pool in response to a query.
+ */
 type GetNumberOfDelegatorsResponse = GetNumberOfDelegatorsQuery["num_active_delegator_per_pool"];
+/**
+ * The response containing the delegated staking activities from the query.
+ */
 type GetDelegatedStakingActivitiesResponse = GetDelegatedStakingActivitiesQuery["delegated_staking_activities"];
+/**
+ * The response structure for retrieving data from the current collections.
+ */
 type GetCollectionDataResponse = GetCollectionDataQuery["current_collections_v2"][0];
+/**
+ * The response structure for retrieving token data, containing the current token information.
+ */
 type GetTokenDataResponse = GetTokenDataQuery["current_token_datas_v2"][0];
+/**
+ * The status of the processor as returned by the GetProcessorStatusQuery.
+ */
 type GetProcessorStatusResponse = GetProcessorStatusQuery["processor_status"];
+/**
+ * The response containing metadata for a fungible asset.
+ */
 type GetFungibleAssetMetadataResponse = GetFungibleAssetMetadataQuery["fungible_asset_metadata"];
+/**
+ * The response containing the activities related to fungible assets.
+ */
 type GetFungibleAssetActivitiesResponse = GetFungibleAssetActivitiesQuery["fungible_asset_activities"];
+/**
+ * The current balances of fungible assets for a specific query.
+ */
 type GetCurrentFungibleAssetBalancesResponse = GetCurrentFungibleAssetBalancesQuery["current_fungible_asset_balances"];
+/**
+ * The response structure for retrieving token activity data.
+ */
 type GetTokenActivityResponse = GetTokenActivityQuery["token_activities_v2"];
+/**
+ * The response structure for retrieving the current token ownership details.
+ */
 type GetCurrentTokenOwnershipResponse = GetCurrentTokenOwnershipQuery["current_token_ownerships_v2"][0];
+/**
+ * The response containing the current token ownerships for a user.
+ */
 type GetOwnedTokensResponse = GetCurrentTokenOwnershipQuery["current_token_ownerships_v2"];
+/**
+ * The response structure for retrieving items from a table.
+ */
 type GetTableItemsDataResponse = GetTableItemsDataQuery["table_items"];
+/**
+ * The metadata for table items retrieved from a query.
+ */
 type GetTableItemsMetadataResponse = GetTableItemsMetadataQuery["table_metadatas"];
+/**
+ * The response containing the current Aptos names from the GetNamesQuery.
+ */
 type GetANSNameResponse = GetNamesQuery["current_aptos_names"];
 /**
  * A generic type that being passed by each function and holds an
@@ -476,19 +539,25 @@ type GetANSNameResponse = GetNamesQuery["current_aptos_names"];
 type OrderBy<T> = Array<{
     [K in keyof T]?: OrderByValue;
 }>;
+/**
+ * Specifies the order direction for sorting, including options for handling null values.
+ */
 type OrderByValue = "asc" | "asc_nulls_first" | "asc_nulls_last" | "desc" | "desc_nulls_first" | "desc_nulls_last";
 /**
- * Refers to the token standard we want to query for
+ * The token standard to query for, which can be either version "v1" or "v2".
  */
 type TokenStandard = "v1" | "v2";
 /**
- * The graphql query type to pass into the `queryIndexer` function
+ * The GraphQL query to pass into the `queryIndexer` function.
  */
 type GraphqlQuery = {
     query: string;
     variables?: {};
 };
 
+/**
+ * Different MIME types used for data interchange in transactions and responses.
+ */
 declare enum MimeType {
     /**
      * JSON representation, used for transaction submission and accept type JSON output
@@ -505,11 +574,11 @@ declare enum MimeType {
     BCS_VIEW_FUNCTION = "application/x.aptos.view_function+bcs"
 }
 /**
- * Hex data as input to a function
+ * Hexadecimal data input for functions, supporting both string and Uint8Array formats.
  */
 type HexInput = string | Uint8Array;
 /**
- * TypeTag enum as they are represented in Rust
+ * Variants of type tags used in the system, encompassing various data types and structures.
  * {@link https://github.com/aptos-labs/aptos-core/blob/main/third_party/move/move-core/types/src/language_storage.rs#L27}
  */
 declare enum TypeTagVariants {
@@ -528,7 +597,7 @@ declare enum TypeTagVariants {
     Generic = 255
 }
 /**
- * Script transaction arguments enum as they are represented in Rust
+ * Variants of script transaction arguments used in Rust, encompassing various data types for transaction processing.
  * {@link https://github.com/aptos-labs/aptos-core/blob/main/third_party/move/move-core/types/src/transaction_argument.rs#L11}
  */
 declare enum ScriptTransactionArgumentVariants {
@@ -544,7 +613,7 @@ declare enum ScriptTransactionArgumentVariants {
     Serialized = 9
 }
 /**
- * Transaction payload enum as they are represented in Rust
+ * The payload for various transaction types in the system.
  * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/mod.rs#L478}
  */
 declare enum TransactionPayloadVariants {
@@ -553,7 +622,7 @@ declare enum TransactionPayloadVariants {
     Multisig = 3
 }
 /**
- * Transaction variants enum as they are represented in Rust
+ * Variants of transactions used in the system.
  * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/mod.rs#L440}
  */
 declare enum TransactionVariants {
@@ -561,7 +630,7 @@ declare enum TransactionVariants {
     FeePayerTransaction = 1
 }
 /**
- * Transaction Authenticator enum as they are represented in Rust
+ * Variants of transaction authenticators used in the system.
  * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs#L44}
  */
 declare enum TransactionAuthenticatorVariant {
@@ -572,7 +641,7 @@ declare enum TransactionAuthenticatorVariant {
     SingleSender = 4
 }
 /**
- * Transaction Authenticator enum as they are represented in Rust
+ * Variants of account authenticators used in transactions.
  * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs#L414}
  */
 declare enum AccountAuthenticatorVariant {
@@ -581,26 +650,44 @@ declare enum AccountAuthenticatorVariant {
     SingleKey = 2,
     MultiKey = 3
 }
+/**
+ * Variants of public keys used in cryptographic operations.
+ */
 declare enum AnyPublicKeyVariant {
     Ed25519 = 0,
     Secp256k1 = 1,
     Keyless = 3,
     FederatedKeyless = 4
 }
+/**
+ * Variants of signature types used for cryptographic operations.
+ */
 declare enum AnySignatureVariant {
     Ed25519 = 0,
     Secp256k1 = 1,
     Keyless = 3
 }
+/**
+ * Variants of ephemeral public keys used in cryptographic operations.
+ */
 declare enum EphemeralPublicKeyVariant {
     Ed25519 = 0
 }
+/**
+ * Variants of ephemeral signatures used for secure communication.
+ */
 declare enum EphemeralSignatureVariant {
     Ed25519 = 0
 }
+/**
+ * Variants of ephemeral certificates used in secure transactions.
+ */
 declare enum EphemeralCertificateVariant {
     ZkProof = 0
 }
+/**
+ * Variants of zero-knowledge proofs used in cryptographic operations.
+ */
 declare enum ZkpVariant {
     Groth16 = 0
 }
@@ -608,16 +695,32 @@ declare enum ZkpVariant {
  * BCS types
  */
 type Uint8 = number;
+/**
+ * A 16-bit unsigned integer.
+ */
 type Uint16 = number;
+/**
+ * A 32-bit unsigned integer.
+ */
 type Uint32 = number;
+/**
+ * A 64-bit unsigned integer value.
+ */
 type Uint64 = bigint;
+/**
+ * A 128-bit unsigned integer used for precise arithmetic operations.
+ */
 type Uint128 = bigint;
+/**
+ * A 256-bit unsigned integer used for precise numerical calculations.
+ */
 type Uint256 = bigint;
+/**
+ * A number or a bigint value.
+ */
 type AnyNumber = number | bigint;
 /**
- * Set of configuration options that can be provided when initializing the SDK.
- * The purpose of these options is to configure various aspects of the SDK's
- * behavior and interaction with the Aptos network
+ * Configuration options for initializing the SDK, allowing customization of its behavior and interaction with the Aptos network.
  */
 type AptosSettings = {
     readonly network?: Network;
@@ -633,15 +736,19 @@ type AptosSettings = {
     readonly faucetConfig?: FaucetConfig;
 };
 /**
- *
- * Controls the number of results that are returned and the starting position of those results.
- * @param offset parameter specifies the starting position of the query result within the set of data. Default is 0.
- * @param limit specifies the maximum number of items or records to return in a query result. Default is 25.
+ * Defines the parameters for paginating query results, including the starting position and maximum number of items to return.
+ * @param offset Specifies the starting position of the query result. Default is 0.
+ * @param limit Specifies the maximum number of items to return. Default is 25.
  */
 interface PaginationArgs {
     offset?: AnyNumber;
     limit?: number;
 }
+/**
+ * Represents the arguments for specifying a token standard.
+ *
+ * @param tokenStandard - Optional standard of the token.
+ */
 interface TokenStandardArg {
     tokenStandard?: TokenStandard;
 }
@@ -655,43 +762,38 @@ interface WhereArg<T extends {}> {
  * QUERY TYPES
  */
 /**
- * A configuration object we can pass with the request to the server.
- *
- * @param API_KEY - api key generated from developer portal {@link https://developers.aptoslabs.com/manage/api-keys}}
- * @param HEADERS - extra headers we want to send with the request
- * @param WITH_CREDENTIALS - whether to carry cookies. By default, it is set to true and cookies will be sent
+ * A configuration object for requests to the server, including API key, extra headers, and cookie handling options.
  */
 type ClientConfig = ClientHeadersType & {
     WITH_CREDENTIALS?: boolean;
     API_KEY?: string;
 };
 /**
- * A Fullnode only configuration object
- *
- * @param HEADERS - extra headers we want to send with the request
+ * A configuration object for a Fullnode, allowing for the inclusion of extra headers in requests.
  */
 type FullNodeConfig = ClientHeadersType;
 /**
- * An Indexer only configuration object
- *
- * @param HEADERS - extra headers we want to send with the request
+ * An Indexer configuration object for sending requests with additional headers.
  */
 type IndexerConfig = ClientHeadersType;
 /**
- * A Faucet only configuration object
- *
- * @param HEADERS - extra headers we want to send with the request
- * @param AUTH_TOKEN - an auth token to send with a faucet request
+ * A configuration object for a faucet, including optional authentication and headers for requests.
  */
 type FaucetConfig = ClientHeadersType & {
     AUTH_TOKEN?: string;
 };
 /**
- * General type definition for client HEADERS
+ * General type definition for client headers.
  */
 type ClientHeadersType = {
     HEADERS?: Record<string, string | number | boolean>;
 };
+/**
+ * Represents a client for making requests to a service provider.
+ *
+ * @param Req - The type of the request payload.
+ * @param Res - The type of the response payload.
+ */
 interface ClientRequest<Req> {
     url: string;
     method: "GET" | "POST";
@@ -712,14 +814,28 @@ interface ClientResponse<Res> {
     headers?: any;
 }
 interface Client {
+    /**
+     * Sends a request to the specified URL with the given options.
+     *
+     * @param requestOptions - The options for the request.
+     * @param requestOptions.url - The URL to send the request to.
+     * @param requestOptions.method - The HTTP method to use, either "GET" or "POST".
+     * @param requestOptions.path - An optional path to append to the URL.
+     * @param requestOptions.body - The body of the request, applicable for POST requests.
+     * @param requestOptions.contentType - The content type of the request body.
+     * @param requestOptions.acceptType - The expected content type of the response.
+     * @param requestOptions.params - Optional parameters to include in the request.
+     * @param requestOptions.originMethod - An optional method to specify the origin of the request.
+     * @param requestOptions.overrides - Optional configuration overrides for the request.
+     */
     provider<Req, Res>(requestOptions: ClientRequest<Req>): Promise<ClientResponse<Res>>;
 }
 /**
  * The API request type
  *
- * @param url - the url to make the request to, i.e https://fullnode.devnet.aptoslabs.com/v1
+ * @param url - the url to make the request to, i.e. https://fullnode.devnet.aptoslabs.com/v1
  * @param method - the request method "GET" | "POST"
- * @param endpoint (optional) - the endpoint to make the request to, i.e transactions
+ * @param endpoint (optional) - the endpoint to make the request to, i.e. transactions
  * @param body (optional) - the body of the request
  * @param contentType (optional) - the content type to set the `content-type` header to,
  * by default is set to `application/json`
@@ -739,7 +855,7 @@ type AptosRequest = {
     overrides?: ClientConfig & FullNodeConfig & IndexerConfig & FaucetConfig;
 };
 /**
- * Specifies ledger version of transactions. By default latest version will be used
+ * The ledger version of transactions, defaulting to the latest version if not specified.
  */
 type LedgerVersionArg = {
     ledgerVersion?: AnyNumber;
@@ -748,7 +864,7 @@ type LedgerVersionArg = {
  * RESPONSE TYPES
  */
 /**
- * Type holding the outputs of the estimate gas API
+ * The output of the estimate gas API, including the deprioritized estimate for the gas unit price.
  */
 type GasEstimation = {
     /**
@@ -768,10 +884,16 @@ type MoveResource<T = {}> = {
     type: MoveStructId;
     data: T;
 };
+/**
+ * The data associated with an account, including its sequence number.
+ */
 type AccountData = {
     sequence_number: string;
     authentication_key: string;
 };
+/**
+ * A Move module containing an address.
+ */
 type MoveModuleBytecode = {
     bytecode: string;
     abi?: MoveModule;
@@ -779,6 +901,9 @@ type MoveModuleBytecode = {
 /**
  * TRANSACTION TYPES
  */
+/**
+ * Different types of transaction responses that can occur in the system.
+ */
 declare enum TransactionResponseType {
     Pending = "pending_transaction",
     User = "user_transaction",
@@ -788,15 +913,66 @@ declare enum TransactionResponseType {
     Validator = "validator_transaction",
     BlockEpilogue = "block_epilogue_transaction"
 }
+/**
+ * The response for a transaction, which can be either pending or committed.
+ */
 type TransactionResponse = PendingTransactionResponse | CommittedTransactionResponse;
+/**
+ * The response for a committed transaction, which can be one of several transaction types.
+ */
 type CommittedTransactionResponse = UserTransactionResponse | GenesisTransactionResponse | BlockMetadataTransactionResponse | StateCheckpointTransactionResponse | ValidatorTransactionResponse | BlockEpilogueTransactionResponse;
+/**
+ * Determine if the given transaction response is currently pending.
+ *
+ * @param response - The transaction response to evaluate.
+ * @returns A boolean indicating whether the transaction is pending.
+ */
 declare function isPendingTransactionResponse(response: TransactionResponse): response is PendingTransactionResponse;
+/**
+ * Determines if the given transaction response is a user transaction.
+ *
+ * @param response - The transaction response to evaluate.
+ * @returns A boolean indicating whether the transaction is of type User.
+ */
 declare function isUserTransactionResponse(response: TransactionResponse): response is UserTransactionResponse;
+/**
+ * Determines if the given transaction response is a Genesis transaction.
+ *
+ * @param response - The transaction response to evaluate.
+ * @returns A boolean indicating whether the transaction is a Genesis transaction.
+ */
 declare function isGenesisTransactionResponse(response: TransactionResponse): response is GenesisTransactionResponse;
+/**
+ * Determine if the given transaction response is of type BlockMetadata.
+ *
+ * @param response - The transaction response to evaluate.
+ * @returns A boolean indicating whether the response is a BlockMetadata transaction.
+ */
 declare function isBlockMetadataTransactionResponse(response: TransactionResponse): response is BlockMetadataTransactionResponse;
+/**
+ * Determines if the provided transaction response is a state checkpoint transaction.
+ *
+ * @param response - The transaction response to evaluate.
+ * @returns A boolean indicating whether the transaction response is of type StateCheckpoint.
+ */
 declare function isStateCheckpointTransactionResponse(response: TransactionResponse): response is StateCheckpointTransactionResponse;
+/**
+ * Determine if the given transaction response is of type Validator.
+ *
+ * @param response - The transaction response to evaluate.
+ * @returns A boolean indicating whether the transaction response is a Validator type.
+ */
 declare function isValidatorTransactionResponse(response: TransactionResponse): response is ValidatorTransactionResponse;
+/**
+ * Determines if the given transaction response is of the type Block Epilogue.
+ *
+ * @param response - The transaction response to evaluate.
+ * @returns A boolean indicating whether the response is a Block Epilogue transaction.
+ */
 declare function isBlockEpilogueTransactionResponse(response: TransactionResponse): response is BlockEpilogueTransactionResponse;
+/**
+ * The response for a pending transaction, indicating that the transaction is still being processed.
+ */
 type PendingTransactionResponse = {
     type: TransactionResponseType.Pending;
     hash: string;
@@ -808,6 +984,9 @@ type PendingTransactionResponse = {
     payload: TransactionPayloadResponse;
     signature?: TransactionSignature;
 };
+/**
+ * The response structure for a user transaction.
+ */
 type UserTransactionResponse = {
     type: TransactionResponseType.User;
     version: string;
@@ -842,6 +1021,9 @@ type UserTransactionResponse = {
     events: Array<Event>;
     timestamp: string;
 };
+/**
+ * The response for a genesis transaction, indicating the type of transaction.
+ */
 type GenesisTransactionResponse = {
     type: TransactionResponseType.Genesis;
     version: string;
@@ -869,6 +1051,9 @@ type GenesisTransactionResponse = {
      */
     events: Array<Event>;
 };
+/**
+ * The structure representing a blockchain block with its height.
+ */
 type BlockMetadataTransactionResponse = {
     type: TransactionResponseType.BlockMetadata;
     version: string;
@@ -908,6 +1093,9 @@ type BlockMetadataTransactionResponse = {
     failed_proposer_indices: Array<number>;
     timestamp: string;
 };
+/**
+ * The response for a state checkpoint transaction, indicating the type of transaction.
+ */
 type StateCheckpointTransactionResponse = {
     type: TransactionResponseType.StateCheckpoint;
     version: string;
@@ -931,6 +1119,9 @@ type StateCheckpointTransactionResponse = {
     changes: Array<WriteSetChange>;
     timestamp: string;
 };
+/**
+ * The response for a validator transaction, indicating the type of transaction.
+ */
 type ValidatorTransactionResponse = {
     type: TransactionResponseType.Validator;
     version: string;
@@ -959,7 +1150,7 @@ type ValidatorTransactionResponse = {
     timestamp: string;
 };
 /**
- * BlockEndInfo describes the gas state of the block
+ * Describes the gas state of the block, indicating whether the block gas limit has been reached.
  */
 type BlockEndInfo = {
     block_gas_limit_reached: boolean;
@@ -968,8 +1159,7 @@ type BlockEndInfo = {
     block_approx_output_size: number;
 };
 /**
- * BlockEpilogueTransactionResponse is a transaction that is executed at the end of a block keeping track of data from
- * the whole block
+ * A transaction executed at the end of a block that tracks data from the entire block.
  */
 type BlockEpilogueTransactionResponse = {
     type: TransactionResponseType.BlockEpilogue;
@@ -998,7 +1188,13 @@ type BlockEpilogueTransactionResponse = {
 /**
  * WRITESET CHANGE TYPES
  */
+/**
+ * A union type that encompasses both script and direct write sets for data operations.
+ */
 type WriteSetChange = WriteSetChangeDeleteModule | WriteSetChangeDeleteResource | WriteSetChangeDeleteTableItem | WriteSetChangeWriteModule | WriteSetChangeWriteResource | WriteSetChangeWriteTableItem;
+/**
+ * The structure for a module deletion change in a write set.
+ */
 type WriteSetChangeDeleteModule = {
     type: string;
     address: string;
@@ -1008,12 +1204,18 @@ type WriteSetChangeDeleteModule = {
     state_key_hash: string;
     module: MoveModuleId;
 };
+/**
+ * The payload for a resource deletion in a write set change.
+ */
 type WriteSetChangeDeleteResource = {
     type: string;
     address: string;
     state_key_hash: string;
     resource: string;
 };
+/**
+ * The payload for a write set change that deletes a table item.
+ */
 type WriteSetChangeDeleteTableItem = {
     type: string;
     state_key_hash: string;
@@ -1021,18 +1223,27 @@ type WriteSetChangeDeleteTableItem = {
     key: string;
     data?: DeletedTableData;
 };
+/**
+ * The structure for a write module change in a write set.
+ */
 type WriteSetChangeWriteModule = {
     type: string;
     address: string;
     state_key_hash: string;
     data: MoveModuleBytecode;
 };
+/**
+ * The resource associated with a write set change, identified by its type.
+ */
 type WriteSetChangeWriteResource = {
     type: string;
     address: string;
     state_key_hash: string;
     data: MoveResource;
 };
+/**
+ * The structure for a write operation on a table in a write set change.
+ */
 type WriteSetChangeWriteTableItem = {
     type: string;
     state_key_hash: string;
@@ -1041,6 +1252,9 @@ type WriteSetChangeWriteTableItem = {
     value: string;
     data?: DecodedTableData;
 };
+/**
+ * The decoded data for a table, including its key in JSON format.
+ */
 type DecodedTableData = {
     /**
      * Key of table in JSON
@@ -1060,7 +1274,7 @@ type DecodedTableData = {
     value_type: string;
 };
 /**
- * Deleted table data
+ * Data for a deleted table entry.
  */
 type DeletedTableData = {
     /**
@@ -1072,7 +1286,13 @@ type DeletedTableData = {
      */
     key_type: string;
 };
+/**
+ * The payload for a transaction response, which can be an entry function, script, or multisig payload.
+ */
 type TransactionPayloadResponse = EntryFunctionPayloadResponse | ScriptPayloadResponse | MultisigPayloadResponse;
+/**
+ * The response payload for an entry function, containing the type of the entry.
+ */
 type EntryFunctionPayloadResponse = {
     type: string;
     function: MoveFunctionId;
@@ -1085,6 +1305,9 @@ type EntryFunctionPayloadResponse = {
      */
     arguments: Array<any>;
 };
+/**
+ * The payload for a script response, containing the type of the script.
+ */
 type ScriptPayloadResponse = {
     type: string;
     code: MoveScriptBytecode;
@@ -1097,41 +1320,88 @@ type ScriptPayloadResponse = {
      */
     arguments: Array<any>;
 };
+/**
+ * The response payload for a multisig transaction, containing the type of the transaction.
+ */
 type MultisigPayloadResponse = {
     type: string;
     multisig_address: string;
     transaction_payload?: EntryFunctionPayloadResponse;
 };
+/**
+ * The payload for the genesis block containing the type of the payload.
+ */
 type GenesisPayload = {
     type: string;
     write_set: WriteSet;
 };
 /**
- * Move script bytecode
+ * The bytecode for a Move script.
  */
 type MoveScriptBytecode = {
     bytecode: string;
     abi?: MoveFunction;
 };
 /**
- * These are the JSON representations of transaction signatures returned from the node API.
+ * JSON representations of transaction signatures returned from the node API.
  */
 type TransactionSignature = TransactionEd25519Signature | TransactionSecp256k1Signature | TransactionMultiEd25519Signature | TransactionMultiAgentSignature | TransactionFeePayerSignature;
+/**
+ * Determine if the provided signature is an Ed25519 signature.
+ * This function checks for the presence of the "signature" property
+ * and verifies that its value is "ed25519_signature".
+ *
+ * @param signature - The transaction signature to be checked.
+ * @returns A boolean indicating whether the signature is an Ed25519 signature.
+ */
 declare function isEd25519Signature(signature: TransactionSignature): signature is TransactionFeePayerSignature;
+/**
+ * Determine if the provided signature is a valid secp256k1 ECDSA signature.
+ *
+ * @param signature - The transaction signature to validate.
+ * @returns A boolean indicating whether the signature is a secp256k1 ECDSA signature.
+ */
 declare function isSecp256k1Signature(signature: TransactionSignature): signature is TransactionFeePayerSignature;
+/**
+ * Determine if the provided transaction signature is a multi-agent signature.
+ *
+ * @param signature - The transaction signature to evaluate.
+ * @returns A boolean indicating whether the signature is a multi-agent signature.
+ */
 declare function isMultiAgentSignature(signature: TransactionSignature): signature is TransactionMultiAgentSignature;
+/**
+ * Determine if the provided signature is a fee payer signature.
+ *
+ * @param signature - The transaction signature to evaluate.
+ * @returns A boolean indicating whether the signature is a fee payer signature.
+ */
 declare function isFeePayerSignature(signature: TransactionSignature): signature is TransactionFeePayerSignature;
+/**
+ * Determine if the provided signature is of type "multi_ed25519_signature".
+ *
+ * @param signature - The transaction signature to check.
+ * @returns A boolean indicating whether the signature is a multi-ed25519 signature.
+ */
 declare function isMultiEd25519Signature(signature: TransactionSignature): signature is TransactionMultiEd25519Signature;
+/**
+ * The signature for a transaction using the Ed25519 algorithm.
+ */
 type TransactionEd25519Signature = {
     type: string;
     public_key: string;
     signature: "ed25519_signature";
 };
+/**
+ * The structure for a Secp256k1 signature in a transaction.
+ */
 type TransactionSecp256k1Signature = {
     type: string;
     public_key: string;
     signature: "secp256k1_ecdsa_signature";
 };
+/**
+ * The structure for a multi-signature transaction using Ed25519.
+ */
 type TransactionMultiEd25519Signature = {
     type: "multi_ed25519_signature";
     /**
@@ -1148,6 +1418,9 @@ type TransactionMultiEd25519Signature = {
     threshold: number;
     bitmap: string;
 };
+/**
+ * The structure for a multi-agent signature in a transaction.
+ */
 type TransactionMultiAgentSignature = {
     type: "multi_agent_signature";
     sender: AccountSignature;
@@ -1160,6 +1433,9 @@ type TransactionMultiAgentSignature = {
      */
     secondary_signers: Array<AccountSignature>;
 };
+/**
+ * The signature of the fee payer in a transaction.
+ */
 type TransactionFeePayerSignature = {
     type: "fee_payer_signature";
     sender: AccountSignature;
@@ -1175,20 +1451,32 @@ type TransactionFeePayerSignature = {
     fee_payer_signer: AccountSignature;
 };
 /**
- * The union of all single account signatures.
+ * The union of all single account signatures, including Ed25519, Secp256k1, and MultiEd25519 signatures.
  */
 type AccountSignature = TransactionEd25519Signature | TransactionSecp256k1Signature | TransactionMultiEd25519Signature;
 type WriteSet = ScriptWriteSet | DirectWriteSet;
+/**
+ * The set of properties for writing scripts, including the type of script.
+ */
 type ScriptWriteSet = {
     type: string;
     execute_as: string;
     script: ScriptPayloadResponse;
 };
+/**
+ * The set of direct write operations, identified by a type string.
+ */
 type DirectWriteSet = {
     type: string;
     changes: Array<WriteSetChange>;
     events: Array<Event>;
 };
+/**
+ * The structure for an event's unique identifier, including its creation number.
+ */
+/**
+ * The structure for an event, identified by a unique GUID.
+ */
 type EventGuid = {
     creation_number: string;
     account_address: string;
@@ -1203,23 +1491,54 @@ type Event = {
     data: any;
 };
 /**
- * Map of Move types to local TypeScript types
+ * A number representing a Move uint8 type.
  */
 type MoveUint8Type = number;
+/**
+ * A 16-bit unsigned integer used in the Move programming language.
+ */
 type MoveUint16Type = number;
+/**
+ * A 32-bit unsigned integer type used in Move programming.
+ */
 type MoveUint32Type = number;
+/**
+ * A string representation of a 64-bit unsigned integer used in Move programming.
+ */
 type MoveUint64Type = string;
+/**
+ * A string representing a 128-bit unsigned integer in the Move programming language.
+ */
 type MoveUint128Type = string;
+/**
+ * A string representation of a 256-bit unsigned integer used in Move programming.
+ */
 type MoveUint256Type = string;
+/**
+ * A string representing a Move address.
+ */
 type MoveAddressType = string;
+/**
+ * The type for identifying objects to be moved within the system.
+ */
 type MoveObjectType = string;
+/**
+ * The type for move options, which can be a MoveType, null, or undefined.
+ */
 type MoveOptionType = MoveType | null | undefined;
 /**
- * This is the format for a fully qualified struct, resource, or entry function in Move.
+ * A structure representing a move with a name.
  */
 type MoveStructId = `${string}::${string}::${string}`;
+/**
+ * The move function containing its name. Same as MoveStructId since it reads weird to take a StructId for a Function.
+ */
 type MoveFunctionId = MoveStructId;
 type MoveStructType = {};
+/**
+ * A union type that encompasses various data types used in Move, including primitive types, address types, object types, and
+ * arrays of MoveType.
+ */
 type MoveType = boolean | string | MoveUint8Type | MoveUint16Type | MoveUint32Type | MoveUint64Type | MoveUint128Type | MoveUint256Type | MoveAddressType | MoveObjectType | MoveStructType | Array<MoveType>;
 /**
  * Possible Move values acceptable by move functions (entry, view)
@@ -1246,12 +1565,12 @@ type MoveType = boolean | string | MoveUint8Type | MoveUint16Type | MoveUint32Ty
  */
 type MoveValue = boolean | string | MoveUint8Type | MoveUint16Type | MoveUint32Type | MoveUint64Type | MoveUint128Type | MoveUint256Type | MoveAddressType | MoveObjectType | MoveStructId | MoveOptionType | Array<MoveValue>;
 /**
- * Move module id is a string representation of Move module.
- * Module name is case-sensitive.
+ * A string representation of a Move module, formatted as `module_name::function_name`.
+ * Module names are case-sensitive.
  */
 type MoveModuleId = `${string}::${string}`;
 /**
- * Move function visibility
+ * Specifies the visibility levels for move functions, controlling access permissions.
  */
 declare enum MoveFunctionVisibility {
     PRIVATE = "private",
@@ -1259,7 +1578,7 @@ declare enum MoveFunctionVisibility {
     FRIEND = "friend"
 }
 /**
- * Move function ability
+ * Abilities related to moving items within the system.
  */
 declare enum MoveAbility {
     STORE = "store",
@@ -1268,13 +1587,13 @@ declare enum MoveAbility {
     COPY = "copy"
 }
 /**
- * Move abilities tied to the generic type param and associated with the function that uses it
+ * Move abilities associated with the generic type parameter of a function.
  */
 type MoveFunctionGenericTypeParam = {
     constraints: Array<MoveAbility>;
 };
 /**
- * Move struct field
+ * A field in a Move struct, identified by its name.
  */
 type MoveStructField = {
     name: string;
@@ -1354,10 +1673,16 @@ type MoveFunction = {
      */
     return: Array<string>;
 };
+/**
+ * Roles that can be assigned within the system, indicating different levels of access and functionality.
+ */
 declare enum RoleType {
     VALIDATOR = "validator",
     FULL_NODE = "full_node"
 }
+/**
+ * Information about the current blockchain ledger, including its chain ID.
+ */
 type LedgerInfo = {
     /**
      * Chain ID of the current chain
@@ -1391,7 +1716,7 @@ type Block = {
     transactions?: Array<TransactionResponse>;
 };
 /**
- * Table Item request for the GetTableItem API
+ * The request payload for the GetTableItem API.
  */
 type TableItemRequest = {
     key_type: MoveValue;
@@ -1402,11 +1727,12 @@ type TableItemRequest = {
     key: any;
 };
 /**
- * A list of Authentication Key schemes that are supported by Aptos.
- *
- * They are combinations of signing schemes and derive schemes.
+ * A list of supported Authentication Key schemes in Aptos, consisting of combinations of signing schemes and derive schemes.
  */
 type AuthenticationKeyScheme = SigningScheme | DeriveScheme;
+/**
+ * Different schemes for signing keys used in cryptographic operations.
+ */
 declare enum SigningScheme {
     /**
      * For Ed25519PublicKey
@@ -1422,6 +1748,9 @@ declare enum SigningScheme {
     SingleKey = 2,
     MultiKey = 3
 }
+/**
+ * Specifies the signing schemes available for cryptographic operations.
+ */
 declare enum SigningSchemeInput {
     /**
      * For Ed25519PublicKey
@@ -1433,7 +1762,7 @@ declare enum SigningSchemeInput {
     Secp256k1Ecdsa = 2
 }
 /**
- * Scheme used for deriving account addresses from other data
+ * Specifies the schemes for deriving account addresses from various data sources.
  */
 declare enum DeriveScheme {
     /**
@@ -1458,7 +1787,7 @@ declare enum DeriveScheme {
     DeriveResourceAccountAddress = 255
 }
 /**
- * Option properties to pass for waitForTransaction() function
+ * Options for configuring the behavior of the waitForTransaction() function.
  */
 type WaitForTransactionOptions = {
     timeoutSecs?: number;
@@ -1466,16 +1795,14 @@ type WaitForTransactionOptions = {
     waitForIndexer?: boolean;
 };
 /**
- * Input type to generate an account using Single Signer
- * Ed25519 or Legacy Ed25519
+ * Input type to generate an account using the Ed25519 signing scheme.
  */
 type GenerateAccountWithEd25519 = {
     scheme: SigningSchemeInput.Ed25519;
     legacy: boolean;
 };
 /**
- * Input type to generate an account using Single Signer
- * Secp256k1
+ * Input type to generate an account with a Single Signer using Secp256k1.
  */
 type GenerateAccountWithSingleSignerSecp256k1Key = {
     scheme: SigningSchemeInput.Secp256k1Ecdsa;
@@ -1488,41 +1815,77 @@ type GenerateAccount = GenerateAccountWithEd25519 | GenerateAccountWithSingleSig
  * deserialize a byte buffer into a type T.
  * It is not intended to be implemented or extended, because Typescript has no support
  * for static methods in interfaces.
+ *
+ * @template T - The type that this will deserialize into.
  */
 interface Deserializable<T> {
+    /**
+     * Deserializes the buffered bytes into an instance of the specified class type.
+     * This function provides an alternative syntax for deserialization, allowing users to call
+     * `deserializer.deserialize(MyClass)` instead of `MyClass.deserialize(deserializer)`.
+     *
+     * @param deserializer - The deserializer instance with the buffered bytes.
+     * @returns The deserialized value of class type T.
+     * @example
+     * ```typescript
+     * const deserializer = new Deserializer(new Uint8Array([1, 2, 3]));
+     * const value = deserializer.deserialize(MyClass); // where MyClass has a `deserialize` function
+     * // value is now an instance of MyClass
+     * // equivalent to `const value = MyClass.deserialize(deserializer)`
+     * ```
+     */
     deserialize(deserializer: Deserializer): T;
 }
+/**
+ * A class that provides methods for deserializing various data types from a byte buffer.
+ * It supports deserialization of primitive types, strings, and complex objects using a BCS (Binary Common Serialization) layout.
+ */
 declare class Deserializer {
     private buffer;
     private offset;
+    /**
+     * Creates a new instance of the class with a copy of the provided data buffer.
+     * This prevents outside mutation of the buffer.
+     *
+     * @param data - The data to be copied into the internal buffer as a Uint8Array.
+     */
     constructor(data: Uint8Array);
+    /**
+     * Reads a specified number of bytes from the buffer and advances the offset.
+     *
+     * @param length - The number of bytes to read from the buffer.
+     * @throws Throws an error if the read operation exceeds the buffer's length.
+     */
     private read;
     /**
      * Returns the number of bytes remaining in the buffer.
      *
-     * Useful to tell if there's more data to be read.
+     * This information is useful to determine if there's more data to be read.
+     *
+     * @returns The number of bytes remaining in the buffer.
      */
     remaining(): number;
     /**
-     * Deserializes a string. UTF8 string is supported. Reads the string's bytes length "l" first,
-     * and then reads "l" bytes of content. Decodes the byte array into a string.
+     * Deserializes a UTF-8 encoded string from a byte array. It first reads the length of the string in bytes,
+     * followed by the actual byte content, and decodes it into a string.
      *
      * BCS layout for "string": string_length | string_content
      * where string_length is a u32 integer encoded as a uleb128 integer, equal to the number of bytes in string_content.
      *
      * @example
-     * ```ts
+     * ```typescript
      * const deserializer = new Deserializer(new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));
      * assert(deserializer.deserializeStr() === "1234abcd");
      * ```
      */
     deserializeStr(): string;
     /**
-     * Deserializes a an optional string.
+     * Deserializes an optional string.
      *
-     * BCS layout for Optional<String>: 0 if none, else 1 | string_length | string_content
+     * The BCS layout for Optional<String> is 0 if none, else 1 followed by the string length and string content.
+     * @returns The deserialized string if it exists, otherwise undefined.
      * @example
-     * ```ts
+     * ```typescript
      * const deserializer = new Deserializer(new Uint8Array([0x00]));
      * assert(deserializer.deserializeOptionStr() === undefined);
      * const deserializer = new Deserializer(new Uint8Array([1, 8, 49, 50, 51, 52, 97, 98, 99, 100]));
@@ -1531,9 +1894,9 @@ declare class Deserializer {
      */
     deserializeOptionStr(): string | undefined;
     /**
-     * Deserializes a an optional deserializable class.
+     * Deserializes an optional deserializable class.
      *
-     * BCS layout for Optional<T>: 0 if none, else 1 | bcs representation of class
+     * BCS layout for Optional<T>: 0 if none, else 1 | BCS representation of class.
      *
      * @example
      * const deserializer = new Deserializer(new Uint8Array([1, 2, 3]));
@@ -1546,50 +1909,59 @@ declare class Deserializer {
      *
      * @param cls The BCS-deserializable class to deserialize the buffered bytes into.
      *
-     * @returns the deserialized value of class type T
+     * @returns The deserialized value of class type T or undefined if no value exists.
      */
     deserializeOption<T>(cls: Deserializable<T>): T | undefined;
     /**
      * Deserializes an array of bytes.
      *
-     * BCS layout for "bytes": bytes_length | bytes
-     * where bytes_length is a u32 integer encoded as a uleb128 integer, equal to the length of the bytes array.
+     * The BCS layout for "bytes" consists of a bytes_length followed by the bytes themselves, where bytes_length is a u32 integer
+     * encoded as a uleb128 integer, indicating the length of the bytes array.
+     *
+     * @returns {Uint8Array} The deserialized array of bytes.
      */
     deserializeBytes(): Uint8Array;
     /**
-     * Deserializes an array of bytes. The number of bytes to read is already known.
+     * Deserializes an array of bytes of a specified length.
      *
+     * @param len - The number of bytes to read from the source.
      */
     deserializeFixedBytes(len: number): Uint8Array;
     /**
-     * Deserializes a boolean value.
+     * Deserializes a boolean value from a byte stream.
+     *
+     * The BCS layout for a boolean uses one byte, where "0x01" represents true and "0x00" represents false.
+     * An error is thrown if the byte value is not valid.
      *
-     * BCS layout for "boolean": One byte. "0x01" for true and "0x00" for false.
+     * @returns The deserialized boolean value.
+     * @throws Throws an error if the boolean value is invalid.
      */
     deserializeBool(): boolean;
     /**
-     * Deserializes a uint8 number.
+     * Deserializes a uint8 number from the binary data.
      *
      * BCS layout for "uint8": One byte. Binary format in little-endian representation.
+     *
+     * @returns {number} The deserialized uint8 number.
      */
     deserializeU8(): Uint8;
     /**
-     * Deserializes a uint16 number.
+     * Deserializes a uint16 number from a binary format in little-endian representation.
      *
-     * BCS layout for "uint16": Two bytes. Binary format in little-endian representation.
+     * BCS layout for "uint16": Two bytes.
      * @example
-     * ```ts
+     * ```typescript
      * const deserializer = new Deserializer(new Uint8Array([0x34, 0x12]));
      * assert(deserializer.deserializeU16() === 4660);
      * ```
      */
     deserializeU16(): Uint16;
     /**
-     * Deserializes a uint32 number.
+     * Deserializes a uint32 number from a binary format in little-endian representation.
      *
-     * BCS layout for "uint32": Four bytes. Binary format in little-endian representation.
+     * BCS layout for "uint32": Four bytes.
      * @example
-     * ```ts
+     * ```typescript
      * const deserializer = new Deserializer(new Uint8Array([0x78, 0x56, 0x34, 0x12]));
      * assert(deserializer.deserializeU32() === 305419896);
      * ```
@@ -1598,30 +1970,36 @@ declare class Deserializer {
     /**
      * Deserializes a uint64 number.
      *
-     * BCS layout for "uint64": Eight bytes. Binary format in little-endian representation.
+     * This function combines two 32-bit values to return a 64-bit unsigned integer in little-endian representation.
      * @example
-     * ```ts
+     * ```typescript
      * const deserializer = new Deserializer(new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]));
      * assert(deserializer.deserializeU64() === 1311768467750121216);
      * ```
      */
     deserializeU64(): Uint64;
     /**
-     * Deserializes a uint128 number.
+     * Deserializes a uint128 number from its binary representation.
+     * This function combines two 64-bit values to return a single uint128 value in little-endian format.
      *
-     * BCS layout for "uint128": Sixteen bytes. Binary format in little-endian representation.
+     * @returns {BigInt} The deserialized uint128 number.
      */
     deserializeU128(): Uint128;
     /**
-     * Deserializes a uint256 number.
+     * Deserializes a uint256 number from its binary representation.
+     *
+     * The BCS layout for "uint256" consists of thirty-two bytes in little-endian format.
      *
-     * BCS layout for "uint256": Thirty-two bytes. Binary format in little-endian representation.
+     * @returns {BigInt} The deserialized uint256 number.
      */
     deserializeU256(): Uint256;
     /**
      * Deserializes a uleb128 encoded uint32 number.
      *
-     * BCS use uleb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values
+     * This function is used for interpreting lengths of variable-length sequences and tags of enum values in BCS encoding.
+     *
+     * @throws {Error} Throws an error if the parsed value exceeds the maximum uint32 number.
+     * @returns {number} The deserialized uint32 value.
      */
     deserializeUleb128AsU32(): Uint32;
     /**
@@ -1639,10 +2017,10 @@ declare class Deserializer {
      */
     deserialize<T>(cls: Deserializable<T>): T;
     /**
-     * Deserializes an array of BCS Deserializable values given an existing Deserializer
-     * instance with a loaded byte buffer.
+     * Deserializes an array of BCS Deserializable values given an existing Deserializer instance with a loaded byte buffer.
      *
      * @param cls The BCS-deserializable class to deserialize the buffered bytes into.
+     * @returns An array of deserialized values of type T.
      * @example
      * // serialize a vector of addresses
      * const addresses = new Array<AccountAddress>(
@@ -1659,7 +2037,6 @@ declare class Deserializer {
      * const deserializer = new Deserializer(serializedBytes);
      * const deserializedAddresses = deserializer.deserializeVector(AccountAddress);
      * // deserializedAddresses is now an array of AccountAddress instances
-     * @returns an array of deserialized values of type T
      */
     deserializeVector<T>(cls: Deserializable<T>): Array<T>;
 }
@@ -1674,6 +2051,12 @@ declare class ParsingError<T> extends Error {
      * messages are not suitable for their use case. This should be an enum.
      */
     invalidReason: T;
+    /**
+     * Creates an instance of the error with a specified message and invalid reason.
+     *
+     * @param message The error message that describes the issue.
+     * @param invalidReason The reason why the input is considered invalid.
+     */
     constructor(message: string, invalidReason: T);
 }
 /**
@@ -1696,7 +2079,7 @@ type ParsingResult<T> = {
 };
 
 /**
- * This enum is used to explain why parsing might have failed.
+ * Provides reasons for parsing failures related to hexadecimal values.
  */
 declare enum HexInvalidReason {
     TOO_SHORT = "too_short",
@@ -1704,28 +2087,26 @@ declare enum HexInvalidReason {
     INVALID_HEX_CHARS = "invalid_hex_chars"
 }
 /**
- * NOTE: Do not use this class when working with account addresses, use AccountAddress.
+ * NOTE: Do not use this class when working with account addresses; use AccountAddress instead.
+ * When accepting hex data as input to a function, prefer to accept HexInput and
+ *
+ * A helper class for working with hex data. Hex data, when represented as a string,
+ * generally looks like this, for example: 0xaabbcc, 45cd32, etc.
  *
- * NOTE: When accepting hex data as input to a function, prefer to accept HexInput and
  * then use the static helper methods of this class to convert it into the desired
  * format. This enables the greatest flexibility for the developer.
  *
- * Hex is a helper class for working with hex data. Hex data, when represented as a
- * string, generally looks like this, for example: 0xaabbcc, 45cd32, etc.
- *
- * You might use this class like this:
- *
- * ```ts
+ * Example usage:
+ * ```typescript
  * getTransactionByHash(txnHash: HexInput): Promise<Transaction> {
  *   const txnHashString = Hex.fromHexInput(txnHash).toString();
  *   return await getTransactionByHashInner(txnHashString);
  * }
  * ```
- *
  * This call to `Hex.fromHexInput().toString()` converts the HexInput to a hex string
  * with a leading 0x prefix, regardless of what the input format was.
  *
- * These are some other ways to chain the functions together:
+ * Other ways to chain the functions together:
  * - `Hex.fromHexString({ hexInput: "0x1f" }).toUint8Array()`
  * - `new Hex([1, 3]).toStringWithoutPrefix()`
  */
@@ -1734,12 +2115,11 @@ declare class Hex {
     /**
      * Create a new Hex instance from a Uint8Array.
      *
-     * @param data Uint8Array
+     * @param data - The Uint8Array containing the data to initialize the Hex instance.
      */
     constructor(data: Uint8Array);
     /**
-     * Get the inner hex data. The inner data is already a Uint8Array so no conversion
-     * is taking place here, it just returns the inner data.
+     * Get the inner hex data as a Uint8Array. The inner data is already a Uint8Array, so no conversion takes place.
      *
      * @returns Hex data as Uint8Array
      */
@@ -1757,34 +2137,36 @@ declare class Hex {
      */
     toString(): string;
     /**
-     * Static method to convert a hex string to Hex
+     * Converts a hex string into a Hex instance, allowing for both prefixed and non-prefixed formats.
      *
-     * @param str A hex string, with or without the 0x prefix
+     * @param str - A hex string, with or without the 0x prefix.
      *
-     * @returns Hex
+     * @throws ParsingError - If the hex string is too short, has an odd number of characters, or contains invalid hex characters.
+     *
+     * @returns Hex - The resulting Hex instance created from the provided string.
      */
     static fromHexString(str: string): Hex;
     /**
-     * Static method to convert an instance of HexInput to Hex
-     *
-     * @param hexInput A HexInput (string or Uint8Array)
+     * Converts an instance of HexInput, which can be a string or a Uint8Array, into a Hex instance.
+     * This function is useful for transforming hexadecimal representations into a structured Hex object for further manipulation.
      *
-     * @returns Hex
+     * @param hexInput - A HexInput which can be a string or Uint8Array.
+     * @returns A Hex instance created from the provided hexInput.
      */
     static fromHexInput(hexInput: HexInput): Hex;
     /**
-     * Check if the string is valid hex.
+     * Check if the provided string is a valid hexadecimal representation.
      *
-     * @param str A hex string representing byte data.
+     * @param str - A hex string representing byte data.
      *
-     * @returns valid = true if the string is valid, false if not. If the string is not
-     * valid, invalidReason and invalidReasonMessage will be set explaining why it is
-     * invalid.
+     * @returns An object containing:
+     *  - valid: A boolean indicating whether the string is valid.
+     *  - invalidReason: The reason for invalidity if the string is not valid.
+     *  - invalidReasonMessage: A message explaining why the string is invalid.
      */
     static isValid(str: string): ParsingResult<HexInvalidReason>;
     /**
-     * Return whether Hex instances are equal. Hex instances are considered equal if
-     * their underlying byte data is identical.
+     * Determine if two Hex instances are equal by comparing their underlying byte data.
      *
      * @param other The Hex instance to compare to.
      * @returns true if the Hex instances are equal, false if not.
@@ -1792,38 +2174,86 @@ declare class Hex {
     equals(other: Hex): boolean;
 }
 
+/**
+ * This class serves as a base class for all serializable types. It facilitates
+ * composable serialization of complex types and enables the serialization of
+ * instances to their BCS (Binary Canonical Serialization) representation.
+ */
 declare abstract class Serializable {
     abstract serialize(serializer: Serializer): void;
     /**
      * Serializes a `Serializable` value to its BCS representation.
-     * This function is the Typescript SDK equivalent of `bcs::to_bytes` in Move.
-     * @returns the BCS representation of the Serializable instance as a byte buffer
+     * This function is the TypeScript SDK equivalent of `bcs::to_bytes` in Move.
+     * @returns the BCS representation of the Serializable instance as a byte buffer.
      */
     bcsToBytes(): Uint8Array;
     /**
-     * Helper function to get a value's BCS-serialized bytes as a Hex instance.
-     * @returns a Hex instance with the BCS-serialized bytes loaded into its underlying Uint8Array
+     * Converts the BCS-serialized bytes of a value into a Hex instance.
+     * This function provides a Hex representation of the BCS-serialized data for easier handling and manipulation.
+     * @returns A Hex instance with the BCS-serialized bytes loaded into its underlying Uint8Array.
      */
     bcsToHex(): Hex;
+    /**
+     * Returns the hex string representation of the `Serializable` value without the 0x prefix.
+     * @returns the hex format as a string without `0x` prefix.
+     */
+    toStringWithoutPrefix(): string;
+    /**
+     * Returns the hex string representation of the `Serializable` value with the 0x prefix.
+     * @returns the hex formatas a string prefixed by `0x`.
+     */
+    toString(): string;
 }
+/**
+ * A class for serializing various data types into a binary format.
+ * It provides methods to serialize strings, bytes, numbers, and other serializable objects
+ * using the Binary Coded Serialization (BCS) layout. The serialized data can be retrieved as a
+ * Uint8Array.
+ */
 declare class Serializer {
     private buffer;
     private offset;
+    /**
+     * Constructs a serializer with a buffer of size `length` bytes, 64 bytes by default.
+     * The `length` must be greater than 0.
+     *
+     * @param length - The size of the buffer in bytes.
+     */
     constructor(length?: number);
+    /**
+     * Ensures that the internal buffer can accommodate the specified number of bytes.
+     * This function dynamically resizes the buffer if the current size is insufficient.
+     *
+     * @param bytes - The number of bytes to ensure the buffer can handle.
+     */
     private ensureBufferWillHandleSize;
+    /**
+     * Appends the specified values to the buffer, ensuring that the buffer can accommodate the new data.
+     *
+     * @param {Uint8Array} values - The values to be appended to the buffer.
+     */
     protected appendToBuffer(values: Uint8Array): void;
+    /**
+     * Serializes a value into the buffer using the provided function, ensuring the buffer can accommodate the size.
+     *
+     * @param fn - The function to serialize the value, which takes a byte offset, the value to serialize, and an optional little-endian flag.
+     * @param fn.byteOffset - The byte offset at which to write the value.
+     * @param fn.value - The numeric value to serialize into the buffer.
+     * @param fn.littleEndian - Optional flag indicating whether to use little-endian byte order (defaults to true).
+     */
     private serializeWithFunction;
     /**
      * Serializes a string. UTF8 string is supported.
-     *
      * The number of bytes in the string content is serialized first, as a uleb128-encoded u32 integer.
      * Then the string content is serialized as UTF8 encoded bytes.
      *
      * BCS layout for "string": string_length | string_content
      * where string_length is a u32 integer encoded as a uleb128 integer, equal to the number of bytes in string_content.
      *
+     * @param value - The string to serialize.
+     *
      * @example
-     * ```ts
+     * ```typescript
      * const serializer = new Serializer();
      * serializer.serializeStr("1234abcd");
      * assert(serializer.toUint8Array() === new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));
@@ -1833,35 +2263,47 @@ declare class Serializer {
     /**
      * Serializes an array of bytes.
      *
+     * This function encodes the length of the byte array as a u32 integer in uleb128 format, followed by the byte array itself.
      * BCS layout for "bytes": bytes_length | bytes
      * where bytes_length is a u32 integer encoded as a uleb128 integer, equal to the length of the bytes array.
+     * @param value - The byte array to serialize.
      */
     serializeBytes(value: Uint8Array): void;
     /**
-     * Serializes an array of bytes with known length. Therefore, length doesn't need to be
-     * serialized to help deserialization.
-     *
+     * Serializes an array of bytes with a known length, allowing for efficient deserialization without needing to serialize the
+     * length itself.
      * When deserializing, the number of bytes to deserialize needs to be passed in.
+  
+     * @param value - The Uint8Array to be serialized.
      */
     serializeFixedBytes(value: Uint8Array): void;
     /**
-     * Serializes a boolean value.
+     * Serializes a boolean value into a byte representation.
+     *
+     * The BCS layout for a boolean uses one byte, where "0x01" represents true and "0x00" represents false.
      *
-     * BCS layout for "boolean": One byte. "0x01" for true and "0x00" for false.
+     * @param value - The boolean value to serialize.
      */
     serializeBool(value: boolean): void;
     /**
-     * Serializes a uint8 number.
-     *
+     * Serializes a Uint8 value and appends it to the buffer.
      * BCS layout for "uint8": One byte. Binary format in little-endian representation.
+     *
+     * @param value - The Uint8 value to serialize.
      */
     serializeU8(value: Uint8): void;
     /**
      * Serializes a uint16 number.
      *
+  
+     */
+    /**
+     * Serializes a 16-bit unsigned integer value into a binary format.
      * BCS layout for "uint16": Two bytes. Binary format in little-endian representation.
+     *
+     * @param value - The 16-bit unsigned integer value to serialize.
      * @example
-     * ```ts
+     * ```typescript
      * const serializer = new Serializer();
      * serializer.serializeU16(4660);
      * assert(serializer.toUint8Array() === new Uint8Array([0x34, 0x12]));
@@ -1869,21 +2311,22 @@ declare class Serializer {
      */
     serializeU16(value: Uint16): void;
     /**
-     * Serializes a uint32 number.
-     *
-     * BCS layout for "uint32": Four bytes. Binary format in little-endian representation.
+     * Serializes a 32-bit unsigned integer value into a binary format.
+     * This function is useful for encoding data that needs to be stored or transmitted in a compact form.
      * @example
-     * ```ts
+     * ```typescript
      * const serializer = new Serializer();
      * serializer.serializeU32(305419896);
      * assert(serializer.toUint8Array() === new Uint8Array([0x78, 0x56, 0x34, 0x12]));
      * ```
+     * @param value - The 32-bit unsigned integer value to serialize.
      */
     serializeU32(value: Uint32): void;
     /**
-     * Serializes a uint64 number.
+     * Serializes a 64-bit unsigned integer into a format suitable for storage or transmission.
+     * This function breaks down the value into two 32-bit components and writes them in little-endian order.
      *
-     * BCS layout for "uint64": Eight bytes. Binary format in little-endian representation.
+     * @param value - The 64-bit unsigned integer to serialize, represented as a number.
      * @example
      * ```ts
      * const serializer = new Serializer();
@@ -1893,66 +2336,44 @@ declare class Serializer {
      */
     serializeU64(value: AnyNumber): void;
     /**
-     * Serializes a uint128 number.
+     * Serializes a U128 value into a format suitable for storage or transmission.
      *
-     * BCS layout for "uint128": Sixteen bytes. Binary format in little-endian representation.
+     * @param value - The U128 value to serialize, represented as a number.
      */
     serializeU128(value: AnyNumber): void;
     /**
-     * Serializes a uint256 number.
+     * Serializes a U256 value into a byte representation.
+     * This function is essential for encoding large numbers in a compact format suitable for transmission or storage.
      *
-     * BCS layout for "uint256": Sixteen bytes. Binary format in little-endian representation.
+     * @param value - The U256 value to serialize, represented as an AnyNumber.
      */
     serializeU256(value: AnyNumber): void;
     /**
-     * Serializes a uint32 number with uleb128.
-     *
+     * Serializes a 32-bit unsigned integer as a variable-length ULEB128 encoded byte array.
      * BCS uses uleb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values
+     *
+     * @param val - The 32-bit unsigned integer value to be serialized.
      */
     serializeU32AsUleb128(val: Uint32): void;
     /**
-     * Returns the buffered bytes
+     * Returns the buffered bytes as a Uint8Array.
+     *
+     * This function allows you to retrieve the byte representation of the buffer up to the current offset.
+     *
+     * @returns Uint8Array - The byte array representation of the buffer.
      */
     toUint8Array(): Uint8Array;
     /**
      * Serializes a `Serializable` value, facilitating composable serialization.
      *
-     * @param value The Serializable value to serialize
-     *
-     * @example
-     * // Define the MoveStruct class that implements the Serializable interface
-     * class MoveStruct extends Serializable {
-     *     constructor(
-     *         public creatorAddress: AccountAddress, // where AccountAddress extends Serializable
-     *         public collectionName: string,
-     *         public tokenName: string
-     *     ) {}
-     *
-     *     serialize(serializer: Serializer): void {
-     *         serializer.serialize(this.creatorAddress);  // Composable serialization of another Serializable object
-     *         serializer.serializeStr(this.collectionName);
-     *         serializer.serializeStr(this.tokenName);
-     *     }
-     * }
-     *
-     * // Construct a MoveStruct
-     * const moveStruct = new MoveStruct(new AccountAddress(...), "MyCollection", "TokenA");
-     *
-     * // Serialize a string, a u64 number, and a MoveStruct instance.
-     * const serializer = new Serializer();
-     * serializer.serializeStr("ExampleString");
-     * serializer.serializeU64(12345678);
-     * serializer.serialize(moveStruct);
-     *
-     * // Get the bytes from the Serializer instance
-     * const serializedBytes = serializer.toUint8Array();
+     * @param value The Serializable value to serialize.
      *
      * @returns the serializer instance
      */
     serialize<T extends Serializable>(value: T): void;
     /**
      * Serializes an array of BCS Serializable values to a serializer instance.
-     * Note that this does not return anything. The bytes are added to the serializer instance's byte buffer.
+     * The bytes are added to the serializer instance's byte buffer.
      *
      * @param values The array of BCS Serializable values
      * @example
@@ -1971,13 +2392,13 @@ declare class Serializer {
      */
     serializeVector<T extends Serializable>(values: Array<T>): void;
     /**
-     * Serializes a BCS Serializable values into a serializer instance or undefined.
-     * Note that this does not return anything. The bytes are added to the serializer instance's byte buffer.
+     * Serializes a BCS Serializable value into a serializer instance or handles the case when the value is undefined.
+     * This function allows you to efficiently add serialized data to the serializer's byte buffer.
      *
-     * @param values The array of BCS Serializable values
+     * @param value The BCS Serializable value to serialize, or undefined if there is no value.
      *
      * @example
-     * ```ts
+     * ```typescript
      * const serializer = new Serializer();
      * serializer.serializeOption(new AccountAddress(...));
      * const serializedBytes = serializer.toUint8Array();
@@ -1990,48 +2411,67 @@ declare class Serializer {
      */
     serializeOption<T extends Serializable>(value?: T): void;
     /**
-     * Serializes an optional string. UTF8 string is supported.
-     *
-     * The existence of the string is encoded first, 0 if undefined and 1 if it exists.
-     * Them the number of bytes in the string content is serialized, as a uleb128-encoded u32 integer.
-     * Then the string content is serialized as UTF8 encoded bytes.
+     * Serializes an optional string, supporting UTF8 encoding.
+     * The function encodes the existence of the string first, followed by the length and content if it exists.
      *
      * BCS layout for optional "string": 1 | string_length | string_content
      * where string_length is a u32 integer encoded as a uleb128 integer, equal to the number of bytes in string_content.
-     *
      * BCS layout for undefined: 0
-     * @example
-     * ```ts
-     * const serializer = new Serializer();
-     * serializer.serializeOptionStr("1234abcd");
-     * assert(serializer.toUint8Array() === new Uint8Array([1, 8, 49, 50, 51, 52, 97, 98, 99, 100]));
      *
-     * const serializer = new Serializer();
-     * serializer.serializeOptionStr(undefined);
-     * assert(serializer.toUint8Array() === new Uint8Array([0]));
-     * ```
+     * @param value - The optional string to serialize. If undefined, it will serialize as 0.
      */
     serializeOptionStr(value?: string): void;
 }
 declare function ensureBoolean(value: unknown): asserts value is boolean;
 declare const outOfRangeErrorMessage: (value: AnyNumber, min: AnyNumber, max: AnyNumber) => string;
+/**
+ * Validates that a given number is within a specified range.
+ * This function throws an error if the value is outside the defined minimum and maximum bounds.
+ *
+ * @param value - The number to validate.
+ * @param minValue - The minimum allowable value (inclusive).
+ * @param maxValue - The maximum allowable value (inclusive).
+ */
 declare function validateNumberInRange<T extends AnyNumber>(value: T, minValue: T, maxValue: T): void;
 
 interface TransactionArgument extends EntryFunctionArgument, ScriptFunctionArgument {
 }
+/**
+ * Represents an argument for entry functions, providing methods to serialize the argument
+ * to BCS-serialized bytes and convert it to different formats.
+ */
 interface EntryFunctionArgument {
     /**
      * Serialize an argument to BCS-serialized bytes.
+     *
+     * @param serializer - The serializer instance used for serialization.
      */
     serialize(serializer: Serializer): void;
     /**
+     * Serialize an argument to BCS-serialized bytes.
      * Serialize an argument as a type-agnostic, fixed byte sequence. The byte sequence contains
      * the number of the following bytes followed by the BCS-serialized bytes for a typed argument.
+     *
+     * @param serializer - The serializer used to convert the argument.
      */
     serializeForEntryFunction(serializer: Serializer): void;
+    /**
+     * Convert the argument to BCS-serialized bytes.
+     *
+     * @returns Uint8Array representing the BCS-serialized bytes of the argument.
+     */
     bcsToBytes(): Uint8Array;
+    /**
+     * Converts the BCS-serialized bytes of an argument into a hexadecimal representation.
+     * This function is useful for obtaining a Hex instance that encapsulates the BCS-serialized bytes,
+     * allowing for easier manipulation and representation of the data.
+     * @returns A Hex instance containing the BCS-serialized bytes.
+     */
     bcsToHex(): Hex;
 }
+/**
+ * Represents an argument for script functions, providing methods to serialize and convert to bytes.
+ */
 interface ScriptFunctionArgument {
     /**
      * Serialize an argument to BCS-serialized bytes.
@@ -2048,7 +2488,7 @@ interface ScriptFunctionArgument {
 }
 
 /**
- * This enum is used to explain why an address was invalid.
+ * Provides reasons for an address was invalid.
  */
 declare enum AddressInvalidReason {
     INCORRECT_NUMBER_OF_BYTES = "incorrect_number_of_bytes",
@@ -2059,6 +2499,9 @@ declare enum AddressInvalidReason {
     LONG_FORM_REQUIRED_UNLESS_SPECIAL = "long_form_required_unless_special",
     INVALID_PADDING_ZEROES = "INVALID_PADDING_ZEROES"
 }
+/**
+ * The input for an account address, which can be either a hexadecimal string or a standard account address.
+ */
 type AccountAddressInput = HexInput | AccountAddress;
 /**
  * NOTE: Only use this class for account addresses. For other hex data, e.g. transaction
@@ -2098,68 +2541,60 @@ declare class AccountAddress extends Serializable implements TransactionArgument
     /**
      * Creates an instance of AccountAddress from a Uint8Array.
      *
-     * @param args.data A Uint8Array representing an account address.
+     * This function ensures that the input data is exactly 32 bytes long, which is required for a valid account address.
+     *
+     * @param input A Uint8Array representing an account address.
+     * @throws ParsingError if the input length is not equal to 32 bytes.
      */
     constructor(input: Uint8Array);
     /**
-     * Returns whether an address is special, where special is defined as 0x0 to 0xf
-     * inclusive. In other words, the last byte of the address must be < 0b10000 (16)
+     * Determines if the address is classified as special, which is defined as 0x0 to 0xf inclusive.
+     * In other words, the last byte of the address must be < 0b10000 (16)
      * and every other byte must be zero.
      *
-     * For more information on how special addresses are defined see AIP-40:
+     * For more information on how special addresses are defined, see AIP-40:
      * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
      *
-     * @returns true if the address is special, false if not.
+     * @returns true if the address is special, false otherwise.
      */
     isSpecial(): boolean;
     /**
      * Return the AccountAddress as a string as per AIP-40.
      * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
-     *
-     * In short, it means that special addresses are represented in SHORT form, meaning
-     * 0x0 through to 0xf inclusive, and every other address is represented in LONG form,
-     * meaning 0x + 64 hex characters.
+     * This representation returns special addresses in SHORT form (0xf)
+     * and other addresses in LONG form (0x + 64 characters).
      *
      * @returns AccountAddress as a string conforming to AIP-40.
      */
     toString(): `0x${string}`;
     /**
-     * NOTE: Prefer to use `toString` where possible.
+     * Return the AccountAddress as a string conforming to AIP-40 but without the leading 0x.
      *
-     * Return the AccountAddress as a string as per AIP-40 but without the leading 0x.
-     *
-     * Learn more by reading the docstring of `toString`.
+     * NOTE: Prefer to use `toString` where possible.
      *
-     * @returns AccountAddress as a string conforming to AIP-40 but without the leading 0x.
+     * @returns AccountAddress as a string without the leading 0x.
      */
     toStringWithoutPrefix(): string;
     /**
-     * NOTE: Prefer to use `toString` where possible.
+     * Convert the account address to a string in LONG format, which is always 0x followed by 64 hex characters.
      *
-     * Whereas toString will format special addresses (as defined by isSpecial) using the
-     * SHORT form (no leading 0s), this format the address in the LONG format
-     * unconditionally.
-     *
-     * This means it will be 0x + 64 hex characters.
+     * NOTE: Prefer to use `toString` where possible, as it formats special addresses using the SHORT form (no leading 0s).
      *
      * @returns AccountAddress as a string in LONG form.
      */
     toStringLong(): `0x${string}`;
     /**
-     * NOTE: Prefer to use `toString` where possible.
-     *
-     * Whereas toString will format special addresses (as defined by isSpecial) using the
-     * SHORT form (no leading 0s), this function will include leading zeroes. The string
-     * will not have a leading zero.
+     * Returns the account address as a string in LONG form without a leading 0x.
+     * This function will include leading zeroes and will produce a string of 64 hex characters.
      *
-     * This means it will be 64 hex characters without a leading 0x.
+     * NOTE: Prefer to use `toString` where possible, as it formats special addresses using the SHORT form (no leading 0s).
      *
-     * @returns AccountAddress as a string in LONG form without a leading 0x.
+     * @returns {string} The account address in LONG form.
      */
     toStringLongWithoutPrefix(): string;
     /**
-     * Get the inner hex data. The inner data is already a Uint8Array so no conversion
-     * is taking place here, it just returns the inner data.
+     * Get the inner data as a Uint8Array.
+     * The inner data is already a Uint8Array, so no conversion takes place.
      *
      * @returns Hex data as Uint8Array
      */
@@ -2176,10 +2611,23 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      * // `bytes` is now the BCS-serialized address.
      */
     serialize(serializer: Serializer): void;
+    /**
+     * Serializes the current instance into a byte sequence suitable for entry functions.
+     * This allows for the proper encoding of data when interacting with entry functions in the blockchain.
+     *
+     * @param serializer - The serializer instance used to convert the data into bytes.
+     */
     serializeForEntryFunction(serializer: Serializer): void;
+    /**
+     * Serializes the current instance for use in a script function by encoding it into a byte sequence.
+     * This process involves serializing the variant index and the instance data, making it suitable for transmission.
+     *
+     * @param serializer - The serializer instance used to perform the serialization.
+     */
     serializeForScriptFunction(serializer: Serializer): void;
     /**
      * Deserialize an AccountAddress from the byte buffer in a Deserializer instance.
+     * This function allows you to convert a byte representation of an AccountAddress into an instance of AccountAddress.
      * @param deserializer The deserializer to deserialize the AccountAddress from.
      * @returns An instance of AccountAddress.
      * @example
@@ -2209,10 +2657,14 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      * - SHORT for non-special addresses.
      * - Any address without a leading 0x.
      *
-     * Learn more about the different address formats by reading AIP-40:
-     * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+     * @param input - A hex string representing an account address.
+     *
+     * @throws {ParsingError} If the hex string does not start with 0x or is not in a valid format.
      *
-     * @param input A hex string representing an account address.
+     * @note This function has strict parsing behavior. For relaxed behavior, please use the `fromString` function.
+     *
+     * @see AIP-40 documentation for more details on address formats:
+     * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
      *
      * @returns An instance of AccountAddress.
      */
@@ -2238,43 +2690,46 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      * Learn more about the different address formats by reading AIP-40:
      * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
      *
-     * @param input A hex string representing an account address.
+     * @param input - A hex string representing an account address.
      *
      * @returns An instance of AccountAddress.
+     *
+     * @throws ParsingError if the hex string is too short, too long, or contains invalid characters.
      */
     static fromString(input: string): AccountAddress;
     /**
-     * Convenience method for creating an AccountAddress from all known inputs.
+     * Convenience method for creating an AccountAddress from various input types.
+     * This function accepts a string, Uint8Array, or an existing AccountAddress instance and returns the corresponding
+     * AccountAddress.
      *
-     * This handles, Uint8array, string, and AccountAddress itself
-     * @param input
+     * @param input - The input to convert into an AccountAddress. This can be a string representation of an address, a Uint8Array,
+     * or an existing AccountAddress.
      */
     static from(input: AccountAddressInput): AccountAddress;
     /**
-     * Convenience method for creating an AccountAddress from all known inputs.
+     * Create an AccountAddress from various input types, including strings, Uint8Array, and AccountAddress instances.
      *
-     * This handles, Uint8array, string, and AccountAddress itself
-     * @param input
+     * @param input - The input to convert into an AccountAddress, which can be a string, a Uint8Array, or an AccountAddress.
      */
     static fromStrict(input: AccountAddressInput): AccountAddress;
     /**
-     * Check if the string is a valid AccountAddress.
+     * Check if the provided input is a valid AccountAddress.
      *
-     * @param args.input A hex string representing an account address.
-     * @param args.strict If true, use strict parsing behavior. If false, use relaxed parsing behavior.
+     * @param args - The arguments for validation.
+     * @param args.input - A hex string representing an account address.
+     * @param args.strict - If true, use strict parsing behavior; if false, use relaxed parsing behavior.
      *
-     * @returns valid = true if the string is valid, valid = false if not. If the string
-     * is not valid, invalidReason will be set explaining why it is invalid.
+     * @returns An object indicating whether the address is valid. If valid, valid = true; if not, valid = false with additional details.
+     * If the address is invalid, invalidReason will explain why it is invalid, and invalidReasonMessage will provide the error message.
      */
     static isValid(args: {
         input: AccountAddressInput;
         strict?: boolean;
     }): ParsingResult<AddressInvalidReason>;
     /**
-     * Return whether AccountAddresses are equal. AccountAddresses are considered equal
-     * if their underlying byte data is identical.
+     * Determine if two AccountAddresses are equal based on their underlying byte data.
      *
-     * @param other The AccountAddress to compare to.
+     * @param other - The AccountAddress to compare to.
      * @returns true if the AccountAddresses are equal, false if not.
      */
     equals(other: AccountAddress): boolean;