@sentio/sdk 2.50.2-rc.2 → 2.51.0-rc.2

package/lib/aptos/builtin/0x1.d.ts

@@ -2,7 +2,7 @@ import { CallFilter, MoveFetchConfig } from "@sentio/sdk/move";
 import { AptosBindOptions, AptosBaseProcessor, TypedFunctionPayload, AptosContext } from "@sentio/sdk/aptos";
 import { TypeDescriptor } from "@typemove/move";
 import { MoveCoder, TypedEventInstance } from "@typemove/aptos";
-import { MoveAddressType } from "@aptos-labs/ts-sdk";
+import { Aptos, Account as AptosAccount, MoveAddressType, PendingTransactionResponse, InputGenerateTransactionOptions, MoveStructId } from "@aptos-labs/ts-sdk";
 export declare namespace acl {
     interface ACL {
         list: MoveAddressType[];
@@ -11,6 +11,8 @@ export declare namespace acl {
         const TYPE_QNAME = "0x1::acl::ACL";
         function type(): TypeDescriptor<ACL>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace any$ {
     interface Any {
@@ -21,8 +23,13 @@ export declare namespace any$ {
         const TYPE_QNAME = "0x1::any::Any";
         function type(): TypeDescriptor<Any>;
     }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace bcs {
+    namespace entry { }
+    namespace view { }
 }
-export declare namespace bcs { }
 export declare class dkg extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -69,6 +76,8 @@ export declare namespace dkg {
         const TYPE_QNAME = "0x1::dkg::DKGState";
         function type(): TypeDescriptor<DKGState>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare class code extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -144,6 +153,13 @@ export declare namespace code {
         const TYPE_QNAME = "0x1::code::UpgradePolicy";
         function type(): TypeDescriptor<UpgradePolicy>;
     }
+    namespace entry {
+        function publishPackageTxn(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string, string[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view { }
     interface PublishPackageTxnPayload extends TypedFunctionPayload<[string, string[]]> {
         arguments_decoded: [string, string[]];
         type_arguments: [];
@@ -370,6 +386,87 @@ export declare namespace coin {
         data_decoded: WithdrawEvent;
         type_arguments: [];
     }
+    namespace entry {
+        function createCoinConversionMap(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createPairing<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function freezeCoinStore<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function migrateToFungibleStore<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function transfer<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function unfreezeCoinStore<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function upgradeSupply<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view {
+        function balance<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function coinSupply<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+        }, version?: bigint): Promise<[option.Option<bigint>]>;
+        function decimals<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+        }, version?: bigint): Promise<[number]>;
+        function isAccountRegistered<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+        function isBalanceAtLeast<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[boolean]>;
+        function isCoinInitialized<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+        }, version?: bigint): Promise<[boolean]>;
+        function isCoinStoreFrozen<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+        function name<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+        }, version?: bigint): Promise<[string]>;
+        function pairedBurnRefExists<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+        }, version?: bigint): Promise<[boolean]>;
+        function pairedCoin(client: Aptos, request: {
+            functionArguments: [object$.Object<fungible_asset.Metadata>];
+        }, version?: bigint): Promise<[option.Option<type_info.TypeInfo>]>;
+        function pairedMetadata<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+        }, version?: bigint): Promise<[option.Option<object$.Object<fungible_asset.Metadata>>]>;
+        function pairedMintRefExists<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+        }, version?: bigint): Promise<[boolean]>;
+        function pairedTransferRefExists<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+        }, version?: bigint): Promise<[boolean]>;
+        function supply<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+        }, version?: bigint): Promise<[option.Option<bigint>]>;
+        function symbol$<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+        }, version?: bigint): Promise<[string]>;
+    }
     interface CreateCoinConversionMapPayload extends TypedFunctionPayload<[]> {
         arguments_decoded: [];
         type_arguments: [];
@@ -415,8 +512,13 @@ export declare namespace guid {
         const TYPE_QNAME = "0x1::guid::ID";
         function type(): TypeDescriptor<ID>;
     }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace hash {
+    namespace entry { }
+    namespace view { }
 }
-export declare namespace hash { }
 export declare class jwks extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -559,6 +661,13 @@ export declare namespace jwks {
         const TYPE_QNAME = "0x1::jwks::UnsupportedJWK";
         function type(): TypeDescriptor<UnsupportedJWK>;
     }
+    namespace entry {
+        function updateFederatedJwkSet(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string, string[], string[], string[], string[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view { }
     interface UpdateFederatedJwkSetPayload extends TypedFunctionPayload<[
         string,
         string[],
@@ -570,7 +679,10 @@ export declare namespace jwks {
         type_arguments: [];
     }
 }
-export declare namespace util { }
+export declare namespace util {
+    namespace entry { }
+    namespace view { }
+}
 export declare class block extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -660,9 +772,20 @@ export declare namespace block {
         data_decoded: UpdateEpochIntervalEvent;
         type_arguments: [];
     }
+    namespace entry { }
+    namespace view {
+        function getCurrentBlockHeight(client: Aptos, version?: bigint): Promise<[bigint]>;
+        function getEpochIntervalSecs(client: Aptos, version?: bigint): Promise<[bigint]>;
+    }
+}
+export declare namespace debug {
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace error {
+    namespace entry { }
+    namespace view { }
 }
-export declare namespace debug { }
-export declare namespace error { }
 export declare namespace event {
     interface EventHandle<T0> {
         counter: bigint;
@@ -672,6 +795,8 @@ export declare namespace event {
         const TYPE_QNAME = "0x1::event::EventHandle";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<EventHandle<T0>>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare class stake extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -1109,6 +1234,95 @@ export declare namespace stake {
         data_decoded: WithdrawStakeEvent;
         type_arguments: [];
     }
+    namespace entry {
+        function addStake(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function increaseLockup(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function initializeStakeOwner(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint, MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function initializeValidator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string, string, string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function joinValidatorSet(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function leaveValidatorSet(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function reactivateStake(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function rotateConsensusKey(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setDelegatedVoter(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function unlock(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateNetworkAndFullnodeAddresses(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function withdraw(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view {
+        function getCurrentEpochProposalCounts(client: Aptos, request: {
+            functionArguments: [bigint];
+        }, version?: bigint): Promise<[bigint, bigint]>;
+        function getCurrentEpochVotingPower(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function getDelegatedVoter(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function getLockupSecs(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function getOperator(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function getRemainingLockupSecs(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function getStake(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint, bigint, bigint, bigint]>;
+        function getValidatorConfig(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[string, string, string]>;
+        function getValidatorIndex(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function getValidatorState(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function stakePoolExists(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+    }
     interface AddStakePayload extends TypedFunctionPayload<[bigint]> {
         arguments_decoded: [bigint];
         type_arguments: [];
@@ -1177,8 +1391,13 @@ export declare namespace table {
         const TYPE_QNAME = "0x1::table::Table";
         function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Table<T0, T1>>;
     }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace math64 {
+    namespace entry { }
+    namespace view { }
 }
-export declare namespace math64 { }
 export declare class object$ extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -1229,9 +1448,7 @@ export declare namespace object$ {
         const TYPE_QNAME = "0x1::object::LinearTransferRef";
         function type(): TypeDescriptor<LinearTransferRef>;
     }
-    interface Object<T0> {
-        inner: MoveAddressType;
-    }
+    type Object<T> = MoveAddressType;
     namespace Object {
         const TYPE_QNAME = "0x1::object::Object";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Object<T0>>;
@@ -1300,6 +1517,38 @@ export declare namespace object$ {
         const TYPE_QNAME = "0x1::object::Untransferable";
         function type(): TypeDescriptor<Untransferable>;
     }
+    namespace entry {
+        function burn<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function transfer<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function transferCall(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function transferToObject<T0 = any, T1 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId, MoveStructId];
+            functionArguments: [object$.Object<T0>, object$.Object<T1>];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function unburn<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view {
+        function isBurnt<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[boolean]>;
+        function isUntransferable<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[boolean]>;
+    }
     interface BurnPayload<T0 = any> extends TypedFunctionPayload<[object$.Object<T0>]> {
         arguments_decoded: [object$.Object<T0>];
         type_arguments: [string];
@@ -1323,14 +1572,19 @@ export declare namespace object$ {
 }
 export declare namespace option {
     interface Option<T0> {
-        vec: T0[] | string;
+        vec: T0[];
     }
     namespace Option {
         const TYPE_QNAME = "0x1::option::Option";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Option<T0>>;
     }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace signer {
+    namespace entry { }
+    namespace view { }
 }
-export declare namespace signer { }
 export declare namespace string$ {
     interface String {
         bytes: string;
@@ -1339,8 +1593,13 @@ export declare namespace string$ {
         const TYPE_QNAME = "0x1::string::String";
         function type(): TypeDescriptor<String>;
     }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace vector {
+    namespace entry { }
+    namespace view { }
 }
-export declare namespace vector { }
 export declare class voting extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -1485,6 +1744,69 @@ export declare namespace voting {
         const TYPE_QNAME = "0x1::voting::VotingForum";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<VotingForum<T0>>;
     }
+    namespace entry { }
+    namespace view {
+        function getEarlyResolutionVoteThreshold<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[option.Option<bigint>]>;
+        function getExecutionHash<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[string]>;
+        function getMinVoteThreshold<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[bigint]>;
+        function getProposalCreationSecs<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[bigint]>;
+        function getProposalExpirationSecs<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[bigint]>;
+        function getProposalMetadata<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[simple_map.SimpleMap<string, string>]>;
+        function getProposalMetadataValue<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint, string];
+        }, version?: bigint): Promise<[string]>;
+        function getProposalState<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[bigint]>;
+        function getProposer<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function getResolutionTimeSecs<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[bigint]>;
+        function getVotes<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[bigint, bigint]>;
+        function isMultiStepProposalInExecution<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[boolean]>;
+        function isResolved<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[boolean]>;
+        function isVotingClosed<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[boolean]>;
+        function nextProposalId<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+    }
 }
 export declare class account extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -1499,6 +1821,7 @@ export declare class account extends AptosBaseProcessor {
     onEntryRotateAuthenticationKey(func: (call: account.RotateAuthenticationKeyPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account;
     onEntryRotateAuthenticationKeyCall(func: (call: account.RotateAuthenticationKeyCallPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account;
     onEntryRotateAuthenticationKeyWithRotationCapability(func: (call: account.RotateAuthenticationKeyWithRotationCapabilityPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account;
+    onEventCoinRegister(func: (event: account.CoinRegisterInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): account;
     onEventKeyRotation(func: (event: account.KeyRotationInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): account;
     onEventCoinRegisterEvent(func: (event: account.CoinRegisterEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): account;
     onEventKeyRotationEvent(func: (event: account.KeyRotationEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): account;
@@ -1524,6 +1847,18 @@ export declare namespace account {
         const TYPE_QNAME = "0x1::account::CapabilityOffer";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<CapabilityOffer<T0>>;
     }
+    interface CoinRegister {
+        account: MoveAddressType;
+        type_info: type_info.TypeInfo;
+    }
+    namespace CoinRegister {
+        const TYPE_QNAME = "0x1::account::CoinRegister";
+        function type(): TypeDescriptor<CoinRegister>;
+    }
+    interface CoinRegisterInstance extends TypedEventInstance<CoinRegister> {
+        data_decoded: CoinRegister;
+        type_arguments: [];
+    }
     interface CoinRegisterEvent {
         type_info: type_info.TypeInfo;
     }
@@ -1626,6 +1961,70 @@ export declare namespace account {
         const TYPE_QNAME = "0x1::account::SignerCapabilityOfferProofChallengeV2";
         function type(): TypeDescriptor<SignerCapabilityOfferProofChallengeV2>;
     }
+    namespace entry {
+        function offerRotationCapability(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string, number, string, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function offerSignerCapability(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string, number, string, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function revokeAnyRotationCapability(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function revokeAnySignerCapability(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function revokeRotationCapability(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function revokeSignerCapability(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function rotateAuthenticationKey(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [number, string, number, string, string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function rotateAuthenticationKeyCall(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function rotateAuthenticationKeyWithRotationCapability(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, number, string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view {
+        function existsAt(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+        function getAuthenticationKey(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[string]>;
+        function getGuidNextCreationNum(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function getRotationCapabilityOfferFor(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function getSequenceNumber(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function getSignerCapabilityOfferFor(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function isRotationCapabilityOffered(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+        function isSignerCapabilityOffered(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+    }
     interface OfferRotationCapabilityPayload extends TypedFunctionPayload<[string, number, string, MoveAddressType]> {
         arguments_decoded: [string, number, string, MoveAddressType];
         type_arguments: [];
@@ -1700,6 +2099,8 @@ export declare namespace ed25519 {
         const TYPE_QNAME = "0x1::ed25519::ValidatedPublicKey";
         function type(): TypeDescriptor<ValidatedPublicKey>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace genesis {
     interface AccountMap {
@@ -1744,8 +2145,13 @@ export declare namespace genesis {
         const TYPE_QNAME = "0x1::genesis::ValidatorConfigurationWithCommission";
         function type(): TypeDescriptor<ValidatorConfigurationWithCommission>;
     }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace math128 {
+    namespace entry { }
+    namespace view { }
 }
-export declare namespace math128 { }
 export declare class version extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -1768,6 +2174,17 @@ export declare namespace version {
         const TYPE_QNAME = "0x1::version::Version";
         function type(): TypeDescriptor<Version>;
     }
+    namespace entry {
+        function setForNextEpoch(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setVersion(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view { }
     interface SetForNextEpochPayload extends TypedFunctionPayload<[bigint]> {
         arguments_decoded: [bigint];
         type_arguments: [];
@@ -2169,6 +2586,124 @@ export declare namespace vesting {
         const TYPE_QNAME = "0x1::vesting::VestingSchedule";
         function type(): TypeDescriptor<VestingSchedule>;
     }
+    namespace entry {
+        function adminWithdraw(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function distribute(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function distributeMany(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function resetBeneficiary(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function resetLockup(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setBeneficiary(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setBeneficiaryForOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setBeneficiaryResetter(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setManagementRole(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function terminateVestingContract(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function unlockRewards(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function unlockRewardsMany(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateCommissionPercentage(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateOperatorWithSameCommission(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateVoter(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function vest(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function vestMany(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view {
+        function accumulatedRewards(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function beneficiary(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function operator(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function operatorCommissionPercentage(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function periodDurationSecs(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function remainingGrant(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function shareholder(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function shareholders(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType[]]>;
+        function stakePoolAddress(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function totalAccumulatedRewards(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function vestingContracts(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType[]]>;
+        function vestingSchedule(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[vesting.VestingSchedule]>;
+        function vestingStartSecs(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function voter(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+    }
     interface AdminWithdrawPayload extends TypedFunctionPayload<[MoveAddressType]> {
         arguments_decoded: [MoveAddressType];
         type_arguments: [];
@@ -2289,6 +2824,8 @@ export declare namespace bls12381 {
         const TYPE_QNAME = "0x1::bls12381::Signature";
         function type(): TypeDescriptor<Signature>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace chain_id {
     interface ChainId {
@@ -2298,6 +2835,10 @@ export declare namespace chain_id {
         const TYPE_QNAME = "0x1::chain_id::ChainId";
         function type(): TypeDescriptor<ChainId>;
     }
+    namespace entry { }
+    namespace view {
+        function get(client: Aptos, version?: bigint): Promise<[number]>;
+    }
 }
 export declare namespace features {
     interface Features {
@@ -2314,8 +2855,17 @@ export declare namespace features {
         const TYPE_QNAME = "0x1::features::PendingFeatures";
         function type(): TypeDescriptor<PendingFeatures>;
     }
+    namespace entry { }
+    namespace view {
+        function isEnabled(client: Aptos, request: {
+            functionArguments: [bigint];
+        }, version?: bigint): Promise<[boolean]>;
+    }
+}
+export declare namespace from_bcs {
+    namespace entry { }
+    namespace view { }
 }
-export declare namespace from_bcs { }
 export declare namespace pool_u64 {
     interface Pool {
         shareholders_limit: bigint;
@@ -2329,6 +2879,8 @@ export declare namespace pool_u64 {
         const TYPE_QNAME = "0x1::pool_u64::Pool";
         function type(): TypeDescriptor<Pool>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace secp256k1 {
     interface ECDSARawPublicKey {
@@ -2345,6 +2897,8 @@ export declare namespace secp256k1 {
         const TYPE_QNAME = "0x1::secp256k1::ECDSASignature";
         function type(): TypeDescriptor<ECDSASignature>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace timestamp {
     interface CurrentTimeMicroseconds {
@@ -2354,6 +2908,11 @@ export declare namespace timestamp {
         const TYPE_QNAME = "0x1::timestamp::CurrentTimeMicroseconds";
         function type(): TypeDescriptor<CurrentTimeMicroseconds>;
     }
+    namespace entry { }
+    namespace view {
+        function nowMicroseconds(client: Aptos, version?: bigint): Promise<[bigint]>;
+        function nowSeconds(client: Aptos, version?: bigint): Promise<[bigint]>;
+    }
 }
 export declare namespace type_info {
     interface TypeInfo {
@@ -2365,6 +2924,8 @@ export declare namespace type_info {
         const TYPE_QNAME = "0x1::type_info::TypeInfo";
         function type(): TypeDescriptor<TypeInfo>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace aggregator {
     interface Aggregator {
@@ -2376,6 +2937,8 @@ export declare namespace aggregator {
         const TYPE_QNAME = "0x1::aggregator::Aggregator";
         function type(): TypeDescriptor<Aggregator>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare class aptos_coin extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -2414,6 +2977,21 @@ export declare namespace aptos_coin {
         const TYPE_QNAME = "0x1::aptos_coin::MintCapStore";
         function type(): TypeDescriptor<MintCapStore>;
     }
+    namespace entry {
+        function claimMintCapability(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function delegateMintCapability(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function mint(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view { }
     interface ClaimMintCapabilityPayload extends TypedFunctionPayload<[]> {
         arguments_decoded: [];
         type_arguments: [];
@@ -2427,10 +3005,13 @@ export declare namespace aptos_coin {
         type_arguments: [];
     }
 }
-export declare namespace aptos_hash { }
+export declare namespace aptos_hash {
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace big_vector {
     interface BigVector<T0> {
-        buckets: table_with_length.TableWithLength<bigint, T0[] | string>;
+        buckets: table_with_length.TableWithLength<bigint, T0[]>;
         end_index: bigint;
         bucket_size: bigint;
     }
@@ -2438,6 +3019,8 @@ export declare namespace big_vector {
         const TYPE_QNAME = "0x1::big_vector::BigVector";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<BigVector<T0>>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace bit_vector {
     interface BitVector {
@@ -2448,6 +3031,8 @@ export declare namespace bit_vector {
         const TYPE_QNAME = "0x1::bit_vector::BitVector";
         function type(): TypeDescriptor<BitVector>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace capability {
     interface Cap<T0> {
@@ -2478,6 +3063,8 @@ export declare namespace capability {
         const TYPE_QNAME = "0x1::capability::LinearCap";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<LinearCap<T0>>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace comparator {
     interface Result {
@@ -2487,8 +3074,13 @@ export declare namespace comparator {
         const TYPE_QNAME = "0x1::comparator::Result";
         function type(): TypeDescriptor<Result>;
     }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace math_fixed {
+    namespace entry { }
+    namespace view { }
 }
-export declare namespace math_fixed { }
 export declare class randomness extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -2516,6 +3108,8 @@ export declare namespace randomness {
         data_decoded: RandomnessGeneratedEvent;
         type_arguments: [];
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace simple_map {
     interface Element<T0, T1> {
@@ -2533,6 +3127,8 @@ export declare namespace simple_map {
         const TYPE_QNAME = "0x1::simple_map::SimpleMap";
         function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<SimpleMap<T0, T1>>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace smart_table {
     interface Entry<T0, T1> {
@@ -2556,6 +3152,8 @@ export declare namespace smart_table {
         const TYPE_QNAME = "0x1::smart_table::SmartTable";
         function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<SmartTable<T0, T1>>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace storage_gas {
     interface GasCurve {
@@ -2605,6 +3203,8 @@ export declare namespace storage_gas {
         const TYPE_QNAME = "0x1::storage_gas::UsageGasConfig";
         function type(): TypeDescriptor<UsageGasConfig>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace chain_status {
     interface GenesisEndMarker {
@@ -2614,6 +3214,11 @@ export declare namespace chain_status {
         const TYPE_QNAME = "0x1::chain_status::GenesisEndMarker";
         function type(): TypeDescriptor<GenesisEndMarker>;
     }
+    namespace entry { }
+    namespace view {
+        function isGenesis(client: Aptos, version?: bigint): Promise<[boolean]>;
+        function isOperating(client: Aptos, version?: bigint): Promise<[boolean]>;
+    }
 }
 export declare namespace copyable_any {
     interface Any {
@@ -2624,6 +3229,8 @@ export declare namespace copyable_any {
         const TYPE_QNAME = "0x1::copyable_any::Any";
         function type(): TypeDescriptor<Any>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace gas_schedule {
     interface GasEntry {
@@ -2649,6 +3256,8 @@ export declare namespace gas_schedule {
         const TYPE_QNAME = "0x1::gas_schedule::GasScheduleV2";
         function type(): TypeDescriptor<GasScheduleV2>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare class managed_coin extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -2670,6 +3279,29 @@ export declare namespace managed_coin {
         const TYPE_QNAME = "0x1::managed_coin::Capabilities";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Capabilities<T0>>;
     }
+    namespace entry {
+        function burn<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function destroyCaps<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function initialize<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [string, string, number, boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function mint<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function register<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view { }
     interface BurnPayload<T0 = any> extends TypedFunctionPayload<[bigint]> {
         arguments_decoded: [bigint];
         type_arguments: [string];
@@ -2691,7 +3323,10 @@ export declare namespace managed_coin {
         type_arguments: [string];
     }
 }
-export declare namespace math_fixed64 { }
+export declare namespace math_fixed64 {
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace ristretto255 {
     interface CompressedRistretto {
         data: string;
@@ -2714,10 +3349,12 @@ export declare namespace ristretto255 {
         const TYPE_QNAME = "0x1::ristretto255::Scalar";
         function type(): TypeDescriptor<Scalar>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace smart_vector {
     interface SmartVector<T0> {
-        inline_vec: T0[] | string;
+        inline_vec: T0[];
         big_vec: option.Option<big_vector.BigVector<T0>>;
         inline_capacity: option.Option<bigint>;
         bucket_size: option.Option<bigint>;
@@ -2726,6 +3363,8 @@ export declare namespace smart_vector {
         const TYPE_QNAME = "0x1::smart_vector::SmartVector";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<SmartVector<T0>>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace string_utils {
     interface Cons<T0, T1> {
@@ -2751,6 +3390,8 @@ export declare namespace string_utils {
         const TYPE_QNAME = "0x1::string_utils::NIL";
         function type(): TypeDescriptor<NIL>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace aggregator_v2 {
     interface Aggregator<T0> {
@@ -2776,6 +3417,8 @@ export declare namespace aggregator_v2 {
         const TYPE_QNAME = "0x1::aggregator_v2::DerivedStringSnapshot";
         function type(): TypeDescriptor<DerivedStringSnapshot>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare class aptos_account extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -2783,11 +3426,13 @@ export declare class aptos_account extends AptosBaseProcessor {
     static bind(options?: Partial<AptosBindOptions>): aptos_account;
     onEntryBatchTransfer(func: (call: aptos_account.BatchTransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
     onEntryBatchTransferCoins(func: (call: aptos_account.BatchTransferCoinsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
+    onEntryBatchTransferFungibleAssets(func: (call: aptos_account.BatchTransferFungibleAssetsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
     onEntryCreateAccount(func: (call: aptos_account.CreateAccountPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
     onEntryFungibleTransferOnly(func: (call: aptos_account.FungibleTransferOnlyPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
     onEntrySetAllowDirectCoinTransfers(func: (call: aptos_account.SetAllowDirectCoinTransfersPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
     onEntryTransfer(func: (call: aptos_account.TransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
     onEntryTransferCoins(func: (call: aptos_account.TransferCoinsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
+    onEntryTransferFungibleAssets(func: (call: aptos_account.TransferFungibleAssetsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
     onEventDirectCoinTransferConfigUpdated(func: (event: aptos_account.DirectCoinTransferConfigUpdatedInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
     onEventDirectCoinTransferConfigUpdatedEvent(func: (event: aptos_account.DirectCoinTransferConfigUpdatedEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
 }
@@ -2823,6 +3468,57 @@ export declare namespace aptos_account {
         const TYPE_QNAME = "0x1::aptos_account::DirectTransferConfig";
         function type(): TypeDescriptor<DirectTransferConfig>;
     }
+    namespace entry {
+        function batchTransfer(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[], bigint[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function batchTransferCoins<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType[], bigint[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function batchTransferFungibleAssets(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [
+                object$.Object<fungible_asset.Metadata>,
+                MoveAddressType[],
+                bigint[]
+            ];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createAccount(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function fungibleTransferOnly(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setAllowDirectCoinTransfers(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function transfer(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function transferCoins<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function transferFungibleAssets(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [
+                object$.Object<fungible_asset.Metadata>,
+                MoveAddressType,
+                bigint
+            ];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view {
+        function canReceiveDirectCoinTransfers(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+    }
     interface BatchTransferPayload extends TypedFunctionPayload<[MoveAddressType[], bigint[]]> {
         arguments_decoded: [MoveAddressType[], bigint[]];
         type_arguments: [];
@@ -2831,6 +3527,18 @@ export declare namespace aptos_account {
         arguments_decoded: [MoveAddressType[], bigint[]];
         type_arguments: [string];
     }
+    interface BatchTransferFungibleAssetsPayload extends TypedFunctionPayload<[
+        object$.Object<fungible_asset.Metadata>,
+        MoveAddressType[],
+        bigint[]
+    ]> {
+        arguments_decoded: [
+            object$.Object<fungible_asset.Metadata>,
+            MoveAddressType[],
+            bigint[]
+        ];
+        type_arguments: [];
+    }
     interface CreateAccountPayload extends TypedFunctionPayload<[MoveAddressType]> {
         arguments_decoded: [MoveAddressType];
         type_arguments: [];
@@ -2851,6 +3559,18 @@ export declare namespace aptos_account {
         arguments_decoded: [MoveAddressType, bigint];
         type_arguments: [string];
     }
+    interface TransferFungibleAssetsPayload extends TypedFunctionPayload<[
+        object$.Object<fungible_asset.Metadata>,
+        MoveAddressType,
+        bigint
+    ]> {
+        arguments_decoded: [
+            object$.Object<fungible_asset.Metadata>,
+            MoveAddressType,
+            bigint
+        ];
+        type_arguments: [];
+    }
 }
 export declare namespace bn254_algebra {
     interface FormatFq12LscLsb {
@@ -2965,6 +3685,8 @@ export declare namespace bn254_algebra {
         const TYPE_QNAME = "0x1::bn254_algebra::Gt";
         function type(): TypeDescriptor<Gt>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace config_buffer {
     interface PendingConfigs {
@@ -2974,8 +3696,13 @@ export declare namespace config_buffer {
         const TYPE_QNAME = "0x1::config_buffer::PendingConfigs";
         function type(): TypeDescriptor<PendingConfigs>;
     }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace create_signer {
+    namespace entry { }
+    namespace view { }
 }
-export declare namespace create_signer { }
 export declare namespace fixed_point32 {
     interface FixedPoint32 {
         value: bigint;
@@ -2984,6 +3711,8 @@ export declare namespace fixed_point32 {
         const TYPE_QNAME = "0x1::fixed_point32::FixedPoint32";
         function type(): TypeDescriptor<FixedPoint32>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace fixed_point64 {
     interface FixedPoint64 {
@@ -2993,6 +3722,8 @@ export declare namespace fixed_point64 {
         const TYPE_QNAME = "0x1::fixed_point64::FixedPoint64";
         function type(): TypeDescriptor<FixedPoint64>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace function_info {
     interface FunctionInfo {
@@ -3004,6 +3735,8 @@ export declare namespace function_info {
         const TYPE_QNAME = "0x1::function_info::FunctionInfo";
         function type(): TypeDescriptor<FunctionInfo>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace multi_ed25519 {
     interface Signature {
@@ -3027,6 +3760,8 @@ export declare namespace multi_ed25519 {
         const TYPE_QNAME = "0x1::multi_ed25519::ValidatedPublicKey";
         function type(): TypeDescriptor<ValidatedPublicKey>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare class staking_proxy extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -3042,6 +3777,41 @@ export declare class staking_proxy extends AptosBaseProcessor {
     onEntrySetVoter(func: (call: staking_proxy.SetVoterPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_proxy;
 }
 export declare namespace staking_proxy {
+    namespace entry {
+        function setOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setStakePoolOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setStakePoolVoter(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setStakingContractOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setStakingContractVoter(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setVestingContractOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setVestingContractVoter(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setVoter(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view { }
     interface SetOperatorPayload extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
         arguments_decoded: [MoveAddressType, MoveAddressType];
         type_arguments: [];
@@ -3099,6 +3869,8 @@ export declare namespace state_storage {
         const TYPE_QNAME = "0x1::state_storage::Usage";
         function type(): TypeDescriptor<Usage>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace crypto_algebra {
     interface Element<T0> {
@@ -3108,6 +3880,8 @@ export declare namespace crypto_algebra {
         const TYPE_QNAME = "0x1::crypto_algebra::Element";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Element<T0>>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare class fungible_asset extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -3302,6 +4076,77 @@ export declare namespace fungible_asset {
         data_decoded: WithdrawEvent;
         type_arguments: [];
     }
+    namespace entry {
+        function transfer<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>, object$.Object<T0>, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function upgradeStoreToConcurrent<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view {
+        function balance<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[bigint]>;
+        function decimals<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[number]>;
+        function iconUri<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[string]>;
+        function isBalanceAtLeast<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>, bigint];
+        }, version?: bigint): Promise<[boolean]>;
+        function isFrozen<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[boolean]>;
+        function isStoreDispatchable<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[boolean]>;
+        function isUntransferable<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[boolean]>;
+        function maximum<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[option.Option<bigint>]>;
+        function metadata<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[fungible_asset.Metadata]>;
+        function name<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[string]>;
+        function projectUri<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[string]>;
+        function storeExists(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+        function storeMetadata<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[object$.Object<fungible_asset.Metadata>]>;
+        function supply<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[option.Option<bigint>]>;
+        function symbol$<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[string]>;
+    }
     interface TransferPayload<T0 = any> extends TypedFunctionPayload<[
         object$.Object<T0>,
         object$.Object<T0>,
@@ -3340,6 +4185,10 @@ export declare namespace staking_config {
         const TYPE_QNAME = "0x1::staking_config::StakingRewardsConfig";
         function type(): TypeDescriptor<StakingRewardsConfig>;
     }
+    namespace entry { }
+    namespace view {
+        function rewardRate(client: Aptos, version?: bigint): Promise<[bigint, bigint]>;
+    }
 }
 export declare class delegation_pool extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -3784,6 +4633,156 @@ export declare namespace delegation_pool {
         data_decoded: WithdrawStakeEvent;
         type_arguments: [];
     }
+    namespace entry {
+        function addStake(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function allowlistDelegator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createProposal(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, string, string, boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function delegateVotingPower(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function disableDelegatorsAllowlisting(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function enableDelegatorsAllowlisting(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function enablePartialGovernanceVoting(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function evictDelegator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function initializeDelegationPool(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function reactivateStake(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function removeDelegatorFromAllowlist(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setBeneficiaryForOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setDelegatedVoter(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function synchronizeDelegationPool(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function unlock(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateCommissionPercentage(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function vote(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint, bigint, boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function withdraw(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view {
+        function allowlistingEnabled(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+        function beneficiaryForOperator(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function calculateAndUpdateDelegatorVoter(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function calculateAndUpdateRemainingVotingPower(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType, bigint];
+        }, version?: bigint): Promise<[bigint]>;
+        function calculateAndUpdateVoterTotalVotingPower(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function calculateAndUpdateVotingDelegation(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType, MoveAddressType, bigint]>;
+        function canWithdrawPendingInactive(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+        function delegationPoolExists(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+        function delegatorAllowlisted(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+        function getAddStakeFee(client: Aptos, request: {
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[bigint]>;
+        function getDelegationPoolStake(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint, bigint, bigint, bigint]>;
+        function getDelegatorsAllowlist(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType[]]>;
+        function getExpectedStakePoolAddress(client: Aptos, request: {
+            functionArguments: [MoveAddressType, string];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function getOwnedPoolAddress(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function getPendingWithdrawal(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[boolean, bigint]>;
+        function getStake(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[bigint, bigint, bigint]>;
+        function isNextCommissionPercentageEffective(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+        function minRemainingSecsForCommissionChange(client: Aptos, version?: bigint): Promise<[bigint]>;
+        function observedLockupCycle(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function operatorCommissionPercentage(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function operatorCommissionPercentageNextLockupCycle(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function ownerCapExists(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+        function partialGovernanceVotingEnabled(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+        function shareholdersCountActivePool(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+    }
     interface AddStakePayload extends TypedFunctionPayload<[MoveAddressType, bigint]> {
         arguments_decoded: [MoveAddressType, bigint];
         type_arguments: [];
@@ -3900,6 +4899,8 @@ export declare namespace keyless_account {
         const TYPE_QNAME = "0x1::keyless_account::Group";
         function type(): TypeDescriptor<Group>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare class reconfiguration extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -3947,6 +4948,8 @@ export declare namespace reconfiguration {
         data_decoded: NewEpochEvent;
         type_arguments: [];
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare class transaction_fee extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -4001,6 +5004,13 @@ export declare namespace transaction_fee {
         data_decoded: FeeStatement;
         type_arguments: [];
     }
+    namespace entry {
+        function convertToAptosFaBurnRef(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view { }
     interface ConvertToAptosFaBurnRefPayload extends TypedFunctionPayload<[]> {
         arguments_decoded: [];
         type_arguments: [];
@@ -4168,6 +5178,62 @@ export declare namespace aptos_governance {
         const TYPE_QNAME = "0x1::aptos_governance::VotingRecordsV2";
         function type(): TypeDescriptor<VotingRecordsV2>;
     }
+    namespace entry {
+        function addApprovedScriptHashScript(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function batchPartialVote(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[], bigint, bigint, boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function batchVote(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[], bigint, boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createProposal(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createProposalV2(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, string, string, boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function forceEndEpoch(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function forceEndEpochTestOnly(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function partialVote(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint, bigint, boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function reconfigure(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function vote(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint, boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view {
+        function getMinVotingThreshold(client: Aptos, version?: bigint): Promise<[bigint]>;
+        function getRemainingVotingPower(client: Aptos, request: {
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[bigint]>;
+        function getRequiredProposerStake(client: Aptos, version?: bigint): Promise<[bigint]>;
+        function getVotingDurationSecs(client: Aptos, version?: bigint): Promise<[bigint]>;
+        function getVotingPower(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function hasEntirelyVoted(client: Aptos, request: {
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[boolean]>;
+    }
     interface AddApprovedScriptHashScriptPayload extends TypedFunctionPayload<[bigint]> {
         arguments_decoded: [bigint];
         type_arguments: [];
@@ -4321,6 +5387,8 @@ export declare namespace bls12381_algebra {
         const TYPE_QNAME = "0x1::bls12381_algebra::HashG2XmdSha256SswuRo";
         function type(): TypeDescriptor<HashG2XmdSha256SswuRo>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace consensus_config {
     interface ConsensusConfig {
@@ -4330,6 +5398,8 @@ export declare namespace consensus_config {
         const TYPE_QNAME = "0x1::consensus_config::ConsensusConfig";
         function type(): TypeDescriptor<ConsensusConfig>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace execution_config {
     interface ExecutionConfig {
@@ -4339,6 +5409,8 @@ export declare namespace execution_config {
         const TYPE_QNAME = "0x1::execution_config::ExecutionConfig";
         function type(): TypeDescriptor<ExecutionConfig>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare class multisig_account extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -4691,6 +5763,180 @@ export declare namespace multisig_account {
         data_decoded: VoteEvent;
         type_arguments: [];
     }
+    namespace entry {
+        function addOwner(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function addOwners(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function addOwnersAndUpdateSignaturesRequired(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[], bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function approveTransaction(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function create(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint, string[], string[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createTransaction(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createTransactionWithHash(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createWithExistingAccount(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [
+                MoveAddressType,
+                MoveAddressType[],
+                bigint,
+                number,
+                string,
+                string,
+                string[],
+                string[]
+            ];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createWithExistingAccountAndRevokeAuthKey(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [
+                MoveAddressType,
+                MoveAddressType[],
+                bigint,
+                number,
+                string,
+                string,
+                string[],
+                string[]
+            ];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createWithExistingAccountAndRevokeAuthKeyCall(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[], bigint, string[], string[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createWithExistingAccountCall(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[], bigint, string[], string[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createWithOwners(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[], bigint, string[], string[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createWithOwnersThenRemoveBootstrapper(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[], bigint, string[], string[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function executeRejectedTransaction(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function executeRejectedTransactions(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function rejectTransaction(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function removeOwner(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function removeOwners(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function swapOwner(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function swapOwners(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[], MoveAddressType[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function swapOwnersAndUpdateSignaturesRequired(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType[], MoveAddressType[], bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateMetadata(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string[], string[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateSignaturesRequired(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function voteTransaction(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint, boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function voteTransactions(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint, bigint, boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function voteTransanction(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint, boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view {
+        function availableTransactionQueueCapacity(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function canBeExecuted(client: Aptos, request: {
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[boolean]>;
+        function canBeRejected(client: Aptos, request: {
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[boolean]>;
+        function canExecute(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType, bigint];
+        }, version?: bigint): Promise<[boolean]>;
+        function canReject(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType, bigint];
+        }, version?: bigint): Promise<[boolean]>;
+        function getNextMultisigAccountAddress(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function getNextTransactionPayload(client: Aptos, request: {
+            functionArguments: [MoveAddressType, string];
+        }, version?: bigint): Promise<[string]>;
+        function getPendingTransactions(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[multisig_account.MultisigTransaction[]]>;
+        function getTransaction(client: Aptos, request: {
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[multisig_account.MultisigTransaction]>;
+        function isOwner(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+        function lastResolvedSequenceNumber(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function metadata(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[simple_map.SimpleMap<string, string>]>;
+        function nextSequenceNumber(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function numSignaturesRequired(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function owners(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType[]]>;
+        function vote(client: Aptos, request: {
+            functionArguments: [MoveAddressType, bigint, MoveAddressType];
+        }, version?: bigint): Promise<[boolean, boolean]>;
+    }
     interface AddOwnerPayload extends TypedFunctionPayload<[MoveAddressType]> {
         arguments_decoded: [MoveAddressType];
         type_arguments: [];
@@ -4867,6 +6113,8 @@ export declare namespace pool_u64_unbound {
         const TYPE_QNAME = "0x1::pool_u64_unbound::Pool";
         function type(): TypeDescriptor<Pool>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare class resource_account extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -4884,6 +6132,21 @@ export declare namespace resource_account {
         const TYPE_QNAME = "0x1::resource_account::Container";
         function type(): TypeDescriptor<Container>;
     }
+    namespace entry {
+        function createResourceAccount(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string, string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createResourceAccountAndFund(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string, string, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createResourceAccountAndPublishPackage(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string, string, string[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view { }
     interface CreateResourceAccountPayload extends TypedFunctionPayload<[string, string]> {
         arguments_decoded: [string, string];
         type_arguments: [];
@@ -5270,6 +6533,88 @@ export declare namespace staking_contract {
         data_decoded: UpdateVoterEvent;
         type_arguments: [];
     }
+    namespace entry {
+        function addStake(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createStakingContract(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [
+                MoveAddressType,
+                MoveAddressType,
+                bigint,
+                bigint,
+                string
+            ];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function distribute(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function requestCommission(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function resetLockup(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setBeneficiaryForOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function switchOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function switchOperatorWithSameCommission(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function unlockRewards(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function unlockStake(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateCommision(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateVoter(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view {
+        function beneficiaryForOperator(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function commissionPercentage(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function getExpectedStakePoolAddress(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType, string];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function lastRecordedPrincipal(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function pendingDistributionCounts(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function stakePoolAddress(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function stakingContractAmounts(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[bigint, bigint, bigint]>;
+        function stakingContractExists(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+    }
     interface AddStakePayload extends TypedFunctionPayload<[MoveAddressType, bigint]> {
         arguments_decoded: [MoveAddressType, bigint];
         type_arguments: [];
@@ -5331,7 +6676,10 @@ export declare namespace staking_contract {
         type_arguments: [];
     }
 }
-export declare namespace system_addresses { }
+export declare namespace system_addresses {
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace randomness_config {
     interface ConfigOff {
         dummy_field: boolean;
@@ -5364,6 +6712,8 @@ export declare namespace randomness_config {
         const TYPE_QNAME = "0x1::randomness_config::RandomnessConfig";
         function type(): TypeDescriptor<RandomnessConfig>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace table_with_length {
     interface TableWithLength<T0, T1> {
@@ -5374,6 +6724,8 @@ export declare namespace table_with_length {
         const TYPE_QNAME = "0x1::table_with_length::TableWithLength";
         function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<TableWithLength<T0, T1>>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace aggregator_factory {
     interface AggregatorFactory {
@@ -5383,6 +6735,8 @@ export declare namespace aggregator_factory {
         const TYPE_QNAME = "0x1::aggregator_factory::AggregatorFactory";
         function type(): TypeDescriptor<AggregatorFactory>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace governance_proposal {
     interface GovernanceProposal {
@@ -5392,6 +6746,8 @@ export declare namespace governance_proposal {
         const TYPE_QNAME = "0x1::governance_proposal::GovernanceProposal";
         function type(): TypeDescriptor<GovernanceProposal>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace optional_aggregator {
     interface Integer {
@@ -5410,6 +6766,8 @@ export declare namespace optional_aggregator {
         const TYPE_QNAME = "0x1::optional_aggregator::OptionalAggregator";
         function type(): TypeDescriptor<OptionalAggregator>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace transaction_context {
     interface AUID {
@@ -5438,6 +6796,8 @@ export declare namespace transaction_context {
         const TYPE_QNAME = "0x1::transaction_context::MultisigPayload";
         function type(): TypeDescriptor<MultisigPayload>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace jwk_consensus_config {
     interface ConfigOff {
@@ -5469,6 +6829,8 @@ export declare namespace jwk_consensus_config {
         const TYPE_QNAME = "0x1::jwk_consensus_config::OIDCProvider";
         function type(): TypeDescriptor<OIDCProvider>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace ristretto255_elgamal {
     interface Ciphertext {
@@ -5494,6 +6856,8 @@ export declare namespace ristretto255_elgamal {
         const TYPE_QNAME = "0x1::ristretto255_elgamal::CompressedPubkey";
         function type(): TypeDescriptor<CompressedPubkey>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace reconfiguration_state {
     interface State {
@@ -5517,6 +6881,8 @@ export declare namespace reconfiguration_state {
         const TYPE_QNAME = "0x1::reconfiguration_state::StateInactive";
         function type(): TypeDescriptor<StateInactive>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace ristretto255_pedersen {
     interface Commitment {
@@ -5526,6 +6892,8 @@ export declare namespace ristretto255_pedersen {
         const TYPE_QNAME = "0x1::ristretto255_pedersen::Commitment";
         function type(): TypeDescriptor<Commitment>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare class object_code_deployment extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -5579,6 +6947,25 @@ export declare namespace object_code_deployment {
         data_decoded: Upgrade;
         type_arguments: [];
     }
+    namespace entry {
+        function freezeCodeObject(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [object$.Object<code.PackageRegistry>];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function publish(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string, string[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function upgrade(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [
+                string,
+                string[],
+                object$.Object<code.PackageRegistry>
+            ];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view { }
     interface FreezeCodeObjectPayload extends TypedFunctionPayload<[object$.Object<code.PackageRegistry>]> {
         arguments_decoded: [object$.Object<code.PackageRegistry>];
         type_arguments: [];
@@ -5611,6 +6998,47 @@ export declare namespace primary_fungible_store {
         const TYPE_QNAME = "0x1::primary_fungible_store::DeriveRefPod";
         function type(): TypeDescriptor<DeriveRefPod>;
     }
+    namespace entry {
+        function transfer<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>, MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function transferAssertMinimumDeposit<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [
+                object$.Object<T0>,
+                MoveAddressType,
+                bigint,
+                bigint
+            ];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view {
+        function balance<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, object$.Object<T0>];
+        }, version?: bigint): Promise<[bigint]>;
+        function isBalanceAtLeast<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, object$.Object<T0>, bigint];
+        }, version?: bigint): Promise<[boolean]>;
+        function isFrozen<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, object$.Object<T0>];
+        }, version?: bigint): Promise<[boolean]>;
+        function primaryStore<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, object$.Object<T0>];
+        }, version?: bigint): Promise<[object$.Object<fungible_asset.FungibleStore>]>;
+        function primaryStoreAddress<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, object$.Object<T0>];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function primaryStoreExists<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, object$.Object<T0>];
+        }, version?: bigint): Promise<[boolean]>;
+    }
     interface TransferPayload<T0 = any> extends TypedFunctionPayload<[
         object$.Object<T0>,
         MoveAddressType,
@@ -5642,6 +7070,8 @@ export declare namespace transaction_validation {
         const TYPE_QNAME = "0x1::transaction_validation::TransactionValidation";
         function type(): TypeDescriptor<TransactionValidation>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace randomness_api_v0_config {
     interface AllowCustomMaxGasFlag {
@@ -5658,6 +7088,8 @@ export declare namespace randomness_api_v0_config {
         const TYPE_QNAME = "0x1::randomness_api_v0_config::RequiredGasDeposit";
         function type(): TypeDescriptor<RequiredGasDeposit>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace randomness_config_seqnum {
     interface RandomnessConfigSeqNum {
@@ -5667,8 +7099,13 @@ export declare namespace randomness_config_seqnum {
         const TYPE_QNAME = "0x1::randomness_config_seqnum::RandomnessConfigSeqNum";
         function type(): TypeDescriptor<RandomnessConfigSeqNum>;
     }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace reconfiguration_with_dkg {
+    namespace entry { }
+    namespace view { }
 }
-export declare namespace reconfiguration_with_dkg { }
 export declare namespace validator_consensus_info {
     interface ValidatorConsensusInfo {
         addr: MoveAddressType;
@@ -5679,6 +7116,8 @@ export declare namespace validator_consensus_info {
         const TYPE_QNAME = "0x1::validator_consensus_info::ValidatorConsensusInfo";
         function type(): TypeDescriptor<ValidatorConsensusInfo>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare namespace ristretto255_bulletproofs {
     interface RangeProof {
@@ -5688,6 +7127,8 @@ export declare namespace ristretto255_bulletproofs {
         const TYPE_QNAME = "0x1::ristretto255_bulletproofs::RangeProof";
         function type(): TypeDescriptor<RangeProof>;
     }
+    namespace entry { }
+    namespace view { }
 }
 export declare class dispatchable_fungible_asset extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -5704,6 +7145,31 @@ export declare namespace dispatchable_fungible_asset {
         const TYPE_QNAME = "0x1::dispatchable_fungible_asset::TransferRefStore";
         function type(): TypeDescriptor<TransferRefStore>;
     }
+    namespace entry {
+        function transfer<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>, object$.Object<T0>, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function transferAssertMinimumDeposit<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [
+                object$.Object<T0>,
+                object$.Object<T0>,
+                bigint,
+                bigint
+            ];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view {
+        function derivedBalance<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[bigint]>;
+        function derivedSupply<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[option.Option<bigint>]>;
+    }
     interface TransferPayload<T0 = any> extends TypedFunctionPayload<[
         object$.Object<T0>,
         object$.Object<T0>,