@aptos-labs/ts-sdk 1.14.0 → 1.15.0-win.1

package/dist/common/index.d.ts

@@ -1,5 +1,5 @@
-import { S as Serializable, T as TransactionArgument, H as HexInput, a as Serializer, D as Deserializer, E as EntryFunctionArgument, U as Uint8, b as Uint16, c as Uint32, A as AnyNumber, d as Deserializable, e as Hex, f as AuthenticationKeyScheme, g as AccountAddress, h as AnyPublicKeyVariant, i as AccountAddressInput, j as SigningSchemeInput, k as SigningScheme, N as Network, C as Client, l as ClientConfig, F as FullNodeConfig, I as IndexerConfig, m as FaucetConfig, n as AptosSettings, o as AccountData, P as PaginationArgs, L as LedgerVersionArg, M as MoveModuleBytecode, p as TransactionResponse, q as MoveResource, r as MoveStructId, s as TokenStandardArg, O as OrderByArg, G as GetAccountOwnedTokensQueryResponse, t as GetAccountOwnedTokensFromCollectionResponse, u as GetAccountCollectionsWithOwnedTokenResponse, v as GetAccountCoinsDataResponse, W as WhereArg, w as GetAccountOwnedObjectsResponse, x as MoveModuleId, y as ScriptFunctionArgument, z as MoveFunctionId, B as MoveFunctionGenericTypeParam, J as GetCollectionDataResponse, K as GetTokenDataResponse, Q as GetCurrentTokenOwnershipResponse, R as GetOwnedTokensResponse, V as GetTokenActivityResponse, X as GetEventsResponse, Y as WaitForTransactionOptions, Z as UserTransactionResponse, _ as MoveFunction, $ as GetFungibleAssetMetadataResponse, a0 as GetFungibleAssetActivitiesResponse, a1 as GetCurrentFungibleAssetBalancesResponse, a2 as LedgerInfo, a3 as Block, a4 as TableItemRequest, a5 as MoveValue, a6 as GetChainTopUserTransactionsResponse, a7 as GraphqlQuery, a8 as GetProcessorStatusResponse, a9 as GetANSNameResponse, aa as GetNumberOfDelegatorsResponse, ab as GetDelegatedStakingActivitiesResponse, ac as PendingTransactionResponse, ad as CommittedTransactionResponse, ae as GasEstimation, af as AptosRequest, ag as ClientRequest, ah as ClientResponse, ai as MimeType } from './accountAddress-csDQ8Gnp.js';
-export { av as AccountAuthenticatorVariant, ba as AccountSignature, am as AddressInvalidReason, aw as AnySignatureVariant, aJ as BlockMetadataTransactionResponse, aA as ClientHeadersType, aT as DecodedTableData, aU as DeletedTableData, bx as DeriveScheme, bd as DirectWriteSet, aW as EntryFunctionPayloadResponse, bf as Event, be as EventGuid, bA as GenerateAccount, by as GenerateAccountWithEd25519, bz as GenerateAccountWithSingleSignerSecp256k1Key, aZ as GenesisPayload, aI as GenesisTransactionResponse, ap as HexInvalidReason, bs as MoveAbility, bm as MoveAddressType, br as MoveFunctionVisibility, bu as MoveModule, bn as MoveObjectType, bo as MoveOptionType, a_ as MoveScriptBytecode, bv as MoveStruct, bt as MoveStructField, bp as MoveStructType, bq as MoveType, bk as MoveUint128Type, bh as MoveUint16Type, bl as MoveUint256Type, bi as MoveUint32Type, bj as MoveUint64Type, bg as MoveUint8Type, aY as MultisigPayloadResponse, bH as NetworkToChainId, bG as NetworkToFaucetAPI, bE as NetworkToIndexerAPI, bI as NetworkToNetworkName, bF as NetworkToNodeAPI, bB as OrderBy, bC as OrderByValue, an as ParsingError, ao as ParsingResult, bw as RoleType, aX as ScriptPayloadResponse, ar as ScriptTransactionArgumentVariants, bc as ScriptWriteSet, aK as StateCheckpointTransactionResponse, bD as TokenStandard, au as TransactionAuthenticatorVariant, b5 as TransactionEd25519Signature, b9 as TransactionFeePayerSignature, b8 as TransactionMultiAgentSignature, b7 as TransactionMultiEd25519Signature, aV as TransactionPayloadResponse, as as TransactionPayloadVariants, aB as TransactionResponseType, b6 as TransactionSecp256k1Signature, a$ as TransactionSignature, at as TransactionVariants, aq as TypeTagVariants, ay as Uint128, az as Uint256, ax as Uint64, aL as ValidatorTransactionResponse, bb as WriteSet, aM as WriteSetChange, aN as WriteSetChangeDeleteModule, aO as WriteSetChangeDeleteResource, aP as WriteSetChangeDeleteTableItem, aQ as WriteSetChangeWriteModule, aR as WriteSetChangeWriteResource, aS as WriteSetChangeWriteTableItem, aj as ensureBoolean, aF as isBlockMetadataTransactionResponse, b0 as isEd25519Signature, b3 as isFeePayerSignature, aE as isGenesisTransactionResponse, b2 as isMultiAgentSignature, b4 as isMultiEd25519Signature, aC as isPendingTransactionResponse, b1 as isSecp256k1Signature, aG as isStateCheckpointTransactionResponse, aD as isUserTransactionResponse, aH as isValidatorTransactionResponse, ak as outOfRangeErrorMessage, al as validateNumberInRange } from './accountAddress-csDQ8Gnp.js';
+import { S as Serializable, T as TransactionArgument, H as HexInput, a as Serializer, D as Deserializer, E as EntryFunctionArgument, U as Uint8, b as Uint16, c as Uint32, A as AnyNumber, d as Deserializable, e as Hex, f as AuthenticationKeyScheme, g as AccountAddress, h as AnyPublicKeyVariant, N as Network, C as Client, i as ClientConfig, F as FullNodeConfig, I as IndexerConfig, j as FaucetConfig, k as AptosSettings, M as MoveModuleId, l as ScriptFunctionArgument, m as MoveFunctionId, n as AccountAddressInput, o as MoveFunctionGenericTypeParam, p as SigningSchemeInput, q as SigningScheme, r as AccountData, P as PaginationArgs, L as LedgerVersionArg, s as MoveModuleBytecode, t as TransactionResponse, u as MoveResource, v as MoveStructId, w as TokenStandardArg, O as OrderByArg, G as GetAccountOwnedTokensQueryResponse, x as GetAccountOwnedTokensFromCollectionResponse, y as GetAccountCollectionsWithOwnedTokenResponse, z as GetAccountCoinsDataResponse, W as WhereArg, B as GetAccountOwnedObjectsResponse, J as GetCollectionDataResponse, K as GetTokenDataResponse, Q as GetCurrentTokenOwnershipResponse, R as GetOwnedTokensResponse, V as GetTokenActivityResponse, X as GetEventsResponse, Y as WaitForTransactionOptions, Z as UserTransactionResponse, _ as MoveFunction, $ as GetFungibleAssetMetadataResponse, a0 as GetFungibleAssetActivitiesResponse, a1 as GetCurrentFungibleAssetBalancesResponse, a2 as LedgerInfo, a3 as Block, a4 as MoveValue, a5 as GetChainTopUserTransactionsResponse, a6 as GraphqlQuery, a7 as GetProcessorStatusResponse, a8 as GetANSNameResponse, a9 as GetNumberOfDelegatorsResponse, aa as GetDelegatedStakingActivitiesResponse, ab as PendingTransactionResponse, ac as CommittedTransactionResponse, ad as GasEstimation, ae as TableItemRequest, af as GetTableItemsDataResponse, ag as GetTableItemsMetadataResponse, ah as AptosRequest, ai as ClientRequest, aj as ClientResponse, ak as MimeType } from './accountAddress-ccLvlUQe.js';
+export { ax as AccountAuthenticatorVariant, bc as AccountSignature, ao as AddressInvalidReason, ay as AnySignatureVariant, aL as BlockMetadataTransactionResponse, aC as ClientHeadersType, aV as DecodedTableData, aW as DeletedTableData, bz as DeriveScheme, bf as DirectWriteSet, aY as EntryFunctionPayloadResponse, bh as Event, bg as EventGuid, bC as GenerateAccount, bA as GenerateAccountWithEd25519, bB as GenerateAccountWithSingleSignerSecp256k1Key, a$ as GenesisPayload, aK as GenesisTransactionResponse, ar as HexInvalidReason, bu as MoveAbility, bo as MoveAddressType, bt as MoveFunctionVisibility, bw as MoveModule, bp as MoveObjectType, bq as MoveOptionType, b0 as MoveScriptBytecode, bx as MoveStruct, bv as MoveStructField, br as MoveStructType, bs as MoveType, bm as MoveUint128Type, bj as MoveUint16Type, bn as MoveUint256Type, bk as MoveUint32Type, bl as MoveUint64Type, bi as MoveUint8Type, a_ as MultisigPayloadResponse, bJ as NetworkToChainId, bI as NetworkToFaucetAPI, bG as NetworkToIndexerAPI, bK as NetworkToNetworkName, bH as NetworkToNodeAPI, bD as OrderBy, bE as OrderByValue, ap as ParsingError, aq as ParsingResult, by as RoleType, aZ as ScriptPayloadResponse, at as ScriptTransactionArgumentVariants, be as ScriptWriteSet, aM as StateCheckpointTransactionResponse, bF as TokenStandard, aw as TransactionAuthenticatorVariant, b7 as TransactionEd25519Signature, bb as TransactionFeePayerSignature, ba as TransactionMultiAgentSignature, b9 as TransactionMultiEd25519Signature, aX as TransactionPayloadResponse, au as TransactionPayloadVariants, aD as TransactionResponseType, b8 as TransactionSecp256k1Signature, b1 as TransactionSignature, av as TransactionVariants, as as TypeTagVariants, aA as Uint128, aB as Uint256, az as Uint64, aN as ValidatorTransactionResponse, bd as WriteSet, aO as WriteSetChange, aP as WriteSetChangeDeleteModule, aQ as WriteSetChangeDeleteResource, aR as WriteSetChangeDeleteTableItem, aS as WriteSetChangeWriteModule, aT as WriteSetChangeWriteResource, aU as WriteSetChangeWriteTableItem, al as ensureBoolean, aH as isBlockMetadataTransactionResponse, b2 as isEd25519Signature, b5 as isFeePayerSignature, aG as isGenesisTransactionResponse, b4 as isMultiAgentSignature, b6 as isMultiEd25519Signature, aE as isPendingTransactionResponse, b3 as isSecp256k1Signature, aI as isStateCheckpointTransactionResponse, aF as isUserTransactionResponse, aJ as isValidatorTransactionResponse, am as outOfRangeErrorMessage, an as validateNumberInRange } from './accountAddress-ccLvlUQe.js';
 import EventEmitter from 'eventemitter3';
 
 type Maybe<T> = T | null;
