@aptos-labs/ts-sdk 1.12.2 → 1.13.0-zeta.1

package/dist/common/index.d.ts

@@ -3,6 +3,8 @@ import EventEmitter from 'eventemitter3';
 declare const NetworkToIndexerAPI: Record<string, string>;
 declare const NetworkToNodeAPI: Record<string, string>;
 declare const NetworkToFaucetAPI: Record<string, string>;
+declare const NetworkToPepperAPI: Record<string, string>;
+declare const NetworkToProverAPI: Record<string, string>;
 declare enum Network {
     MAINNET = "mainnet",
     TESTNET = "testnet",
@@ -867,11 +869,23 @@ declare enum AccountAuthenticatorVariant {
 }
 declare enum AnyPublicKeyVariant {
     Ed25519 = 0,
-    Secp256k1 = 1
+    Secp256k1 = 1,
+    Keyless = 3
 }
 declare enum AnySignatureVariant {
     Ed25519 = 0,
-    Secp256k1 = 1
+    Secp256k1 = 1,
+    Keyless = 3
+}
+declare enum EphemeralPublicKeyVariant {
+    Ed25519 = 0
+}
+declare enum EphemeralSignatureVariant {
+    Ed25519 = 0
+}
+declare enum EphemeralCertificate {
+    ZkProof = 0,
+    OpenIdSignature = 1
 }
 /**
  * BCS types
@@ -893,6 +907,8 @@ type AptosSettings = {
     readonly fullnode?: string;
     readonly faucet?: string;
     readonly indexer?: string;
+    readonly pepper?: string;
+    readonly prover?: string;
     readonly clientConfig?: ClientConfig;
     readonly client?: Client;
     readonly fullnodeConfig?: FullNodeConfig;
@@ -962,6 +978,7 @@ type ClientHeadersType = {
 interface ClientRequest<Req> {
     url: string;
     method: "GET" | "POST";
+    originMethod?: string;
     body?: Req;
     contentType?: string;
     params?: any;
@@ -2153,6 +2170,8 @@ declare class Serializer {
      * // `bcs::to_bytes(&vector<address> [@0x1, @0x2, @0xa, @0xb])`;
      */
     serializeVector<T extends Serializable>(values: Array<T>): void;
+    serializeOption<T extends Serializable>(value?: T): void;
+    serializeOptionStr(value?: string): void;
 }
 declare function ensureBoolean(value: unknown): asserts value is boolean;
 declare const outOfRangeErrorMessage: (value: AnyNumber, min: AnyNumber, max: AnyNumber) => string;
@@ -3020,7 +3039,7 @@ declare class Ed25519PrivateKey extends Serializable implements PrivateKey {
      * The Ed25519 signing key
      * @private
      */
-    private readonly signingKeyPair;
+    private readonly signingKey;
     /**
      * Create a new PrivateKey instance from a Uint8Array or String.
      *
@@ -3045,16 +3064,6 @@ declare class Ed25519PrivateKey extends Serializable implements PrivateKey {
      * @param mnemonics the mnemonic seed phrase
      */
     static fromDerivationPath(path: string, mnemonics: string): Ed25519PrivateKey;
-    /**
-     * A private inner function so we can separate from the main fromDerivationPath() method
-     * to add tests to verify we create the keys correctly.
-     *
-     * @param path the BIP44 path
-     * @param seed the seed phrase created by the mnemonics
-     * @param offset the offset used for key derivation, defaults to 0x80000000
-     * @returns
-     */
-    private static fromDerivationPathInner;
     /**
      * Derive the Ed25519PublicKey for this private key.
      *
@@ -3104,6 +3113,13 @@ declare class Ed25519Signature extends Signature {
     toUint8Array(): Uint8Array;
     serialize(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): Ed25519Signature;
+    /**
+     * Checks if an ED25519 signature is non-canonical.
+     *
+     * Comes from Aptos Core
+     * https://github.com/aptos-labs/aptos-core/blob/main/crates/aptos-crypto/src/ed25519/ed25519_sigs.rs#L47-L85
+     */
+    isCanonicalSignature(): boolean;
 }
 
 type DerivedKeys = {
@@ -3115,6 +3131,7 @@ type DerivedKeys = {
  */
 declare const APTOS_HARDENED_REGEX: RegExp;
 declare const APTOS_BIP44_REGEX: RegExp;
+declare const APTOS_BIP44_DEFAULT_DERIVATION_PATH = "m/44'/637'/0'/0'/0'";
 /**
  * A list of supported key types and associated seeds
  */
@@ -3164,6 +3181,13 @@ declare const CKDPriv: ({ key, chainCode }: DerivedKeys, index: number) => Deriv
  * @param path
  */
 declare const splitPath: (path: string) => Array<string>;
+/**
+ * @param path the BIP44 path
+ * @param seed the seed phrase created by the mnemonics
+ * @param offset the offset used for key derivation, defaults to 0x80000000
+ * @returns
+ */
+declare function fromDerivationPath(path: string, hashSeed: HexInput, seed: Uint8Array, offset?: number): Uint8Array;
 /**
  * Normalizes the mnemonic by removing extra whitespace and making it lowercase
  * @param mnemonic the mnemonic seed phrase
@@ -3370,8 +3394,9 @@ declare class MultiKey extends AccountPublicKey {
     createBitmap(args: {
         bits: number[];
     }): Uint8Array;
+    getIndex(publicKey: PublicKey): number;
 }
-declare class MultiKeySignature extends Signature {
+declare class MultiSignature extends Signature {
     /**
      * Number of bytes in the bitmap representing who signed the transaction (32-bits)
      */
@@ -3423,7 +3448,265 @@ declare class MultiKeySignature extends Signature {
     }): Uint8Array;
     toUint8Array(): Uint8Array;
     serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): MultiKeySignature;
+    static deserialize(deserializer: Deserializer): MultiSignature;
+}
+
+/**
+ * Represents ephemeral keys and signatures for Aptos Keyless accounts.
+ *
+ * TODO
+ */
+declare class EphemeralPublicKey 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: EphemeralSignature;
+    }): boolean;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): EphemeralPublicKey;
+    static isPublicKey(publicKey: PublicKey): publicKey is EphemeralPublicKey;
+    isEd25519(): this is Ed25519PublicKey;
+}
+declare class EphemeralSignature 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;
+    static fromHex(hexInput: HexInput): EphemeralSignature;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): EphemeralSignature;
+}
+
+declare const EPK_HORIZON_SECS = 10000000;
+declare const MAX_AUD_VAL_BYTES = 120;
+declare const MAX_UID_KEY_BYTES = 30;
+declare const MAX_UID_VAL_BYTES = 330;
+declare const MAX_ISS_VAL_BYTES = 120;
+declare const MAX_EXTRA_FIELD_BYTES = 350;
+declare const MAX_JWT_HEADER_B64_BYTES = 300;
+declare const MAX_COMMITED_EPK_BYTES = 93;
+/**
+ * Represents the KeylessPublicKey public key
+ *
+ * KeylessPublicKey authentication key is represented in the SDK as `AnyPublicKey`.
+ */
+declare class KeylessPublicKey extends AccountPublicKey {
+    static readonly ADDRESS_SEED_LENGTH: number;
+    readonly iss: string;
+    readonly addressSeed: Uint8Array;
+    constructor(iss: string, addressSeed: HexInput);
+    authKey(): AuthenticationKey;
+    /**
+     * 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: KeylessSignature;
+    }): boolean;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): KeylessPublicKey;
+    static load(deserializer: Deserializer): KeylessPublicKey;
+    static isPublicKey(publicKey: PublicKey): publicKey is KeylessPublicKey;
+    static create(args: {
+        iss: string;
+        uidKey: string;
+        uidVal: string;
+        aud: string;
+        pepper: HexInput;
+    }): KeylessPublicKey;
+}
+declare function computeAddressSeed(args: {
+    uidKey: string;
+    uidVal: string;
+    aud: string;
+    pepper: HexInput;
+}): Uint8Array;
+declare class OpenIdSignatureOrZkProof 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): OpenIdSignatureOrZkProof;
+}
+declare class Groth16Zkp extends Serializable {
+    a: Uint8Array;
+    b: Uint8Array;
+    c: Uint8Array;
+    constructor(args: {
+        a: HexInput;
+        b: HexInput;
+        c: HexInput;
+    });
+    toUint8Array(): Uint8Array;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): Groth16Zkp;
+}
+declare class SignedGroth16Signature extends Signature {
+    readonly proof: Groth16Zkp;
+    readonly expHorizonSecs: bigint;
+    readonly extraField?: string;
+    readonly overrideAudVal?: string;
+    readonly trainingWheelsSignature?: EphemeralSignature;
+    constructor(args: {
+        proof: Groth16Zkp;
+        expHorizonSecs?: bigint;
+        extraField?: string;
+        overrideAudVal?: string;
+        trainingWheelsSignature?: EphemeralSignature;
+    });
+    /**
+     * Get the signature in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the signature
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the signature as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the signature
+     */
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): SignedGroth16Signature;
+    static load(deserializer: Deserializer): SignedGroth16Signature;
+}
+/**
+ * A OpenId signature which contains the private inputs to an OIDB proof.
+ */
+declare class OpenIdSignature extends Signature {
+    readonly jwtSignature: string;
+    readonly jwtPayloadJson: string;
+    readonly uidKey: string;
+    readonly epkBlinder: Uint8Array;
+    readonly pepper: Uint8Array;
+    readonly overrideAudValue?: string;
+    /**
+     * Create a new Signature instance from a Uint8Array or String.
+     *
+     * @param hexInput A HexInput (string or Uint8Array)
+     */
+    constructor(args: {
+        jwtSignature: string;
+        jwtPayloadJson: string;
+        uidKey?: string;
+        epkBlinder: Uint8Array;
+        pepper: Uint8Array;
+        overrideAudValue?: string;
+    });
+    /**
+     * Get the signature in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the signature
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the signature as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the signature
+     */
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): OpenIdSignature;
+    static load(deserializer: Deserializer): OpenIdSignature;
+    static isSignature(signature: Signature): signature is OpenIdSignature;
+}
+/**
+ * A signature of a message signed via OIDC that uses proofs or the jwt token to authenticate.
+ */
+declare class KeylessSignature extends Signature {
+    readonly openIdSignatureOrZkProof: OpenIdSignatureOrZkProof;
+    readonly jwtHeader: string;
+    readonly expiryDateSecs: bigint;
+    readonly ephemeralPublicKey: EphemeralPublicKey;
+    readonly ephemeralSignature: EphemeralSignature;
+    /**
+     * Create a new Signature instance from a Uint8Array or String.
+     *
+     * @param hexInput A HexInput (string or Uint8Array)
+     */
+    constructor(args: {
+        jwtHeader: string;
+        openIdSignatureOrZkProof: OpenIdSignatureOrZkProof;
+        expiryDateSecs: bigint;
+        ephemeralPublicKey: EphemeralPublicKey;
+        ephemeralSignature: EphemeralSignature;
+    });
+    /**
+     * Get the signature in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the signature
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the signature as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the signature
+     */
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): KeylessSignature;
+    static load(deserializer: Deserializer): KeylessSignature;
+    static isSignature(signature: Signature): signature is KeylessSignature;
 }
 
 /**
@@ -3440,6 +3723,11 @@ declare class Secp256k1PublicKey extends PublicKey {
      * @param hexInput A HexInput (string or Uint8Array)
      */
     constructor(hexInput: HexInput);
+    /**
+     * Verifies a Secp256k1 signature against the public key
+     *
+     * Note signatures are validated to be canonical as a malleability check
+     */
     verifySignature(args: VerifySignatureArgs): boolean;
     toUint8Array(): Uint8Array;
     serialize(serializer: Serializer): void;
@@ -3497,6 +3785,8 @@ declare class Secp256k1PrivateKey extends Serializable implements PrivateKey {
     /**
      * Sign the given message with the private key.
      *
+     * Note: signatures are canonical, and non-malleable
+     *
      * @param message a message as a string or Uint8Array
      * @returns Signature
      */
@@ -3609,365 +3899,53 @@ declare class AccountAuthenticatorSingleKey extends AccountAuthenticator {
  */
 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);
+    readonly signatures: MultiSignature;
+    constructor(public_keys: MultiKey, signatures: MultiSignature);
     serialize(serializer: Serializer): void;
     static load(deserializer: Deserializer): AccountAuthenticatorMultiKey;
 }
 
-interface SingleKeySignerConstructorArgs {
-    privateKey: PrivateKey;
-    address?: AccountAddressInput;
-}
-interface SingleKeySignerGenerateArgs {
-    scheme?: SigningSchemeInput;
-}
-type SingleKeySignerFromDerivationPathArgs = SingleKeySignerGenerateArgs & {
-    path: string;
-    mnemonic: string;
-};
-interface VerifySingleKeySignatureArgs {
-    message: HexInput;
-    signature: AnySignature;
-}
 /**
- * Signer implementation for the SingleKey authentication scheme.
- * This extends a SingleKeyAccount by adding signing capabilities through a valid private key.
- * Currently, the only supported signature schemes are Ed25519 and Secp256k1.
- *
- * Note: Generating a signer instance does not create the account on-chain.
+ * Type of API endpoint for request routing
  */
