@aptos-labs/ts-sdk 3.1.2 → 4.0.0-zeta.0

package/dist/common/index.d.ts

@@ -1,5 +1,5 @@
-import { A as AccountAddress, a as AccountPublicKey, b as AuthenticationKey, V as VerifySignatureArgs, c as VerifySignatureAsyncArgs, S as Serializer, d as Signature, H as HexInput, D as Deserializer, P as PublicKey, E as EphemeralPublicKeyVariant, e as AptosConfig, f as Serializable, g as EphemeralCertificateVariant, Z as ZkpVariant, L as LedgerVersionArg, h as AccountAddressInput, i as Ed25519PublicKey, j as AnyPublicKey, M as MultiKey, k as MultiEd25519PublicKey, l as Ed25519Signature, m as MultiEd25519Signature, n as AccountAuthenticator, o as MoveString, p as MoveVector, U as U8, q as U64, r as AnyNumber, R as RawTransaction, s as SimpleEntryFunctionArgumentTypes, t as EntryFunctionArgumentTypes, B as Bool, F as FixedBytes, u as U16, v as U32, w as U128, x as U256, I as InputGenerateTransactionPayloadDataWithRemoteABI, y as InputGenerateTransactionPayloadData, z as InputScriptData, C as MoveFunction, T as TransactionPayloadScript, G as InputEntryFunctionDataWithRemoteABI, J as TransactionPayloadEntryFunction, K as InputMultiSigDataWithRemoteABI, N as TransactionPayloadMultiSig, O as InputEntryFunctionDataWithABI, Q as InputMultiSigDataWithABI, W as InputViewFunctionDataWithRemoteABI, X as EntryFunction, Y as InputViewFunctionDataWithABI, _ as AnyTransactionPayloadInstance, $ as InputGenerateTransactionOptions, a0 as TransactionInnerPayload, a1 as InputGenerateSingleSignerRawTransactionArgs, a2 as SimpleTransaction, a3 as InputGenerateMultiAgentRawTransactionArgs, a4 as MultiAgentTransaction, a5 as InputSimulateTransactionData, a6 as AccountAuthenticatorNoAccountAuthenticator, a7 as AccountAuthenticatorEd25519, a8 as AccountAuthenticatorSingleKey, a9 as AccountAuthenticatorMultiKey, aa as InputSubmitTransactionData, ab as TypeArgument, ac as TypeTag, ad as MoveModule, ae as FunctionABI, af as EntryFunctionABI, ag as ViewFunctionABI, ah as AnyRawTransaction, ai as AnyRawTransactionInstance, aj as AccountData, ak as MoveModuleBytecode, al as CursorPaginationArgs, am as PaginationArgs, an as TransactionResponse, ao as MoveResource, ap as MoveStructId, aq as TokenStandardArg, ar as OrderByArg, as as GetAccountOwnedTokensQueryResponse, at as GetAccountOwnedTokensFromCollectionResponse, au as GetAccountCollectionsWithOwnedTokenResponse, av as GetAccountCoinsDataResponse, aw as WhereArg, ax as GetObjectDataQueryResponse, ay as PrivateKeyInput, az as GetCollectionDataResponse, aA as GetTokenDataResponse, aB as GetCurrentTokenOwnershipResponse, aC as GetOwnedTokensResponse, aD as GetTokenActivityResponse, aE as GetEventsResponse, aF as WaitForTransactionOptions, aG as UserTransactionResponse, aH as GetFungibleAssetMetadataResponse, aI as GetFungibleAssetActivitiesResponse, aJ as GetCurrentFungibleAssetBalancesResponse, aK as LedgerInfo, aL as Block, aM as MoveValue, aN as InputViewFunctionData, aO as InputViewFunctionJsonData, aP as GetChainTopUserTransactionsResponse, aQ as GraphqlQuery, aR as ProcessorType, aS as GetProcessorStatusResponse, aT as GetANSNameResponse, aU as GetNumberOfDelegatorsResponse, aV as GetDelegatedStakingActivitiesResponse, aW as InputSimulateTransactionOptions, aX as InputTransactionPluginData, aY as PendingTransactionResponse, aZ as CommittedTransactionResponse, a_ as GasEstimation, a$ as Ed25519PrivateKey, b0 as TableItemRequest, b1 as GetTableItemsDataResponse, b2 as GetTableItemsMetadataResponse, b3 as PrivateKey, b4 as SigningScheme, b5 as SigningSchemeInput, b6 as AnySignature, b7 as EntryFunctionArgument, b8 as MultiKeySignature, b9 as AccountAuthenticatorMultiEd25519, ba as AccountAuthenticatorAbstraction, bb as MoveFunctionId, bc as ClientRequest, bd as Client, be as ClientResponse, bf as AptosRequest, bg as AptosApiType, bh as AptosResponse, bi as MimeType, bj as ClientConfig } from './account-Bb5REyaT.js';
-export { ea as APTOS_COIN, eb as APTOS_FA, bu as AbstractMultiKey, cy as AccountAuthenticatorVariant, dy as AccountSignature, bq as AddressInvalidReason, cA as AnyPublicKeyVariant, cC as AnySignatureVariant, cK as AptosSettings, dW as AuthenticationKeyScheme, d3 as BlockEndInfo, d4 as BlockEpilogueTransactionResponse, d0 as BlockMetadataTransactionResponse, bB as ChainId, cP as ClientHeadersType, e7 as DEFAULT_MAX_GAS_AMOUNT, e8 as DEFAULT_TXN_EXP_SEC_FROM_NOW, e9 as DEFAULT_TXN_TIMEOUT_SEC, dc as DecodedTableData, dd as DeletedTableData, dX as DeriveScheme, bk as Deserializable, dB as DirectWriteSet, df as EntryFunctionPayloadResponse, cD as EphemeralSignatureVariant, dD as Event, dC as EventGuid, ee as FIREBASE_AUTH_ISS_PATTERN, cN as FaucetConfig, bG as FeePayerRawTransaction, cL as FullNodeConfig, d_ as GenerateAccount, dY as GenerateAccountWithEd25519, dZ as GenerateAccountWithSingleSignerSecp256k1Key, di as GenesisPayload, c$ as GenesisTransactionResponse, cm as GetAccountAddressesForAuthKeyResponse, bz as Hex, by as HexInvalidReason, bC as Identifier, cM as IndexerConfig, ce as InputEntryFunctionData, ck as InputGenerateMultiAgentRawTransactionData, cd as InputGenerateOrderlessTransactionOptions, ci as InputGenerateRawTransactionArgs, cc as InputGenerateSequenceNumberTransactionOptions, cj as InputGenerateSingleSignerRawTransactionData, cl as InputGenerateTransactionData, cf as InputGenerateTransactionPayloadDataWithABI, cg as InputMultiSigData, bD as ModuleId, dR as MoveAbility, dK as MoveAddressType, dS as MoveFunctionGenericTypeParam, dQ as MoveFunctionVisibility, dP as MoveModuleId, dL as MoveObjectType, bp as MoveOption, dM as MoveOptionType, dj as MoveScriptBytecode, dU as MoveStruct, dT as MoveStructField, dN as MoveStructType, dO as MoveType, dI as MoveUint128Type, dF as MoveUint16Type, dJ as MoveUint256Type, dG as MoveUint32Type, dH as MoveUint64Type, dE as MoveUint8Type, bF as MultiAgentRawTransaction, bM as MultiSig, bN as MultiSigTransactionPayload, dh as MultisigPayloadResponse, e4 as Network, e5 as NetworkToChainId, e1 as NetworkToFaucetAPI, d$ as NetworkToIndexerAPI, e6 as NetworkToNetworkName, e0 as NetworkToNodeAPI, e2 as NetworkToPepperAPI, e3 as NetworkToProverAPI, cn as OrderBy, co as OrderByValue, br as ParsingError, bs as ParsingResult, cQ as PluginConfig, cR as PluginSettings, cz as PrivateKeyVariants, ec as RAW_TRANSACTION_SALT, ed as RAW_TRANSACTION_WITH_DATA_SALT, bE as RawTransactionWithData, dV as RoleType, bL as Script, bI as ScriptFunctionArgument, cb as ScriptFunctionArgumentTypes, dg as ScriptPayloadResponse, cr as ScriptTransactionArgumentVariants, dA as ScriptWriteSet, bw as Secp256k1PrivateKey, bv as Secp256k1PublicKey, bx as Secp256k1Signature, bo as Serialized, d1 as StateCheckpointTransactionResponse, c6 as StructTag, cp as TokenStandard, bH as TransactionArgument, cx as TransactionAuthenticatorVariant, ds as TransactionEd25519Signature, bP as TransactionExecutable, bS as TransactionExecutableEmpty, bR as TransactionExecutableEntryFunction, bQ as TransactionExecutableScript, cu as TransactionExecutableVariants, bT as TransactionExtraConfig, bU as TransactionExtraConfigV1, cv as TransactionExtraConfigVariants, dx as TransactionFeePayerSignature, cO as TransactionGenerationConfig, bO as TransactionInnerPayloadV1, ct as TransactionInnerPayloadVariants, dw as TransactionMultiAgentSignature, dv as TransactionMultiEd25519Signature, bK as TransactionPayload, de as TransactionPayloadResponse, cs as TransactionPayloadVariants, cT as TransactionResponseType, dt as TransactionSecp256k1Signature, dk as TransactionSignature, du as TransactionSingleSenderSignature, cS as TransactionSubmitter, cw as TransactionVariants, c0 as TypeTagAddress, bV as TypeTagBool, c3 as TypeTagGeneric, c2 as TypeTagReference, c1 as TypeTagSigner, c5 as TypeTagStruct, b_ as TypeTagU128, bX as TypeTagU16, b$ as TypeTagU256, bY as TypeTagU32, bZ as TypeTagU64, bW as TypeTagU8, cq as TypeTagVariants, c4 as TypeTagVector, cI as Uint128, cF as Uint16, cJ as Uint256, cG as Uint32, cH as Uint64, cE as Uint8, d2 as ValidatorTransactionResponse, ch as ViewFunctionJsonPayload, dz as WriteSet, d5 as WriteSetChange, d6 as WriteSetChangeDeleteModule, d7 as WriteSetChangeDeleteResource, d8 as WriteSetChangeDeleteTableItem, d9 as WriteSetChangeWriteModule, da as WriteSetChangeWriteResource, db as WriteSetChangeWriteTableItem, cB as anyPublicKeyVariantToString, c7 as aptosCoinStructTag, bJ as deserializeFromScriptArgument, bl as ensureBoolean, bA as hexToAsciiString, c_ as isBlockEpilogueTransactionResponse, cX as isBlockMetadataTransactionResponse, bt as isCanonicalEd25519Signature, dl as isEd25519Signature, dp as isFeePayerSignature, cW as isGenesisTransactionResponse, dn as isMultiAgentSignature, dq as isMultiEd25519Signature, cU as isPendingTransactionResponse, dm as isSecp256k1Signature, dr as isSingleSenderSignature, cY as isStateCheckpointTransactionResponse, cV as isUserTransactionResponse, cZ as isValidatorTransactionResponse, ca as objectStructTag, c9 as optionStructTag, bm as outOfRangeErrorMessage, c8 as stringStructTag, bn as validateNumberInRange } from './account-Bb5REyaT.js';
+import { A as AccountAddress, a as AccountPublicKey, b as AuthenticationKey, V as VerifySignatureArgs, c as VerifySignatureAsyncArgs, S as Serializer, d as Signature, H as HexInput, D as Deserializer, P as PublicKey, E as EphemeralPublicKeyVariant, e as AptosConfig, f as Serializable, g as EphemeralCertificateVariant, Z as ZkpVariant, L as LedgerVersionArg, h as AccountAddressInput, i as Ed25519PublicKey, j as AnyPublicKey, M as MultiKey, k as MultiEd25519PublicKey, l as Ed25519Signature, m as MultiEd25519Signature, n as AccountAuthenticator, o as MoveString, p as MoveVector, U as U8, q as U64, r as AnyNumber, R as RawTransaction, s as SimpleEntryFunctionArgumentTypes, t as EntryFunctionArgumentTypes, B as Bool, F as FixedBytes, u as U16, v as U32, w as U128, x as U256, I as InputGenerateTransactionPayloadDataWithRemoteABI, y as InputGenerateTransactionPayloadData, z as InputScriptData, C as MoveFunction, T as TransactionPayloadScript, G as InputEntryFunctionDataWithRemoteABI, J as TransactionPayloadEntryFunction, K as InputMultiSigDataWithRemoteABI, N as TransactionPayloadMultiSig, O as InputEntryFunctionDataWithABI, Q as InputMultiSigDataWithABI, W as InputViewFunctionDataWithRemoteABI, X as EntryFunction, Y as InputViewFunctionDataWithABI, _ as AnyTransactionPayloadInstance, $ as InputGenerateTransactionOptions, a0 as TransactionInnerPayload, a1 as InputGenerateSingleSignerRawTransactionArgs, a2 as SimpleTransaction, a3 as InputGenerateMultiAgentRawTransactionArgs, a4 as MultiAgentTransaction, a5 as InputSimulateTransactionData, a6 as AccountAuthenticatorNoAccountAuthenticator, a7 as AccountAuthenticatorEd25519, a8 as AccountAuthenticatorSingleKey, a9 as AccountAuthenticatorMultiKey, aa as InputSubmitTransactionData, ab as TypeArgument, ac as TypeTag, ad as MoveModule, ae as FunctionABI, af as EntryFunctionABI, ag as ViewFunctionABI, ah as AnyRawTransaction, ai as AnyRawTransactionInstance, aj as AccountData, ak as MoveModuleBytecode, al as CursorPaginationArgs, am as PaginationArgs, an as TransactionResponse, ao as MoveResource, ap as MoveStructId, aq as TokenStandardArg, ar as OrderByArg, as as GetAccountOwnedTokensQueryResponse, at as GetAccountOwnedTokensFromCollectionResponse, au as GetAccountCollectionsWithOwnedTokenResponse, av as GetAccountCoinsDataResponse, aw as WhereArg, ax as GetObjectDataQueryResponse, ay as PrivateKeyInput, az as GetCollectionDataResponse, aA as GetTokenDataResponse, aB as GetCurrentTokenOwnershipResponse, aC as GetOwnedTokensResponse, aD as GetTokenActivityResponse, aE as WaitForTransactionOptions, aF as UserTransactionResponse, aG as GetFungibleAssetMetadataResponse, aH as GetFungibleAssetActivitiesResponse, aI as GetCurrentFungibleAssetBalancesResponse, aJ as LedgerInfo, aK as Block, aL as MoveValue, aM as InputViewFunctionData, aN as InputViewFunctionJsonData, aO as GetChainTopUserTransactionsResponse, aP as GraphqlQuery, aQ as ProcessorType, aR as GetProcessorStatusResponse, aS as GetANSNameResponse, aT as GetNumberOfDelegatorsResponse, aU as GetDelegatedStakingActivitiesResponse, aV as InputSimulateTransactionOptions, aW as InputTransactionPluginData, aX as PendingTransactionResponse, aY as CommittedTransactionResponse, aZ as GasEstimation, a_ as Ed25519PrivateKey, a$ as TableItemRequest, b0 as GetTableItemsDataResponse, b1 as GetTableItemsMetadataResponse, b2 as PrivateKey, b3 as SigningScheme, b4 as SigningSchemeInput, b5 as AnySignature, b6 as MoveFunctionId, b7 as TransactionSubmitter, b8 as Network, b9 as EntryFunctionArgument, ba as MultiKeySignature, bb as AccountAuthenticatorMultiEd25519, bc as AccountAuthenticatorAbstraction, bd as ClientRequest, be as Client, bf as ClientResponse, bg as AptosRequest, bh as AptosApiType, bi as AptosResponse, bj as MimeType, bk as ClientConfig } from './account-D4dsN-1K.js';
+export { ea as APTOS_COIN, eb as APTOS_FA, bv as AbstractMultiKey, cA as AccountAuthenticatorVariant, dz as AccountSignature, br as AddressInvalidReason, cC as AnyPublicKeyVariant, cE as AnySignatureVariant, cM as AptosSettings, dX as AuthenticationKeyScheme, d4 as BlockEndInfo, d5 as BlockEpilogueTransactionResponse, d1 as BlockMetadataTransactionResponse, bC as ChainId, cR as ClientHeadersType, e7 as DEFAULT_MAX_GAS_AMOUNT, e8 as DEFAULT_TXN_EXP_SEC_FROM_NOW, e9 as DEFAULT_TXN_TIMEOUT_SEC, dd as DecodedTableData, de as DeletedTableData, dY as DeriveScheme, bl as Deserializable, dC as DirectWriteSet, dg as EntryFunctionPayloadResponse, cF as EphemeralSignatureVariant, dE as Event, dD as EventGuid, ee as FIREBASE_AUTH_ISS_PATTERN, cP as FaucetConfig, bH as FeePayerRawTransaction, cN as FullNodeConfig, d$ as GenerateAccount, dZ as GenerateAccountWithEd25519, d_ as GenerateAccountWithSingleSignerSecp256k1Key, dj as GenesisPayload, d0 as GenesisTransactionResponse, cn as GetAccountAddressesForAuthKeyResponse, co as GetEventsResponse, bA as Hex, bz as HexInvalidReason, bD as Identifier, cO as IndexerConfig, cf as InputEntryFunctionData, cl as InputGenerateMultiAgentRawTransactionData, ce as InputGenerateOrderlessTransactionOptions, cj as InputGenerateRawTransactionArgs, cd as InputGenerateSequenceNumberTransactionOptions, ck as InputGenerateSingleSignerRawTransactionData, cm as InputGenerateTransactionData, cg as InputGenerateTransactionPayloadDataWithABI, ch as InputMultiSigData, bE as ModuleId, dS as MoveAbility, dL as MoveAddressType, dT as MoveFunctionGenericTypeParam, dR as MoveFunctionVisibility, dQ as MoveModuleId, dM as MoveObjectType, bq as MoveOption, dN as MoveOptionType, dk as MoveScriptBytecode, dV as MoveStruct, dU as MoveStructField, dO as MoveStructType, dP as MoveType, dJ as MoveUint128Type, dG as MoveUint16Type, dK as MoveUint256Type, dH as MoveUint32Type, dI as MoveUint64Type, dF as MoveUint8Type, bG as MultiAgentRawTransaction, bN as MultiSig, bO as MultiSigTransactionPayload, di as MultisigPayloadResponse, e5 as NetworkToChainId, e2 as NetworkToFaucetAPI, e0 as NetworkToIndexerAPI, e6 as NetworkToNetworkName, e1 as NetworkToNodeAPI, e3 as NetworkToPepperAPI, e4 as NetworkToProverAPI, cp as OrderBy, cq as OrderByValue, bs as ParsingError, bt as ParsingResult, cS as PluginConfig, cT as PluginSettings, cB as PrivateKeyVariants, ec as RAW_TRANSACTION_SALT, ed as RAW_TRANSACTION_WITH_DATA_SALT, bF as RawTransactionWithData, dW as RoleType, bM as Script, bJ as ScriptFunctionArgument, cc as ScriptFunctionArgumentTypes, dh as ScriptPayloadResponse, ct as ScriptTransactionArgumentVariants, dB as ScriptWriteSet, bx as Secp256k1PrivateKey, bw as Secp256k1PublicKey, by as Secp256k1Signature, bp as Serialized, d2 as StateCheckpointTransactionResponse, c7 as StructTag, cr as TokenStandard, bI as TransactionArgument, cz as TransactionAuthenticatorVariant, dt as TransactionEd25519Signature, bQ as TransactionExecutable, bT as TransactionExecutableEmpty, bS as TransactionExecutableEntryFunction, bR as TransactionExecutableScript, cw as TransactionExecutableVariants, bU as TransactionExtraConfig, bV as TransactionExtraConfigV1, cx as TransactionExtraConfigVariants, dy as TransactionFeePayerSignature, cQ as TransactionGenerationConfig, bP as TransactionInnerPayloadV1, cv as TransactionInnerPayloadVariants, dx as TransactionMultiAgentSignature, dw as TransactionMultiEd25519Signature, bL as TransactionPayload, df as TransactionPayloadResponse, cu as TransactionPayloadVariants, cU as TransactionResponseType, du as TransactionSecp256k1Signature, dl as TransactionSignature, dv as TransactionSingleSenderSignature, cy as TransactionVariants, c1 as TypeTagAddress, bW as TypeTagBool, c4 as TypeTagGeneric, c3 as TypeTagReference, c2 as TypeTagSigner, c6 as TypeTagStruct, b$ as TypeTagU128, bY as TypeTagU16, c0 as TypeTagU256, bZ as TypeTagU32, b_ as TypeTagU64, bX as TypeTagU8, cs as TypeTagVariants, c5 as TypeTagVector, cK as Uint128, cH as Uint16, cL as Uint256, cI as Uint32, cJ as Uint64, cG as Uint8, d3 as ValidatorTransactionResponse, ci as ViewFunctionJsonPayload, dA as WriteSet, d6 as WriteSetChange, d7 as WriteSetChangeDeleteModule, d8 as WriteSetChangeDeleteResource, d9 as WriteSetChangeDeleteTableItem, da as WriteSetChangeWriteModule, db as WriteSetChangeWriteResource, dc as WriteSetChangeWriteTableItem, cD as anyPublicKeyVariantToString, c8 as aptosCoinStructTag, bK as deserializeFromScriptArgument, bm as ensureBoolean, bB as hexToAsciiString, c$ as isBlockEpilogueTransactionResponse, cY as isBlockMetadataTransactionResponse, bu as isCanonicalEd25519Signature, dm as isEd25519Signature, dq as isFeePayerSignature, cX as isGenesisTransactionResponse, dp as isMultiAgentSignature, dr as isMultiEd25519Signature, cV as isPendingTransactionResponse, dn as isSecp256k1Signature, ds as isSingleSenderSignature, cZ as isStateCheckpointTransactionResponse, cW as isUserTransactionResponse, c_ as isValidatorTransactionResponse, cb as objectStructTag, ca as optionStructTag, bn as outOfRangeErrorMessage, c9 as stringStructTag, bo as validateNumberInRange } from './account-D4dsN-1K.js';
 import { ProjPointType } from '@noble/curves/abstract/weierstrass';
 import { Fp2 } from '@noble/curves/abstract/tower';
 import EventEmitter from 'eventemitter3';
