@typemove/aptos 1.6.1-rc.2 → 1.6.2-rc.1

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

@@ -197,6 +197,13 @@ export declare namespace coin {
         const TYPE_QNAME = "0x1::coin::BurnCapability";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<BurnCapability<T0>>;
     }
+    interface BurnRefReceipt {
+        metadata: object_.Object<fungible_asset.Metadata>;
+    }
+    namespace BurnRefReceipt {
+        const TYPE_QNAME = "0x1::coin::BurnRefReceipt";
+        function type(): TypeDescriptor<BurnRefReceipt>;
+    }
     interface Coin<T0> {
         value: bigint;
     }
@@ -204,6 +211,26 @@ export declare namespace coin {
         const TYPE_QNAME = "0x1::coin::Coin";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Coin<T0>>;
     }
+    interface CoinConversionMap {
+        coin_to_fungible_asset_map: table.Table<type_info.TypeInfo, object_.Object<fungible_asset.Metadata>>;
+    }
+    namespace CoinConversionMap {
+        const TYPE_QNAME = "0x1::coin::CoinConversionMap";
+        function type(): TypeDescriptor<CoinConversionMap>;
+    }
+    interface CoinEventHandleDeletion {
+        event_handle_creation_address: MoveAddressType;
+        deleted_deposit_event_handle_creation_number: bigint;
+        deleted_withdraw_event_handle_creation_number: bigint;
+    }
+    namespace CoinEventHandleDeletion {
+        const TYPE_QNAME = "0x1::coin::CoinEventHandleDeletion";
+        function type(): TypeDescriptor<CoinEventHandleDeletion>;
+    }
+    interface CoinEventHandleDeletionInstance extends TypedEventInstance<CoinEventHandleDeletion> {
+        data_decoded: CoinEventHandleDeletion;
+        type_arguments: [];
+    }
     interface CoinInfo<T0> {
         name: string;
         symbol: string;
@@ -224,6 +251,18 @@ export declare namespace coin {
         const TYPE_QNAME = "0x1::coin::CoinStore";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<CoinStore<T0>>;
     }
+    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 DepositInstance extends TypedEventInstance<Deposit<any>> {
+        data_decoded: Deposit<any>;
+        type_arguments: [string];
+    }
     interface DepositEvent {
         amount: bigint;
     }
@@ -242,6 +281,13 @@ export declare namespace coin {
         const TYPE_QNAME = "0x1::coin::FreezeCapability";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<FreezeCapability<T0>>;
     }
+    interface MigrationFlag {
+        dummy_field: Boolean;
+    }
+    namespace MigrationFlag {
+        const TYPE_QNAME = "0x1::coin::MigrationFlag";
+        function type(): TypeDescriptor<MigrationFlag>;
+    }
     interface MintCapability<T0> {
         dummy_field: Boolean;
     }
@@ -249,6 +295,41 @@ export declare namespace coin {
         const TYPE_QNAME = "0x1::coin::MintCapability";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<MintCapability<T0>>;
     }
+    interface MintRefReceipt {
+        metadata: object_.Object<fungible_asset.Metadata>;
+    }
+    namespace MintRefReceipt {
+        const TYPE_QNAME = "0x1::coin::MintRefReceipt";
+        function type(): TypeDescriptor<MintRefReceipt>;
+    }
+    interface PairCreation {
+        coin_type: type_info.TypeInfo;
+        fungible_asset_metadata_address: MoveAddressType;
+    }
+    namespace PairCreation {
+        const TYPE_QNAME = "0x1::coin::PairCreation";
+        function type(): TypeDescriptor<PairCreation>;
+    }
+    interface PairCreationInstance extends TypedEventInstance<PairCreation> {
+        data_decoded: PairCreation;
+        type_arguments: [];
+    }
+    interface PairedCoinType {
+        type: type_info.TypeInfo;
+    }
+    namespace PairedCoinType {
+        const TYPE_QNAME = "0x1::coin::PairedCoinType";
+        function type(): TypeDescriptor<PairedCoinType>;
+    }
+    interface PairedFungibleAssetRefs {
+        mint_ref_opt: option.Option<fungible_asset.MintRef>;
+        transfer_ref_opt: option.Option<fungible_asset.TransferRef>;
+        burn_ref_opt: option.Option<fungible_asset.BurnRef>;
+    }
+    namespace PairedFungibleAssetRefs {
+        const TYPE_QNAME = "0x1::coin::PairedFungibleAssetRefs";
+        function type(): TypeDescriptor<PairedFungibleAssetRefs>;
+    }
     interface SupplyConfig {
         allow_upgrades: Boolean;
     }
@@ -256,6 +337,25 @@ export declare namespace coin {
         const TYPE_QNAME = "0x1::coin::SupplyConfig";
         function type(): TypeDescriptor<SupplyConfig>;
     }
+    interface TransferRefReceipt {
+        metadata: object_.Object<fungible_asset.Metadata>;
+    }
+    namespace TransferRefReceipt {
+        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 WithdrawInstance extends TypedEventInstance<Withdraw<any>> {
+        data_decoded: Withdraw<any>;
+        type_arguments: [string];
+    }
     interface WithdrawEvent {
         amount: bigint;
     }
@@ -268,10 +368,22 @@ export declare namespace coin {
         type_arguments: [];
     }
     namespace entry {
+        function createCoinConversionMap(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function createPairing<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function freezeCoinStore<T0 = any>(client: Aptos, account: AptosAccount, request: {
             typeArguments: [MoveStructId];
             functionArguments: [MoveAddressType, MoveAddressType];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function migrateToFungibleStore<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function transfer<T0 = any>(client: Aptos, account: AptosAccount, request: {
             typeArguments: [MoveStructId];
             functionArguments: [MoveAddressType, bigint];
@@ -290,6 +402,9 @@ export declare namespace coin {
             typeArguments: [MoveStructId];
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
+        function coinSupply<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+        }, version?: bigint): Promise<[option.Option<bigint>]>;
         function decimals<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
         }, version?: bigint): Promise<[number]>;
@@ -297,6 +412,10 @@ export declare namespace coin {
             typeArguments: [MoveStructId];
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[Boolean]>;
+        function isBalanceAtLeast<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, bigint];
+        }, version?: bigint): Promise<[Boolean]>;
         function isCoinInitialized<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
         }, version?: bigint): Promise<[Boolean]>;
@@ -307,6 +426,21 @@ export declare namespace coin {
         function name<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
         }, version?: bigint): Promise<[string]>;
+        function pairedBurnRefExists<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+        }, version?: bigint): Promise<[Boolean]>;
+        function pairedCoin(client: Aptos, request: {
+            functionArguments: [object_.Object<fungible_asset.Metadata>];
+        }, version?: bigint): Promise<[option.Option<type_info.TypeInfo>]>;
+        function pairedMetadata<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+        }, version?: bigint): Promise<[option.Option<object_.Object<fungible_asset.Metadata>>]>;
+        function pairedMintRefExists<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+        }, version?: bigint): Promise<[Boolean]>;
+        function pairedTransferRefExists<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+        }, version?: bigint): Promise<[Boolean]>;
         function supply<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
         }, version?: bigint): Promise<[option.Option<bigint>]>;