-declare class SingleKeyAccount implements Account$1 {
-    /**
-     * Private key associated with the account
-     */
-    readonly privateKey: PrivateKey;
-    readonly publicKey: AnyPublicKey;
-    readonly accountAddress: AccountAddress;
-    readonly signingScheme = SigningScheme.SingleKey;
-    constructor(args: SingleKeySignerConstructorArgs);
-    /**
-     * Derives an account from a randomly generated private key.
-     * Default generation is using an Ed25519 key
-     * @returns Account with the given signature scheme
-     */
-    static generate(args?: SingleKeySignerGenerateArgs): SingleKeyAccount;
-    /**
-     * Derives an account with bip44 path and mnemonics,
-     * Default to using an Ed25519 signature scheme.
-     *
-     * @param args.scheme The signature scheme to derive the private key with
-     * @param args.path the BIP44 derive hardened path (e.g. m/44'/637'/0'/0'/0') for Ed25519,
-     * or non-hardened path (e.g. m/44'/637'/0'/0/0) for secp256k1
-     * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
-     * @param args.mnemonic the mnemonic seed phrase of the account
-     */
-    static fromDerivationPath(args: SingleKeySignerFromDerivationPathArgs): SingleKeyAccount;
-    verifySignature(args: VerifySingleKeySignatureArgs): boolean;
-    signWithAuthenticator(message: HexInput): AccountAuthenticatorSingleKey;
-    sign(message: HexInput): AnySignature;
+declare enum AptosApiType {
+    FULLNODE = "Fullnode",
+    INDEXER = "Indexer",
+    FAUCET = "Faucet",
+    PEPPER = "Pepper",
+    PROVER = "Prover"
 }
-
 /**
- * Arguments for creating an `Ed25519Account` from an `Ed25519PrivateKey`.
- * This is the default input type when passing an `Ed25519PrivateKey`.
- * In order to use the SingleKey authentication scheme, `legacy` needs to be explicitly set to false.
+ * The default max gas amount when none is given.
+ *
+ * This is the maximum number of gas units that will be used by a transaction before being rejected.
+ *
+ * Note that max gas amount varies based on the transaction.  A larger transaction will go over this
+ * default gas amount, and the value will need to be changed for the specific transaction.
  */
-interface CreateEd25519AccountFromPrivateKeyArgs {
-    privateKey: Ed25519PrivateKey;
-    address?: AccountAddressInput;
-    legacy?: true;
-}
+declare const DEFAULT_MAX_GAS_AMOUNT = 200000;
 /**
- * Arguments for creating an `SingleKeyAccount` from an `Ed25519PrivateKey`.
- * The `legacy` argument needs to be explicitly set to false in order to
- * use the `SingleKey` authentication scheme.
+ * The default transaction expiration seconds from now.
+ *
+ * This time is how long until the blockchain nodes will reject the transaction.
+ *
+ * Note that the transaction expiration time varies based on network connection and network load.  It may need to be
+ * increased for the transaction to be processed.
  */
-interface CreateEd25519SingleKeyAccountFromPrivateKeyArgs {
-    privateKey: Ed25519PrivateKey;
-    address?: AccountAddressInput;
-    legacy: false;
-}
+declare const DEFAULT_TXN_EXP_SEC_FROM_NOW = 20;
 /**
- * Arguments for creating an `SingleKeyAccount` from any supported private key
- * that is not an `Ed25519PrivateKey`.
- * The `legacy` argument defaults to false and cannot be explicitly set to true.
+ * The default number of seconds to wait for a transaction to be processed.
+ *
+ * This time is the amount of time that the SDK will wait for a transaction to be processed when waiting for
+ * the results of the transaction.  It may take longer based on network connection and network load.
  */
-interface CreateSingleKeyAccountFromPrivateKeyArgs {
-    privateKey: Exclude<PrivateKey, Ed25519PrivateKey>;
-    address?: AccountAddressInput;
-    legacy?: false;
-}
+declare const DEFAULT_TXN_TIMEOUT_SEC = 20;
 /**
- * Arguments for creating an opaque `Account` from any supported private key.
- * This is used when the private key type is not known at compilation time.
+ * The default gas currency for the network.
  */
-interface CreateAccountFromPrivateKeyArgs {
-    privateKey: PrivateKey;
-    address?: AccountAddressInput;
-    legacy?: boolean;
-}
-/**
- * Arguments for generating an `Ed25519Account`.
- * This is the input type used by default.
- */
-interface GenerateEd25519AccountArgs {
-    scheme?: SigningSchemeInput.Ed25519;
-    legacy?: true;
-}
-/**
- * Arguments for generating an `SingleKeyAccount` with ah underlying `Ed25519PrivateKey`.
- * The `legacy` argument needs to be explicitly set to false,
- * otherwise an `Ed25519Account` will be returned instead.
- */
-interface GenerateEd25519SingleKeyAccountArgs {
-    scheme?: SigningSchemeInput.Ed25519;
-    legacy: false;
-}
-/**
- * Arguments for generating an `SingleKeyAccount` with any supported private key
- * that is not an `Ed25519PrivateKey`.
- * The `legacy` argument defaults to false and cannot be explicitly set to true.
- */
-interface GenerateSingleKeyAccountArgs {
-    scheme: Exclude<SigningSchemeInput, SigningSchemeInput.Ed25519>;
-    legacy?: false;
-}
-/**
- * Arguments for generating an opaque `Account`.
- * This is used when the input signature scheme is not known at compilation time.
- */
-interface GenerateAccountArgs {
-    scheme?: SigningSchemeInput;
-    legacy?: boolean;
-}
-/**
- * Arguments for deriving a private key from a mnemonic phrase and a BIP44 path.
- */
-interface PrivateKeyFromDerivationPathArgs {
-    path: string;
-    mnemonic: string;
-}
-/**
- * Interface for a generic Aptos account.
- *
- * The interface is defined as abstract class to provide a single entrypoint for account generation,
- * either through `Account.generate()` or `Account.fromDerivationPath`.
- * Despite this being an abstract class, it should be treated as an interface and enforced using
- * the `implements` keyword.
- *
- * Note: Generating an account instance does not create the account on-chain.
- */
-declare abstract class Account$1 {
-    /**
-     * Private key associated with the account.
-     * Note: this will be removed in the next major release,
-     *  as not all accounts have a private key.
-     */
-    abstract readonly privateKey: PrivateKey;
-    /**
-     * Public key associated with the account
-     */
-    abstract readonly publicKey: AccountPublicKey;
-    /**
-     * Account address associated with the account
-     */
-    abstract readonly accountAddress: AccountAddress;
-    /**
-     * Signing scheme used to sign transactions
-     */
-    abstract signingScheme: SigningScheme;
-    /**
-     * Derives an account from a randomly generated private key.
-     * @param args.scheme The signature scheme to use, to generate the private key
-     * @param args.legacy Whether to use a legacy authentication scheme, when applicable
-     * @returns An account compatible with the provided signature scheme
-     */
-    static generate(args?: GenerateEd25519AccountArgs): Ed25519Account;
-    static generate(args: GenerateEd25519SingleKeyAccountArgs): SingleKeyAccount;
-    static generate(args: GenerateSingleKeyAccountArgs): SingleKeyAccount;
-    static generate(args: GenerateAccountArgs): Account$1;
-    /**
-     * Creates an account from the provided private key.
-     *
-     * @param args.privateKey a valid private key
-     * @param args.address the account's address. If not provided, it will be derived from the public key.
-     * @param args.legacy Whether to use a legacy authentication scheme, when applicable
-     */
-    static fromPrivateKey(args: CreateEd25519AccountFromPrivateKeyArgs): Ed25519Account;
-    static fromPrivateKey(args: CreateEd25519SingleKeyAccountFromPrivateKeyArgs): SingleKeyAccount;
-    static fromPrivateKey(args: CreateSingleKeyAccountFromPrivateKeyArgs): SingleKeyAccount;
-    static fromPrivateKey(args: CreateAccountFromPrivateKeyArgs): Account$1;
-    /**
-     * @deprecated use `fromPrivateKey` instead.
-     * 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 args.privateKey PrivateKey - the underlying private key for the account
-     * @param args.address AccountAddress - The account address the `Account` will sign for
-     * @param args.legacy optional. If set to false, the keypair generated is a Unified keypair. Defaults
-     * to generating a Legacy Ed25519 keypair
-     *
-     * @returns Account
-     */
-    static fromPrivateKeyAndAddress(args: CreateAccountFromPrivateKeyArgs): Account$1;
-    /**
-     * Derives an account with bip44 path and mnemonics
-     *
-     * @param args.scheme The signature scheme to derive the private key with
-     * @param args.path the BIP44 derive hardened path (e.g. m/44'/637'/0'/0'/0') for Ed25519,
-     * or non-hardened path (e.g. m/44'/637'/0'/0/0) for secp256k1
-     * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
-     * @param args.mnemonic the mnemonic seed phrase of the account
-     */
-    static fromDerivationPath(args: GenerateEd25519AccountArgs & PrivateKeyFromDerivationPathArgs): Ed25519Account;
-    static fromDerivationPath(args: GenerateEd25519SingleKeyAccountArgs & PrivateKeyFromDerivationPathArgs): SingleKeyAccount;
-    static fromDerivationPath(args: GenerateSingleKeyAccountArgs & PrivateKeyFromDerivationPathArgs): SingleKeyAccount;
-    static fromDerivationPath(args: GenerateAccountArgs & PrivateKeyFromDerivationPathArgs): Account$1;
-    /**
-     * @deprecated use `publicKey.authKey()` instead.
-     * This key enables account owners to rotate their private key(s)
-     * associated with the account without changing the address that hosts their account.
-     * See here for more info: {@link https://aptos.dev/concepts/accounts#single-signer-authentication}
-     *
-     * @param args.publicKey PublicKey - public key of the account
-     * @returns The authentication key for the associated account
-     */
-    static authKey(args: {
-        publicKey: AccountPublicKey;
-    }): AuthenticationKey;
-    /**
-     * Sign a message using the available signing capabilities.
-     * @param message the signing message, as binary input
-     * @return the AccountAuthenticator containing the signature, together with the account's public key
-     */
-    abstract signWithAuthenticator(message: HexInput): AccountAuthenticator;
-    /**
-     * Sign the given message with the private key.
-     * @param message in HexInput format
-     * @returns AccountSignature
-     */
-    abstract sign(message: HexInput): Signature;
-    /**
-     * @param args.message raw message data in HexInput format
-     * @param args.signature signed message signature
-     */
-    verifySignature(args: VerifySignatureArgs): boolean;
-}
-
-interface Ed25519SignerConstructorArgs {
-    privateKey: Ed25519PrivateKey;
-    address?: AccountAddressInput;
-}
-interface Ed25519SignerFromDerivationPathArgs {
-    path: string;
-    mnemonic: string;
-}
-interface VerifyEd25519SignatureArgs {
-    message: HexInput;
-    signature: Ed25519Signature;
-}
-/**
- * Signer implementation for the Ed25519 authentication scheme.
- * This extends an {@link Ed25519Account} by adding signing capabilities through an {@link Ed25519PrivateKey}.
- *
- * Note: Generating a signer instance does not create the account on-chain.
- */
-declare class Ed25519Account implements Account$1 {
-    /**
-     * Private key associated with the account
-     */
-    readonly privateKey: Ed25519PrivateKey;
-    readonly publicKey: Ed25519PublicKey;
-    readonly accountAddress: AccountAddress;
-    readonly signingScheme = SigningScheme.Ed25519;
-    constructor(args: Ed25519SignerConstructorArgs);
-    /**
-     * Derives a signer from a randomly generated private key
-     */
-    static generate(): Ed25519Account;
-    /**
-     * Derives an account with bip44 path and mnemonics
-     *
-     * @param args.path the BIP44 derive hardened path e.g. m/44'/637'/0'/0'/0'
-     * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
-     * @param args.mnemonic the mnemonic seed phrase of the account
-     */
-    static fromDerivationPath(args: Ed25519SignerFromDerivationPathArgs): Ed25519Account;
-    verifySignature(args: VerifyEd25519SignatureArgs): boolean;
-    signWithAuthenticator(message: HexInput): AccountAuthenticatorEd25519;
-    sign(message: HexInput): Ed25519Signature;
-}
-
-/**
- * Creates an object address from creator address and seed
- *
- * @param creatorAddress The object creator account address
- * @param seed The seed in either Uint8Array | string type
- *
- * @returns The object account address
- */
-declare const createObjectAddress: (creatorAddress: AccountAddress, seed: Uint8Array | string) => AccountAddress;
-/**
- * Creates an resource address from creator address and seed
- *
- * @param creatorAddress The creator account address
- * @param seed The seed in either Uint8Array | string type
- *
- * @returns The resource account address
- */
-declare const createResourceAddress: (creatorAddress: AccountAddress, seed: Uint8Array | string) => AccountAddress;
-/**
- * Creates a token object address from creator address, collection name and token name
- *
- * @param creatorAddress The token creator account address
- * @param collectionName The collection name
- * @param tokenName The token name
- *
- * @returns The token account address
- */
-declare const createTokenAddress: (creatorAddress: AccountAddress, collectionName: string, tokenName: string) => AccountAddress;
-
-/**
- * Type of API endpoint for request routing
- */
-declare enum AptosApiType {
-    FULLNODE = "Fullnode",
-    INDEXER = "Indexer",
-    FAUCET = "Faucet"
-}
-/**
- * The default max gas amount when none is given.
- *
- * This is the maximum number of gas units that will be used by a transaction before being rejected.
- *
- * Note that max gas amount varies based on the transaction.  A larger transaction will go over this
- * default gas amount, and the value will need to be changed for the specific transaction.
- */
-declare const DEFAULT_MAX_GAS_AMOUNT = 200000;
-/**
- * The default transaction expiration seconds from now.
- *
- * This time is how long until the blockchain nodes will reject the transaction.
- *
- * Note that the transaction expiration time varies based on network connection and network load.  It may need to be
- * increased for the transaction to be processed.
- */
-declare const DEFAULT_TXN_EXP_SEC_FROM_NOW = 20;
-/**
- * The default number of seconds to wait for a transaction to be processed.
- *
- * This time is the amount of time that the SDK will wait for a transaction to be processed when waiting for
- * the results of the transaction.  It may take longer based on network connection and network load.
- */
-declare const DEFAULT_TXN_TIMEOUT_SEC = 20;
-/**
- * The default gas currency for the network.
- */
-declare const APTOS_COIN = "0x1::aptos_coin::AptosCoin";
-declare const RAW_TRANSACTION_SALT = "APTOS::RawTransaction";
-declare const RAW_TRANSACTION_WITH_DATA_SALT = "APTOS::RawTransactionWithData";
+declare const APTOS_COIN = "0x1::aptos_coin::AptosCoin";
+declare const RAW_TRANSACTION_SALT = "RawTransaction";
+declare const RAW_TRANSACTION_WITH_DATA_SALT = "RawTransactionWithData";
 /**
  * The list of supported Processor types for our indexer api.
  *
@@ -3986,6 +3964,10 @@ declare enum ProcessorType {
 
 /**
  * This class holds the config information for the SDK client instance.
+ *
+ * @example
+ *
+ * const aptosConfig = new AptosConfig({network:Network.TESTNET})
  */
 declare class AptosConfig {
     /**
@@ -4004,6 +3986,14 @@ declare class AptosConfig {
      * The optional hardcoded faucet URL to send requests to instead of using the network
      */
     readonly faucet?: string;
+    /**
+     * The optional hardcoded pepper service URL to send requests to instead of using the network
+     */
+    readonly pepper?: string;
+    /**
+     * The optional hardcoded prover service URL to send requests to instead of using the network
+     */
+    readonly prover?: string;
     /**
      * The optional hardcoded indexer URL to send requests to instead of using the network
      */
@@ -4036,1115 +4026,1582 @@ declare class AptosConfig {
      * @internal
      */
     getRequestUrl(apiType: AptosApiType): string;
+    /**
+     * Checks if the URL is a known pepper service endpoint
+     *
+     * @internal
+     * */
+    isPepperServiceRequest(url: string): boolean;
+    /**
+     * Checks if the URL is a known prover service endpoint
+     *
+     * @internal
+     * */
+    isProverServiceRequest(url: string): boolean;
 }
 
 /**
- * A class to query all `Account` related queries on Aptos.
+ * Representation of a ChainId that can serialized and deserialized
  */
-declare class Account {
-    readonly config: AptosConfig;
-    constructor(config: AptosConfig);
-    /**
-     * Queries the current state for an Aptos account given its account address
-     *
-     * @param args.accountAddress Aptos account address
-     *
-     * @returns The account data
-     *
-     * @example An example of the returned account
-     * ```
-     * {
-     *    sequence_number: "1",
-     *    authentication_key: "0x5307b5f4bc67829097a8ba9b43dba3b88261eeccd1f709d9bde240fc100fbb69"
-     * }
+declare class ChainId extends Serializable {
+    readonly chainId: number;
+    constructor(chainId: number);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): ChainId;
+}
+
+/**
+ * Representation of an Identifier that can serialized and deserialized.
+ * We use Identifier to represent the module "name" in "ModuleId" and
+ * the "function name" in "EntryFunction"
+ */
+declare class Identifier extends Serializable {
+    identifier: string;
+    constructor(identifier: string);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): Identifier;
+}
+
+/**
+ * Representation of a ModuleId that can serialized and deserialized
+ * ModuleId means the module address (e.g "0x1") and the module name (e.g "coin")
+ */
+declare class ModuleId extends Serializable {
+    readonly address: AccountAddress;
+    readonly name: Identifier;
+    /**
+     * Full name of a module.
+     * @param address The account address. e.g "0x1"
+     * @param name The module name under the "address". e.g "coin"
+     */
+    constructor(address: AccountAddress, name: Identifier);
+    /**
+     * Converts a string literal to a ModuleId
+     * @param moduleId String literal in format "account_address::module_name", e.g. "0x1::coin"
+     * @returns ModuleId
+     */
+    static fromStr(moduleId: MoveModuleId): ModuleId;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): ModuleId;
+}
+
+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);
+    static u8(): TypeTagVector;
+    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;
+    isTypeTag(address: AccountAddress, moduleName: string, structName: string): boolean;
+    isString(): boolean;
+    isOption(): boolean;
+    isObject(): boolean;
+}
+declare class StructTag extends Serializable {
+    readonly address: AccountAddress;
+    readonly moduleName: Identifier;
+    readonly name: Identifier;
+    readonly typeArgs: Array<TypeTag>;
+    constructor(address: AccountAddress, module_name: Identifier, name: Identifier, type_args: Array<TypeTag>);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): StructTag;
+}
+declare function aptosCoinStructTag(): StructTag;
+declare function stringStructTag(): StructTag;
+declare function optionStructTag(typeArg: TypeTag): StructTag;
+declare function objectStructTag(typeArg: TypeTag): StructTag;
+
+/**
+ * Deserialize a Script Transaction Argument
+ */
+declare function deserializeFromScriptArgument(deserializer: Deserializer): TransactionArgument;
+/**
+ * Representation of the supported Transaction Payload
+ * that can serialized and deserialized
+ */
+declare abstract class TransactionPayload extends Serializable {
+    /**
+     * Serialize a Transaction Payload
+     */
+    abstract serialize(serializer: Serializer): void;
+    /**
+     * Deserialize a Transaction Payload
+     */
+    static deserialize(deserializer: Deserializer): TransactionPayload;
+}
+/**
+ * Representation of a Transaction Payload Script that can serialized and deserialized
+ */
+declare class TransactionPayloadScript extends TransactionPayload {
+    readonly script: Script;
+    constructor(script: Script);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TransactionPayloadScript;
+}
+/**
+ * Representation of a Transaction Payload Entry Function that can serialized and deserialized
+ */
+declare class TransactionPayloadEntryFunction extends TransactionPayload {
+    readonly entryFunction: EntryFunction;
+    constructor(entryFunction: EntryFunction);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TransactionPayloadEntryFunction;
+}
+/**
+ * Representation of a Transaction Payload Multi-sig that can serialized and deserialized
+ */
+declare class TransactionPayloadMultiSig extends TransactionPayload {
+    readonly multiSig: MultiSig;
+    constructor(multiSig: MultiSig);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TransactionPayloadMultiSig;
+}
+/**
+ * Representation of a EntryFunction that can serialized and deserialized
+ */
+declare class EntryFunction {
+    readonly module_name: ModuleId;
+    readonly function_name: Identifier;
+    readonly type_args: Array<TypeTag>;
+    readonly args: Array<EntryFunctionArgument>;
+    /**
+     * Contains the payload to run a function within a module.
+     * @param module_name Fully qualified module name in format "account_address::module_name" e.g. "0x1::coin"
+     * @param function_name The function name. e.g "transfer"
+     * @param type_args Type arguments that move function requires.
+     *
+     * @example
+     * A coin transfer function has one type argument "CoinType".
+     * ```
+     * public entry fun transfer<CoinType>(from: &signer, to: address, amount: u64)
+     * ```
+     * @param args arguments to the move function.
+     *
+     * @example
+     * A coin transfer function has three arguments "from", "to" and "amount".
+     * ```
+     * public entry fun transfer<CoinType>(from: &signer, to: address, amount: u64)
      * ```
      */
-    getAccountInfo(args: {
-        accountAddress: AccountAddressInput;
-    }): Promise<AccountData>;
+    constructor(module_name: ModuleId, function_name: Identifier, type_args: Array<TypeTag>, args: Array<EntryFunctionArgument>);
     /**
-     * Queries for all modules in an account given an account address
+     * A helper function to build a EntryFunction payload from raw primitive values
      *
-     * Note: In order to get all account modules, this function may call the API
-     * multiple times as it auto paginates.
+     * @param module_id Fully qualified module name in format "AccountAddress::module_id" e.g. "0x1::coin"
+     * @param function_name Function name
+     * @param type_args Type arguments that move function requires.
      *
-     * @param args.accountAddress Aptos account address
-     * @param args.options.offset The number module to start returning results from
-     * @param args.options.limit The number of results to return
-     * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
+     * @example
+     * A coin transfer function has one type argument "CoinType".
+     * ```
+     * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
+     * ```
+     * @param args Arguments to the move function.
      *
-     * @returns Account modules
+     * @example
+     * A coin transfer function has three arguments "from", "to" and "amount".
+     * ```
+     * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
+     * ```
+     * @returns EntryFunction
      */
-    getAccountModules(args: {
-        accountAddress: AccountAddressInput;
-        options?: PaginationArgs & LedgerVersionArg;
-    }): Promise<MoveModuleBytecode[]>;
+    static build(module_id: MoveModuleId, function_name: string, type_args: Array<TypeTag>, args: Array<EntryFunctionArgument>): EntryFunction;
+    serialize(serializer: Serializer): void;
     /**
-     * Queries for a specific account module given account address and module name
+     * Deserializes an entry function payload with the arguments represented as EntryFunctionBytes instances.
+     * @see EntryFunctionBytes
      *
-     * @param args.accountAddress Aptos account address
-     * @param args.moduleName The name of the module
-     * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
+     * NOTE: When you deserialize an EntryFunction payload with this method, the entry function
+     * arguments are populated into the deserialized instance as type-agnostic, raw fixed bytes
+     * in the form of the EntryFunctionBytes class.
      *
-     * @returns Account module
+     * In order to correctly deserialize these arguments as their actual type representations, you
+     * must know the types of the arguments beforehand and deserialize them yourself individually.
+     *
+     * One way you could achieve this is by using the ABIs for an entry function and deserializing each
+     * argument as its given, corresponding type.
+     *
+     * @param deserializer
+     * @returns A deserialized EntryFunction payload for a transaction.
+     *
+     */
+    static deserialize(deserializer: Deserializer): EntryFunction;
+}
+/**
+ * Representation of a Script that can serialized and deserialized
+ */
+declare class Script {
+    /**
+     * The move module bytecode
+     */
+    readonly bytecode: Uint8Array;
+    /**
+     * The type arguments that the bytecode function requires.
+     */
+    readonly type_args: Array<TypeTag>;
+    /**
+     * The arguments that the bytecode function requires.
+     */
+    readonly args: Array<ScriptFunctionArgument>;
+    /**
+     * Scripts contain the Move bytecodes payload that can be submitted to Aptos chain for execution.
      *
-     * @example An example of an account module
+     * @param bytecode The move module bytecode
+     * @param type_args The type arguments that the bytecode function requires.
+     *
+     * @example
+     * A coin transfer function has one type argument "CoinType".
      * ```
-     * {
-     *    bytecode: "0xa11ceb0b0600000006010002030206050807070f0d081c200",
-     *    abi: { address: "0x1" }
-     * }
+     * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
+     * ```
+     * @param args The arguments that the bytecode function requires.
+     *
+     * @example
+     * A coin transfer function has three arguments "from", "to" and "amount".
+     * ```
+     * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
      * ```
      */
-    getAccountModule(args: {
-        accountAddress: AccountAddressInput;
-        moduleName: string;
-        options?: LedgerVersionArg;
-    }): Promise<MoveModuleBytecode>;
+    constructor(bytecode: Uint8Array, type_args: Array<TypeTag>, args: Array<ScriptFunctionArgument>);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): Script;
+}
+/**
+ * Representation of a MultiSig that can serialized and deserialized
+ */
+declare class MultiSig {
+    readonly multisig_address: AccountAddress;
+    readonly transaction_payload?: MultiSigTransactionPayload;
+    /**
+     * Contains the payload to run a multi-sig account transaction.
+     *
+     * @param multisig_address The multi-sig account address the transaction will be executed as.
+     *
+     * @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);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): MultiSig;
+}
+/**
+ * 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 extends Serializable {
+    readonly transaction_payload: EntryFunction;
+    /**
+     * Contains the payload to run a multi-sig account transaction.
+     *
+     * @param transaction_payload The payload of the multi-sig transaction.
+     * This can only be EntryFunction for now but,
+     * Script might be supported in the future.
+     */
+    constructor(transaction_payload: EntryFunction);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): MultiSigTransactionPayload;
+}
+
+/**
+ * Representation of a Raw Transaction that can serialized and deserialized
+ */
+declare class RawTransaction extends Serializable {
+    readonly sender: AccountAddress;
+    readonly sequence_number: bigint;
+    readonly payload: TransactionPayload;
+    readonly max_gas_amount: bigint;
+    readonly gas_unit_price: bigint;
+    readonly expiration_timestamp_secs: bigint;
+    readonly chain_id: ChainId;
     /**
-     * Queries account transactions given an account address
-     *
-     * Note: In order to get all account transactions, this function may call the API
-     * multiple times as it auto paginates.
-     *
-     * @param args.accountAddress Aptos account address
-     * @param args.options.offset The number transaction to start returning results from
-     * @param args.options.limit The number of results to return
+     * RawTransactions contain the metadata and payloads that can be submitted to Aptos chain for execution.
+     * RawTransactions must be signed before Aptos chain can execute them.
      *
-     * @returns The account transactions
+     * @param sender The sender Account Address
+     * @param sequence_number Sequence number of this transaction. This must match the sequence number stored in
+     *   the sender's account at the time the transaction executes.
+     * @param payload Instructions for the Aptos Blockchain, including publishing a module,
+     *   execute an entry function or execute a script payload.
+     * @param max_gas_amount Maximum total gas to spend for this transaction. The account must have more
+     *   than this gas or the transaction will be discarded during validation.
+     * @param gas_unit_price Price to be paid per gas unit.
+     * @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.
      */
-    getAccountTransactions(args: {
-        accountAddress: AccountAddressInput;
-        options?: PaginationArgs;
-    }): Promise<TransactionResponse[]>;
+    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;
+}
+/**
+ * Representation of a Raw Transaction With Data that can serialized and deserialized
+ */
+declare abstract class RawTransactionWithData extends Serializable {
     /**
-     * Queries all account resources given an account address
-     *
-     * Note: In order to get all account resources, this function may call the API
-     * multiple times as it auto paginates.
-     *
-     * @param args.accountAddress Aptos account address
-     * @param args.options.offset The number resource to start returning results from
-     * @param args.options.limit The number of results to return
-     * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
-     * @returns Account resources
+     * Serialize a Raw Transaction With Data
      */
-    getAccountResources(args: {
-        accountAddress: AccountAddressInput;
-        options?: PaginationArgs & LedgerVersionArg;
-    }): Promise<MoveResource[]>;
+    abstract serialize(serializer: Serializer): void;
     /**
-     * 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
-     *
-     * @returns Account resource
-     *
-     * @example An example of an account resource
-     * ```
-     * {
-     *    value: 6
-     * }
-     * ```
+     * Deserialize a Raw Transaction With Data
      */
-    getAccountResource<T extends {} = any>(args: {
-        accountAddress: AccountAddressInput;
-        resourceType: MoveStructId;
-        options?: LedgerVersionArg;
-    }): Promise<T>;
+    static deserialize(deserializer: Deserializer): RawTransactionWithData;
+}
+/**
+ * Representation of a Multi Agent Transaction that can serialized and deserialized
+ */
+declare class MultiAgentRawTransaction extends RawTransactionWithData {
     /**
-     * Looks up the account address for a given authentication key
-     *
-     * This handles both if the account's authentication key has been rotated or not.
-     *
-     * @param args.authenticationKey The authentication key
-     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-     * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
-     * @returns Promise<AccountAddress> The accountAddress associated with the authentication key
+     * The raw transaction
      */
-    lookupOriginalAccountAddress(args: {
-        authenticationKey: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: LedgerVersionArg;
-    }): Promise<AccountAddress>;
+    readonly raw_txn: RawTransaction;
     /**
-     * Queries the current count of tokens owned by an account
-     *
-     * @param args.accountAddress The account address
-     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-     * @returns Current count of tokens owned by the account
+     * The secondary signers on this transaction
      */
-    getAccountTokensCount(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
+    readonly secondary_signer_addresses: Array<AccountAddress>;
+    constructor(raw_txn: RawTransaction, secondary_signer_addresses: Array<AccountAddress>);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): MultiAgentRawTransaction;
+}
+/**
+ * Representation of a Fee Payer Transaction that can serialized and deserialized
+ */
+declare class FeePayerRawTransaction extends RawTransactionWithData {
     /**
-     * Queries the account's current owned tokens.
-     *
-     * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.
-     * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param
-     *
-     * @param args.accountAddress The account address we want to get the tokens for
-     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-     * @param args.options.tokenStandard The NFT standard to query for
-     * @param args.options.offset The number token to start returning results from
-     * @param args.options.limit The number of results to return
-     * @param args.options.orderBy The order to sort the tokens by
-     * @returns Tokens array with the token data
+     * The raw transaction
      */
-    getAccountOwnedTokens(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensQueryResponse[0]>;
-    }): Promise<GetAccountOwnedTokensQueryResponse>;
+    readonly raw_txn: RawTransaction;
     /**
-     * Queries all current tokens of a specific collection that an account owns by the collection address
-     *
-     * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.
-     * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param
-     *
-     * @param args.accountAddress The account address we want to get the tokens for
-     * @param args.collectionAddress The address of the collection being queried
-     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-     * @param args.options.tokenStandard The NFT standard to query for
-     * @param args.options.offset The number token to start returning results from
-     * @param args.options.limit The number of results to return
-     * @param args.options.orderBy The order to sort the tokens by
-     * @returns Tokens array with the token data
+     * The secondary signers on this transaction - optional and can be empty
      */