@@ -223,21 +223,6 @@ type CurrentFungibleAssetBalancesBoolExp = {
     storage_id?: InputMaybe<StringComparisonExp>;
     token_standard?: InputMaybe<StringComparisonExp>;
 };
-/** Boolean expression to filter rows from the table "events". All fields are combined with a logical 'AND'. */
-type EventsBoolExp = {
-    _and?: InputMaybe<Array<EventsBoolExp>>;
-    _not?: InputMaybe<EventsBoolExp>;
-    _or?: InputMaybe<Array<EventsBoolExp>>;
-    account_address?: InputMaybe<StringComparisonExp>;
-    creation_number?: InputMaybe<BigintComparisonExp>;
-    data?: InputMaybe<JsonbComparisonExp>;
-    event_index?: InputMaybe<BigintComparisonExp>;
-    indexed_type?: InputMaybe<StringComparisonExp>;
-    sequence_number?: InputMaybe<BigintComparisonExp>;
-    transaction_block_height?: InputMaybe<BigintComparisonExp>;
-    transaction_version?: InputMaybe<BigintComparisonExp>;
-    type?: InputMaybe<StringComparisonExp>;
-};
 /** Boolean expression to filter rows from the table "fungible_asset_activities". All fields are combined with a logical 'AND'. */
 type FungibleAssetActivitiesBoolExp = {
     _and?: InputMaybe<Array<FungibleAssetActivitiesBoolExp>>;
@@ -4548,190 +4533,6 @@ declare class DigitalAsset {
     }): Promise<SimpleTransaction>;
 }
 