@@ -553,6 +687,24 @@ export declare namespace block {
         const TYPE_QNAME = "0x1::block::CommitHistory";
         function type(): TypeDescriptor<CommitHistory>;
     }
+    interface NewBlock {
+        hash: MoveAddressType;
+        epoch: bigint;
+        round: bigint;
+        height: bigint;
+        previous_block_votes_bitvec: string;
+        proposer: MoveAddressType;
+        failed_proposer_indices: bigint[];
+        time_microseconds: bigint;
+    }
+    namespace NewBlock {
+        const TYPE_QNAME = "0x1::block::NewBlock";
+        function type(): TypeDescriptor<NewBlock>;
+    }
+    interface NewBlockInstance extends TypedEventInstance<NewBlock> {
+        data_decoded: NewBlock;
+        type_arguments: [];
+    }
     interface NewBlockEvent {
         hash: MoveAddressType;
         epoch: bigint;
@@ -571,6 +723,18 @@ export declare namespace block {
         data_decoded: NewBlockEvent;
         type_arguments: [];
     }
+    interface UpdateEpochInterval {
+        old_epoch_interval: bigint;
+        new_epoch_interval: bigint;
+    }
+    namespace UpdateEpochInterval {
+        const TYPE_QNAME = "0x1::block::UpdateEpochInterval";
+        function type(): TypeDescriptor<UpdateEpochInterval>;
+    }
+    interface UpdateEpochIntervalInstance extends TypedEventInstance<UpdateEpochInterval> {
+        data_decoded: UpdateEpochInterval;
+        type_arguments: [];
+    }
     interface UpdateEpochIntervalEvent {
         old_epoch_interval: bigint;
         new_epoch_interval: bigint;
@@ -610,6 +774,18 @@ export declare namespace event {
     namespace view { }
 }
 export declare namespace stake {
+    interface AddStake {
+        pool_address: MoveAddressType;
+        amount_added: bigint;
+    }
+    namespace AddStake {
+        const TYPE_QNAME = "0x1::stake::AddStake";
+        function type(): TypeDescriptor<AddStake>;
+    }
+    interface AddStakeInstance extends TypedEventInstance<AddStake> {
+        data_decoded: AddStake;
+        type_arguments: [];
+    }
     interface AddStakeEvent {
         pool_address: MoveAddressType;
         amount_added: bigint;
@@ -636,6 +812,18 @@ export declare namespace stake {
         const TYPE_QNAME = "0x1::stake::AptosCoinCapabilities";
         function type(): TypeDescriptor<AptosCoinCapabilities>;
     }
+    interface DistributeRewards {
+        pool_address: MoveAddressType;
+        rewards_amount: bigint;
+    }
+    namespace DistributeRewards {
+        const TYPE_QNAME = "0x1::stake::DistributeRewards";
+        function type(): TypeDescriptor<DistributeRewards>;
+    }
+    interface DistributeRewardsInstance extends TypedEventInstance<DistributeRewards> {
+        data_decoded: DistributeRewards;
+        type_arguments: [];
+    }
     interface DistributeRewardsEvent {
         pool_address: MoveAddressType;
         rewards_amount: bigint;
@@ -648,6 +836,19 @@ export declare namespace stake {
         data_decoded: DistributeRewardsEvent;
         type_arguments: [];
     }
+    interface IncreaseLockup {
+        pool_address: MoveAddressType;
+        old_locked_until_secs: bigint;
+        new_locked_until_secs: bigint;
+    }
+    namespace IncreaseLockup {
+        const TYPE_QNAME = "0x1::stake::IncreaseLockup";
+        function type(): TypeDescriptor<IncreaseLockup>;
+    }
+    interface IncreaseLockupInstance extends TypedEventInstance<IncreaseLockup> {
+        data_decoded: IncreaseLockup;
+        type_arguments: [];
+    }
     interface IncreaseLockupEvent {
         pool_address: MoveAddressType;
         old_locked_until_secs: bigint;
@@ -673,6 +874,17 @@ export declare namespace stake {
         data_decoded: IndividualValidatorPerformance;
         type_arguments: [];
     }
+    interface JoinValidatorSet {
+        pool_address: MoveAddressType;
+    }
+    namespace JoinValidatorSet {
+        const TYPE_QNAME = "0x1::stake::JoinValidatorSet";
+        function type(): TypeDescriptor<JoinValidatorSet>;
+    }
+    interface JoinValidatorSetInstance extends TypedEventInstance<JoinValidatorSet> {
+        data_decoded: JoinValidatorSet;
+        type_arguments: [];
+    }
     interface JoinValidatorSetEvent {
         pool_address: MoveAddressType;
     }
@@ -684,6 +896,17 @@ export declare namespace stake {
         data_decoded: JoinValidatorSetEvent;
         type_arguments: [];
     }
+    interface LeaveValidatorSet {
+        pool_address: MoveAddressType;
+    }
+    namespace LeaveValidatorSet {
+        const TYPE_QNAME = "0x1::stake::LeaveValidatorSet";
+        function type(): TypeDescriptor<LeaveValidatorSet>;
+    }
+    interface LeaveValidatorSetInstance extends TypedEventInstance<LeaveValidatorSet> {
+        data_decoded: LeaveValidatorSet;
+        type_arguments: [];
+    }
     interface LeaveValidatorSetEvent {
         pool_address: MoveAddressType;
     }
@@ -702,6 +925,18 @@ export declare namespace stake {
         const TYPE_QNAME = "0x1::stake::OwnerCapability";
         function type(): TypeDescriptor<OwnerCapability>;
     }
+    interface ReactivateStake {
+        pool_address: MoveAddressType;
+        amount: bigint;
+    }
+    namespace ReactivateStake {
+        const TYPE_QNAME = "0x1::stake::ReactivateStake";
+        function type(): TypeDescriptor<ReactivateStake>;
+    }
+    interface ReactivateStakeInstance extends TypedEventInstance<ReactivateStake> {
+        data_decoded: ReactivateStake;
+        type_arguments: [];
+    }
     interface ReactivateStakeEvent {
         pool_address: MoveAddressType;
         amount: bigint;
@@ -714,6 +949,17 @@ export declare namespace stake {
         data_decoded: ReactivateStakeEvent;
         type_arguments: [];
     }
+    interface RegisterValidatorCandidate {
+        pool_address: MoveAddressType;
+    }
+    namespace RegisterValidatorCandidate {
+        const TYPE_QNAME = "0x1::stake::RegisterValidatorCandidate";
+        function type(): TypeDescriptor<RegisterValidatorCandidate>;
+    }
+    interface RegisterValidatorCandidateInstance extends TypedEventInstance<RegisterValidatorCandidate> {
+        data_decoded: RegisterValidatorCandidate;
+        type_arguments: [];
+    }
     interface RegisterValidatorCandidateEvent {
         pool_address: MoveAddressType;
     }
@@ -725,6 +971,19 @@ export declare namespace stake {
         data_decoded: RegisterValidatorCandidateEvent;
         type_arguments: [];
     }
+    interface RotateConsensusKey {
+        pool_address: MoveAddressType;
+        old_consensus_pubkey: string;
+        new_consensus_pubkey: string;
+    }
+    namespace RotateConsensusKey {
+        const TYPE_QNAME = "0x1::stake::RotateConsensusKey";
+        function type(): TypeDescriptor<RotateConsensusKey>;
+    }
+    interface RotateConsensusKeyInstance extends TypedEventInstance<RotateConsensusKey> {
+        data_decoded: RotateConsensusKey;
+        type_arguments: [];
+    }
     interface RotateConsensusKeyEvent {
         pool_address: MoveAddressType;
         old_consensus_pubkey: string;
@@ -738,6 +997,19 @@ export declare namespace stake {
         data_decoded: RotateConsensusKeyEvent;
         type_arguments: [];
     }
+    interface SetOperator {
+        pool_address: MoveAddressType;
+        old_operator: MoveAddressType;
+        new_operator: MoveAddressType;
+    }
+    namespace SetOperator {
+        const TYPE_QNAME = "0x1::stake::SetOperator";
+        function type(): TypeDescriptor<SetOperator>;
+    }
+    interface SetOperatorInstance extends TypedEventInstance<SetOperator> {
+        data_decoded: SetOperator;
+        type_arguments: [];
+    }
     interface SetOperatorEvent {
         pool_address: MoveAddressType;
         old_operator: MoveAddressType;
@@ -776,6 +1048,18 @@ export declare namespace stake {
         const TYPE_QNAME = "0x1::stake::StakePool";
         function type(): TypeDescriptor<StakePool>;
     }
+    interface UnlockStake {
+        pool_address: MoveAddressType;
+        amount_unlocked: bigint;
+    }
+    namespace UnlockStake {
+        const TYPE_QNAME = "0x1::stake::UnlockStake";
+        function type(): TypeDescriptor<UnlockStake>;
+    }
+    interface UnlockStakeInstance extends TypedEventInstance<UnlockStake> {
+        data_decoded: UnlockStake;
+        type_arguments: [];
+    }
     interface UnlockStakeEvent {
         pool_address: MoveAddressType;
         amount_unlocked: bigint;
@@ -788,6 +1072,21 @@ export declare namespace stake {
         data_decoded: UnlockStakeEvent;
         type_arguments: [];
     }
+    interface UpdateNetworkAndFullnodeAddresses {
+        pool_address: MoveAddressType;
+        old_network_addresses: string;
+        new_network_addresses: string;
+        old_fullnode_addresses: string;
+        new_fullnode_addresses: string;
+    }
+    namespace UpdateNetworkAndFullnodeAddresses {
+        const TYPE_QNAME = "0x1::stake::UpdateNetworkAndFullnodeAddresses";
+        function type(): TypeDescriptor<UpdateNetworkAndFullnodeAddresses>;
+    }
+    interface UpdateNetworkAndFullnodeAddressesInstance extends TypedEventInstance<UpdateNetworkAndFullnodeAddresses> {
+        data_decoded: UpdateNetworkAndFullnodeAddresses;
+        type_arguments: [];
+    }
     interface UpdateNetworkAndFullnodeAddressesEvent {
         pool_address: MoveAddressType;
         old_network_addresses: string;
@@ -860,6 +1159,18 @@ export declare namespace stake {
         data_decoded: ValidatorSet;
         type_arguments: [];
     }
+    interface WithdrawStake {
+        pool_address: MoveAddressType;
+        amount_withdrawn: bigint;
+    }
+    namespace WithdrawStake {
+        const TYPE_QNAME = "0x1::stake::WithdrawStake";
+        function type(): TypeDescriptor<WithdrawStake>;
+    }
+    interface WithdrawStakeInstance extends TypedEventInstance<WithdrawStake> {
+        data_decoded: WithdrawStake;
+        type_arguments: [];
+    }
     interface WithdrawStakeEvent {
         pool_address: MoveAddressType;
         amount_withdrawn: bigint;
@@ -1073,6 +1384,19 @@ export declare namespace object_ {
         const TYPE_QNAME = "0x1::object::TombStone";
         function type(): TypeDescriptor<TombStone>;
     }
+    interface Transfer {
+        object: MoveAddressType;
+        from: MoveAddressType;
+        to: MoveAddressType;
+    }
+    namespace Transfer {
+        const TYPE_QNAME = "0x1::object::Transfer";
+        function type(): TypeDescriptor<Transfer>;
+    }
+    interface TransferInstance extends TypedEventInstance<Transfer> {
+        data_decoded: Transfer;
+        type_arguments: [];
+    }
     interface TransferEvent {
         object: MoveAddressType;
         from: MoveAddressType;
@@ -1097,6 +1421,13 @@ export declare namespace object_ {
         data_decoded: TransferRef;
         type_arguments: [];
     }
+    interface Untransferable {
+        dummy_field: Boolean;
+    }
+    namespace Untransferable {
+        const TYPE_QNAME = "0x1::object::Untransferable";
+        function type(): TypeDescriptor<Untransferable>;
+    }
     namespace entry {
         function burn<T0 = any>(client: Aptos, account: AptosAccount, request: {
             typeArguments: [MoveStructId];
@@ -1124,6 +1455,10 @@ export declare namespace object_ {
             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]>;
     }
 }
 export declare namespace option {
@@ -1165,6 +1500,22 @@ export declare namespace vector {
     namespace view { }
 }
 export declare namespace voting {
+    interface CreateProposal {
+        proposal_id: bigint;
+        early_resolution_vote_threshold: option.Option<bigint>;
+        execution_hash: string;
+        expiration_secs: bigint;
+        metadata: simple_map.SimpleMap<string, string>;
+        min_vote_threshold: bigint;
+    }
+    namespace CreateProposal {
+        const TYPE_QNAME = "0x1::voting::CreateProposal";
+        function type(): TypeDescriptor<CreateProposal>;
+    }
+    interface CreateProposalInstance extends TypedEventInstance<CreateProposal> {
+        data_decoded: CreateProposal;
+        type_arguments: [];
+    }
     interface CreateProposalEvent {
         proposal_id: bigint;
         early_resolution_vote_threshold: option.Option<bigint>;
@@ -1199,6 +1550,18 @@ export declare namespace voting {
         const TYPE_QNAME = "0x1::voting::Proposal";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Proposal<T0>>;
     }
+    interface RegisterForum {
+        hosting_account: MoveAddressType;
+        proposal_type_info: type_info.TypeInfo;
+    }
+    namespace RegisterForum {
+        const TYPE_QNAME = "0x1::voting::RegisterForum";
+        function type(): TypeDescriptor<RegisterForum>;
+    }
+    interface RegisterForumInstance extends TypedEventInstance<RegisterForum> {
+        data_decoded: RegisterForum;
+        type_arguments: [];
+    }
     interface RegisterForumEvent {
         hosting_account: MoveAddressType;
         proposal_type_info: type_info.TypeInfo;
@@ -1225,6 +1588,18 @@ export declare namespace voting {
         data_decoded: ResolveProposal;
         type_arguments: [];
     }
+    interface Vote {
+        proposal_id: bigint;
+        num_votes: bigint;
+    }
+    namespace Vote {
+        const TYPE_QNAME = "0x1::voting::Vote";
+        function type(): TypeDescriptor<Vote>;
+    }
+    interface VoteInstance extends TypedEventInstance<Vote> {
+        data_decoded: Vote;
+        type_arguments: [];
+    }
     interface VoteEvent {
         proposal_id: bigint;
         num_votes: bigint;
@@ -1352,6 +1727,19 @@ export declare namespace account {
         data_decoded: CoinRegisterEvent;
         type_arguments: [];
     }
+    interface KeyRotation {
+        account: MoveAddressType;
+        old_authentication_key: string;
+        new_authentication_key: string;
+    }
+    namespace KeyRotation {
+        const TYPE_QNAME = "0x1::account::KeyRotation";
+        function type(): TypeDescriptor<KeyRotation>;
+    }
+    interface KeyRotationInstance extends TypedEventInstance<KeyRotation> {
+        data_decoded: KeyRotation;
+        type_arguments: [];
+    }
     interface KeyRotationEvent {
         old_authentication_key: string;
         new_authentication_key: string;
@@ -1639,6 +2027,19 @@ export declare namespace vesting {
         const TYPE_QNAME = "0x1::vesting::AdminStore";
         function type(): TypeDescriptor<AdminStore>;
     }
+    interface AdminWithdraw {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        amount: bigint;
+    }
+    namespace AdminWithdraw {
+        const TYPE_QNAME = "0x1::vesting::AdminWithdraw";
+        function type(): TypeDescriptor<AdminWithdraw>;
+    }
+    interface AdminWithdrawInstance extends TypedEventInstance<AdminWithdraw> {
+        data_decoded: AdminWithdraw;
+        type_arguments: [];
+    }
     interface AdminWithdrawEvent {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
@@ -1652,6 +2053,23 @@ export declare namespace vesting {
         data_decoded: AdminWithdrawEvent;
         type_arguments: [];
     }
+    interface CreateVestingContract {
+        operator: MoveAddressType;
+        voter: MoveAddressType;
+        grant_amount: bigint;
+        withdrawal_address: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
+        commission_percentage: bigint;
+    }
+    namespace CreateVestingContract {
+        const TYPE_QNAME = "0x1::vesting::CreateVestingContract";
+        function type(): TypeDescriptor<CreateVestingContract>;
+    }
+    interface CreateVestingContractInstance extends TypedEventInstance<CreateVestingContract> {
+        data_decoded: CreateVestingContract;
+        type_arguments: [];
+    }
     interface CreateVestingContractEvent {
         operator: MoveAddressType;
         voter: MoveAddressType;
@@ -1669,6 +2087,19 @@ export declare namespace vesting {
         data_decoded: CreateVestingContractEvent;
         type_arguments: [];
     }
+    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;
@@ -1682,6 +2113,20 @@ export declare namespace vesting {
         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;
@@ -1696,6 +2141,21 @@ export declare namespace vesting {
         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;
@@ -1721,6 +2181,18 @@ export declare namespace vesting {
         const TYPE_QNAME = "0x1::vesting::StakingInfo";
         function type(): TypeDescriptor<StakingInfo>;
     }
+    interface Terminate {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+    }
+    namespace Terminate {
+        const TYPE_QNAME = "0x1::vesting::Terminate";
+        function type(): TypeDescriptor<Terminate>;
+    }
+    interface TerminateInstance extends TypedEventInstance<Terminate> {
+        data_decoded: Terminate;
+        type_arguments: [];
+    }
     interface TerminateEvent {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
@@ -1733,6 +2205,20 @@ export declare namespace vesting {
         data_decoded: TerminateEvent;
         type_arguments: [];
     }
+    interface UnlockRewards {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
+        amount: bigint;
+    }
+    namespace UnlockRewards {
+        const TYPE_QNAME = "0x1::vesting::UnlockRewards";
+        function type(): TypeDescriptor<UnlockRewards>;
+    }
+    interface UnlockRewardsInstance extends TypedEventInstance<UnlockRewards> {
+        data_decoded: UnlockRewards;
+        type_arguments: [];
+    }
     interface UnlockRewardsEvent {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
@@ -1747,6 +2233,22 @@ export declare namespace vesting {
         data_decoded: UnlockRewardsEvent;
         type_arguments: [];
     }
+    interface UpdateOperator {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
+        old_operator: MoveAddressType;
+        new_operator: MoveAddressType;
+        commission_percentage: bigint;
+    }
+    namespace UpdateOperator {
+        const TYPE_QNAME = "0x1::vesting::UpdateOperator";
+        function type(): TypeDescriptor<UpdateOperator>;
+    }
+    interface UpdateOperatorInstance extends TypedEventInstance<UpdateOperator> {
+        data_decoded: UpdateOperator;
+        type_arguments: [];
+    }
     interface UpdateOperatorEvent {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
@@ -1763,6 +2265,21 @@ 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;
@@ -1778,6 +2295,21 @@ export declare namespace vesting {
         data_decoded: UpdateVoterEvent;
         type_arguments: [];
     }
+    interface Vest {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
+        period_vested: bigint;
+        amount: bigint;
+    }
+    namespace Vest {
+        const TYPE_QNAME = "0x1::vesting::Vest";
+        function type(): TypeDescriptor<Vest>;
+    }
+    interface VestInstance extends TypedEventInstance<Vest> {
+        data_decoded: Vest;
+        type_arguments: [];
+    }
     interface VestEvent {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
@@ -2645,6 +3177,18 @@ export declare namespace aggregator_v2 {
     namespace view { }
 }
 export declare namespace aptos_account {
+    interface DirectCoinTransferConfigUpdated {
+        account: MoveAddressType;
+        new_allow_direct_transfers: Boolean;
+    }
+    namespace DirectCoinTransferConfigUpdated {
+        const TYPE_QNAME = "0x1::aptos_account::DirectCoinTransferConfigUpdated";
+        function type(): TypeDescriptor<DirectCoinTransferConfigUpdated>;
+    }
+    interface DirectCoinTransferConfigUpdatedInstance extends TypedEventInstance<DirectCoinTransferConfigUpdated> {
+        data_decoded: DirectCoinTransferConfigUpdated;
+        type_arguments: [];
+    }
     interface DirectCoinTransferConfigUpdatedEvent {
         new_allow_direct_transfers: Boolean;
     }
@@ -2857,6 +3401,23 @@ export declare namespace fixed_point64 {
     namespace entry { }
     namespace view { }
 }
+export declare namespace function_info {
+    interface FunctionInfo {
+        module_address: MoveAddressType;
+        module_name: string;
+        function_name: string;
+    }
+    namespace FunctionInfo {
+        const TYPE_QNAME = "0x1::function_info::FunctionInfo";
+        function type(): TypeDescriptor<FunctionInfo>;
+    }
+    interface FunctionInfoInstance extends TypedEventInstance<FunctionInfo> {
+        data_decoded: FunctionInfo;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace multi_ed25519 {
     interface Signature {
         bytes: string;
@@ -2985,6 +3546,13 @@ export declare namespace fungible_asset {
         data_decoded: BurnRef;
         type_arguments: [];
     }
+    interface ConcurrentFungibleBalance {
+        balance: aggregator_v2.Aggregator<bigint>;
+    }
+    namespace ConcurrentFungibleBalance {
+        const TYPE_QNAME = "0x1::fungible_asset::ConcurrentFungibleBalance";
+        function type(): TypeDescriptor<ConcurrentFungibleBalance>;
+    }
     interface ConcurrentSupply {
         current: aggregator_v2.Aggregator<bigint>;
     }
@@ -2992,6 +3560,18 @@ export declare namespace fungible_asset {
         const TYPE_QNAME = "0x1::fungible_asset::ConcurrentSupply";
         function type(): TypeDescriptor<ConcurrentSupply>;
     }
+    interface Deposit {
+        store: MoveAddressType;
+        amount: bigint;
+    }
+    namespace Deposit {
+        const TYPE_QNAME = "0x1::fungible_asset::Deposit";
+        function type(): TypeDescriptor<Deposit>;
+    }
+    interface DepositInstance extends TypedEventInstance<Deposit> {
+        data_decoded: Deposit;
+        type_arguments: [];
+    }
     interface DepositEvent {
         amount: bigint;
     }
@@ -3003,6 +3583,27 @@ export declare namespace fungible_asset {
         data_decoded: DepositEvent;
         type_arguments: [];
     }
+    interface DispatchFunctionStore {
+        withdraw_function: option.Option<function_info.FunctionInfo>;
+        deposit_function: option.Option<function_info.FunctionInfo>;
+        derived_balance_function: option.Option<function_info.FunctionInfo>;
+    }
+    namespace DispatchFunctionStore {
+        const TYPE_QNAME = "0x1::fungible_asset::DispatchFunctionStore";
+        function type(): TypeDescriptor<DispatchFunctionStore>;
+    }
+    interface Frozen {
+        store: MoveAddressType;
+        frozen: Boolean;
+    }
+    namespace Frozen {
+        const TYPE_QNAME = "0x1::fungible_asset::Frozen";
+        function type(): TypeDescriptor<Frozen>;
+    }
+    interface FrozenInstance extends TypedEventInstance<Frozen> {
+        data_decoded: Frozen;
+        type_arguments: [];
+    }
     interface FrozenEvent {
         frozen: Boolean;
     }
@@ -3081,6 +3682,25 @@ export declare namespace fungible_asset {
         data_decoded: TransferRef;
         type_arguments: [];
     }
+    interface Untransferable {
+        dummy_field: Boolean;
+    }
+    namespace Untransferable {
+        const TYPE_QNAME = "0x1::fungible_asset::Untransferable";
+        function type(): TypeDescriptor<Untransferable>;
+    }
+    interface Withdraw {
+        store: MoveAddressType;
+        amount: bigint;
+    }
+    namespace Withdraw {
+        const TYPE_QNAME = "0x1::fungible_asset::Withdraw";
+        function type(): TypeDescriptor<Withdraw>;
+    }
+    interface WithdrawInstance extends TypedEventInstance<Withdraw> {
+        data_decoded: Withdraw;
+        type_arguments: [];
+    }
     interface WithdrawEvent {
         amount: bigint;
     }
@@ -3097,6 +3717,10 @@ export declare namespace fungible_asset {
             typeArguments: [MoveStructId];
             functionArguments: [object_.Object<T0>, object_.Object<T0>, bigint];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function upgradeStoreToConcurrent<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
         function balance<T0 = any>(client: Aptos, request: {
@@ -3107,10 +3731,22 @@ export declare namespace fungible_asset {
             typeArguments: [MoveStructId];
             functionArguments: [object_.Object<T0>];
         }, version?: bigint): Promise<[number]>;
+        function isBalanceAtLeast<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>, bigint];
+        }, version?: bigint): Promise<[Boolean]>;
         function isFrozen<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
             functionArguments: [object_.Object<T0>];
         }, version?: bigint): Promise<[Boolean]>;
+        function isStoreDispatchable<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[Boolean]>;
+        function isUntransferable<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[Boolean]>;
         function maximum<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
             functionArguments: [object_.Object<T0>];
@@ -3165,6 +3801,20 @@ export declare namespace staking_config {
     namespace view { }
 }
 export declare namespace delegation_pool {
+    interface AddStake {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+        amount_added: bigint;
+        add_stake_fee: bigint;
+    }
+    namespace AddStake {
+        const TYPE_QNAME = "0x1::delegation_pool::AddStake";
+        function type(): TypeDescriptor<AddStake>;
+    }
+    interface AddStakeInstance extends TypedEventInstance<AddStake> {
+        data_decoded: AddStake;
+        type_arguments: [];
+    }
     interface AddStakeEvent {
         pool_address: MoveAddressType;
         delegator_address: MoveAddressType;
@@ -3211,6 +3861,19 @@ 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;
@@ -3224,6 +3887,19 @@ export declare namespace delegation_pool {
         data_decoded: CreateProposalEvent;
         type_arguments: [];
     }
+    interface DelegateVotingPower {
+        pool_address: MoveAddressType;
+        delegator: MoveAddressType;
+        voter: MoveAddressType;
+    }
+    namespace DelegateVotingPower {
+        const TYPE_QNAME = "0x1::delegation_pool::DelegateVotingPower";
+        function type(): TypeDescriptor<DelegateVotingPower>;
+    }
+    interface DelegateVotingPowerInstance extends TypedEventInstance<DelegateVotingPower> {
+        data_decoded: DelegateVotingPower;
+        type_arguments: [];
+    }
     interface DelegateVotingPowerEvent {
         pool_address: MoveAddressType;
         delegator: MoveAddressType;
@@ -3374,8 +4050,21 @@ export declare namespace delegation_pool {
         const TYPE_QNAME = "0x1::delegation_pool::ObservedLockupCycle";
         function type(): TypeDescriptor<ObservedLockupCycle>;
     }
-    interface ObservedLockupCycleInstance extends TypedEventInstance<ObservedLockupCycle> {
-        data_decoded: ObservedLockupCycle;
+    interface ObservedLockupCycleInstance extends TypedEventInstance<ObservedLockupCycle> {
+        data_decoded: ObservedLockupCycle;
+        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 {
@@ -3416,6 +4105,19 @@ 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;
@@ -3429,6 +4131,21 @@ export declare namespace delegation_pool {
         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;
@@ -3469,6 +4186,19 @@ export declare namespace delegation_pool {
         data_decoded: VotingRecordKey;
         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;
@@ -3576,6 +4306,9 @@ export declare namespace delegation_pool {
         function calculateAndUpdateVoterTotalVotingPower(client: Aptos, request: {
             functionArguments: [MoveAddressType, MoveAddressType];
         }, version?: bigint): Promise<[bigint]>;
+        function calculateAndUpdateVotingDelegation(client: Aptos, request: {
+            functionArguments: [MoveAddressType, MoveAddressType];
+        }, version?: bigint): Promise<[MoveAddressType, MoveAddressType, bigint]>;
         function canWithdrawPendingInactive(client: Aptos, request: {
             functionArguments: [MoveAddressType];
         }, version?: bigint): Promise<[Boolean]>;
@@ -3645,6 +4378,10 @@ export declare namespace keyless_account {
         const TYPE_QNAME = "0x1::keyless_account::Configuration";
         function type(): TypeDescriptor<Configuration>;
     }
+    interface ConfigurationInstance extends TypedEventInstance<Configuration> {
+        data_decoded: Configuration;
+        type_arguments: [];
+    }
     interface Groth16VerificationKey {
         alpha_g1: string;
         beta_g2: string;
@@ -3656,6 +4393,10 @@ export declare namespace keyless_account {
         const TYPE_QNAME = "0x1::keyless_account::Groth16VerificationKey";
         function type(): TypeDescriptor<Groth16VerificationKey>;
     }
+    interface Groth16VerificationKeyInstance extends TypedEventInstance<Groth16VerificationKey> {
+        data_decoded: Groth16VerificationKey;
+        type_arguments: [];
+    }
     interface Group {
         dummy_field: Boolean;
     }
@@ -3683,6 +4424,17 @@ export declare namespace reconfiguration {
         const TYPE_QNAME = "0x1::reconfiguration::DisableReconfiguration";
         function type(): TypeDescriptor<DisableReconfiguration>;
     }
+    interface NewEpoch {
+        epoch: bigint;
+    }
+    namespace NewEpoch {
+        const TYPE_QNAME = "0x1::reconfiguration::NewEpoch";
+        function type(): TypeDescriptor<NewEpoch>;
+    }
+    interface NewEpochInstance extends TypedEventInstance<NewEpoch> {
+        data_decoded: NewEpoch;
+        type_arguments: [];
+    }
     interface NewEpochEvent {
         epoch: bigint;
     }
@@ -3712,6 +4464,13 @@ export declare namespace transaction_fee {
         const TYPE_QNAME = "0x1::transaction_fee::AptosCoinMintCapability";
         function type(): TypeDescriptor<AptosCoinMintCapability>;
     }
+    interface AptosFABurnCapabilities {
+        burn_ref: fungible_asset.BurnRef;
+    }
+    namespace AptosFABurnCapabilities {
+        const TYPE_QNAME = "0x1::transaction_fee::AptosFABurnCapabilities";
+        function type(): TypeDescriptor<AptosFABurnCapabilities>;
+    }
     interface CollectedFeesPerBlock {
         amount: coin.AggregatableCoin<aptos_coin.AptosCoin>;
         proposer: option.Option<MoveAddressType>;
@@ -3736,7 +4495,12 @@ export declare namespace transaction_fee {
         data_decoded: FeeStatement;
         type_arguments: [];
     }
-    namespace entry { }
+    namespace entry {
+        function convertToAptosFaBurnRef(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
     namespace view { }
 }
 export declare namespace aptos_governance {
@@ -3747,6 +4511,21 @@ export declare namespace aptos_governance {
         const TYPE_QNAME = "0x1::aptos_governance::ApprovedExecutionHashes";
         function type(): TypeDescriptor<ApprovedExecutionHashes>;
     }
+    interface CreateProposal {
+        proposer: MoveAddressType;
+        stake_pool: MoveAddressType;
+        proposal_id: bigint;
+        execution_hash: string;
+        proposal_metadata: simple_map.SimpleMap<string, string>;
+    }
+    namespace CreateProposal {
+        const TYPE_QNAME = "0x1::aptos_governance::CreateProposal";
+        function type(): TypeDescriptor<CreateProposal>;
+    }
+    interface CreateProposalInstance extends TypedEventInstance<CreateProposal> {
+        data_decoded: CreateProposal;
+        type_arguments: [];
+    }
     interface CreateProposalEvent {
         proposer: MoveAddressType;
         stake_pool: MoveAddressType;
@@ -3799,6 +4578,19 @@ export declare namespace aptos_governance {
         data_decoded: RecordKey;
         type_arguments: [];
     }
+    interface UpdateConfig {
+        min_voting_threshold: bigint;
+        required_proposer_stake: bigint;
+        voting_duration_secs: bigint;
+    }
+    namespace UpdateConfig {
+        const TYPE_QNAME = "0x1::aptos_governance::UpdateConfig";
+        function type(): TypeDescriptor<UpdateConfig>;
+    }
+    interface UpdateConfigInstance extends TypedEventInstance<UpdateConfig> {
+        data_decoded: UpdateConfig;
+        type_arguments: [];
+    }
     interface UpdateConfigEvent {
         min_voting_threshold: bigint;
         required_proposer_stake: bigint;
@@ -3812,6 +4604,21 @@ 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;
@@ -4030,6 +4837,18 @@ export declare namespace execution_config {
     namespace view { }
 }
 export declare namespace multisig_account {
+    interface AddOwners {
+        multisig_account: MoveAddressType;
+        owners_added: MoveAddressType[];
+    }
+    namespace AddOwners {
+        const TYPE_QNAME = "0x1::multisig_account::AddOwners";
+        function type(): TypeDescriptor<AddOwners>;
+    }
+    interface AddOwnersInstance extends TypedEventInstance<AddOwners> {
+        data_decoded: AddOwners;
+        type_arguments: [];
+    }
     interface AddOwnersEvent {
         owners_added: MoveAddressType[];
     }
@@ -4041,6 +4860,20 @@ export declare namespace multisig_account {
         data_decoded: AddOwnersEvent;
         type_arguments: [];
     }
+    interface CreateTransaction {
+        multisig_account: MoveAddressType;
+        creator: MoveAddressType;
+        sequence_number: bigint;
+        transaction: multisig_account.MultisigTransaction;
+    }
+    namespace CreateTransaction {
+        const TYPE_QNAME = "0x1::multisig_account::CreateTransaction";
+        function type(): TypeDescriptor<CreateTransaction>;
+    }
+    interface CreateTransactionInstance extends TypedEventInstance<CreateTransaction> {
+        data_decoded: CreateTransaction;
+        type_arguments: [];
+    }
     interface CreateTransactionEvent {
         creator: MoveAddressType;
         sequence_number: bigint;
@@ -4054,6 +4887,20 @@ export declare namespace multisig_account {
         data_decoded: CreateTransactionEvent;
         type_arguments: [];
     }
+    interface ExecuteRejectedTransaction {
+        multisig_account: MoveAddressType;
+        sequence_number: bigint;
+        num_rejections: bigint;
+        executor: MoveAddressType;
+    }
+    namespace ExecuteRejectedTransaction {
+        const TYPE_QNAME = "0x1::multisig_account::ExecuteRejectedTransaction";
+        function type(): TypeDescriptor<ExecuteRejectedTransaction>;
+    }
+    interface ExecuteRejectedTransactionInstance extends TypedEventInstance<ExecuteRejectedTransaction> {
+        data_decoded: ExecuteRejectedTransaction;
+        type_arguments: [];
+    }
     interface ExecuteRejectedTransactionEvent {
         sequence_number: bigint;
         num_rejections: bigint;
@@ -4080,6 +4927,19 @@ export declare namespace multisig_account {
         data_decoded: ExecutionError;
         type_arguments: [];
     }
+    interface MetadataUpdated {
+        multisig_account: MoveAddressType;
+        old_metadata: simple_map.SimpleMap<string, string>;
+        new_metadata: simple_map.SimpleMap<string, string>;
+    }
+    namespace MetadataUpdated {
+        const TYPE_QNAME = "0x1::multisig_account::MetadataUpdated";
+        function type(): TypeDescriptor<MetadataUpdated>;
+    }
+    interface MetadataUpdatedInstance extends TypedEventInstance<MetadataUpdated> {
+        data_decoded: MetadataUpdated;
+        type_arguments: [];
+    }
     interface MetadataUpdatedEvent {
         old_metadata: simple_map.SimpleMap<string, string>;
         new_metadata: simple_map.SimpleMap<string, string>;
@@ -4151,6 +5011,18 @@ export declare namespace multisig_account {
         data_decoded: MultisigTransaction;
         type_arguments: [];
     }
+    interface RemoveOwners {
+        multisig_account: MoveAddressType;
+        owners_removed: MoveAddressType[];
+    }
+    namespace RemoveOwners {
+        const TYPE_QNAME = "0x1::multisig_account::RemoveOwners";
+        function type(): TypeDescriptor<RemoveOwners>;
+    }
+    interface RemoveOwnersInstance extends TypedEventInstance<RemoveOwners> {
+        data_decoded: RemoveOwners;
+        type_arguments: [];
+    }
     interface RemoveOwnersEvent {
         owners_removed: MoveAddressType[];
     }
@@ -4162,6 +5034,22 @@ export declare namespace multisig_account {
         data_decoded: RemoveOwnersEvent;
         type_arguments: [];
     }
+    interface TransactionExecutionFailed {
+        multisig_account: MoveAddressType;
+        executor: MoveAddressType;
+        sequence_number: bigint;
+        transaction_payload: string;
+        num_approvals: bigint;
+        execution_error: multisig_account.ExecutionError;
+    }
+    namespace TransactionExecutionFailed {
+        const TYPE_QNAME = "0x1::multisig_account::TransactionExecutionFailed";
+        function type(): TypeDescriptor<TransactionExecutionFailed>;
+    }
+    interface TransactionExecutionFailedInstance extends TypedEventInstance<TransactionExecutionFailed> {
+        data_decoded: TransactionExecutionFailed;
+        type_arguments: [];
+    }
     interface TransactionExecutionFailedEvent {
         executor: MoveAddressType;
         sequence_number: bigint;
@@ -4177,6 +5065,21 @@ export declare namespace multisig_account {
         data_decoded: TransactionExecutionFailedEvent;
         type_arguments: [];
     }
+    interface TransactionExecutionSucceeded {
+        multisig_account: MoveAddressType;
+        executor: MoveAddressType;
+        sequence_number: bigint;
+        transaction_payload: string;
+        num_approvals: bigint;
+    }
+    namespace TransactionExecutionSucceeded {
+        const TYPE_QNAME = "0x1::multisig_account::TransactionExecutionSucceeded";
+        function type(): TypeDescriptor<TransactionExecutionSucceeded>;
+    }
+    interface TransactionExecutionSucceededInstance extends TypedEventInstance<TransactionExecutionSucceeded> {
+        data_decoded: TransactionExecutionSucceeded;
+        type_arguments: [];
+    }
     interface TransactionExecutionSucceededEvent {
         executor: MoveAddressType;
         sequence_number: bigint;
@@ -4191,6 +5094,19 @@ export declare namespace multisig_account {
         data_decoded: TransactionExecutionSucceededEvent;
         type_arguments: [];
     }
+    interface UpdateSignaturesRequired {
+        multisig_account: MoveAddressType;
+        old_num_signatures_required: bigint;
+        new_num_signatures_required: bigint;
+    }
+    namespace UpdateSignaturesRequired {
+        const TYPE_QNAME = "0x1::multisig_account::UpdateSignaturesRequired";
+        function type(): TypeDescriptor<UpdateSignaturesRequired>;
+    }
+    interface UpdateSignaturesRequiredInstance extends TypedEventInstance<UpdateSignaturesRequired> {
+        data_decoded: UpdateSignaturesRequired;
+        type_arguments: [];
+    }
     interface UpdateSignaturesRequiredEvent {
         old_num_signatures_required: bigint;
         new_num_signatures_required: bigint;
@@ -4203,6 +5119,20 @@ 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;
@@ -4422,6 +5352,19 @@ export declare namespace resource_account {
     namespace view { }
 }
 export declare namespace staking_contract {
+    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;
@@ -4435,6 +5378,19 @@ export declare namespace staking_contract {
         data_decoded: AddDistributionEvent;
         type_arguments: [];
     }
+    interface AddStake {
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
+        amount: bigint;
+    }
+    namespace AddStake {
+        const TYPE_QNAME = "0x1::staking_contract::AddStake";
+        function type(): TypeDescriptor<AddStake>;
+    }
+    interface AddStakeInstance extends TypedEventInstance<AddStake> {
+        data_decoded: AddStake;
+        type_arguments: [];
+    }
     interface AddStakeEvent {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
@@ -4455,6 +5411,21 @@ export declare namespace staking_contract {
         const TYPE_QNAME = "0x1::staking_contract::BeneficiaryForOperator";
         function type(): TypeDescriptor<BeneficiaryForOperator>;
     }
+    interface CreateStakingContract {
+        operator: MoveAddressType;
+        voter: MoveAddressType;
+        pool_address: MoveAddressType;
+        principal: bigint;
+        commission_percentage: bigint;
+    }
+    namespace CreateStakingContract {
+        const TYPE_QNAME = "0x1::staking_contract::CreateStakingContract";
+        function type(): TypeDescriptor<CreateStakingContract>;
+    }
+    interface CreateStakingContractInstance extends TypedEventInstance<CreateStakingContract> {
+        data_decoded: CreateStakingContract;
+        type_arguments: [];
+    }
     interface CreateStakingContractEvent {
         operator: MoveAddressType;
         voter: MoveAddressType;
@@ -4470,6 +5441,20 @@ export declare namespace staking_contract {
         data_decoded: CreateStakingContractEvent;
         type_arguments: [];
     }
+    interface Distribute {
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
+        recipient: MoveAddressType;
+        amount: bigint;
+    }
+    namespace Distribute {
+        const TYPE_QNAME = "0x1::staking_contract::Distribute";
+        function type(): TypeDescriptor<Distribute>;
+    }
+    interface DistributeInstance extends TypedEventInstance<Distribute> {
+        data_decoded: Distribute;
+        type_arguments: [];
+    }
     interface DistributeEvent {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
@@ -4484,6 +5469,20 @@ export declare namespace staking_contract {
         data_decoded: DistributeEvent;
         type_arguments: [];
     }
+    interface RequestCommission {
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
+        accumulated_rewards: bigint;
+        commission_amount: bigint;
+    }
+    namespace RequestCommission {
+        const TYPE_QNAME = "0x1::staking_contract::RequestCommission";
+        function type(): TypeDescriptor<RequestCommission>;
+    }
+    interface RequestCommissionInstance extends TypedEventInstance<RequestCommission> {
+        data_decoded: RequestCommission;
+        type_arguments: [];
+    }
     interface RequestCommissionEvent {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
@@ -4498,6 +5497,18 @@ export declare namespace staking_contract {
         data_decoded: RequestCommissionEvent;
         type_arguments: [];
     }
+    interface ResetLockup {
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
+    }
+    namespace ResetLockup {
+        const TYPE_QNAME = "0x1::staking_contract::ResetLockup";
+        function type(): TypeDescriptor<ResetLockup>;
+    }
+    interface ResetLockupInstance extends TypedEventInstance<ResetLockup> {
+        data_decoded: ResetLockup;
+        type_arguments: [];
+    }
     interface ResetLockupEvent {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
@@ -4565,6 +5576,19 @@ export declare namespace staking_contract {
         const TYPE_QNAME = "0x1::staking_contract::Store";
         function type(): TypeDescriptor<Store>;
     }
+    interface SwitchOperator {
+        old_operator: MoveAddressType;
+        new_operator: MoveAddressType;
+        pool_address: MoveAddressType;
+    }
+    namespace SwitchOperator {
+        const TYPE_QNAME = "0x1::staking_contract::SwitchOperator";
+        function type(): TypeDescriptor<SwitchOperator>;
+    }
+    interface SwitchOperatorInstance extends TypedEventInstance<SwitchOperator> {
+        data_decoded: SwitchOperator;
+        type_arguments: [];
+    }
     interface SwitchOperatorEvent {
         old_operator: MoveAddressType;
         new_operator: MoveAddressType;
@@ -4578,6 +5602,20 @@ 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;
@@ -4592,6 +5630,20 @@ export declare namespace staking_contract {
         data_decoded: UnlockStakeEvent;
         type_arguments: [];
     }
+    interface UpdateCommission {
+        staker: MoveAddressType;
+        operator: MoveAddressType;
+        old_commission_percentage: bigint;
+        new_commission_percentage: bigint;
+    }
+    namespace UpdateCommission {
+        const TYPE_QNAME = "0x1::staking_contract::UpdateCommission";
+        function type(): TypeDescriptor<UpdateCommission>;
+    }
+    interface UpdateCommissionInstance extends TypedEventInstance<UpdateCommission> {
+        data_decoded: UpdateCommission;
+        type_arguments: [];
+    }
     interface UpdateCommissionEvent {
         staker: MoveAddressType;
         operator: MoveAddressType;
@@ -4606,6 +5658,20 @@ export declare namespace staking_contract {
         data_decoded: UpdateCommissionEvent;
         type_arguments: [];
     }
+    interface UpdateVoter {
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
+        old_voter: MoveAddressType;
+        new_voter: MoveAddressType;
+    }
+    namespace UpdateVoter {
+        const TYPE_QNAME = "0x1::staking_contract::UpdateVoter";
+        function type(): TypeDescriptor<UpdateVoter>;
+    }
+    interface UpdateVoterInstance extends TypedEventInstance<UpdateVoter> {
+        data_decoded: UpdateVoter;
+        type_arguments: [];
+    }
     interface UpdateVoterEvent {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
@@ -4828,6 +5894,25 @@ export declare namespace transaction_context {
         data_decoded: AUID;
         type_arguments: [];
     }
+    interface EntryFunctionPayload {
+        account_address: MoveAddressType;
+        module_name: string;
+        function_name: string;
+        ty_args_names: string[];
+        args: string[];
+    }
+    namespace EntryFunctionPayload {
+        const TYPE_QNAME = "0x1::transaction_context::EntryFunctionPayload";
+        function type(): TypeDescriptor<EntryFunctionPayload>;
+    }
+    interface MultisigPayload {
+        multisig_address: MoveAddressType;
+        entry_function_payload: option.Option<transaction_context.EntryFunctionPayload>;
+    }
+    namespace MultisigPayload {
+        const TYPE_QNAME = "0x1::transaction_context::MultisigPayload";
+        function type(): TypeDescriptor<MultisigPayload>;
+    }
     namespace entry { }
     namespace view { }
 }
@@ -5033,12 +6118,25 @@ export declare namespace primary_fungible_store {
             typeArguments: [MoveStructId];
             functionArguments: [object_.Object<T0>, MoveAddressType, bigint];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function transferAssertMinimumDeposit<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [
+                object_.Object<T0>,
+                MoveAddressType,
+                bigint,
+                bigint
+            ];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
     }
     namespace view {
         function balance<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
             functionArguments: [MoveAddressType, object_.Object<T0>];
         }, version?: bigint): Promise<[bigint]>;
+        function isBalanceAtLeast<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [MoveAddressType, object_.Object<T0>, bigint];
+        }, version?: bigint): Promise<[Boolean]>;
         function isFrozen<T0 = any>(client: Aptos, request: {
             typeArguments: [MoveStructId];
             functionArguments: [MoveAddressType, object_.Object<T0>];
@@ -5073,6 +6171,47 @@ export declare namespace transaction_validation {
     namespace entry { }
     namespace view { }
 }
+export declare namespace randomness_api_v0_config {
+    interface AllowCustomMaxGasFlag {
+        value: Boolean;
+    }
+    namespace AllowCustomMaxGasFlag {
+        const TYPE_QNAME = "0x1::randomness_api_v0_config::AllowCustomMaxGasFlag";
+        function type(): TypeDescriptor<AllowCustomMaxGasFlag>;
+    }
+    interface AllowCustomMaxGasFlagInstance extends TypedEventInstance<AllowCustomMaxGasFlag> {
+        data_decoded: AllowCustomMaxGasFlag;
+        type_arguments: [];
+    }
+    interface RequiredGasDeposit {
+        gas_amount: option.Option<bigint>;
+    }
+    namespace RequiredGasDeposit {
+        const TYPE_QNAME = "0x1::randomness_api_v0_config::RequiredGasDeposit";
+        function type(): TypeDescriptor<RequiredGasDeposit>;
+    }
+    interface RequiredGasDepositInstance extends TypedEventInstance<RequiredGasDeposit> {
+        data_decoded: RequiredGasDeposit;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace randomness_config_seqnum {
+    interface RandomnessConfigSeqNum {
+        seq_num: bigint;
+    }
+    namespace RandomnessConfigSeqNum {
+        const TYPE_QNAME = "0x1::randomness_config_seqnum::RandomnessConfigSeqNum";
+        function type(): TypeDescriptor<RandomnessConfigSeqNum>;
+    }
+    interface RandomnessConfigSeqNumInstance extends TypedEventInstance<RandomnessConfigSeqNum> {
+        data_decoded: RandomnessConfigSeqNum;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace reconfiguration_with_dkg {
     namespace entry { }
     namespace view { }
@@ -5109,5 +6248,35 @@ export declare namespace ristretto255_bulletproofs {
     namespace entry { }
     namespace view { }
 }
+export declare namespace dispatchable_fungible_asset {
+    interface TransferRefStore {
+        transfer_ref: fungible_asset.TransferRef;
+    }
+    namespace TransferRefStore {
+        const TYPE_QNAME = "0x1::dispatchable_fungible_asset::TransferRefStore";
+        function type(): TypeDescriptor<TransferRefStore>;
+    }
+    namespace entry {
+        function transfer<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>, object_.Object<T0>, bigint];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function transferAssertMinimumDeposit<T0 = any>(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [
+                object_.Object<T0>,
+                object_.Object<T0>,
+                bigint,
+                bigint
+            ];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view {
+        function derivedBalance<T0 = any>(client: Aptos, request: {
+            typeArguments: [MoveStructId];
+            functionArguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[bigint]>;
+    }
+}
 export declare function loadAllTypes(coder: MoveCoder): void;
 //# sourceMappingURL=0x1.d.ts.map