@aptos-labs/ts-sdk 0.0.1 → 0.0.3

package/dist/cjs/index.d.ts

@@ -678,7 +678,7 @@ declare enum MimeType {
  */
 declare type HexInput = string | Uint8Array;
 /**
- * Script transaction arguments enum as they are represented in Rust
+ * TypeTag enum as they are represented in Rust
  * {@link https://github.com/aptos-labs/aptos-core/blob/main/third_party/move/move-core/types/src/language_storage.rs#L27}
  */
 declare enum TypeTagVariants {
@@ -692,7 +692,9 @@ declare enum TypeTagVariants {
     Struct = 7,
     U16 = 8,
     U32 = 9,
-    U256 = 10
+    U256 = 10,
+    Reference = 254,
+    Generic = 255
 }
 /**
  * Script transaction arguments enum as they are represented in Rust
@@ -735,7 +737,7 @@ declare enum TransactionAuthenticatorVariant {
     MultiEd25519 = 1,
     MultiAgent = 2,
     FeePayer = 3,
-    Secp256k1Ecdsa = 4
+    SingleSender = 4
 }
 /**
  * Transaction Authenticator enum as they are represented in Rust
@@ -744,7 +746,16 @@ declare enum TransactionAuthenticatorVariant {
 declare enum AccountAuthenticatorVariant {
     Ed25519 = 0,
     MultiEd25519 = 1,
-    Secp256k1 = 2
+    SingleKey = 2,
+    MultiKey = 3
+}
+declare enum AnyPublicKeyVariant {
+    Ed25519 = 0,
+    Secp256k1 = 1
+}
+declare enum AnySignatureVariant {
+    Ed25519 = 0,
+    Secp256k1 = 1
 }
 /**
  * BCS types
@@ -866,7 +877,7 @@ declare type GasEstimation = {
     prioritized_gas_estimate?: number;
 };
 declare type MoveResource = {
-    type: MoveResourceType;
+    type: MoveStructType;
     data: {};
 };
 declare type AccountData = {
@@ -1102,7 +1113,7 @@ declare type DeletedTableData = {
 declare type TransactionPayloadResponse = EntryFunctionPayloadResponse | ScriptPayloadResponse | MultisigPayloadResponse;
 declare type EntryFunctionPayloadResponse = {
     type: string;
-    function: MoveResourceType;
+    function: MoveStructType;
     /**
      * Type arguments of the function
      */
@@ -1236,14 +1247,13 @@ declare type MoveUint32Type = number;
 declare type MoveUint64Type = string;
 declare type MoveUint128Type = string;
 declare type MoveUint256Type = string;
-declare type MoveAddressType = `0x${string}`;
-declare type MoveObjectType = `0x${string}`;
-declare type MoveStructType = `0x${string}::${string}::${string}`;
+declare type MoveAddressType = string;
+declare type MoveObjectType = string;
 declare type MoveOptionType = MoveType | null | undefined;
 /**
- * String representation of a on-chain Move struct type.
+ * This is the format for a fully qualified struct, resource, or entry function in Move.
  */
-declare type MoveResourceType = `${string}::${string}::${string}`;
+declare type MoveStructType = `${string}::${string}::${string}`;
 declare type MoveType = boolean | string | MoveUint8Type | MoveUint16Type | MoveUint32Type | MoveUint64Type | MoveUint128Type | MoveUint256Type | MoveAddressType | MoveObjectType | MoveStructType | Array<MoveType>;
 /**
  * Possible Move values acceptable by move functions (entry, view)
@@ -1399,7 +1409,7 @@ declare type LedgerInfo = {
  */
 declare type Block = {
     block_height: string;
-    block_hash: `0x${string}`;
+    block_hash: string;
     block_timestamp: string;
     first_version: string;
     last_version: string;
@@ -1413,24 +1423,24 @@ declare type Block = {
  */
 declare type ViewRequestData = {
     function: MoveStructType;
-    typeArguments?: Array<MoveResourceType>;
-    arguments?: Array<MoveValue>;
+    typeArguments?: Array<MoveStructType>;
+    functionArguments?: Array<MoveValue>;
 };
 /**
  * View request for the Move view function API
  *
- * `type MoveResourceType = ${string}::${string}::${string}`;
+ * `type MoveStructType = ${string}::${string}::${string}`;
  */
 declare type ViewRequest = {
-    function: MoveResourceType;
+    function: MoveStructType;
     /**
      * Type arguments of the function
      */
-    type_arguments: Array<MoveResourceType>;
+    type_arguments: Array<MoveStructType>;
     /**
      * Arguments of the function
      */
-    arguments: Array<MoveValue>;
+    functionArguments: Array<MoveValue>;
 };
 /**
  * Table Item request for the GetTableItem API
@@ -1449,11 +1459,6 @@ declare type TableItemRequest = {
  * They are combinations of signing schemes and derive schemes.
  */
 declare type AuthenticationKeyScheme = SigningScheme | DeriveScheme;
-/**
- * A list of signing schemes that are supported by Aptos.
- *
- * https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs#L375-L378
- */
 declare enum SigningScheme {
     /**
      * For Ed25519PublicKey
@@ -1464,7 +1469,18 @@ declare enum SigningScheme {
      */
     MultiEd25519 = 1,
     /**
-     * For Secp256k1 ecdsa
+     * For SingleKey ecdsa
+     */
+    SingleKey = 2,
+    MultiKey = 3
+}
+declare enum SigningSchemeInput {
+    /**
+     * For Ed25519PublicKey
+     */
+    Ed25519 = 0,
+    /**
+     * For Secp256k1Ecdsa
      */
     Secp256k1Ecdsa = 2
 }
@@ -1493,6 +1509,37 @@ declare enum DeriveScheme {
      */
     DeriveResourceAccountAddress = 255
 }
+/**
+ * Option properties to pass for waitForTransaction() function
+ */
+declare type WaitForTransactionOptions = {
+    timeoutSecs?: number;
+    checkSuccess?: boolean;
+    indexerVersionCheck?: boolean;
+};
+/**
+ * Account input type to generate an account using Legacy
+ * Ed25519 or MultiEd25519 keys or without a specified `scheme`.
+ * If `scheme` is not specified, we default to ED25519
+ * In this case `legacy` is always true
+ */
+declare type GenerateAccountWithLegacyKey = {
+    scheme?: SigningSchemeInput.Ed25519;
+    legacy: true;
+};
+/**
+ * Account input type to generate an account using Unified
+ * Secp256k1Ecdsa key
+ * In this case `legacy` is always false
+ */
+declare type GenerateAccountWithUnifiedKey = {
+    scheme: SigningSchemeInput.Secp256k1Ecdsa | SigningSchemeInput.Ed25519;
+    legacy?: false;
+};
+/**
+ * Unify GenerateAccount type for Legacy and Unified keys
+ */
+declare type GenerateAccount = GenerateAccountWithLegacyKey | GenerateAccountWithUnifiedKey;
 
 /**
  * Type of API endpoint for request routing
@@ -1509,6 +1556,9 @@ declare enum AptosApiType {
 declare class AptosConfig {
     /** The Network that this SDK is associated with. */
     readonly network: Network;
+    /**
+     * The client instance the SDK uses
+     */
     readonly client: Client;
     /**
      * The optional hardcoded fullnode URL to send requests to instead of using the network
@@ -2068,6 +2118,7 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      * The length of an address string in LONG form without a leading 0x.
      */
     static readonly LONG_STRING_LENGTH: number;
+    static ZERO: AccountAddress;
     static ONE: AccountAddress;
     static TWO: AccountAddress;
     static THREE: AccountAddress;
@@ -2101,7 +2152,7 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      *
      * @returns AccountAddress as a string conforming to AIP-40.
      */
-    toString(): string;
+    toString(): `0x${string}`;
     /**
      * NOTE: Prefer to use `toString` where possible.
      *
@@ -2123,7 +2174,7 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      *
      * @returns AccountAddress as a string in LONG form.
      */
-    toStringLong(): string;
+    toStringLong(): `0x${string}`;
     /**
      * NOTE: Prefer to use `toString` where possible.
      *
@@ -2280,9 +2331,9 @@ declare class AccountAddress extends Serializable implements TransactionArgument
  *  @example
  *  const yourCustomSerializedBytes = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
  *  const fixedBytes = new FixedBytes(yourCustomSerializedBytes);
- *  const payload = generateTransactionPayload({
+ *  const payload = await generateTransactionPayload({
  *    function: "0xbeefcafe::your_module::your_function_that_requires_custom_serialization",
- *    arguments: [yourCustomBytes],
+ *    functionArguments: [yourCustomBytes],
  *  });
  *
  *  For example, if you store each of the 32 bytes for an address as a U8 in a MoveVector<U8>, when you
@@ -2430,7 +2481,7 @@ declare class U256 extends Serializable implements TransactionArgument {
  * values: an Array<T> of values where T is a class that implements Serializable
  * @returns a `MoveVector<T>` with the values `values`
  */
-declare class MoveVector<T extends Serializable> extends Serializable implements TransactionArgument {
+declare class MoveVector<T extends Serializable & EntryFunctionArgument> extends Serializable implements TransactionArgument {
     values: Array<T>;
     constructor(values: Array<T>);
     serializeForEntryFunction(serializer: Serializer): void;
@@ -2528,7 +2579,7 @@ declare class MoveVector<T extends Serializable> extends Serializable implements
      * @returns a MoveVector of the corresponding class T
      * *
      */
-    static deserialize<T extends Serializable>(deserializer: Deserializer, cls: Deserializable<T>): MoveVector<T>;
+    static deserialize<T extends Serializable & EntryFunctionArgument>(deserializer: Deserializer, cls: Deserializable<T>): MoveVector<T>;
 }
 declare class MoveString extends Serializable implements TransactionArgument {
     value: string;
@@ -2538,7 +2589,7 @@ declare class MoveString extends Serializable implements TransactionArgument {
     serializeForScriptFunction(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): MoveString;
 }
-declare class MoveOption<T extends Serializable> extends Serializable implements EntryFunctionArgument {
+declare class MoveOption<T extends Serializable & EntryFunctionArgument> extends Serializable implements EntryFunctionArgument {
     private vec;
     readonly value?: T;
     constructor(value?: T | null);
@@ -2659,15 +2710,7 @@ declare class MoveOption<T extends Serializable> extends Serializable implements
      * @returns a MoveOption<MoveString> with an inner value `value`
      */
     static MoveString(value?: string | null): MoveOption<MoveString>;
-    static deserialize<U extends Serializable>(deserializer: Deserializer, cls: Deserializable<U>): MoveOption<U>;
-}
-declare class MoveObject extends Serializable implements TransactionArgument {
-    value: AccountAddress;
-    constructor(value: HexInput | AccountAddress);
-    serialize(serializer: Serializer): void;
-    serializeForEntryFunction(serializer: Serializer): void;
-    serializeForScriptFunction(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): MoveObject;
+    static deserialize<U extends Serializable & EntryFunctionArgument>(deserializer: Deserializer, cls: Deserializable<U>): MoveOption<U>;
 }
 
 /**
@@ -2739,6 +2782,22 @@ declare abstract class Signature extends Serializable {
  *
  * Use this class to create accounts, sign transactions, and more.
  * Note: Creating an account instance does not create the account on-chain.
+ *
+ * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports
+ * `Legacy` and `Unified` authentications.
+ *
+ * @Legacy includes `ED25519` and `MultiED25519`
+ * @Unified includes `SingleSender` and `MultiSender`, where currently
+ * `SingleSender` supports `ED25519` and `Secp256k1`, and `MultiSender` supports
+ * `MultiED25519`.
+ *
+ * In TypeScript SDK, we support all of these options
+ * @generate default to generate Unified keys, with an optional `legacy` boolean argument
+ * that lets you generate new keys conforming to the Legacy authentication.
+ * @fromPrivateKey derives an account by a provided private key and address, with an optional
+ * `legacy` boolean argument that lets you generate new keys conforming to the Legacy authentication.
+ * @fromDerivationPath derives an account with bip44 path and mnemonics,
+ *
  */
 declare class Account$1 {
     /**
@@ -2764,38 +2823,56 @@ declare class Account$1 {
      *
      * @param args.privateKey PrivateKey - private key of the account
      * @param args.address AccountAddress - address of the account
+     * @param args.legacy optional. If set to true, the keypair authentication keys will be derived with a Legacy scheme.
+     * Defaults to deriving an authentication key with a Unified scheme
      *
      * This method is private because it should only be called by the factory static methods.
      * @returns Account
      */
     private constructor();
     /**
-     * Derives an account with random private key and address
+     * Derives an account with random private key and address.
+     * Default generation is using the Unified flow with ED25519 key
      *
-     * @param scheme optional SigningScheme - type of SigningScheme to use. Default to Ed25519
-     * Currently only Ed25519 and Secp256k1 are supported
+     * @param args optional. Unify GenerateAccount type for Legacy and Unified keys
+     *
+     * Account input type to generate an account using Legacy
+     * Ed25519 or MultiEd25519 keys or without a specified `scheme`.
+     * ```
+     * GenerateAccountWithLegacyKey = {
+     *  scheme?: SigningSchemeInput.Ed25519 | SigningSchemeInput.MultiEd25519;
+     *  legacy: true;
+     * };
+     * ```
+     *
+     * Account input type to generate an account using Unified
+     * Secp256k1Ecdsa key
+     * In this case `legacy` is always false
+     * ```
+     * GenerateAccountWithUnifiedKey = {
+     *  scheme: SigningSchemeInput.Secp256k1Ecdsa;
+     *  legacy?: false;
+     * };
+     * ```
      *
      * @returns Account with the given signing scheme
      */
-    static generate(scheme?: SigningScheme): Account$1;
+    static generate(args?: GenerateAccount): Account$1;
     /**
-     * Derives an account with provided private key
+     * Instantiates an account given a private key and a specified account address.
+     * This is primarily used to instantiate an `Account` that has had its authentication key rotated.
      *
-     * @param privateKey Hex - private key of the account
-     * @returns Account
-     */
-    static fromPrivateKey(privateKey: PrivateKey): Account$1;
-    /**
-     * Derives an account with provided private key and address
-     * This is intended to be used for account that has it's key rotated
+     * @param privateKey PrivateKey - private key of the account
+     * @param address The account address
+     * @param args.legacy optional. If set to true, the keypair authentication keys will be derived with a Legacy scheme.
+     * Defaults to deriving an authentication key with a Unified scheme
      *
-     * @param args.privateKey Hex - private key of the account
-     * @param args.address AccountAddress - address of the account
      * @returns Account
      */
     static fromPrivateKeyAndAddress(args: {
         privateKey: PrivateKey;
         address: AccountAddress;
+        legacy?: boolean;
     }): Account$1;
     /**
      * Derives an account with bip44 path and mnemonics,
@@ -2851,7 +2928,7 @@ declare class Account$1 {
  *
  * Account addresses can be derived from AuthenticationKey
  */
-declare class AuthenticationKey {
+declare class AuthenticationKey extends Serializable {
     /**
      * An authentication key is always a SHA3-256 hash of data, and is always 32 bytes.
      */
@@ -2863,6 +2940,13 @@ declare class AuthenticationKey {
     constructor(args: {
         data: HexInput;
     });
+    serialize(serializer: Serializer): void;
+    /**
+     * Deserialize an AuthenticationKey from the byte buffer in a Deserializer instance.
+     * @param deserializer The deserializer to deserialize the AuthenticationKey from.
+     * @returns An instance of AuthenticationKey.
+     */
+    static deserialize(deserializer: Deserializer): AuthenticationKey;
     toString(): string;
     toUint8Array(): Uint8Array;
     /**
@@ -2871,7 +2955,10 @@ declare class AuthenticationKey {
      * This allows for the creation of AuthenticationKeys that are not derived from Public Keys directly
      * @param args
      */
-    private static fromBytesAndScheme;
+    static fromPublicKeyAndScheme(args: {
+        publicKey: PublicKey;
+        scheme: AuthenticationKeyScheme;
+    }): AuthenticationKey;
     /**
      * Converts a PublicKey(s) to AuthenticationKey
      *
@@ -2892,6 +2979,12 @@ declare class AuthenticationKey {
 
 /**
  * Represents the public key of an Ed25519 key pair.
+ *
+ * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports
+ * `Legacy` and `Unified` authentication keys.
+ *
+ * Ed25519 scheme is represented in the SDK as `Legacy authentication key` and also
+ * as `AnyPublicKey` that represents any `Unified authentication key`
  */
 declare class Ed25519PublicKey extends PublicKey {
     /**
@@ -2932,6 +3025,7 @@ declare class Ed25519PublicKey extends PublicKey {
     }): boolean;
     serialize(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): Ed25519PublicKey;
+    static load(deserializer: Deserializer): Ed25519PublicKey;
 }
 /**
  * Represents the private key of an Ed25519 key pair.
@@ -3014,6 +3108,7 @@ declare class Ed25519Signature extends Signature {
     toString(): string;
     serialize(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): Ed25519Signature;
+    static load(deserializer: Deserializer): Ed25519Signature;
 }
 
 /**
@@ -3131,6 +3226,8 @@ declare class MultiEd25519Signature extends Signature {
 
 /**
  * Represents the Secp256k1 ecdsa public key
+ *
+ * Secp256k1 authentication key is represented in the SDK as `AnyPublicKey`.
  */
 declare class Secp256k1PublicKey extends PublicKey {
     static readonly LENGTH: number;
@@ -3166,6 +3263,7 @@ declare class Secp256k1PublicKey extends PublicKey {
     }): boolean;
     serialize(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): Secp256k1PublicKey;
+    static load(deserializer: Deserializer): Secp256k1PublicKey;
 }
 /**
  * A Secp256k1 ecdsa private key
@@ -3253,6 +3351,105 @@ declare class Secp256k1Signature extends Signature {
     toString(): string;
     serialize(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): Secp256k1Signature;
+    static load(deserializer: Deserializer): Secp256k1Signature;
+}
+
+declare class AnySignature extends Signature {
+    readonly signature: Signature;
+    constructor(signature: Signature);
+    /**
+     * Get the public key in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the public key
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the public key as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the public key
+     */
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): AnySignature;
+}
+
+/**
+ * Represents any public key supported by Aptos.
+ *
+ * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports
+ * `Legacy` and `Unified` authentication keys.
+ *
+ * Any unified authentication key is represented in the SDK as `AnyPublicKey`.
+ */
+declare class AnyPublicKey extends PublicKey {
+    /**
+     * Reference to the inner public key
+     */
+    readonly publicKey: PublicKey;
+    constructor(publicKey: PublicKey);
+    /**
+     * Get the public key in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the public key
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the public key as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the public key
+     */
+    toString(): string;
+    /**
+     * Verifies a signed data with a public key
+     *
+     * @param args.message message
+     * @param args.signature The signature
+     * @returns true if the signature is valid
+     */
+    verifySignature(args: {
+        message: HexInput;
+        signature: AnySignature;
+    }): boolean;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): AnyPublicKey;
+}
+
+declare class MultiKey extends PublicKey {
+    /**
+     * List of any public keys
+     */
+    readonly publicKeys: AnyPublicKey[];
+    /**
+     * The minimum number of valid signatures required, for the number of public keys specified
+     */
+    readonly signaturesRequired: number;
+    constructor(args: {
+        publicKeys: PublicKey[];
+        signaturesRequired: number;
+    });
+    toUint8Array(): Uint8Array;
+    /**
+     * Create a bitmap that holds the mapping from the original public keys
+     * to the signatures passed in
+     *
+     * @param args.bits array of the index mapping to the matching public keys
+     * @returns Uint8array bit map
+     */
+    createBitmap(args: {
+        bits: number[];
+    }): Uint8Array;
+    /**
+     * Hex string representation the multi key bytes
+     *
+     * @returns string
+     */
+    toString(): string;
+    verifySignature(args: {
+        message: HexInput;
+        signature: AnySignature;
+    }): boolean;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): MultiKey;
 }
 
 /**
@@ -3351,8 +3548,10 @@ declare class Account {
         options?: PaginationArgs & LedgerVersion;
     }): Promise<MoveResource[]>;
     /**
-     * Queries a specific account resource given account address and resource type
+     * Queries a specific account resource given account address and resource type. Note that the default is `any` in order
+     * to allow for ease of accessing properties of the object.
      *
+     * @type The typed output of the resource
      * @param args.accountAddress Aptos account address
      * @param args.resourceType String representation of an on-chain Move struct type, i.e "0x1::aptos_coin::AptosCoin"
      * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
@@ -3362,16 +3561,15 @@ declare class Account {
      * @example An example of an account resource
      * ```
      * {
-     *    type: "0x1::aptos_coin::AptosCoin",
      *    data: { value: 6 }
      * }
      * ```
      */
-    getAccountResource(args: {
+    getAccountResource<T extends {} = any>(args: {
         accountAddress: HexInput;
-        resourceType: MoveResourceType;
+        resourceType: MoveStructType;
         options?: LedgerVersion;
-    }): Promise<MoveResource>;
+    }): Promise<T>;
     /**
      * Looks up the account address for a given authentication key
      *
@@ -3509,6 +3707,23 @@ declare class Account {
             orderBy?: OrderBy<GetAccountOwnedObjectsResponse[0]>;
         };
     }): Promise<GetAccountOwnedObjectsResponse>;
+    /**
+     * Derives an account by providing a private key.
+     * This functions resolves the provided private key type and derives the public key from it.
+     *
+     * If the privateKey is a Secp256k1 type, it derives the account using the derived public key and
+     * auth key using the SingleKey scheme locally.
+     *
+     * If the privateKey is a ED25519 type, it looks up the authentication key on chain, and uses it to resolve
+     * whether it is a Legacy ED25519 key or a Unified ED25519 key. It then derives the account based
+     * on that.
+     *
+     * @param args.privateKey An account private key
+     * @returns Account type
+     */
+    deriveAccountFromPrivateKey(args: {
+        privateKey: PrivateKey;
+    }): Promise<Account$1>;
 }
 
 /**
@@ -3559,65 +3774,101 @@ declare class ModuleId extends Serializable {
 declare abstract class TypeTag extends Serializable {
     abstract serialize(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): TypeTag;
+    abstract toString(): string;
+    isBool(): this is TypeTagBool;
+    isAddress(): this is TypeTagAddress;
+    isGeneric(): this is TypeTagGeneric;
+    isSigner(): this is TypeTagSigner;
+    isVector(): this is TypeTagVector;
+    isStruct(): this is TypeTagStruct;
+    isU8(): this is TypeTagU8;
+    isU16(): this is TypeTagU16;
+    isU32(): this is TypeTagU32;
+    isU64(): this is TypeTagU64;
+    isU128(): this is TypeTagU128;
+    isU256(): this is TypeTagU256;
 }
 declare class TypeTagBool extends TypeTag {
+    toString(): string;
     serialize(serializer: Serializer): void;
     static load(_deserializer: Deserializer): TypeTagBool;
 }
 declare class TypeTagU8 extends TypeTag {
+    toString(): string;
     serialize(serializer: Serializer): void;
     static load(_deserializer: Deserializer): TypeTagU8;
 }
 declare class TypeTagU16 extends TypeTag {
+    toString(): string;
     serialize(serializer: Serializer): void;
     static load(_deserializer: Deserializer): TypeTagU16;
 }
 declare class TypeTagU32 extends TypeTag {
+    toString(): string;
     serialize(serializer: Serializer): void;
     static load(_deserializer: Deserializer): TypeTagU32;
 }
 declare class TypeTagU64 extends TypeTag {
+    toString(): string;
     serialize(serializer: Serializer): void;
     static load(_deserializer: Deserializer): TypeTagU64;
 }
 declare class TypeTagU128 extends TypeTag {
+    toString(): string;
     serialize(serializer: Serializer): void;
     static load(_deserializer: Deserializer): TypeTagU128;
 }
 declare class TypeTagU256 extends TypeTag {
+    toString(): string;
     serialize(serializer: Serializer): void;
     static load(_deserializer: Deserializer): TypeTagU256;
 }
 declare class TypeTagAddress extends TypeTag {
+    toString(): string;
     serialize(serializer: Serializer): void;
     static load(_deserializer: Deserializer): TypeTagAddress;
 }
 declare class TypeTagSigner extends TypeTag {
+    toString(): string;
     serialize(serializer: Serializer): void;
     static load(_deserializer: Deserializer): TypeTagSigner;
 }
+declare class TypeTagReference extends TypeTag {
+    readonly value: TypeTag;
+    toString(): `&${string}`;
+    constructor(value: TypeTag);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TypeTagReference;
+}
+/**
+ * Generics are used for type parameters in entry functions.  However,
+ * they are not actually serialized into a real type, so they cannot be
+ * used as a type directly.
+ */
+declare class TypeTagGeneric extends TypeTag {
+    readonly value: number;
+    toString(): `T${number}`;
+    constructor(value: number);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TypeTagGeneric;
+}
 declare class TypeTagVector extends TypeTag {
     readonly value: TypeTag;
+    toString(): `vector<${string}>`;
     constructor(value: TypeTag);
     serialize(serializer: Serializer): void;
     static load(deserializer: Deserializer): TypeTagVector;
 }
 declare class TypeTagStruct extends TypeTag {
     readonly value: StructTag;
+    toString(): `0x${string}::${string}::${string}`;
     constructor(value: StructTag);
     serialize(serializer: Serializer): void;
     static load(deserializer: Deserializer): TypeTagStruct;
-    /**
-     * This function checks if the TypeTagStruct is a Move String TypeTag.
-     * In Move, a string is represented as the String struct from string.move, deployed at `0x1`,
-     * meaning it has the following properties:
-     * - address: 0x1
-     * - module_name: "string"
-     * - name: "String"
-     *
-     * @returns true if the StructTag is a String type tag, false otherwise
-     */
-    isStringTypeTag(): boolean;
+    isTypeTag(address: AccountAddress, moduleName: string, structName: string): boolean;
+    isString(): boolean;
+    isOption(): boolean;
+    isObject(): boolean;
 }
 declare class StructTag extends Serializable {
     readonly address: AccountAddress;
@@ -3625,46 +3876,23 @@ declare class StructTag extends Serializable {
     readonly name: Identifier;
     readonly type_args: Array<TypeTag>;
     constructor(address: AccountAddress, module_name: Identifier, name: Identifier, type_args: Array<TypeTag>);
-    /**
-     * Converts a string literal to a StructTag
-     * @param structTag String literal in format "AccountAddress::module_name::ResourceName",
-     *   e.g. "0x1::aptos_coin::AptosCoin"
-     * @returns
-     */
-    static fromString(structTag: string): StructTag;
     serialize(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): StructTag;
 }
-declare const stringStructTag: () => StructTag;
+declare function aptosCoinStructTag(): StructTag;
+declare function stringStructTag(): StructTag;
 declare function optionStructTag(typeArg: TypeTag): StructTag;
 declare function objectStructTag(typeArg: TypeTag): StructTag;
+
 /**
- * Parser to parse a type tag string
+ * Deserialize a Script Transaction Argument
  */
-declare class TypeTagParser {
-    private readonly tokens;
-    private readonly typeTags;
-    constructor(tagStr: string, typeTags?: string[]);
-    private consume;
-    /**
-     * Consumes all of an unused generic field, mostly applicable to object
-     *
-     * Note: This is recursive.  it can be problematic if there's bad input
-     * @private
-     */
-    private consumeWholeGeneric;
-    private parseCommaList;
-    parseTypeTag(): TypeTag;
-}
-declare class TypeTagParserError extends Error {
-    constructor(message: string);
-}
-
+declare function deserializeFromScriptArgument(deserializer: Deserializer): TransactionArgument;
 /**
  * Representation of the supported Transaction Payload
  * that can serialized and deserialized
  */
-declare abstract class TransactionPayload$1 extends Serializable {
+declare abstract class TransactionPayload extends Serializable {
     /**
      * Serialize a Transaction Payload
      */
@@ -3672,12 +3900,12 @@ declare abstract class TransactionPayload$1 extends Serializable {
     /**
      * Deserialize a Transaction Payload
      */
-    static deserialize(deserializer: Deserializer): TransactionPayload$1;
+    static deserialize(deserializer: Deserializer): TransactionPayload;
 }
 /**
  * Representation of a Transaction Payload Script that can serialized and deserialized
  */
-declare class TransactionPayloadScript extends TransactionPayload$1 {
+declare class TransactionPayloadScript extends TransactionPayload {
     readonly script: Script;
     constructor(script: Script);
     serialize(serializer: Serializer): void;
@@ -3686,7 +3914,7 @@ declare class TransactionPayloadScript extends TransactionPayload$1 {
 /**
  * Representation of a Transaction Payload Entry Function that can serialized and deserialized
  */
-declare class TransactionPayloadEntryFunction extends TransactionPayload$1 {
+declare class TransactionPayloadEntryFunction extends TransactionPayload {
     readonly entryFunction: EntryFunction;
     constructor(entryFunction: EntryFunction);
     serialize(serializer: Serializer): void;
@@ -3695,7 +3923,7 @@ declare class TransactionPayloadEntryFunction extends TransactionPayload$1 {
 /**
  * Representation of a Transaction Payload Multi-sig that can serialized and deserialized
  */
-declare class TransactionPayloadMultisig extends TransactionPayload$1 {
+declare class TransactionPayloadMultisig extends TransactionPayload {
     readonly multiSig: MultiSig;
     constructor(multiSig: MultiSig);
     serialize(serializer: Serializer): void;
@@ -3816,7 +4044,7 @@ declare class Script {
  */
 declare class MultiSig {
     readonly multisig_address: AccountAddress;
-    readonly transaction_payload?: MultiSigTransactionPayload;
+    readonly transaction_payload?: MultisigTransactionPayload;
     /**
      * Contains the payload to run a multi-sig account transaction.
      *
@@ -3825,14 +4053,19 @@ declare class MultiSig {
      * @param transaction_payload The payload of the multi-sig transaction. This is optional when executing a multi-sig
      *  transaction whose payload is already stored on chain.
      */
-    constructor(multisig_address: AccountAddress, transaction_payload?: MultiSigTransactionPayload);
+    constructor(multisig_address: AccountAddress, transaction_payload?: MultisigTransactionPayload);
     serialize(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): MultiSig;
 }
 /**
- * Representation of a MultiSig Transaction Payload that can serialized and deserialized
+ * Representation of a MultiSig Transaction Payload from `multisig_account.move`
+ * that can be serialized and deserialized
+
+ * This class exists right now to represent an extensible transaction payload class for
+ * transactions used in `multisig_account.move`. Eventually, this class will be able to
+ * support script payloads when the `multisig_account.move` module supports them.
  */
-declare class MultiSigTransactionPayload {
+declare class MultisigTransactionPayload {
     readonly transaction_payload: EntryFunction;
     /**
      * Contains the payload to run a multi-sig account transaction.
@@ -3843,7 +4076,7 @@ declare class MultiSigTransactionPayload {
      */
     constructor(transaction_payload: EntryFunction);
     serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): MultiSigTransactionPayload;
+    static deserialize(deserializer: Deserializer): MultisigTransactionPayload;
 }
 
 /**
@@ -3852,7 +4085,7 @@ declare class MultiSigTransactionPayload {
 declare class RawTransaction extends Serializable {
     readonly sender: AccountAddress;
     readonly sequence_number: bigint;
-    readonly payload: TransactionPayload$1;
+    readonly payload: TransactionPayload;
     readonly max_gas_amount: bigint;
     readonly gas_unit_price: bigint;
     readonly expiration_timestamp_secs: bigint;
@@ -3872,7 +4105,7 @@ declare class RawTransaction extends Serializable {
      * @param expiration_timestamp_secs The blockchain timestamp at which the blockchain would discard this transaction.
      * @param chain_id The chain ID of the blockchain that this transaction is intended to be run on.
      */
-    constructor(sender: AccountAddress, sequence_number: bigint, payload: TransactionPayload$1, max_gas_amount: bigint, gas_unit_price: bigint, expiration_timestamp_secs: bigint, chain_id: ChainId);
+    constructor(sender: AccountAddress, sequence_number: bigint, payload: TransactionPayload, max_gas_amount: bigint, gas_unit_price: bigint, expiration_timestamp_secs: bigint, chain_id: ChainId);
     serialize(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): RawTransaction;
 }
@@ -3926,8 +4159,184 @@ declare class FeePayerRawTransaction extends RawTransactionWithData {
     static load(deserializer: Deserializer): FeePayerRawTransaction;
 }
 
-declare type EntryFunctionArgumentTypes = Bool | U8 | U16 | U32 | U64 | U128 | U256 | AccountAddress | MoveObject | MoveVector<EntryFunctionArgumentTypes> | MoveOption<EntryFunctionArgumentTypes> | MoveString | FixedBytes;
-declare type ScriptFunctionArgumentTypes = Bool | U8 | U16 | U32 | U64 | U128 | U256 | AccountAddress | MoveObject | MoveVector<U8> | MoveString | FixedBytes;
+declare abstract class AccountAuthenticator extends Serializable {
+    abstract serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): AccountAuthenticator;
+}
+/**
+ * Transaction authenticator Ed25519 for a multi signer transaction
+ *
+ * @param public_key Account's Ed25519 public key.
+ * @param signature Account's Ed25519 signature
+ *
+ */
+declare class AccountAuthenticatorEd25519 extends AccountAuthenticator {
+    readonly public_key: Ed25519PublicKey;
+    readonly signature: Ed25519Signature;
+    constructor(public_key: Ed25519PublicKey, signature: Ed25519Signature);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): AccountAuthenticatorEd25519;
+}
+/**
+ * Transaction authenticator Multi Ed25519 for a multi signers transaction
+ *
+ * @param public_key Account's MultiEd25519 public key.
+ * @param signature Account's MultiEd25519 signature
+ *
+ */
+declare class AccountAuthenticatorMultiEd25519 extends AccountAuthenticator {
+    readonly public_key: MultiEd25519PublicKey;
+    readonly signature: MultiEd25519Signature;
+    constructor(public_key: MultiEd25519PublicKey, signature: MultiEd25519Signature);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): AccountAuthenticatorMultiEd25519;
+}
+/**
+ * AccountAuthenticatorSingleKey for a single signer
+ *
+ * @param public_key AnyPublicKey
+ * @param signature AnySignature
+ *
+ */
+declare class AccountAuthenticatorSingleKey extends AccountAuthenticator {
+    readonly public_key: AnyPublicKey;
+    readonly signature: AnySignature;
+    constructor(public_key: AnyPublicKey, signature: AnySignature);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): AccountAuthenticatorSingleKey;
+}
+/**
+ * AccountAuthenticatorMultiKey for a multi signer
+ *
+ * @param public_keys MultiKey
+ * @param signatures Signature
+ *
+ */
+declare class AccountAuthenticatorMultiKey extends AccountAuthenticator {
+    readonly public_keys: MultiKey;
+    readonly signatures: Array<AnySignature>;
+    readonly signatures_bitmap: Uint8Array;
+    constructor(public_keys: MultiKey, signatures: Array<AnySignature>, signatures_bitmap: Uint8Array);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): AccountAuthenticatorMultiKey;
+}
+
+declare abstract class TransactionAuthenticator extends Serializable {
+    abstract serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): TransactionAuthenticator;
+}
+/**
+ * Transaction authenticator Ed25519 for a single signer transaction
+ *
+ * @param public_key Client's public key.
+ * @param signature Ed25519 signature of a raw transaction.
+ * @see {@link https://aptos.dev/integration/creating-a-signed-transaction | Creating a Signed Transaction}
+ * for details about generating a signature.
+ */
+declare class TransactionAuthenticatorEd25519 extends TransactionAuthenticator {
+    readonly public_key: Ed25519PublicKey;
+    readonly signature: Ed25519Signature;
+    constructor(public_key: Ed25519PublicKey, signature: Ed25519Signature);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TransactionAuthenticatorEd25519;
+}
+/**
+ * Transaction authenticator Ed25519 for a multi signers transaction
+ *
+ * @param public_key Client's public key.
+ * @param signature Multi Ed25519 signature of a raw transaction.
+ *
+ */
+declare class TransactionAuthenticatorMultiEd25519 extends TransactionAuthenticator {
+    readonly public_key: MultiEd25519PublicKey;
+    readonly signature: MultiEd25519Signature;
+    constructor(public_key: MultiEd25519PublicKey, signature: MultiEd25519Signature);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TransactionAuthenticatorMultiEd25519;
+}
+/**
+ * Transaction authenticator for a multi-agent transaction
+ *
+ * @param sender Sender account authenticator
+ * @param secondary_signer_addresses Secondary signers address
+ * @param secondary_signers Secondary signers account authenticators
+ *
+ */
+declare class TransactionAuthenticatorMultiAgent extends TransactionAuthenticator {
+    readonly sender: AccountAuthenticator;
+    readonly secondary_signer_addresses: Array<AccountAddress>;
+    readonly secondary_signers: Array<AccountAuthenticator>;
+    constructor(sender: AccountAuthenticator, secondary_signer_addresses: Array<AccountAddress>, secondary_signers: Array<AccountAuthenticator>);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TransactionAuthenticatorMultiAgent;
+}
+/**
+ * Transaction authenticator for a fee payer transaction
+ *
+ * @param sender Sender account authenticator
+ * @param secondary_signer_addresses Secondary signers address
+ * @param secondary_signers Secondary signers account authenticators
+ * @param fee_payer Object of the fee payer account address and the fee payer authentication
+ *
+ */
+declare class TransactionAuthenticatorFeePayer extends TransactionAuthenticator {
+    readonly sender: AccountAuthenticator;
+    readonly secondary_signer_addresses: Array<AccountAddress>;
+    readonly secondary_signers: Array<AccountAuthenticator>;
+    readonly fee_payer: {
+        address: AccountAddress;
+        authenticator: AccountAuthenticator;
+    };
+    constructor(sender: AccountAuthenticator, secondary_signer_addresses: Array<AccountAddress>, secondary_signers: Array<AccountAuthenticator>, fee_payer: {
+        address: AccountAddress;
+        authenticator: AccountAuthenticator;
+    });
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TransactionAuthenticatorMultiAgent;
+}
+/**
+ * Single Sender authenticator for a single signer transaction
+ *
+ * @param sender AccountAuthenticator
+ */
+declare class TransactionAuthenticatorSingleSender extends TransactionAuthenticator {
+    readonly sender: AccountAuthenticator;
+    constructor(sender: AccountAuthenticator);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TransactionAuthenticatorSingleSender;
+}
+
+declare class SignedTransaction extends Serializable {
+    readonly raw_txn: RawTransaction;
+    readonly authenticator: TransactionAuthenticator;
+    /**
+     * A SignedTransaction consists of a raw transaction and an authenticator. The authenticator
+     * contains a client's public key and the signature of the raw transaction.
+     *
+     * @see {@link https://aptos.dev/integration/creating-a-signed-transaction | Creating a Signed Transaction}
+     *
+     * @param raw_txn
+     * @param authenticator Contains a client's public key and the signature of the raw transaction.
+     * Authenticator has 3 flavors: single signature, multi-signature and multi-agent.
+     * @see {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs} for details.
+     */
+    constructor(raw_txn: RawTransaction, authenticator: TransactionAuthenticator);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): SignedTransaction;
+}
+
+/**
+ * Entry function arguments to be used when building a raw transaction using remote ABI
+ */
+declare type SimpleEntryFunctionArgumentTypes = boolean | number | bigint | string | null | undefined | Uint8Array | Array<SimpleEntryFunctionArgumentTypes>;
+/**
+ * Entry function arguments to be used when building a raw transaction using BCS serialized arguments
+ */
+declare type EntryFunctionArgumentTypes = Bool | U8 | U16 | U32 | U64 | U128 | U256 | AccountAddress | MoveVector<EntryFunctionArgumentTypes> | MoveOption<EntryFunctionArgumentTypes> | MoveString | FixedBytes;
+/**
+ * Script function arguments to be used when building a raw transaction using BCS serialized arguments
+ */
+declare type ScriptFunctionArgumentTypes = Bool | U8 | U16 | U32 | U64 | U128 | U256 | AccountAddress | MoveVector<U8> | MoveString | FixedBytes;
 /**
  * Type that holds all raw transaction instances Aptos SDK supports
  */
@@ -3935,7 +4344,7 @@ declare type AnyRawTransactionInstance = RawTransaction | MultiAgentRawTransacti
 /**
  * Optional options to set when generating a transaction
  */
-declare type GenerateTransactionOptions = {
+declare type InputGenerateTransactionOptions = {
     maxGasAmount?: AnyNumber;
     gasUnitPrice?: AnyNumber;
     expireTimestamp?: AnyNumber;
@@ -3944,80 +4353,101 @@ declare type GenerateTransactionOptions = {
 /**
  * The generated transaction payload type that was produces from `generateTransactionPayload()` function.
  */
-declare type TransactionPayload = TransactionPayloadEntryFunction | TransactionPayloadScript | TransactionPayloadMultisig;
+declare type AnyTransactionPayloadInstance = TransactionPayloadEntryFunction | TransactionPayloadScript | TransactionPayloadMultisig;
 /**
  * Unified type for the data needed to generate a transaction payload of types:
  * Entry Function | Script | Multi Sig
  */
-declare type GenerateTransactionPayloadData = EntryFunctionData | ScriptData | MultiSigData;
+declare type InputGenerateTransactionPayloadData = InputEntryFunctionData | InputScriptData | InputMultiSigData;
+declare type InputGenerateTransactionPayloadDataWithRemoteABI = (InputScriptData & {
+    aptosConfig?: undefined;
+}) | InputEntryFunctionDataWithRemoteABI | InputMultiSigDataWithRemoteABI;
 /**
  * The data needed to generate an Entry Function payload
  */
-declare type EntryFunctionData = {
+declare type InputEntryFunctionData = {
     function: MoveStructType;
     typeArguments?: Array<TypeTag>;
-    arguments: Array<EntryFunctionArgumentTypes>;
+    functionArguments: Array<EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes>;
+};
+declare type InputEntryFunctionDataWithRemoteABI = InputEntryFunctionData & {
+    aptosConfig: AptosConfig;
 };
 /**
  * The data needed to generate a Multi Sig payload
  */
-declare type MultiSigData = {
+declare type InputMultiSigData = {
     multisigAddress: AccountAddress;
-} & EntryFunctionData;
+} & InputEntryFunctionData;
+/**
+ * The data needed to generate a Multi Sig payload
+ */
+declare type InputMultiSigDataWithRemoteABI = {
+    multisigAddress: AccountAddress | string;
+} & InputEntryFunctionDataWithRemoteABI;
 /**
  * The data needed to generate a Script payload
  */
-declare type ScriptData = {
+declare type InputScriptData = {
     bytecode: HexInput;
     typeArguments?: Array<TypeTag>;
-    arguments: Array<ScriptFunctionArgumentTypes>;
+    functionArguments: Array<ScriptFunctionArgumentTypes>;
+};
+/**
+ * Interface of an Entry function's ABI.
+ *
+ * This is used to provide type checking and simple input conversion on ABI based transaction submission.
+ */
+declare type EntryFunctionABI = {
+    typeParameters: Array<MoveFunctionGenericTypeParam>;
+    parameters: Array<TypeTag>;
 };
 /**
  * Interface of the arguments to generate a single signer transaction.
  * Used to provide to `generateTransaction()` method in the transaction builder flow
  */
-interface GenerateSingleSignerRawTransactionArgs {
+interface InputGenerateSingleSignerRawTransactionArgs {
     aptosConfig: AptosConfig;
     sender: HexInput;
-    payload: TransactionPayload;
+    payload: AnyTransactionPayloadInstance;
     feePayerAddress?: undefined;
     secondarySignerAddresses?: undefined;
-    options?: GenerateTransactionOptions;
+    options?: InputGenerateTransactionOptions;
 }
 /**
  * Interface of the arguments to generate a fee payer transaction.
  * Used to provide to `generateTransaction()` method in the transaction builder flow
  */
-interface GenerateFeePayerRawTransactionArgs {
+interface InputGenerateFeePayerRawTransactionArgs {
     aptosConfig: AptosConfig;
     sender: HexInput;
-    payload: TransactionPayload;
+    payload: AnyTransactionPayloadInstance;
     feePayerAddress: HexInput;
     secondarySignerAddresses?: HexInput[];
-    options?: GenerateTransactionOptions;
+    options?: InputGenerateTransactionOptions;
 }
 /**
  * Interface of the arguments to generate a multi-agent transaction.
  * Used to provide to `generateTransaction()` method in the transaction builder flow
  */
-interface GenerateMultiAgentRawTransactionArgs {
+interface InputGenerateMultiAgentRawTransactionArgs {
     aptosConfig: AptosConfig;
     sender: HexInput;
-    payload: TransactionPayload;
+    payload: AnyTransactionPayloadInstance;
     secondarySignerAddresses: HexInput[];
     feePayerAddress?: undefined;
-    options?: GenerateTransactionOptions;
+    options?: InputGenerateTransactionOptions;
 }
 /**
  * Unified type that holds all the interfaces to generate different transaction types
  */
-declare type GenerateRawTransactionArgs = GenerateSingleSignerRawTransactionArgs | GenerateFeePayerRawTransactionArgs | GenerateMultiAgentRawTransactionArgs;
+declare type InputGenerateRawTransactionArgs = InputGenerateSingleSignerRawTransactionArgs | InputGenerateFeePayerRawTransactionArgs | InputGenerateMultiAgentRawTransactionArgs;
 /**
  * Interface that holds the return data when generating a single signer transaction
  *
  * @param rawTransaction a bcs serialized raw transaction
  */
-interface SingleSignerTransaction {
+interface InputSingleSignerTransaction {
     rawTransaction: Uint8Array;
     feePayerAddress?: undefined;
     secondarySignerAddresses?: undefined;
@@ -4029,7 +4459,7 @@ interface SingleSignerTransaction {
  * @param secondarySignerAddresses optional. secondary signer addresses for multi-agent transaction
  * @param feePayerAddress fee payer address for a fee payer transaction (aka Sponsored Transaction)
  */
-interface FeePayerTransaction {
+interface InputFeePayerTransaction {
     rawTransaction: Uint8Array;
     feePayerAddress: AccountAddress;
     secondarySignerAddresses?: AccountAddress[];
@@ -4040,7 +4470,7 @@ interface FeePayerTransaction {
  * @param rawTransaction a bcs serialized raw transaction
  * @param secondarySignerAddresses secondary signer addresses for multi-agent transaction
  */
-interface MultiAgentTransaction {
+interface InputMultiAgentTransaction {
     rawTransaction: Uint8Array;
     secondarySignerAddresses: AccountAddress[];
     feePayerAddress?: undefined;
@@ -4048,8 +4478,8 @@ interface MultiAgentTransaction {
 /**
  * Unified type that holds all the return interfaces when generating different transaction types
  */
-declare type AnyRawTransaction = SingleSignerTransaction | FeePayerTransaction | MultiAgentTransaction;
-declare type SimulateTransactionData = {
+declare type AnyRawTransaction = InputSingleSignerTransaction | InputFeePayerTransaction | InputMultiAgentTransaction;
+declare type InputSimulateTransactionData = {
     /**
      * The transaction to simulate, probably generated by `generateTransaction()`
      */
@@ -4066,9 +4496,9 @@ declare type SimulateTransactionData = {
      * For a fee payer transaction (aka Sponsored Transaction)
      */
     feePayerPublicKey?: PublicKey;
-    options?: SimulateTransactionOptions;
+    options?: InputSimulateTransactionOptions;
 };
-declare type SimulateTransactionOptions = {
+declare type InputSimulateTransactionOptions = {
     estimateGasUnitPrice?: boolean;
     estimateMaxGasAmount?: boolean;
     estimatePrioritizedGasUnitPrice?: boolean;
@@ -4076,37 +4506,37 @@ declare type SimulateTransactionOptions = {
 /**
  * Interface that holds the user data input when generating a single signer transaction
  */
-interface GenerateSingleSignerRawTransactionInput {
+interface InputGenerateSingleSignerRawTransactionData {
     sender: HexInput;
     feePayerAddress?: undefined;
     secondarySignerAddresses?: undefined;
-    options?: GenerateTransactionOptions;
-    data: GenerateTransactionPayloadData;
+    options?: InputGenerateTransactionOptions;
+    data: InputGenerateTransactionPayloadData;
 }
 /**
  * Interface that holds the user data input when generating a fee payer transaction
  */
-interface GenerateFeePayerRawTransactionInput {
+interface InputGenerateFeePayerRawTransactionData {
     sender: HexInput;
     feePayerAddress: HexInput;
     secondarySignerAddresses?: HexInput[];
-    options?: GenerateTransactionOptions;
-    data: GenerateTransactionPayloadData;
+    options?: InputGenerateTransactionOptions;
+    data: InputGenerateTransactionPayloadData;
 }
 /**
  * Interface that holds the user data input when generating a multi-agent transaction
  */
-interface GenerateMultiAgentRawTransactionInput {
+interface InputGenerateMultiAgentRawTransactionData {
     sender: HexInput;
     secondarySignerAddresses: HexInput[];
     feePayerAddress?: undefined;
-    options?: GenerateTransactionOptions;
-    data: GenerateTransactionPayloadData;
+    options?: InputGenerateTransactionOptions;
+    data: InputGenerateTransactionPayloadData;
 }
 /**
  * Unified type that holds all the user data input interfaces when generating different transaction types
  */
-declare type GenerateTransactionInput = GenerateMultiAgentRawTransactionInput | GenerateFeePayerRawTransactionInput | GenerateSingleSignerRawTransactionInput;
+declare type InputGenerateTransactionData = InputGenerateMultiAgentRawTransactionData | InputGenerateFeePayerRawTransactionData | InputGenerateSingleSignerRawTransactionData;
 
 /**
  * A class to handle all `Coin` operations
@@ -4128,9 +4558,9 @@ declare class Coin {
         sender: Account$1;
         recipient: HexInput;
         amount: AnyNumber;
-        coinType?: MoveResourceType;
-        options?: GenerateTransactionOptions;
-    }): Promise<SingleSignerTransaction>;
+        coinType?: MoveStructType;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<InputSingleSignerTransaction>;
 }
 
 /**
@@ -4191,8 +4621,8 @@ declare class DigitalAsset {
         description: string;
         name: string;
         uri: string;
-        options?: GenerateTransactionOptions;
-    } & CreateCollectionOptions): Promise<SingleSignerTransaction>;
+        options?: InputGenerateTransactionOptions;
+    } & CreateCollectionOptions): Promise<InputSingleSignerTransaction>;
     /**
      * Queries data of a specific collection by the collection creator address and the collection name.
      *
@@ -4246,8 +4676,8 @@ declare class DigitalAsset {
         description: string;
         name: string;
         uri: string;
-        options?: GenerateTransactionOptions;
-    }): Promise<SingleSignerTransaction>;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<InputSingleSignerTransaction>;
     /**
      * Gets token data given the address of a token.
      *
@@ -4322,7 +4752,7 @@ declare class Event {
      */
     getAccountEventsByEventType(args: {
         accountAddress: HexInput;
-        eventType: MoveResourceType;
+        eventType: MoveStructType;
         options?: {
             pagination?: PaginationArgs;
             orderBy?: OrderBy<GetEventsResponse[0]>;
@@ -4365,13 +4795,13 @@ declare class Faucet {
      *
      * @param args.accountAddress Address of the account to fund
      * @param args.amount Amount of tokens to fund the account with
-     * @param args.timeoutSecs Timeout in seconds. Defaults to 20 seconds.
+     * @param args.options Configuration options for waitForTransaction
      * @returns Transaction hash of the transaction that funded the account
      */
     fundAccount(args: {
         accountAddress: HexInput;
         amount: number;
-        timeoutSecs?: number;
+        options?: WaitForTransactionOptions;
     }): Promise<string>;
 }
 
@@ -4395,6 +4825,19 @@ declare class FungibleAsset {
             where?: FungibleAssetMetadataBoolExp;
         };
     }): Promise<GetFungibleAssetMetadataResponse>;
+    /**
+     * Queries the current specific fungible asset metadata
+     *
+     * This query returns the fungible asset metadata for a specific fungible asset.
+     *
+     * @param assetType The asset type of the fungible asset.
+     * e.g
+     * "0x1::aptos_coin::AptosCoin" for Aptos Coin
+     * "0xc2948283c2ce03aafbb294821de7ee684b06116bb378ab614fa2de07a99355a8" - address format if this is fungible asset
+     *
+     * @returns getFungibleAssetMetadata A fungible asset metadata item
+     */
+    getFungibleAssetMetadataByAssetType(assetType: string): Promise<GetFungibleAssetMetadataResponse[0]>;
     /**
      * Queries the fungible asset activities
      *
@@ -4515,8 +4958,8 @@ declare class General {
      * `
      * const payload: ViewRequest = {
      *  function: "0x1::coin::balance",
-     *  type_arguments: ["0x1::aptos_coin::AptosCoin"],
-     *  arguments: [accountAddress],
+     *  typeArguments: ["0x1::aptos_coin::AptosCoin"],
+     *  functionArguments: [accountAddress],
      * };
      * `
      *
@@ -4676,10 +5119,7 @@ declare class Transaction {
      */
     waitForTransaction(args: {
         transactionHash: HexInput;
-        options?: {
-            timeoutSecs?: number;
-            checkSuccess?: boolean;
-        };
+        options?: WaitForTransactionOptions;
     }): Promise<TransactionResponse>;
     /**
      * Gives an estimate of the gas unit price required to get a
@@ -4699,11 +5139,6 @@ declare class Transaction {
     getGasPriceEstimation(): Promise<GasEstimation>;
 }
 
-declare abstract class AccountAuthenticator extends Serializable {
-    abstract serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): AccountAuthenticator;
-}
-
 declare class TransactionSubmission {
     readonly config: AptosConfig;
     constructor(config: AptosConfig);
@@ -4713,10 +5148,10 @@ declare class TransactionSubmission {
      * When we call `generateTransaction` function with the relevant type properties,
      * Typescript can infer the return type based on the appropriate function overload.
      */
-    generateTransaction(args: GenerateSingleSignerRawTransactionInput): Promise<SingleSignerTransaction>;
-    generateTransaction(args: GenerateFeePayerRawTransactionInput): Promise<FeePayerTransaction>;
-    generateTransaction(args: GenerateMultiAgentRawTransactionInput): Promise<MultiAgentTransaction>;
-    generateTransaction(args: GenerateTransactionInput): Promise<AnyRawTransaction>;
+    generateTransaction(args: InputGenerateSingleSignerRawTransactionData): Promise<InputSingleSignerTransaction>;
+    generateTransaction(args: InputGenerateFeePayerRawTransactionData): Promise<InputFeePayerTransaction>;
+    generateTransaction(args: InputGenerateMultiAgentRawTransactionData): Promise<InputMultiAgentTransaction>;
+    generateTransaction(args: InputGenerateTransactionData): Promise<AnyRawTransaction>;
     /**
      * Sign a transaction that can later be submitted to chain
      *
@@ -4745,7 +5180,7 @@ declare class TransactionSubmission {
      * @param args.feePayerPublicKey optional. For when the transaction is a fee payer (aka sponsored) transaction
      * @param args.options optional. A config to simulate the transaction with
      */
-    simulateTransaction(args: SimulateTransactionData): Promise<Array<UserTransactionResponse>>;
+    simulateTransaction(args: InputSimulateTransactionData): Promise<Array<UserTransactionResponse>>;
     /**
      * Submit transaction to chain
      *
@@ -4789,18 +5224,18 @@ declare class TransactionSubmission {
      * `aptos move compile --save-metadata ...`,
      * For more info {@link https://aptos.dev/tutorials/your-first-dapp/#step-4-publish-a-move-module}
      *
-     * @param account The publisher account
-     * @param metadataBytes The package metadata bytes
-     * @param byteCode The bytecodes of modules
+     * @param args.account The publisher account
+     * @param args.metadataBytes The package metadata bytes
+     * @param args.moduleBytecode An array of the bytecode of each module in the package in compiler output order
      *
      * @returns A SingleSignerTransaction that can be simulated or submitted to chain
      */
-    publishModuleTransaction(args: {
+    publishPackageTransaction(args: {
         account: HexInput;
         metadataBytes: HexInput;
-        byteCode: HexInput;
-        options?: GenerateTransactionOptions;
-    }): Promise<SingleSignerTransaction>;
+        moduleBytecode: Array<HexInput>;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<InputSingleSignerTransaction>;
 }
 
 /**
@@ -4975,6 +5410,196 @@ declare function postAptosFullNode<Req, Res>(options: PostAptosRequestOptions):
 declare function postAptosIndexer<Req, Res>(options: PostAptosRequestOptions): Promise<AptosResponse<Req, Res>>;
 declare function postAptosFaucet<Req, Res>(options: PostAptosRequestOptions): Promise<AptosResponse<Req, Res>>;
 
+declare function isBool(arg: SimpleEntryFunctionArgumentTypes): arg is boolean;
+declare function isString(arg: any): arg is string;
+declare function isNumber(arg: SimpleEntryFunctionArgumentTypes): arg is number;
+declare function isLargeNumber(arg: SimpleEntryFunctionArgumentTypes): arg is number | bigint | string;
+declare function isNull(arg: SimpleEntryFunctionArgumentTypes): arg is null | undefined;
+declare function isBcsBool(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is Bool;
+declare function isBcsAddress(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is AccountAddress;
+declare function isBcsString(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is MoveString;
+declare function isBcsFixedBytes(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is FixedBytes;
+declare function isBcsU8(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U8;
+declare function isBcsU16(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U16;
+declare function isBcsU32(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U32;
+declare function isBcsU64(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U64;
+declare function isBcsU128(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U128;
+declare function isBcsU256(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U256;
+declare function isScriptDataInput(arg: InputGenerateTransactionPayloadDataWithRemoteABI | InputGenerateTransactionPayloadData): arg is InputScriptData;
+declare function throwTypeMismatch(expectedType: string, position: number): void;
+/**
+ * Finds first non-signer arg.
+ *
+ * A function is often defined with a `signer` or `&signer` arguments at the start, which are filled in
+ * by signatures, and not by the caller.
+ * @param functionAbi
+ */
+declare function findFirstNonSignerArg(functionAbi: MoveFunction): number;
+declare function getFunctionParts(functionArg: MoveStructType): {
+    moduleAddress: string;
+    moduleName: string;
+    functionName: string;
+};
+
+/**
+ * We are defining function signatures, each with its specific input and output.
+ * These are the possible function signature for our `generateTransactionPayload` function.
+ * When we call our `generateTransactionPayload` function with the relevant type properties,
+ * Typescript can infer the return type based on the appropriate function overload.
+ */
+declare function generateTransactionPayload(args: InputScriptData & {
+    aptosConfig?: undefined;
+}): Promise<TransactionPayloadScript>;
+declare function generateTransactionPayload(args: InputEntryFunctionDataWithRemoteABI): Promise<TransactionPayloadEntryFunction>;
+declare function generateTransactionPayload(args: InputMultiSigDataWithRemoteABI): Promise<TransactionPayloadMultisig>;
+declare function generateTransactionPayload(args: InputGenerateTransactionPayloadDataWithRemoteABI): Promise<AnyTransactionPayloadInstance>;
+declare function generateTransactionPayloadWithABI(args: InputEntryFunctionData, functionAbi: EntryFunctionABI): TransactionPayloadEntryFunction;
+declare function generateTransactionPayloadWithABI(args: InputMultiSigData, functionAbi: EntryFunctionABI): TransactionPayloadMultisig;
+declare function generateTransactionPayloadWithABI(args: InputGenerateTransactionPayloadData, functionAbi: EntryFunctionABI): AnyTransactionPayloadInstance;
+/**
+ * Generates a raw transaction
+ *
+ * @param args.aptosConfig AptosConfig
+ * @param args.sender The transaction's sender account address as a hex input
+ * @param args.payload The transaction payload - can create by using generateTransactionPayload()
+ *
+ * @returns RawTransaction
+ */
+declare function generateRawTransaction(args: {
+    aptosConfig: AptosConfig;
+    sender: HexInput;
+    payload: AnyTransactionPayloadInstance;
+    options?: InputGenerateTransactionOptions;
+}): Promise<RawTransaction>;
+/**
+ * We are defining function signatures, each with its specific input and output.
+ * These are the possible function signature for our `generateTransaction` function.
+ * When we call our `generateTransaction` function with the relevant type properties,
+ * Typescript can infer the return type based on the appropriate function overload.
+ */
+declare function buildTransaction(args: InputGenerateSingleSignerRawTransactionArgs): Promise<InputSingleSignerTransaction>;
+declare function buildTransaction(args: InputGenerateFeePayerRawTransactionArgs): Promise<InputFeePayerTransaction>;
+declare function buildTransaction(args: InputGenerateMultiAgentRawTransactionArgs): Promise<InputMultiAgentTransaction>;
+declare function buildTransaction(args: InputGenerateRawTransactionArgs): Promise<AnyRawTransaction>;
+/**
+ * Simulate a transaction before signing and submit to chain
+ *
+ * @param args.transaction A aptos transaction type to sign
+ * @param args.signerPublicKey The signer public key
+ * @param args.secondarySignersPublicKeys optional. The secondary signers public keys if multi signers transaction
+ * @param args.feePayerPublicKey optional. The fee payer public key is a fee payer (aka sponsored) transaction
+ * @param args.options optional. SimulateTransactionOptions
+ *
+ * @returns A signed serialized transaction that can be simulated
+ */
+declare function generateSignedTransactionForSimulation(args: InputSimulateTransactionData): Uint8Array;
+declare function getAuthenticatorForSimulation(publicKey: PublicKey): AccountAuthenticatorEd25519 | AccountAuthenticatorSingleKey;
+/**
+ * Sign a transaction that can later be submitted to chain
+ *
+ * @param args.signer The signer account to sign the transaction
+ * @param args.transaction A aptos transaction type to sign
+ *
+ * @return The signer AccountAuthenticator
+ */
+declare function sign(args: {
+    signer: Account$1;
+    transaction: AnyRawTransaction;
+}): AccountAuthenticator;
+/**
+ * Prepare a transaction to be submitted to chain
+ *
+ * @param args.transaction A aptos transaction type
+ * @param args.senderAuthenticator The account authenticator of the transaction sender
+ * @param args.secondarySignerAuthenticators optional. For when the transaction is a multi signers transaction
+ *
+ * @returns A SignedTransaction
+ */
+declare function generateSignedTransaction(args: {
+    transaction: AnyRawTransaction;
+    senderAuthenticator: AccountAuthenticator;
+    secondarySignerAuthenticators?: {
+        feePayerAuthenticator?: AccountAuthenticator;
+        additionalSignersAuthenticators?: Array<AccountAuthenticator>;
+    };
+}): Uint8Array;
+/**
+ * Derive the raw transaction type - FeePayerRawTransaction or MultiAgentRawTransaction or RawTransaction
+ *
+ * @param transaction A aptos transaction type
+ *
+ * @returns FeePayerRawTransaction | MultiAgentRawTransaction | RawTransaction
+ */
+declare function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTransactionInstance;
+/**
+ * Generate a multi signers signed transaction that can be submitted to chain
+ *
+ * @param transaction MultiAgentRawTransaction | FeePayerRawTransaction
+ * @param senderAuthenticator The account authenticator of the transaction sender
+ * @param secondarySignerAuthenticators The extra signers account Authenticators
+ *
+ * @returns A SignedTransaction
+ */
+declare function generateMultiSignersSignedTransaction(transaction: MultiAgentRawTransaction | FeePayerRawTransaction, senderAuthenticator: AccountAuthenticator, secondarySignerAuthenticators: {
+    feePayerAuthenticator?: AccountAuthenticator;
+    additionalSignersAuthenticators?: Array<AccountAuthenticator>;
+}): Uint8Array;
+declare function getSigningMessage(rawTxn: AnyRawTransactionInstance): Uint8Array;
+
+/**
+ * Convert type arguments to only type tags, allowing for string representations of type tags
+ */
+declare function standardizeTypeTags(typeArguments?: Array<TypeTag | string>): Array<TypeTag>;
+/**
+ * Fetches the ABI for an entry function from the module
+ *
+ * @param moduleAddress
+ * @param moduleName
+ * @param functionName
+ * @param aptosConfig
+ */
+declare function fetchEntryFunctionAbi(moduleAddress: string, moduleName: string, functionName: string, aptosConfig: AptosConfig): Promise<EntryFunctionABI>;
+/**
+ * Converts a non-BCS encoded argument into BCS encoded, if necessary
+ * @param functionName
+ * @param functionAbi
+ * @param arg
+ * @param position
+ */
+declare function convertArgument(functionName: string, functionAbi: EntryFunctionABI, arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes, position: number, genericTypeParams: Array<TypeTag>): EntryFunctionArgumentTypes;
+
+declare enum TypeTagParserErrorType {
+    InvalidTypeTag = "unknown type",
+    UnexpectedTypeArgumentClose = "unexpected '>'",
+    UnexpectedWhitespaceCharacter = "unexpected whitespace character",
+    UnexpectedComma = "unexpected ','",
+    TypeArgumentCountMismatch = "type argument count doesn't match expected amount",
+    MissingTypeArgumentClose = "no matching '>' for '<'",
+    UnexpectedPrimitiveTypeArguments = "primitive types not expected to have type arguments",
+    UnexpectedVectorTypeArgumentCount = "vector type expected to have exactly one type argument",
+    UnexpectedStructFormat = "unexpected struct format, must be of the form 0xaddress::module_name::struct_name",
+    InvalidModuleNameCharacter = "module name must only contain alphanumeric or '_' characters",
+    InvalidStructNameCharacter = "struct name must only contain alphanumeric or '_' characters"
+}
+declare class TypeTagParserError extends Error {
+    constructor(typeTagStr: string, invalidReason: TypeTagParserErrorType);
+}
+/**
+ * All types are made of a few parts they're either:
+ * 1. A simple type e.g. u8
+ * 2. A standalone struct e.g. 0x1::account::Account
+ * 3. A nested struct e.g. 0x1::coin::Coin<0x1234::coin::MyCoin>
+ *
+ * There are a few more special cases that need to be handled, however.
+ * 1. Multiple generics e.g 0x1::pair::Pair<u8, u16>
+ * 2. Spacing in the generics e.g. 0x1::pair::Pair< u8 , u16>
+ * 3. Nested generics of different depths e.g. 0x1::pair::Pair<0x1::coin::Coin<0x1234::coin::MyCoin>, u8>
+ * 4. Generics for types in ABIs are filled in with placeholders e.g T1, T2, T3
+ */
+declare function parseTypeTag(typeStr: string, options?: {
+    allowGenerics?: boolean;
+}): TypeTag;
+
 declare type DerivedKeys = {
     key: Uint8Array;
     chainCode: Uint8Array;
@@ -5009,4 +5634,4 @@ declare const isValidPath: (path: string) => boolean;
  */
 declare const derivePrivateKeyFromMnemonic: (keyType: KeyType, path: string, seedPhrase: string, offset?: number) => DerivedKeys;
 
-export { APTOS_PATH_REGEX, Account$1 as Account, AccountAddress, AccountAuthenticatorVariant, AccountData, AccountEd25519Signature, AccountMultiEd25519Signature, AccountSecp256k1Signature, AccountSignature, AddressInvalidReason, AnyNumber, AnyRawTransaction, AnyRawTransactionInstance, Aptos, AptosApiError, AptosConfig, AptosRequest, AptosResponse, AptosSettings, AuthenticationKey, AuthenticationKeyScheme, Block, BlockMetadataTransactionResponse, Bool, Client, ClientConfig, ClientRequest, ClientResponse, DecodedTableData, DeletedTableData, DeriveScheme, DerivedKeys, Deserializable, Deserializer, DirectWriteSet, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, EntryFunctionArgumentTypes, EntryFunctionBytes, EntryFunctionData, EntryFunctionPayloadResponse, Event$1 as Event, EventGuid, FeePayerTransaction, FixedBytes, GasEstimation, GenerateFeePayerRawTransactionArgs, GenerateFeePayerRawTransactionInput, GenerateMultiAgentRawTransactionArgs, GenerateMultiAgentRawTransactionInput, GenerateRawTransactionArgs, GenerateSingleSignerRawTransactionArgs, GenerateSingleSignerRawTransactionInput, GenerateTransactionInput, GenerateTransactionOptions, GenerateTransactionPayloadData, GenesisPayload, GenesisTransactionResponse, GetAccountCoinsDataResponse, GetAccountCollectionsWithOwnedTokenResponse, GetAccountOwnedObjectsResponse, GetAccountOwnedTokensFromCollectionResponse, GetAccountOwnedTokensQueryResponse, GetAptosRequestOptions, GetChainTopUserTransactionsResponse, GetCollectionDataResponse, GetCurrentFungibleAssetBalancesResponse, GetCurrentTokenOwnershipResponse, GetDelegatedStakingActivitiesResponse, GetEventsResponse, GetFungibleAssetActivitiesResponse, GetFungibleAssetMetadataResponse, GetNumberOfDelegatorsResponse, GetOwnedTokensResponse, GetProcessorStatusResponse, GetRequestOptions, GetTokenActivityResponse, GetTokenDataResponse, GraphqlQuery, Hex, HexInput, HexInvalidReason, KeyType, LedgerInfo, LedgerVersion, MimeType, MoveAbility, MoveAddressType, MoveFunction, MoveFunctionGenericTypeParam, MoveFunctionVisibility, MoveModule, MoveModuleBytecode, MoveModuleId, MoveObject, MoveObjectType, MoveOption, MoveOptionType, MoveResource, MoveResourceType, MoveScriptBytecode, MoveString, MoveStruct, MoveStructField, MoveStructType, MoveType, MoveUint128Type, MoveUint16Type, MoveUint256Type, MoveUint32Type, MoveUint64Type, MoveUint8Type, MoveValue, MoveVector, MultiAgentTransaction, MultiEd25519PublicKey, MultiEd25519Signature, MultiSigData, MultisigPayloadResponse, Network, NetworkToChainId, NetworkToFaucetAPI, NetworkToIndexerAPI, NetworkToNodeAPI, OrderBy, OrderByValue, PaginationArgs, ParsingError, ParsingResult, PendingTransactionResponse, PostAptosRequestOptions, PostRequestOptions, PrivateKey, PublicKey, RoleType, ScriptData, ScriptFunctionArgumentTypes, ScriptPayloadResponse, ScriptTransactionArgumentVariants, ScriptWriteSet, Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature, Serializable, Serializer, Signature, SigningScheme, SimulateTransactionData, SimulateTransactionOptions, SingleSignerTransaction, StateCheckpointTransactionResponse, StructTag, TableItemRequest, TokenStandard, TransactionAuthenticatorVariant, TransactionEd25519Signature, TransactionFeePayerSignature, TransactionMultiAgentSignature, TransactionMultiEd25519Signature, TransactionPayload, TransactionPayloadResponse, TransactionPayloadVariants, TransactionResponse, TransactionResponseType, TransactionSecp256k1Signature, TransactionSignature, TransactionVariants, TypeTag, TypeTagAddress, TypeTagBool, TypeTagParser, TypeTagParserError, TypeTagSigner, TypeTagStruct, TypeTagU128, TypeTagU16, TypeTagU256, TypeTagU32, TypeTagU64, TypeTagU8, TypeTagVariants, TypeTagVector, U128, U16, U256, U32, U64, U8, Uint128, Uint16, Uint256, Uint32, Uint64, Uint8, UserTransactionResponse, ViewRequest, ViewRequestData, WriteSet, WriteSetChange, WriteSetChangeDeleteModule, WriteSetChangeDeleteResource, WriteSetChangeDeleteTableItem, WriteSetChangeWriteModule, WriteSetChangeWriteResource, WriteSetChangeWriteTableItem, aptosRequest, derivePrivateKeyFromMnemonic, ensureBoolean, get, getAptosFullNode, isValidPath, objectStructTag, optionStructTag, outOfRangeErrorMessage, paginateWithCursor, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, request, stringStructTag, validateNumberInRange };
+export { APTOS_PATH_REGEX, Account$1 as Account, AccountAddress, AccountAuthenticator, AccountAuthenticatorEd25519, AccountAuthenticatorMultiEd25519, AccountAuthenticatorMultiKey, AccountAuthenticatorSingleKey, AccountAuthenticatorVariant, AccountData, AccountEd25519Signature, AccountMultiEd25519Signature, AccountSecp256k1Signature, AccountSignature, AddressInvalidReason, AnyNumber, AnyPublicKeyVariant, AnyRawTransaction, AnyRawTransactionInstance, AnySignatureVariant, AnyTransactionPayloadInstance, Aptos, AptosApiError, AptosConfig, AptosRequest, AptosResponse, AptosSettings, AuthenticationKey, AuthenticationKeyScheme, Block, BlockMetadataTransactionResponse, Bool, ChainId, Client, ClientConfig, ClientRequest, ClientResponse, DecodedTableData, DeletedTableData, DeriveScheme, DerivedKeys, Deserializable, Deserializer, DirectWriteSet, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, EntryFunction, EntryFunctionABI, EntryFunctionArgument, EntryFunctionArgumentTypes, EntryFunctionBytes, EntryFunctionPayloadResponse, Event$1 as Event, EventGuid, FeePayerRawTransaction, FixedBytes, GasEstimation, GenerateAccount, GenerateAccountWithLegacyKey, GenerateAccountWithUnifiedKey, GenesisPayload, GenesisTransactionResponse, GetAccountCoinsDataResponse, GetAccountCollectionsWithOwnedTokenResponse, GetAccountOwnedObjectsResponse, GetAccountOwnedTokensFromCollectionResponse, GetAccountOwnedTokensQueryResponse, GetAptosRequestOptions, GetChainTopUserTransactionsResponse, GetCollectionDataResponse, GetCurrentFungibleAssetBalancesResponse, GetCurrentTokenOwnershipResponse, GetDelegatedStakingActivitiesResponse, GetEventsResponse, GetFungibleAssetActivitiesResponse, GetFungibleAssetMetadataResponse, GetNumberOfDelegatorsResponse, GetOwnedTokensResponse, GetProcessorStatusResponse, GetRequestOptions, GetTokenActivityResponse, GetTokenDataResponse, GraphqlQuery, Hex, HexInput, HexInvalidReason, Identifier, InputEntryFunctionData, InputEntryFunctionDataWithRemoteABI, InputFeePayerTransaction, InputGenerateFeePayerRawTransactionArgs, InputGenerateFeePayerRawTransactionData, InputGenerateMultiAgentRawTransactionArgs, InputGenerateMultiAgentRawTransactionData, InputGenerateRawTransactionArgs, InputGenerateSingleSignerRawTransactionArgs, InputGenerateSingleSignerRawTransactionData, InputGenerateTransactionData, InputGenerateTransactionOptions, InputGenerateTransactionPayloadData, InputGenerateTransactionPayloadDataWithRemoteABI, InputMultiAgentTransaction, InputMultiSigData, InputMultiSigDataWithRemoteABI, InputScriptData, InputSimulateTransactionData, InputSimulateTransactionOptions, InputSingleSignerTransaction, KeyType, LedgerInfo, LedgerVersion, MimeType, ModuleId, MoveAbility, MoveAddressType, MoveFunction, MoveFunctionGenericTypeParam, MoveFunctionVisibility, MoveModule, MoveModuleBytecode, MoveModuleId, MoveObjectType, MoveOption, MoveOptionType, MoveResource, MoveScriptBytecode, MoveString, MoveStruct, MoveStructField, MoveStructType, MoveType, MoveUint128Type, MoveUint16Type, MoveUint256Type, MoveUint32Type, MoveUint64Type, MoveUint8Type, MoveValue, MoveVector, MultiAgentRawTransaction, MultiEd25519PublicKey, MultiEd25519Signature, MultiKey, MultiSig, MultisigPayloadResponse, MultisigTransactionPayload, Network, NetworkToChainId, NetworkToFaucetAPI, NetworkToIndexerAPI, NetworkToNodeAPI, OrderBy, OrderByValue, PaginationArgs, ParsingError, ParsingResult, PendingTransactionResponse, PostAptosRequestOptions, PostRequestOptions, PrivateKey, PublicKey, RawTransaction, RawTransactionWithData, RoleType, Script, ScriptFunctionArgument, ScriptFunctionArgumentTypes, ScriptPayloadResponse, ScriptTransactionArgumentVariants, ScriptWriteSet, Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature, Serializable, Serializer, Signature, SignedTransaction, SigningScheme, SigningSchemeInput, SimpleEntryFunctionArgumentTypes, StateCheckpointTransactionResponse, StructTag, TableItemRequest, TokenStandard, TransactionArgument, TransactionAuthenticator, TransactionAuthenticatorEd25519, TransactionAuthenticatorFeePayer, TransactionAuthenticatorMultiAgent, TransactionAuthenticatorMultiEd25519, TransactionAuthenticatorSingleSender, TransactionAuthenticatorVariant, TransactionEd25519Signature, TransactionFeePayerSignature, TransactionMultiAgentSignature, TransactionMultiEd25519Signature, TransactionPayload, TransactionPayloadEntryFunction, TransactionPayloadMultisig, TransactionPayloadResponse, TransactionPayloadScript, TransactionPayloadVariants, TransactionResponse, TransactionResponseType, TransactionSecp256k1Signature, TransactionSignature, TransactionVariants, TypeTag, TypeTagAddress, TypeTagBool, TypeTagGeneric, TypeTagParserError, TypeTagParserErrorType, TypeTagReference, TypeTagSigner, TypeTagStruct, TypeTagU128, TypeTagU16, TypeTagU256, TypeTagU32, TypeTagU64, TypeTagU8, TypeTagVariants, TypeTagVector, U128, U16, U256, U32, U64, U8, Uint128, Uint16, Uint256, Uint32, Uint64, Uint8, UserTransactionResponse, ViewRequest, ViewRequestData, WaitForTransactionOptions, WriteSet, WriteSetChange, WriteSetChangeDeleteModule, WriteSetChangeDeleteResource, WriteSetChangeDeleteTableItem, WriteSetChangeWriteModule, WriteSetChangeWriteResource, WriteSetChangeWriteTableItem, aptosCoinStructTag, aptosRequest, buildTransaction, convertArgument, derivePrivateKeyFromMnemonic, deriveTransactionType, deserializeFromScriptArgument, ensureBoolean, fetchEntryFunctionAbi, findFirstNonSignerArg, generateMultiSignersSignedTransaction, generateRawTransaction, generateSignedTransaction, generateSignedTransactionForSimulation, generateTransactionPayload, generateTransactionPayloadWithABI, get, getAptosFullNode, getAuthenticatorForSimulation, getFunctionParts, getSigningMessage, isBcsAddress, isBcsBool, isBcsFixedBytes, isBcsString, isBcsU128, isBcsU16, isBcsU256, isBcsU32, isBcsU64, isBcsU8, isBool, isLargeNumber, isNull, isNumber, isScriptDataInput, isString, isValidPath, objectStructTag, optionStructTag, outOfRangeErrorMessage, paginateWithCursor, parseTypeTag, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, request, sign, standardizeTypeTags, stringStructTag, throwTypeMismatch, validateNumberInRange };