-/**
- * A class to query all `Event` Aptos related queries.
- * @group Event
- */
-declare class Event {
-    readonly config: AptosConfig;
-    /**
-     * Initializes a new instance of the Aptos client with the provided configuration.
-     *
-     * @param config - The configuration settings for the Aptos client.
-     * @param config.network - The network to connect to (e.g., Testnet, Mainnet).
-     * @param config.nodeUrl - The URL of the Aptos node to connect to.
-     * @param config.faucetUrl - The URL of the faucet to use for funding accounts.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * async function runExample() {
-     *     // Create a new Aptos client with Testnet configuration
-     *     const config = new AptosConfig({ network: Network.TESTNET }); // Specify your own network if needed
-     *     const aptos = new Aptos(config);
-     *
-     *     console.log("Aptos client initialized:", aptos);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Event
-     */
-    constructor(config: AptosConfig);
-    /**
-     * Retrieve module events based on a specified event type.
-     * This function allows you to query for events that are associated with a particular module event type in the Aptos blockchain.
-     *
-     * @param args - The arguments for retrieving module events.
-     * @param args.eventType - The event type to filter the results.
-     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
-     * @param args.options - Optional pagination and ordering parameters for the event results.
-     *
-     * @returns Promise<GetEventsResponse> - A promise that resolves to the retrieved events.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Retrieve module events for a specific event type
-     *   const events = await aptos.getModuleEventsByEventType({
-     *     eventType: "0x1::transaction_fee::FeeStatement", // specify the event type
-     *     minimumLedgerVersion: 1, // optional: specify minimum ledger version if needed
-     *   });
-     *
-     *   console.log(events); // log the retrieved events
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Event
-     */
-    getModuleEventsByEventType(args: {
-        eventType: MoveStructId;
-        minimumLedgerVersion?: AnyNumber;
-        options?: PaginationArgs & OrderByArg<GetEventsResponse[0]>;
-    }): Promise<GetEventsResponse>;
-    /**
-     * Retrieve events associated with a specific account address and creation number.
-     *
-     * @param args - The parameters for retrieving account events.
-     * @param args.accountAddress - The account address to query events for.
-     * @param args.creationNumber - The event creation number to filter the events.
-     * @param args.minimumLedgerVersion - Optional minimum ledger version to sync up to before querying.
-     *
-     * @returns Promise<GetEventsResponse>
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Get events for the account at creation number 0
-     *   const events = await aptos.getAccountEventsByCreationNumber({
-     *     accountAddress: "0x1", // replace with a real account address
-     *     creationNumber: 0,
-     *   });
-     *
-     *   console.log(events);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Event
-     */
-    getAccountEventsByCreationNumber(args: {
-        accountAddress: AccountAddressInput;
-        creationNumber: AnyNumber;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<GetEventsResponse>;
-    /**
-     * Retrieve events associated with a specific account address and event type.
-     *
-     * @param args.accountAddress - The account address to query events for.
-     * @param args.eventType - The type of event to filter by.
-     * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
-     * @param args.options - Optional pagination and ordering parameters for the event query.
-     *
-     * @returns Promise<GetEventsResponse>
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Get events for a specific account and event type
-     *   const events = await aptos.getAccountEventsByEventType({
-     *     accountAddress: "0x1", // replace with a real account address
-     *     eventType: "0x1::transaction_fee::FeeStatement", // replace with a real event type
-     *     minimumLedgerVersion: 1, // optional, specify if needed
-     *   });
-     *
-     *   console.log(events);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Event
-     */
-    getAccountEventsByEventType(args: {
-        accountAddress: AccountAddressInput;
-        eventType: MoveStructId;
-        minimumLedgerVersion?: AnyNumber;
-        options?: PaginationArgs & OrderByArg<GetEventsResponse[0]>;
-    }): Promise<GetEventsResponse>;
-    /**
-     * Retrieve all events from the Aptos blockchain.
-     * An optional `where` clause can be provided to filter the results based on specific criteria.
-     *
-     * @param args Optional parameters for the query.
-     * @param args.minimumLedgerVersion Optional ledger version to sync up to before querying.
-     * @param args.options Optional pagination and filtering options.
-     * @param args.options.where Optional condition to filter events.
-     * @param args.options.offset Optional pagination offset.
-     * @param args.options.limit Optional maximum number of events to return.
-     * @param args.options.orderBy Optional ordering of the results.
-     *
-     * @returns GetEventsQuery response type containing the events.
-     *
-     * @example
-     * ```typescript
-     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Retrieve all events
-     *   const events = await aptos.getEvents();
-     *
-     *   // Retrieve events with filtering by account address
-     *   const whereCondition = {
-     *     account_address: { _eq: "0x123" }, // replace with a real account address
-     *   };
-     *   const filteredEvents = await aptos.getEvents({
-     *     options: { where: whereCondition },
-     *   });
-     *
-     *   console.log(events);
-     *   console.log(filteredEvents);
-     * }
-     * runExample().catch(console.error);
-     * ```
-     * @group Event
-     */
-    getEvents(args?: {
-        minimumLedgerVersion?: AnyNumber;
-        options?: PaginationArgs & OrderByArg<GetEventsResponse[0]> & WhereArg<EventsBoolExp>;
-    }): Promise<GetEventsResponse>;
-}
-
 /**
  * A class to query all `Faucet` related queries on Aptos.
  * @group Faucet
@@ -5390,6 +5191,9 @@ declare class General {
  * @param sender - The account initiating the name registration.
  * @param name - The name to be registered.
  * @param expiration - The expiration policy for the name registration.
+ * @param transferable - Whether the name can be transferred to another owner.
+ * @param toAddress - The address that will be set as the owner_address of the name.
+ * @param targetAddress - The address that this name will resolve to.
  * @group Implementation
  */
 interface RegisterNameParameters {
@@ -7451,43 +7255,33 @@ declare class Transaction {
      *
      * @param args - The arguments for rotating the authentication key.
      * @param args.fromAccount - The account from which the authentication key will be rotated.
-     * @param args.toAccount - (Optional) The target account to rotate to. Required if not using toNewPrivateKey or toAuthKey.
-     * @param args.toNewPrivateKey - (Optional) The new private key to rotate to. Required if not using toAccount or toAuthKey.
-     * @param args.toAuthKey - (Optional) The new authentication key to rotate to. Can only be used with dangerouslySkipVerification=true.
-     * @param args.dangerouslySkipVerification - (Optional) If true, skips verification steps after rotation. Required when using toAuthKey.
+     * @param args.toAccount - (Optional) The target account to rotate to. Required if not using toNewPrivateKey.
+     * @param args.toNewPrivateKey - (Optional) The new private key to rotate to. Required if not using toAccount.
      *
      * @remarks
      * This function supports three modes of rotation:
      * 1. Using a target Account object (toAccount)
      * 2. Using a new private key (toNewPrivateKey)
-     * 3. Using a raw authentication key (toAuthKey) - requires dangerouslySkipVerification=true
      *
-     * When not using dangerouslySkipVerification, the function performs additional safety checks and account setup.
+     * For Ed25519 accounts, the function will use a challenge-based rotation that requires signatures from both the old and new keys.
+     * For multi-key accounts like MultiEd25519Account, the function will use a challenge-based rotation that requires signatures from both keys.
+     * For other account types, the function will use an unverified rotation that only requires the new public key.
      *
-     * If the new key is a multi key, skipping verification is dangerous because verification will publish the public key onchain and
-     * prevent users from being locked out of the account from loss of knowledge of one of the public keys.
-     *
-     * @returns PendingTransactionResponse
+     * @returns SimpleTransaction that can be submitted to rotate the auth key
      *
      * @example
      * ```typescript
-     * import { Aptos, AptosConfig, Network, Account, PrivateKey } from "@aptos-labs/ts-sdk";
-     *
-     * const config = new AptosConfig({ network: Network.TESTNET });
-     * const aptos = new Aptos(config);
-     *
-     * async function runExample() {
-     *   // Rotate the authentication key for an account
-     *   const response = await aptos.rotateAuthKey({
-     *     // replace with a real account
-     *     fromAccount: Account.generate(),
-     *     // replace with a real private key
-     *     toNewPrivateKey: new PrivateKey("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"),
-     *   });
+     * // Create and submit transaction to rotate the auth key
+     * const transaction = await aptos.rotateAuthKey({
+     *   fromAccount,
+     *   toAccount: toAccount,
+     * });
      *
-     *   console.log(response);
-     * }
-     * runExample().catch(console.error);
+     * // Sign and submit the transaction
+     * const pendingTransaction = await aptos.signAndSubmitTransaction({
+     *   signer: fromAccount,
+     *   transaction,
+     * });
      * ```
      * @group Transaction
      */
@@ -7495,15 +7289,44 @@ declare class Transaction {
         fromAccount: Account;
         options?: InputGenerateTransactionOptions;
     } & ({
-        toAccount: Account;
-        dangerouslySkipVerification?: never;
+        toAccount: Ed25519Account | MultiEd25519Account;
     } | {
         toNewPrivateKey: Ed25519PrivateKey;
-        dangerouslySkipVerification?: never;
-    } | {
-        toAuthKey: AuthenticationKey;
-        dangerouslySkipVerification: true;
-    })): Promise<PendingTransactionResponse>;
+    })): Promise<SimpleTransaction>;
+    /**
+     * Rotates the authentication key for a given account without verifying the new key.
+     *
+     * Accounts with their auth key rotated via this function will be derivable via the `getAccountsForPublicKey` and
+     * `deriveOwnedAccountsFromSigner` functions however the public key will be unverified (no proof of ownership). Thus
+     * includeUnverified must be set to true to derive the account until the public key is verified via signing a transaction.
+     *
+     * @param args - The arguments for rotating the authentication key.
+     * @param args.fromAccount - The account from which the authentication key will be rotated.
+     * @param args.toNewPublicKey - The new public key to rotate to.
+     *
+     * @returns A simple transaction object that can be submitted to the network.
+     *
+     * @example
+     * ```typescript
+     * // Create and submit transaction to rotate the auth key
+     * const transaction = await aptos.rotateAuthKeyUnverified({
+     *   fromAccount,
+     *   toNewPublicKey,
+     * });
+     *
+     * // Sign and submit the transaction
+     * const pendingTransaction = await aptos.signAndSubmitTransaction({
+     *   signer: fromAccount,
+     *   transaction,
+     * });
+     * ```
+     * @group Transaction
+     */
+    rotateAuthKeyUnverified(args: {
+        fromAccount: Account;
+        options?: InputGenerateTransactionOptions;
+        toNewPublicKey: AccountPublicKey;
+    }): Promise<SimpleTransaction>;
     /**
      * Sign a transaction that can later be submitted to the chain.
      * This function is essential for ensuring the authenticity of the transaction by using the provided account's signing capabilities.
@@ -9133,7 +8956,6 @@ declare class Aptos {
     readonly ans: ANS;
     readonly coin: Coin;
     readonly digitalAsset: DigitalAsset;
-    readonly event: Event;
     readonly faucet: Faucet;
     readonly fungibleAsset: FungibleAsset;
     readonly general: General;
@@ -9170,111 +8992,567 @@ interface Aptos extends Account$1, ANS, Coin, DigitalAsset, Event, Faucet, Fungi
 }
 
 /**
- * This class exists solely to represent a sequence of fixed bytes as a serialized entry function, because
- * serializing an entry function appends a prefix that's *only* used for entry function arguments.
- *
- * NOTE: Using this class for serialized script functions will lead to erroneous and unexpected behavior.
- *
- * If you wish to convert this class back to a TransactionArgument, you must know the type
- * of the argument beforehand, and use the appropriate class to deserialize the bytes within
- * an instance of this class.
  * @group Implementation
- * @category BCS
+ * @category Utils
  */