@@ -144,6 +144,7 @@ type CurrentAptosNamesBoolExp = {
     _not?: InputMaybe<CurrentAptosNamesBoolExp>;
     _or?: InputMaybe<Array<CurrentAptosNamesBoolExp>>;
     domain?: InputMaybe<StringComparisonExp>;
+    domain_expiration_timestamp?: InputMaybe<TimestampComparisonExp>;
     domain_with_suffix?: InputMaybe<StringComparisonExp>;
     expiration_timestamp?: InputMaybe<TimestampComparisonExp>;
     is_active?: InputMaybe<BooleanComparisonExp>;
@@ -153,6 +154,7 @@ type CurrentAptosNamesBoolExp = {
     owner_address?: InputMaybe<StringComparisonExp>;
     registered_address?: InputMaybe<StringComparisonExp>;
     subdomain?: InputMaybe<StringComparisonExp>;
+    subdomain_expiration_policy?: InputMaybe<BigintComparisonExp>;
     token_name?: InputMaybe<StringComparisonExp>;
     token_standard?: InputMaybe<StringComparisonExp>;
 };
@@ -161,6 +163,8 @@ declare enum CurrentAptosNamesSelectColumn {
     /** column name */
     Domain = "domain",
     /** column name */
+    DomainExpirationTimestamp = "domain_expiration_timestamp",
+    /** column name */
     DomainWithSuffix = "domain_with_suffix",
     /** column name */
     ExpirationTimestamp = "expiration_timestamp",
@@ -177,6 +181,8 @@ declare enum CurrentAptosNamesSelectColumn {
     /** column name */
     Subdomain = "subdomain",
     /** column name */
+    SubdomainExpirationPolicy = "subdomain_expiration_policy",
+    /** column name */
     TokenName = "token_name",
     /** column name */
     TokenStandard = "token_standard"
@@ -307,6 +313,27 @@ type NumericComparisonExp = {
     _neq?: InputMaybe<Scalars["numeric"]["input"]>;
     _nin?: InputMaybe<Array<Scalars["numeric"]["input"]>>;
 };
+/** Boolean expression to filter rows from the table "table_items". All fields are combined with a logical 'AND'. */
+type TableItemsBoolExp = {
+    _and?: InputMaybe<Array<TableItemsBoolExp>>;
+    _not?: InputMaybe<TableItemsBoolExp>;
+    _or?: InputMaybe<Array<TableItemsBoolExp>>;
+    decoded_key?: InputMaybe<JsonbComparisonExp>;
+    decoded_value?: InputMaybe<JsonbComparisonExp>;
+    key?: InputMaybe<StringComparisonExp>;
+    table_handle?: InputMaybe<StringComparisonExp>;
+    transaction_version?: InputMaybe<BigintComparisonExp>;
+    write_set_change_index?: InputMaybe<BigintComparisonExp>;
+};
+/** Boolean expression to filter rows from the table "table_metadatas". All fields are combined with a logical 'AND'. */
+type TableMetadatasBoolExp = {
+    _and?: InputMaybe<Array<TableMetadatasBoolExp>>;
+    _not?: InputMaybe<TableMetadatasBoolExp>;
+    _or?: InputMaybe<Array<TableMetadatasBoolExp>>;
+    handle?: InputMaybe<StringComparisonExp>;
+    key_type?: InputMaybe<StringComparisonExp>;
+    value_type?: InputMaybe<StringComparisonExp>;
+};
 /** Boolean expression to compare columns of type "timestamp". All fields are combined with logical 'AND'. */
 type TimestampComparisonExp = {
     _eq?: InputMaybe<Scalars["timestamp"]["input"]>;
@@ -1277,6 +1304,13 @@ declare class MultiKey extends AccountPublicKey {
     createBitmap(args: {
         bits: number[];
     }): Uint8Array;
+    /**
+     * Get the index of the provided public key.
+     *
+     * @param publicKey array of the index mapping to the matching public keys
+     * @returns the corresponding index of the publicKey, if it exists
+     */
+    getIndex(publicKey: PublicKey): number;
 }
 declare class MultiKeySignature extends Signature {
     /**
@@ -1523,1587 +1557,1720 @@ 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: MultiKeySignature;
+    constructor(public_keys: MultiKey, signatures: MultiKeySignature);
     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.
- */
-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;
-}
-
-/**
- * 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;
-}
-/**
- * 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;
-}
-/**
- * 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;
-}
 /**
- * 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.
+ * Type of API endpoint for request routing
  */
-interface CreateAccountFromPrivateKeyArgs {
-    privateKey: PrivateKey;
-    address?: AccountAddressInput;
-    legacy?: boolean;
+declare enum AptosApiType {
+    FULLNODE = "Fullnode",
+    INDEXER = "Indexer",
+    FAUCET = "Faucet"
 }
 /**
- * Arguments for generating an `Ed25519Account`.
- * This is the input type used by default.
+ * 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 GenerateEd25519AccountArgs {
-    scheme?: SigningSchemeInput.Ed25519;
-    legacy?: true;
-}
+declare const DEFAULT_MAX_GAS_AMOUNT = 200000;
 /**
- * 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.
+ * 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 GenerateEd25519SingleKeyAccountArgs {
-    scheme?: SigningSchemeInput.Ed25519;
-    legacy: false;
-}
+declare const DEFAULT_TXN_EXP_SEC_FROM_NOW = 20;
 /**
- * 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.
+ * 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 GenerateSingleKeyAccountArgs {
-    scheme: Exclude<SigningSchemeInput, SigningSchemeInput.Ed25519>;
-    legacy?: false;
-}
+declare const DEFAULT_TXN_TIMEOUT_SEC = 20;
 /**
- * Arguments for generating an opaque `Account`.
- * This is used when the input signature scheme is not known at compilation time.
+ * The default gas currency for the network.
  */
-interface GenerateAccountArgs {
-    scheme?: SigningSchemeInput;
-    legacy?: boolean;
-}
+declare const APTOS_COIN = "0x1::aptos_coin::AptosCoin";
+declare const RAW_TRANSACTION_SALT = "APTOS::RawTransaction";
+declare const RAW_TRANSACTION_WITH_DATA_SALT = "APTOS::RawTransactionWithData";
 /**
- * Arguments for deriving a private key from a mnemonic phrase and a BIP44 path.
+ * The list of supported Processor types for our indexer api.
+ *
+ * These can be found from the processor_status table in the indexer database.
+ * {@link https://cloud.hasura.io/public/graphiql?endpoint=https://api.mainnet.aptoslabs.com/v1/graphql}
  */
-interface PrivateKeyFromDerivationPathArgs {
-    path: string;
-    mnemonic: string;
+declare enum ProcessorType {
+    ACCOUNT_TRANSACTION_PROCESSOR = "account_transactions_processor",
+    DEFAULT = "default_processor",
+    EVENTS_PROCESSOR = "events_processor",
+    FUNGIBLE_ASSET_PROCESSOR = "fungible_asset_processor",
+    STAKE_PROCESSOR = "stake_processor",
+    TOKEN_V2_PROCESSOR = "token_v2_processor",
+    USER_TRANSACTION_PROCESSOR = "user_transaction_processor"
 }
+
 /**
- * Interface for a generic Aptos account.
+ * This class holds the config information for the SDK client instance.
  *
- * 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.
+ * @example
  *
- * Note: Generating an account instance does not create the account on-chain.
+ * const aptosConfig = new AptosConfig({network:Network.TESTNET})
  */
-declare abstract class Account$1 {
+declare class AptosConfig {
     /**
-     * Private key associated with the account.
-     * Note: this will be removed in the next major release,
-     *  as not all accounts have a private key.
+     * The Network that this SDK is associated with. Defaults to DEVNET
      */
-    abstract readonly privateKey: PrivateKey;
+    readonly network: Network;
     /**
-     * Public key associated with the account
+     * The client instance the SDK uses. Defaults to `@aptos-labs/aptos-client
      */
-    abstract readonly publicKey: AccountPublicKey;
+    readonly client: Client;
     /**
-     * Account address associated with the account
+     * The optional hardcoded fullnode URL to send requests to instead of using the network
      */
-    abstract readonly accountAddress: AccountAddress;
+    readonly fullnode?: string;
     /**
-     * Signing scheme used to sign transactions
+     * The optional hardcoded faucet URL to send requests to instead of using the network
      */
-    abstract signingScheme: SigningScheme;
+    readonly faucet?: string;
     /**
-     * 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
+     * The optional hardcoded indexer URL to send requests to instead of using the network
      */
-    static generate(args?: GenerateEd25519AccountArgs): Ed25519Account;
-    static generate(args: GenerateEd25519SingleKeyAccountArgs): SingleKeyAccount;
-    static generate(args: GenerateSingleKeyAccountArgs): SingleKeyAccount;
-    static generate(args: GenerateAccountArgs): Account$1;
+    readonly indexer?: string;
     /**
-     * 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
+     * Optional client configurations
      */
-    static fromPrivateKey(args: CreateEd25519AccountFromPrivateKeyArgs): Ed25519Account;
-    static fromPrivateKey(args: CreateEd25519SingleKeyAccountFromPrivateKeyArgs): SingleKeyAccount;
-    static fromPrivateKey(args: CreateSingleKeyAccountFromPrivateKeyArgs): SingleKeyAccount;
-    static fromPrivateKey(args: CreateAccountFromPrivateKeyArgs): Account$1;
+    readonly clientConfig?: ClientConfig;
     /**
-     * @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
+     * Optional specific Fullnode configurations
      */
-    static fromPrivateKeyAndAddress(args: CreateAccountFromPrivateKeyArgs): Account$1;
+    readonly fullnodeConfig?: FullNodeConfig;
     /**
-     * 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
+     * Optional specific Indexer configurations
      */
-    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;
+    readonly indexerConfig?: IndexerConfig;
     /**
-     * @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
+     * Optional specific Faucet configurations
      */
-    static authKey(args: {
-        publicKey: AccountPublicKey;
-    }): AuthenticationKey;
+    readonly faucetConfig?: FaucetConfig;
+    constructor(settings?: AptosSettings);
     /**
-     * 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
+     * Returns the URL endpoint to send the request to.
+     * If a custom URL was provided in the config, that URL is returned.
+     * If a custom URL was provided but not URL endpoints, an error is thrown.
+     * Otherwise, the URL endpoint is derived from the network.
+     *
+     * @param apiType - The type of Aptos API to get the URL for.
+     *
+     * @internal
      */
-    verifySignature(args: VerifySignatureArgs): boolean;
+    getRequestUrl(apiType: AptosApiType): string;
 }
 
-interface Ed25519SignerConstructorArgs {
-    privateKey: Ed25519PrivateKey;
-    address?: AccountAddressInput;
-}
-interface Ed25519SignerFromDerivationPathArgs {
-    path: string;
-    mnemonic: string;
+/**
+ * Representation of a ChainId that can serialized and deserialized
+ */
+declare class ChainId extends Serializable {
+    readonly chainId: number;
+    constructor(chainId: number);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): ChainId;
 }
-interface VerifyEd25519SignatureArgs {
-    message: HexInput;
-    signature: Ed25519Signature;
+
+/**
+ * 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;
 }
+
 /**
- * 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.
+ * 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 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);
+declare class ModuleId extends Serializable {
+    readonly address: AccountAddress;
+    readonly name: Identifier;
     /**
-     * Derives a signer from a randomly generated private key
+     * Full name of a module.
+     * @param address The account address. e.g "0x1"
+     * @param name The module name under the "address". e.g "coin"
      */
-    static generate(): Ed25519Account;
+    constructor(address: AccountAddress, name: Identifier);
     /**
-     * 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
+     * Converts a string literal to a ModuleId
+     * @param moduleId String literal in format "account_address::module_name", e.g. "0x1::coin"
+     * @returns ModuleId
      */
-    static fromDerivationPath(args: Ed25519SignerFromDerivationPathArgs): Ed25519Account;
-    verifySignature(args: VerifyEd25519SignatureArgs): boolean;
-    signWithAuthenticator(message: HexInput): AccountAuthenticatorEd25519;
-    sign(message: HexInput): Ed25519Signature;
+    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;
+}
 /**
- * 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
+ * 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 const createObjectAddress: (creatorAddress: AccountAddress, seed: Uint8Array | string) => AccountAddress;
+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;
+
 /**
- * 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
+ * Deserialize a Script Transaction Argument
  */
-declare const createResourceAddress: (creatorAddress: AccountAddress, seed: Uint8Array | string) => AccountAddress;
+declare function deserializeFromScriptArgument(deserializer: Deserializer): TransactionArgument;
 /**
- * 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
+ * Representation of the supported Transaction Payload
+ * that can serialized and deserialized
  */
-declare const createTokenAddress: (creatorAddress: AccountAddress, collectionName: string, tokenName: string) => AccountAddress;
-
+declare abstract class TransactionPayload extends Serializable {
+    /**
+     * Serialize a Transaction Payload
+     */
+    abstract serialize(serializer: Serializer): void;
+    /**
+     * Deserialize a Transaction Payload
+     */
+    static deserialize(deserializer: Deserializer): TransactionPayload;
+}
 /**
- * Type of API endpoint for request routing
+ * Representation of a Transaction Payload Script that can serialized and deserialized
  */
-declare enum AptosApiType {
-    FULLNODE = "Fullnode",
-    INDEXER = "Indexer",
-    FAUCET = "Faucet"
+declare class TransactionPayloadScript extends TransactionPayload {
+    readonly script: Script;
+    constructor(script: Script);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TransactionPayloadScript;
 }
 /**
- * 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.
+ * Representation of a Transaction Payload Entry Function that can serialized and deserialized
  */
-declare const DEFAULT_MAX_GAS_AMOUNT = 200000;
+declare class TransactionPayloadEntryFunction extends TransactionPayload {
+    readonly entryFunction: EntryFunction;
+    constructor(entryFunction: EntryFunction);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TransactionPayloadEntryFunction;
+}
 /**
- * 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.
+ * Representation of a Transaction Payload Multi-sig that can serialized and deserialized
  */
-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";
-/**
- * The list of supported Processor types for our indexer api.
- *
- * These can be found from the processor_status table in the indexer database.
- * {@link https://cloud.hasura.io/public/graphiql?endpoint=https://api.mainnet.aptoslabs.com/v1/graphql}
- */
-declare enum ProcessorType {
-    ACCOUNT_TRANSACTION_PROCESSOR = "account_transactions_processor",
-    DEFAULT = "default_processor",
-    EVENTS_PROCESSOR = "events_processor",
-    FUNGIBLE_ASSET_PROCESSOR = "fungible_asset_processor",
-    STAKE_PROCESSOR = "stake_processor",
-    TOKEN_V2_PROCESSOR = "token_v2_processor",
-    USER_TRANSACTION_PROCESSOR = "user_transaction_processor"
+declare class TransactionPayloadMultiSig extends TransactionPayload {
+    readonly multiSig: MultiSig;
+    constructor(multiSig: MultiSig);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TransactionPayloadMultiSig;
 }
-
 /**
- * This class holds the config information for the SDK client instance.
- *
- * @example
- *
- * const aptosConfig = new AptosConfig({network:Network.TESTNET})
+ * Representation of a EntryFunction that can serialized and deserialized
  */
-declare class AptosConfig {
-    /**
-     * The Network that this SDK is associated with. Defaults to DEVNET
-     */
-    readonly network: Network;
-    /**
-     * The client instance the SDK uses. Defaults to `@aptos-labs/aptos-client
-     */
-    readonly client: Client;
-    /**
-     * The optional hardcoded fullnode URL to send requests to instead of using the network
-     */
-    readonly fullnode?: string;
-    /**
-     * The optional hardcoded faucet URL to send requests to instead of using the network
-     */
-    readonly faucet?: string;
-    /**
-     * The optional hardcoded indexer URL to send requests to instead of using the network
-     */
-    readonly indexer?: string;
-    /**
-     * Optional client configurations
-     */
-    readonly clientConfig?: ClientConfig;
-    /**
-     * Optional specific Fullnode configurations
-     */
-    readonly fullnodeConfig?: FullNodeConfig;
-    /**
-     * Optional specific Indexer configurations
-     */
-    readonly indexerConfig?: IndexerConfig;
-    /**
-     * Optional specific Faucet configurations
-     */
-    readonly faucetConfig?: FaucetConfig;
-    constructor(settings?: AptosSettings);
+declare class EntryFunction {
+    readonly module_name: ModuleId;
+    readonly function_name: Identifier;
+    readonly type_args: Array<TypeTag>;
+    readonly args: Array<EntryFunctionArgument>;
     /**
-     * Returns the URL endpoint to send the request to.
-     * If a custom URL was provided in the config, that URL is returned.
-     * If a custom URL was provided but not URL endpoints, an error is thrown.
-     * Otherwise, the URL endpoint is derived from the network.
+     * 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.
      *
-     * @param apiType - The type of Aptos API to get the URL for.
+     * @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.
      *
-     * @internal
+     * @example
+     * A coin transfer function has three arguments "from", "to" and "amount".
+     * ```
+     * public entry fun transfer<CoinType>(from: &signer, to: address, amount: u64)
+     * ```
      */
-    getRequestUrl(apiType: AptosApiType): string;
-}
-
-/**
- * A class to query all `Account` related queries on Aptos.
- */
-declare class Account {
-    readonly config: AptosConfig;
-    constructor(config: AptosConfig);
+    constructor(module_name: ModuleId, function_name: Identifier, type_args: Array<TypeTag>, args: Array<EntryFunctionArgument>);
     /**
-     * Queries the current state for an Aptos account given its account address
+     * A helper function to build a EntryFunction payload from raw primitive values
      *
-     * @param args.accountAddress Aptos account address
+     * @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.
      *
-     * @returns The account data
+     * @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.
      *
-     * @example An example of the returned account
+     * @example
+     * A coin transfer function has three arguments "from", "to" and "amount".
      * ```
-     * {
-     *    sequence_number: "1",
-     *    authentication_key: "0x5307b5f4bc67829097a8ba9b43dba3b88261eeccd1f709d9bde240fc100fbb69"
-     * }
+     * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
      * ```
+     * @returns EntryFunction
      */
-    getAccountInfo(args: {
-        accountAddress: AccountAddressInput;
-    }): Promise<AccountData>;
+    static build(module_id: MoveModuleId, function_name: string, type_args: Array<TypeTag>, args: Array<EntryFunctionArgument>): EntryFunction;
+    serialize(serializer: Serializer): void;
     /**
-     * Queries for all modules in an account given an account address
+     * Deserializes an entry function payload with the arguments represented as EntryFunctionBytes instances.
+     * @see EntryFunctionBytes
      *
-     * Note: In order to get all account modules, this function may call the API
-     * multiple times as it auto paginates.
+     * 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.
      *
-     * @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
+     * 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.
      *
-     * @returns Account modules
      */
-    getAccountModules(args: {
-        accountAddress: AccountAddressInput;
-        options?: PaginationArgs & LedgerVersionArg;
-    }): Promise<MoveModuleBytecode[]>;
+    static deserialize(deserializer: Deserializer): EntryFunction;
+}
+/**
+ * Representation of a Script that can serialized and deserialized
+ */
+declare class Script {
     /**
-     * Queries for a specific account module given account address and module name
+     * 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.
      *
-     * @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
+     * @param bytecode The move module bytecode
+     * @param type_args The type arguments that the bytecode function requires.
      *
-     * @returns Account module
+     * @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.
      *
      * @example
-     * const module = await aptos.getAccountModule({accountAddress:"0x456"})
-     * // An example of an account module response
+     * A coin transfer function has three arguments "from", "to" and "amount".
      * ```
-     * {
-     *    bytecode: "0xa11ceb0b0600000006010002030206050807070f0d081c200",
-     *    abi: { address: "0x1" }
-     * }
+     * 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;
     /**
-     * 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.
-     *
-     * @example
-     * const transactions = await aptos.getAccountTransactions({accountAddress:"0x456"})
+     * Contains the payload to run a multi-sig account transaction.
      *
-     * @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 multisig_address The multi-sig account address the transaction will be executed as.
      *
-     * @returns The account transactions
+     * @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.
      */
-    getAccountTransactions(args: {
-        accountAddress: AccountAddressInput;
-        options?: PaginationArgs;
-    }): Promise<TransactionResponse[]>;
+    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;
     /**
-     * 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.
+     * Contains the payload to run a multi-sig account transaction.
      *
-     * @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
-     */
-    getAccountResources(args: {
-        accountAddress: AccountAddressInput;
-        options?: PaginationArgs & LedgerVersionArg;
-    }): Promise<MoveResource[]>;
-    /**
-     * 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"})
-     *
-     */
-    getAccountResource<T extends {} = any>(args: {
-        accountAddress: AccountAddressInput;
-        resourceType: MoveStructId;
-        options?: LedgerVersionArg;
-    }): Promise<T>;
-    /**
-     * 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
-     */
-    lookupOriginalAccountAddress(args: {
-        authenticationKey: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: LedgerVersionArg;
-    }): Promise<AccountAddress>;
-    /**
-     * 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
+     * @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.
      */
-    getAccountTokensCount(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
+    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 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"})
+     * 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 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
+     * @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.
      */
-    getAccountOwnedTokens(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensQueryResponse[0]>;
-    }): Promise<GetAccountOwnedTokensQueryResponse>;
+    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 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
+     * Serialize a Raw Transaction With Data
      */
-    getAccountOwnedTokensFromCollectionAddress(args: {
-        accountAddress: AccountAddressInput;
-        collectionAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensFromCollectionResponse[0]>;
-    }): Promise<GetAccountOwnedTokensFromCollectionResponse>;
+    abstract serialize(serializer: Serializer): void;
     /**
-     * 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
+     * Deserialize a Raw Transaction With Data
      */
-    getAccountCollectionsWithOwnedTokens(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountCollectionsWithOwnedTokenResponse[0]>;
-    }): Promise<GetAccountCollectionsWithOwnedTokenResponse>;
+    static deserialize(deserializer: Deserializer): RawTransactionWithData;
+}
+/**
+ * Representation of a Multi Agent Transaction that can serialized and deserialized
+ */
+declare class MultiAgentRawTransaction extends RawTransactionWithData {
     /**
-     * Queries the current count of transactions submitted by an account
-     *
-     * @example
-     * const accountTransactionsCount = await aptos.getAccountTransactionsCount({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 count of transactions made by an account
+     * The raw transaction
      */
-    getAccountTransactionsCount(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
+    readonly raw_txn: RawTransaction;
     /**
-     * Queries an account's coins data
-     *
-     * @example
-     * const accountCoinsData = await aptos.getAccountCoinsData({accountAddress:"0x123"})
-     *
-     * @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
+     * The secondary signers on this transaction
      */
-    getAccountCoinsData(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: PaginationArgs & OrderByArg<GetAccountCoinsDataResponse[0]> & WhereArg<CurrentFungibleAssetBalancesBoolExp>;
-    }): Promise<GetAccountCoinsDataResponse>;
+    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 current count of an account's coins aggregated
-     *
-     * @example
-     * const accountCoinsCount = await aptos.getAccountCoinsCount({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 count of the aggregated count of all account's coins
+     * The raw transaction
      */
-    getAccountCoinsCount(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
+    readonly raw_txn: RawTransaction;
     /**
-     * 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
+     * The secondary signers on this transaction - optional and can be empty
      */
-    getAccountAPTAmount(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
+    readonly secondary_signer_addresses: Array<AccountAddress>;
     /**
-     * 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
+     * The fee payer account address
      */
-    getAccountCoinAmount(args: {
-        accountAddress: AccountAddressInput;
-        coinType: MoveStructId;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
-    /**
-     * 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
-     */
-    getAccountOwnedObjects(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: PaginationArgs & OrderByArg<GetAccountOwnedObjectsResponse[0]>;
-    }): Promise<GetAccountOwnedObjectsResponse>;
-    /**
-     * Derives an account by providing a private key.
-     * This functions resolves the provided private key type and derives the public key from it.
-     *
-     * If the privateKey is a Secp256k1 type, it derives the account using the derived public key and
-     * auth key using the SingleKey scheme locally.
-     *
-     * If the privateKey is a ED25519 type, it looks up the authentication key on chain, and uses it to resolve
-     * whether it is a Legacy ED25519 key or a Unified ED25519 key. It then derives the account based
-     * on that.
-     *
-     * @example
-     * const account = await aptos.deriveAccountFromPrivateKey({privateKey:new Ed25519PrivateKey("0x123")})
-     *
-     * @param args.privateKey An account private key
-     * @returns Account type
-     */
-    deriveAccountFromPrivateKey(args: {
-        privateKey: PrivateKey;
-    }): Promise<Account$1>;
+    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 ChainId that can serialized and deserialized
+ * Representation of the challenge which is needed to sign by owner of the account
+ * to rotate the authentication key.
  */
-declare class ChainId extends Serializable {
-    readonly chainId: number;
-    constructor(chainId: number);
+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;
-    static deserialize(deserializer: Deserializer): ChainId;
 }
 
+declare abstract class TransactionAuthenticator extends Serializable {
+    abstract serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): TransactionAuthenticator;
+}
 /**
- * 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"
+ * 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 Identifier extends Serializable {
-    identifier: string;
-    constructor(identifier: string);
+declare class TransactionAuthenticatorEd25519 extends TransactionAuthenticator {
+    readonly public_key: Ed25519PublicKey;
+    readonly signature: Ed25519Signature;
+    constructor(public_key: Ed25519PublicKey, signature: Ed25519Signature);
     serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): Identifier;
+    static load(deserializer: Deserializer): TransactionAuthenticatorEd25519;
 }
-
 /**
- * Representation of a ModuleId that can serialized and deserialized
- * ModuleId means the module address (e.g "0x1") and the module name (e.g "coin")
+ * 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 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;
+declare class TransactionAuthenticatorMultiEd25519 extends TransactionAuthenticator {
+    readonly public_key: MultiEd25519PublicKey;
+    readonly signature: MultiEd25519Signature;
+    constructor(public_key: MultiEd25519PublicKey, signature: MultiEd25519Signature);
     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;
+    static load(deserializer: Deserializer): TransactionAuthenticatorMultiEd25519;
 }
-declare class TypeTagBool extends TypeTag {
-    toString(): string;
+/**
+ * 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): TypeTagBool;
+    static load(deserializer: Deserializer): TransactionAuthenticatorMultiAgent;
 }
-declare class TypeTagU8 extends TypeTag {
-    toString(): string;
+/**
+ * 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): TypeTagU8;
+    static load(deserializer: Deserializer): TransactionAuthenticatorMultiAgent;
 }
-declare class TypeTagU16 extends TypeTag {
-    toString(): string;
+/**
+ * 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): TypeTagU16;
+    static load(deserializer: Deserializer): TransactionAuthenticatorSingleSender;
 }
-declare class TypeTagU32 extends TypeTag {
-    toString(): string;
+
+declare class SignedTransaction extends Serializable {
+    readonly raw_txn: RawTransaction;
+    readonly authenticator: TransactionAuthenticator;
+    /**
+     * A SignedTransaction consists of a raw transaction and an authenticator. The authenticator
+     * contains a client's public key and the signature of the raw transaction.
+     *
+     * @see {@link https://aptos.dev/integration/creating-a-signed-transaction | Creating a Signed Transaction}
+     *
+     * @param raw_txn
+     * @param authenticator Contains a client's public key and the signature of the raw transaction.
+     * Authenticator has 3 flavors: single signature, multi-signature and multi-agent.
+     * @see {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs} for details.
+     */
+    constructor(raw_txn: RawTransaction, authenticator: TransactionAuthenticator);
     serialize(serializer: Serializer): void;
-    static load(_deserializer: Deserializer): TypeTagU32;
+    static deserialize(deserializer: Deserializer): SignedTransaction;
 }
-declare class TypeTagU64 extends TypeTag {
-    toString(): string;
+
+/**
+ * Representation of a SimpleTransaction that can serialized and deserialized
+ */
+declare class SimpleTransaction extends Serializable {
+    rawTransaction: RawTransaction;
+    feePayerAddress?: AccountAddress | undefined;
+    readonly secondarySignerAddresses: undefined;
+    /**
+     * SimpleTransaction represents a simple transaction type of a single signer that
+     * can be submitted to Aptos chain for execution.
+     *
+     * 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
+     */
+    constructor(rawTransaction: RawTransaction, feePayerAddress?: AccountAddress);
     serialize(serializer: Serializer): void;
-    static load(_deserializer: Deserializer): TypeTagU64;
+    static deserialize(deserializer: Deserializer): SimpleTransaction;
 }
-declare class TypeTagU128 extends TypeTag {
-    toString(): string;
+
+/**
+ * Representation of a Raw Transaction that can serialized and deserialized
+ */
+declare class MultiAgentTransaction extends Serializable {
+    rawTransaction: RawTransaction;
+    feePayerAddress?: AccountAddress | undefined;
+    secondarySignerAddresses: AccountAddress[];
+    /**
+     * SimpleTransaction represents a simple transaction type of a single signer that
+     * can be submitted to Aptos chain for execution.
+     *
+     * 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
+     */
+    constructor(rawTransaction: RawTransaction, secondarySignerAddresses: AccountAddress[], feePayerAddress?: AccountAddress);
     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;
+    static deserialize(deserializer: Deserializer): MultiAgentTransaction;
 }
+
 /**
- * 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.
+ * Entry function arguments to be used when building a raw transaction using remote ABI
  */
-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;
-
+type SimpleEntryFunctionArgumentTypes = boolean | number | bigint | string | null | undefined | Uint8Array | ArrayBuffer | Array<SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes>;
 /**
- * Deserialize a Script Transaction Argument
+ * Entry function arguments to be used when building a raw transaction using BCS serialized arguments
  */
-declare function deserializeFromScriptArgument(deserializer: Deserializer): TransactionArgument;
+type EntryFunctionArgumentTypes = Bool | U8 | U16 | U32 | U64 | U128 | U256 | AccountAddress | MoveVector<EntryFunctionArgumentTypes> | MoveOption<EntryFunctionArgumentTypes> | MoveString | FixedBytes;
 /**
- * Representation of the supported Transaction Payload
- * that can serialized and deserialized
+ * Script function arguments to be used when building a raw transaction using BCS serialized arguments
  */
-declare abstract class TransactionPayload extends Serializable {
-    /**
-     * Serialize a Transaction Payload
-     */
-    abstract serialize(serializer: Serializer): void;
-    /**
-     * Deserialize a Transaction Payload
-     */
-    static deserialize(deserializer: Deserializer): TransactionPayload;
-}
+type ScriptFunctionArgumentTypes = Bool | U8 | U16 | U32 | U64 | U128 | U256 | AccountAddress | MoveVector<U8> | MoveString | FixedBytes;
 /**
- * Representation of a Transaction Payload Script that can serialized and deserialized
+ * Type that holds all raw transaction instances Aptos SDK supports
  */
-declare class TransactionPayloadScript extends TransactionPayload {
-    readonly script: Script;
-    constructor(script: Script);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TransactionPayloadScript;
-}
+type AnyRawTransactionInstance = RawTransaction | MultiAgentRawTransaction | FeePayerRawTransaction;
 /**
- * Representation of a Transaction Payload Entry Function that can serialized and deserialized
+ * Optional options to set when generating a transaction
  */
-declare class TransactionPayloadEntryFunction extends TransactionPayload {
-    readonly entryFunction: EntryFunction;
-    constructor(entryFunction: EntryFunction);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TransactionPayloadEntryFunction;
+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;
 }
 /**
- * Representation of a Transaction Payload Multi-sig that can serialized and deserialized
+ * Interface of the arguments to generate a multi-agent transaction.
+ * Used to provide to `generateTransaction()` method in the transaction builder flow
  */
-declare class TransactionPayloadMultiSig extends TransactionPayload {
-    readonly multiSig: MultiSig;
-    constructor(multiSig: MultiSig);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TransactionPayloadMultiSig;
+interface InputGenerateMultiAgentRawTransactionArgs {
+    aptosConfig: AptosConfig;
+    sender: AccountAddressInput;
+    payload: AnyTransactionPayloadInstance;
+    secondarySignerAddresses: AccountAddressInput[];
+    options?: InputGenerateTransactionOptions;
+    feePayerAddress?: AccountAddressInput;
 }
 /**
- * Representation of a EntryFunction that can serialized and deserialized
+ * Unified type that holds all the interfaces to generate different transaction types
  */
-declare class EntryFunction {
-    readonly module_name: ModuleId;
-    readonly function_name: Identifier;
-    readonly type_args: Array<TypeTag>;
-    readonly args: Array<EntryFunctionArgument>;
+type InputGenerateRawTransactionArgs = InputGenerateSingleSignerRawTransactionArgs | InputGenerateMultiAgentRawTransactionArgs;
+/**
+ * Unified type that holds all the return interfaces when generating different transaction types
+ */
+type AnyRawTransaction = SimpleTransaction | MultiAgentTransaction;
+type InputSimulateTransactionData = {
     /**
-     * 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)
-     * ```
+     * The transaction to simulate, probably generated by `generateTransaction()`
      */
-    constructor(module_name: ModuleId, function_name: Identifier, type_args: Array<TypeTag>, args: Array<EntryFunctionArgument>);
+    transaction: AnyRawTransaction;
     /**
-     * A helper function to build a EntryFunction payload from raw primitive values
-     *
-     * @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.
-     *
-     * @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.
-     *
-     * @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
-     */
-    static build(module_id: MoveModuleId, function_name: string, type_args: Array<TypeTag>, args: Array<EntryFunctionArgument>): EntryFunction;
-    serialize(serializer: Serializer): 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.
-     *
-     * 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.
+     * For a single signer transaction
      */
-    readonly type_args: Array<TypeTag>;
+    signerPublicKey: PublicKey;
     /**
-     * The arguments that the bytecode function requires.
+     * For a fee payer or multi-agent transaction that requires additional signers in
      */
-    readonly args: Array<ScriptFunctionArgument>;
+    secondarySignersPublicKeys?: Array<PublicKey>;
     /**
-     * Scripts contain the Move bytecodes payload that can be submitted to Aptos chain for execution.
-     *
-     * @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".
-     * ```
-     * 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,)
-     * ```
+     * For a fee payer transaction (aka Sponsored Transaction)
      */
-    constructor(bytecode: Uint8Array, type_args: Array<TypeTag>, args: Array<ScriptFunctionArgument>);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): Script;
+    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 MultiSig that can serialized and deserialized
+ * Interface that holds the user data input when generating a multi-agent transaction
  */
-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;
+interface InputGenerateMultiAgentRawTransactionData {
+    sender: AccountAddressInput;
+    data: InputGenerateTransactionPayloadData;
+    secondarySignerAddresses: AccountAddressInput[];
+    options?: InputGenerateTransactionOptions;
+    withFeePayer?: boolean;
 }
 /**
- * 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.
+ * Unified type that holds all the user data input interfaces when generating different transaction types
  */
-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;
+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 Raw Transaction that can serialized and deserialized
+ * 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 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;
+declare class SingleKeyAccount implements Account$1 {
     /**
-     * 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 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.
+     * Private key associated with the account
      */
-    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 {
+    readonly privateKey: PrivateKey;
+    readonly publicKey: AnyPublicKey;
+    readonly accountAddress: AccountAddress;
+    readonly signingScheme = SigningScheme.SingleKey;
+    constructor(args: SingleKeySignerConstructorArgs);
     /**
-     * Serialize a Raw Transaction With Data
+     * Derives an account from a randomly generated private key.
+     * Default generation is using an Ed25519 key
+     * @returns Account with the given signature scheme
      */
-    abstract serialize(serializer: Serializer): void;
+    static generate(args?: SingleKeySignerGenerateArgs): SingleKeyAccount;
     /**
-     * Deserialize a Raw Transaction With Data
+     * 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 deserialize(deserializer: Deserializer): RawTransactionWithData;
-}
-/**
- * Representation of a Multi Agent Transaction that can serialized and deserialized
- */
-declare class MultiAgentRawTransaction extends RawTransactionWithData {
+    static fromDerivationPath(args: SingleKeySignerFromDerivationPathArgs): SingleKeyAccount;
     /**
-     * The raw transaction
+     * 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
      */
-    readonly raw_txn: RawTransaction;
+    verifySignature(args: VerifySingleKeySignatureArgs): boolean;
     /**
-     * The secondary signers on this transaction
+     * Sign a message using the account's private key.
+     * @param message the signing message, as binary input
+     * @return the AccountAuthenticator containing the signature, together with the account's public key
      */
-    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 {
+    signWithAuthenticator(message: HexInput): AccountAuthenticatorSingleKey;
     /**
-     * The raw transaction
+     * Sign a transaction using the account's private key.
+     * @param transaction the raw transaction
+     * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
      */
-    readonly raw_txn: RawTransaction;
+    signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorSingleKey;
     /**
-     * The secondary signers on this transaction - optional and can be empty
+     * Sign the given message using the account's private key.
+     * @param message in HexInput format
+     * @returns Signature
      */
-    readonly secondary_signer_addresses: Array<AccountAddress>;
+    sign(message: HexInput): AnySignature;
     /**
-     * The fee payer account address
+     * Sign the given transaction using the account's private key.
+     * @param transaction the transaction to be signed
+     * @returns Signature
      */
-    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;
+    signTransaction(transaction: AnyRawTransaction): AnySignature;
 }
 
 /**
- * Representation of a SimpleTransaction that can serialized and deserialized
+ * 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.
  */
-declare class SimpleTransaction extends Serializable {
-    rawTransaction: RawTransaction;
-    feePayerAddress?: AccountAddress | undefined;
-    readonly secondarySignerAddresses: undefined;
-    /**
-     * SimpleTransaction represents a simple transaction type of a single signer that
-     * can be submitted to Aptos chain for execution.
-     *
-     * 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
-     */
-    constructor(rawTransaction: RawTransaction, feePayerAddress?: AccountAddress);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): SimpleTransaction;
+interface CreateEd25519AccountFromPrivateKeyArgs {
+    privateKey: Ed25519PrivateKey;
+    address?: AccountAddressInput;
+    legacy?: true;
 }
-
 /**
- * Representation of the challenge which is needed to sign by owner of the account
- * to rotate the authentication key.
+ * 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.
  */
-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;
+interface CreateEd25519SingleKeyAccountFromPrivateKeyArgs {
+    privateKey: Ed25519PrivateKey;
+    address?: AccountAddressInput;
+    legacy: false;
 }
-
-declare abstract class TransactionAuthenticator extends Serializable {
-    abstract serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): TransactionAuthenticator;
+/**
+ * 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;
 }
 /**
- * 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.
+ * 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.
  */
-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;
+interface CreateAccountFromPrivateKeyArgs {
+    privateKey: PrivateKey;
+    address?: AccountAddressInput;
+    legacy?: boolean;
 }
 /**
- * Transaction authenticator Ed25519 for a multi signers transaction
- *
- * @param public_key Client's public key.
- * @param signature Multi Ed25519 signature of a raw transaction.
- *
+ * Arguments for generating an `Ed25519Account`.
+ * This is the input type used by default.
  */
-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;
+interface GenerateEd25519AccountArgs {
+    scheme?: SigningSchemeInput.Ed25519;
+    legacy?: true;
 }
 /**
- * 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
- *
+ * 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.
  */
-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;
+interface GenerateEd25519SingleKeyAccountArgs {
+    scheme?: SigningSchemeInput.Ed25519;
+    legacy: false;
 }
 /**
- * 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
- *
+ * 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.
  */
-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;
+interface GenerateSingleKeyAccountArgs {
+    scheme: Exclude<SigningSchemeInput, SigningSchemeInput.Ed25519>;
+    legacy?: false;
 }
 /**
- * Single Sender authenticator for a single signer transaction
- *
- * @param sender AccountAuthenticator
+ * Arguments for generating an opaque `Account`.
+ * This is used when the input signature scheme is not known at compilation time.
  */
-declare class TransactionAuthenticatorSingleSender extends TransactionAuthenticator {
-    readonly sender: AccountAuthenticator;
-    constructor(sender: AccountAuthenticator);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TransactionAuthenticatorSingleSender;
+interface GenerateAccountArgs {
+    scheme?: SigningSchemeInput;
+    legacy?: boolean;
 }
-
-declare class SignedTransaction extends Serializable {
-    readonly raw_txn: RawTransaction;
-    readonly authenticator: TransactionAuthenticator;
-    /**
-     * A SignedTransaction consists of a raw transaction and an authenticator. The authenticator
-     * contains a client's public key and the signature of the raw transaction.
-     *
-     * @see {@link https://aptos.dev/integration/creating-a-signed-transaction | Creating a Signed Transaction}
-     *
-     * @param raw_txn
-     * @param authenticator Contains a client's public key and the signature of the raw transaction.
-     * Authenticator has 3 flavors: single signature, multi-signature and multi-agent.
-     * @see {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs} for details.
-     */
-    constructor(raw_txn: RawTransaction, authenticator: TransactionAuthenticator);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): SignedTransaction;
+/**
+ * Arguments for deriving a private key from a mnemonic phrase and a BIP44 path.
+ */
+interface PrivateKeyFromDerivationPathArgs {
+    path: string;
+    mnemonic: string;
 }
-
 /**
- * Representation of a Raw Transaction 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 class MultiAgentTransaction extends Serializable {
-    rawTransaction: RawTransaction;
-    feePayerAddress?: AccountAddress | undefined;
-    secondarySignerAddresses: AccountAddress[];
+declare abstract class Account$1 {
     /**
-     * SimpleTransaction represents a simple transaction type of a single signer that
-     * can be submitted to Aptos chain for execution.
+     * 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.
      *
-     * SimpleTransaction metadata contains the Raw Transaction and an optional
-     * sponsor Account Address to pay the gas fees.
+     * @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 rawTransaction The Raw Tranasaction
-     * @param feePayerAddress The sponsor Account Address
+     * @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
      */
-    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;
-};
+    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 a transaction using the available signing capabilities.
+     * @param transaction the raw transaction
+     * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
+     */
+    abstract signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticator;
+    /**
+     * Sign the given message using the available signing capabilities.
+     * @param message in HexInput format
+     * @returns Signature
+     */
+    abstract sign(message: HexInput): Signature;
+    /**
+     * Sign the given transaction using the available signing capabilities.
+     * @param transaction the transaction to be signed
+     * @returns Signature
+     */
+    abstract signTransaction(transaction: AnyRawTransaction): Signature;
+    /**
+     * 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
+     */
+    verifySignature(args: VerifySignatureArgs): boolean;
+}
+
+interface Ed25519SignerConstructorArgs {
+    privateKey: Ed25519PrivateKey;
+    address?: AccountAddressInput;
+}
+interface Ed25519SignerFromDerivationPathArgs {
+    path: string;
+    mnemonic: string;
+}
+interface VerifyEd25519SignatureArgs {
+    message: HexInput;
+    signature: Ed25519Signature;
+}
 /**
- * Interface of an View function's ABI.
+ * Signer implementation for the Ed25519 authentication scheme.
+ * This extends an {@link Ed25519Account} by adding signing capabilities through an {@link Ed25519PrivateKey}.
  *
- * 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
+ * Note: Generating a signer instance does not create the account on-chain.
  */
-interface InputGenerateSingleSignerRawTransactionArgs {
-    aptosConfig: AptosConfig;
-    sender: AccountAddressInput;
-    payload: AnyTransactionPayloadInstance;
-    options?: InputGenerateTransactionOptions;
-    feePayerAddress?: AccountAddressInput;
+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;
+    /**
+     * 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
+     */
+    verifySignature(args: VerifyEd25519SignatureArgs): boolean;
+    /**
+     * Sign a message using the account's Ed25519 private key.
+     * @param message the signing message, as binary input
+     * @return the AccountAuthenticator containing the signature, together with the account's public key
+     */
+    signWithAuthenticator(message: HexInput): AccountAuthenticatorEd25519;
+    /**
+     * Sign a transaction using the account's Ed25519 private key.
+     * @param transaction the raw transaction
+     * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
+     */
+    signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorEd25519;
+    /**
+     * Sign the given message using the account's Ed25519 private key.
+     * @param message in HexInput format
+     * @returns Signature
+     */
+    sign(message: HexInput): Ed25519Signature;
+    /**
+     * Sign the given transaction using the available signing capabilities.
+     * @param transaction the transaction to be signed
+     * @returns Signature
+     */
+    signTransaction(transaction: AnyRawTransaction): Ed25519Signature;
 }
-/**
- * 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;
+
+interface VerifyMultiKeySignatureArgs {
+    message: HexInput;
+    signature: MultiKeySignature;
 }
 /**
- * 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
+ * Signer implementation for the MultiKey authentication scheme.
+ *
+ * This accounts to use a M of N signing scheme. M and N are specified in the {@link MultiKey}
+ * It signs messages via the array of M number of Accounts that individually correspond to a public key in the {@link MultiKey}.
+ *
+ * Note: Generating a signer instance does not create the account on-chain.
  */
-type AnyRawTransaction = SimpleTransaction | MultiAgentTransaction;
-type InputSimulateTransactionData = {
+declare class MultiKeyAccount implements Account$1 {
+    /**
+     * Public key associated with the account
+     */
+    readonly publicKey: MultiKey;
+    /**
+     * Account address associated with the account
+     */
+    readonly accountAddress: AccountAddress;
+    /**
+     * Signing scheme used to sign transactions
+     */
+    readonly signingScheme: SigningScheme;
+    /**
+     * The signers used to sign messages.  These signers should correspond to public keys in the
+     * MultiKeyAccount's public key.  The number of signers should be equal or greater
+     * than this.publicKey.signaturesRequired
+     */
+    readonly signers: Account$1[];
+    /**
+     * An array of indicies where for signer[i], signerIndicies[i] is the index of the corresponding public key in
+     * publicKey.publicKeys.  Used to derive the right public key to use for verification.
+     */
+    readonly signerIndicies: number[];
+    readonly signaturesBitmap: Uint8Array;
+    /**
+     * constructor for MultiKeyAccount
+     *
+     * @param args.multiKey the multikey of the account which consists of N public keys and a number M which is
+     * the number of required signatures.
+     * @param args.signers an array of M signers that will be used to sign the transaction
+     * @returns MultiKeyAccount
+     */
+    constructor(args: {
+        multiKey: MultiKey;
+        signers: Account$1[];
+    });
+    /**
+     * Static constructor for MultiKeyAccount
+     *
+     * @param args.publicKeys the N public keys of the MultiKeyAccount
+     * @param args.signaturesRequired the number of signatures required
+     * @param args.signers an array of M signers that will be used to sign the transaction
+     * @returns MultiKeyAccount
+     */
+    static fromPublicKeysAndSigners(args: {
+        publicKeys: PublicKey[];
+        signaturesRequired: number;
+        signers: Account$1[];
+    }): MultiKeyAccount;
+    static isMultiKeySigner(account: Account$1): account is MultiKeyAccount;
+    /**
+     * Sign a message using the account's signers.
+     * @param message the signing message, as binary input
+     * @return the AccountAuthenticator containing the signature, together with the account's public key
+     */
+    signWithAuthenticator(message: HexInput): AccountAuthenticatorMultiKey;
+    /**
+     * Sign a transaction using the account's signers.
+     * @param transaction the raw transaction
+     * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
+     */
+    signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorMultiKey;
+    /**
+     * Sign the given message using the MultiKeyAccount's signers
+     * @param message in HexInput format
+     * @returns MultiKeySignature
+     */
+    sign(data: HexInput): MultiKeySignature;
+    /**
+     * Sign the given transaction using the MultiKeyAccount's signers
+     * @param transaction the transaction to be signed
+     * @returns MultiKeySignature
+     */
+    signTransaction(transaction: AnyRawTransaction): MultiKeySignature;
+    /**
+     * Verify the given message and signature with the public key.
+     *
+     * @param args.message raw message data in HexInput format
+     * @param args.signatures signed message MultiKeySignature
+     * @returns boolean
+     */
+    verifySignature(args: VerifyMultiKeySignatureArgs): boolean;
+}
+
+/**
+ * A class to query all `Account` related queries on Aptos.
+ */
+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"
+     * }
+     * ```
+     */
+    getAccountInfo(args: {
+        accountAddress: AccountAddressInput;
+    }): Promise<AccountData>;
+    /**
+     * 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
+     */
+    getAccountModules(args: {
+        accountAddress: AccountAddressInput;
+        options?: PaginationArgs & LedgerVersionArg;
+    }): Promise<MoveModuleBytecode[]>;
+    /**
+     * Queries for a specific account module given account address and module name
+     *
+     * @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
+     *
+     * @returns Account module
+     *
+     * @example
+     * const module = await aptos.getAccountModule({accountAddress:"0x456"})
+     * // An example of an account module response
+     * ```
+     * {
+     *    bytecode: "0xa11ceb0b0600000006010002030206050807070f0d081c200",
+     *    abi: { address: "0x1" }
+     * }
+     * ```
+     */
+    getAccountModule(args: {
+        accountAddress: AccountAddressInput;
+        moduleName: string;
+        options?: LedgerVersionArg;
+    }): Promise<MoveModuleBytecode>;
+    /**
+     * 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.
+     *
+     * @example
+     * const transactions = await aptos.getAccountTransactions({accountAddress:"0x456"})
+     *
+     * @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
+     *
+     * @returns The account transactions
+     */
+    getAccountTransactions(args: {
+        accountAddress: AccountAddressInput;
+        options?: PaginationArgs;
+    }): Promise<TransactionResponse[]>;
+    /**
+     * 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
+     */
+    getAccountResources(args: {
+        accountAddress: AccountAddressInput;
+        options?: PaginationArgs & LedgerVersionArg;
+    }): Promise<MoveResource[]>;
+    /**
+     * 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"})
+     *
+     */
+    getAccountResource<T extends {} = any>(args: {
+        accountAddress: AccountAddressInput;
+        resourceType: MoveStructId;
+        options?: LedgerVersionArg;
+    }): Promise<T>;
+    /**
+     * 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
+     */
+    lookupOriginalAccountAddress(args: {
+        authenticationKey: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: LedgerVersionArg;
+    }): Promise<AccountAddress>;
+    /**
+     * 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
+     */
+    getAccountTokensCount(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<number>;
+    /**
+     * 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
+     */
+    getAccountOwnedTokens(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensQueryResponse[0]>;
+    }): Promise<GetAccountOwnedTokensQueryResponse>;
+    /**
+     * Queries all current tokens of a specific collection that an account owns by the collection address
+     *
+     * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.
+     * If you want to get only the token from a specific standard, you can pass an optional tokenStandard 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
+     */
+    getAccountOwnedTokensFromCollectionAddress(args: {
+        accountAddress: AccountAddressInput;
+        collectionAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensFromCollectionResponse[0]>;
+    }): Promise<GetAccountOwnedTokensFromCollectionResponse>;
+    /**
+     * Queries for all collections that an account currently has tokens for.
+     *
+     * 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
+     */
+    getAccountCollectionsWithOwnedTokens(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountCollectionsWithOwnedTokenResponse[0]>;
+    }): Promise<GetAccountCollectionsWithOwnedTokenResponse>;
+    /**
+     * Queries the current count of transactions submitted by an account
+     *
+     * @example
+     * const accountTransactionsCount = await aptos.getAccountTransactionsCount({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 count of transactions made by an account
+     */
+    getAccountTransactionsCount(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<number>;
     /**
-     * The transaction to simulate, probably generated by `generateTransaction()`
+     * Queries an account's coins data
+     *
+     * @example
+     * const accountCoinsData = await aptos.getAccountCoinsData({accountAddress:"0x123"})
+     *
+     * @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
      */
-    transaction: AnyRawTransaction;
+    getAccountCoinsData(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & OrderByArg<GetAccountCoinsDataResponse[0]> & WhereArg<CurrentFungibleAssetBalancesBoolExp>;
+    }): Promise<GetAccountCoinsDataResponse>;
     /**
-     * For a single signer transaction
+     * Queries the current count of an account's coins aggregated
+     *
+     * @example
+     * const accountCoinsCount = await aptos.getAccountCoinsCount({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 count of the aggregated count of all account's coins
      */
-    signerPublicKey: PublicKey;
+    getAccountCoinsCount(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<number>;
     /**
-     * For a fee payer or multi-agent transaction that requires additional signers in
+     * 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
      */
-    secondarySignersPublicKeys?: Array<PublicKey>;
+    getAccountAPTAmount(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<number>;
     /**
-     * For a fee payer transaction (aka Sponsored 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
      */
-    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>;
+    getAccountCoinAmount(args: {
+        accountAddress: AccountAddressInput;
+        coinType: MoveStructId;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<number>;
+    /**
+     * 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
+     */
+    getAccountOwnedObjects(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & OrderByArg<GetAccountOwnedObjectsResponse[0]>;
+    }): Promise<GetAccountOwnedObjectsResponse>;
+    /**
+     * Derives an account by providing a private key.
+     * This functions resolves the provided private key type and derives the public key from it.
+     *
+     * If the privateKey is a Secp256k1 type, it derives the account using the derived public key and
+     * auth key using the SingleKey scheme locally.
+     *
+     * If the privateKey is a ED25519 type, it looks up the authentication key on chain, and uses it to resolve
+     * whether it is a Legacy ED25519 key or a Unified ED25519 key. It then derives the account based
+     * on that.
+     *
+     * @example
+     * const account = await aptos.deriveAccountFromPrivateKey({privateKey:new Ed25519PrivateKey("0x123")})
+     *
+     * @param args.privateKey An account private key
+     * @returns Account type
+     */
+    deriveAccountFromPrivateKey(args: {
+        privateKey: PrivateKey;
+    }): Promise<Account$1>;
 }
 
 /**
@@ -3891,18 +4058,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
  *
@@ -3923,15 +4078,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;
-declare function generateSigningMessage(transaction: AnyRawTransaction): Uint8Array;
 
 /**
  * Convert type arguments to only type tags, allowing for string representations of type tags
@@ -3973,6 +4119,43 @@ 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;
+/**
+ * Generates the 'signing message' form of a message to be signed.
+ *
+ * @param bytes The byte representation of the message to be signed and sent to the chain
+ * @param domainSeparator A domain separator that starts with 'APTOS::'
+ *
+ * @returns The Uint8Array of the signing message
+ */
+declare function generateSigningMessage(bytes: Uint8Array, domainSeparator: string): Uint8Array;
+/**
+ * Generates the 'signing message' form of a serilizable value. It bcs serializes the value and uses the name of
+ * its constructor as the domain separator.
+ *
+ * @param serializable An object that has a bcs serialized form
+ *
+ * @returns The Uint8Array of the signing message
+ */
+declare function generateSigningMessageForSerializable(serializable: Serializable): Uint8Array;
+/**
+ * Generates the 'signing message' form of a transaction. It derives the type of transaction and
+ * applies the appropriate domain separator based on if there is extra data such as a fee payer or
+ * secondary signers.
+ *
+ * @param transaction A transaction that is to be signed
+ *
+ * @returns The Uint8Array of the signing message
+ */
+declare function generateSigningMessageForTransaction(transaction: AnyRawTransaction): Uint8Array;
+
 declare enum TypeTagParserErrorType {
     InvalidTypeTag = "unknown type",
     UnexpectedGenericType = "unexpected generic type",
@@ -4179,31 +4362,6 @@ declare class General {
             withTransactions?: boolean;
         };
     }): Promise<Block>;
-    /**
-     * 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
-     *
-     * @returns Table item value rendered in JSON
-     */
-    getTableItem<T>(args: {
-        handle: string;
-        data: TableItemRequest;
-        options?: LedgerVersionArg;
-    }): Promise<T>;
     /**
      * Queries for a Move view function
      * @param args.payload Payload for the view function
@@ -5276,6 +5434,81 @@ declare class Transaction {
     }): Promise<PendingTransactionResponse>;
 }
 
+/**
+ * A class to query all `Table` Aptos related queries
+ */
+declare class Table {
+    readonly config: AptosConfig;
+    constructor(config: AptosConfig);
+    /**
+     * 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.
+     *
+     * Note, this query calls the fullnode server
+     *
+     * @example https://api.devnet.aptoslabs.com/v1/accounts/0x1/resource/0x1::coin::CoinInfo%3C0x1::aptos_coin::AptosCoin%3E
+     * const tableItem = await aptos.getTableItem({
+     *  handle: "0x1b854694ae746cdbd8d44186ca4929b2b337df21d1c74633be19b2710552fdca",
+     *  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
+     *
+     * @returns Table item value rendered in JSON
+     */
+    getTableItem<T>(args: {
+        handle: string;
+        data: TableItemRequest;
+        options?: LedgerVersionArg;
+    }): Promise<T>;
+    /**
+     * Queries for a table items data.
+     *
+     * Optional `options.where` param can be passed to filter the response.
+     *
+     * Note, this query calls the indexer server
+     *
+     * @example
+     * const data = await aptos.getTableItemsData({
+     *  options: { where: {
+     *      table_handle: { _eq: "0x1b854694ae746cdbd8d44186ca4929b2b337df21d1c74633be19b2710552fdca" },
+     *      transaction_version: { _eq: "0" }
+     *    }
+     *  },
+     * });
+     *
+     * @returns GetTableItemsDataResponse
+     */
+    getTableItemsData(args: {
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & WhereArg<TableItemsBoolExp> & OrderByArg<GetTableItemsDataResponse[0]>;
+    }): Promise<GetTableItemsDataResponse>;
+    /**
+     * Queries for a table items metadata.
+     *
+     * Optional `options.where` param can be passed to filter the response.
+     *
+     * Note, this query calls the indexer server
+     *
+     * @example
+     * const data = await aptos.getTableItemsMetadata({
+     *  options: { where: { handle: { _eq: "0x1b854694ae746cdbd8d44186ca4929b2b337df21d1c74633be19b2710552fdca" } } },
+     * });
+     *
+     * @returns GetTableItemsMetadataResponse
+     */
+    getTableItemsMetadata(args: {
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & WhereArg<TableMetadatasBoolExp> & OrderByArg<GetTableItemsMetadataResponse[0]>;
+    }): Promise<GetTableItemsMetadataResponse>;
+}
+
 /**
  * This class is the main entry point into Aptos's
  * APIs and separates functionality into different namespaces.
@@ -5299,9 +5532,10 @@ declare class Aptos {
     readonly general: General;
     readonly staking: Staking;
     readonly transaction: Transaction;
+    readonly table: Table;
     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, Staking, Table, Omit<Transaction, "build" | "simulate" | "submit" | "batch"> {
 }
 
 /**
@@ -5464,4 +5698,4 @@ declare function postAptosFullNode<Req extends {}, Res extends {}>(options: Post
 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>>;
 
-export { APTOS_BIP44_REGEX, APTOS_COIN, APTOS_HARDENED_REGEX, Account$1 as Account, AccountAddress, AccountAddressInput, AccountAuthenticator, AccountAuthenticatorEd25519, AccountAuthenticatorMultiEd25519, AccountAuthenticatorMultiKey, AccountAuthenticatorSingleKey, AccountData, AccountPublicKey, AccountSequenceNumber, AnyNumber, AnyPublicKey, AnyPublicKeyVariant, type AnyRawTransaction, type AnyRawTransactionInstance, AnySignature, type AnyTransactionPayloadInstance, Aptos, AptosApiError, AptosApiType, AptosConfig, AptosRequest, type AptosResponse, AptosSettings, AuthenticationKey, AuthenticationKeyScheme, Block, Bool, CKDPriv, ChainId, Client, ClientConfig, ClientRequest, ClientResponse, CommittedTransactionResponse, type CreateAccountFromPrivateKeyArgs, type CreateEd25519AccountFromPrivateKeyArgs, type CreateEd25519SingleKeyAccountFromPrivateKeyArgs, type CreateSingleKeyAccountFromPrivateKeyArgs, DEFAULT_MAX_GAS_AMOUNT, DEFAULT_TXN_EXP_SEC_FROM_NOW, DEFAULT_TXN_TIMEOUT_SEC, type DerivedKeys, Deserializable, type DeserializableClass, Deserializer, Ed25519Account, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, type Ed25519SignerConstructorArgs, type Ed25519SignerFromDerivationPathArgs, EntryFunction, type EntryFunctionABI, EntryFunctionArgument, type EntryFunctionArgumentTypes, EntryFunctionBytes, type ExecutionFinishEventData, type FailureEventData, FaucetConfig, FeePayerRawTransaction, FixedBytes, FullNodeConfig, type FunctionABI, GasEstimation, type GenerateAccountArgs, type GenerateEd25519AccountArgs, type GenerateEd25519SingleKeyAccountArgs, type GenerateSingleKeyAccountArgs, GetANSNameResponse, GetAccountCoinsDataResponse, GetAccountCollectionsWithOwnedTokenResponse, GetAccountOwnedObjectsResponse, GetAccountOwnedTokensFromCollectionResponse, GetAccountOwnedTokensQueryResponse, type GetAptosRequestOptions, GetChainTopUserTransactionsResponse, GetCollectionDataResponse, GetCurrentFungibleAssetBalancesResponse, GetCurrentTokenOwnershipResponse, GetDelegatedStakingActivitiesResponse, GetEventsResponse, GetFungibleAssetActivitiesResponse, GetFungibleAssetMetadataResponse, GetNumberOfDelegatorsResponse, GetOwnedTokensResponse, GetProcessorStatusResponse, type GetRequestOptions, GetTokenActivityResponse, GetTokenDataResponse, GraphqlQuery, HARDENED_OFFSET, Hex, HexInput, Identifier, 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, LedgerInfo, LedgerVersionArg, MimeType, ModuleId, MoveFunction, MoveFunctionGenericTypeParam, MoveFunctionId, MoveModuleBytecode, MoveModuleId, MoveOption, MoveResource, MoveString, MoveStructId, MoveValue, MoveVector, MultiAgentRawTransaction, MultiAgentTransaction, MultiEd25519PublicKey, MultiEd25519Signature, MultiKey, MultiKeySignature, MultiSig, MultiSigTransactionPayload, Network, OrderByArg, PaginationArgs, PendingTransactionResponse, type PostAptosRequestOptions, type PostRequestOptions, type PrivateKey, type PrivateKeyFromDerivationPathArgs, ProcessorType, PublicKey, RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT, RawTransaction, RawTransactionWithData, RotationProofChallenge, Script, ScriptFunctionArgument, type ScriptFunctionArgumentTypes, Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature, Serializable, Serializer, Signature, SignedTransaction, SigningScheme, SigningSchemeInput, type SimpleEntryFunctionArgumentTypes, SimpleTransaction, SingleKeyAccount, type SingleKeySignerConstructorArgs, type SingleKeySignerFromDerivationPathArgs, type SingleKeySignerGenerateArgs, StructTag, type SuccessEventData, TableItemRequest, TokenStandardArg, TransactionArgument, TransactionAuthenticator, TransactionAuthenticatorEd25519, TransactionAuthenticatorFeePayer, TransactionAuthenticatorMultiAgent, TransactionAuthenticatorMultiEd25519, TransactionAuthenticatorSingleSender, TransactionPayload, TransactionPayloadEntryFunction, TransactionPayloadMultiSig, TransactionPayloadScript, TransactionResponse, TransactionWorker, type TransactionWorkerEvents, TransactionWorkerEventsEnum, TypeTag, TypeTagAddress, TypeTagBool, TypeTagGeneric, TypeTagParserError, TypeTagParserErrorType, TypeTagReference, TypeTagSigner, TypeTagStruct, TypeTagU128, TypeTagU16, TypeTagU256, TypeTagU32, TypeTagU64, TypeTagU8, TypeTagVector, U128, U16, U256, U32, U64, U8, Uint16, Uint32, Uint8, UserTransactionResponse, type VerifyEd25519SignatureArgs, type VerifySignatureArgs, type VerifySingleKeySignatureArgs, type ViewFunctionABI, WaitForTransactionOptions, WhereArg, aptosCoinStructTag, aptosRequest, buildTransaction, checkOrConvertArgument, convertArgument, createObjectAddress, createResourceAddress, createTokenAddress, deriveKey, deriveTransactionType, deserializeFromScriptArgument, fetchEntryFunctionAbi, fetchFunctionAbi, fetchViewFunctionAbi, findFirstNonSignerArg, generateRawTransaction, generateSignedTransaction, generateSignedTransactionForSimulation, generateSigningMessage, generateTransactionPayload, generateTransactionPayloadWithABI, generateUserTransactionHash, generateViewFunctionPayload, generateViewFunctionPayloadWithABI, get, getAptosFullNode, getAuthenticatorForSimulation, getFunctionParts, hashValues, isBcsAddress, isBcsBool, isBcsFixedBytes, isBcsString, isBcsU128, isBcsU16, isBcsU256, isBcsU32, isBcsU64, isBcsU8, isBool, isEncodedEntryFunctionArgument, isLargeNumber, isNull, isNumber, isScriptDataInput, isString, isValidBIP44Path, isValidHardenedPath, mnemonicToSeed, normalizeBundle, objectStructTag, optionStructTag, paginateWithCursor, parseTypeTag, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, promiseFulfilledStatus, request, sign, splitPath, standardizeTypeTags, stringStructTag, throwTypeMismatch };
+export { APTOS_BIP44_REGEX, APTOS_COIN, APTOS_HARDENED_REGEX, Account$1 as Account, AccountAddress, AccountAddressInput, AccountAuthenticator, AccountAuthenticatorEd25519, AccountAuthenticatorMultiEd25519, AccountAuthenticatorMultiKey, AccountAuthenticatorSingleKey, AccountData, AccountPublicKey, AccountSequenceNumber, AnyNumber, AnyPublicKey, AnyPublicKeyVariant, type AnyRawTransaction, type AnyRawTransactionInstance, AnySignature, type AnyTransactionPayloadInstance, Aptos, AptosApiError, AptosApiType, AptosConfig, AptosRequest, type AptosResponse, AptosSettings, AuthenticationKey, AuthenticationKeyScheme, Block, Bool, CKDPriv, ChainId, Client, ClientConfig, ClientRequest, ClientResponse, CommittedTransactionResponse, type CreateAccountFromPrivateKeyArgs, type CreateEd25519AccountFromPrivateKeyArgs, type CreateEd25519SingleKeyAccountFromPrivateKeyArgs, type CreateSingleKeyAccountFromPrivateKeyArgs, DEFAULT_MAX_GAS_AMOUNT, DEFAULT_TXN_EXP_SEC_FROM_NOW, DEFAULT_TXN_TIMEOUT_SEC, type DerivedKeys, Deserializable, type DeserializableClass, Deserializer, Ed25519Account, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, type Ed25519SignerConstructorArgs, type Ed25519SignerFromDerivationPathArgs, EntryFunction, type EntryFunctionABI, EntryFunctionArgument, type EntryFunctionArgumentTypes, EntryFunctionBytes, type ExecutionFinishEventData, type FailureEventData, FaucetConfig, FeePayerRawTransaction, FixedBytes, FullNodeConfig, type FunctionABI, GasEstimation, type GenerateAccountArgs, type GenerateEd25519AccountArgs, type GenerateEd25519SingleKeyAccountArgs, type GenerateSingleKeyAccountArgs, GetANSNameResponse, GetAccountCoinsDataResponse, GetAccountCollectionsWithOwnedTokenResponse, GetAccountOwnedObjectsResponse, GetAccountOwnedTokensFromCollectionResponse, GetAccountOwnedTokensQueryResponse, type GetAptosRequestOptions, GetChainTopUserTransactionsResponse, GetCollectionDataResponse, GetCurrentFungibleAssetBalancesResponse, GetCurrentTokenOwnershipResponse, GetDelegatedStakingActivitiesResponse, GetEventsResponse, GetFungibleAssetActivitiesResponse, GetFungibleAssetMetadataResponse, GetNumberOfDelegatorsResponse, GetOwnedTokensResponse, GetProcessorStatusResponse, type GetRequestOptions, GetTableItemsDataResponse, GetTableItemsMetadataResponse, GetTokenActivityResponse, GetTokenDataResponse, GraphqlQuery, HARDENED_OFFSET, Hex, HexInput, Identifier, 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, LedgerInfo, LedgerVersionArg, MimeType, ModuleId, MoveFunction, MoveFunctionGenericTypeParam, MoveFunctionId, MoveModuleBytecode, MoveModuleId, MoveOption, MoveResource, MoveString, MoveStructId, MoveValue, MoveVector, MultiAgentRawTransaction, MultiAgentTransaction, MultiEd25519PublicKey, MultiEd25519Signature, MultiKey, MultiKeyAccount, MultiKeySignature, MultiSig, MultiSigTransactionPayload, Network, OrderByArg, PaginationArgs, PendingTransactionResponse, type PostAptosRequestOptions, type PostRequestOptions, type PrivateKey, type PrivateKeyFromDerivationPathArgs, ProcessorType, PublicKey, RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT, RawTransaction, RawTransactionWithData, RotationProofChallenge, Script, ScriptFunctionArgument, type ScriptFunctionArgumentTypes, Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature, Serializable, Serializer, Signature, SignedTransaction, SigningScheme, SigningSchemeInput, type SimpleEntryFunctionArgumentTypes, SimpleTransaction, SingleKeyAccount, type SingleKeySignerConstructorArgs, type SingleKeySignerFromDerivationPathArgs, type SingleKeySignerGenerateArgs, StructTag, type SuccessEventData, TableItemRequest, TokenStandardArg, TransactionArgument, TransactionAuthenticator, TransactionAuthenticatorEd25519, TransactionAuthenticatorFeePayer, TransactionAuthenticatorMultiAgent, TransactionAuthenticatorMultiEd25519, TransactionAuthenticatorSingleSender, TransactionPayload, TransactionPayloadEntryFunction, TransactionPayloadMultiSig, TransactionPayloadScript, TransactionResponse, TransactionWorker, type TransactionWorkerEvents, TransactionWorkerEventsEnum, TypeTag, TypeTagAddress, TypeTagBool, TypeTagGeneric, TypeTagParserError, TypeTagParserErrorType, TypeTagReference, TypeTagSigner, TypeTagStruct, TypeTagU128, TypeTagU16, TypeTagU256, TypeTagU32, TypeTagU64, TypeTagU8, TypeTagVector, U128, U16, U256, U32, U64, U8, Uint16, Uint32, Uint8, UserTransactionResponse, type VerifyEd25519SignatureArgs, type VerifyMultiKeySignatureArgs, type VerifySignatureArgs, type VerifySingleKeySignatureArgs, type ViewFunctionABI, WaitForTransactionOptions, WhereArg, aptosCoinStructTag, aptosRequest, buildTransaction, checkOrConvertArgument, convertArgument, deriveKey, deriveTransactionType, deserializeFromScriptArgument, fetchEntryFunctionAbi, fetchFunctionAbi, fetchViewFunctionAbi, findFirstNonSignerArg, generateRawTransaction, generateSignedTransaction, generateSignedTransactionForSimulation, generateSigningMessage, generateSigningMessageForSerializable, generateSigningMessageForTransaction, generateTransactionPayload, generateTransactionPayloadWithABI, generateUserTransactionHash, generateViewFunctionPayload, generateViewFunctionPayloadWithABI, get, getAptosFullNode, getAuthenticatorForSimulation, getFunctionParts, hashValues, isBcsAddress, isBcsBool, isBcsFixedBytes, isBcsString, isBcsU128, isBcsU16, isBcsU256, isBcsU32, isBcsU64, isBcsU8, isBool, isEncodedEntryFunctionArgument, isLargeNumber, isNull, isNumber, isScriptDataInput, isString, isValidBIP44Path, isValidHardenedPath, mnemonicToSeed, normalizeBundle, objectStructTag, optionStructTag, paginateWithCursor, parseTypeTag, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, promiseFulfilledStatus, request, splitPath, standardizeTypeTags, stringStructTag, throwTypeMismatch };