-    getAccountOwnedTokensFromCollectionAddress(args: {
-        accountAddress: AccountAddressInput;
-        collectionAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensFromCollectionResponse[0]>;
-    }): Promise<GetAccountOwnedTokensFromCollectionResponse>;
+    readonly secondary_signer_addresses: Array<AccountAddress>;
+    /**
+     * The fee payer account address
+     */
+    readonly fee_payer_address: AccountAddress;
+    constructor(raw_txn: RawTransaction, secondary_signer_addresses: Array<AccountAddress>, fee_payer_address: AccountAddress);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): FeePayerRawTransaction;
+}
+
+/**
+ * Representation of the challenge which is needed to sign by owner of the account
+ * to rotate the authentication key.
+ */
+declare class RotationProofChallenge extends Serializable {
+    readonly accountAddress: AccountAddress;
+    readonly moduleName: MoveString;
+    readonly structName: MoveString;
+    readonly originator: AccountAddress;
+    readonly currentAuthKey: AccountAddress;
+    readonly newPublicKey: MoveVector<U8>;
+    readonly sequenceNumber: U64;
+    constructor(args: {
+        sequenceNumber: AnyNumber;
+        originator: AccountAddress;
+        currentAuthKey: AccountAddress;
+        newPublicKey: PublicKey;
+    });
+    serialize(serializer: Serializer): void;
+}
+
+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;
     /**
-     * Queries for all collections that an account currently has tokens for.
+     * 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.
      *
-     * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.
-     * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param
+     * @see {@link https://aptos.dev/integration/creating-a-signed-transaction | Creating a Signed Transaction}
      *
-     * @param args.accountAddress The account address we want to get the collections for
-     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-     * @param args.options.tokenStandard The NFT standard to query for
-     * @param args.options.offset The number collection to start returning results from
-     * @param args.options.limit The number of results to return
-     * @param args.options.orderBy The order to sort the tokens by
-     * @returns Collections array with the collections data
+     * @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.
      */