-declare class EntryFunctionBytes extends Serializable implements EntryFunctionArgument {
-    readonly value: FixedBytes;
-    /**
-     * Creates an instance of the class with a specified hexadecimal input value.
-     *
-     * @param value - The hexadecimal input to be converted into FixedBytes.
-     * @group Implementation
-     * @category BCS
-     */
-    private constructor();
-    /**
-     * Serializes the value using the provided serializer.
-     * This function is essential for accurately representing a sequence of bytes that are already BCS-serialized as a type.
-     *
-     * Note that to see the Move, BCS-serialized representation of the underlying fixed byte vector,
-     * we must not serialize the length prefix.
-     *
-     * @param serializer - The serializer instance used to perform the serialization.
-     * @group Implementation
-     * @category BCS
-     */
-    serialize(serializer: Serializer): void;
+type DeserializableClass<T extends Serializable> = {
     /**
-     * Serializes the current instance for use as an entry function argument by converting the underlying fixed byte vector to a
-     * type-agnostic byte vector.
-     * This process includes serializing the length prefix of the byte vector.
+     * Deserializes a serialized object using the provided deserializer.
+     * This function allows you to reconstruct an object from its serialized form.
      *
-     * @param serializer - The serializer instance used to perform the serialization.
-     * @group Implementation
-     * @category BCS
-     */
-    serializeForEntryFunction(serializer: Serializer): void;
-    /**
-     * The only way to create an instance of this class is to use this static method.
-     * This function should only be used when deserializing a sequence of EntryFunctionPayload arguments.
-     * @param deserializer - The deserializer instance with the buffered bytes.
-     * @param length - The length of the bytes to deserialize.
-     * @returns An instance of this class, which will now only be usable as an EntryFunctionArgument.
+     * @param deserializer - An instance of the Deserializer used to read the serialized data.
      * @group Implementation
-     * @category BCS
+     * @category Utils
      */
-    static deserialize(deserializer: Deserializer, length: number): EntryFunctionBytes;
-}
-
+    deserialize(deserializer: Deserializer): T;
+};
 /**
- * Arguments required to create an instance of an Ed25519 signer.
+ * Normalizes an instance of a class by deserializing it from its byte representation.
+ * This function allows the `instanceof` operator to work correctly when the input objects originate from a different bundle.
  *
- * @param privateKey - The private key used for signing.
- * @param address - Optional account address associated with the signer.
+ * @param cls - The class of the object to normalize.
+ * @param value - The instance to normalize.
  * @group Implementation
- * @category Account (On-Chain Model)
+ * @category Utils
  */
-interface Ed25519SignerConstructorArgs {
-    privateKey: Ed25519PrivateKey;
-    address?: AccountAddressInput;
-}
+declare function normalizeBundle<T extends Serializable>(cls: DeserializableClass<T>, value: T): T;
+
 /**
- * Arguments for creating an Ed25519 signer from a derivation path.
+ * Sleep for the specified amount of time in milliseconds.
+ * This function can be used to introduce delays in asynchronous operations.
  *
- * @param path - The derivation path for the Ed25519 key.
- * @param mnemonic - The mnemonic phrase used to generate the key.
+ * @param timeMs - The time in milliseconds to sleep.
  * @group Implementation
- * @category Account (On-Chain Model)
+ * @category Utils
  */
-interface Ed25519SignerFromDerivationPathArgs {
-    path: string;
-    mnemonic: string;
-}
+declare function sleep(timeMs: number): Promise<null>;
 /**
- * Arguments required to verify an Ed25519 signature against a given message.
+ * Get the error message from an unknown error.
  *
- * @param message - The message to be verified, represented in hexadecimal format.
- * @param signature - The Ed25519 signature to validate.
+ * @param error The error to get the message from
+ * @returns The error message
  * @group Implementation
- * @category Account (On-Chain Model)
+ * @category Utils
  */
-interface VerifyEd25519SignatureArgs {
-    message: HexInput;
-    signature: Ed25519Signature;
-}
+declare function getErrorMessage(error: unknown): string;
 /**
- * Represents an Ed25519 account that provides signing capabilities through an Ed25519 private key.
- * This class allows for the creation of accounts, signing messages and transactions, and verifying signatures.
- *
- * Note: Generating an instance of this class does not create the account on-chain.
  * @group Implementation
- * @category Account (On-Chain Model)
+ * @category Utils
  */
