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

package/dist/common/{accountAddress-fJZJVSBc.d.ts → accountAddress-Cf1amU98.d.ts}

@@ -421,6 +421,8 @@ type GetTokenDataQuery = {
  *
  * These types are used as the return type when making the actual request (usually
  * under the /internal/ folder)
+ * @group Implementation
+ * @category Types
  */
 
 /**
@@ -432,118 +434,190 @@ type GetTokenDataQuery = {
  *
  * These types are used as the return type when calling a sdk api function
  * that calls the function that queries the server (usually under the /api/ folder)
+ * @group Implementation
+ * @category Types
  */
 type GetObjectDataQueryResponse = GetObjectDataQuery["current_objects"];
 /**
  * The response structure for querying tokens owned by an account.
+ * @group Implementation
+ * @category Types
  */
 type GetAccountOwnedTokensQueryResponse = GetAccountOwnedTokensQuery["current_token_ownerships_v2"];
 /**
  * The response containing the current token ownerships for an account from a specific collection.
+ * @group Implementation
+ * @category Types
  */
 type GetAccountOwnedTokensFromCollectionResponse = GetAccountOwnedTokensFromCollectionQuery["current_token_ownerships_v2"];
 /**
  * The response structure for retrieving account collections associated with owned tokens.
+ * @group Implementation
+ * @category Types
  */
 type GetAccountCollectionsWithOwnedTokenResponse = GetAccountCollectionsWithOwnedTokensQuery["current_collection_ownership_v2_view"];
 /**
  * The current balances of fungible assets for an account.
+ * @group Implementation
+ * @category Types
  */
 type GetAccountCoinsDataResponse = GetAccountCoinsDataQuery["current_fungible_asset_balances"];
 /**
  * The response structure for retrieving user transactions from the top of the blockchain.
+ * @group Implementation
+ * @category Types
  */
 type GetChainTopUserTransactionsResponse = GetChainTopUserTransactionsQuery["user_transactions"];
 /**
  * The response containing the events from the GetEventsQuery.
+ * @group Implementation
+ * @category Types
  */
 type GetEventsResponse = GetEventsQuery["events"];
 /**
  * The number of active delegators per pool in response to a query.
+ * @group Implementation
+ * @category Types
  */
 type GetNumberOfDelegatorsResponse = GetNumberOfDelegatorsQuery["num_active_delegator_per_pool"];
 /**
  * The response containing the delegated staking activities from the query.
+ * @group Implementation
+ * @category Types
  */
 type GetDelegatedStakingActivitiesResponse = GetDelegatedStakingActivitiesQuery["delegated_staking_activities"];
 /**
  * The response structure for retrieving data from the current collections.
+ * @group Implementation
+ * @category Types
  */
 type GetCollectionDataResponse = GetCollectionDataQuery["current_collections_v2"][0];
 /**
  * The response structure for retrieving token data, containing the current token information.
+ * @group Implementation
+ * @category Types
  */
 type GetTokenDataResponse = GetTokenDataQuery["current_token_datas_v2"][0];
 /**
  * The status of the processor as returned by the GetProcessorStatusQuery.
+ * @group Implementation
+ * @category Types
  */
 type GetProcessorStatusResponse = GetProcessorStatusQuery["processor_status"];
 /**
  * The response containing metadata for a fungible asset.
+ * @group Implementation
+ * @category Types
  */
 type GetFungibleAssetMetadataResponse = GetFungibleAssetMetadataQuery["fungible_asset_metadata"];
 /**
  * The response containing the activities related to fungible assets.
+ * @group Implementation
+ * @category Types
  */
 type GetFungibleAssetActivitiesResponse = GetFungibleAssetActivitiesQuery["fungible_asset_activities"];
 /**
  * The current balances of fungible assets for a specific query.
+ * @group Implementation
+ * @category Types
  */
 type GetCurrentFungibleAssetBalancesResponse = GetCurrentFungibleAssetBalancesQuery["current_fungible_asset_balances"];
 /**
  * The response structure for retrieving token activity data.
+ * @group Implementation
+ * @category Types
  */
 type GetTokenActivityResponse = GetTokenActivityQuery["token_activities_v2"];
 /**
  * The response structure for retrieving the current token ownership details.
+ * @group Implementation
+ * @category Types
  */
 type GetCurrentTokenOwnershipResponse = GetCurrentTokenOwnershipQuery["current_token_ownerships_v2"][0];
 /**
  * The response containing the current token ownerships for a user.
+ * @group Implementation
+ * @category Types
  */
 type GetOwnedTokensResponse = GetCurrentTokenOwnershipQuery["current_token_ownerships_v2"];
 /**
  * The response structure for retrieving items from a table.
+ * @group Implementation
+ * @category Types
  */
 type GetTableItemsDataResponse = GetTableItemsDataQuery["table_items"];
 /**
  * The metadata for table items retrieved from a query.
+ * @group Implementation
+ * @category Types
  */
 type GetTableItemsMetadataResponse = GetTableItemsMetadataQuery["table_metadatas"];
 /**
  * The response containing the current Aptos names from the GetNamesQuery.
+ * @group Implementation
+ * @category Types
  */
 type GetANSNameResponse = GetNamesQuery["current_aptos_names"];
 /**
  * A generic type that being passed by each function and holds an
  * array of properties we can sort the query by
+ * @group Implementation
+ * @category Types
  */
 type OrderBy<T> = Array<{
     [K in keyof T]?: OrderByValue;
 }>;
 /**
  * Specifies the order direction for sorting, including options for handling null values.
+ * @group Implementation
+ * @category Types
  */
 type OrderByValue = "asc" | "asc_nulls_first" | "asc_nulls_last" | "desc" | "desc_nulls_first" | "desc_nulls_last";
 /**
  * The token standard to query for, which can be either version "v1" or "v2".
+ * @group Implementation
+ * @category Types
  */
 type TokenStandard = "v1" | "v2";
 /**
  * The GraphQL query to pass into the `queryIndexer` function.
+ * @group Implementation
+ * @category Types
  */
 type GraphqlQuery = {
     query: string;
     variables?: {};
 };
 
+/**
+ * @group Implementation
+ * @category Network
+ */
 declare const NetworkToIndexerAPI: Record<string, string>;
+/**
+ * @group Implementation
+ * @category Network
+ */
 declare const NetworkToNodeAPI: Record<string, string>;
+/**
+ * @group Implementation
+ * @category Network
+ */
 declare const NetworkToFaucetAPI: Record<string, string>;
+/**
+ * @group Implementation
+ * @category Network
+ */
 declare const NetworkToPepperAPI: Record<string, string>;
+/**
+ * @group Implementation
+ * @category Network
+ */
 declare const NetworkToProverAPI: Record<string, string>;
 /**
  * Different network environments for connecting to services, ranging from production to development setups.
+ * @group Implementation
+ * @category Network
  */
 declare enum Network {
     MAINNET = "mainnet",
@@ -552,7 +626,15 @@ declare enum Network {
     LOCAL = "local",
     CUSTOM = "custom"
 }
+/**
+ * @group Implementation
+ * @category Network
+ */
 declare const NetworkToChainId: Record<string, number>;
+/**
+ * @group Implementation
+ * @category Network
+ */
 declare const NetworkToNetworkName: Record<string, Network>;
 
 /**
@@ -1846,6 +1928,8 @@ type GenerateAccount = GenerateAccountWithEd25519 | GenerateAccountWithSingleSig
  * for static methods in interfaces.
  *
  * @template T - The type that this will deserialize into.
+ * @group Implementation
+ * @category BCS
  */
 interface Deserializable<T> {
     /**
@@ -1862,12 +1946,16 @@ interface Deserializable<T> {
      * // value is now an instance of MyClass
      * // equivalent to `const value = MyClass.deserialize(deserializer)`
      * ```
+     * @group Implementation
+     * @category BCS
      */
     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.
+ * @group Implementation
+ * @category BCS
  */
 declare class Deserializer {
     private buffer;
@@ -1877,13 +1965,18 @@ declare class Deserializer {
      * This prevents outside mutation of the buffer.
      *
      * @param data - The data to be copied into the internal buffer as a Uint8Array.
+     * @group Implementation
+     * @category BCS
      */
     constructor(data: Uint8Array);
+    static fromHex(hex: HexInput): Deserializer;
     /**
      * 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.
+     * @group Implementation
+     * @category BCS
      */
     private read;
     /**
@@ -1892,10 +1985,11 @@ declare class Deserializer {
      * This information is useful to determine if there's more data to be read.
      *
      * @returns The number of bytes remaining in the buffer.
+     * @group Implementation
+     * @category BCS
      */
     remaining(): number;
     /**
-     * @deprecated use `deserializeOption` instead.
      * 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.
      *
@@ -1907,8 +2001,24 @@ declare class Deserializer {
      * const deserializer = new Deserializer(new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));
      * assert(deserializer.deserializeStr() === "1234abcd");
      * ```
+     * @group Implementation
+     * @category BCS
      */
     deserializeStr(): string;
+    /**
+     * @deprecated use `deserializeOption("string")` instead.
+     *
+     * 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
+     * ```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]));
+     * assert(deserializer.deserializeOptionStr() === "1234abcd");
+     * ```
+     */
+    deserializeOptionStr(): string | undefined;
     /**
      * Deserializes an optional value from the buffer.
      *
@@ -1944,6 +2054,8 @@ declare class Deserializer {
      * const optBytes = deserializer.deserializeOption("fixedBytes", 4);
      * // optBytes === Uint8Array[1, 2, 3, 4]
      * ```
+     * @group Implementation
+     * @category BCS
      */
     deserializeOption(type: "string"): string | undefined;
     deserializeOption(type: "bytes"): Uint8Array | undefined;
@@ -1956,12 +2068,16 @@ declare class Deserializer {
      * encoded as a uleb128 integer, indicating the length of the bytes array.
      *
      * @returns {Uint8Array} The deserialized array of bytes.
+     * @group Implementation
+     * @category BCS
      */
     deserializeBytes(): Uint8Array;
     /**
      * Deserializes an array of bytes of a specified length.
      *
      * @param len - The number of bytes to read from the source.
+     * @group Implementation
+     * @category BCS
      */
     deserializeFixedBytes(len: number): Uint8Array;
     /**
@@ -1972,6 +2088,8 @@ declare class Deserializer {
      *
      * @returns The deserialized boolean value.
      * @throws Throws an error if the boolean value is invalid.
+     * @group Implementation
+     * @category BCS
      */
     deserializeBool(): boolean;
     /**
@@ -1980,6 +2098,8 @@ declare class Deserializer {
      * BCS layout for "uint8": One byte. Binary format in little-endian representation.
      *
      * @returns {number} The deserialized uint8 number.
+     * @group Implementation
+     * @category BCS
      */
     deserializeU8(): Uint8;
     /**
@@ -1991,6 +2111,8 @@ declare class Deserializer {
      * const deserializer = new Deserializer(new Uint8Array([0x34, 0x12]));
      * assert(deserializer.deserializeU16() === 4660);
      * ```
+     * @group Implementation
+     * @category BCS
      */
     deserializeU16(): Uint16;
     /**
@@ -2002,6 +2124,8 @@ declare class Deserializer {
      * const deserializer = new Deserializer(new Uint8Array([0x78, 0x56, 0x34, 0x12]));
      * assert(deserializer.deserializeU32() === 305419896);
      * ```
+     * @group Implementation
+     * @category BCS
      */
     deserializeU32(): Uint32;
     /**
@@ -2013,6 +2137,8 @@ declare class Deserializer {
      * const deserializer = new Deserializer(new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]));
      * assert(deserializer.deserializeU64() === 1311768467750121216);
      * ```
+     * @group Implementation
+     * @category BCS
      */
     deserializeU64(): Uint64;
     /**
@@ -2020,6 +2146,8 @@ declare class Deserializer {
      * This function combines two 64-bit values to return a single uint128 value in little-endian format.
      *
      * @returns {BigInt} The deserialized uint128 number.
+     * @group Implementation
+     * @category BCS
      */
     deserializeU128(): Uint128;
     /**
@@ -2028,6 +2156,8 @@ declare class Deserializer {
      * The BCS layout for "uint256" consists of thirty-two bytes in little-endian format.
      *
      * @returns {BigInt} The deserialized uint256 number.
+     * @group Implementation
+     * @category BCS
      */
     deserializeU256(): Uint256;
     /**
@@ -2037,6 +2167,8 @@ declare class Deserializer {
      *
      * @throws {Error} Throws an error if the parsed value exceeds the maximum uint32 number.
      * @returns {number} The deserialized uint32 value.
+     * @group Implementation
+     * @category BCS
      */
     deserializeUleb128AsU32(): Uint32;
     /**
@@ -2051,6 +2183,8 @@ declare class Deserializer {
      * @param cls The BCS-deserializable class to deserialize the buffered bytes into.
      *
      * @returns the deserialized value of class type T
+     * @group Implementation
+     * @category BCS
      */
     deserialize<T>(cls: Deserializable<T>): T;
     /**
@@ -2074,18 +2208,24 @@ declare class Deserializer {
      * const deserializer = new Deserializer(serializedBytes);
      * const deserializedAddresses = deserializer.deserializeVector(AccountAddress);
      * // deserializedAddresses is now an array of AccountAddress instances
+     * @group Implementation
+     * @category BCS
      */
     deserializeVector<T>(cls: Deserializable<T>): Array<T>;
 }
 
 /**
  * This error is used to explain why parsing failed.
+ * @group Implementation
+ * @category Serialization
  */
 declare class ParsingError<T> extends Error {
     /**
      * This provides a programmatic way to access why parsing failed. Downstream devs
      * might want to use this to build their own error messages if the default error
      * messages are not suitable for their use case. This should be an enum.
+     * @group Implementation
+     * @category Serialization
      */
     invalidReason: T;
     /**
@@ -2093,30 +2233,42 @@ declare class ParsingError<T> extends Error {
      *
      * @param message The error message that describes the issue.
      * @param invalidReason The reason why the input is considered invalid.
+     * @group Implementation
+     * @category Serialization
      */
     constructor(message: string, invalidReason: T);
 }
 /**
  * Whereas ParsingError is thrown when parsing fails, e.g. in a fromString function,
  * this type is returned from "defensive" functions like isValid.
+ * @group Implementation
+ * @category Serialization
  */
 type ParsingResult<T> = {
     /**
      * True if valid, false otherwise.
+     * @group Implementation
+     * @category Serialization
      */
     valid: boolean;
     /**
      * If valid is false, this will be a code explaining why parsing failed.
+     * @group Implementation
+     * @category Serialization
      */
     invalidReason?: T;
     /**
      * If valid is false, this will be a string explaining why parsing failed.
+     * @group Implementation
+     * @category Serialization
      */
     invalidReasonMessage?: string;
 };
 
 /**
  * Provides reasons for parsing failures related to hexadecimal values.
+ * @group Implementation
+ * @category Serialization
  */
 declare enum HexInvalidReason {
     TOO_SHORT = "too_short",
@@ -2146,6 +2298,8 @@ declare enum HexInvalidReason {
  * Other ways to chain the functions together:
  * - `Hex.fromHexString({ hexInput: "0x1f" }).toUint8Array()`
  * - `new Hex([1, 3]).toStringWithoutPrefix()`
+ * @group Implementation
+ * @category Serialization
  */
 declare class Hex {
     private readonly data;
@@ -2153,24 +2307,32 @@ declare class Hex {
      * Create a new Hex instance from a Uint8Array.
      *
      * @param data - The Uint8Array containing the data to initialize the Hex instance.
+     * @group Implementation
+     * @category Serialization
      */
     constructor(data: Uint8Array);
     /**
      * 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
+     * @group Implementation
+     * @category Serialization
      */
     toUint8Array(): Uint8Array;
     /**
      * Get the hex data as a string without the 0x prefix.
      *
      * @returns Hex string without 0x prefix
+     * @group Implementation
+     * @category Serialization
      */
     toStringWithoutPrefix(): string;
     /**
      * Get the hex data as a string with the 0x prefix.
      *
      * @returns Hex string with 0x prefix
+     * @group Implementation
+     * @category Serialization
      */
     toString(): string;
     /**
@@ -2181,6 +2343,8 @@ declare class 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.
+     * @group Implementation
+     * @category Serialization
      */
     static fromHexString(str: string): Hex;
     /**
@@ -2189,6 +2353,8 @@ declare class Hex {
      *
      * @param hexInput - A HexInput which can be a string or Uint8Array.
      * @returns A Hex instance created from the provided hexInput.
+     * @group Implementation
+     * @category Serialization
      */
     static fromHexInput(hexInput: HexInput): Hex;
     /**
@@ -2235,6 +2401,8 @@ declare class Hex {
      *  - 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.
+     * @group Implementation
+     * @category Serialization
      */
     static isValid(str: string): ParsingResult<HexInvalidReason>;
     /**
@@ -2242,6 +2410,8 @@ declare class Hex {
      *
      * @param other The Hex instance to compare to.
      * @returns true if the Hex instances are equal, false if not.
+     * @group Implementation
+     * @category Serialization
      */
     equals(other: Hex): boolean;
 }
@@ -2251,6 +2421,8 @@ declare const hexToAsciiString: (hex: string) => string;
  * 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.
+ * @group Implementation
+ * @category BCS
  */
 declare abstract class Serializable {
     abstract serialize(serializer: Serializer): void;
@@ -2258,12 +2430,16 @@ declare abstract class Serializable {
      * 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.
+     * @group Implementation
+     * @category BCS
      */
     bcsToBytes(): 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.
+     * @group Implementation
+     * @category BCS
      */
     bcsToHex(): Hex;
     /**
@@ -2282,6 +2458,8 @@ declare abstract class Serializable {
  * 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.
+ * @group Implementation
+ * @category BCS
  */
 declare class Serializer {
     private buffer;
@@ -2291,6 +2469,8 @@ declare class Serializer {
      * The `length` must be greater than 0.
      *
      * @param length - The size of the buffer in bytes.
+     * @group Implementation
+     * @category BCS
      */
     constructor(length?: number);
     /**
@@ -2298,12 +2478,16 @@ declare class Serializer {
      * This function dynamically resizes the buffer if the current size is insufficient.
      *
      * @param bytes - The number of bytes to ensure the buffer can handle.
+     * @group Implementation
+     * @category BCS
      */
     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.
+     * @group Implementation
+     * @category BCS
      */
     protected appendToBuffer(values: Uint8Array): void;
     /**
@@ -2313,6 +2497,8 @@ declare class Serializer {
      * @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).
+     * @group Implementation
+     * @category BCS
      */
     private serializeWithFunction;
     /**
@@ -2331,6 +2517,8 @@ declare class Serializer {
      * serializer.serializeStr("1234abcd");
      * assert(serializer.toUint8Array() === new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));
      * ```
+     * @group Implementation
+     * @category BCS
      */
     serializeStr(value: string): void;
     /**
@@ -2340,6 +2528,8 @@ declare class Serializer {
      * 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.
+     * @group Implementation
+     * @category BCS
      */
     serializeBytes(value: Uint8Array): void;
     /**
@@ -2348,6 +2538,8 @@ declare class Serializer {
      * When deserializing, the number of bytes to deserialize needs to be passed in.
   
      * @param value - The Uint8Array to be serialized.
+     * @group Implementation
+     * @category BCS
      */
     serializeFixedBytes(value: Uint8Array): void;
     /**
@@ -2356,6 +2548,8 @@ declare class Serializer {
      * The BCS layout for a boolean uses one byte, where "0x01" represents true and "0x00" represents false.
      *
      * @param value - The boolean value to serialize.
+     * @group Implementation
+     * @category BCS
      */
     serializeBool(value: boolean): void;
     /**
@@ -2363,11 +2557,15 @@ declare class Serializer {
      * BCS layout for "uint8": One byte. Binary format in little-endian representation.
      *
      * @param value - The Uint8 value to serialize.
+     * @group Implementation
+     * @category BCS
      */
     serializeU8(value: Uint8): void;
     /**
      * Serializes a uint16 number.
      *
+     * @group Implementation
+     * @category BCS
   
      */
     /**
@@ -2381,6 +2579,8 @@ declare class Serializer {
      * serializer.serializeU16(4660);
      * assert(serializer.toUint8Array() === new Uint8Array([0x34, 0x12]));
      * ```
+     * @group Implementation
+     * @category BCS
      */
     serializeU16(value: Uint16): void;
     /**
@@ -2393,6 +2593,8 @@ declare class Serializer {
      * assert(serializer.toUint8Array() === new Uint8Array([0x78, 0x56, 0x34, 0x12]));
      * ```
      * @param value - The 32-bit unsigned integer value to serialize.
+     * @group Implementation
+     * @category BCS
      */
     serializeU32(value: Uint32): void;
     /**
@@ -2406,12 +2608,16 @@ declare class Serializer {
      * serializer.serializeU64(1311768467750121216);
      * assert(serializer.toUint8Array() === new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]));
      * ```
+     * @group Implementation
+     * @category BCS
      */
     serializeU64(value: AnyNumber): void;
     /**
      * Serializes a U128 value into a format suitable for storage or transmission.
      *
      * @param value - The U128 value to serialize, represented as a number.
+     * @group Implementation
+     * @category BCS
      */
     serializeU128(value: AnyNumber): void;
     /**
@@ -2419,6 +2625,8 @@ declare class Serializer {
      * This function is essential for encoding large numbers in a compact format suitable for transmission or storage.
      *
      * @param value - The U256 value to serialize, represented as an AnyNumber.
+     * @group Implementation
+     * @category BCS
      */
     serializeU256(value: AnyNumber): void;
     /**
@@ -2426,6 +2634,8 @@ declare class Serializer {
      * 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.
+     * @group Implementation
+     * @category BCS
      */
     serializeU32AsUleb128(val: Uint32): void;
     /**
@@ -2434,6 +2644,8 @@ declare class Serializer {
      * 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.
+     * @group Implementation
+     * @category BCS
      */
     toUint8Array(): Uint8Array;
     /**
@@ -2442,6 +2654,8 @@ declare class Serializer {
      * @param value The Serializable value to serialize.
      *
      * @returns the serializer instance
+     * @group Implementation
+     * @category BCS
      */
     serialize<T extends Serializable>(value: T): void;
     /**
@@ -2462,6 +2676,8 @@ declare class Serializer {
      * // serializedBytes is now the BCS-serialized bytes
      * // The equivalent value in Move would be:
      * // `bcs::to_bytes(&vector<address> [@0x1, @0x2, @0xa, @0xb])`;
+     * @group Implementation
+     * @category BCS
      */
     serializeVector<T extends Serializable>(values: Array<T>): void;
     /**
@@ -2480,6 +2696,8 @@ declare class Serializer {
      * serializer.serializeOption(new AccountAddress(...));  // Serializes optional Serializable
      * serializer.serializeOption(undefined);  // Serializes none case
      * ```
+     * @group Implementation
+     * @category BCS
      */
     serializeOption<T extends Serializable | string | Uint8Array>(value?: T, len?: number): void;
     /**
@@ -2492,10 +2710,20 @@ declare class Serializer {
      * BCS layout for undefined: 0
      *
      * @param value - The optional string to serialize. If undefined, it will serialize as 0.
+     * @group Implementation
+     * @category BCS
      */
     serializeOptionStr(value?: string): void;
 }
+/**
+ * @group Implementation
+ * @category BCS
+ */
 declare function ensureBoolean(value: unknown): asserts value is boolean;
+/**
+ * @group Implementation
+ * @category BCS
+ */
 declare const outOfRangeErrorMessage: (value: AnyNumber, min: AnyNumber, max: AnyNumber) => string;
 /**
  * Validates that a given number is within a specified range.
@@ -2504,6 +2732,8 @@ declare const outOfRangeErrorMessage: (value: AnyNumber, min: AnyNumber, max: An
  * @param value - The number to validate.
  * @param minValue - The minimum allowable value (inclusive).
  * @param maxValue - The maximum allowable value (inclusive).
+ * @group Implementation
+ * @category BCS
  */
 declare function validateNumberInRange<T extends AnyNumber>(value: T, minValue: T, maxValue: T): void;
 
@@ -2512,12 +2742,16 @@ interface TransactionArgument extends EntryFunctionArgument, ScriptFunctionArgum
 /**
  * Represents an argument for entry functions, providing methods to serialize the argument
  * to BCS-serialized bytes and convert it to different formats.
+ * @group Implementation
+ * @category Transactions
  */
 interface EntryFunctionArgument {
     /**
      * Serialize an argument to BCS-serialized bytes.
      *
      * @param serializer - The serializer instance used for serialization.
+     * @group Implementation
+     * @category Transactions
      */
     serialize(serializer: Serializer): void;
     /**
@@ -2526,12 +2760,16 @@ interface EntryFunctionArgument {
      * 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.
+     * @group Implementation
+     * @category Transactions
      */
     serializeForEntryFunction(serializer: Serializer): void;
     /**
      * Convert the argument to BCS-serialized bytes.
      *
      * @returns Uint8Array representing the BCS-serialized bytes of the argument.
+     * @group Implementation
+     * @category Transactions
      */
     bcsToBytes(): Uint8Array;
     /**
@@ -2539,21 +2777,29 @@ interface EntryFunctionArgument {
      * 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.
+     * @group Implementation
+     * @category Transactions
      */
     bcsToHex(): Hex;
 }
 /**
  * Represents an argument for script functions, providing methods to serialize and convert to bytes.
+ * @group Implementation
+ * @category Transactions
  */
 interface ScriptFunctionArgument {
     /**
      * Serialize an argument to BCS-serialized bytes.
+     * @group Implementation
+     * @category Transactions
      */
     serialize(serializer: Serializer): void;
     /**
      * Serialize an argument to BCS-serialized bytes as a type aware byte sequence.
      * The byte sequence contains an enum variant index followed by the BCS-serialized
      * bytes for a typed argument.
+     * @group Implementation
+     * @category Transactions
      */
     serializeForScriptFunction(serializer: Serializer): void;
     bcsToBytes(): Uint8Array;
@@ -2562,6 +2808,8 @@ interface ScriptFunctionArgument {
 
 /**
  * Provides reasons for an address was invalid.
+ * @group Implementation
+ * @category Serialization
  */
 declare enum AddressInvalidReason {
     INCORRECT_NUMBER_OF_BYTES = "incorrect_number_of_bytes",
@@ -2575,6 +2823,8 @@ declare enum AddressInvalidReason {
 }
 /**
  * The input for an account address, which can be either a hexadecimal string or a standard account address.
+ * @group Implementation
+ * @category Serialization
  */
 type AccountAddressInput = HexInput | AccountAddress;
 /**
@@ -2592,18 +2842,26 @@ type AccountAddressInput = HexInput | AccountAddress;
  *
  * The comments in this class make frequent reference to the LONG and SHORT formats,
  * as well as "special" addresses. To learn what these refer to see AIP-40.
+ * @group Implementation
+ * @category Serialization
  */
 declare class AccountAddress extends Serializable implements TransactionArgument {
     /**
      * This is the internal representation of an account address.
+     * @group Implementation
+     * @category Serialization
      */
     readonly data: Uint8Array;
     /**
      * The number of bytes that make up an account address.
+     * @group Implementation
+     * @category Serialization
      */
     static readonly LENGTH: number;
     /**
      * The length of an address string in LONG form without a leading 0x.
+     * @group Implementation
+     * @category Serialization
      */
     static readonly LONG_STRING_LENGTH: number;
     static ZERO: AccountAddress;
@@ -2619,6 +2877,8 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      *
      * @param input A Uint8Array representing an account address.
      * @throws ParsingError if the input length is not equal to 32 bytes.
+     * @group Implementation
+     * @category Serialization
      */
     constructor(input: Uint8Array);
     /**
@@ -2630,6 +2890,8 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
      *
      * @returns true if the address is special, false otherwise.
+     * @group Implementation
+     * @category Serialization
      */
     isSpecial(): boolean;
     /**
@@ -2639,6 +2901,8 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      * and other addresses in LONG form (0x + 64 characters).
      *
      * @returns AccountAddress as a string conforming to AIP-40.
+     * @group Implementation
+     * @category Serialization
      */
     toString(): `0x${string}`;
     /**
@@ -2647,6 +2911,8 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      * NOTE: Prefer to use `toString` where possible.
      *
      * @returns AccountAddress as a string without the leading 0x.
+     * @group Implementation
+     * @category Serialization
      */
     toStringWithoutPrefix(): string;
     /**
@@ -2655,6 +2921,8 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      * 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.
+     * @group Implementation
+     * @category Serialization
      */
     toStringLong(): `0x${string}`;
     /**
@@ -2664,6 +2932,8 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      * NOTE: Prefer to use `toString` where possible, as it formats special addresses using the SHORT form (no leading 0s).
      *
      * @returns {string} The account address in LONG form.
+     * @group Implementation
+     * @category Serialization
      */
     toStringLongWithoutPrefix(): string;
     /**
@@ -2671,6 +2941,8 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      * The inner data is already a Uint8Array, so no conversion takes place.
      *
      * @returns Hex data as Uint8Array
+     * @group Implementation
+     * @category Serialization
      */
     toUint8Array(): Uint8Array;
     /**
@@ -2683,6 +2955,8 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      * address.serialize(serializer);
      * const bytes = serializer.toUint8Array();
      * // `bytes` is now the BCS-serialized address.
+     * @group Implementation
+     * @category Serialization
      */
     serialize(serializer: Serializer): void;
     /**
@@ -2690,6 +2964,8 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      * 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.
+     * @group Implementation
+     * @category Serialization
      */
     serializeForEntryFunction(serializer: Serializer): void;
     /**
@@ -2697,6 +2973,8 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      * 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.
+     * @group Implementation
+     * @category Serialization
      */
     serializeForScriptFunction(serializer: Serializer): void;
     /**
@@ -2709,6 +2987,8 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      * const deserializer = new Deserializer(bytes);
      * const address = AccountAddress.deserialize(deserializer);
      * // `address` is now an instance of AccountAddress.
+     * @group Implementation
+     * @category Serialization
      */
     static deserialize(deserializer: Deserializer): AccountAddress;
     /**
@@ -2743,6 +3023,8 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
      *
      * @returns An instance of AccountAddress.
+     * @group Implementation
+     * @category Serialization
      */
     static fromStringStrict(input: string): AccountAddress;
     /**
@@ -2772,6 +3054,8 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      * @returns An instance of AccountAddress.
      *
      * @throws ParsingError if the hex string is too short, too long, or contains invalid characters.
+     * @group Implementation
+     * @category Serialization
      */
     static fromString(input: string, { maxMissingChars }?: {
         maxMissingChars?: number;
@@ -2784,6 +3068,8 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      * @param input - The input to convert into an AccountAddress. This can be a string representation of an address, a Uint8Array,
      * or an existing AccountAddress.
      * @param args.maxMissingChars The number of characters that can be missing in a padded address before it is invalid.
+     * @group Implementation
+     * @category Serialization
      */
     static from(input: AccountAddressInput, { maxMissingChars }?: {
         maxMissingChars?: number;
@@ -2792,6 +3078,8 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      * Create an AccountAddress from various input types, including strings, Uint8Array, and AccountAddress instances.
      *
      * @param input - The input to convert into an AccountAddress, which can be a string, a Uint8Array, or an AccountAddress.
+     * @group Implementation
+     * @category Serialization
      */
     static fromStrict(input: AccountAddressInput): AccountAddress;
     /**
@@ -2803,6 +3091,8 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      *
      * @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.
+     * @group Implementation
+     * @category Serialization
      */
     static isValid(args: {
         input: AccountAddressInput;
@@ -2813,6 +3103,8 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      *
      * @param other - The AccountAddress to compare to.
      * @returns true if the AccountAddresses are equal, false if not.
+     * @group Implementation
+     * @category Serialization
      */
     equals(other: AccountAddress): boolean;
 }