-    getAccountCollectionsWithOwnedTokens(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountCollectionsWithOwnedTokenResponse[0]>;
-    }): Promise<GetAccountCollectionsWithOwnedTokenResponse>;
+    constructor(raw_txn: RawTransaction, authenticator: TransactionAuthenticator);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): SignedTransaction;
+}
+
+/**
+ * Representation of a SimpleTransaction that can serialized and deserialized
+ */
+declare class SimpleTransaction extends Serializable {
+    rawTransaction: RawTransaction;
+    feePayerAddress?: AccountAddress | undefined;
+    readonly secondarySignerAddresses: undefined;
     /**
-     * Queries the current count of transactions submitted by an account
+     * SimpleTransaction represents a simple transaction type of a single signer that
+     * can be submitted to Aptos chain for execution.
      *
-     * @param args.accountAddress The account address we want to get the total count for
-     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-     * @returns Current count of transactions made by an account
-     */
-    getAccountTransactionsCount(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
-    /**
-     * Queries an account's coins data
+     * SimpleTransaction metadata contains the Raw Transaction and an optional
+     * sponsor Account Address to pay the gas fees.
      *
-     * @param args.accountAddress The account address we want to get the coins data for
-     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-     * @param args.options.offset optional. The number coin to start returning results from
-     * @param args.options.limit optional. The number of results to return
-     * @param args.options.orderBy optional. The order to sort the coins by
-     * @param args.options.where optional. Filter the results by
-     * @returns Array with the coins data
+     * @param rawTransaction The Raw Tranasaction
+     * @param feePayerAddress The sponsor Account Address
      */
-    getAccountCoinsData(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: PaginationArgs & OrderByArg<GetAccountCoinsDataResponse[0]> & WhereArg<CurrentFungibleAssetBalancesBoolExp>;
-    }): Promise<GetAccountCoinsDataResponse>;
+    constructor(rawTransaction: RawTransaction, feePayerAddress?: AccountAddress);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): SimpleTransaction;
+}
+
+/**
+ * Representation of a Raw Transaction that can serialized and deserialized
+ */
+declare class MultiAgentTransaction extends Serializable {
+    rawTransaction: RawTransaction;
+    feePayerAddress?: AccountAddress | undefined;
+    secondarySignerAddresses: AccountAddress[];
     /**
-     * Queries the current count of an account's coins aggregated
+     * SimpleTransaction represents a simple transaction type of a single signer that
+     * can be submitted to Aptos chain for execution.
      *
-     * @param args.accountAddress The account address we want to get the total count for
-     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-     * @returns Current count of the aggregated count of all account's coins
+     * SimpleTransaction metadata contains the Raw Transaction and an optional
+     * sponsor Account Address to pay the gas fees.
+     *
+     * @param rawTransaction The Raw Tranasaction
+     * @param feePayerAddress The sponsor Account Address
      */
-    getAccountCoinsCount(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
+    constructor(rawTransaction: RawTransaction, secondarySignerAddresses: AccountAddress[], feePayerAddress?: AccountAddress);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): MultiAgentTransaction;
+}
+
+/**
+ * Entry function arguments to be used when building a raw transaction using remote ABI
+ */
+type SimpleEntryFunctionArgumentTypes = boolean | number | bigint | string | null | undefined | Uint8Array | ArrayBuffer | Array<SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes>;
+/**
+ * Entry function arguments to be used when building a raw transaction using BCS serialized arguments
+ */
+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
+ */
+type ScriptFunctionArgumentTypes = Bool | U8 | U16 | U32 | U64 | U128 | U256 | AccountAddress | MoveVector<U8> | MoveString | FixedBytes;
+/**
+ * Type that holds all raw transaction instances Aptos SDK supports
+ */
+type AnyRawTransactionInstance = RawTransaction | MultiAgentRawTransaction | FeePayerRawTransaction;
+/**
+ * Optional options to set when generating a transaction
+ */
+type InputGenerateTransactionOptions = {
+    maxGasAmount?: number;
+    gasUnitPrice?: number;
+    expireTimestamp?: number;
+    accountSequenceNumber?: AnyNumber;
+};
+/**
+ * The generated transaction payload type that was produces from `generateTransactionPayload()` function.
+ */
+type AnyTransactionPayloadInstance = TransactionPayloadEntryFunction | TransactionPayloadScript | TransactionPayloadMultiSig;
+/**
+ * Unified type for the data needed to generate a transaction payload of types:
+ * Entry Function | Script | Multi Sig
+ */
+type InputGenerateTransactionPayloadData = InputEntryFunctionData | InputScriptData | InputMultiSigData;
+type InputGenerateTransactionPayloadDataWithRemoteABI = InputScriptData | InputEntryFunctionDataWithRemoteABI | InputMultiSigDataWithRemoteABI;
+/**
+ * The data needed to generate an Entry Function payload
+ */
+type InputEntryFunctionData = {
+    function: MoveFunctionId;
+    typeArguments?: Array<TypeTag | string>;
+    functionArguments: Array<EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes>;
+    abi?: EntryFunctionABI;
+};
+type InputGenerateTransactionPayloadDataWithABI = InputEntryFunctionDataWithABI | InputMultiSigDataWithABI;
+type InputEntryFunctionDataWithABI = Omit<InputEntryFunctionData, "abi"> & {
+    abi: EntryFunctionABI;
+};
+type InputMultiSigDataWithABI = {
+    multisigAddress: AccountAddressInput;
+} & InputEntryFunctionDataWithABI;
+type InputEntryFunctionDataWithRemoteABI = InputEntryFunctionData & {
+    aptosConfig: AptosConfig;
+};
+/**
+ * The data needed to generate a Multi Sig payload
+ */
+type InputMultiSigData = {
+    multisigAddress: AccountAddressInput;
+} & InputEntryFunctionData;
+/**
+ * The data needed to generate a Multi Sig payload
+ */
+type InputMultiSigDataWithRemoteABI = {
+    multisigAddress: AccountAddressInput;
+} & InputEntryFunctionDataWithRemoteABI;
+/**
+ * The data needed to generate a Script payload
+ */
+type InputScriptData = {
+    bytecode: HexInput;
+    typeArguments?: Array<TypeTag>;
+    functionArguments: Array<ScriptFunctionArgumentTypes>;
+};
+/**
+ * The data needed to generate a View Function payload
+ */
+type InputViewFunctionData = {
+    function: MoveFunctionId;
+    typeArguments?: Array<TypeTag | string>;
+    functionArguments?: Array<EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes>;
+    abi?: ViewFunctionABI;
+};
+/**
+ * Data needed to generate a view function payload and fetch the remote ABI
+ */
+type InputViewFunctionDataWithRemoteABI = InputViewFunctionData & {
+    aptosConfig: AptosConfig;
+};
+/**
+ * Data needed to generate a view function, with an already fetched ABI
+ */
+type InputViewFunctionDataWithABI = InputViewFunctionData & {
+    abi: ViewFunctionABI;
+};
+/**
+ * Data need for a generic function ABI, both view and entry
+ */
+type FunctionABI = {
+    typeParameters: Array<MoveFunctionGenericTypeParam>;
+    parameters: Array<TypeTag>;
+};
+/**
+ * Interface of an Entry function's ABI.
+ *
+ * This is used to provide type checking and simple input conversion on ABI based transaction submission.
+ */
+type EntryFunctionABI = FunctionABI & {
+    signers?: number;
+};
+/**
+ * Interface of an View function's ABI.
+ *
+ * This is used to provide type checking and simple input conversion on ABI based transaction submission.
+ */
+type ViewFunctionABI = FunctionABI & {
+    returnTypes: Array<TypeTag>;
+};
+/**
+ * Interface of the arguments to generate a single signer transaction.
+ * Used to provide to `generateTransaction()` method in the transaction builder flow
+ */
+interface InputGenerateSingleSignerRawTransactionArgs {
+    aptosConfig: AptosConfig;
+    sender: AccountAddressInput;
+    payload: AnyTransactionPayloadInstance;
+    options?: InputGenerateTransactionOptions;
+    feePayerAddress?: AccountAddressInput;
+}
+/**
+ * Interface of the arguments to generate a multi-agent transaction.
+ * Used to provide to `generateTransaction()` method in the transaction builder flow
+ */
+interface InputGenerateMultiAgentRawTransactionArgs {
+    aptosConfig: AptosConfig;
+    sender: AccountAddressInput;
+    payload: AnyTransactionPayloadInstance;
+    secondarySignerAddresses: AccountAddressInput[];
+    options?: InputGenerateTransactionOptions;
+    feePayerAddress?: AccountAddressInput;
+}
+/**
+ * Unified type that holds all the interfaces to generate different transaction types
+ */
+type InputGenerateRawTransactionArgs = InputGenerateSingleSignerRawTransactionArgs | InputGenerateMultiAgentRawTransactionArgs;
+/**
+ * Unified type that holds all the return interfaces when generating different transaction types
+ */
+type AnyRawTransaction = SimpleTransaction | MultiAgentTransaction;
+type InputSimulateTransactionData = {
     /**
-     * Queries the account's APT amount
-     *
-     * @param args.accountAddress The account address we want to get the total count for
-     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-     * @returns Current amount of account's APT
+     * The transaction to simulate, probably generated by `generateTransaction()`
      */
-    getAccountAPTAmount(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
+    transaction: AnyRawTransaction;
     /**
-     * Queries the account's coin amount by the coin type
-     *
-     * @param args.accountAddress The account address we want to get the total count for
-     * @param args.coinType The coin type to query
-     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-     * @returns Current amount of account's coin
+     * For a single signer transaction
      */
-    getAccountCoinAmount(args: {
-        accountAddress: AccountAddressInput;
-        coinType: MoveStructId;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
+    signerPublicKey: PublicKey;
     /**
-     * Queries an account's owned objects
-     *
-     * @param args.accountAddress The account address we want to get the objects for
-     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
-     * @param args.options.offset The starting position to start returning results from
-     * @param args.options.limit The number of results to return
-     * @param args.options.orderBy The order to sort the objects by
-     * @returns Objects array with the object data
+     * For a fee payer or multi-agent transaction that requires additional signers in
      */
-    getAccountOwnedObjects(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: PaginationArgs & OrderByArg<GetAccountOwnedObjectsResponse[0]>;
-    }): Promise<GetAccountOwnedObjectsResponse>;
+    secondarySignersPublicKeys?: Array<PublicKey>;
     /**
-     * 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
+     * For a fee payer transaction (aka Sponsored Transaction)
      */
-    deriveAccountFromPrivateKey(args: {
-        privateKey: PrivateKey;
-    }): Promise<Account$1>;
+    feePayerPublicKey?: PublicKey;
+    options?: InputSimulateTransactionOptions;
+};
+type InputSimulateTransactionOptions = {
+    estimateGasUnitPrice?: boolean;
+    estimateMaxGasAmount?: boolean;
+    estimatePrioritizedGasUnitPrice?: boolean;
+};
+/**
+ * Interface that holds the user data input when generating a single signer transaction
+ */
+interface InputGenerateSingleSignerRawTransactionData {
+    sender: AccountAddressInput;
+    data: InputGenerateTransactionPayloadData;
+    options?: InputGenerateTransactionOptions;
+    withFeePayer?: boolean;
+    secondarySignerAddresses?: undefined;
 }
-
 /**
- * Representation of a ChainId that can serialized and deserialized
+ * Interface that holds the user data input when generating a multi-agent transaction
  */
-declare class ChainId extends Serializable {
-    readonly chainId: number;
-    constructor(chainId: number);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): ChainId;
+interface InputGenerateMultiAgentRawTransactionData {
+    sender: AccountAddressInput;
+    data: InputGenerateTransactionPayloadData;
+    secondarySignerAddresses: AccountAddressInput[];
+    options?: InputGenerateTransactionOptions;
+    withFeePayer?: boolean;
 }
-
 /**
- * Representation of an Identifier that can serialized and deserialized.
- * We use Identifier to represent the module "name" in "ModuleId" and
- * the "function name" in "EntryFunction"
+ * Unified type that holds all the user data input interfaces when generating different transaction types
  */
-declare class Identifier extends Serializable {
-    identifier: string;
-    constructor(identifier: string);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): Identifier;
+type InputGenerateTransactionData = InputGenerateSingleSignerRawTransactionData | InputGenerateMultiAgentRawTransactionData;
+/**
+ * Interface that holds the user data input when submitting a transaction
+ */
+interface InputSubmitTransactionData {
+    transaction: AnyRawTransaction;
+    senderAuthenticator: AccountAuthenticator;
+    feePayerAuthenticator?: AccountAuthenticator;
+    additionalSignersAuthenticators?: Array<AccountAuthenticator>;
 }
 
+interface SingleKeySignerConstructorArgs {
+    privateKey: PrivateKey;
+    address?: AccountAddressInput;
+}
+interface SingleKeySignerGenerateArgs {
+    scheme?: SigningSchemeInput;
+}
+type SingleKeySignerFromDerivationPathArgs = SingleKeySignerGenerateArgs & {
+    path: string;
+    mnemonic: string;
+};
+interface VerifySingleKeySignatureArgs {
+    message: HexInput;
+    signature: AnySignature;
+}
 /**
- * Representation of a ModuleId that can serialized and deserialized
- * ModuleId means the module address (e.g "0x1") and the module name (e.g "coin")
+ * Signer implementation for the SingleKey authentication scheme.
+ * This extends a SingleKeyAccount by adding signing capabilities through a valid private key.
+ * Currently, the only supported signature schemes are Ed25519 and Secp256k1.
+ *
+ * Note: Generating a signer instance does not create the account on-chain.
  */
-declare class ModuleId extends Serializable {
-    readonly address: AccountAddress;
-    readonly name: Identifier;
+declare class SingleKeyAccount implements Account$1 {
     /**
-     * Full name of a module.
-     * @param address The account address. e.g "0x1"
-     * @param name The module name under the "address". e.g "coin"
+     * Private key associated with the account
      */
-    constructor(address: AccountAddress, name: Identifier);
+    readonly privateKey: PrivateKey;
+    readonly publicKey: AnyPublicKey;
+    readonly accountAddress: AccountAddress;
+    readonly signingScheme = SigningScheme.SingleKey;
+    constructor(args: SingleKeySignerConstructorArgs);
     /**
-     * Converts a string literal to a ModuleId
-     * @param moduleId String literal in format "account_address::module_name", e.g. "0x1::coin"
-     * @returns ModuleId
+     * Derives an account from a randomly generated private key.
+     * Default generation is using an Ed25519 key
+     * @returns Account with the given signature scheme
      */
-    static fromStr(moduleId: MoveModuleId): ModuleId;
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): ModuleId;
+    static generate(args?: SingleKeySignerGenerateArgs): SingleKeyAccount;
+    /**
+     * Derives an account with bip44 path and mnemonics,
+     * Default to using an Ed25519 signature scheme.
+     *
+     * @param args.scheme The signature scheme to derive the private key with
+     * @param args.path the BIP44 derive hardened path (e.g. m/44'/637'/0'/0'/0') for Ed25519,
+     * or non-hardened path (e.g. m/44'/637'/0'/0/0) for secp256k1
+     * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
+     * @param args.mnemonic the mnemonic seed phrase of the account
+     */
+    static fromDerivationPath(args: SingleKeySignerFromDerivationPathArgs): SingleKeyAccount;
+    verifySignature(args: VerifySingleKeySignatureArgs): boolean;
+    signWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorSingleKey;
+    sign(message: HexInput): Signature;
+    signTransaction(transaction: AnyRawTransaction): Signature;
 }
 
-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;
+/**
+ * Arguments for creating an `Ed25519Account` from an `Ed25519PrivateKey`.
+ * This is the default input type when passing an `Ed25519PrivateKey`.
+ * In order to use the SingleKey authentication scheme, `legacy` needs to be explicitly set to false.
+ */
+interface CreateEd25519AccountFromPrivateKeyArgs {
+    privateKey: Ed25519PrivateKey;
+    address?: AccountAddressInput;
+    legacy?: true;
 }
-declare class TypeTagAddress extends TypeTag {
-    toString(): string;
-    serialize(serializer: Serializer): void;
-    static load(_deserializer: Deserializer): TypeTagAddress;
+/**
+ * Arguments for creating an `SingleKeyAccount` from an `Ed25519PrivateKey`.
+ * The `legacy` argument needs to be explicitly set to false in order to
+ * use the `SingleKey` authentication scheme.
+ */
+interface CreateEd25519SingleKeyAccountFromPrivateKeyArgs {
+    privateKey: Ed25519PrivateKey;
+    address?: AccountAddressInput;
+    legacy: false;
 }
-declare class TypeTagSigner extends TypeTag {
-    toString(): string;
-    serialize(serializer: Serializer): void;
-    static load(_deserializer: Deserializer): TypeTagSigner;
+/**
+ * Arguments for creating an `SingleKeyAccount` from any supported private key
+ * that is not an `Ed25519PrivateKey`.
+ * The `legacy` argument defaults to false and cannot be explicitly set to true.
+ */
+interface CreateSingleKeyAccountFromPrivateKeyArgs {
+    privateKey: Exclude<PrivateKey, Ed25519PrivateKey>;
+    address?: AccountAddressInput;
+    legacy?: false;
 }
-declare class TypeTagReference extends TypeTag {
-    readonly value: TypeTag;
-    toString(): `&${string}`;
-    constructor(value: TypeTag);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TypeTagReference;
+/**
+ * Arguments for creating an opaque `Account` from any supported private key.
+ * This is used when the private key type is not known at compilation time.
+ */
+interface CreateAccountFromPrivateKeyArgs {
+    privateKey: PrivateKey;
+    address?: AccountAddressInput;
+    legacy?: boolean;
 }
 /**
- * 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.
+ * Arguments for generating an `Ed25519Account`.
+ * This is the input type used by default.
  */
-declare class TypeTagGeneric extends TypeTag {
-    readonly value: number;
-    toString(): `T${number}`;
-    constructor(value: number);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TypeTagGeneric;
+interface GenerateEd25519AccountArgs {
+    scheme?: SigningSchemeInput.Ed25519;
+    legacy?: true;
 }
-declare class TypeTagVector extends TypeTag {
-    readonly value: TypeTag;
-    toString(): `vector<${string}>`;
-    constructor(value: TypeTag);
-    static u8(): TypeTagVector;
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TypeTagVector;
+/**
+ * Arguments for generating an `SingleKeyAccount` with ah underlying `Ed25519PrivateKey`.
+ * The `legacy` argument needs to be explicitly set to false,
+ * otherwise an `Ed25519Account` will be returned instead.
+ */
+interface GenerateEd25519SingleKeyAccountArgs {
+    scheme?: SigningSchemeInput.Ed25519;
+    legacy: false;
 }
-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;
-    isTypeTag(address: AccountAddress, moduleName: string, structName: string): boolean;
-    isString(): boolean;
-    isOption(): boolean;
-    isObject(): boolean;
+/**
+ * Arguments for generating an `SingleKeyAccount` with any supported private key
+ * that is not an `Ed25519PrivateKey`.
+ * The `legacy` argument defaults to false and cannot be explicitly set to true.
+ */
+interface GenerateSingleKeyAccountArgs {
+    scheme: Exclude<SigningSchemeInput, SigningSchemeInput.Ed25519>;
+    legacy?: false;
 }
-declare class StructTag extends Serializable {
-    readonly address: AccountAddress;
-    readonly moduleName: Identifier;
-    readonly name: Identifier;
-    readonly typeArgs: Array<TypeTag>;
-    constructor(address: AccountAddress, module_name: Identifier, name: Identifier, type_args: Array<TypeTag>);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): StructTag;
+/**
+ * Arguments for generating an opaque `Account`.
+ * This is used when the input signature scheme is not known at compilation time.
+ */
+interface GenerateAccountArgs {
+    scheme?: SigningSchemeInput;
+    legacy?: boolean;
 }
-declare function aptosCoinStructTag(): StructTag;
-declare function stringStructTag(): StructTag;
-declare function optionStructTag(typeArg: TypeTag): StructTag;
-declare function objectStructTag(typeArg: TypeTag): StructTag;
-
 /**
- * Deserialize a Script Transaction Argument
+ * Arguments for deriving a private key from a mnemonic phrase and a BIP44 path.
  */
-declare function deserializeFromScriptArgument(deserializer: Deserializer): TransactionArgument;
+interface PrivateKeyFromDerivationPathArgs {
+    path: string;
+    mnemonic: string;
+}
 /**
- * Representation of the supported Transaction Payload
- * that can serialized and deserialized
+ * Interface for a generic Aptos account.
+ *
+ * The interface is defined as abstract class to provide a single entrypoint for account generation,
+ * either through `Account.generate()` or `Account.fromDerivationPath`.
+ * Despite this being an abstract class, it should be treated as an interface and enforced using
+ * the `implements` keyword.
+ *
+ * Note: Generating an account instance does not create the account on-chain.
  */
-declare abstract class TransactionPayload extends Serializable {
+declare abstract class Account$1 {
     /**
-     * Serialize a Transaction Payload
+     * Public key associated with the account
      */
-    abstract serialize(serializer: Serializer): void;
+    abstract readonly publicKey: AccountPublicKey;
     /**
-     * Deserialize a Transaction Payload
+     * Account address associated with the account
      */
-    static deserialize(deserializer: Deserializer): TransactionPayload;
+    abstract readonly accountAddress: AccountAddress;
+    /**
+     * Signing scheme used to sign transactions
+     */
+    abstract signingScheme: SigningScheme;
+    /**
+     * Derives an account from a randomly generated private key.
+     * @param args.scheme The signature scheme to use, to generate the private key
+     * @param args.legacy Whether to use a legacy authentication scheme, when applicable
+     * @returns An account compatible with the provided signature scheme
+     */
+    static generate(args?: GenerateEd25519AccountArgs): Ed25519Account;
+    static generate(args: GenerateEd25519SingleKeyAccountArgs): SingleKeyAccount;
+    static generate(args: GenerateSingleKeyAccountArgs): SingleKeyAccount;
+    static generate(args: GenerateAccountArgs): Account$1;
+    /**
+     * Creates an account from the provided private key.
+     *
+     * @param args.privateKey a valid private key
+     * @param args.address the account's address. If not provided, it will be derived from the public key.
+     * @param args.legacy Whether to use a legacy authentication scheme, when applicable
+     */
+    static fromPrivateKey(args: CreateEd25519AccountFromPrivateKeyArgs): Ed25519Account;
+    static fromPrivateKey(args: CreateEd25519SingleKeyAccountFromPrivateKeyArgs): SingleKeyAccount;
+    static fromPrivateKey(args: CreateSingleKeyAccountFromPrivateKeyArgs): SingleKeyAccount;
+    static fromPrivateKey(args: CreateAccountFromPrivateKeyArgs): Account$1;
+    /**
+     * @deprecated use `fromPrivateKey` instead.
+     * 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 args.privateKey PrivateKey - the underlying private key for the account
+     * @param args.address AccountAddress - The account address the `Account` will sign for
+     * @param args.legacy optional. If set to false, the keypair generated is a Unified keypair. Defaults
+     * to generating a Legacy Ed25519 keypair
+     *
+     * @returns Account
+     */
+    static fromPrivateKeyAndAddress(args: CreateAccountFromPrivateKeyArgs): Account$1;
+    /**
+     * Derives an account with bip44 path and mnemonics
+     *
+     * @param args.scheme The signature scheme to derive the private key with
+     * @param args.path the BIP44 derive hardened path (e.g. m/44'/637'/0'/0'/0') for Ed25519,
+     * or non-hardened path (e.g. m/44'/637'/0'/0/0) for secp256k1
+     * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
+     * @param args.mnemonic the mnemonic seed phrase of the account
+     */
+    static fromDerivationPath(args: GenerateEd25519AccountArgs & PrivateKeyFromDerivationPathArgs): Ed25519Account;
+    static fromDerivationPath(args: GenerateEd25519SingleKeyAccountArgs & PrivateKeyFromDerivationPathArgs): SingleKeyAccount;
+    static fromDerivationPath(args: GenerateSingleKeyAccountArgs & PrivateKeyFromDerivationPathArgs): SingleKeyAccount;
+    static fromDerivationPath(args: GenerateAccountArgs & PrivateKeyFromDerivationPathArgs): Account$1;
+    /**
+     * @deprecated use `publicKey.authKey()` instead.
+     * This key enables account owners to rotate their private key(s)
+     * associated with the account without changing the address that hosts their account.
+     * See here for more info: {@link https://aptos.dev/concepts/accounts#single-signer-authentication}
+     *
+     * @param args.publicKey PublicKey - public key of the account
+     * @returns The authentication key for the associated account
+     */
+    static authKey(args: {
+        publicKey: AccountPublicKey;
+    }): AuthenticationKey;
+    /**
+     * Sign a transaction using the available signing capabilities.
+     * @param transaction the raw transaction
+     * @return the AccountAuthenticator containing the signature og the transaction, together with the account's public key
+     */
+    abstract signWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticator;
+    /**
+     * Sign the given message with the private key.
+     * @param message in HexInput format
+     * @returns AccountSignature
+     */
+    abstract sign(message: HexInput): Signature;
+    abstract signTransaction(transaction: AnyRawTransaction): Signature;
+    /**
+     * @param args.message raw message data in HexInput format
+     * @param args.signature signed message signature
+     */
+    verifySignature(args: VerifySignatureArgs): boolean;
 }
-/**
- * Representation of a Transaction Payload Script that can serialized and deserialized
- */
-declare class TransactionPayloadScript extends TransactionPayload {
-    readonly script: Script;
-    constructor(script: Script);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TransactionPayloadScript;
+
+interface Ed25519SignerConstructorArgs {
+    privateKey: Ed25519PrivateKey;
+    address?: AccountAddressInput;
 }
-/**
- * Representation of a Transaction Payload Entry Function that can serialized and deserialized
- */
-declare class TransactionPayloadEntryFunction extends TransactionPayload {
-    readonly entryFunction: EntryFunction;
-    constructor(entryFunction: EntryFunction);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TransactionPayloadEntryFunction;
+interface Ed25519SignerFromDerivationPathArgs {
+    path: string;
+    mnemonic: string;
 }
-/**
- * Representation of a Transaction Payload Multi-sig that can serialized and deserialized
- */
-declare class TransactionPayloadMultiSig extends TransactionPayload {
-    readonly multiSig: MultiSig;
-    constructor(multiSig: MultiSig);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TransactionPayloadMultiSig;
+interface VerifyEd25519SignatureArgs {
+    message: HexInput;
+    signature: Ed25519Signature;
 }
 /**
- * Representation of a EntryFunction that can serialized and deserialized
+ * Signer implementation for the Ed25519 authentication scheme.
+ * This extends an {@link Ed25519Account} by adding signing capabilities through an {@link Ed25519PrivateKey}.
+ *
+ * Note: Generating a signer instance does not create the account on-chain.
  */
-declare class EntryFunction {
-    readonly module_name: ModuleId;
-    readonly function_name: Identifier;
-    readonly type_args: Array<TypeTag>;
-    readonly args: Array<EntryFunctionArgument>;
+declare class Ed25519Account implements Account$1 {
+    /**
+     * Private key associated with the account
+     */
+    readonly privateKey: Ed25519PrivateKey;
+    readonly publicKey: Ed25519PublicKey;
+    readonly accountAddress: AccountAddress;
+    readonly signingScheme = SigningScheme.Ed25519;
+    constructor(args: Ed25519SignerConstructorArgs);
+    /**
+     * Derives a signer from a randomly generated private key
+     */
+    static generate(): Ed25519Account;
+    /**
+     * Derives an account with bip44 path and mnemonics
+     *
+     * @param args.path the BIP44 derive hardened path e.g. m/44'/637'/0'/0'/0'
+     * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
+     * @param args.mnemonic the mnemonic seed phrase of the account
+     */
+    static fromDerivationPath(args: Ed25519SignerFromDerivationPathArgs): Ed25519Account;
+    verifySignature(args: VerifyEd25519SignatureArgs): boolean;
+    signWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorEd25519;
+    sign(message: HexInput): Ed25519Signature;
+    signTransaction(transaction: AnyRawTransaction): Ed25519Signature;
+}
+
+declare class EphemeralKeyPair {
+    readonly blinder: Uint8Array;
+    readonly expiryDateSecs: bigint;
+    readonly nonce: string;
+    readonly privateKey: PrivateKey;
+    readonly publicKey: EphemeralPublicKey;
+    constructor(args: {
+        privateKey: PrivateKey;
+        expiryDateSecs?: bigint;
+        blinder?: HexInput;
+    });
+    static generate(args?: {
+        scheme: SigningSchemeInput;
+    }): EphemeralKeyPair;
+    generateNonce(): string;
+    /**
+     * Sign the given message with the private key.
+     *   *
+     * @param data in HexInput format
+     * @returns EphemeralSignature
+     */
+    sign(data: HexInput): EphemeralSignature;
+}
+
+declare class KeylessAccount implements Account$1 {
+    static readonly PEPPER_LENGTH: number;
+    static readonly SLIP_0010_SEED: string;
+    static readonly APTOS_CONNECT_CLIENT_ID: string;
+    publicKey: KeylessPublicKey;
+    ephemeralKeyPair: EphemeralKeyPair;
+    uidKey: string;
+    uidVal: string;
+    aud: string;
+    pepper: Uint8Array;
+    accountAddress: AccountAddress;
+    proof: SignedGroth16Signature | Promise<SignedGroth16Signature>;
+    signingScheme: SigningScheme;
+    jwt: string;
+    constructor(args: {
+        address?: AccountAddress;
+        ephemeralKeyPair: EphemeralKeyPair;
+        iss: string;
+        uidKey: string;
+        uidVal: string;
+        aud: string;
+        pepper: HexInput;
+        proofFetcherOrData: Promise<SignedGroth16Signature> | SignedGroth16Signature;
+        jwt: string;
+    });
+    private initialize;
+    signWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorSingleKey;
+    waitForProofFetch(): Promise<void>;
+    sign(data: HexInput): Signature;
+    signTransaction(transaction: AnyRawTransaction): Signature;
+    signWithOpenIdSignature(data: HexInput): Signature;
+    deriveAptosConnectPublicKey(): KeylessPublicKey;
+    verifySignature(args: {
+        message: HexInput;
+        signature: Signature;
+    }): boolean;
+    static fromJWTAndProof(args: {
+        proofFetcherOrData: Promise<SignedGroth16Signature> | SignedGroth16Signature;
+        jwt: string;
+        ephemeralKeyPair: EphemeralKeyPair;
+        pepper: HexInput;
+        uidKey?: string;
+    }): KeylessAccount;
+    static fromDerivationPath(path: string, seed: Uint8Array): Uint8Array;
+}
+
+declare class MultiKeyAccount implements Account$1 {
     /**
-     * Contains the payload to run a function within a module.
-     * @param module_name Fully qualified module name in format "account_address::module_name" e.g. "0x1::coin"
-     * @param function_name The function name. e.g "transfer"
-     * @param type_args Type arguments that move function requires.
-     *
-     * @example
-     * A coin transfer function has one type argument "CoinType".
-     * ```
-     * public entry fun transfer<CoinType>(from: &signer, to: address, amount: u64)
-     * ```
-     * @param args arguments to the move function.
-     *
-     * @example
-     * A coin transfer function has three arguments "from", "to" and "amount".
-     * ```
-     * public entry fun transfer<CoinType>(from: &signer, to: address, amount: u64)
-     * ```
+     * Public key associated with the account
      */
-    constructor(module_name: ModuleId, function_name: Identifier, type_args: Array<TypeTag>, args: Array<EntryFunctionArgument>);
+    readonly publicKey: MultiKey;
     /**
-     * A helper function to build a EntryFunction payload from raw primitive values
+     * Account address associated with the account
+     */
+    readonly accountAddress: AccountAddress;
+    /**
+     * Signing scheme used to sign transactions
+     */
+    readonly signingScheme: SigningScheme;
+    signers: Account$1[];
+    signaturesBitmap: Uint8Array;
+    /**
+     * constructor for Account
      *
-     * @param module_id Fully qualified module name in format "AccountAddress::module_id" e.g. "0x1::coin"
-     * @param function_name Function name
-     * @param type_args Type arguments that move function requires.
+     * Need to update this to use the new crypto library if new schemes are added.
      *
-     * @example
-     * A coin transfer function has one type argument "CoinType".
-     * ```
-     * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
-     * ```
-     * @param args Arguments to the move function.
+     * @param args.privateKey PrivateKey - private key of the account
+     * @param args.address AccountAddress - address of the account
+     * @param args.legacy optional. If set to false, the keypair authentication keys will be derived with a unified scheme.
+     * Defaults to deriving an authentication key with the legacy scheme.
      *
-     * @example
-     * A coin transfer function has three arguments "from", "to" and "amount".
-     * ```
-     * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
-     * ```
-     * @returns EntryFunction
+     * This method is private because it should only be called by the factory static methods.
+     * @returns Account
      */
-    static build(module_id: MoveModuleId, function_name: string, type_args: Array<TypeTag>, args: Array<EntryFunctionArgument>): EntryFunction;
-    serialize(serializer: Serializer): void;
+    constructor(args: {
+        multiKey: MultiKey;
+        signers: Account$1[];
+    });
+    static fromPublicKeysAndSigners(args: {
+        publicKeys: PublicKey[];
+        signaturesRequired: number;
+        signers: Account$1[];
+    }): MultiKeyAccount;
+    static isMultiKeySigner(account: Account$1): account is MultiKeyAccount;
+    signWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorMultiKey;
+    waitForProofFetch(): Promise<void>;
     /**
-     * Deserializes an entry function payload with the arguments represented as EntryFunctionBytes instances.
-     * @see EntryFunctionBytes
-     *
-     * NOTE: When you deserialize an EntryFunction payload with this method, the entry function
-     * arguments are populated into the deserialized instance as type-agnostic, raw fixed bytes
-     * in the form of the EntryFunctionBytes class.
-     *
-     * In order to correctly deserialize these arguments as their actual type representations, you
-     * must know the types of the arguments beforehand and deserialize them yourself individually.
+     * Sign the given message with the private key.
      *
-     * One way you could achieve this is by using the ABIs for an entry function and deserializing each
-     * argument as its given, corresponding type.
+     * TODO: Add sign transaction or specific types
      *
-     * @param deserializer
-     * @returns A deserialized EntryFunction payload for a transaction.
+     * @param data in HexInput format
+     * @returns Signature
+     */
+    sign(data: HexInput): MultiSignature;
+    signTransaction(transaction: AnyRawTransaction): MultiSignature;
+    /**
+     * Verify the given message and signature with the public key.
      *
+     * @param args.message raw message data in HexInput format
+     * @param args.signature signed message Signature
+     * @returns
      */
-    static deserialize(deserializer: Deserializer): EntryFunction;
+    verifySignature(args: {
+        message: HexInput;
+        signature: Signature;
+    }): boolean;
 }
+
 /**
- * Representation of a Script that can serialized and deserialized
+ * A class to query all `Account` related queries on Aptos.
  */
-declare class Script {
-    /**
-     * The move module bytecode
-     */
-    readonly bytecode: Uint8Array;
+declare class Account {
+    readonly config: AptosConfig;
+    constructor(config: AptosConfig);
     /**
-     * The type arguments that the bytecode function requires.
+     * Queries the current state for an Aptos account given its account address
+     *
+     * @param args.accountAddress Aptos account address
+     *
+     * @returns The account data
+     *
+     * @example An example of the returned account
+     * ```
+     * {
+     *    sequence_number: "1",
+     *    authentication_key: "0x5307b5f4bc67829097a8ba9b43dba3b88261eeccd1f709d9bde240fc100fbb69"
+     * }
+     * ```
      */
-    readonly type_args: Array<TypeTag>;
+    getAccountInfo(args: {
+        accountAddress: AccountAddressInput;
+    }): Promise<AccountData>;
     /**
-     * The arguments that the bytecode function requires.
+     * Queries for all modules in an account given an account address
+     *
+     * Note: In order to get all account modules, this function may call the API
+     * multiple times as it auto paginates.
+     *
+     * @param args.accountAddress Aptos account address
+     * @param args.options.offset The number module to start returning results from
+     * @param args.options.limit The number of results to return
+     * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
+     *
+     * @returns Account modules
      */
-    readonly args: Array<ScriptFunctionArgument>;
+    getAccountModules(args: {
+        accountAddress: AccountAddressInput;
+        options?: PaginationArgs & LedgerVersionArg;
+    }): Promise<MoveModuleBytecode[]>;
     /**
-     * Scripts contain the Move bytecodes payload that can be submitted to Aptos chain for execution.
+     * Queries for a specific account module given account address and module name
      *
-     * @param bytecode The move module bytecode
-     * @param type_args The type arguments that the bytecode function requires.
+     * @param args.accountAddress Aptos account address
+     * @param args.moduleName The name of the module
+     * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
      *
-     * @example
-     * A coin transfer function has one type argument "CoinType".
-     * ```
-     * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
-     * ```
-     * @param args The arguments that the bytecode function requires.
+     * @returns Account module
      *
      * @example
-     * A coin transfer function has three arguments "from", "to" and "amount".
+     * const module = await aptos.getAccountModule({accountAddress:"0x456"})
+     * // An example of an account module response
      * ```
-     * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
+     * {
+     *    bytecode: "0xa11ceb0b0600000006010002030206050807070f0d081c200",
+     *    abi: { address: "0x1" }
+     * }
      * ```
      */
-    constructor(bytecode: Uint8Array, type_args: Array<TypeTag>, args: Array<ScriptFunctionArgument>);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): Script;
-}
-/**
- * Representation of a MultiSig that can serialized and deserialized
- */
-declare class MultiSig {
-    readonly multisig_address: AccountAddress;
-    readonly transaction_payload?: MultiSigTransactionPayload;
+    getAccountModule(args: {
+        accountAddress: AccountAddressInput;
+        moduleName: string;
+        options?: LedgerVersionArg;
+    }): Promise<MoveModuleBytecode>;
     /**
-     * Contains the payload to run a multi-sig account transaction.
+     * Queries account transactions given an account address
      *
-     * @param multisig_address The multi-sig account address the transaction will be executed as.
+     * Note: In order to get all account transactions, this function may call the API
+     * multiple times as it auto paginates.
      *
-     * @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);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): MultiSig;
-}
-/**
- * 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 extends Serializable {
-    readonly transaction_payload: EntryFunction;
-    /**
-     * Contains the payload to run a multi-sig account transaction.
+     * @example
+     * const transactions = await aptos.getAccountTransactions({accountAddress:"0x456"})
      *
-     * @param transaction_payload The payload of the multi-sig transaction.
-     * This can only be EntryFunction for now but,
-     * Script might be supported in the future.
-     */
-    constructor(transaction_payload: EntryFunction);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): MultiSigTransactionPayload;
-}
-
-/**
- * Representation of a Raw Transaction that can serialized and deserialized
- */
-declare class RawTransaction extends Serializable {
-    readonly sender: AccountAddress;
-    readonly sequence_number: bigint;
-    readonly payload: TransactionPayload;
-    readonly max_gas_amount: bigint;
-    readonly gas_unit_price: bigint;
-    readonly expiration_timestamp_secs: bigint;
-    readonly chain_id: ChainId;
-    /**
-     * RawTransactions contain the metadata and payloads that can be submitted to Aptos chain for execution.
-     * RawTransactions must be signed before Aptos chain can execute them.
+     * @param args.accountAddress Aptos account address
+     * @param args.options.offset The number transaction to start returning results from
+     * @param args.options.limit The number of results to return
      *
-     * @param sender The sender Account Address
-     * @param sequence_number Sequence number of this transaction. This must match the sequence number stored in
-     *   the sender's account at the time the transaction executes.
-     * @param payload Instructions for the Aptos Blockchain, including publishing a module,
-     *   execute an entry function or execute a script payload.
-     * @param max_gas_amount Maximum total gas to spend for this transaction. The account must have more
-     *   than this gas or the transaction will be discarded during validation.
-     * @param gas_unit_price Price to be paid per gas unit.
-     * @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.
+     * @returns The account transactions
      */
-    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;
-}
-/**
- * Representation of a Raw Transaction With Data that can serialized and deserialized
- */
-declare abstract class RawTransactionWithData extends Serializable {
+    getAccountTransactions(args: {
+        accountAddress: AccountAddressInput;
+        options?: PaginationArgs;
+    }): Promise<TransactionResponse[]>;
     /**
-     * Serialize a Raw Transaction With Data
+     * Queries all account resources given an account address
+     *
+     * Note: In order to get all account resources, this function may call the API
+     * multiple times as it auto paginates.
+     *
+     * @example
+     * const resources = await aptos.getAccountResources({accountAddress:"0x456"})
+     *
+     * @param args.accountAddress Aptos account address
+     * @param args.options.offset The number resource to start returning results from
+     * @param args.options.limit The number of results to return
+     * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
+     * @returns Account resources
      */
-    abstract serialize(serializer: Serializer): void;
+    getAccountResources(args: {
+        accountAddress: AccountAddressInput;
+        options?: PaginationArgs & LedgerVersionArg;
+    }): Promise<MoveResource[]>;
     /**
-     * Deserialize a Raw Transaction With Data
+     * 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
+     *
+     * @returns Account resource
+     *
+     * @example
+     * const resource = await aptos.getAccountResource({accountAddress:"0x456"})
+     *
      */
-    static deserialize(deserializer: Deserializer): RawTransactionWithData;
-}
-/**
- * Representation of a Multi Agent Transaction that can serialized and deserialized
- */
-declare class MultiAgentRawTransaction extends RawTransactionWithData {
+    getAccountResource<T extends {} = any>(args: {
+        accountAddress: AccountAddressInput;
+        resourceType: MoveStructId;
+        options?: LedgerVersionArg;
+    }): Promise<T>;
     /**
-     * The raw transaction
+     * Looks up the account address for a given authentication key
+     *
+     * This handles both if the account's authentication key has been rotated or not.
+     *
+     * @example
+     * const accountAddress = await aptos.lookupOriginalAccountAddress({authenticationKey:account.accountAddress})
+     *
+     * @param args.authenticationKey The authentication key
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
+     * @returns Promise<AccountAddress> The accountAddress associated with the authentication key
      */
-    readonly raw_txn: RawTransaction;
+    lookupOriginalAccountAddress(args: {
+        authenticationKey: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: LedgerVersionArg;
+    }): Promise<AccountAddress>;
     /**
-     * The secondary signers on this transaction
+     * Queries the current count of tokens owned by an account
+     *
+     * @example
+     * const tokensCount = await aptos.getAccountTokensCount({accountAddress:"0x456"})
+     *
+     * @param args.accountAddress The account address
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @returns Current count of tokens owned by the account
      */
-    readonly secondary_signer_addresses: Array<AccountAddress>;
-    constructor(raw_txn: RawTransaction, secondary_signer_addresses: Array<AccountAddress>);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): MultiAgentRawTransaction;
-}
-/**
- * Representation of a Fee Payer Transaction that can serialized and deserialized
- */
-declare class FeePayerRawTransaction extends RawTransactionWithData {
+    getAccountTokensCount(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<number>;
     /**
-     * The raw transaction
+     * Queries the account's current owned tokens.
+     *
+     * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.
+     * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param
+     *
+     * @example
+     * const accountOwnedTokens = await aptos.getAccountOwnedTokens({accountAddress:"0x456"})
+     *
+     * @param args.accountAddress The account address we want to get the tokens for
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @param args.options.tokenStandard The NFT standard to query for
+     * @param args.options.offset The number token to start returning results from
+     * @param args.options.limit The number of results to return
+     * @param args.options.orderBy The order to sort the tokens by
+     * @returns Tokens array with the token data
      */
-    readonly raw_txn: RawTransaction;
+    getAccountOwnedTokens(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensQueryResponse[0]>;
+    }): Promise<GetAccountOwnedTokensQueryResponse>;
     /**
-     * The secondary signers on this transaction - optional and can be empty
+     * Queries all current tokens of a specific collection that an account owns by the collection address
+     *
+     * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.
+     * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param
+     *
+     * @example
+     * const accountOwnedTokens = await aptos.getAccountOwnedTokensFromCollectionAddress({accountAddress:"0x123", collectionAddress:"0x456"})
+     *
+     * @param args.accountAddress The account address we want to get the tokens for
+     * @param args.collectionAddress The address of the collection being queried
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @param args.options.tokenStandard The NFT standard to query for
+     * @param args.options.offset The number token to start returning results from
+     * @param args.options.limit The number of results to return
+     * @param args.options.orderBy The order to sort the tokens by
+     * @returns Tokens array with the token data
      */
-    readonly secondary_signer_addresses: Array<AccountAddress>;
+    getAccountOwnedTokensFromCollectionAddress(args: {
+        accountAddress: AccountAddressInput;
+        collectionAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensFromCollectionResponse[0]>;
+    }): Promise<GetAccountOwnedTokensFromCollectionResponse>;
     /**
-     * The fee payer account address
+     * Queries for all collections that an account currently has tokens for.
+     *
+     * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.
+     * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param
+     *
+     * @example
+     * const accountCollectionsWithOwnedTokens = await aptos.getAccountCollectionsWithOwnedTokens({accountAddress:"0x123"})
+     *
+     * @param args.accountAddress The account address we want to get the collections for
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @param args.options.tokenStandard The NFT standard to query for
+     * @param args.options.offset The number collection to start returning results from
+     * @param args.options.limit The number of results to return
+     * @param args.options.orderBy The order to sort the tokens by
+     * @returns Collections array with the collections data
      */
-    readonly fee_payer_address: AccountAddress;
-    constructor(raw_txn: RawTransaction, secondary_signer_addresses: Array<AccountAddress>, fee_payer_address: AccountAddress);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): FeePayerRawTransaction;
-}
-
-/**
- * Representation of a SimpleTransaction that can serialized and deserialized
- */
-declare class SimpleTransaction extends Serializable {
-    rawTransaction: RawTransaction;
-    feePayerAddress?: AccountAddress | undefined;
-    readonly secondarySignerAddresses: undefined;
+    getAccountCollectionsWithOwnedTokens(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountCollectionsWithOwnedTokenResponse[0]>;
+    }): Promise<GetAccountCollectionsWithOwnedTokenResponse>;
     /**
-     * SimpleTransaction represents a simple transaction type of a single signer that
-     * can be submitted to Aptos chain for execution.
+     * Queries the current count of transactions submitted by an account
      *
-     * SimpleTransaction metadata contains the Raw Transaction and an optional
-     * sponsor Account Address to pay the gas fees.
+     * @example
+     * const accountTransactionsCount = await aptos.getAccountTransactionsCount({accountAddress:"0x123"})
      *
-     * @param rawTransaction The Raw Tranasaction
-     * @param feePayerAddress The sponsor Account Address
+     * @param args.accountAddress The account address we want to get the total count for
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @returns Current count of transactions made by an account
      */
-    constructor(rawTransaction: RawTransaction, feePayerAddress?: AccountAddress);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): SimpleTransaction;
-}
-
-/**
- * Representation of the challenge which is needed to sign by owner of the account
- * to rotate the authentication key.
- */
-declare class RotationProofChallenge extends Serializable {
-    readonly accountAddress: AccountAddress;
-    readonly moduleName: MoveString;
-    readonly structName: MoveString;
-    readonly originator: AccountAddress;
-    readonly currentAuthKey: AccountAddress;
-    readonly newPublicKey: MoveVector<U8>;
-    readonly sequenceNumber: U64;
-    constructor(args: {
-        sequenceNumber: AnyNumber;
-        originator: AccountAddress;
-        currentAuthKey: AccountAddress;
-        newPublicKey: PublicKey;
-    });
-    serialize(serializer: Serializer): void;
-}
-
-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;
+    getAccountTransactionsCount(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<number>;
     /**
-     * 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.
+     * Queries an account's coins data
      *
-     * @see {@link https://aptos.dev/integration/creating-a-signed-transaction | Creating a Signed Transaction}
+     * @example
+     * const accountCoinsData = await aptos.getAccountCoinsData({accountAddress:"0x123"})
      *
-     * @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.
+     * @param args.accountAddress The account address we want to get the coins data for
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @param args.options.offset optional. The number coin to start returning results from
+     * @param args.options.limit optional. The number of results to return
+     * @param args.options.orderBy optional. The order to sort the coins by
+     * @param args.options.where optional. Filter the results by
+     * @returns Array with the coins data
      */
-    constructor(raw_txn: RawTransaction, authenticator: TransactionAuthenticator);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): SignedTransaction;
-}
-
-/**
- * Representation of a Raw Transaction that can serialized and deserialized
- */
-declare class MultiAgentTransaction extends Serializable {
-    rawTransaction: RawTransaction;
-    feePayerAddress?: AccountAddress | undefined;
-    secondarySignerAddresses: AccountAddress[];
+    getAccountCoinsData(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & OrderByArg<GetAccountCoinsDataResponse[0]> & WhereArg<CurrentFungibleAssetBalancesBoolExp>;
+    }): Promise<GetAccountCoinsDataResponse>;
     /**
-     * SimpleTransaction represents a simple transaction type of a single signer that
-     * can be submitted to Aptos chain for execution.
+     * Queries the current count of an account's coins aggregated
      *
-     * SimpleTransaction metadata contains the Raw Transaction and an optional
-     * sponsor Account Address to pay the gas fees.
+     * @example
+     * const accountCoinsCount = await aptos.getAccountCoinsCount({accountAddress:"0x123"})
      *
-     * @param rawTransaction The Raw Tranasaction
-     * @param feePayerAddress The sponsor Account Address
+     * @param args.accountAddress The account address we want to get the total count for
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @returns Current count of the aggregated count of all account's coins
      */
-    constructor(rawTransaction: RawTransaction, secondarySignerAddresses: AccountAddress[], feePayerAddress?: AccountAddress);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): MultiAgentTransaction;
-}
-
-/**
- * Entry function arguments to be used when building a raw transaction using remote ABI
- */
-type SimpleEntryFunctionArgumentTypes = boolean | number | bigint | string | null | undefined | Uint8Array | ArrayBuffer | Array<SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes>;
-/**
- * Entry function arguments to be used when building a raw transaction using BCS serialized arguments
- */
-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
- */
-type ScriptFunctionArgumentTypes = Bool | U8 | U16 | U32 | U64 | U128 | U256 | AccountAddress | MoveVector<U8> | MoveString | FixedBytes;
-/**
- * Type that holds all raw transaction instances Aptos SDK supports
- */
-type AnyRawTransactionInstance = RawTransaction | MultiAgentRawTransaction | FeePayerRawTransaction;
-/**
- * Optional options to set when generating a transaction
- */
-type InputGenerateTransactionOptions = {
-    maxGasAmount?: number;
-    gasUnitPrice?: number;
-    expireTimestamp?: number;
-    accountSequenceNumber?: AnyNumber;
-};
-/**
- * The generated transaction payload type that was produces from `generateTransactionPayload()` function.
- */
-type AnyTransactionPayloadInstance = TransactionPayloadEntryFunction | TransactionPayloadScript | TransactionPayloadMultiSig;
-/**
- * Unified type for the data needed to generate a transaction payload of types:
- * Entry Function | Script | Multi Sig
- */
-type InputGenerateTransactionPayloadData = InputEntryFunctionData | InputScriptData | InputMultiSigData;
-type InputGenerateTransactionPayloadDataWithRemoteABI = InputScriptData | InputEntryFunctionDataWithRemoteABI | InputMultiSigDataWithRemoteABI;
-/**
- * The data needed to generate an Entry Function payload
- */
-type InputEntryFunctionData = {
-    function: MoveFunctionId;
-    typeArguments?: Array<TypeTag | string>;
-    functionArguments: Array<EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes>;
-    abi?: EntryFunctionABI;
-};
-type InputGenerateTransactionPayloadDataWithABI = InputEntryFunctionDataWithABI | InputMultiSigDataWithABI;
-type InputEntryFunctionDataWithABI = Omit<InputEntryFunctionData, "abi"> & {
-    abi: EntryFunctionABI;
-};
-type InputMultiSigDataWithABI = {
-    multisigAddress: AccountAddressInput;
-} & InputEntryFunctionDataWithABI;
-type InputEntryFunctionDataWithRemoteABI = InputEntryFunctionData & {
-    aptosConfig: AptosConfig;
-};
-/**
- * The data needed to generate a Multi Sig payload
- */
-type InputMultiSigData = {
-    multisigAddress: AccountAddressInput;
-} & InputEntryFunctionData;
-/**
- * The data needed to generate a Multi Sig payload
- */
-type InputMultiSigDataWithRemoteABI = {
-    multisigAddress: AccountAddressInput;
-} & InputEntryFunctionDataWithRemoteABI;
-/**
- * The data needed to generate a Script payload
- */
-type InputScriptData = {
-    bytecode: HexInput;
-    typeArguments?: Array<TypeTag>;
-    functionArguments: Array<ScriptFunctionArgumentTypes>;
-};
-/**
- * The data needed to generate a View Function payload
- */
-type InputViewFunctionData = {
-    function: MoveFunctionId;
-    typeArguments?: Array<TypeTag | string>;
-    functionArguments?: Array<EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes>;
-    abi?: ViewFunctionABI;
-};
-/**
- * Data needed to generate a view function payload and fetch the remote ABI
- */
-type InputViewFunctionDataWithRemoteABI = InputViewFunctionData & {
-    aptosConfig: AptosConfig;
-};
-/**
- * Data needed to generate a view function, with an already fetched ABI
- */
-type InputViewFunctionDataWithABI = InputViewFunctionData & {
-    abi: ViewFunctionABI;
-};
-/**
- * Data need for a generic function ABI, both view and entry
- */
-type FunctionABI = {
-    typeParameters: Array<MoveFunctionGenericTypeParam>;
-    parameters: Array<TypeTag>;
-};
-/**
- * Interface of an Entry function's ABI.
- *
- * This is used to provide type checking and simple input conversion on ABI based transaction submission.
- */
-type EntryFunctionABI = FunctionABI & {
-    signers?: number;
-};
-/**
- * Interface of an View function's ABI.
- *
- * This is used to provide type checking and simple input conversion on ABI based transaction submission.
- */
-type ViewFunctionABI = FunctionABI & {
-    returnTypes: Array<TypeTag>;
-};
-/**
- * Interface of the arguments to generate a single signer transaction.
- * Used to provide to `generateTransaction()` method in the transaction builder flow
- */
-interface InputGenerateSingleSignerRawTransactionArgs {
-    aptosConfig: AptosConfig;
-    sender: AccountAddressInput;
-    payload: AnyTransactionPayloadInstance;
-    options?: InputGenerateTransactionOptions;
-    feePayerAddress?: AccountAddressInput;
-}
-/**
- * Interface of the arguments to generate a multi-agent transaction.
- * Used to provide to `generateTransaction()` method in the transaction builder flow
- */
-interface InputGenerateMultiAgentRawTransactionArgs {
-    aptosConfig: AptosConfig;
-    sender: AccountAddressInput;
-    payload: AnyTransactionPayloadInstance;
-    secondarySignerAddresses: AccountAddressInput[];
-    options?: InputGenerateTransactionOptions;
-    feePayerAddress?: AccountAddressInput;
-}
-/**
- * Unified type that holds all the interfaces to generate different transaction types
- */
-type InputGenerateRawTransactionArgs = InputGenerateSingleSignerRawTransactionArgs | InputGenerateMultiAgentRawTransactionArgs;
-/**
- * Unified type that holds all the return interfaces when generating different transaction types
- */
-type AnyRawTransaction = SimpleTransaction | MultiAgentTransaction;
-type InputSimulateTransactionData = {
+    getAccountCoinsCount(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<number>;
     /**
-     * The transaction to simulate, probably generated by `generateTransaction()`
+     * Queries the account's APT amount
+     *
+     * @example
+     * const accountAPTAmount = await aptos.getAccountAPTAmount({accountAddress:"0x123"})
+     *
+     * @param args.accountAddress The account address we want to get the total count for
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @returns Current amount of account's APT
      */
-    transaction: AnyRawTransaction;
+    getAccountAPTAmount(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<number>;
     /**
-     * For a single signer transaction
+     * Queries the account's coin amount by the coin type
+     *
+     * @example
+     * const accountCoinAmount = await aptos.getAccountCoinAmount({accountAddress:"0x123", coinType:"0x1::aptos_coin::AptosCoin"})
+     *
+     * @param args.accountAddress The account address we want to get the total count for
+     * @param args.coinType The coin type to query
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @returns Current amount of account's coin
      */
-    signerPublicKey: PublicKey;
+    getAccountCoinAmount(args: {
+        accountAddress: AccountAddressInput;
+        coinType: MoveStructId;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<number>;
     /**
-     * For a fee payer or multi-agent transaction that requires additional signers in
+     * Queries an account's owned objects
+     *
+     * @example
+     * const accountOwnedObjects = await aptos.getAccountOwnedObjects({accountAddress:"0x123"})
+     *
+     * @param args.accountAddress The account address we want to get the objects for
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @param args.options.offset The starting position to start returning results from
+     * @param args.options.limit The number of results to return
+     * @param args.options.orderBy The order to sort the objects by
+     * @returns Objects array with the object data
      */
-    secondarySignersPublicKeys?: Array<PublicKey>;
+    getAccountOwnedObjects(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & OrderByArg<GetAccountOwnedObjectsResponse[0]>;
+    }): Promise<GetAccountOwnedObjectsResponse>;
     /**
-     * For a fee payer transaction (aka Sponsored Transaction)
+     * 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.
+     *
+     * @example
+     * const account = await aptos.deriveAccountFromPrivateKey({privateKey:new Ed25519PrivateKey("0x123")})
+     *
+     * @param args.privateKey An account private key
+     * @returns Account type
      */
-    feePayerPublicKey?: PublicKey;
-    options?: InputSimulateTransactionOptions;
-};
-type InputSimulateTransactionOptions = {
-    estimateGasUnitPrice?: boolean;
-    estimateMaxGasAmount?: boolean;
-    estimatePrioritizedGasUnitPrice?: boolean;
-};
-/**
- * Interface that holds the user data input when generating a single signer transaction
- */
-interface InputGenerateSingleSignerRawTransactionData {
-    sender: AccountAddressInput;
-    data: InputGenerateTransactionPayloadData;
-    options?: InputGenerateTransactionOptions;
-    withFeePayer?: boolean;
-    secondarySignerAddresses?: undefined;
-}
-/**
- * Interface that holds the user data input when generating a multi-agent transaction
- */
-interface InputGenerateMultiAgentRawTransactionData {
-    sender: AccountAddressInput;
-    data: InputGenerateTransactionPayloadData;
-    secondarySignerAddresses: AccountAddressInput[];
-    options?: InputGenerateTransactionOptions;
-    withFeePayer?: boolean;
-}
-/**
- * Unified type that holds all the user data input interfaces when generating different transaction types
- */
-type InputGenerateTransactionData = InputGenerateSingleSignerRawTransactionData | InputGenerateMultiAgentRawTransactionData;
-/**
- * Interface that holds the user data input when submitting a transaction
- */
-interface InputSubmitTransactionData {
-    transaction: AnyRawTransaction;
-    senderAuthenticator: AccountAuthenticator;
-    feePayerAuthenticator?: AccountAuthenticator;
-    additionalSignersAuthenticators?: Array<AccountAuthenticator>;
+    deriveAccountFromPrivateKey(args: {
+        privateKey: PrivateKey;
+    }): Promise<Account$1>;
 }
 
 /**
@@ -5156,6 +5613,13 @@ declare class Coin {
     /**
      * Generate a transfer coin transaction that can be simulated and/or signed and submitted
      *
+     * @example
+     * const transferCoinTransaction = await aptos.transferCoinTransaction({
+     * sender: "0x123",
+     * recipient:"0x456",
+     * amount: 10,
+     * })
+     *
      * @param args.sender The sender account
      * @param args.recipient The recipient address
      * @param args.amount The amount to transfer
@@ -5220,6 +5684,9 @@ declare class DigitalAsset {
      * If, for some reason, a creator account has 2 collections with the same name in v1 and v2,
      * can pass an optional `tokenStandard` parameter to query a specific standard
      *
+     * @example
+     * const collection = await aptos.getCollectionData({creatorAddress:"0x123",collectionName:"myCollection"})
+     *
      * @param args.creatorAddress the address of the collection's creator
      * @param args.collectionName the name of the collection
      * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
@@ -5235,6 +5702,9 @@ declare class DigitalAsset {
     /**
      * Queries data of a specific collection by the collection ID.
      *
+     * @example
+     * const collection = await aptos.getCollectionDataByCollectionId({collectionId:"0x123"})
+     *
      * @param args.collectionId the ID of the collection, it's the same thing as the address of the collection object
      * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @returns GetCollectionDataResponse response type
@@ -5249,6 +5719,9 @@ declare class DigitalAsset {
      * This is the same as the collection's object address in V2, but V1 does
      * not use objects, and does not have an address
      *
+     * @example
+     * const collection = await aptos.getCollectionId({creatorAddress:"0x123",collectionName:"myCollection"})
+     *
      * @param args.creatorAddress the address of the collection's creator
      * @param args.collectionName the name of the collection
      * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
@@ -5264,6 +5737,9 @@ declare class DigitalAsset {
     /**
      * Gets digital asset data given the address of a digital asset.
      *
+     * @example
+     * const digitalAsset = await aptos.getDigitalAssetData({digitalAssetAddress:"0x123"})
+     *
      * @param args.tokenAddress The address of the digital asset
      * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @returns GetTokenDataResponse containing relevant data to the digital asset.
@@ -5275,6 +5751,9 @@ declare class DigitalAsset {
     /**
      * Gets digital asset ownership data given the address of a digital asset.
      *
+     * @example
+     * const digitalAssetOwner = await aptos.getCurrentDigitalAssetOwnership({digitalAssetAddress:"0x123"})
+     *
      * @param args.tokenAddress The address of the digital asset
      * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      *
@@ -5287,6 +5766,9 @@ declare class DigitalAsset {
     /**
      * Gets the digital assets that the given address owns.
      *
+     * @example
+     * const digitalAssets = await aptos.getOwnedDigitalAssets({ownerAddress:"0x123"})
+     *
      * @param args.ownerAddress The address of the owner
      * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      *
@@ -5300,6 +5782,9 @@ declare class DigitalAsset {
     /**
      * Gets the activity data given the address of a digital asset.
      *
+     * @example
+     * const digitalAssetActivity = await aptos.getDigitalAssetActivity({digitalAssetAddress:"0x123"})
+     *
      * @param args.tokenAddress The address of the digital asset
      * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      *
@@ -5313,6 +5798,14 @@ declare class DigitalAsset {
     /**
      * Creates a new collection within the specified account
      *
+     * @example
+     * const transaction = await aptos.createCollectionTransaction({
+     *  creator: alice,
+     *  description: "collectionDescription",
+     *  name: "collectionName",
+     *  uri: "collection-uri.com",
+     * });
+     *
      * @param args.creator the account of the collection's creator
      * @param args.description the description of the collection
      * @param args.name the name of the collection
@@ -5346,6 +5839,15 @@ declare class DigitalAsset {
     /**
      * Create a transaction to mint a digital asset into the creators account within an existing collection.
      *
+     * @example
+     * const transaction = await aptos.mintDigitalAssetTransaction({
+     *  creator: alice,
+     *  description: "collectionDescription",
+     *  collection: "collectionName",
+     *  name: "digitalAssetName",
+     *  uri: "digital-asset-uri.com",
+     * });
+     *
      * @param args.creator the creator of the collection
      * @param args.collection the name of the collection the digital asset belongs to
      * @param args.description the description of the digital asset
@@ -5371,6 +5873,13 @@ declare class DigitalAsset {
      * We can transfer a digital asset only when the digital asset is not frozen
      * (i.e. owner transfer is not disabled such as for soul bound digital assets)
      *
+     * @example
+     * const transaction = await aptos.transferDigitalAssetTransaction({
+     *  sender: alice,
+     *  digitalAssetAddress: "0x123",
+     *  recipient: "0x456",
+     * });
+     *
      * @param args.sender The sender account of the current digital asset owner
      * @param args.digitalAssetAddress The digital asset address
      * @param args.recipient The recipient account address
@@ -5388,6 +5897,16 @@ declare class DigitalAsset {
     /**
      * Mint a soul bound digital asset into a recipient's account
      *
+     * @example
+     * const transaction = await aptos.mintSoulBoundTransaction({
+     *  account: alice,
+     *  collection: "collectionName",
+     *  description: "collectionDescription",
+     *  name: "digitalAssetName",
+     *  uri: "digital-asset-uri.com",
+     *  recipient: "0x123"
+     * });
+     *
      * @param args.account The account that mints the digital asset
      * @param args.collection The collection name that the digital asset belongs to
      * @param args.description The digital asset description
@@ -5406,7 +5925,7 @@ declare class DigitalAsset {
         description: string;
         name: string;
         uri: string;
-        recipient: AccountAddress;
+        recipient: AccountAddressInput;
         propertyKeys?: Array<string>;
         propertyTypes?: Array<PropertyType>;
         propertyValues?: Array<PropertyValue>;
@@ -5415,6 +5934,12 @@ declare class DigitalAsset {
     /**
      * Burn a digital asset by its creator
      *
+     * @example
+     * const transaction = await aptos.burnDigitalAssetTransaction({
+     *  creator: alice,
+     *  digitalAssetAddress: "0x123",
+     * });
+     *
      * @param args.creator The creator account
      * @param args.digitalAssetAddress The digital asset address
      *
@@ -5429,6 +5954,12 @@ declare class DigitalAsset {
     /**
      * Freeze digital asset transfer ability
      *
+     * @example
+     * const transaction = await aptos.freezeDigitalAssetTransaferTransaction({
+     *  creator: alice,
+     *  digitalAssetAddress: "0x123",
+     * });
+     *
      * @param args.creator The creator account
      * @param args.digitalAssetAddress The digital asset address
      *
@@ -5443,6 +5974,12 @@ declare class DigitalAsset {
     /**
      * Unfreeze digital asset transfer ability
      *
+     * @example
+     * const transaction = await aptos.unfreezeDigitalAssetTransaferTransaction({
+     *  creator: alice,
+     *  digitalAssetAddress: "0x123",
+     * });
+     *
      * @param args.creator The creator account
      * @param args.digitalAssetAddress The digital asset address
      *
@@ -5457,6 +5994,13 @@ declare class DigitalAsset {
     /**
      * Set the digital asset description
      *
+     * @example
+     * const transaction = await aptos.setDigitalAssetDescriptionTransaction({
+     *  creator: alice,
+     *  description: "digitalAssetDescription",
+     *  digitalAssetAddress: "0x123",
+     * });
+     *
      * @param args.creator The creator account
      * @param args.description The digital asset description
      * @param args.digitalAssetAddress The digital asset address
@@ -5473,6 +6017,13 @@ declare class DigitalAsset {
     /**
      * Set the digital asset name
      *
+     * @example
+     * const transaction = await aptos.setDigitalAssetNameTransaction({
+     *  creator: alice,
+     *  name: "digitalAssetName",
+     *  digitalAssetAddress: "0x123",
+     * });
+     *
      * @param args.creator The creator account
      * @param args.name The digital asset name
      * @param args.digitalAssetAddress The digital asset address
@@ -5489,6 +6040,13 @@ declare class DigitalAsset {
     /**
      * Set the digital asset name
      *
+     * @example
+     * const transaction = await aptos.setDigitalAssetURITransaction({
+     *  creator: alice,
+     *  uri: "digital-asset-uri.com",
+     *  digitalAssetAddress: "0x123",
+     * });
+     *
      * @param args.creator The creator account
      * @param args.uri The digital asset uri
      * @param args.digitalAssetAddress The digital asset address
@@ -5505,6 +6063,15 @@ declare class DigitalAsset {
     /**
      * Add a digital asset property
      *
+     * @example
+     * const transaction = await aptos.addDigitalAssetPropertyTransaction({
+     *  creator: alice,
+     *  propertyKey: "newKey",
+     *  propertyType: "BOOLEAN",
+     *  propertyValue: true,
+     *  digitalAssetAddress: "0x123",
+     * });
+     *
      * @param args.account The account that mints the digital asset
      * @param args.digitalAssetAddress The digital asset address
      * @param args.propertyKey The property key for storing on-chain properties
@@ -5525,6 +6092,15 @@ declare class DigitalAsset {
     /**
      * Remove a digital asset property
      *
+     * @example
+     * const transaction = await aptos.removeDigitalAssetPropertyTransaction({
+     *  creator: alice,
+     *  propertyKey: "newKey",
+     *  propertyType: "BOOLEAN",
+     *  propertyValue: true,
+     *  digitalAssetAddress: "0x123",
+     * });
+     *
      * @param args.account The account that mints the digital asset
      * @param args.digitalAssetAddress The digital asset address
      * @param args.propertyKey The property key for storing on-chain properties
@@ -5545,6 +6121,15 @@ declare class DigitalAsset {
     /**
      * Update a digital asset property
      *
+     * @example
+     * const transaction = await aptos.updateDigitalAssetPropertyTransaction({
+     *  creator: alice,
+     *  propertyKey: "newKey",
+     *  propertyType: "BOOLEAN",
+     *  propertyValue: false,
+     *  digitalAssetAddress: "0x123",
+     * });
+     *
      * @param args.account The account that mints the digital asset
      * @param args.digitalAssetAddress The digital asset address
      * @param args.propertyKey The property key for storing on-chain properties
@@ -5565,6 +6150,15 @@ declare class DigitalAsset {
     /**
      * Add a typed digital asset property
      *
+     * @example
+     * const transaction = await aptos.addDigitalAssetTypedPropertyTransaction({
+     *  creator: alice,
+     *  propertyKey: "typedKey",
+     *  propertyType: "STRING",
+     *  propertyValue: "hello",
+     *  digitalAssetAddress: "0x123",
+     * });
+     *
      * @param args.account The account that mints the digital asset
      * @param args.digitalAssetAddress The digital asset address
      * @param args.propertyKey The property key for storing on-chain properties
@@ -5585,6 +6179,15 @@ declare class DigitalAsset {
     /**
      * Update a typed digital asset property
      *
+     * @example
+     * const transaction = await aptos.updateDigitalAssetTypedPropertyTransaction({
+     *  creator: alice,
+     *  propertyKey: "typedKey",
+     *  propertyType: "U8",
+     *  propertyValue: 2,
+     *  digitalAssetAddress: "0x123",
+     * });
+     *
      * @param args.account The account that mints the digital asset
      * @param args.digitalAssetAddress The digital asset address
      * @param args.propertyKey The property key for storing on-chain properties
@@ -5613,6 +6216,9 @@ declare class Event {
     /**
      * Get module events by event type
      *
+     * @example
+     * const events = await aptos.getModuleEventsByEventType({eventType:"0x1::transaction_fee::FeeStatement"})
+     *
      * @param args.eventType - The event type
      * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      *
@@ -5626,6 +6232,9 @@ declare class Event {
     /**
      * Get events by creation number and an account address
      *
+     * @example
+     * const events = await aptos.getAccountEventsByCreationNumber({accountAddress:"0x123",creationNumber: 0})
+     *
      * @param args.accountAddress - The account address
      * @param args.creationNumber - The event creation number
      * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
@@ -5640,6 +6249,9 @@ declare class Event {
     /**
      * Get events by event type and an account address
      *
+     * @example
+     * const events = await aptos.getAccountEventsByEventType({accountAddress:"0x123",eventType: "0x1::transaction_fee::FeeStatement"})
+     *
      * @param args.accountAddress - The account address
      * @param args.eventType - The event type
      * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
@@ -5656,15 +6268,11 @@ declare class Event {
      * Get all events
      *
      * An optional `where` can be passed in to filter out the response.
-     *@param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @example
-     * ```
-     * { where:
-     *  {
-     *   transaction_version: { _eq: 123456 },
-     *  }
-     * }
-     * ```
+     * const events = await aptos.getEvents()
+     * // with filtering
+     * const events = await aptos.getEvents({options: { where: { account_address: { _eq: "0x123" } } }});
      *
      * @returns GetEventsQuery response type
      */
@@ -5684,6 +6292,9 @@ declare class Faucet {
      * This creates an account if it does not exist and mints the specified amount of
      * coins into that account
      *
+     * @example
+     * const transaction = await aptos.fundAccount({accountAddress:"0x123", amount: 100})
+     *
      * @param args.accountAddress Address of the account to fund
      * @param args.amount Amount of tokens to fund the account with
      * @param args.options Configuration options for waitForTransaction
@@ -5778,18 +6389,6 @@ declare function buildTransaction(args: InputGenerateMultiAgentRawTransactionArg
  */
 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
  *
@@ -5810,14 +6409,6 @@ declare function hashValues(input: (Uint8Array | string)[]): Uint8Array;
  * @param args InputSubmitTransactionData
  */
 declare function generateUserTransactionHash(args: InputSubmitTransactionData): string;
-/**
- * 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
  *
@@ -5828,7 +6419,6 @@ declare function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTr
  * @returns A SignedTransaction
  */
 declare function generateMultiSignersSignedTransaction(transaction: MultiAgentRawTransaction | FeePayerRawTransaction, senderAuthenticator: AccountAuthenticator, feePayerAuthenticator?: AccountAuthenticator, additionalSignersAuthenticators?: Array<AccountAuthenticator>): Uint8Array;
-declare function generateSigningMessage(transaction: AnyRawTransaction): Uint8Array;
 
 /**
  * Convert type arguments to only type tags, allowing for string representations of type tags
@@ -5870,6 +6460,18 @@ declare function fetchViewFunctionAbi(moduleAddress: string, moduleName: string,
 declare function convertArgument(functionName: string, functionAbi: FunctionABI, arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes, position: number, genericTypeParams: Array<TypeTag>): EntryFunctionArgumentTypes;
 declare function checkOrConvertArgument(arg: SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes, param: TypeTag, position: number, genericTypeParams: Array<TypeTag>): EntryFunctionArgumentTypes;
 
+/**
+ * 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;
+declare function generateSigningMessage(bytes: Uint8Array, domainSeparator: string): Uint8Array;
+declare function generateSigningMessageForSerializable(obj: Serializable): Uint8Array;
+declare function generateSigningMessageForTransaction(transaction: AnyRawTransaction): Uint8Array;
+
 declare enum TypeTagParserErrorType {
     InvalidTypeTag = "unknown type",
     UnexpectedGenericType = "unexpected generic type",
@@ -5912,7 +6514,11 @@ declare class FungibleAsset {
     /**
      * Queries all fungible asset metadata.
      *
+     * @example
+     * const fungibleAsset = await aptos.getFungibleAssetMetadata()
+     *
      * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @param args.options Optional configuration for pagination and filtering
      *
      * @returns A list of fungible asset metadata
      */
@@ -5925,6 +6531,9 @@ declare class FungibleAsset {
      *
      * This query returns the fungible asset metadata for a specific fungible asset.
      *
+     * @example
+     * const fungibleAsset = await aptos.getFungibleAssetMetadataByAssetType({assetType:"0x123::test_coin::TestCoin"})
+     *
      * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @param args.assetType The asset type of the fungible asset.
      * e.g
@@ -5940,7 +6549,11 @@ declare class FungibleAsset {
     /**
      * Queries all fungible asset activities
      *
+     * @example
+     * const fungibleAssetActivities = await aptos.getFungibleAssetActivities()
+     *
      * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @param args.options Optional configuration for pagination and filtering
      *
      * @returns A list of fungible asset metadata
      */
@@ -5951,7 +6564,11 @@ declare class FungibleAsset {
     /**
      * Queries all fungible asset balances
      *
+     * @example
+     * const fungibleAssetBalances = await aptos.getCurrentFungibleAssetBalances()
+     *
      * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @param args.options Optional configuration for pagination and filtering
      *
      * @returns A list of fungible asset metadata
      */
@@ -5960,10 +6577,18 @@ declare class FungibleAsset {
         options?: PaginationArgs & WhereArg<CurrentFungibleAssetBalancesBoolExp>;
     }): Promise<GetCurrentFungibleAssetBalancesResponse>;
     /**
-     *  Transfer `amount` of fungible asset from sender's primary store to recipient's primary store.
+     * Transfer `amount` of fungible asset from sender's primary store to recipient's primary store.
      *
      * Use this method to transfer any fungible asset including fungible token.
      *
+     * @example
+     * const transaction = await aptos.transferFungibleAsset({
+     *  sender: alice,
+     *  fungibleAssetMetadataAddress: "0x123",
+     *  recipient: "0x456",
+     *  amount: 5
+     * })
+     *
      * @param sender The sender account
      * @param fungibleAssetMetadataAddress The fungible asset account address.
      * For example if you’re transferring USDT this would be the USDT address
@@ -5974,8 +6599,8 @@ declare class FungibleAsset {
      */
     transferFungibleAsset(args: {
         sender: Account$1;
-        fungibleAssetMetadataAddress: AccountAddress;
-        recipient: AccountAddress;
+        fungibleAssetMetadataAddress: AccountAddressInput;
+        recipient: AccountAddressInput;
         amount: AnyNumber;
         options?: InputGenerateTransactionOptions;
     }): Promise<SimpleTransaction>;
@@ -5992,7 +6617,9 @@ declare class General {
      *
      * @returns Aptos Ledger Info
      *
-     * @example An example of the returned data
+     * @example
+     * const ledgerInfo = await aptos.getLedgerInfo()
+     * // an example of the returned data
      * ```
      * {
      * "chain_id": 4,
@@ -6011,12 +6638,18 @@ declare class General {
     /**
      * Queries for the chain id
      *
+     * @example
+     * const chainId = await aptos.getChainId()
+     *
      * @returns The chain id
      */
     getChainId(): Promise<number>;
     /**
      * Queries for block by transaction version
      *
+     * @example
+     * const block = await aptos.getBlockByVersion({ledgerVersion:5})
+     *
      * @param args.ledgerVersion Ledger version to lookup block information for
      * @param args.options.withTransactions If set to true, include all transactions in the block
      *
@@ -6031,6 +6664,9 @@ declare class General {
     /**
      * Get block by block height
      *
+     * @example
+     * const block = await aptos.getBlockByVersion({blockHeight:5})
+     *
      * @param args.blockHeight Block height to lookup.  Starts at 0
      * @param args.options.withTransactions If set to true, include all transactions in the block
      *
@@ -6045,17 +6681,21 @@ declare class General {
     /**
      * Queries for a table item for a table identified by the handle and the key for the item.
      * Key and value types need to be passed in to help with key serialization and value deserialization.
+     *
+     * @example https://api.devnet.aptoslabs.com/v1/accounts/0x1/resource/0x1::coin::CoinInfo%3C0x1::aptos_coin::AptosCoin%3E
+     * const tableItem = await aptos.getTableItem({
+     *  handle: "0x123",
+     *  data: {
+     *   key_type: "address", // Move type of table key
+     *   value_type: "u128", // Move type of table value
+     *   key: "0x619dc29a0aac8fa146714058e8dd6d2d0f3bdf5f6331907bf91f3acd81e6935" // Value of table key
+     *  },
+     * })
+     *
      * @param args.handle A pointer to where that table is stored
      * @param args.data Object that describes table item
      * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
      *
-     * @example https://api.devnet.aptoslabs.com/v1/accounts/0x1/resource/0x1::coin::CoinInfo%3C0x1::aptos_coin::AptosCoin%3E
-     * {
-     *  data.key_type = "address" // Move type of table key
-     *  data.value_type = "u128" // Move type of table value
-     *  data.key = "0x619dc29a0aac8fa146714058e8dd6d2d0f3bdf5f6331907bf91f3acd81e6935" // Value of table key
-     * }
-     *
      * @returns Table item value rendered in JSON
      */
     getTableItem<T>(args: {
@@ -6067,14 +6707,15 @@ declare class General {
      * Queries for a Move view function
      * @param args.payload Payload for the view function
      * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
+     *
      * @example
-     * `
-     * const payload: ViewRequest = {
-     *  function: "0x1::coin::balance",
-     *  typeArguments: ["0x1::aptos_coin::AptosCoin"],
-     *  functionArguments: [accountAddress],
-     * };
-     * `
+     * const data = await aptos.view({
+     *  payload: {
+     *   function: "0x1::coin::balance",
+     *   typeArguments: ["0x1::aptos_coin::AptosCoin"],
+     *   functionArguments: [accountAddress],
+     *  }
+     * })
      *
      * @returns an array of Move values
      */
@@ -6085,6 +6726,9 @@ declare class General {
     /**
      * Queries top user transactions
      *
+     * @example
+     * const topUserTransactions = await aptos.getChainTopUserTransactions({limit:5})
+     *
      * @param args.limit The number of transactions to return
      * @returns GetChainTopUserTransactionsResponse
      */
@@ -6096,18 +6740,16 @@ declare class General {
      * For more detailed queries specification see
      * {@link https://cloud.hasura.io/public/graphiql?endpoint=https://api.mainnet.aptoslabs.com/v1/graphql}
      *
-     * @param args.query.query A GraphQL query
-     * @param args.query.variables The variables for the query
      * @example
-     * ```
-     * {
+     * const topUserTransactions = await aptos.queryIndexer({
      *  query: `query MyQuery {
-          ledger_infos {
-            chain_id
-          }
-        }`;
-     * }
-     * ```
+     *   ledger_infos {
+     *     chain_id
+     *   }}`;
+     * })
+     *
+     * @param args.query.query A GraphQL query
+     * @param args.query.variables The variables for the query
      *
      * @return The provided T type
      */
@@ -6118,11 +6760,17 @@ declare class General {
      * Queries for the last successful indexer version
      *
      * This is useful to tell what ledger version the indexer is updated to, as it can be behind the full nodes.
+     *
+     * @example
+     * const version = await aptos.getIndexerLastSuccessVersion()
      */
     getIndexerLastSuccessVersion(): Promise<bigint>;
     /**
      * Query the processor status for a specific processor type.
      *
+     * @example
+     * const status = await aptos.getProcessorStatus({processorType:"account_transactions_processor"})
+     *
      * @param processorType The processor type to query
      * @returns
      */
@@ -6179,11 +6827,10 @@ declare class ANS {
     /**
      * Retrieve the owner address of a domain name or subdomain name from the contract.
      *
-     * ```ts
+     * @example
      * // Will return the owner address of "test.aptos.apt" or undefined
      * const owner = await aptos.getOwnerAddress({name: "test.aptos"})
      * // owner = 0x123...
-     * ```
      *
      * @param args.name - A string of the name to retrieve
      *
@@ -6195,11 +6842,10 @@ declare class ANS {
     /**
      * Retrieve the expiration time of a domain name or subdomain name from the contract.
      *
-     * ```ts
+     * @example
      * // Will return the expiration of "test.aptos.apt" or undefined
      * const exp = await aptos.getExpiration({name: "test.aptos"})
      * // new Date(exp) would give you the date in question: 2021-01-01T00:00:00.000Z
-     * ```
      *
      * @param args.name - A string of the name to retrieve
      *
@@ -6213,10 +6859,9 @@ declare class ANS {
      * address the name points to for use on chain. Note, the target address can
      * point to addresses that are not the owner of the name
      *
-     * ```ts
+     * @example
      * const targetAddr = await aptos.getTargetAddress({name: "test.aptos"})
      * // targetAddr = 0x123...
-     * ```
      *
      * @param args.name - A string of the name: primary, primary.apt, secondary.primary, secondary.primary.apt, etc.
      *
@@ -6230,11 +6875,10 @@ declare class ANS {
      * address the name points to for use on chain. Note, the target address can
      * point to addresses that are not the owner of the name
      *
-     * ```ts
+     * @example
      * await aptos.setTargetAddress({sender: alice, name: "test.aptos", address: bob.accountAddress})
      * const address = await aptos.getTargetAddress({name: "test.aptos"})
      * // address = bob.accountAddress
-     * ```
      *
      * @param args.name - A string of the name: test.aptos.apt, test.apt, test, test.aptos, etc.
      * @param args.address - A AccountAddressInput of the address to set the domain or subdomain to
@@ -6252,10 +6896,9 @@ declare class ANS {
      * multiple names that target it, but only a single name that is primary. An
      * account also may not have a primary name.
      *
-     * ```ts
+     * @example
      * const name = await aptos.getPrimaryName({address: alice.accountAddress})
      * // name = test.aptos
-     * ```
      *
      * @param args.address - A AccountAddressInput (address) of the account
      *
@@ -6269,11 +6912,10 @@ declare class ANS {
      * multiple names that target it, but only a single name that is primary. An
      * account also may not have a primary name.
      *
-     * ```ts
+     * @example
      * await aptos.setPrimaryName({sender: alice, name: "test.aptos"})
      * const primaryName = await aptos.getPrimaryName({address: alice.accountAddress})
      * // primaryName = test.aptos
-     * ```
      *
      * @param args.sender - The sender account
      * @param args.name - A string of the name: test, test.apt, test.aptos, test.aptos.apt, etc.
@@ -6288,7 +6930,7 @@ declare class ANS {
     /**
      * Registers a new name
      *
-     * ```ts
+     * @example
      * // An example of registering a subdomain name assuming def.apt is already registered
      * // and belongs to the sender alice.
      *  const txn = aptos.registerName({
@@ -6299,7 +6941,6 @@ declare class ANS {
      *      expirationDate: Date.now() + 30 * 24 * 60 * 60 * 1000,
      *    },
      *  });
-     * ```
      *
      * @param args.sender - The sender account
      * @param args.name - A string of the name to register. This can be inclusive or exclusive of the .apt suffix.
@@ -6326,10 +6967,9 @@ declare class ANS {
      *
      * Note: If a domain name was minted with V1 of the contract, it will automatically be upgraded to V2 via this transaction.
      *
-     * ```ts
+     * @example
      * await aptos.renewDomain({sender: alice, name: "test"})
      * // test.apt will be renewed for one year
-     * ```
      *
      * @param args.sender - The sender account
      * @param args.name - A string of the domain the subdomain will be under. The signer must be the domain owner.
@@ -6418,6 +7058,9 @@ declare class Staking {
     /**
      * Queries current number of delegators in a pool.  Throws an error if the pool is not found.
      *
+     * @example
+     * const delegators = await aptos.getNumberOfDelegators({poolAddress:"0x123"})
+     *
      * @param args.poolAddress Pool address
      * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @returns The number of delegators for the given pool
@@ -6429,6 +7072,9 @@ declare class Staking {
     /**
      * Queries current number of delegators in a pool.  Throws an error if the pool is not found.
      *
+     * @example
+     * const delegators = await aptos.getNumberOfDelegatorsForAllPools()
+     *
      * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @returns GetNumberOfDelegatorsForAllPoolsResponse response type
      */
@@ -6439,6 +7085,9 @@ declare class Staking {
     /**
      * Queries delegated staking activities
      *
+     * @example
+     * const delegators = await aptos.getDelegatedStakingActivities({delegatorAddress:"0x123",poolAddress:"0x456"})
+     *
      * @param args.delegatorAddress Delegator address
      * @param args.poolAddress Pool address
      * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
@@ -6889,6 +7538,9 @@ declare class Transaction {
      * Queries on-chain transactions. This function will not return pending
      * transactions. For that, use `getTransactionsByHash`.
      *
+     * @example
+     * const transactions = await aptos.getTransactions()
+     *
      * @param args.options.offset The number transaction to start with
      * @param args.options.limit Number of results to return
      *
@@ -6900,6 +7552,9 @@ declare class Transaction {
     /**
      * Queries on-chain transaction by version. This function will not return pending transactions.
      *
+     * @example
+     * const transaction = await aptos.getTransactions({ledgerVersion:1})
+     *
      * @param args.ledgerVersion - Transaction version is an unsigned 64-bit number.
      * @returns On-chain transaction. Only on-chain transactions have versions, so this
      * function cannot be used to query pending transactions.
@@ -6909,6 +7564,10 @@ declare class Transaction {
     }): Promise<TransactionResponse>;
     /**
      * Queries on-chain transaction by transaction hash. This function will return pending transactions.
+     *
+     * @example
+     * const transaction = await aptos.getTransactionByHash({transactionHash:"0x123"})
+     *
      * @param args.transactionHash - Transaction hash should be hex-encoded bytes string with 0x prefix.
      * @returns Transaction from mempool (pending) or on-chain (committed) transaction
      */
@@ -6924,6 +7583,9 @@ declare class Transaction {
      * 2. Apply hash algorithm SHA3-256 to the hash message bytes.
      * 3. Hex-encode the hash bytes with 0x prefix.
      *
+     * @example
+     * const isPendingTransaction = await aptos.isPendingTransaction({transactionHash:"0x123"})
+     *
      * @param args.transactionHash A hash of transaction
      * @returns `true` if transaction is in pending state and `false` otherwise
      */
@@ -6945,6 +7607,8 @@ declare class Transaction {
      * 4. Transaction does not move past the pending state within `args.options.timeoutSecs` seconds.
      *    - The function will throw a WaitForTransactionError
      *
+     * @example
+     * const transaction = await aptos.waitForTransaction({transactionHash:"0x123"})
      *
      * @param args.transactionHash The hash of a transaction previously submitted to the blockchain.
      * @param args.options.timeoutSecs Timeout in seconds. Defaults to 20 seconds.
@@ -6962,14 +7626,9 @@ declare class Transaction {
      * For more information {@link https://api.mainnet.aptoslabs.com/v1/spec#/operations/estimate_gas_price}
      *
      * @returns Object holding the outputs of the estimate gas API
+     *
      * @example
-     * ```
-     * {
-     *  gas_estimate: number;
-     *  deprioritized_gas_estimate?: number;
-     *  prioritized_gas_estimate?: number;
-     * }
-     * ```
+     * const gasPrice = await aptos.waitForTransaction()
      */
     getGasPriceEstimation(): Promise<GasEstimation>;
     /**
@@ -6977,6 +7636,11 @@ declare class Transaction {
      *
      * This allows a user to sign a transaction using their own preferred signing method, and
      * then submit it to the network.
+     *
+     * @example
+     * const transaction = await aptos.transaction.build.simple({...})
+     * const message = await aptos.getSigningMessage({transaction})
+     *
      * @param args.transaction A raw transaction for signing elsewhere
      */
     getSigningMessage(args: {
@@ -6989,6 +7653,13 @@ declare class Transaction {
      * `aptos move compile --save-metadata ...`,
      * For more info {@link https://aptos.dev/tutorials/your-first-dapp/#step-4-publish-a-move-module}
      *
+     * @example
+     * const transaction = await aptos.publishPackageTransaction({
+     *  account: alice,
+     *  metadataBytes,
+     *  moduleBytecode: [byteCode],
+     * })
+     *
      * @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
@@ -7006,6 +7677,13 @@ declare class Transaction {
      * the account.
      * Note: Only legacy Ed25519 scheme is supported for now.
      * More info: {@link https://aptos.dev/guides/account-management/key-rotation/}
+     *
+     * @example
+     * const response = await aptos.rotateAuthKey({
+     *  fromAccount: alice,
+     *  toNewPrivateKey: new ED25519PublicKey("0x123"),
+     * })
+     *
      * @param args.fromAccount The account to rotate the auth key for
      * @param args.toNewPrivateKey The new private key to rotate to
      *
@@ -7018,6 +7696,13 @@ declare class Transaction {
     /**
      * Sign a transaction that can later be submitted to chain
      *
+     * @example
+     * const transaction = await aptos.transaction.build.simple({...})
+     * const transaction = await aptos.transaction.sign({
+     *  signer: alice,
+     *  transaction
+     * })
+     *
      * @param args.signer The signer account
      * @param args.transaction A raw transaction to sign on
      *
@@ -7030,6 +7715,13 @@ declare class Transaction {
     /**
      * Sign a transaction as a fee payer that can later be submitted to chain
      *
+     * @example
+     * const transaction = await aptos.transaction.build.simple({...})
+     * const transaction = await aptos.transaction.signAsFeePayer({
+     *  signer: alice,
+     *  transaction
+     * })
+     *
      * @param args.signer The fee payer signer account
      * @param args.transaction A raw transaction to sign on
      *
@@ -7067,13 +7759,13 @@ declare class Transaction {
      *
      * @param args.signer The signer account to sign the transaction
      * @param args.transaction An instance of a RawTransaction, plus optional secondary/fee payer addresses
-     * ```
-     * {
-     *  rawTransaction: RawTransaction,
-     *  secondarySignerAddresses? : Array<AccountAddress>,
-     *  feePayerAddress?: AccountAddress
-     * }
-     * ```
+     *
+     * @example
+     * const transaction = await aptos.transaction.build.simple({...})
+     * const transaction = await aptos.signAndSubmitTransaction({
+     *  signer: alice,
+     *  transaction
+     * })
      *
      * @return PendingTransactionResponse
      */
@@ -7083,12 +7775,50 @@ declare class Transaction {
     }): Promise<PendingTransactionResponse>;
 }
 
+interface BaseDeriveKeylessAccountArgs {
+    jwt: string;
+    ephemeralKeyPair: EphemeralKeyPair;
+    uidKey?: string;
+    pepper?: HexInput;
+    extraFieldKey?: string;
+    fetchProofAsync?: boolean;
+}
+interface DeriveKeylessAccountArgs extends BaseDeriveKeylessAccountArgs {
+    disableConnect: true;
+}
+interface DeriveKeylessAccountWithConnectArgs extends BaseDeriveKeylessAccountArgs {
+    disableConnect?: boolean;
+}
+/**
+ * A class to query all `OIDB` related queries on Aptos.
+ */
+declare class Keyless {
+    readonly config: AptosConfig;
+    constructor(config: AptosConfig);
+    /**
+     * TODO
+     *
+     * @param args.jwt jwt token
+     * @returns The pepper
+     */
+    getPepper(args: {
+        jwt: string;
+        ephemeralKeyPair: EphemeralKeyPair;
+    }): Promise<Uint8Array>;
+    deriveKeylessAccount(args: DeriveKeylessAccountArgs): Promise<KeylessAccount>;
+    deriveKeylessAccount(args: DeriveKeylessAccountWithConnectArgs): Promise<MultiKeyAccount>;
+}
+
 /**
  * This class is the main entry point into Aptos's
  * APIs and separates functionality into different namespaces.
  *
  * To use the SDK, create a new Aptos instance to get access
  * to all the sdk functionality.
+ *
+ * @example
+ *
+ * const aptos = new Aptos();
  */
 declare class Aptos {
     readonly config: AptosConfig;
@@ -7102,9 +7832,10 @@ declare class Aptos {
     readonly general: General;
     readonly staking: Staking;
     readonly transaction: Transaction;
+    readonly keyless: Keyless;
     constructor(settings?: AptosConfig);
 }
-interface Aptos extends Account, ANS, Coin, DigitalAsset, Event, Faucet, FungibleAsset, General, Staking, Omit<Transaction, "build" | "simulate" | "submit" | "batch"> {
+interface Aptos extends Account, ANS, Coin, DigitalAsset, Event, Faucet, FungibleAsset, General, Keyless, Staking, Omit<Transaction, "build" | "simulate" | "submit" | "batch"> {
 }
 
 /**
@@ -7203,6 +7934,7 @@ type GetAptosRequestOptions = Omit<GetRequestOptions, "type">;
  */
 declare function get<Req extends {}, Res extends {}>(options: GetRequestOptions): Promise<AptosResponse<Req, Res>>;
 declare function getAptosFullNode<Req extends {}, Res extends {}>(options: GetAptosRequestOptions): Promise<AptosResponse<Req, Res>>;
+declare function getAptosPepperService<Req extends {}, Res extends {}>(options: GetAptosRequestOptions): Promise<AptosResponse<Req, Res>>;
 declare function paginateWithCursor<Req extends Record<string, any>, Res extends Array<{}>>(options: GetAptosRequestOptions): Promise<Res>;
 
 type PostRequestOptions = {
@@ -7254,5 +7986,7 @@ declare function post<Req extends {}, Res extends {}>(options: PostRequestOption
 declare function postAptosFullNode<Req extends {}, Res extends {}>(options: PostAptosRequestOptions): Promise<AptosResponse<Req, Res>>;
 declare function postAptosIndexer<Req extends {}, Res extends {}>(options: PostAptosRequestOptions): Promise<AptosResponse<Req, Res>>;
 declare function postAptosFaucet<Req extends {}, Res extends {}>(options: PostAptosRequestOptions): Promise<AptosResponse<Req, Res>>;
+declare function postAptosPepperService<Req extends {}, Res extends {}>(options: PostAptosRequestOptions): Promise<AptosResponse<Req, Res>>;
+declare function postAptosProvingService<Req extends {}, Res extends {}>(options: PostAptosRequestOptions): Promise<AptosResponse<Req, Res>>;
 
-export { APTOS_BIP44_REGEX, APTOS_COIN, APTOS_HARDENED_REGEX, Account$1 as Account, AccountAddress, type AccountAddressInput, AccountAuthenticator, AccountAuthenticatorEd25519, AccountAuthenticatorMultiEd25519, AccountAuthenticatorMultiKey, AccountAuthenticatorSingleKey, AccountAuthenticatorVariant, type AccountData, AccountPublicKey, AccountSequenceNumber, type AccountSignature, AddressInvalidReason, type AnyNumber, AnyPublicKey, AnyPublicKeyVariant, type AnyRawTransaction, type AnyRawTransactionInstance, AnySignature, AnySignatureVariant, type AnyTransactionPayloadInstance, Aptos, AptosApiError, AptosApiType, AptosConfig, type AptosRequest, type AptosResponse, type AptosSettings, AuthenticationKey, type AuthenticationKeyScheme, type Block, type BlockMetadataTransactionResponse, Bool, CKDPriv, ChainId, type Client, type ClientConfig, type ClientHeadersType, type ClientRequest, type ClientResponse, type CommittedTransactionResponse, type CreateAccountFromPrivateKeyArgs, type CreateEd25519AccountFromPrivateKeyArgs, type CreateEd25519SingleKeyAccountFromPrivateKeyArgs, type CreateSingleKeyAccountFromPrivateKeyArgs, DEFAULT_MAX_GAS_AMOUNT, DEFAULT_TXN_EXP_SEC_FROM_NOW, DEFAULT_TXN_TIMEOUT_SEC, type DecodedTableData, type DeletedTableData, DeriveScheme, type DerivedKeys, type Deserializable, Deserializer, type DirectWriteSet, Ed25519Account, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, type Ed25519SignerConstructorArgs, type Ed25519SignerFromDerivationPathArgs, EntryFunction, type EntryFunctionABI, type EntryFunctionArgument, type EntryFunctionArgumentTypes, EntryFunctionBytes, type EntryFunctionPayloadResponse, type Event$1 as Event, type EventGuid, type ExecutionFinishEventData, type FailureEventData, type FaucetConfig, FeePayerRawTransaction, FixedBytes, type FullNodeConfig, type FunctionABI, type GasEstimation, type GenerateAccount, type GenerateAccountArgs, type GenerateAccountWithEd25519, type GenerateAccountWithSingleSignerSecp256k1Key, type GenerateEd25519AccountArgs, type GenerateEd25519SingleKeyAccountArgs, type GenerateSingleKeyAccountArgs, type GenesisPayload, type GenesisTransactionResponse, type GetANSNameResponse, type GetAccountCoinsDataResponse, type GetAccountCollectionsWithOwnedTokenResponse, type GetAccountOwnedObjectsResponse, type GetAccountOwnedTokensFromCollectionResponse, type GetAccountOwnedTokensQueryResponse, type GetAptosRequestOptions, type GetChainTopUserTransactionsResponse, type GetCollectionDataResponse, type GetCurrentFungibleAssetBalancesResponse, type GetCurrentTokenOwnershipResponse, type GetDelegatedStakingActivitiesResponse, type GetEventsResponse, type GetFungibleAssetActivitiesResponse, type GetFungibleAssetMetadataResponse, type GetNumberOfDelegatorsResponse, type GetOwnedTokensResponse, type GetProcessorStatusResponse, type GetRequestOptions, type GetTokenActivityResponse, type GetTokenDataResponse, type GraphqlQuery, HARDENED_OFFSET, Hex, type HexInput, HexInvalidReason, Identifier, type IndexerConfig, type InputEntryFunctionData, type InputEntryFunctionDataWithABI, type InputEntryFunctionDataWithRemoteABI, type InputGenerateMultiAgentRawTransactionArgs, type InputGenerateMultiAgentRawTransactionData, type InputGenerateRawTransactionArgs, type InputGenerateSingleSignerRawTransactionArgs, type InputGenerateSingleSignerRawTransactionData, type InputGenerateTransactionData, type InputGenerateTransactionOptions, type InputGenerateTransactionPayloadData, type InputGenerateTransactionPayloadDataWithABI, type InputGenerateTransactionPayloadDataWithRemoteABI, type InputMultiSigData, type InputMultiSigDataWithABI, type InputMultiSigDataWithRemoteABI, type InputScriptData, type InputSimulateTransactionData, type InputSimulateTransactionOptions, type InputSubmitTransactionData, type InputViewFunctionData, type InputViewFunctionDataWithABI, type InputViewFunctionDataWithRemoteABI, KeyType, type LedgerInfo, type LedgerVersionArg, MimeType, ModuleId, MoveAbility, type MoveAddressType, type MoveFunction, type MoveFunctionGenericTypeParam, type MoveFunctionId, MoveFunctionVisibility, type MoveModule, type MoveModuleBytecode, type MoveModuleId, type MoveObjectType, MoveOption, type MoveOptionType, type MoveResource, type MoveScriptBytecode, MoveString, type MoveStruct, type MoveStructField, type MoveStructId, type MoveStructType, type MoveType, type MoveUint128Type, type MoveUint16Type, type MoveUint256Type, type MoveUint32Type, type MoveUint64Type, type MoveUint8Type, type MoveValue, MoveVector, MultiAgentRawTransaction, MultiEd25519PublicKey, MultiEd25519Signature, MultiKey, MultiKeySignature, MultiSig, MultiSigTransactionPayload, type MultisigPayloadResponse, Network, NetworkToChainId, NetworkToFaucetAPI, NetworkToIndexerAPI, NetworkToNetworkName, NetworkToNodeAPI, type OrderBy, type OrderByArg, type OrderByValue, type PaginationArgs, ParsingError, type ParsingResult, type PendingTransactionResponse, type PostAptosRequestOptions, type PostRequestOptions, type PrivateKey, type PrivateKeyFromDerivationPathArgs, ProcessorType, PublicKey, RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT, RawTransaction, RawTransactionWithData, RoleType, RotationProofChallenge, Script, type ScriptFunctionArgument, type ScriptFunctionArgumentTypes, type ScriptPayloadResponse, ScriptTransactionArgumentVariants, type ScriptWriteSet, Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature, Serializable, Serializer, Signature, SignedTransaction, SigningScheme, SigningSchemeInput, type SimpleEntryFunctionArgumentTypes, SimpleTransaction, SingleKeyAccount, type SingleKeySignerConstructorArgs, type SingleKeySignerFromDerivationPathArgs, type SingleKeySignerGenerateArgs, type StateCheckpointTransactionResponse, StructTag, type SuccessEventData, type TableItemRequest, type TokenStandard, type TokenStandardArg, type TransactionArgument, TransactionAuthenticator, TransactionAuthenticatorEd25519, TransactionAuthenticatorFeePayer, TransactionAuthenticatorMultiAgent, TransactionAuthenticatorMultiEd25519, TransactionAuthenticatorSingleSender, TransactionAuthenticatorVariant, type TransactionEd25519Signature, type TransactionFeePayerSignature, type TransactionMultiAgentSignature, type TransactionMultiEd25519Signature, TransactionPayload, TransactionPayloadEntryFunction, TransactionPayloadMultiSig, type TransactionPayloadResponse, TransactionPayloadScript, TransactionPayloadVariants, type TransactionResponse, TransactionResponseType, type TransactionSecp256k1Signature, type TransactionSignature, TransactionVariants, TransactionWorker, type TransactionWorkerEvents, TransactionWorkerEventsEnum, TypeTag, TypeTagAddress, TypeTagBool, TypeTagGeneric, TypeTagParserError, TypeTagParserErrorType, TypeTagReference, TypeTagSigner, TypeTagStruct, TypeTagU128, TypeTagU16, TypeTagU256, TypeTagU32, TypeTagU64, TypeTagU8, TypeTagVariants, TypeTagVector, U128, U16, U256, U32, U64, U8, type Uint128, type Uint16, type Uint256, type Uint32, type Uint64, type Uint8, type UserTransactionResponse, type ValidatorTransactionResponse, type VerifyEd25519SignatureArgs, type VerifySignatureArgs, type VerifySingleKeySignatureArgs, type ViewFunctionABI, type WaitForTransactionOptions, type WhereArg, type WriteSet, type WriteSetChange, type WriteSetChangeDeleteModule, type WriteSetChangeDeleteResource, type WriteSetChangeDeleteTableItem, type WriteSetChangeWriteModule, type WriteSetChangeWriteResource, type WriteSetChangeWriteTableItem, aptosCoinStructTag, aptosRequest, buildTransaction, checkOrConvertArgument, convertArgument, createObjectAddress, createResourceAddress, createTokenAddress, deriveKey, deriveTransactionType, deserializeFromScriptArgument, ensureBoolean, fetchEntryFunctionAbi, fetchFunctionAbi, fetchViewFunctionAbi, findFirstNonSignerArg, generateMultiSignersSignedTransaction, generateRawTransaction, generateSignedTransaction, generateSignedTransactionForSimulation, generateSigningMessage, generateTransactionPayload, generateTransactionPayloadWithABI, generateUserTransactionHash, generateViewFunctionPayload, generateViewFunctionPayloadWithABI, get, getAptosFullNode, getAuthenticatorForSimulation, getFunctionParts, hashValues, isBcsAddress, isBcsBool, isBcsFixedBytes, isBcsString, isBcsU128, isBcsU16, isBcsU256, isBcsU32, isBcsU64, isBcsU8, isBlockMetadataTransactionResponse, isBool, isEd25519Signature, isEncodedEntryFunctionArgument, isFeePayerSignature, isGenesisTransactionResponse, isLargeNumber, isMultiAgentSignature, isMultiEd25519Signature, isNull, isNumber, isPendingTransactionResponse, isScriptDataInput, isSecp256k1Signature, isStateCheckpointTransactionResponse, isString, isUserTransactionResponse, isValidBIP44Path, isValidHardenedPath, isValidatorTransactionResponse, mnemonicToSeed, objectStructTag, optionStructTag, outOfRangeErrorMessage, paginateWithCursor, parseTypeTag, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, promiseFulfilledStatus, request, sign, splitPath, standardizeTypeTags, stringStructTag, throwTypeMismatch, validateNumberInRange };
+export { APTOS_BIP44_DEFAULT_DERIVATION_PATH, APTOS_BIP44_REGEX, APTOS_COIN, APTOS_HARDENED_REGEX, Account$1 as Account, AccountAddress, type AccountAddressInput, AccountAuthenticator, AccountAuthenticatorEd25519, AccountAuthenticatorMultiEd25519, AccountAuthenticatorMultiKey, AccountAuthenticatorSingleKey, AccountAuthenticatorVariant, type AccountData, AccountPublicKey, AccountSequenceNumber, type AccountSignature, AddressInvalidReason, type AnyNumber, AnyPublicKey, AnyPublicKeyVariant, type AnyRawTransaction, type AnyRawTransactionInstance, AnySignature, AnySignatureVariant, type AnyTransactionPayloadInstance, Aptos, AptosApiError, AptosApiType, AptosConfig, type AptosRequest, type AptosResponse, type AptosSettings, AuthenticationKey, type AuthenticationKeyScheme, type Block, type BlockMetadataTransactionResponse, Bool, CKDPriv, ChainId, type Client, type ClientConfig, type ClientHeadersType, type ClientRequest, type ClientResponse, type CommittedTransactionResponse, type CreateAccountFromPrivateKeyArgs, type CreateEd25519AccountFromPrivateKeyArgs, type CreateEd25519SingleKeyAccountFromPrivateKeyArgs, type CreateSingleKeyAccountFromPrivateKeyArgs, DEFAULT_MAX_GAS_AMOUNT, DEFAULT_TXN_EXP_SEC_FROM_NOW, DEFAULT_TXN_TIMEOUT_SEC, type DecodedTableData, type DeletedTableData, DeriveScheme, type DerivedKeys, type Deserializable, Deserializer, type DirectWriteSet, EPK_HORIZON_SECS, Ed25519Account, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, type Ed25519SignerConstructorArgs, type Ed25519SignerFromDerivationPathArgs, EntryFunction, type EntryFunctionABI, type EntryFunctionArgument, type EntryFunctionArgumentTypes, EntryFunctionBytes, type EntryFunctionPayloadResponse, EphemeralCertificate, EphemeralKeyPair, EphemeralPublicKey, EphemeralPublicKeyVariant, EphemeralSignature, EphemeralSignatureVariant, type Event$1 as Event, type EventGuid, type ExecutionFinishEventData, type FailureEventData, type FaucetConfig, FeePayerRawTransaction, FixedBytes, type FullNodeConfig, type FunctionABI, type GasEstimation, type GenerateAccount, type GenerateAccountArgs, type GenerateAccountWithEd25519, type GenerateAccountWithSingleSignerSecp256k1Key, type GenerateEd25519AccountArgs, type GenerateEd25519SingleKeyAccountArgs, type GenerateSingleKeyAccountArgs, type GenesisPayload, type GenesisTransactionResponse, type GetANSNameResponse, type GetAccountCoinsDataResponse, type GetAccountCollectionsWithOwnedTokenResponse, type GetAccountOwnedObjectsResponse, type GetAccountOwnedTokensFromCollectionResponse, type GetAccountOwnedTokensQueryResponse, type GetAptosRequestOptions, type GetChainTopUserTransactionsResponse, type GetCollectionDataResponse, type GetCurrentFungibleAssetBalancesResponse, type GetCurrentTokenOwnershipResponse, type GetDelegatedStakingActivitiesResponse, type GetEventsResponse, type GetFungibleAssetActivitiesResponse, type GetFungibleAssetMetadataResponse, type GetNumberOfDelegatorsResponse, type GetOwnedTokensResponse, type GetProcessorStatusResponse, type GetRequestOptions, type GetTokenActivityResponse, type GetTokenDataResponse, type GraphqlQuery, Groth16Zkp, HARDENED_OFFSET, Hex, type HexInput, HexInvalidReason, Identifier, type IndexerConfig, type InputEntryFunctionData, type InputEntryFunctionDataWithABI, type InputEntryFunctionDataWithRemoteABI, type InputGenerateMultiAgentRawTransactionArgs, type InputGenerateMultiAgentRawTransactionData, type InputGenerateRawTransactionArgs, type InputGenerateSingleSignerRawTransactionArgs, type InputGenerateSingleSignerRawTransactionData, type InputGenerateTransactionData, type InputGenerateTransactionOptions, type InputGenerateTransactionPayloadData, type InputGenerateTransactionPayloadDataWithABI, type InputGenerateTransactionPayloadDataWithRemoteABI, type InputMultiSigData, type InputMultiSigDataWithABI, type InputMultiSigDataWithRemoteABI, type InputScriptData, type InputSimulateTransactionData, type InputSimulateTransactionOptions, type InputSubmitTransactionData, type InputViewFunctionData, type InputViewFunctionDataWithABI, type InputViewFunctionDataWithRemoteABI, KeyType, KeylessAccount, KeylessPublicKey, KeylessSignature, type LedgerInfo, type LedgerVersionArg, MAX_AUD_VAL_BYTES, MAX_COMMITED_EPK_BYTES, MAX_EXTRA_FIELD_BYTES, MAX_ISS_VAL_BYTES, MAX_JWT_HEADER_B64_BYTES, MAX_UID_KEY_BYTES, MAX_UID_VAL_BYTES, MimeType, ModuleId, MoveAbility, type MoveAddressType, type MoveFunction, type MoveFunctionGenericTypeParam, type MoveFunctionId, MoveFunctionVisibility, type MoveModule, type MoveModuleBytecode, type MoveModuleId, type MoveObjectType, MoveOption, type MoveOptionType, type MoveResource, type MoveScriptBytecode, MoveString, type MoveStruct, type MoveStructField, type MoveStructId, type MoveStructType, type MoveType, type MoveUint128Type, type MoveUint16Type, type MoveUint256Type, type MoveUint32Type, type MoveUint64Type, type MoveUint8Type, type MoveValue, MoveVector, MultiAgentRawTransaction, MultiEd25519PublicKey, MultiEd25519Signature, MultiKey, MultiKeyAccount, MultiSig, MultiSigTransactionPayload, MultiSignature, type MultisigPayloadResponse, Network, NetworkToChainId, NetworkToFaucetAPI, NetworkToIndexerAPI, NetworkToNetworkName, NetworkToNodeAPI, NetworkToPepperAPI, NetworkToProverAPI, OpenIdSignature, OpenIdSignatureOrZkProof, type OrderBy, type OrderByArg, type OrderByValue, type PaginationArgs, ParsingError, type ParsingResult, type PendingTransactionResponse, type PostAptosRequestOptions, type PostRequestOptions, type PrivateKey, type PrivateKeyFromDerivationPathArgs, ProcessorType, PublicKey, RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT, RawTransaction, RawTransactionWithData, RoleType, RotationProofChallenge, Script, type ScriptFunctionArgument, type ScriptFunctionArgumentTypes, type ScriptPayloadResponse, ScriptTransactionArgumentVariants, type ScriptWriteSet, Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature, Serializable, Serializer, Signature, SignedGroth16Signature, SignedTransaction, SigningScheme, SigningSchemeInput, type SimpleEntryFunctionArgumentTypes, SimpleTransaction, SingleKeyAccount, type SingleKeySignerConstructorArgs, type SingleKeySignerFromDerivationPathArgs, type SingleKeySignerGenerateArgs, type StateCheckpointTransactionResponse, StructTag, type SuccessEventData, type TableItemRequest, type TokenStandard, type TokenStandardArg, type TransactionArgument, TransactionAuthenticator, TransactionAuthenticatorEd25519, TransactionAuthenticatorFeePayer, TransactionAuthenticatorMultiAgent, TransactionAuthenticatorMultiEd25519, TransactionAuthenticatorSingleSender, TransactionAuthenticatorVariant, type TransactionEd25519Signature, type TransactionFeePayerSignature, type TransactionMultiAgentSignature, type TransactionMultiEd25519Signature, TransactionPayload, TransactionPayloadEntryFunction, TransactionPayloadMultiSig, type TransactionPayloadResponse, TransactionPayloadScript, TransactionPayloadVariants, type TransactionResponse, TransactionResponseType, type TransactionSecp256k1Signature, type TransactionSignature, TransactionVariants, TransactionWorker, type TransactionWorkerEvents, TransactionWorkerEventsEnum, TypeTag, TypeTagAddress, TypeTagBool, TypeTagGeneric, TypeTagParserError, TypeTagParserErrorType, TypeTagReference, TypeTagSigner, TypeTagStruct, TypeTagU128, TypeTagU16, TypeTagU256, TypeTagU32, TypeTagU64, TypeTagU8, TypeTagVariants, TypeTagVector, U128, U16, U256, U32, U64, U8, type Uint128, type Uint16, type Uint256, type Uint32, type Uint64, type Uint8, type UserTransactionResponse, type ValidatorTransactionResponse, type VerifyEd25519SignatureArgs, type VerifySignatureArgs, type VerifySingleKeySignatureArgs, type ViewFunctionABI, type WaitForTransactionOptions, type WhereArg, type WriteSet, type WriteSetChange, type WriteSetChangeDeleteModule, type WriteSetChangeDeleteResource, type WriteSetChangeDeleteTableItem, type WriteSetChangeWriteModule, type WriteSetChangeWriteResource, type WriteSetChangeWriteTableItem, aptosCoinStructTag, aptosRequest, buildTransaction, checkOrConvertArgument, computeAddressSeed, convertArgument, deriveKey, deriveTransactionType, deserializeFromScriptArgument, ensureBoolean, fetchEntryFunctionAbi, fetchFunctionAbi, fetchViewFunctionAbi, findFirstNonSignerArg, fromDerivationPath, generateMultiSignersSignedTransaction, generateRawTransaction, generateSignedTransaction, generateSignedTransactionForSimulation, generateSigningMessage, generateSigningMessageForSerializable, generateSigningMessageForTransaction, generateTransactionPayload, generateTransactionPayloadWithABI, generateUserTransactionHash, generateViewFunctionPayload, generateViewFunctionPayloadWithABI, get, getAptosFullNode, getAptosPepperService, getAuthenticatorForSimulation, getFunctionParts, hashValues, isBcsAddress, isBcsBool, isBcsFixedBytes, isBcsString, isBcsU128, isBcsU16, isBcsU256, isBcsU32, isBcsU64, isBcsU8, isBlockMetadataTransactionResponse, isBool, isEd25519Signature, isEncodedEntryFunctionArgument, isFeePayerSignature, isGenesisTransactionResponse, isLargeNumber, isMultiAgentSignature, isMultiEd25519Signature, isNull, isNumber, isPendingTransactionResponse, isScriptDataInput, isSecp256k1Signature, isStateCheckpointTransactionResponse, isString, isUserTransactionResponse, isValidBIP44Path, isValidHardenedPath, isValidatorTransactionResponse, mnemonicToSeed, objectStructTag, optionStructTag, outOfRangeErrorMessage, paginateWithCursor, parseTypeTag, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, postAptosPepperService, postAptosProvingService, promiseFulfilledStatus, request, splitPath, standardizeTypeTags, stringStructTag, throwTypeMismatch, validateNumberInRange };