@typemove/aptos 1.8.2 → 1.8.3-rc.1

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

@@ -71,6 +71,10 @@ export declare namespace dkg {
     namespace entry { }
     namespace view { }
 }
+export declare namespace mem {
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace code {
     interface AllowedDep {
         account: MoveAddressType;
@@ -147,6 +151,44 @@ export declare namespace code {
     namespace view { }
 }
 export declare namespace coin {
+    interface Deposit<T0> {
+        account: MoveAddressType;
+        amount: bigint;
+    }
+    namespace Deposit {
+        const TYPE_QNAME = "0x1::coin::Deposit";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Deposit<T0>>;
+    }
+    interface DepositEvent {
+        amount: bigint;
+    }
+    namespace DepositEvent {
+        const TYPE_QNAME = "0x1::coin::DepositEvent";
+        function type(): TypeDescriptor<DepositEvent>;
+    }
+    interface DepositEventInstance extends TypedEventInstance<DepositEvent> {
+        data_decoded: DepositEvent;
+        type_arguments: [];
+    }
+    interface Withdraw<T0> {
+        account: MoveAddressType;
+        amount: bigint;
+    }
+    namespace Withdraw {
+        const TYPE_QNAME = "0x1::coin::Withdraw";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Withdraw<T0>>;
+    }
+    interface WithdrawEvent {
+        amount: bigint;
+    }
+    namespace WithdrawEvent {
+        const TYPE_QNAME = "0x1::coin::WithdrawEvent";
+        function type(): TypeDescriptor<WithdrawEvent>;
+    }
+    interface WithdrawEventInstance extends TypedEventInstance<WithdrawEvent> {
+        data_decoded: WithdrawEvent;
+        type_arguments: [];
+    }
     interface AggregatableCoin<T0> {
         value: aggregator.Aggregator;
     }
@@ -241,25 +283,6 @@ export declare namespace coin {
         data_decoded: CoinWithdraw;
         type_arguments: [];
     }
-    interface Deposit<T0> {
-        account: MoveAddressType;
-        amount: bigint;
-    }
-    namespace Deposit {
-        const TYPE_QNAME = "0x1::coin::Deposit";
-        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Deposit<T0>>;
-    }
-    interface DepositEvent {
-        amount: bigint;
-    }
-    namespace DepositEvent {
-        const TYPE_QNAME = "0x1::coin::DepositEvent";
-        function type(): TypeDescriptor<DepositEvent>;
-    }
-    interface DepositEventInstance extends TypedEventInstance<DepositEvent> {
-        data_decoded: DepositEvent;
-        type_arguments: [];
-    }
     interface FreezeCapability<T0> {
         dummy_field: boolean;
     }
@@ -330,26 +353,11 @@ export declare namespace coin {
         const TYPE_QNAME = "0x1::coin::TransferRefReceipt";
         function type(): TypeDescriptor<TransferRefReceipt>;
     }
-    interface Withdraw<T0> {
-        account: MoveAddressType;
-        amount: bigint;
-    }
-    namespace Withdraw {
-        const TYPE_QNAME = "0x1::coin::Withdraw";
-        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Withdraw<T0>>;
-    }
-    interface WithdrawEvent {
-        amount: bigint;
-    }
-    namespace WithdrawEvent {
-        const TYPE_QNAME = "0x1::coin::WithdrawEvent";
-        function type(): TypeDescriptor<WithdrawEvent>;
-    }
-    interface WithdrawEventInstance extends TypedEventInstance<WithdrawEvent> {
-        data_decoded: WithdrawEvent;
-        type_arguments: [];
-    }
     namespace entry {
+        function transfer<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function createCoinConversionMap(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [];
@@ -362,13 +370,13 @@ export declare namespace coin {
             typeArguments: [MoveStructId];
             functionArguments: [MoveAddressType, MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function migrateToFungibleStore<T0 = any>(client: Aptos, account: AptosAccount, request: {
+        function migrateCoinStoreToFungibleStore<T0 = any>(client: Aptos, account: AptosAccount, request: {
             typeArguments: [MoveStructId];
-            functionArguments: [];
+            functionArguments: [MoveAddressType[]];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function transfer<T0 = any>(client: Aptos, account: AptosAccount, request: {
+        function migrateToFungibleStore<T0 = any>(client: Aptos, account: AptosAccount, request: {
             typeArguments: [MoveStructId];
-            functionArguments: [MoveAddressType, bigint];
+            functionArguments: [];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function unfreezeCoinStore<T0 = any>(client: Aptos, account: AptosAccount, request: {
             typeArguments: [MoveStructId];
@@ -380,24 +388,33 @@ export declare namespace coin {
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
-        function balance<T0 = any>(client: Aptos, request: {
+        function name<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
-            functionArguments: [MoveAddressType];
-        }, version?: bigint): Promise<[bigint]>;
-        function coinSupply<T0 = any>(client: Aptos, request: {
+        }, version?: bigint): Promise<[string]>;
+        function symbol$<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
-        }, version?: bigint): Promise<[option.Option<bigint>]>;
+        }, version?: bigint): Promise<[string]>;
         function decimals<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
         }, version?: bigint): Promise<[number]>;
-        function isAccountRegistered<T0 = any>(client: Aptos, request: {
+        function balance<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
             functionArguments: [MoveAddressType];
-        }, version?: bigint): Promise<[boolean]>;
+        }, version?: bigint): Promise<[bigint]>;
         function isBalanceAtLeast<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
             functionArguments: [MoveAddressType, bigint];
         }, version?: bigint): Promise<[boolean]>;
+        function supply<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+        }, version?: bigint): Promise<[option.Option<bigint>]>;
+        function coinSupply<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+        }, version?: bigint): Promise<[option.Option<bigint>]>;
+        function isAccountRegistered<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
         function isCoinInitialized<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
         }, version?: bigint): Promise<[boolean]>;
@@ -405,9 +422,6 @@ export declare namespace coin {
             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]>;
@@ -423,12 +437,6 @@ export declare namespace coin {
         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]>;
     }
 }
 export declare namespace guid {
@@ -1102,6 +1110,10 @@ export declare namespace stake {
         type_arguments: [];
     }
     namespace entry {
+        function withdraw(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function addStake(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [bigint];
@@ -1150,10 +1162,6 @@ export declare namespace stake {
             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: {
@@ -1751,6 +1759,10 @@ export declare namespace account {
             typeArguments: [];
             functionArguments: [MoveAddressType, number, string, string];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setOriginatingAddress(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
         function existsAt(client: Aptos, request: {
@@ -1777,6 +1789,9 @@ export declare namespace account {
         function isSignerCapabilityOffered(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[boolean]>;
+        function originatingAddress(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[option.Option<MoveAddressType>]>;
     }
 }
 export declare namespace ed25519 {
@@ -1890,6 +1905,90 @@ export declare namespace version {
     namespace view { }
 }
 export declare namespace vesting {
+    interface Distribute {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        amount: bigint;
+    }
+    namespace Distribute {
+        const TYPE_QNAME = "0x1::vesting::Distribute";
+        function type(): TypeDescriptor<Distribute>;
+    }
+    interface DistributeInstance extends TypedEventInstance<Distribute> {
+        data_decoded: Distribute;
+        type_arguments: [];
+    }
+    interface DistributeEvent {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        amount: bigint;
+    }
+    namespace DistributeEvent {
+        const TYPE_QNAME = "0x1::vesting::DistributeEvent";
+        function type(): TypeDescriptor<DistributeEvent>;
+    }
+    interface DistributeEventInstance extends TypedEventInstance<DistributeEvent> {
+        data_decoded: DistributeEvent;
+        type_arguments: [];
+    }
+    interface ResetLockup {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
+        new_lockup_expiration_secs: bigint;
+    }
+    namespace ResetLockup {
+        const TYPE_QNAME = "0x1::vesting::ResetLockup";
+        function type(): TypeDescriptor<ResetLockup>;
+    }
+    interface ResetLockupInstance extends TypedEventInstance<ResetLockup> {
+        data_decoded: ResetLockup;
+        type_arguments: [];
+    }
+    interface ResetLockupEvent {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
+        new_lockup_expiration_secs: bigint;
+    }
+    namespace ResetLockupEvent {
+        const TYPE_QNAME = "0x1::vesting::ResetLockupEvent";
+        function type(): TypeDescriptor<ResetLockupEvent>;
+    }
+    interface ResetLockupEventInstance extends TypedEventInstance<ResetLockupEvent> {
+        data_decoded: ResetLockupEvent;
+        type_arguments: [];
+    }
+    interface UpdateVoter {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
+        old_voter: MoveAddressType;
+        new_voter: MoveAddressType;
+    }
+    namespace UpdateVoter {
+        const TYPE_QNAME = "0x1::vesting::UpdateVoter";
+        function type(): TypeDescriptor<UpdateVoter>;
+    }
+    interface UpdateVoterInstance extends TypedEventInstance<UpdateVoter> {
+        data_decoded: UpdateVoter;
+        type_arguments: [];
+    }
+    interface UpdateVoterEvent {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
+        old_voter: MoveAddressType;
+        new_voter: MoveAddressType;
+    }
+    namespace UpdateVoterEvent {
+        const TYPE_QNAME = "0x1::vesting::UpdateVoterEvent";
+        function type(): TypeDescriptor<UpdateVoterEvent>;
+    }
+    interface UpdateVoterEventInstance extends TypedEventInstance<UpdateVoterEvent> {
+        data_decoded: UpdateVoterEvent;
+        type_arguments: [];
+    }
     interface AdminStore {
         vesting_contracts: MoveAddressType[];
         nonce: bigint;
@@ -1959,88 +2058,34 @@ export declare namespace vesting {
         data_decoded: CreateVestingContractEvent;
         type_arguments: [];
     }
-    interface Distribute {
+    interface SetBeneficiary {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
-        amount: bigint;
+        shareholder: MoveAddressType;
+        old_beneficiary: MoveAddressType;
+        new_beneficiary: MoveAddressType;
     }
-    namespace Distribute {
-        const TYPE_QNAME = "0x1::vesting::Distribute";
-        function type(): TypeDescriptor<Distribute>;
+    namespace SetBeneficiary {
+        const TYPE_QNAME = "0x1::vesting::SetBeneficiary";
+        function type(): TypeDescriptor<SetBeneficiary>;
     }
-    interface DistributeInstance extends TypedEventInstance<Distribute> {
-        data_decoded: Distribute;
+    interface SetBeneficiaryInstance extends TypedEventInstance<SetBeneficiary> {
+        data_decoded: SetBeneficiary;
         type_arguments: [];
     }
-    interface DistributeEvent {
+    interface SetBeneficiaryEvent {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
-        amount: bigint;
+        shareholder: MoveAddressType;
+        old_beneficiary: MoveAddressType;
+        new_beneficiary: MoveAddressType;
     }
-    namespace DistributeEvent {
-        const TYPE_QNAME = "0x1::vesting::DistributeEvent";
-        function type(): TypeDescriptor<DistributeEvent>;
+    namespace SetBeneficiaryEvent {
+        const TYPE_QNAME = "0x1::vesting::SetBeneficiaryEvent";
+        function type(): TypeDescriptor<SetBeneficiaryEvent>;
     }
-    interface DistributeEventInstance extends TypedEventInstance<DistributeEvent> {
-        data_decoded: DistributeEvent;
-        type_arguments: [];
-    }
-    interface ResetLockup {
-        admin: MoveAddressType;
-        vesting_contract_address: MoveAddressType;
-        staking_pool_address: MoveAddressType;
-        new_lockup_expiration_secs: bigint;
-    }
-    namespace ResetLockup {
-        const TYPE_QNAME = "0x1::vesting::ResetLockup";
-        function type(): TypeDescriptor<ResetLockup>;
-    }
-    interface ResetLockupInstance extends TypedEventInstance<ResetLockup> {
-        data_decoded: ResetLockup;
-        type_arguments: [];
-    }
-    interface ResetLockupEvent {
-        admin: MoveAddressType;
-        vesting_contract_address: MoveAddressType;
-        staking_pool_address: MoveAddressType;
-        new_lockup_expiration_secs: bigint;
-    }
-    namespace ResetLockupEvent {
-        const TYPE_QNAME = "0x1::vesting::ResetLockupEvent";
-        function type(): TypeDescriptor<ResetLockupEvent>;
-    }
-    interface ResetLockupEventInstance extends TypedEventInstance<ResetLockupEvent> {
-        data_decoded: ResetLockupEvent;
-        type_arguments: [];
-    }
-    interface SetBeneficiary {
-        admin: MoveAddressType;
-        vesting_contract_address: MoveAddressType;
-        shareholder: MoveAddressType;
-        old_beneficiary: MoveAddressType;
-        new_beneficiary: MoveAddressType;
-    }
-    namespace SetBeneficiary {
-        const TYPE_QNAME = "0x1::vesting::SetBeneficiary";
-        function type(): TypeDescriptor<SetBeneficiary>;
-    }
-    interface SetBeneficiaryInstance extends TypedEventInstance<SetBeneficiary> {
-        data_decoded: SetBeneficiary;
-        type_arguments: [];
-    }
-    interface SetBeneficiaryEvent {
-        admin: MoveAddressType;
-        vesting_contract_address: MoveAddressType;
-        shareholder: MoveAddressType;
-        old_beneficiary: MoveAddressType;
-        new_beneficiary: MoveAddressType;
-    }
-    namespace SetBeneficiaryEvent {
-        const TYPE_QNAME = "0x1::vesting::SetBeneficiaryEvent";
-        function type(): TypeDescriptor<SetBeneficiaryEvent>;
-    }
-    interface SetBeneficiaryEventInstance extends TypedEventInstance<SetBeneficiaryEvent> {
-        data_decoded: SetBeneficiaryEvent;
+    interface SetBeneficiaryEventInstance extends TypedEventInstance<SetBeneficiaryEvent> {
+        data_decoded: SetBeneficiaryEvent;
         type_arguments: [];
     }
     interface StakingInfo {
@@ -2137,36 +2182,6 @@ export declare namespace vesting {
         data_decoded: UpdateOperatorEvent;
         type_arguments: [];
     }
-    interface UpdateVoter {
-        admin: MoveAddressType;
-        vesting_contract_address: MoveAddressType;
-        staking_pool_address: MoveAddressType;
-        old_voter: MoveAddressType;
-        new_voter: MoveAddressType;
-    }
-    namespace UpdateVoter {
-        const TYPE_QNAME = "0x1::vesting::UpdateVoter";
-        function type(): TypeDescriptor<UpdateVoter>;
-    }
-    interface UpdateVoterInstance extends TypedEventInstance<UpdateVoter> {
-        data_decoded: UpdateVoter;
-        type_arguments: [];
-    }
-    interface UpdateVoterEvent {
-        admin: MoveAddressType;
-        vesting_contract_address: MoveAddressType;
-        staking_pool_address: MoveAddressType;
-        old_voter: MoveAddressType;
-        new_voter: MoveAddressType;
-    }
-    namespace UpdateVoterEvent {
-        const TYPE_QNAME = "0x1::vesting::UpdateVoterEvent";
-        function type(): TypeDescriptor<UpdateVoterEvent>;
-    }
-    interface UpdateVoterEventInstance extends TypedEventInstance<UpdateVoterEvent> {
-        data_decoded: UpdateVoterEvent;
-        type_arguments: [];
-    }
     interface Vest {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
@@ -2239,33 +2254,45 @@ export declare namespace vesting {
         function type(): TypeDescriptor<VestingSchedule>;
     }
     namespace entry {
-        function adminWithdraw(client: Aptos, account: AptosAccount, request: {
+        function setBeneficiaryForOperator(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 distribute(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function distributeMany(client: Aptos, account: AptosAccount, request: {
+        function resetLockup(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
-            functionArguments: [MoveAddressType[]];
+            functionArguments: [MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function resetBeneficiary(client: Aptos, account: AptosAccount, request: {
+        function unlockRewards(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function updateVoter(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType, MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function resetLockup(client: Aptos, account: AptosAccount, request: {
+        function adminWithdraw(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function setBeneficiary(client: Aptos, account: AptosAccount, request: {
+        function distributeMany(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
-            functionArguments: [MoveAddressType, MoveAddressType, MoveAddressType];
+            functionArguments: [MoveAddressType[]];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function setBeneficiaryForOperator(client: Aptos, account: AptosAccount, request: {
+        function resetBeneficiary(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
-            functionArguments: [MoveAddressType];
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setBeneficiary(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, MoveAddressType, MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function setBeneficiaryResetter(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
@@ -2279,18 +2306,10 @@ export declare namespace vesting {
             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];
@@ -2299,10 +2318,6 @@ export declare namespace vesting {
             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];
@@ -2313,25 +2328,19 @@ export declare namespace vesting {
         }, 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: {
+        function voter(client: Aptos, request: {
             functionArguments: [MoveAddressType];
-        }, version?: bigint): Promise<[bigint]>;
-        function remainingGrant(client: Aptos, request: {
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function shareholder(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function operatorCommissionPercentage(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
-        function shareholder(client: Aptos, request: {
+        function beneficiary(client: Aptos, request: {
             functionArguments: [MoveAddressType, MoveAddressType];
         }, version?: bigint): Promise<[MoveAddressType]>;
         function shareholders(client: Aptos, request: {
@@ -2340,21 +2349,27 @@ export declare namespace vesting {
         function stakePoolAddress(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[MoveAddressType]>;
+        function accumulatedRewards(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function vestingSchedule(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[vesting.VestingSchedule]>;
+        function periodDurationSecs(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function remainingGrant(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
         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]>;
     }
 }
 export declare namespace bls12381 {
@@ -2546,6 +2561,10 @@ export declare namespace aptos_coin {
         function type(): TypeDescriptor<MintCapStore>;
     }
     namespace entry {
+        function mint(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function claimMintCapability(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [];
@@ -2554,10 +2573,6 @@ export declare namespace aptos_coin {
             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 { }
 }
@@ -2820,18 +2835,14 @@ export declare namespace managed_coin {
         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 burn<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function mint<T0 = any>(client: Aptos, account: AptosAccount, request: {
             typeArguments: [MoveStructId];
             functionArguments: [MoveAddressType, bigint];
@@ -2840,6 +2851,10 @@ export declare namespace managed_coin {
             typeArguments: [MoveStructId];
             functionArguments: [];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function destroyCaps<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view { }
 }
@@ -2973,6 +2988,14 @@ export declare namespace aptos_account {
         function type(): TypeDescriptor<DirectTransferConfig>;
     }
     namespace entry {
+        function createAccount(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function transfer(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function batchTransfer(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType[], bigint[]];
@@ -2989,10 +3012,6 @@ export declare namespace aptos_account {
                 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];
@@ -3001,10 +3020,6 @@ export declare namespace aptos_account {
             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];
@@ -3032,20 +3047,6 @@ export declare namespace bn254_algebra {
         const TYPE_QNAME = "0x1::bn254_algebra::FormatFq12LscLsb";
         function type(): TypeDescriptor<FormatFq12LscLsb>;
     }
-    interface FormatFqLsb {
-        dummy_field: boolean;
-    }
-    namespace FormatFqLsb {
-        const TYPE_QNAME = "0x1::bn254_algebra::FormatFqLsb";
-        function type(): TypeDescriptor<FormatFqLsb>;
-    }
-    interface FormatFqMsb {
-        dummy_field: boolean;
-    }
-    namespace FormatFqMsb {
-        const TYPE_QNAME = "0x1::bn254_algebra::FormatFqMsb";
-        function type(): TypeDescriptor<FormatFqMsb>;
-    }
     interface FormatFrLsb {
         dummy_field: boolean;
     }
@@ -3095,13 +3096,6 @@ export declare namespace bn254_algebra {
         const TYPE_QNAME = "0x1::bn254_algebra::FormatGt";
         function type(): TypeDescriptor<FormatGt>;
     }
-    interface Fq {
-        dummy_field: boolean;
-    }
-    namespace Fq {
-        const TYPE_QNAME = "0x1::bn254_algebra::Fq";
-        function type(): TypeDescriptor<Fq>;
-    }
     interface Fq12 {
         dummy_field: boolean;
     }
@@ -3137,6 +3131,27 @@ export declare namespace bn254_algebra {
         const TYPE_QNAME = "0x1::bn254_algebra::Gt";
         function type(): TypeDescriptor<Gt>;
     }
+    interface FormatFqLsb {
+        dummy_field: boolean;
+    }
+    namespace FormatFqLsb {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatFqLsb";
+        function type(): TypeDescriptor<FormatFqLsb>;
+    }
+    interface FormatFqMsb {
+        dummy_field: boolean;
+    }
+    namespace FormatFqMsb {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatFqMsb";
+        function type(): TypeDescriptor<FormatFqMsb>;
+    }
+    interface Fq {
+        dummy_field: boolean;
+    }
+    namespace Fq {
+        const TYPE_QNAME = "0x1::bn254_algebra::Fq";
+        function type(): TypeDescriptor<Fq>;
+    }
     namespace entry { }
     namespace view { }
 }
@@ -3291,15 +3306,29 @@ export declare namespace crypto_algebra {
     namespace view { }
 }
 export declare namespace fungible_asset {
-    interface BurnRef {
+    interface TransferRef {
         metadata: object$.Object<fungible_asset.Metadata>;
     }
-    namespace BurnRef {
-        const TYPE_QNAME = "0x1::fungible_asset::BurnRef";
-        function type(): TypeDescriptor<BurnRef>;
+    namespace TransferRef {
+        const TYPE_QNAME = "0x1::fungible_asset::TransferRef";
+        function type(): TypeDescriptor<TransferRef>;
     }
-    interface ConcurrentFungibleBalance {
-        balance: aggregator_v2.Aggregator<bigint>;
+    interface Untransferable {
+        dummy_field: boolean;
+    }
+    namespace Untransferable {
+        const TYPE_QNAME = "0x1::fungible_asset::Untransferable";
+        function type(): TypeDescriptor<Untransferable>;
+    }
+    interface BurnRef {
+        metadata: object$.Object<fungible_asset.Metadata>;
+    }
+    namespace BurnRef {
+        const TYPE_QNAME = "0x1::fungible_asset::BurnRef";
+        function type(): TypeDescriptor<BurnRef>;
+    }
+    interface ConcurrentFungibleBalance {
+        balance: aggregator_v2.Aggregator<bigint>;
     }
     namespace ConcurrentFungibleBalance {
         const TYPE_QNAME = "0x1::fungible_asset::ConcurrentFungibleBalance";
@@ -3433,20 +3462,6 @@ export declare namespace fungible_asset {
         const TYPE_QNAME = "0x1::fungible_asset::Supply";
         function type(): TypeDescriptor<Supply>;
     }
-    interface TransferRef {
-        metadata: object$.Object<fungible_asset.Metadata>;
-    }
-    namespace TransferRef {
-        const TYPE_QNAME = "0x1::fungible_asset::TransferRef";
-        function type(): TypeDescriptor<TransferRef>;
-    }
-    interface Untransferable {
-        dummy_field: boolean;
-    }
-    namespace Untransferable {
-        const TYPE_QNAME = "0x1::fungible_asset::Untransferable";
-        function type(): TypeDescriptor<Untransferable>;
-    }
     interface Withdraw {
         store: MoveAddressType;
         amount: bigint;
@@ -3481,10 +3496,18 @@ export declare namespace fungible_asset {
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
-        function balance<T0 = any>(client: Aptos, request: {
+        function isUntransferable<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
             functionArguments: [object$.Object<T0>];
-        }, version?: bigint): Promise<[bigint]>;
+        }, version?: bigint): Promise<[boolean]>;
+        function name<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[string]>;
+        function symbol$<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[string]>;
         function decimals<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
             functionArguments: [object$.Object<T0>];
@@ -3493,6 +3516,18 @@ export declare namespace fungible_asset {
             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 balance<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[bigint]>;
+        function metadata<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object$.Object<T0>];
+        }, version?: bigint): Promise<[fungible_asset.Metadata]>;
         function isBalanceAtLeast<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
             functionArguments: [object$.Object<T0>, bigint];
@@ -3505,26 +3540,10 @@ export declare namespace fungible_asset {
             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]>;
@@ -3536,10 +3555,6 @@ export declare namespace fungible_asset {
             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]>;
     }
 }
 export declare namespace staking_config {
@@ -3573,6 +3588,62 @@ export declare namespace staking_config {
     }
 }
 export declare namespace delegation_pool {
+    interface CreateProposal {
+        proposal_id: bigint;
+        voter: MoveAddressType;
+        delegation_pool: MoveAddressType;
+    }
+    namespace CreateProposal {
+        const TYPE_QNAME = "0x1::delegation_pool::CreateProposal";
+        function type(): TypeDescriptor<CreateProposal>;
+    }
+    interface CreateProposalInstance extends TypedEventInstance<CreateProposal> {
+        data_decoded: CreateProposal;
+        type_arguments: [];
+    }
+    interface CreateProposalEvent {
+        proposal_id: bigint;
+        voter: MoveAddressType;
+        delegation_pool: MoveAddressType;
+    }
+    namespace CreateProposalEvent {
+        const TYPE_QNAME = "0x1::delegation_pool::CreateProposalEvent";
+        function type(): TypeDescriptor<CreateProposalEvent>;
+    }
+    interface CreateProposalEventInstance extends TypedEventInstance<CreateProposalEvent> {
+        data_decoded: CreateProposalEvent;
+        type_arguments: [];
+    }
+    interface Vote {
+        voter: MoveAddressType;
+        proposal_id: bigint;
+        delegation_pool: MoveAddressType;
+        num_votes: bigint;
+        should_pass: boolean;
+    }
+    namespace Vote {
+        const TYPE_QNAME = "0x1::delegation_pool::Vote";
+        function type(): TypeDescriptor<Vote>;
+    }
+    interface VoteInstance extends TypedEventInstance<Vote> {
+        data_decoded: Vote;
+        type_arguments: [];
+    }
+    interface VoteEvent {
+        voter: MoveAddressType;
+        proposal_id: bigint;
+        delegation_pool: MoveAddressType;
+        num_votes: bigint;
+        should_pass: boolean;
+    }
+    namespace VoteEvent {
+        const TYPE_QNAME = "0x1::delegation_pool::VoteEvent";
+        function type(): TypeDescriptor<VoteEvent>;
+    }
+    interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
+        data_decoded: VoteEvent;
+        type_arguments: [];
+    }
     interface AddStake {
         pool_address: MoveAddressType;
         delegator_address: MoveAddressType;
@@ -3601,6 +3672,84 @@ export declare namespace delegation_pool {
         data_decoded: AddStakeEvent;
         type_arguments: [];
     }
+    interface ReactivateStake {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+        amount_reactivated: bigint;
+    }
+    namespace ReactivateStake {
+        const TYPE_QNAME = "0x1::delegation_pool::ReactivateStake";
+        function type(): TypeDescriptor<ReactivateStake>;
+    }
+    interface ReactivateStakeInstance extends TypedEventInstance<ReactivateStake> {
+        data_decoded: ReactivateStake;
+        type_arguments: [];
+    }
+    interface ReactivateStakeEvent {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+        amount_reactivated: bigint;
+    }
+    namespace ReactivateStakeEvent {
+        const TYPE_QNAME = "0x1::delegation_pool::ReactivateStakeEvent";
+        function type(): TypeDescriptor<ReactivateStakeEvent>;
+    }
+    interface ReactivateStakeEventInstance extends TypedEventInstance<ReactivateStakeEvent> {
+        data_decoded: ReactivateStakeEvent;
+        type_arguments: [];
+    }
+    interface UnlockStake {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+        amount_unlocked: bigint;
+    }
+    namespace UnlockStake {
+        const TYPE_QNAME = "0x1::delegation_pool::UnlockStake";
+        function type(): TypeDescriptor<UnlockStake>;
+    }
+    interface UnlockStakeInstance extends TypedEventInstance<UnlockStake> {
+        data_decoded: UnlockStake;
+        type_arguments: [];
+    }
+    interface UnlockStakeEvent {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+        amount_unlocked: bigint;
+    }
+    namespace UnlockStakeEvent {
+        const TYPE_QNAME = "0x1::delegation_pool::UnlockStakeEvent";
+        function type(): TypeDescriptor<UnlockStakeEvent>;
+    }
+    interface UnlockStakeEventInstance extends TypedEventInstance<UnlockStakeEvent> {
+        data_decoded: UnlockStakeEvent;
+        type_arguments: [];
+    }
+    interface WithdrawStake {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+        amount_withdrawn: bigint;
+    }
+    namespace WithdrawStake {
+        const TYPE_QNAME = "0x1::delegation_pool::WithdrawStake";
+        function type(): TypeDescriptor<WithdrawStake>;
+    }
+    interface WithdrawStakeInstance extends TypedEventInstance<WithdrawStake> {
+        data_decoded: WithdrawStake;
+        type_arguments: [];
+    }
+    interface WithdrawStakeEvent {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+        amount_withdrawn: bigint;
+    }
+    namespace WithdrawStakeEvent {
+        const TYPE_QNAME = "0x1::delegation_pool::WithdrawStakeEvent";
+        function type(): TypeDescriptor<WithdrawStakeEvent>;
+    }
+    interface WithdrawStakeEventInstance extends TypedEventInstance<WithdrawStakeEvent> {
+        data_decoded: WithdrawStakeEvent;
+        type_arguments: [];
+    }
     interface AllowlistDelegator {
         pool_address: MoveAddressType;
         delegator_address: MoveAddressType;
@@ -3633,32 +3782,6 @@ export declare namespace delegation_pool {
         data_decoded: CommissionPercentageChange;
         type_arguments: [];
     }
-    interface CreateProposal {
-        proposal_id: bigint;
-        voter: MoveAddressType;
-        delegation_pool: MoveAddressType;
-    }
-    namespace CreateProposal {
-        const TYPE_QNAME = "0x1::delegation_pool::CreateProposal";
-        function type(): TypeDescriptor<CreateProposal>;
-    }
-    interface CreateProposalInstance extends TypedEventInstance<CreateProposal> {
-        data_decoded: CreateProposal;
-        type_arguments: [];
-    }
-    interface CreateProposalEvent {
-        proposal_id: bigint;
-        voter: MoveAddressType;
-        delegation_pool: MoveAddressType;
-    }
-    namespace CreateProposalEvent {
-        const TYPE_QNAME = "0x1::delegation_pool::CreateProposalEvent";
-        function type(): TypeDescriptor<CreateProposalEvent>;
-    }
-    interface CreateProposalEventInstance extends TypedEventInstance<CreateProposalEvent> {
-        data_decoded: CreateProposalEvent;
-        type_arguments: [];
-    }
     interface DelegateVotingPower {
         pool_address: MoveAddressType;
         delegator: MoveAddressType;
@@ -3818,48 +3941,22 @@ export declare namespace delegation_pool {
         const TYPE_QNAME = "0x1::delegation_pool::ObservedLockupCycle";
         function type(): TypeDescriptor<ObservedLockupCycle>;
     }
-    interface ReactivateStake {
+    interface RemoveDelegatorFromAllowlist {
         pool_address: MoveAddressType;
         delegator_address: MoveAddressType;
-        amount_reactivated: bigint;
     }
-    namespace ReactivateStake {
-        const TYPE_QNAME = "0x1::delegation_pool::ReactivateStake";
-        function type(): TypeDescriptor<ReactivateStake>;
+    namespace RemoveDelegatorFromAllowlist {
+        const TYPE_QNAME = "0x1::delegation_pool::RemoveDelegatorFromAllowlist";
+        function type(): TypeDescriptor<RemoveDelegatorFromAllowlist>;
     }
-    interface ReactivateStakeInstance extends TypedEventInstance<ReactivateStake> {
-        data_decoded: ReactivateStake;
+    interface RemoveDelegatorFromAllowlistInstance extends TypedEventInstance<RemoveDelegatorFromAllowlist> {
+        data_decoded: RemoveDelegatorFromAllowlist;
         type_arguments: [];
     }
-    interface ReactivateStakeEvent {
-        pool_address: MoveAddressType;
-        delegator_address: MoveAddressType;
-        amount_reactivated: bigint;
-    }
-    namespace ReactivateStakeEvent {
-        const TYPE_QNAME = "0x1::delegation_pool::ReactivateStakeEvent";
-        function type(): TypeDescriptor<ReactivateStakeEvent>;
-    }
-    interface ReactivateStakeEventInstance extends TypedEventInstance<ReactivateStakeEvent> {
-        data_decoded: ReactivateStakeEvent;
-        type_arguments: [];
-    }
-    interface RemoveDelegatorFromAllowlist {
-        pool_address: MoveAddressType;
-        delegator_address: MoveAddressType;
-    }
-    namespace RemoveDelegatorFromAllowlist {
-        const TYPE_QNAME = "0x1::delegation_pool::RemoveDelegatorFromAllowlist";
-        function type(): TypeDescriptor<RemoveDelegatorFromAllowlist>;
-    }
-    interface RemoveDelegatorFromAllowlistInstance extends TypedEventInstance<RemoveDelegatorFromAllowlist> {
-        data_decoded: RemoveDelegatorFromAllowlist;
-        type_arguments: [];
-    }
-    interface SetBeneficiaryForOperator {
-        operator: MoveAddressType;
-        old_beneficiary: MoveAddressType;
-        new_beneficiary: MoveAddressType;
+    interface SetBeneficiaryForOperator {
+        operator: MoveAddressType;
+        old_beneficiary: MoveAddressType;
+        new_beneficiary: MoveAddressType;
     }
     namespace SetBeneficiaryForOperator {
         const TYPE_QNAME = "0x1::delegation_pool::SetBeneficiaryForOperator";
@@ -3869,47 +3966,6 @@ export declare namespace delegation_pool {
         data_decoded: SetBeneficiaryForOperator;
         type_arguments: [];
     }
-    interface UnlockStake {
-        pool_address: MoveAddressType;
-        delegator_address: MoveAddressType;
-        amount_unlocked: bigint;
-    }
-    namespace UnlockStake {
-        const TYPE_QNAME = "0x1::delegation_pool::UnlockStake";
-        function type(): TypeDescriptor<UnlockStake>;
-    }
-    interface UnlockStakeInstance extends TypedEventInstance<UnlockStake> {
-        data_decoded: UnlockStake;
-        type_arguments: [];
-    }
-    interface UnlockStakeEvent {
-        pool_address: MoveAddressType;
-        delegator_address: MoveAddressType;
-        amount_unlocked: bigint;
-    }
-    namespace UnlockStakeEvent {
-        const TYPE_QNAME = "0x1::delegation_pool::UnlockStakeEvent";
-        function type(): TypeDescriptor<UnlockStakeEvent>;
-    }
-    interface UnlockStakeEventInstance extends TypedEventInstance<UnlockStakeEvent> {
-        data_decoded: UnlockStakeEvent;
-        type_arguments: [];
-    }
-    interface Vote {
-        voter: MoveAddressType;
-        proposal_id: bigint;
-        delegation_pool: MoveAddressType;
-        num_votes: bigint;
-        should_pass: boolean;
-    }
-    namespace Vote {
-        const TYPE_QNAME = "0x1::delegation_pool::Vote";
-        function type(): TypeDescriptor<Vote>;
-    }
-    interface VoteInstance extends TypedEventInstance<Vote> {
-        data_decoded: Vote;
-        type_arguments: [];
-    }
     interface VoteDelegation {
         voter: MoveAddressType;
         pending_voter: MoveAddressType;
@@ -3919,21 +3975,6 @@ export declare namespace delegation_pool {
         const TYPE_QNAME = "0x1::delegation_pool::VoteDelegation";
         function type(): TypeDescriptor<VoteDelegation>;
     }
-    interface VoteEvent {
-        voter: MoveAddressType;
-        proposal_id: bigint;
-        delegation_pool: MoveAddressType;
-        num_votes: bigint;
-        should_pass: boolean;
-    }
-    namespace VoteEvent {
-        const TYPE_QNAME = "0x1::delegation_pool::VoteEvent";
-        function type(): TypeDescriptor<VoteEvent>;
-    }
-    interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
-        data_decoded: VoteEvent;
-        type_arguments: [];
-    }
     interface VotingRecordKey {
         voter: MoveAddressType;
         proposal_id: bigint;
@@ -3942,44 +3983,42 @@ export declare namespace delegation_pool {
         const TYPE_QNAME = "0x1::delegation_pool::VotingRecordKey";
         function type(): TypeDescriptor<VotingRecordKey>;
     }
-    interface WithdrawStake {
-        pool_address: MoveAddressType;
-        delegator_address: MoveAddressType;
-        amount_withdrawn: bigint;
-    }
-    namespace WithdrawStake {
-        const TYPE_QNAME = "0x1::delegation_pool::WithdrawStake";
-        function type(): TypeDescriptor<WithdrawStake>;
-    }
-    interface WithdrawStakeInstance extends TypedEventInstance<WithdrawStake> {
-        data_decoded: WithdrawStake;
-        type_arguments: [];
-    }
-    interface WithdrawStakeEvent {
-        pool_address: MoveAddressType;
-        delegator_address: MoveAddressType;
-        amount_withdrawn: bigint;
-    }
-    namespace WithdrawStakeEvent {
-        const TYPE_QNAME = "0x1::delegation_pool::WithdrawStakeEvent";
-        function type(): TypeDescriptor<WithdrawStakeEvent>;
-    }
-    interface WithdrawStakeEventInstance extends TypedEventInstance<WithdrawStakeEvent> {
-        data_decoded: WithdrawStakeEvent;
-        type_arguments: [];
-    }
     namespace entry {
+        function withdraw(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createProposal(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, string, string, string, boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function vote(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint, bigint, boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function addStake(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType, bigint];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function allowlistDelegator(client: Aptos, account: AptosAccount, request: {
+        function reactivateStake(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setDelegatedVoter(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
-        function createProposal(client: Aptos, account: AptosAccount, request: {
+        function setOperator(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
-            functionArguments: [MoveAddressType, string, string, string, boolean];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function unlock(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 delegateVotingPower(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
@@ -4005,10 +4044,6 @@ export declare namespace delegation_pool {
             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];
@@ -4017,36 +4052,25 @@ export declare namespace delegation_pool {
             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 partialGovernanceVotingEnabled(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+        function getOwnedPoolAddress(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType]>;
+        function getStake(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[bigint, bigint, bigint]>;
         function allowlistingEnabled(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[boolean]>;
@@ -4086,15 +4110,12 @@ export declare namespace delegation_pool {
         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 operatorCommissionPercentage(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
         function isNextCommissionPercentageEffective(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[boolean]>;
@@ -4102,18 +4123,12 @@ export declare namespace delegation_pool {
         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]>;
@@ -4134,6 +4149,13 @@ export declare namespace keyless_account {
         const TYPE_QNAME = "0x1::keyless_account::Configuration";
         function type(): TypeDescriptor<Configuration>;
     }
+    interface Group {
+        dummy_field: boolean;
+    }
+    namespace Group {
+        const TYPE_QNAME = "0x1::keyless_account::Group";
+        function type(): TypeDescriptor<Group>;
+    }
     interface Groth16VerificationKey {
         alpha_g1: string;
         beta_g2: string;
@@ -4145,13 +4167,6 @@ export declare namespace keyless_account {
         const TYPE_QNAME = "0x1::keyless_account::Groth16VerificationKey";
         function type(): TypeDescriptor<Groth16VerificationKey>;
     }
-    interface Group {
-        dummy_field: boolean;
-    }
-    namespace Group {
-        const TYPE_QNAME = "0x1::keyless_account::Group";
-        function type(): TypeDescriptor<Group>;
-    }
     namespace entry { }
     namespace view { }
 }
@@ -4252,13 +4267,6 @@ export declare namespace transaction_fee {
     namespace view { }
 }
 export declare namespace aptos_governance {
-    interface ApprovedExecutionHashes {
-        hashes: simple_map.SimpleMap<bigint, string>;
-    }
-    namespace ApprovedExecutionHashes {
-        const TYPE_QNAME = "0x1::aptos_governance::ApprovedExecutionHashes";
-        function type(): TypeDescriptor<ApprovedExecutionHashes>;
-    }
     interface CreateProposal {
         proposer: MoveAddressType;
         stake_pool: MoveAddressType;
@@ -4289,6 +4297,43 @@ export declare namespace aptos_governance {
         data_decoded: CreateProposalEvent;
         type_arguments: [];
     }
+    interface Vote {
+        proposal_id: bigint;
+        voter: MoveAddressType;
+        stake_pool: MoveAddressType;
+        num_votes: bigint;
+        should_pass: boolean;
+    }
+    namespace Vote {
+        const TYPE_QNAME = "0x1::aptos_governance::Vote";
+        function type(): TypeDescriptor<Vote>;
+    }
+    interface VoteInstance extends TypedEventInstance<Vote> {
+        data_decoded: Vote;
+        type_arguments: [];
+    }
+    interface VoteEvent {
+        proposal_id: bigint;
+        voter: MoveAddressType;
+        stake_pool: MoveAddressType;
+        num_votes: bigint;
+        should_pass: boolean;
+    }
+    namespace VoteEvent {
+        const TYPE_QNAME = "0x1::aptos_governance::VoteEvent";
+        function type(): TypeDescriptor<VoteEvent>;
+    }
+    interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
+        data_decoded: VoteEvent;
+        type_arguments: [];
+    }
+    interface ApprovedExecutionHashes {
+        hashes: simple_map.SimpleMap<bigint, string>;
+    }
+    namespace ApprovedExecutionHashes {
+        const TYPE_QNAME = "0x1::aptos_governance::ApprovedExecutionHashes";
+        function type(): TypeDescriptor<ApprovedExecutionHashes>;
+    }
     interface GovernanceConfig {
         min_voting_threshold: bigint;
         required_proposer_stake: bigint;
@@ -4348,36 +4393,6 @@ export declare namespace aptos_governance {
         data_decoded: UpdateConfigEvent;
         type_arguments: [];
     }
-    interface Vote {
-        proposal_id: bigint;
-        voter: MoveAddressType;
-        stake_pool: MoveAddressType;
-        num_votes: bigint;
-        should_pass: boolean;
-    }
-    namespace Vote {
-        const TYPE_QNAME = "0x1::aptos_governance::Vote";
-        function type(): TypeDescriptor<Vote>;
-    }
-    interface VoteInstance extends TypedEventInstance<Vote> {
-        data_decoded: Vote;
-        type_arguments: [];
-    }
-    interface VoteEvent {
-        proposal_id: bigint;
-        voter: MoveAddressType;
-        stake_pool: MoveAddressType;
-        num_votes: bigint;
-        should_pass: boolean;
-    }
-    namespace VoteEvent {
-        const TYPE_QNAME = "0x1::aptos_governance::VoteEvent";
-        function type(): TypeDescriptor<VoteEvent>;
-    }
-    interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
-        data_decoded: VoteEvent;
-        type_arguments: [];
-    }
     interface VotingRecords {
         votes: table.Table<aptos_governance.RecordKey, boolean>;
     }
@@ -4393,6 +4408,22 @@ export declare namespace aptos_governance {
         function type(): TypeDescriptor<VotingRecordsV2>;
     }
     namespace entry {
+        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 vote(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType, bigint, boolean];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function reconfigure(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function addApprovedScriptHashScript(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [bigint];
@@ -4405,14 +4436,6 @@ export declare namespace aptos_governance {
             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: [];
@@ -4425,25 +4448,17 @@ export declare namespace aptos_governance {
             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 getVotingPower(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
         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]>;
@@ -4581,6 +4596,33 @@ export declare namespace execution_config {
     namespace view { }
 }
 export declare namespace multisig_account {
+    interface Vote {
+        multisig_account: MoveAddressType;
+        owner: MoveAddressType;
+        sequence_number: bigint;
+        approved: boolean;
+    }
+    namespace Vote {
+        const TYPE_QNAME = "0x1::multisig_account::Vote";
+        function type(): TypeDescriptor<Vote>;
+    }
+    interface VoteInstance extends TypedEventInstance<Vote> {
+        data_decoded: Vote;
+        type_arguments: [];
+    }
+    interface VoteEvent {
+        owner: MoveAddressType;
+        sequence_number: bigint;
+        approved: boolean;
+    }
+    namespace VoteEvent {
+        const TYPE_QNAME = "0x1::multisig_account::VoteEvent";
+        function type(): TypeDescriptor<VoteEvent>;
+    }
+    interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
+        data_decoded: VoteEvent;
+        type_arguments: [];
+    }
     interface AddOwners {
         multisig_account: MoveAddressType;
         owners_added: MoveAddressType[];
@@ -4855,34 +4897,11 @@ export declare namespace multisig_account {
         data_decoded: UpdateSignaturesRequiredEvent;
         type_arguments: [];
     }
-    interface Vote {
-        multisig_account: MoveAddressType;
-        owner: MoveAddressType;
-        sequence_number: bigint;
-        approved: boolean;
-    }
-    namespace Vote {
-        const TYPE_QNAME = "0x1::multisig_account::Vote";
-        function type(): TypeDescriptor<Vote>;
-    }
-    interface VoteInstance extends TypedEventInstance<Vote> {
-        data_decoded: Vote;
-        type_arguments: [];
-    }
-    interface VoteEvent {
-        owner: MoveAddressType;
-        sequence_number: bigint;
-        approved: boolean;
-    }
-    namespace VoteEvent {
-        const TYPE_QNAME = "0x1::multisig_account::VoteEvent";
-        function type(): TypeDescriptor<VoteEvent>;
-    }
-    interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
-        data_decoded: VoteEvent;
-        type_arguments: [];
-    }
     namespace entry {
+        function create(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [bigint, string[], string[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function addOwner(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType];
@@ -4899,10 +4918,6 @@ export declare namespace multisig_account {
             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];
@@ -5007,6 +5022,15 @@ export declare namespace multisig_account {
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
+        function isOwner(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[boolean]>;
+        function metadata(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[simple_map.SimpleMap<string, string>]>;
+        function vote(client: Aptos, request: {
+            functionArguments: [MoveAddressType, bigint, MoveAddressType];
+        }, version?: bigint): Promise<[boolean, boolean]>;
         function availableTransactionQueueCapacity(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
@@ -5022,6 +5046,12 @@ export declare namespace multisig_account {
         function canReject(client: Aptos, request: {
             functionArguments: [MoveAddressType, MoveAddressType, bigint];
         }, version?: bigint): Promise<[boolean]>;
+        function numSignaturesRequired(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
+        function owners(client: Aptos, request: {
+            functionArguments: [MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType[]]>;
         function getNextMultisigAccountAddress(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[MoveAddressType]>;
@@ -5034,27 +5064,12 @@ export declare namespace multisig_account {
         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]>;
     }
 }
 export declare namespace pool_u64_unbound {
@@ -5096,56 +5111,58 @@ export declare namespace resource_account {
     namespace view { }
 }
 export declare namespace staking_contract {
-    interface AddDistribution {
+    interface AddStake {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
         amount: bigint;
     }
-    namespace AddDistribution {
-        const TYPE_QNAME = "0x1::staking_contract::AddDistribution";
-        function type(): TypeDescriptor<AddDistribution>;
+    namespace AddStake {
+        const TYPE_QNAME = "0x1::staking_contract::AddStake";
+        function type(): TypeDescriptor<AddStake>;
     }
-    interface AddDistributionInstance extends TypedEventInstance<AddDistribution> {
-        data_decoded: AddDistribution;
+    interface AddStakeInstance extends TypedEventInstance<AddStake> {
+        data_decoded: AddStake;
         type_arguments: [];
     }
-    interface AddDistributionEvent {
+    interface AddStakeEvent {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
         amount: bigint;
     }
-    namespace AddDistributionEvent {
-        const TYPE_QNAME = "0x1::staking_contract::AddDistributionEvent";
-        function type(): TypeDescriptor<AddDistributionEvent>;
+    namespace AddStakeEvent {
+        const TYPE_QNAME = "0x1::staking_contract::AddStakeEvent";
+        function type(): TypeDescriptor<AddStakeEvent>;
     }
-    interface AddDistributionEventInstance extends TypedEventInstance<AddDistributionEvent> {
-        data_decoded: AddDistributionEvent;
+    interface AddStakeEventInstance extends TypedEventInstance<AddStakeEvent> {
+        data_decoded: AddStakeEvent;
         type_arguments: [];
     }
-    interface AddStake {
+    interface UnlockStake {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
         amount: bigint;
+        commission_paid: bigint;
     }
-    namespace AddStake {
-        const TYPE_QNAME = "0x1::staking_contract::AddStake";
-        function type(): TypeDescriptor<AddStake>;
+    namespace UnlockStake {
+        const TYPE_QNAME = "0x1::staking_contract::UnlockStake";
+        function type(): TypeDescriptor<UnlockStake>;
     }
-    interface AddStakeInstance extends TypedEventInstance<AddStake> {
-        data_decoded: AddStake;
+    interface UnlockStakeInstance extends TypedEventInstance<UnlockStake> {
+        data_decoded: UnlockStake;
         type_arguments: [];
     }
-    interface AddStakeEvent {
+    interface UnlockStakeEvent {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
         amount: bigint;
+        commission_paid: bigint;
     }
-    namespace AddStakeEvent {
-        const TYPE_QNAME = "0x1::staking_contract::AddStakeEvent";
-        function type(): TypeDescriptor<AddStakeEvent>;
+    namespace UnlockStakeEvent {
+        const TYPE_QNAME = "0x1::staking_contract::UnlockStakeEvent";
+        function type(): TypeDescriptor<UnlockStakeEvent>;
     }
-    interface AddStakeEventInstance extends TypedEventInstance<AddStakeEvent> {
-        data_decoded: AddStakeEvent;
+    interface UnlockStakeEventInstance extends TypedEventInstance<UnlockStakeEvent> {
+        data_decoded: UnlockStakeEvent;
         type_arguments: [];
     }
     interface BeneficiaryForOperator {
@@ -5155,6 +5172,45 @@ export declare namespace staking_contract {
         const TYPE_QNAME = "0x1::staking_contract::BeneficiaryForOperator";
         function type(): TypeDescriptor<BeneficiaryForOperator>;
     }
+    interface SetBeneficiaryForOperator {
+        operator: MoveAddressType;
+        old_beneficiary: MoveAddressType;
+        new_beneficiary: MoveAddressType;
+    }
+    namespace SetBeneficiaryForOperator {
+        const TYPE_QNAME = "0x1::staking_contract::SetBeneficiaryForOperator";
+        function type(): TypeDescriptor<SetBeneficiaryForOperator>;
+    }
+    interface SetBeneficiaryForOperatorInstance extends TypedEventInstance<SetBeneficiaryForOperator> {
+        data_decoded: SetBeneficiaryForOperator;
+        type_arguments: [];
+    }
+    interface AddDistribution {
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
+        amount: bigint;
+    }
+    namespace AddDistribution {
+        const TYPE_QNAME = "0x1::staking_contract::AddDistribution";
+        function type(): TypeDescriptor<AddDistribution>;
+    }
+    interface AddDistributionInstance extends TypedEventInstance<AddDistribution> {
+        data_decoded: AddDistribution;
+        type_arguments: [];
+    }
+    interface AddDistributionEvent {
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
+        amount: bigint;
+    }
+    namespace AddDistributionEvent {
+        const TYPE_QNAME = "0x1::staking_contract::AddDistributionEvent";
+        function type(): TypeDescriptor<AddDistributionEvent>;
+    }
+    interface AddDistributionEventInstance extends TypedEventInstance<AddDistributionEvent> {
+        data_decoded: AddDistributionEvent;
+        type_arguments: [];
+    }
     interface CreateStakingContract {
         operator: MoveAddressType;
         voter: MoveAddressType;
@@ -5265,19 +5321,6 @@ export declare namespace staking_contract {
         data_decoded: ResetLockupEvent;
         type_arguments: [];
     }
-    interface SetBeneficiaryForOperator {
-        operator: MoveAddressType;
-        old_beneficiary: MoveAddressType;
-        new_beneficiary: MoveAddressType;
-    }
-    namespace SetBeneficiaryForOperator {
-        const TYPE_QNAME = "0x1::staking_contract::SetBeneficiaryForOperator";
-        function type(): TypeDescriptor<SetBeneficiaryForOperator>;
-    }
-    interface SetBeneficiaryForOperatorInstance extends TypedEventInstance<SetBeneficiaryForOperator> {
-        data_decoded: SetBeneficiaryForOperator;
-        type_arguments: [];
-    }
     interface StakingContract {
         principal: bigint;
         pool_address: MoveAddressType;
@@ -5350,34 +5393,6 @@ export declare namespace staking_contract {
         data_decoded: SwitchOperatorEvent;
         type_arguments: [];
     }
-    interface UnlockStake {
-        operator: MoveAddressType;
-        pool_address: MoveAddressType;
-        amount: bigint;
-        commission_paid: bigint;
-    }
-    namespace UnlockStake {
-        const TYPE_QNAME = "0x1::staking_contract::UnlockStake";
-        function type(): TypeDescriptor<UnlockStake>;
-    }
-    interface UnlockStakeInstance extends TypedEventInstance<UnlockStake> {
-        data_decoded: UnlockStake;
-        type_arguments: [];
-    }
-    interface UnlockStakeEvent {
-        operator: MoveAddressType;
-        pool_address: MoveAddressType;
-        amount: bigint;
-        commission_paid: bigint;
-    }
-    namespace UnlockStakeEvent {
-        const TYPE_QNAME = "0x1::staking_contract::UnlockStakeEvent";
-        function type(): TypeDescriptor<UnlockStakeEvent>;
-    }
-    interface UnlockStakeEventInstance extends TypedEventInstance<UnlockStakeEvent> {
-        data_decoded: UnlockStakeEvent;
-        type_arguments: [];
-    }
     interface UpdateCommission {
         staker: MoveAddressType;
         operator: MoveAddressType;
@@ -5439,6 +5454,10 @@ export declare namespace staking_contract {
             typeArguments: [];
             functionArguments: [MoveAddressType, bigint];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function setBeneficiaryForOperator(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [MoveAddressType];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function createStakingContract(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [
@@ -5461,10 +5480,6 @@ export declare namespace staking_contract {
             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];
@@ -5494,12 +5509,12 @@ export declare namespace staking_contract {
         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 commissionPercentage(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[bigint]>;
         function lastRecordedPrincipal(client: Aptos, request: {
             functionArguments: [MoveAddressType, MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
@@ -5655,13 +5670,6 @@ export declare namespace jwk_consensus_config {
         const TYPE_QNAME = "0x1::jwk_consensus_config::ConfigV1";
         function type(): TypeDescriptor<ConfigV1>;
     }
-    interface JWKConsensusConfig {
-        variant: copyable_any.Any;
-    }
-    namespace JWKConsensusConfig {
-        const TYPE_QNAME = "0x1::jwk_consensus_config::JWKConsensusConfig";
-        function type(): TypeDescriptor<JWKConsensusConfig>;
-    }
     interface OIDCProvider {
         name: string;
         config_url: string;
@@ -5670,6 +5678,13 @@ export declare namespace jwk_consensus_config {
         const TYPE_QNAME = "0x1::jwk_consensus_config::OIDCProvider";
         function type(): TypeDescriptor<OIDCProvider>;
     }
+    interface JWKConsensusConfig {
+        variant: copyable_any.Any;
+    }
+    namespace JWKConsensusConfig {
+        const TYPE_QNAME = "0x1::jwk_consensus_config::JWKConsensusConfig";
+        function type(): TypeDescriptor<JWKConsensusConfig>;
+    }
     namespace entry { }
     namespace view { }
 }