@typemove/aptos 1.0.0-rc.15 → 1.0.0-rc.16

package/dist/builtin/0x1.d.ts

@@ -1,7 +1,7 @@
 import { TypeDescriptor } from "@typemove/move";
 import { MoveCoder, TypedEventInstance } from "@typemove/aptos";
 import { Address } from "@typemove/aptos";
-import { AptosClient } from "aptos";
+import { AptosClient, AptosAccount, Types, OptionalTransactionArgs } from "aptos";
 export declare namespace acl {
     interface ACL {
         list: Address[];
@@ -10,6 +10,7 @@ export declare namespace acl {
         const TYPE_QNAME = "0x1::acl::ACL";
         function type(): TypeDescriptor<ACL>;
     }
+    namespace entry { }
     namespace view { }
 }
 export declare namespace any_ {
@@ -21,9 +22,11 @@ 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 code {
@@ -81,6 +84,12 @@ export declare namespace code {
         const TYPE_QNAME = "0x1::code::UpgradePolicy";
         function type(): TypeDescriptor<UpgradePolicy>;
     }
+    namespace entry {
+        function publishPackageTxn(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [string, string[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
     namespace view { }
 }
 export declare namespace coin {
@@ -168,6 +177,24 @@ export declare namespace coin {
         data_decoded: WithdrawEvent;
         type_arguments: [];
     }
+    namespace entry {
+        function freezeCoinStore<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function transfer<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function unfreezeCoinStore<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function upgradeSupply<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
     namespace view {
         function balance<T0 = any>(client: AptosClient, request: {
             type_arguments: [string];
@@ -215,12 +242,15 @@ 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 util {
+    namespace entry { }
     namespace view { }
 }
 export declare namespace block {
@@ -264,6 +294,7 @@ export declare namespace block {
         data_decoded: UpdateEpochIntervalEvent;
         type_arguments: [];
     }
+    namespace entry { }
     namespace view {
         function getCurrentBlockHeight(client: AptosClient, request: {
             type_arguments: [];
@@ -276,9 +307,11 @@ export declare namespace block {
     }
 }
 export declare namespace debug {
+    namespace entry { }
     namespace view { }
 }
 export declare namespace error {
+    namespace entry { }
     namespace view { }
 }
 export declare namespace event {
@@ -290,6 +323,7 @@ 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 namespace stake {
@@ -539,6 +573,60 @@ export declare namespace stake {
         data_decoded: WithdrawStakeEvent;
         type_arguments: [];
     }
+    namespace entry {
+        function addStake(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function increaseLockup(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function initializeStakeOwner(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint, Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function initializeValidator(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [string, string, string, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function joinValidatorSet(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function leaveValidatorSet(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function reactivateStake(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function rotateConsensusKey(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, string, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setDelegatedVoter(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setOperator(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function unlock(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function updateNetworkAndFullnodeAddresses(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, string, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function withdraw(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
     namespace view {
         function getCurrentEpochProposalCounts(client: AptosClient, request: {
             type_arguments: [];
@@ -601,9 +689,11 @@ 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 object_ {
@@ -688,6 +778,20 @@ export declare namespace object_ {
         const TYPE_QNAME = "0x1::object::TransferRef";
         function type(): TypeDescriptor<TransferRef>;
     }
+    namespace entry {
+        function transfer<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function transferCall(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function transferToObject<T0 = any, T1 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string, string];
+            arguments: [object_.Object<T0>, object_.Object<T1>];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
     namespace view { }
 }
 export declare namespace option {
@@ -698,9 +802,11 @@ export declare 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 string_ {
@@ -711,9 +817,11 @@ 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 voting {
@@ -808,6 +916,7 @@ 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: AptosClient, request: {
             type_arguments: [string];
@@ -965,6 +1074,40 @@ export declare namespace account {
         const TYPE_QNAME = "0x1::account::SignerCapabilityOfferProofChallengeV2";
         function type(): TypeDescriptor<SignerCapabilityOfferProofChallengeV2>;
     }
+    namespace entry {
+        function offerRotationCapability(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [string, number, string, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function offerSignerCapability(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [string, number, string, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function revokeAnyRotationCapability(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function revokeAnySignerCapability(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function revokeRotationCapability(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function revokeSignerCapability(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function rotateAuthenticationKey(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [number, string, number, string, string, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function rotateAuthenticationKeyWithRotationCapability(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, number, string, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
     namespace view {
         function existsAt(client: AptosClient, request: {
             type_arguments: [];
@@ -1022,6 +1165,7 @@ export declare namespace ed25519 {
         const TYPE_QNAME = "0x1::ed25519::ValidatedPublicKey";
         function type(): TypeDescriptor<ValidatedPublicKey>;
     }
+    namespace entry { }
     namespace view { }
 }
 export declare namespace genesis {
@@ -1067,9 +1211,11 @@ 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 version {
@@ -1087,6 +1233,12 @@ export declare namespace version {
         const TYPE_QNAME = "0x1::version::Version";
         function type(): TypeDescriptor<Version>;
     }
+    namespace entry {
+        function setVersion(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
     namespace view { }
 }
 export declare namespace vesting {
@@ -1294,6 +1446,72 @@ export declare namespace vesting {
         const TYPE_QNAME = "0x1::vesting::VestingSchedule";
         function type(): TypeDescriptor<VestingSchedule>;
     }
+    namespace entry {
+        function adminWithdraw(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function distribute(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function distributeMany(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function resetBeneficiary(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function resetLockup(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setBeneficiary(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setBeneficiaryResetter(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setManagementRole(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, string, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function terminateVestingContract(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function unlockRewards(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function unlockRewardsMany(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function updateOperator(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function updateOperatorWithSameCommission(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function updateVoter(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function vest(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function vestMany(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
     namespace view {
         function accumulatedRewards(client: AptosClient, request: {
             type_arguments: [];
@@ -1396,6 +1614,7 @@ export declare namespace bls12381 {
         const TYPE_QNAME = "0x1::bls12381::Signature";
         function type(): TypeDescriptor<Signature>;
     }
+    namespace entry { }
     namespace view { }
 }
 export declare namespace chain_id {
@@ -1406,6 +1625,7 @@ export declare namespace chain_id {
         const TYPE_QNAME = "0x1::chain_id::ChainId";
         function type(): TypeDescriptor<ChainId>;
     }
+    namespace entry { }
     namespace view {
         function get(client: AptosClient, request: {
             type_arguments: [];
@@ -1421,9 +1641,11 @@ export declare namespace features {
         const TYPE_QNAME = "0x1::features::Features";
         function type(): TypeDescriptor<Features>;
     }
+    namespace entry { }
     namespace view { }
 }
 export declare namespace from_bcs {
+    namespace entry { }
     namespace view { }
 }
 export declare namespace pool_u64 {
@@ -1439,6 +1661,7 @@ export declare namespace pool_u64 {
         const TYPE_QNAME = "0x1::pool_u64::Pool";
         function type(): TypeDescriptor<Pool>;
     }
+    namespace entry { }
     namespace view { }
 }
 export declare namespace secp256k1 {
@@ -1456,6 +1679,7 @@ export declare namespace secp256k1 {
         const TYPE_QNAME = "0x1::secp256k1::ECDSASignature";
         function type(): TypeDescriptor<ECDSASignature>;
     }
+    namespace entry { }
     namespace view { }
 }
 export declare namespace timestamp {
@@ -1466,6 +1690,7 @@ export declare namespace timestamp {
         const TYPE_QNAME = "0x1::timestamp::CurrentTimeMicroseconds";
         function type(): TypeDescriptor<CurrentTimeMicroseconds>;
     }
+    namespace entry { }
     namespace view {
         function nowMicroseconds(client: AptosClient, request: {
             type_arguments: [];
@@ -1487,6 +1712,7 @@ export declare namespace type_info {
         const TYPE_QNAME = "0x1::type_info::TypeInfo";
         function type(): TypeDescriptor<TypeInfo>;
     }
+    namespace entry { }
     namespace view { }
 }
 export declare namespace aggregator {
@@ -1499,6 +1725,7 @@ export declare namespace aggregator {
         const TYPE_QNAME = "0x1::aggregator::Aggregator";
         function type(): TypeDescriptor<Aggregator>;
     }
+    namespace entry { }
     namespace view { }
 }
 export declare namespace aptos_coin {
@@ -1530,9 +1757,24 @@ export declare namespace aptos_coin {
         const TYPE_QNAME = "0x1::aptos_coin::MintCapStore";
         function type(): TypeDescriptor<MintCapStore>;
     }
+    namespace entry {
+        function claimMintCapability(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function delegateMintCapability(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function mint(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
     namespace view { }
 }
 export declare namespace aptos_hash {
+    namespace entry { }
     namespace view { }
 }
 export declare namespace big_vector {
@@ -1545,6 +1787,7 @@ 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 {
@@ -1556,6 +1799,7 @@ export declare namespace bit_vector {
         const TYPE_QNAME = "0x1::bit_vector::BitVector";
         function type(): TypeDescriptor<BitVector>;
     }
+    namespace entry { }
     namespace view { }
 }
 export declare namespace capability {
@@ -1587,6 +1831,7 @@ 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 {
@@ -1597,9 +1842,11 @@ 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 simple_map {
@@ -1618,6 +1865,7 @@ 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 {
@@ -1642,6 +1890,7 @@ 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 {
@@ -1692,6 +1941,7 @@ 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 {
@@ -1702,6 +1952,7 @@ export declare namespace chain_status {
         const TYPE_QNAME = "0x1::chain_status::GenesisEndMarker";
         function type(): TypeDescriptor<GenesisEndMarker>;
     }
+    namespace entry { }
     namespace view {
         function isGenesis(client: AptosClient, request: {
             type_arguments: [];
@@ -1722,6 +1973,7 @@ 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 {
@@ -1748,6 +2000,7 @@ export declare namespace gas_schedule {
         const TYPE_QNAME = "0x1::gas_schedule::GasScheduleV2";
         function type(): TypeDescriptor<GasScheduleV2>;
     }
+    namespace entry { }
     namespace view { }
 }
 export declare namespace managed_coin {
@@ -1760,9 +2013,28 @@ 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: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function initialize<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [string, string, number, Boolean];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function mint<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function register<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
     namespace view { }
 }
 export declare namespace math_fixed64 {
+    namespace entry { }
     namespace view { }
 }
 export declare namespace ristretto255 {
@@ -1787,6 +2059,7 @@ export declare namespace ristretto255 {
         const TYPE_QNAME = "0x1::ristretto255::Scalar";
         function type(): TypeDescriptor<Scalar>;
     }
+    namespace entry { }
     namespace view { }
 }
 export declare namespace smart_vector {
@@ -1800,6 +2073,7 @@ 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 {
@@ -1826,6 +2100,7 @@ export declare namespace string_utils {
         const TYPE_QNAME = "0x1::string_utils::NIL";
         function type(): TypeDescriptor<NIL>;
     }
+    namespace entry { }
     namespace view { }
 }
 export declare namespace aptos_account {
@@ -1848,6 +2123,32 @@ export declare namespace aptos_account {
         const TYPE_QNAME = "0x1::aptos_account::DirectTransferConfig";
         function type(): TypeDescriptor<DirectTransferConfig>;
     }
+    namespace entry {
+        function batchTransfer(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address[], bigint[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function batchTransferCoins<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [Address[], bigint[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createAccount(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setAllowDirectCoinTransfers(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Boolean];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function transfer(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function transferCoins<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
     namespace view {
         function canReceiveDirectCoinTransfers(client: AptosClient, request: {
             type_arguments: [];
@@ -1856,6 +2157,7 @@ export declare namespace aptos_account {
     }
 }
 export declare namespace create_signer {
+    namespace entry { }
     namespace view { }
 }
 export declare namespace fixed_point32 {
@@ -1866,6 +2168,7 @@ 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 {
@@ -1876,6 +2179,7 @@ export declare namespace fixed_point64 {
         const TYPE_QNAME = "0x1::fixed_point64::FixedPoint64";
         function type(): TypeDescriptor<FixedPoint64>;
     }
+    namespace entry { }
     namespace view { }
 }
 export declare namespace multi_ed25519 {
@@ -1900,9 +2204,44 @@ export declare namespace multi_ed25519 {
         const TYPE_QNAME = "0x1::multi_ed25519::ValidatedPublicKey";
         function type(): TypeDescriptor<ValidatedPublicKey>;
     }
+    namespace entry { }
     namespace view { }
 }
 export declare namespace staking_proxy {
+    namespace entry {
+        function setOperator(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setStakePoolOperator(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setStakePoolVoter(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setStakingContractOperator(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setStakingContractVoter(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setVestingContractOperator(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setVestingContractVoter(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setVoter(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
     namespace view { }
 }
 export declare namespace state_storage {
@@ -1929,6 +2268,7 @@ 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 {
@@ -1939,6 +2279,7 @@ 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 namespace fungible_asset {
@@ -2041,6 +2382,12 @@ export declare namespace fungible_asset {
         data_decoded: WithdrawEvent;
         type_arguments: [];
     }
+    namespace entry {
+        function transfer<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>, object_.Object<T0>, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
     namespace view {
         function balance<T0 = any>(client: AptosClient, request: {
             type_arguments: [string];
@@ -2105,6 +2452,7 @@ export declare namespace staking_config {
         const TYPE_QNAME = "0x1::staking_config::StakingRewardsConfig";
         function type(): TypeDescriptor<StakingRewardsConfig>;
     }
+    namespace entry { }
     namespace view { }
 }
 export declare namespace delegation_pool {
@@ -2207,6 +2555,40 @@ export declare namespace delegation_pool {
         data_decoded: WithdrawStakeEvent;
         type_arguments: [];
     }
+    namespace entry {
+        function addStake(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function initializeDelegationPool(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function reactivateStake(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setDelegatedVoter(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setOperator(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function synchronizeDelegationPool(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function unlock(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function withdraw(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
     namespace view {
         function canWithdrawPendingInactive(client: AptosClient, request: {
             type_arguments: [];
@@ -2282,6 +2664,7 @@ export declare namespace reconfiguration {
         data_decoded: NewEpochEvent;
         type_arguments: [];
     }
+    namespace entry { }
     namespace view { }
 }
 export declare namespace transaction_fee {
@@ -2301,6 +2684,7 @@ export declare namespace transaction_fee {
         const TYPE_QNAME = "0x1::transaction_fee::CollectedFeesPerBlock";
         function type(): TypeDescriptor<CollectedFeesPerBlock>;
     }
+    namespace entry { }
     namespace view { }
 }
 export declare namespace aptos_governance {
@@ -2394,6 +2778,24 @@ export declare namespace aptos_governance {
         const TYPE_QNAME = "0x1::aptos_governance::VotingRecords";
         function type(): TypeDescriptor<VotingRecords>;
     }
+    namespace entry {
+        function addApprovedScriptHashScript(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createProposal(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, string, string, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createProposalV2(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, string, string, string, Boolean];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function vote(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint, Boolean];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
     namespace view {
         function getMinVotingThreshold(client: AptosClient, request: {
             type_arguments: [];
@@ -2515,6 +2917,7 @@ 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 {
@@ -2525,6 +2928,7 @@ 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 {
@@ -2535,6 +2939,7 @@ export declare namespace execution_config {
         const TYPE_QNAME = "0x1::execution_config::ExecutionConfig";
         function type(): TypeDescriptor<ExecutionConfig>;
     }
+    namespace entry { }
     namespace view { }
 }
 export declare namespace multisig_account {
@@ -2705,6 +3110,77 @@ export declare namespace multisig_account {
         data_decoded: VoteEvent;
         type_arguments: [];
     }
+    namespace entry {
+        function addOwner(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function addOwners(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function approveTransaction(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function create(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint, string[], string[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createTransaction(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createTransactionWithHash(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createWithExistingAccount(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [
+                Address,
+                Address[],
+                bigint,
+                number,
+                string,
+                string,
+                string[],
+                string[]
+            ];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createWithOwners(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address[], bigint, string[], string[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function executeRejectedTransaction(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function rejectTransaction(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function removeOwner(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function removeOwners(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function updateMetadata(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [string[], string[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function updateSignaturesRequired(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function voteTransanction(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint, Boolean];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
     namespace view {
         function canBeExecuted(client: AptosClient, request: {
             type_arguments: [];
@@ -2767,6 +3243,7 @@ export declare namespace pool_u64_unbound {
         const TYPE_QNAME = "0x1::pool_u64_unbound::Pool";
         function type(): TypeDescriptor<Pool>;
     }
+    namespace entry { }
     namespace view { }
 }
 export declare namespace resource_account {
@@ -2777,6 +3254,20 @@ export declare namespace resource_account {
         const TYPE_QNAME = "0x1::resource_account::Container";
         function type(): TypeDescriptor<Container>;
     }
+    namespace entry {
+        function createResourceAccount(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [string, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createResourceAccountAndFund(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [string, string, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createResourceAccountAndPublishPackage(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [string, string, string[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
     namespace view { }
 }
 export declare namespace staking_contract {
@@ -2958,6 +3449,52 @@ export declare namespace staking_contract {
         data_decoded: UpdateVoterEvent;
         type_arguments: [];
     }
+    namespace entry {
+        function addStake(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createStakingContract(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address, bigint, bigint, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function distribute(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function requestCommission(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function resetLockup(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function switchOperator(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function switchOperatorWithSameCommission(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function unlockRewards(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function unlockStake(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function updateCommision(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function updateVoter(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
     namespace view {
         function commissionPercentage(client: AptosClient, request: {
             type_arguments: [];
@@ -2986,6 +3523,7 @@ export declare namespace staking_contract {
     }
 }
 export declare namespace system_addresses {
+    namespace entry { }
     namespace view { }
 }
 export declare namespace table_with_length {
@@ -2997,6 +3535,7 @@ 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 {
@@ -3007,6 +3546,7 @@ 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 {
@@ -3017,6 +3557,7 @@ 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 {
@@ -3036,9 +3577,11 @@ 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 {
+    namespace entry { }
     namespace view { }
 }
 export declare namespace primary_fungible_store {
@@ -3049,6 +3592,12 @@ 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: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>, Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
     namespace view {
         function balance<T0 = any>(client: AptosClient, request: {
             type_arguments: [string];
@@ -3085,6 +3634,7 @@ export declare namespace transaction_validation {
         const TYPE_QNAME = "0x1::transaction_validation::TransactionValidation";
         function type(): TypeDescriptor<TransactionValidation>;
     }
+    namespace entry { }
     namespace view { }
 }
 export declare function loadAllTypes(coder: MoveCoder): void;