-declare class Ed25519Account implements Account {
-    /**
-     * Private key associated with the account
-     * @group Implementation
-     * @category Account (On-Chain Model)
-     */
+declare const nowInSeconds: () => number;
+/**
+ * Floors the given timestamp to the nearest whole hour.
+ * This function is useful for normalizing timestamps to hourly intervals.
+ *
+ * @param timestampInSeconds - The timestamp in seconds to be floored.
+ * @group Implementation
+ * @category Utils
+ */
+declare function floorToWholeHour(timestampInSeconds: number): number;
+/**
+ * Decodes a base64 URL-encoded string into its original form.
+ * This function is useful for converting base64 URL-encoded data back to a readable format.
+ *
+ * @param base64Url - The base64 URL-encoded string to decode.
+ * @returns The decoded string.
+ * @group Implementation
+ * @category Utils
+ */
+declare function base64UrlDecode(base64Url: string): string;
+declare function base64UrlToBytes(base64Url: string): Uint8Array;
+/**
+ * Amount is represented in the smallest unit format on chain, this function converts
+ * a human-readable amount format to the smallest unit format
+ * @example
+ * human-readable amount format: 500
+ * on chain amount format when decimal is 8: 50000000000
+ *
+ * @param value The value in human-readable format
+ * @param decimal The token decimal
+ * @returns The value in the smallest units
+ * @group Implementation
+ * @category Utils
+ */
+declare const convertAmountFromHumanReadableToOnChain: (value: number, decimal: number) => number;
+/**
+ * Amount is represented in the smallest unit format on chain, this function converts
+ * the smallest unit format to a human-readable amount format
+ * @example
+ * human-readable amount format: 500
+ * on chain amount format when decimal is 8: 50000000000
+ *
+ * @param value The value in human-readable format
+ * @param decimal The token decimal
+ * @returns The value in the smallest units
+ * @group Implementation
+ * @category Utils
+ */
+declare const convertAmountFromOnChainToHumanReadable: (value: number, decimal: number) => number;
+/**
+ * Convert an encoded struct to a MoveStructId.
+ *
+ * @example
+ * const structObj = {
+ *   account_address: "0x1",
+ *   module_name: "0x6170746f735f636f696e",
+ *   struct_name: "0x4170746f73436f696e",
+ * };
+ * // structId is "0x1::aptos_coin::AptosCoin"
+ * const structId = parseEncodedStruct(structObj);
+ *
+ * @param structObj The struct with account_address, module_name, and struct_name properties
+ * @returns The MoveStructId
+ * @group Implementation
+ * @category Utils
+ */
+declare const parseEncodedStruct: (structObj: {
+    account_address: string;
+    module_name: string;
+    struct_name: string;
+}) => MoveStructId;
+/**
+ * Determines whether the given object is an encoded struct type with the following properties:
+ * - account_address: string
+ * - module_name: string
+ * - struct_name: string
+ *
+ * @param structObj The object to check
+ * @returns Whether the object is an encoded struct type
+ * @group Implementation
+ * @category Utils
+ */
+declare const isEncodedStruct: (structObj: any) => structObj is {
+    account_address: string;
+    module_name: string;
+    struct_name: string;
+};
+/**
+ * Splits a function identifier into its constituent parts: module address, module name, and function name.
+ * This function helps in validating and extracting details from a function identifier string.
+ *
+ * @param functionArg - The function identifier string in the format "moduleAddress::moduleName::functionName".
+ * @returns An object containing the module address, module name, and function name.
+ * @throws Error if the function identifier does not contain exactly three parts.
+ * @group Implementation
+ * @category Transactions
+ */
+declare function getFunctionParts(functionArg: MoveFunctionId): {
+    moduleAddress: string;
+    moduleName: string;
+    functionName: string;
+};
+/**
+ * Validates the provided function information.
+ *
+ * @param functionInfo - The function information to validate.
+ * @returns Whether the function information is valid.
+ * @group Implementation
+ * @category Utils
+ */
+declare function isValidFunctionInfo(functionInfo: string): boolean;
+/**
+ * Truncates the provided wallet address at the middle with an ellipsis.
+ *
+ * @param address - The wallet address to truncate.
+ * @param start - The number of characters to show at the beginning of the address.
+ * @param end - The number of characters to show at the end of the address.
+ * @returns The truncated address.
+ * @group Implementation
+ * @category Utils
+ */
+declare function truncateAddress(address: string, start?: number, end?: number): string;
+/**
+ * Calculates the paired FA metadata address for a given coin type.
+ * This function is tolerant of various address formats in the coin type string,
+ * including complex nested types.
+ *
+ * @example
+ * // All these formats are valid and will produce the same result:
+ * pairedFaMetadataAddress("0x1::aptos_coin::AptosCoin")  // simple form
+ * pairedFaMetadataAddress("0x0000000000000000000000000000000000000000000000000000000000000001::aptos_coin::AptosCoin")  // long form
+ * pairedFaMetadataAddress("0x00001::aptos_coin::AptosCoin")  // with leading zeros
+ * pairedFaMetadataAddress("0x1::coin::Coin<0x1412::a::struct<0x0001::aptos_coin::AptosCoin>>")  // nested type parameters
+ *
+ * @param coinType - The coin type string in any of these formats:
+ *   - Short form address: "0x1::aptos_coin::AptosCoin"
+ *   - Long form address: "0x0000000000000000000000000000000000000000000000000000000000000001::aptos_coin::AptosCoin"
+ *   - With leading zeros: "0x00001::aptos_coin::AptosCoin"
+ *   - With nested types: "0x1::coin::Coin<0x1412::a::struct<0x0001::aptos_coin::AptosCoin>>"
+ * @returns The calculated metadata address as an AccountAddress instance
+ */
+declare function pairedFaMetadataAddress(coinType: `0x${string}::${string}::${string}`): AccountAddress;
+
+type FunctionsWithReturnType<T, ReturnType> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => ReturnType ? T[K] extends <M extends {} = any>(...args: any[]) => Promise<M> ? never : K : never;
+}[keyof T];
+type RemoveSender<T> = T extends (args: infer Args) => infer Return ? Args extends {
+    sender?: any;
+    account?: any;
+    creator?: any;
+    [key: string]: any;
+} ? (args: Omit<Args, "sender" | "account" | "creator" | "fromAccount">) => Return : T : T;
+type TransformReturnType<T> = T extends (...args: infer Args) => Promise<SimpleTransaction> ? (...args: Args) => TransactionContext : T;
+type SimpleTransactionGenerator = {
+    [K in FunctionsWithReturnType<Aptos, Promise<SimpleTransaction>>]: TransformReturnType<RemoveSender<Aptos[K]>>;
+};
+type TransactionGenerationArgs = {
+    sender: Account;
+    options: InputGenerateTransactionOptions;
+    aptos: Aptos;
+};
+type TransactionGenerationFunction = (args: TransactionGenerationArgs) => Promise<SimpleTransaction>;
+declare class TransactionContext {
+    senderAccount?: Account;
+    transactionGenerationFunction: TransactionGenerationFunction;
+    maxGasAmountVal: number;
+    gasUnitPriceVal: number | undefined;
+    defaultTxnExpirySecsFromNow: number;
+    txnExpirySecsFromNow?: number;
+    withFeePayerBool: boolean;
+    expiryTimestampSecsVal?: number;
+    orderMode?: OrderMode;
+    accountSequenceNumberVal: AnyNumber | undefined;
+    replayProtectionNonceVal: AnyNumber | undefined;
+    pluginParams?: Record<string, any>;
+    transactionSubmitter?: TransactionSubmitter | null;
+    aptos: Aptos;
+    timeoutSecs: number;
+    waitForIndexerBool: boolean;
+    checkSuccessBool: boolean;
+    feePayerAccount: Account | undefined;
+    constructor(manager: TransactionManager, transactionGenerationFunction: TransactionGenerationFunction);
+    private createAptosWithConfig;
+    clientOverride(aptos: Aptos): this;
+    network(network: Network): this;
+    orderless(replayProtectionNonce: AnyNumber): this;
+    sequential(accountSequenceNumber?: AnyNumber): this;
+    maxGasAmount(amount: number): this;
+    gasUnitPrice(gasUnitPrice: number): this;
+    expiresAfter(txnExpirySecsFromNow: number): this;
+    expiresAt(expiryTimestampSecs: number): this;
+    withGasStation(gasStation: TransactionSubmitter): this;
+    useFeePayer(useFeePayer?: boolean): this;
+    feePayer(feePayerAccount: Account | undefined): this;
+    withSubmitter(transactionSubmitter: TransactionSubmitter, pluginParams?: Record<string, any>): this;
+    ignoreSubmitter(): this;
+    timeoutAfter(timeoutSecs: number): this;
+    skipWaitForIndexer(): this;
+    skipCheckSuccess(): this;
+    sender(sender: Account): this;
+    getClient(): Aptos;
+    validateSettings(): void;
+    private setProperty;
+    submit(): Promise<UserTransactionResponse>;
+    generateTransaction(): Promise<SimpleTransaction>;
+}
+declare class FaucetContext {
+    aptos: Aptos;
+    amountVal: number;
+    accountAddress?: AccountAddressInput;
+    timeoutSecs: number;
+    checkSuccess: boolean;
+    waitForIndexer: boolean;
+    constructor(manager: TransactionManager);
+    submit(): Promise<UserTransactionResponse>;
+    amount(amount: number): this;
+    account(account: AccountAddressInput | Account): this;
+}
+type OrderMode = "orderless" | "sequential";
+declare class TransactionManager implements SimpleTransactionGenerator {
+    sender?: Account;
+    maxGasAmount?: number;
+    gasUnitPrice?: number;
+    txnExpirySecFromNow?: number;
+    orderMode?: OrderMode;
+    transactionSubmitter?: TransactionSubmitter | null;
+    pluginParams?: Record<string, any>;
+    txnTimeoutSecs?: number;
+    waitForIndexer?: boolean;
+    checkSuccess?: boolean;
+    aptos: Aptos;
+    withFeePayer?: boolean;
+    fundAmount?: number;
+    private constructor();
+    static new(aptosOrConfig: Aptos | AptosConfig): TransactionManager;
+    private createAptosWithConfig;
+    setClient(aptos: Aptos): void;
+    setDefaultNetwork(network: Network): void;
+    defaultSender(sender: Account): this;
+    generateDefaultSender(): this;
+    fundAccount(account?: Account | AccountAddressInput): FaucetContext;
+    defaultMaxGasAmount(maxGasAmount: number): this;
+    defaultGasUnitPrice(gasUnitPrice: number): this;
+    defaultExpireTimestamp(expireTimestamp: number): this;
+    defaultWithFeePayer(withFeePayer: boolean): this;
+    defaultOrderMode(orderMode: OrderMode): this;
+    defaultTransactionSubmitter(transactionSubmitter: TransactionSubmitter | null, pluginParams?: Record<string, any>): this;
+    defaultPluginParams(pluginParams: Record<string, any>): this;
+    defaultTxnTimeoutSecs(txnTimeoutSec: number): this;
+    defaultWaitForIndexer(waitForIndexer: boolean): this;
+    defaultCheckSuccess(checkSuccess: boolean): this;
+    defaultGasStation(gasStation: TransactionSubmitter): this;
+    defaultFundAmount(amount: number): this;
+    getClient(): Aptos;
+    getDefaultNetwork(): Network;
+    getDefaultSender(): Account | undefined;
+    getDefaultMaxGasAmount(): number;
+    getDefaultGasUnitPrice(): number | undefined;
+    getDefaulTxnExpirySecFromNow(): number;
+    getDefaultOrderMode(): OrderMode | undefined;
+    getDefaultWithFeePayer(): boolean;
+    getDefaultTransactionSubmitter(): TransactionSubmitter | undefined;
+    getDefaultPluginParams(): Record<string, any> | undefined;
+    getDefaultTxnTimeoutSecs(): number;
+    getDefaultWaitForIndexer(): boolean;
+    getDefaultCheckSuccess(): boolean;
+    getDefaultFundAmount(): number;
+    private createTransactionContext;
+    fromTransaction(transaction: SimpleTransaction): TransactionContext;
+    build(args: {
+        data: InputGenerateTransactionPayloadData;
+    }): TransactionContext;
+    publishPackageTransaction(args: {
+        metadataBytes: HexInput;
+        moduleBytecode: Array<HexInput>;
+    }): TransactionContext;
+    rotateAuthKey(args: {
+        toAccount: Ed25519Account | MultiEd25519Account;
+    } | {
+        toNewPrivateKey: Ed25519PrivateKey;
+    }): TransactionContext;
+    rotateAuthKeyUnverified(args: {
+        toNewPublicKey: AccountPublicKey;
+    }): TransactionContext;
+    setTargetAddress(args: {
+        name: string;
+        address: AccountAddressInput;
+    }): TransactionContext;
+    setPrimaryName(args: {
+        name?: string;
+    }): TransactionContext;
+    registerName(args: Omit<RegisterNameParameters, "aptosConfig" | "sender">): TransactionContext;
+    renewDomain(args: {
+        name: string;
+        years?: 1;
+    }): TransactionContext;
+    transferCoinTransaction(args: {
+        recipient: AccountAddressInput;
+        amount: AnyNumber;
+        coinType?: MoveStructId;
+    }): TransactionContext;
+    createCollectionTransaction(args: {
+        description: string;
+        name: string;
+        uri: string;
+    } & CreateCollectionOptions): TransactionContext;
+    mintDigitalAssetTransaction(args: {
+        collection: string;
+        description: string;
+        name: string;
+        uri: string;
+        propertyKeys?: Array<string>;
+        propertyTypes?: Array<PropertyType>;
+        propertyValues?: Array<PropertyValue>;
+    }): TransactionContext;
+    transferDigitalAssetTransaction(args: {
+        digitalAssetAddress: AccountAddressInput;
+        recipient: AccountAddress;
+        digitalAssetType?: MoveStructId;
+    }): TransactionContext;
+    mintSoulBoundTransaction(args: {
+        collection: string;
+        description: string;
+        name: string;
+        uri: string;
+        recipient: AccountAddressInput;
+        propertyKeys?: Array<string>;
+        propertyTypes?: Array<PropertyType>;
+        propertyValues?: Array<PropertyValue>;
+    }): TransactionContext;
+    burnDigitalAssetTransaction(args: {
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+    }): TransactionContext;
+    freezeDigitalAssetTransaferTransaction(args: {
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+    }): TransactionContext;
+    unfreezeDigitalAssetTransaferTransaction(args: {
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+    }): TransactionContext;
+    setDigitalAssetDescriptionTransaction(args: {
+        description: string;
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+    }): TransactionContext;
+    setDigitalAssetNameTransaction(args: {
+        name: string;
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+    }): TransactionContext;
+    setDigitalAssetURITransaction(args: {
+        uri: string;
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+    }): TransactionContext;
+    addDigitalAssetPropertyTransaction(args: {
+        propertyKey: string;
+        propertyType: PropertyType;
+        propertyValue: PropertyValue;
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+    }): TransactionContext;
+    removeDigitalAssetPropertyTransaction(args: {
+        propertyKey: string;
+        propertyType: PropertyType;
+        propertyValue: PropertyValue;
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+    }): TransactionContext;
+    updateDigitalAssetPropertyTransaction(args: {
+        propertyKey: string;
+        propertyType: PropertyType;
+        propertyValue: PropertyValue;
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+    }): TransactionContext;
+    addDigitalAssetTypedPropertyTransaction(args: {
+        propertyKey: string;
+        propertyType: PropertyType;
+        propertyValue: PropertyValue;
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+    }): TransactionContext;
+    updateDigitalAssetTypedPropertyTransaction(args: {
+        propertyKey: string;
+        propertyType: PropertyType;
+        propertyValue: PropertyValue;
+        digitalAssetAddress: AccountAddressInput;
+        digitalAssetType?: MoveStructId;
+    }): TransactionContext;
+    transferFungibleAsset(args: {
+        fungibleAssetMetadataAddress: AccountAddressInput;
+        recipient: AccountAddressInput;
+        amount: AnyNumber;
+    }): TransactionContext;
+    transferFungibleAssetBetweenStores(args: {
+        fromStore: AccountAddressInput;
+        toStore: AccountAddressInput;
+        amount: AnyNumber;
+    }): TransactionContext;
+    updateFederatedKeylessJwkSetTransaction(args: {
+        iss: string;
+        jwksUrl?: string;
+    }): TransactionContext;
+}
+
+/**
+ * This class exists solely to represent a sequence of fixed bytes as a serialized entry function, because
+ * serializing an entry function appends a prefix that's *only* used for entry function arguments.
+ *
+ * NOTE: Using this class for serialized script functions will lead to erroneous and unexpected behavior.
+ *
+ * If you wish to convert this class back to a TransactionArgument, you must know the type
+ * of the argument beforehand, and use the appropriate class to deserialize the bytes within
+ * an instance of this class.
+ * @group Implementation
+ * @category BCS
+ */
+declare class EntryFunctionBytes extends Serializable implements EntryFunctionArgument {
+    readonly value: FixedBytes;
+    /**
+     * Creates an instance of the class with a specified hexadecimal input value.
+     *
+     * @param value - The hexadecimal input to be converted into FixedBytes.
+     * @group Implementation
+     * @category BCS
+     */
+    private constructor();
+    /**
+     * Serializes the value using the provided serializer.
+     * This function is essential for accurately representing a sequence of bytes that are already BCS-serialized as a type.
+     *
+     * Note that to see the Move, BCS-serialized representation of the underlying fixed byte vector,
+     * we must not serialize the length prefix.
+     *
+     * @param serializer - The serializer instance used to perform the serialization.
+     * @group Implementation
+     * @category BCS
+     */
+    serialize(serializer: Serializer): void;
+    /**
+     * Serializes the current instance for use as an entry function argument by converting the underlying fixed byte vector to a
+     * type-agnostic byte vector.
+     * This process includes serializing the length prefix of the byte vector.
+     *
+     * @param serializer - The serializer instance used to perform the serialization.
+     * @group Implementation
+     * @category BCS
+     */
+    serializeForEntryFunction(serializer: Serializer): void;
+    /**
+     * The only way to create an instance of this class is to use this static method.
+     * This function should only be used when deserializing a sequence of EntryFunctionPayload arguments.
+     * @param deserializer - The deserializer instance with the buffered bytes.
+     * @param length - The length of the bytes to deserialize.
+     * @returns An instance of this class, which will now only be usable as an EntryFunctionArgument.
+     * @group Implementation
+     * @category BCS
+     */
+    static deserialize(deserializer: Deserializer, length: number): EntryFunctionBytes;
+}
+
+/**
+ * Arguments required to create an instance of an Ed25519 signer.
+ *
+ * @param privateKey - The private key used for signing.
+ * @param address - Optional account address associated with the signer.
+ * @group Implementation
+ * @category Account (On-Chain Model)
+ */
+interface Ed25519SignerConstructorArgs {
+    privateKey: Ed25519PrivateKey;
+    address?: AccountAddressInput;
+}
+/**
+ * Arguments for creating an Ed25519 signer from a derivation path.
+ *
+ * @param path - The derivation path for the Ed25519 key.
+ * @param mnemonic - The mnemonic phrase used to generate the key.
+ * @group Implementation
+ * @category Account (On-Chain Model)
+ */
+interface Ed25519SignerFromDerivationPathArgs {
+    path: string;
+    mnemonic: string;
+}
+/**
+ * Arguments required to verify an Ed25519 signature against a given message.
+ *
+ * @param message - The message to be verified, represented in hexadecimal format.
+ * @param signature - The Ed25519 signature to validate.
+ * @group Implementation
+ * @category Account (On-Chain Model)
+ */
+interface VerifyEd25519SignatureArgs {
+    message: HexInput;
+    signature: Ed25519Signature;
+}
+/**
+ * Represents an Ed25519 account that provides signing capabilities through an Ed25519 private key.
+ * This class allows for the creation of accounts, signing messages and transactions, and verifying signatures.
+ *
+ * Note: Generating an instance of this class does not create the account on-chain.
+ * @group Implementation
+ * @category Account (On-Chain Model)
+ */
+declare class Ed25519Account implements Account {
+    /**
+     * Private key associated with the account
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
     readonly privateKey: Ed25519PrivateKey;
     readonly publicKey: Ed25519PublicKey;
     readonly accountAddress: AccountAddress;
@@ -9881,197 +10159,6 @@ declare class DerivableAbstractedAccount extends AbstractedAccount {
     signWithAuthenticator(message: HexInput): AccountAuthenticatorAbstraction;
 }
 
-/**
- * @group Implementation
- * @category Utils
- */
-type DeserializableClass<T extends Serializable> = {
-    /**
-     * Deserializes a serialized object using the provided deserializer.
-     * This function allows you to reconstruct an object from its serialized form.
-     *
-     * @param deserializer - An instance of the Deserializer used to read the serialized data.
-     * @group Implementation
-     * @category Utils
-     */
-    deserialize(deserializer: Deserializer): T;
-};
-/**
- * Normalizes an instance of a class by deserializing it from its byte representation.
- * This function allows the `instanceof` operator to work correctly when the input objects originate from a different bundle.
- *
- * @param cls - The class of the object to normalize.
- * @param value - The instance to normalize.
- * @group Implementation
- * @category Utils
- */
-declare function normalizeBundle<T extends Serializable>(cls: DeserializableClass<T>, value: T): T;
-
-/**
- * Sleep for the specified amount of time in milliseconds.
- * This function can be used to introduce delays in asynchronous operations.
- *
- * @param timeMs - The time in milliseconds to sleep.
- * @group Implementation
- * @category Utils
- */
-declare function sleep(timeMs: number): Promise<null>;
-/**
- * Get the error message from an unknown error.
- *
- * @param error The error to get the message from
- * @returns The error message
- * @group Implementation
- * @category Utils
- */
-declare function getErrorMessage(error: unknown): string;
-/**
- * @group Implementation
- * @category Utils
- */
-declare const nowInSeconds: () => number;
-/**
- * Floors the given timestamp to the nearest whole hour.
- * This function is useful for normalizing timestamps to hourly intervals.
- *
- * @param timestampInSeconds - The timestamp in seconds to be floored.
- * @group Implementation
- * @category Utils
- */
-declare function floorToWholeHour(timestampInSeconds: number): number;
-/**
- * Decodes a base64 URL-encoded string into its original form.
- * This function is useful for converting base64 URL-encoded data back to a readable format.
- *
- * @param base64Url - The base64 URL-encoded string to decode.
- * @returns The decoded string.
- * @group Implementation
- * @category Utils
- */
-declare function base64UrlDecode(base64Url: string): string;
-declare function base64UrlToBytes(base64Url: string): Uint8Array;
-/**
- * Amount is represented in the smallest unit format on chain, this function converts
- * a human-readable amount format to the smallest unit format
- * @example
- * human-readable amount format: 500
- * on chain amount format when decimal is 8: 50000000000
- *
- * @param value The value in human-readable format
- * @param decimal The token decimal
- * @returns The value in the smallest units
- * @group Implementation
- * @category Utils
- */
-declare const convertAmountFromHumanReadableToOnChain: (value: number, decimal: number) => number;
-/**
- * Amount is represented in the smallest unit format on chain, this function converts
- * the smallest unit format to a human-readable amount format
- * @example
- * human-readable amount format: 500
- * on chain amount format when decimal is 8: 50000000000
- *
- * @param value The value in human-readable format
- * @param decimal The token decimal
- * @returns The value in the smallest units
- * @group Implementation
- * @category Utils
- */
-declare const convertAmountFromOnChainToHumanReadable: (value: number, decimal: number) => number;
-/**
- * Convert an encoded struct to a MoveStructId.
- *
- * @example
- * const structObj = {
- *   account_address: "0x1",
- *   module_name: "0x6170746f735f636f696e",
- *   struct_name: "0x4170746f73436f696e",
- * };
- * // structId is "0x1::aptos_coin::AptosCoin"
- * const structId = parseEncodedStruct(structObj);
- *
- * @param structObj The struct with account_address, module_name, and struct_name properties
- * @returns The MoveStructId
- * @group Implementation
- * @category Utils
- */
-declare const parseEncodedStruct: (structObj: {
-    account_address: string;
-    module_name: string;
-    struct_name: string;
-}) => MoveStructId;
-/**
- * Determines whether the given object is an encoded struct type with the following properties:
- * - account_address: string
- * - module_name: string
- * - struct_name: string
- *
- * @param structObj The object to check
- * @returns Whether the object is an encoded struct type
- * @group Implementation
- * @category Utils
- */
-declare const isEncodedStruct: (structObj: any) => structObj is {
-    account_address: string;
-    module_name: string;
-    struct_name: string;
-};
-/**
- * Splits a function identifier into its constituent parts: module address, module name, and function name.
- * This function helps in validating and extracting details from a function identifier string.
- *
- * @param functionArg - The function identifier string in the format "moduleAddress::moduleName::functionName".
- * @returns An object containing the module address, module name, and function name.
- * @throws Error if the function identifier does not contain exactly three parts.
- * @group Implementation
- * @category Transactions
- */
-declare function getFunctionParts(functionArg: MoveFunctionId): {
-    moduleAddress: string;
-    moduleName: string;
-    functionName: string;
-};
-/**
- * Validates the provided function information.
- *
- * @param functionInfo - The function information to validate.
- * @returns Whether the function information is valid.
- * @group Implementation
- * @category Utils
- */
-declare function isValidFunctionInfo(functionInfo: string): boolean;
-/**
- * Truncates the provided wallet address at the middle with an ellipsis.
- *
- * @param address - The wallet address to truncate.
- * @param start - The number of characters to show at the beginning of the address.
- * @param end - The number of characters to show at the end of the address.
- * @returns The truncated address.
- * @group Implementation
- * @category Utils
- */
-declare function truncateAddress(address: string, start?: number, end?: number): string;
-/**
- * Calculates the paired FA metadata address for a given coin type.
- * This function is tolerant of various address formats in the coin type string,
- * including complex nested types.
- *
- * @example
- * // All these formats are valid and will produce the same result:
- * pairedFaMetadataAddress("0x1::aptos_coin::AptosCoin")  // simple form
- * pairedFaMetadataAddress("0x0000000000000000000000000000000000000000000000000000000000000001::aptos_coin::AptosCoin")  // long form
- * pairedFaMetadataAddress("0x00001::aptos_coin::AptosCoin")  // with leading zeros
- * pairedFaMetadataAddress("0x1::coin::Coin<0x1412::a::struct<0x0001::aptos_coin::AptosCoin>>")  // nested type parameters
- *
- * @param coinType - The coin type string in any of these formats:
- *   - Short form address: "0x1::aptos_coin::AptosCoin"
- *   - Long form address: "0x0000000000000000000000000000000000000000000000000000000000000001::aptos_coin::AptosCoin"
- *   - With leading zeros: "0x00001::aptos_coin::AptosCoin"
- *   - With nested types: "0x1::coin::Coin<0x1412::a::struct<0x0001::aptos_coin::AptosCoin>>"
- * @returns The calculated metadata address as an AccountAddress instance
- */
-declare function pairedFaMetadataAddress(coinType: `0x${string}::${string}::${string}`): AccountAddress;
-
 /**
  * Sends a request using the specified options and returns the response.
  *
@@ -10495,4 +10582,4 @@ declare class AptosApiError extends Error {
     constructor({ apiType, aptosRequest, aptosResponse }: AptosApiErrorOpts);
 }
 
-export { APTOS_BIP44_REGEX, APTOS_HARDENED_REGEX, AbstractKeylessAccount, AbstractPublicKey, AbstractSignature, AbstractedAccount, Account, AccountAddress, AccountAddressInput, AccountAuthenticator, AccountAuthenticatorAbstraction, AccountAuthenticatorEd25519, AccountAuthenticatorMultiEd25519, AccountAuthenticatorMultiKey, AccountAuthenticatorNoAccountAuthenticator, AccountAuthenticatorSingleKey, AccountData, AccountPublicKey, AccountSequenceNumber, AccountUtils, AnyNumber, AnyPublicKey, AnyRawTransaction, AnyRawTransactionInstance, AnySignature, AnyTransactionPayloadInstance, Aptos, AptosApiError, AptosApiType, AptosConfig, AptosRequest, AptosResponse, AuthenticationKey, type BaseAccountPublicKey, Block, Bool, CKDPriv, Client, ClientConfig, ClientRequest, ClientResponse, CommittedTransactionResponse, type CreateAccountFromPrivateKeyArgs, type CreateEd25519AccountFromPrivateKeyArgs, type CreateEd25519SingleKeyAccountFromPrivateKeyArgs, type CreateSingleKeyAccountFromPrivateKeyArgs, CursorPaginationArgs, DerivableAbstractedAccount, type DerivedKeys, type DeserializableClass, Deserializer, EPK_HORIZON_SECS, Ed25519Account, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, type Ed25519SignerConstructorArgs, type Ed25519SignerFromDerivationPathArgs, EntryFunction, EntryFunctionABI, EntryFunctionArgument, EntryFunctionArgumentTypes, EntryFunctionBytes, EphemeralCertificate, EphemeralCertificateVariant, EphemeralKeyPair, EphemeralPublicKey, EphemeralPublicKeyVariant, EphemeralSignature, type ExecutionFinishEventData, type FailureEventData, FederatedKeylessAccount, FederatedKeylessPublicKey, FixedBytes, FunctionABI, GasEstimation, type GenerateAccountArgs, type GenerateEd25519AccountArgs, type GenerateEd25519SingleKeyAccountArgs, type GenerateSingleKeyAccountArgs, GetANSNameResponse, GetAccountCoinsDataResponse, GetAccountCollectionsWithOwnedTokenResponse, GetAccountOwnedTokensFromCollectionResponse, GetAccountOwnedTokensQueryResponse, type GetAptosRequestOptions, GetChainTopUserTransactionsResponse, GetCollectionDataResponse, GetCurrentFungibleAssetBalancesResponse, GetCurrentTokenOwnershipResponse, GetDelegatedStakingActivitiesResponse, GetEventsResponse, GetFungibleAssetActivitiesResponse, GetFungibleAssetMetadataResponse, GetNumberOfDelegatorsResponse, GetObjectDataQueryResponse, GetOwnedTokensResponse, GetProcessorStatusResponse, type GetRequestOptions, GetTableItemsDataResponse, GetTableItemsMetadataResponse, GetTokenActivityResponse, GetTokenDataResponse, GraphqlQuery, Groth16ProofAndStatement, Groth16VerificationKey, Groth16Zkp, HARDENED_OFFSET, HexInput, InputEntryFunctionDataWithABI, InputEntryFunctionDataWithRemoteABI, InputGenerateMultiAgentRawTransactionArgs, InputGenerateSingleSignerRawTransactionArgs, InputGenerateTransactionOptions, InputGenerateTransactionPayloadData, InputGenerateTransactionPayloadDataWithRemoteABI, InputMultiSigDataWithABI, InputMultiSigDataWithRemoteABI, InputScriptData, InputSimulateTransactionData, InputSimulateTransactionOptions, InputSubmitTransactionData, InputTransactionPluginData, InputViewFunctionData, InputViewFunctionDataWithABI, InputViewFunctionDataWithRemoteABI, InputViewFunctionJsonData, KeyType, KeylessAccount, KeylessConfiguration, KeylessError, KeylessErrorCategory, KeylessErrorResolutionTip, KeylessErrorType, KeylessPublicKey, KeylessSignature, type KeylessSigner, LedgerInfo, LedgerVersionArg, MAX_AUD_VAL_BYTES, MAX_COMMITED_EPK_BYTES, MAX_EXTRA_FIELD_BYTES, MAX_ISS_VAL_BYTES, MAX_JWT_HEADER_B64_BYTES, MAX_UID_KEY_BYTES, MAX_UID_VAL_BYTES, MimeType, MoveFunction, MoveFunctionId, MoveJWK, MoveModule, MoveModuleBytecode, MoveResource, MoveString, MoveStructId, MoveValue, MoveVector, MultiAgentTransaction, MultiEd25519Account, MultiEd25519PublicKey, MultiEd25519Signature, type MultiEd25519SignerConstructorArgs, MultiKey, MultiKeyAccount, MultiKeySignature, OrderByArg, PaginationArgs, PendingTransactionResponse, type PostAptosRequestOptions, type PostRequestOptions, PrivateKey, type PrivateKeyFromDerivationPathArgs, PrivateKeyInput, ProcessorType, type ProofFetchCallback, type ProofFetchEvents, type ProofFetchFailure, type ProofFetchStatus, type ProofFetchSuccess, PublicKey, RawTransaction, RotationProofChallenge, Serializable, Serializer, Signature, SignedTransaction, SigningScheme, SigningSchemeInput, SimpleEntryFunctionArgumentTypes, SimpleTransaction, SingleKeyAccount, type SingleKeySigner, type SingleKeySignerConstructorArgs, type SingleKeySignerFromDerivationPathArgs, type SingleKeySignerGenerateArgs, type SingleKeySignerOrLegacyEd25519Account, type SuccessEventData, TableItemRequest, TokenStandardArg, TransactionAndProof, TransactionAuthenticator, TransactionAuthenticatorEd25519, TransactionAuthenticatorFeePayer, TransactionAuthenticatorMultiAgent, TransactionAuthenticatorMultiEd25519, TransactionAuthenticatorSingleSender, TransactionInnerPayload, TransactionPayloadEntryFunction, TransactionPayloadMultiSig, TransactionPayloadScript, TransactionResponse, TransactionWorker, type TransactionWorkerEvents, TransactionWorkerEventsEnum, TypeArgument, TypeTag, TypeTagParserError, TypeTagParserErrorType, U128, U16, U256, U32, U64, U8, UserTransactionResponse, type VerifyEd25519SignatureArgs, type VerifyMultiEd25519SignatureArgs, type VerifyMultiKeySignatureArgs, VerifySignatureArgs, VerifySignatureAsyncArgs, type VerifySingleKeySignatureArgs, ViewFunctionABI, WaitForTransactionOptions, WhereArg, ZeroKnowledgeSig, ZkProof, ZkpVariant, aptosRequest, base64UrlDecode, base64UrlToBytes, bigIntToBytesLE, buildTransaction, bytesToBigIntLE, checkOrConvertArgument, convertAmountFromHumanReadableToOnChain, convertAmountFromOnChainToHumanReadable, convertArgument, convertNumber, convertPayloadToInnerPayload, createObjectAddress, createResourceAddress, createTokenAddress, deriveKey, deriveTransactionType, deserializePublicKey, deserializeSignature, fetchEntryFunctionAbi, fetchFunctionAbi, fetchJWK, fetchModuleAbi, fetchMoveFunctionAbi, fetchViewFunctionAbi, findFirstNonSignerArg, floorToWholeHour, generateRawTransaction, generateSignedTransaction, generateSignedTransactionForSimulation, generateSigningMessage, generateSigningMessageForSerializable, generateSigningMessageForTransaction, generateTransactionPayload, generateTransactionPayloadWithABI, generateUserTransactionHash, generateViewFunctionPayload, generateViewFunctionPayloadWithABI, get, getAptosFullNode, getAptosPepperService, getAuthenticatorForSimulation, getErrorMessage, getFunctionParts, getIssAudAndUidVal, getKeylessConfig, getKeylessJWKs, getPageWithObfuscatedCursor, hashStrToField, hashValues, isBcsAddress, isBcsBool, isBcsFixedBytes, isBcsString, isBcsU128, isBcsU16, isBcsU256, isBcsU32, isBcsU64, isBcsU8, isBool, isEmptyOption, isEncodedEntryFunctionArgument, isEncodedStruct, isKeylessSigner, isLargeNumber, isNumber, isScriptDataInput, isSingleKeySigner, isString, isValidBIP44Path, isValidFunctionInfo, isValidHardenedPath, mnemonicToSeed, normalizeBundle, nowInSeconds, padAndPackBytesWithLen, paginateWithCursor, paginateWithObfuscatedCursor, pairedFaMetadataAddress, parseEncodedStruct, parseJwtHeader, parseTypeTag, poseidonHash, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, postAptosPepperService, postAptosProvingService, promiseFulfilledStatus, request, sleep, splitPath, standardizeTypeTags, throwTypeMismatch, truncateAddress, verifyKeylessSignature, verifyKeylessSignatureWithJwkAndConfig };
+export { APTOS_BIP44_REGEX, APTOS_HARDENED_REGEX, AbstractKeylessAccount, AbstractPublicKey, AbstractSignature, AbstractedAccount, Account, AccountAddress, AccountAddressInput, AccountAuthenticator, AccountAuthenticatorAbstraction, AccountAuthenticatorEd25519, AccountAuthenticatorMultiEd25519, AccountAuthenticatorMultiKey, AccountAuthenticatorNoAccountAuthenticator, AccountAuthenticatorSingleKey, AccountData, AccountPublicKey, AccountSequenceNumber, AccountUtils, AnyNumber, AnyPublicKey, AnyRawTransaction, AnyRawTransactionInstance, AnySignature, AnyTransactionPayloadInstance, Aptos, AptosApiError, AptosApiType, AptosConfig, AptosRequest, AptosResponse, AuthenticationKey, type BaseAccountPublicKey, Block, Bool, CKDPriv, Client, ClientConfig, ClientRequest, ClientResponse, CommittedTransactionResponse, type CreateAccountFromPrivateKeyArgs, type CreateEd25519AccountFromPrivateKeyArgs, type CreateEd25519SingleKeyAccountFromPrivateKeyArgs, type CreateSingleKeyAccountFromPrivateKeyArgs, CursorPaginationArgs, DerivableAbstractedAccount, type DerivedKeys, type DeserializableClass, Deserializer, EPK_HORIZON_SECS, Ed25519Account, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, type Ed25519SignerConstructorArgs, type Ed25519SignerFromDerivationPathArgs, EntryFunction, EntryFunctionABI, EntryFunctionArgument, EntryFunctionArgumentTypes, EntryFunctionBytes, EphemeralCertificate, EphemeralCertificateVariant, EphemeralKeyPair, EphemeralPublicKey, EphemeralPublicKeyVariant, EphemeralSignature, type ExecutionFinishEventData, type FailureEventData, FederatedKeylessAccount, FederatedKeylessPublicKey, FixedBytes, FunctionABI, GasEstimation, type GenerateAccountArgs, type GenerateEd25519AccountArgs, type GenerateEd25519SingleKeyAccountArgs, type GenerateSingleKeyAccountArgs, GetANSNameResponse, GetAccountCoinsDataResponse, GetAccountCollectionsWithOwnedTokenResponse, GetAccountOwnedTokensFromCollectionResponse, GetAccountOwnedTokensQueryResponse, type GetAptosRequestOptions, GetChainTopUserTransactionsResponse, GetCollectionDataResponse, GetCurrentFungibleAssetBalancesResponse, GetCurrentTokenOwnershipResponse, GetDelegatedStakingActivitiesResponse, GetFungibleAssetActivitiesResponse, GetFungibleAssetMetadataResponse, GetNumberOfDelegatorsResponse, GetObjectDataQueryResponse, GetOwnedTokensResponse, GetProcessorStatusResponse, type GetRequestOptions, GetTableItemsDataResponse, GetTableItemsMetadataResponse, GetTokenActivityResponse, GetTokenDataResponse, GraphqlQuery, Groth16ProofAndStatement, Groth16VerificationKey, Groth16Zkp, HARDENED_OFFSET, HexInput, InputEntryFunctionDataWithABI, InputEntryFunctionDataWithRemoteABI, InputGenerateMultiAgentRawTransactionArgs, InputGenerateSingleSignerRawTransactionArgs, InputGenerateTransactionOptions, InputGenerateTransactionPayloadData, InputGenerateTransactionPayloadDataWithRemoteABI, InputMultiSigDataWithABI, InputMultiSigDataWithRemoteABI, InputScriptData, InputSimulateTransactionData, InputSimulateTransactionOptions, InputSubmitTransactionData, InputTransactionPluginData, InputViewFunctionData, InputViewFunctionDataWithABI, InputViewFunctionDataWithRemoteABI, InputViewFunctionJsonData, KeyType, KeylessAccount, KeylessConfiguration, KeylessError, KeylessErrorCategory, KeylessErrorResolutionTip, KeylessErrorType, KeylessPublicKey, KeylessSignature, type KeylessSigner, LedgerInfo, LedgerVersionArg, MAX_AUD_VAL_BYTES, MAX_COMMITED_EPK_BYTES, MAX_EXTRA_FIELD_BYTES, MAX_ISS_VAL_BYTES, MAX_JWT_HEADER_B64_BYTES, MAX_UID_KEY_BYTES, MAX_UID_VAL_BYTES, MimeType, MoveFunction, MoveFunctionId, MoveJWK, MoveModule, MoveModuleBytecode, MoveResource, MoveString, MoveStructId, MoveValue, MoveVector, MultiAgentTransaction, MultiEd25519Account, MultiEd25519PublicKey, MultiEd25519Signature, type MultiEd25519SignerConstructorArgs, MultiKey, MultiKeyAccount, MultiKeySignature, Network, OrderByArg, PaginationArgs, PendingTransactionResponse, type PostAptosRequestOptions, type PostRequestOptions, PrivateKey, type PrivateKeyFromDerivationPathArgs, PrivateKeyInput, ProcessorType, type ProofFetchCallback, type ProofFetchEvents, type ProofFetchFailure, type ProofFetchStatus, type ProofFetchSuccess, PublicKey, RawTransaction, RotationProofChallenge, Serializable, Serializer, Signature, SignedTransaction, SigningScheme, SigningSchemeInput, SimpleEntryFunctionArgumentTypes, SimpleTransaction, SingleKeyAccount, type SingleKeySigner, type SingleKeySignerConstructorArgs, type SingleKeySignerFromDerivationPathArgs, type SingleKeySignerGenerateArgs, type SingleKeySignerOrLegacyEd25519Account, type SuccessEventData, TableItemRequest, TokenStandardArg, TransactionAndProof, TransactionAuthenticator, TransactionAuthenticatorEd25519, TransactionAuthenticatorFeePayer, TransactionAuthenticatorMultiAgent, TransactionAuthenticatorMultiEd25519, TransactionAuthenticatorSingleSender, TransactionInnerPayload, TransactionManager, TransactionPayloadEntryFunction, TransactionPayloadMultiSig, TransactionPayloadScript, TransactionResponse, TransactionSubmitter, TransactionWorker, type TransactionWorkerEvents, TransactionWorkerEventsEnum, TypeArgument, TypeTag, TypeTagParserError, TypeTagParserErrorType, U128, U16, U256, U32, U64, U8, UserTransactionResponse, type VerifyEd25519SignatureArgs, type VerifyMultiEd25519SignatureArgs, type VerifyMultiKeySignatureArgs, VerifySignatureArgs, VerifySignatureAsyncArgs, type VerifySingleKeySignatureArgs, ViewFunctionABI, WaitForTransactionOptions, WhereArg, ZeroKnowledgeSig, ZkProof, ZkpVariant, aptosRequest, base64UrlDecode, base64UrlToBytes, bigIntToBytesLE, buildTransaction, bytesToBigIntLE, checkOrConvertArgument, convertAmountFromHumanReadableToOnChain, convertAmountFromOnChainToHumanReadable, convertArgument, convertNumber, convertPayloadToInnerPayload, createObjectAddress, createResourceAddress, createTokenAddress, deriveKey, deriveTransactionType, deserializePublicKey, deserializeSignature, fetchEntryFunctionAbi, fetchFunctionAbi, fetchJWK, fetchModuleAbi, fetchMoveFunctionAbi, fetchViewFunctionAbi, findFirstNonSignerArg, floorToWholeHour, generateRawTransaction, generateSignedTransaction, generateSignedTransactionForSimulation, generateSigningMessage, generateSigningMessageForSerializable, generateSigningMessageForTransaction, generateTransactionPayload, generateTransactionPayloadWithABI, generateUserTransactionHash, generateViewFunctionPayload, generateViewFunctionPayloadWithABI, get, getAptosFullNode, getAptosPepperService, getAuthenticatorForSimulation, getErrorMessage, getFunctionParts, getIssAudAndUidVal, getKeylessConfig, getKeylessJWKs, getPageWithObfuscatedCursor, hashStrToField, hashValues, isBcsAddress, isBcsBool, isBcsFixedBytes, isBcsString, isBcsU128, isBcsU16, isBcsU256, isBcsU32, isBcsU64, isBcsU8, isBool, isEmptyOption, isEncodedEntryFunctionArgument, isEncodedStruct, isKeylessSigner, isLargeNumber, isNumber, isScriptDataInput, isSingleKeySigner, isString, isValidBIP44Path, isValidFunctionInfo, isValidHardenedPath, mnemonicToSeed, normalizeBundle, nowInSeconds, padAndPackBytesWithLen, paginateWithCursor, paginateWithObfuscatedCursor, pairedFaMetadataAddress, parseEncodedStruct, parseJwtHeader, parseTypeTag, poseidonHash, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, postAptosPepperService, postAptosProvingService, promiseFulfilledStatus, request, sleep, splitPath, standardizeTypeTags, throwTypeMismatch, truncateAddress, verifyKeylessSignature, verifyKeylessSignatureWithJwkAndConfig };