@typemove/aptos 1.2.4-rc.1 → 1.2.4-rc3

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

@@ -0,0 +1,3796 @@
+import { TypeDescriptor } from "@typemove/move";
+import { MoveCoder, TypedEventInstance } from "@typemove/aptos";
+import { Address } from "@typemove/aptos";
+import { AptosClient, AptosAccount, Types, OptionalTransactionArgs } from "aptos";
+export declare namespace acl {
+    interface ACL {
+        list: Address[];
+    }
+    namespace ACL {
+        const TYPE_QNAME = "0x1::acl::ACL";
+        function type(): TypeDescriptor<ACL>;
+    }
+    interface ACLInstance extends TypedEventInstance<ACL> {
+        data_decoded: ACL;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace any_ {
+    interface Any {
+        type_name: string;
+        data: string;
+    }
+    namespace Any {
+        const TYPE_QNAME = "0x1::any::Any";
+        function type(): TypeDescriptor<Any>;
+    }
+    interface AnyInstance extends TypedEventInstance<Any> {
+        data_decoded: Any;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace bcs {
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace code {
+    interface AllowedDep {
+        account: Address;
+        module_name: string;
+    }
+    namespace AllowedDep {
+        const TYPE_QNAME = "0x1::code::AllowedDep";
+        function type(): TypeDescriptor<AllowedDep>;
+    }
+    interface ModuleMetadata {
+        name: string;
+        source: string;
+        source_map: string;
+        extension: option.Option<copyable_any.Any>;
+    }
+    namespace ModuleMetadata {
+        const TYPE_QNAME = "0x1::code::ModuleMetadata";
+        function type(): TypeDescriptor<ModuleMetadata>;
+    }
+    interface ModuleMetadataInstance extends TypedEventInstance<ModuleMetadata> {
+        data_decoded: ModuleMetadata;
+        type_arguments: [];
+    }
+    interface PackageDep {
+        account: Address;
+        package_name: string;
+    }
+    namespace PackageDep {
+        const TYPE_QNAME = "0x1::code::PackageDep";
+        function type(): TypeDescriptor<PackageDep>;
+    }
+    interface PackageDepInstance extends TypedEventInstance<PackageDep> {
+        data_decoded: PackageDep;
+        type_arguments: [];
+    }
+    interface PackageMetadata {
+        name: string;
+        upgrade_policy: code.UpgradePolicy;
+        upgrade_number: bigint;
+        source_digest: string;
+        manifest: string;
+        modules: code.ModuleMetadata[];
+        deps: code.PackageDep[];
+        extension: option.Option<copyable_any.Any>;
+    }
+    namespace PackageMetadata {
+        const TYPE_QNAME = "0x1::code::PackageMetadata";
+        function type(): TypeDescriptor<PackageMetadata>;
+    }
+    interface PackageMetadataInstance extends TypedEventInstance<PackageMetadata> {
+        data_decoded: PackageMetadata;
+        type_arguments: [];
+    }
+    interface PackageRegistry {
+        packages: code.PackageMetadata[];
+    }
+    namespace PackageRegistry {
+        const TYPE_QNAME = "0x1::code::PackageRegistry";
+        function type(): TypeDescriptor<PackageRegistry>;
+    }
+    interface PackageRegistryInstance extends TypedEventInstance<PackageRegistry> {
+        data_decoded: PackageRegistry;
+        type_arguments: [];
+    }
+    interface UpgradePolicy {
+        policy: number;
+    }
+    namespace UpgradePolicy {
+        const TYPE_QNAME = "0x1::code::UpgradePolicy";
+        function type(): TypeDescriptor<UpgradePolicy>;
+    }
+    interface UpgradePolicyInstance extends TypedEventInstance<UpgradePolicy> {
+        data_decoded: UpgradePolicy;
+        type_arguments: [];
+    }
+    namespace entry {
+        function publishPackageTxn(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [string, string[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
+    namespace view { }
+}
+export declare namespace coin {
+    interface AggregatableCoin<T0> {
+        value: aggregator.Aggregator;
+    }
+    namespace AggregatableCoin {
+        const TYPE_QNAME = "0x1::coin::AggregatableCoin";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<AggregatableCoin<T0>>;
+    }
+    interface BurnCapability<T0> {
+        dummy_field: Boolean;
+    }
+    namespace BurnCapability {
+        const TYPE_QNAME = "0x1::coin::BurnCapability";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<BurnCapability<T0>>;
+    }
+    interface Coin<T0> {
+        value: bigint;
+    }
+    namespace Coin {
+        const TYPE_QNAME = "0x1::coin::Coin";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Coin<T0>>;
+    }
+    interface CoinInfo<T0> {
+        name: string;
+        symbol: string;
+        decimals: number;
+        supply: option.Option<optional_aggregator.OptionalAggregator>;
+    }
+    namespace CoinInfo {
+        const TYPE_QNAME = "0x1::coin::CoinInfo";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<CoinInfo<T0>>;
+    }
+    interface CoinStore<T0> {
+        coin: coin.Coin<T0>;
+        frozen: Boolean;
+        deposit_events: event.EventHandle<coin.DepositEvent>;
+        withdraw_events: event.EventHandle<coin.WithdrawEvent>;
+    }
+    namespace CoinStore {
+        const TYPE_QNAME = "0x1::coin::CoinStore";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<CoinStore<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;
+    }
+    namespace FreezeCapability {
+        const TYPE_QNAME = "0x1::coin::FreezeCapability";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<FreezeCapability<T0>>;
+    }
+    interface MintCapability<T0> {
+        dummy_field: Boolean;
+    }
+    namespace MintCapability {
+        const TYPE_QNAME = "0x1::coin::MintCapability";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<MintCapability<T0>>;
+    }
+    interface SupplyConfig {
+        allow_upgrades: Boolean;
+    }
+    namespace SupplyConfig {
+        const TYPE_QNAME = "0x1::coin::SupplyConfig";
+        function type(): TypeDescriptor<SupplyConfig>;
+    }
+    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 freezeCoinStore<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function transfer<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function unfreezeCoinStore<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function upgradeSupply<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
+    namespace view {
+        function balance<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function decimals<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+        }, version?: bigint): Promise<[number]>;
+        function isAccountRegistered<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
+        function isCoinInitialized<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+        }, version?: bigint): Promise<[Boolean]>;
+        function name<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+        }, version?: bigint): Promise<[string]>;
+        function supply<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+        }, version?: bigint): Promise<[option.Option<bigint>]>;
+        function symbol<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+        }, version?: bigint): Promise<[string]>;
+    }
+}
+export declare namespace guid {
+    interface GUID {
+        id: guid.ID;
+    }
+    namespace GUID {
+        const TYPE_QNAME = "0x1::guid::GUID";
+        function type(): TypeDescriptor<GUID>;
+    }
+    interface GUIDInstance extends TypedEventInstance<GUID> {
+        data_decoded: GUID;
+        type_arguments: [];
+    }
+    interface ID {
+        creation_num: bigint;
+        addr: Address;
+    }
+    namespace ID {
+        const TYPE_QNAME = "0x1::guid::ID";
+        function type(): TypeDescriptor<ID>;
+    }
+    interface IDInstance extends TypedEventInstance<ID> {
+        data_decoded: ID;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace hash {
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace util {
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace block {
+    interface BlockResource {
+        height: bigint;
+        epoch_interval: bigint;
+        new_block_events: event.EventHandle<block.NewBlockEvent>;
+        update_epoch_interval_events: event.EventHandle<block.UpdateEpochIntervalEvent>;
+    }
+    namespace BlockResource {
+        const TYPE_QNAME = "0x1::block::BlockResource";
+        function type(): TypeDescriptor<BlockResource>;
+    }
+    interface NewBlockEvent {
+        hash: Address;
+        epoch: bigint;
+        round: bigint;
+        height: bigint;
+        previous_block_votes_bitvec: string;
+        proposer: Address;
+        failed_proposer_indices: bigint[];
+        time_microseconds: bigint;
+    }
+    namespace NewBlockEvent {
+        const TYPE_QNAME = "0x1::block::NewBlockEvent";
+        function type(): TypeDescriptor<NewBlockEvent>;
+    }
+    interface NewBlockEventInstance extends TypedEventInstance<NewBlockEvent> {
+        data_decoded: NewBlockEvent;
+        type_arguments: [];
+    }
+    interface UpdateEpochIntervalEvent {
+        old_epoch_interval: bigint;
+        new_epoch_interval: bigint;
+    }
+    namespace UpdateEpochIntervalEvent {
+        const TYPE_QNAME = "0x1::block::UpdateEpochIntervalEvent";
+        function type(): TypeDescriptor<UpdateEpochIntervalEvent>;
+    }
+    interface UpdateEpochIntervalEventInstance extends TypedEventInstance<UpdateEpochIntervalEvent> {
+        data_decoded: UpdateEpochIntervalEvent;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view {
+        function getCurrentBlockHeight(client: AptosClient, version?: bigint): Promise<[bigint]>;
+        function getEpochIntervalSecs(client: AptosClient, version?: bigint): Promise<[bigint]>;
+    }
+}
+export declare namespace debug {
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace error {
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace event {
+    interface EventHandle<T0> {
+        counter: bigint;
+        guid: guid.GUID;
+    }
+    namespace EventHandle {
+        const TYPE_QNAME = "0x1::event::EventHandle";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<EventHandle<T0>>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace stake {
+    interface AddStakeEvent {
+        pool_address: Address;
+        amount_added: bigint;
+    }
+    namespace AddStakeEvent {
+        const TYPE_QNAME = "0x1::stake::AddStakeEvent";
+        function type(): TypeDescriptor<AddStakeEvent>;
+    }
+    interface AddStakeEventInstance extends TypedEventInstance<AddStakeEvent> {
+        data_decoded: AddStakeEvent;
+        type_arguments: [];
+    }
+    interface AllowedValidators {
+        accounts: Address[];
+    }
+    namespace AllowedValidators {
+        const TYPE_QNAME = "0x1::stake::AllowedValidators";
+        function type(): TypeDescriptor<AllowedValidators>;
+    }
+    interface AptosCoinCapabilities {
+        mint_cap: coin.MintCapability<aptos_coin.AptosCoin>;
+    }
+    namespace AptosCoinCapabilities {
+        const TYPE_QNAME = "0x1::stake::AptosCoinCapabilities";
+        function type(): TypeDescriptor<AptosCoinCapabilities>;
+    }
+    interface DistributeRewardsEvent {
+        pool_address: Address;
+        rewards_amount: bigint;
+    }
+    namespace DistributeRewardsEvent {
+        const TYPE_QNAME = "0x1::stake::DistributeRewardsEvent";
+        function type(): TypeDescriptor<DistributeRewardsEvent>;
+    }
+    interface DistributeRewardsEventInstance extends TypedEventInstance<DistributeRewardsEvent> {
+        data_decoded: DistributeRewardsEvent;
+        type_arguments: [];
+    }
+    interface IncreaseLockupEvent {
+        pool_address: Address;
+        old_locked_until_secs: bigint;
+        new_locked_until_secs: bigint;
+    }
+    namespace IncreaseLockupEvent {
+        const TYPE_QNAME = "0x1::stake::IncreaseLockupEvent";
+        function type(): TypeDescriptor<IncreaseLockupEvent>;
+    }
+    interface IncreaseLockupEventInstance extends TypedEventInstance<IncreaseLockupEvent> {
+        data_decoded: IncreaseLockupEvent;
+        type_arguments: [];
+    }
+    interface IndividualValidatorPerformance {
+        successful_proposals: bigint;
+        failed_proposals: bigint;
+    }
+    namespace IndividualValidatorPerformance {
+        const TYPE_QNAME = "0x1::stake::IndividualValidatorPerformance";
+        function type(): TypeDescriptor<IndividualValidatorPerformance>;
+    }
+    interface IndividualValidatorPerformanceInstance extends TypedEventInstance<IndividualValidatorPerformance> {
+        data_decoded: IndividualValidatorPerformance;
+        type_arguments: [];
+    }
+    interface JoinValidatorSetEvent {
+        pool_address: Address;
+    }
+    namespace JoinValidatorSetEvent {
+        const TYPE_QNAME = "0x1::stake::JoinValidatorSetEvent";
+        function type(): TypeDescriptor<JoinValidatorSetEvent>;
+    }
+    interface JoinValidatorSetEventInstance extends TypedEventInstance<JoinValidatorSetEvent> {
+        data_decoded: JoinValidatorSetEvent;
+        type_arguments: [];
+    }
+    interface LeaveValidatorSetEvent {
+        pool_address: Address;
+    }
+    namespace LeaveValidatorSetEvent {
+        const TYPE_QNAME = "0x1::stake::LeaveValidatorSetEvent";
+        function type(): TypeDescriptor<LeaveValidatorSetEvent>;
+    }
+    interface LeaveValidatorSetEventInstance extends TypedEventInstance<LeaveValidatorSetEvent> {
+        data_decoded: LeaveValidatorSetEvent;
+        type_arguments: [];
+    }
+    interface OwnerCapability {
+        pool_address: Address;
+    }
+    namespace OwnerCapability {
+        const TYPE_QNAME = "0x1::stake::OwnerCapability";
+        function type(): TypeDescriptor<OwnerCapability>;
+    }
+    interface ReactivateStakeEvent {
+        pool_address: Address;
+        amount: bigint;
+    }
+    namespace ReactivateStakeEvent {
+        const TYPE_QNAME = "0x1::stake::ReactivateStakeEvent";
+        function type(): TypeDescriptor<ReactivateStakeEvent>;
+    }
+    interface ReactivateStakeEventInstance extends TypedEventInstance<ReactivateStakeEvent> {
+        data_decoded: ReactivateStakeEvent;
+        type_arguments: [];
+    }
+    interface RegisterValidatorCandidateEvent {
+        pool_address: Address;
+    }
+    namespace RegisterValidatorCandidateEvent {
+        const TYPE_QNAME = "0x1::stake::RegisterValidatorCandidateEvent";
+        function type(): TypeDescriptor<RegisterValidatorCandidateEvent>;
+    }
+    interface RegisterValidatorCandidateEventInstance extends TypedEventInstance<RegisterValidatorCandidateEvent> {
+        data_decoded: RegisterValidatorCandidateEvent;
+        type_arguments: [];
+    }
+    interface RotateConsensusKeyEvent {
+        pool_address: Address;
+        old_consensus_pubkey: string;
+        new_consensus_pubkey: string;
+    }
+    namespace RotateConsensusKeyEvent {
+        const TYPE_QNAME = "0x1::stake::RotateConsensusKeyEvent";
+        function type(): TypeDescriptor<RotateConsensusKeyEvent>;
+    }
+    interface RotateConsensusKeyEventInstance extends TypedEventInstance<RotateConsensusKeyEvent> {
+        data_decoded: RotateConsensusKeyEvent;
+        type_arguments: [];
+    }
+    interface SetOperatorEvent {
+        pool_address: Address;
+        old_operator: Address;
+        new_operator: Address;
+    }
+    namespace SetOperatorEvent {
+        const TYPE_QNAME = "0x1::stake::SetOperatorEvent";
+        function type(): TypeDescriptor<SetOperatorEvent>;
+    }
+    interface SetOperatorEventInstance extends TypedEventInstance<SetOperatorEvent> {
+        data_decoded: SetOperatorEvent;
+        type_arguments: [];
+    }
+    interface StakePool {
+        active: coin.Coin<aptos_coin.AptosCoin>;
+        inactive: coin.Coin<aptos_coin.AptosCoin>;
+        pending_active: coin.Coin<aptos_coin.AptosCoin>;
+        pending_inactive: coin.Coin<aptos_coin.AptosCoin>;
+        locked_until_secs: bigint;
+        operator_address: Address;
+        delegated_voter: Address;
+        initialize_validator_events: event.EventHandle<stake.RegisterValidatorCandidateEvent>;
+        set_operator_events: event.EventHandle<stake.SetOperatorEvent>;
+        add_stake_events: event.EventHandle<stake.AddStakeEvent>;
+        reactivate_stake_events: event.EventHandle<stake.ReactivateStakeEvent>;
+        rotate_consensus_key_events: event.EventHandle<stake.RotateConsensusKeyEvent>;
+        update_network_and_fullnode_addresses_events: event.EventHandle<stake.UpdateNetworkAndFullnodeAddressesEvent>;
+        increase_lockup_events: event.EventHandle<stake.IncreaseLockupEvent>;
+        join_validator_set_events: event.EventHandle<stake.JoinValidatorSetEvent>;
+        distribute_rewards_events: event.EventHandle<stake.DistributeRewardsEvent>;
+        unlock_stake_events: event.EventHandle<stake.UnlockStakeEvent>;
+        withdraw_stake_events: event.EventHandle<stake.WithdrawStakeEvent>;
+        leave_validator_set_events: event.EventHandle<stake.LeaveValidatorSetEvent>;
+    }
+    namespace StakePool {
+        const TYPE_QNAME = "0x1::stake::StakePool";
+        function type(): TypeDescriptor<StakePool>;
+    }
+    interface UnlockStakeEvent {
+        pool_address: Address;
+        amount_unlocked: bigint;
+    }
+    namespace UnlockStakeEvent {
+        const TYPE_QNAME = "0x1::stake::UnlockStakeEvent";
+        function type(): TypeDescriptor<UnlockStakeEvent>;
+    }
+    interface UnlockStakeEventInstance extends TypedEventInstance<UnlockStakeEvent> {
+        data_decoded: UnlockStakeEvent;
+        type_arguments: [];
+    }
+    interface UpdateNetworkAndFullnodeAddressesEvent {
+        pool_address: Address;
+        old_network_addresses: string;
+        new_network_addresses: string;
+        old_fullnode_addresses: string;
+        new_fullnode_addresses: string;
+    }
+    namespace UpdateNetworkAndFullnodeAddressesEvent {
+        const TYPE_QNAME = "0x1::stake::UpdateNetworkAndFullnodeAddressesEvent";
+        function type(): TypeDescriptor<UpdateNetworkAndFullnodeAddressesEvent>;
+    }
+    interface UpdateNetworkAndFullnodeAddressesEventInstance extends TypedEventInstance<UpdateNetworkAndFullnodeAddressesEvent> {
+        data_decoded: UpdateNetworkAndFullnodeAddressesEvent;
+        type_arguments: [];
+    }
+    interface ValidatorConfig {
+        consensus_pubkey: string;
+        network_addresses: string;
+        fullnode_addresses: string;
+        validator_index: bigint;
+    }
+    namespace ValidatorConfig {
+        const TYPE_QNAME = "0x1::stake::ValidatorConfig";
+        function type(): TypeDescriptor<ValidatorConfig>;
+    }
+    interface ValidatorConfigInstance extends TypedEventInstance<ValidatorConfig> {
+        data_decoded: ValidatorConfig;
+        type_arguments: [];
+    }
+    interface ValidatorFees {
+        fees_table: table.Table<Address, coin.Coin<aptos_coin.AptosCoin>>;
+    }
+    namespace ValidatorFees {
+        const TYPE_QNAME = "0x1::stake::ValidatorFees";
+        function type(): TypeDescriptor<ValidatorFees>;
+    }
+    interface ValidatorInfo {
+        addr: Address;
+        voting_power: bigint;
+        config: stake.ValidatorConfig;
+    }
+    namespace ValidatorInfo {
+        const TYPE_QNAME = "0x1::stake::ValidatorInfo";
+        function type(): TypeDescriptor<ValidatorInfo>;
+    }
+    interface ValidatorInfoInstance extends TypedEventInstance<ValidatorInfo> {
+        data_decoded: ValidatorInfo;
+        type_arguments: [];
+    }
+    interface ValidatorPerformance {
+        validators: stake.IndividualValidatorPerformance[];
+    }
+    namespace ValidatorPerformance {
+        const TYPE_QNAME = "0x1::stake::ValidatorPerformance";
+        function type(): TypeDescriptor<ValidatorPerformance>;
+    }
+    interface ValidatorSet {
+        consensus_scheme: number;
+        active_validators: stake.ValidatorInfo[];
+        pending_inactive: stake.ValidatorInfo[];
+        pending_active: stake.ValidatorInfo[];
+        total_voting_power: bigint;
+        total_joining_power: bigint;
+    }
+    namespace ValidatorSet {
+        const TYPE_QNAME = "0x1::stake::ValidatorSet";
+        function type(): TypeDescriptor<ValidatorSet>;
+    }
+    interface WithdrawStakeEvent {
+        pool_address: Address;
+        amount_withdrawn: bigint;
+    }
+    namespace WithdrawStakeEvent {
+        const TYPE_QNAME = "0x1::stake::WithdrawStakeEvent";
+        function type(): TypeDescriptor<WithdrawStakeEvent>;
+    }
+    interface WithdrawStakeEventInstance extends TypedEventInstance<WithdrawStakeEvent> {
+        data_decoded: WithdrawStakeEvent;
+        type_arguments: [];
+    }
+    namespace entry {
+        function addStake(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function increaseLockup(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function initializeStakeOwner(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint, Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function initializeValidator(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [string, string, string, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function joinValidatorSet(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function leaveValidatorSet(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function reactivateStake(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function rotateConsensusKey(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, string, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setDelegatedVoter(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setOperator(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function unlock(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function updateNetworkAndFullnodeAddresses(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, string, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function withdraw(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
+    namespace view {
+        function getCurrentEpochProposalCounts(client: AptosClient, request: {
+            arguments: [bigint];
+        }, version?: bigint): Promise<[bigint, bigint]>;
+        function getCurrentEpochVotingPower(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function getDelegatedVoter(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address]>;
+        function getLockupSecs(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function getOperator(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address]>;
+        function getRemainingLockupSecs(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function getStake(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint, bigint, bigint, bigint]>;
+        function getValidatorConfig(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[string, string, string]>;
+        function getValidatorIndex(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function getValidatorState(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function stakePoolExists(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
+    }
+}
+export declare namespace table {
+    interface Box<T0> {
+        val: T0;
+    }
+    namespace Box {
+        const TYPE_QNAME = "0x1::table::Box";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Box<T0>>;
+    }
+    interface BoxInstance extends TypedEventInstance<Box<any>> {
+        data_decoded: Box<any>;
+        type_arguments: [string];
+    }
+    interface Table<T0, T1> {
+        handle: Address;
+    }
+    namespace Table {
+        const TYPE_QNAME = "0x1::table::Table";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Table<T0, T1>>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace math64 {
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace object_ {
+    interface ConstructorRef {
+        self: Address;
+        can_delete: Boolean;
+    }
+    namespace ConstructorRef {
+        const TYPE_QNAME = "0x1::object::ConstructorRef";
+        function type(): TypeDescriptor<ConstructorRef>;
+    }
+    interface DeleteRef {
+        self: Address;
+    }
+    namespace DeleteRef {
+        const TYPE_QNAME = "0x1::object::DeleteRef";
+        function type(): TypeDescriptor<DeleteRef>;
+    }
+    interface DeleteRefInstance extends TypedEventInstance<DeleteRef> {
+        data_decoded: DeleteRef;
+        type_arguments: [];
+    }
+    interface DeriveRef {
+        self: Address;
+    }
+    namespace DeriveRef {
+        const TYPE_QNAME = "0x1::object::DeriveRef";
+        function type(): TypeDescriptor<DeriveRef>;
+    }
+    interface DeriveRefInstance extends TypedEventInstance<DeriveRef> {
+        data_decoded: DeriveRef;
+        type_arguments: [];
+    }
+    interface ExtendRef {
+        self: Address;
+    }
+    namespace ExtendRef {
+        const TYPE_QNAME = "0x1::object::ExtendRef";
+        function type(): TypeDescriptor<ExtendRef>;
+    }
+    interface ExtendRefInstance extends TypedEventInstance<ExtendRef> {
+        data_decoded: ExtendRef;
+        type_arguments: [];
+    }
+    interface LinearTransferRef {
+        self: Address;
+        owner: Address;
+    }
+    namespace LinearTransferRef {
+        const TYPE_QNAME = "0x1::object::LinearTransferRef";
+        function type(): TypeDescriptor<LinearTransferRef>;
+    }
+    interface Object<T0> {
+        inner: Address;
+    }
+    namespace Object {
+        const TYPE_QNAME = "0x1::object::Object";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Object<T0>>;
+    }
+    interface ObjectInstance extends TypedEventInstance<Object<any>> {
+        data_decoded: Object<any>;
+        type_arguments: [string];
+    }
+    interface ObjectCore {
+        guid_creation_num: bigint;
+        owner: Address;
+        allow_ungated_transfer: Boolean;
+        transfer_events: event.EventHandle<object_.TransferEvent>;
+    }
+    namespace ObjectCore {
+        const TYPE_QNAME = "0x1::object::ObjectCore";
+        function type(): TypeDescriptor<ObjectCore>;
+    }
+    interface ObjectGroup {
+        dummy_field: Boolean;
+    }
+    namespace ObjectGroup {
+        const TYPE_QNAME = "0x1::object::ObjectGroup";
+        function type(): TypeDescriptor<ObjectGroup>;
+    }
+    interface TransferEvent {
+        object: Address;
+        from: Address;
+        to: Address;
+    }
+    namespace TransferEvent {
+        const TYPE_QNAME = "0x1::object::TransferEvent";
+        function type(): TypeDescriptor<TransferEvent>;
+    }
+    interface TransferEventInstance extends TypedEventInstance<TransferEvent> {
+        data_decoded: TransferEvent;
+        type_arguments: [];
+    }
+    interface TransferRef {
+        self: Address;
+    }
+    namespace TransferRef {
+        const TYPE_QNAME = "0x1::object::TransferRef";
+        function type(): TypeDescriptor<TransferRef>;
+    }
+    interface TransferRefInstance extends TypedEventInstance<TransferRef> {
+        data_decoded: TransferRef;
+        type_arguments: [];
+    }
+    namespace entry {
+        function transfer<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function transferCall(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function transferToObject<T0 = any, T1 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string, string];
+            arguments: [object_.Object<T0>, object_.Object<T1>];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
+    namespace view { }
+}
+export declare namespace option {
+    interface Option<T0> {
+        vec: T0[] | string;
+    }
+    namespace Option {
+        const TYPE_QNAME = "0x1::option::Option";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Option<T0>>;
+    }
+    interface OptionInstance extends TypedEventInstance<Option<any>> {
+        data_decoded: Option<any>;
+        type_arguments: [string];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace signer {
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace string_ {
+    interface String {
+        bytes: string;
+    }
+    namespace String {
+        const TYPE_QNAME = "0x1::string::String";
+        function type(): TypeDescriptor<String>;
+    }
+    interface StringInstance extends TypedEventInstance<String> {
+        data_decoded: String;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace vector {
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace voting {
+    interface CreateProposalEvent {
+        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 CreateProposalEvent {
+        const TYPE_QNAME = "0x1::voting::CreateProposalEvent";
+        function type(): TypeDescriptor<CreateProposalEvent>;
+    }
+    interface CreateProposalEventInstance extends TypedEventInstance<CreateProposalEvent> {
+        data_decoded: CreateProposalEvent;
+        type_arguments: [];
+    }
+    interface Proposal<T0> {
+        proposer: Address;
+        execution_content: option.Option<T0>;
+        metadata: simple_map.SimpleMap<string, string>;
+        creation_time_secs: bigint;
+        execution_hash: string;
+        min_vote_threshold: bigint;
+        expiration_secs: bigint;
+        early_resolution_vote_threshold: option.Option<bigint>;
+        yes_votes: bigint;
+        no_votes: bigint;
+        is_resolved: Boolean;
+        resolution_time_secs: bigint;
+    }
+    namespace Proposal {
+        const TYPE_QNAME = "0x1::voting::Proposal";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Proposal<T0>>;
+    }
+    interface RegisterForumEvent {
+        hosting_account: Address;
+        proposal_type_info: type_info.TypeInfo;
+    }
+    namespace RegisterForumEvent {
+        const TYPE_QNAME = "0x1::voting::RegisterForumEvent";
+        function type(): TypeDescriptor<RegisterForumEvent>;
+    }
+    interface RegisterForumEventInstance extends TypedEventInstance<RegisterForumEvent> {
+        data_decoded: RegisterForumEvent;
+        type_arguments: [];
+    }
+    interface ResolveProposal {
+        proposal_id: bigint;
+        yes_votes: bigint;
+        no_votes: bigint;
+        resolved_early: Boolean;
+    }
+    namespace ResolveProposal {
+        const TYPE_QNAME = "0x1::voting::ResolveProposal";
+        function type(): TypeDescriptor<ResolveProposal>;
+    }
+    interface ResolveProposalInstance extends TypedEventInstance<ResolveProposal> {
+        data_decoded: ResolveProposal;
+        type_arguments: [];
+    }
+    interface VoteEvent {
+        proposal_id: bigint;
+        num_votes: bigint;
+    }
+    namespace VoteEvent {
+        const TYPE_QNAME = "0x1::voting::VoteEvent";
+        function type(): TypeDescriptor<VoteEvent>;
+    }
+    interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
+        data_decoded: VoteEvent;
+        type_arguments: [];
+    }
+    interface VotingEvents {
+        create_proposal_events: event.EventHandle<voting.CreateProposalEvent>;
+        register_forum_events: event.EventHandle<voting.RegisterForumEvent>;
+        resolve_proposal_events: event.EventHandle<voting.ResolveProposal>;
+        vote_events: event.EventHandle<voting.VoteEvent>;
+    }
+    namespace VotingEvents {
+        const TYPE_QNAME = "0x1::voting::VotingEvents";
+        function type(): TypeDescriptor<VotingEvents>;
+    }
+    interface VotingForum<T0> {
+        proposals: table.Table<bigint, voting.Proposal<T0>>;
+        events: voting.VotingEvents;
+        next_proposal_id: bigint;
+    }
+    namespace VotingForum {
+        const TYPE_QNAME = "0x1::voting::VotingForum";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<VotingForum<T0>>;
+    }
+    namespace entry { }
+    namespace view {
+        function getEarlyResolutionVoteThreshold<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[option.Option<bigint>]>;
+        function getExecutionHash<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[string]>;
+        function getMinVoteThreshold<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[bigint]>;
+        function getProposalCreationSecs<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[bigint]>;
+        function getProposalExpirationSecs<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[bigint]>;
+        function getProposalState<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[bigint]>;
+        function getVotes<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[bigint, bigint]>;
+        function isMultiStepProposalInExecution<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[Boolean]>;
+        function isResolved<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[Boolean]>;
+        function isVotingClosed<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[Boolean]>;
+        function nextProposalId<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+    }
+}
+export declare namespace account {
+    interface Account {
+        authentication_key: string;
+        sequence_number: bigint;
+        guid_creation_num: bigint;
+        coin_register_events: event.EventHandle<account.CoinRegisterEvent>;
+        key_rotation_events: event.EventHandle<account.KeyRotationEvent>;
+        rotation_capability_offer: account.CapabilityOffer<account.RotationCapability>;
+        signer_capability_offer: account.CapabilityOffer<account.SignerCapability>;
+    }
+    namespace Account {
+        const TYPE_QNAME = "0x1::account::Account";
+        function type(): TypeDescriptor<Account>;
+    }
+    interface CapabilityOffer<T0> {
+        for: option.Option<Address>;
+    }
+    namespace CapabilityOffer {
+        const TYPE_QNAME = "0x1::account::CapabilityOffer";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<CapabilityOffer<T0>>;
+    }
+    interface CoinRegisterEvent {
+        type_info: type_info.TypeInfo;
+    }
+    namespace CoinRegisterEvent {
+        const TYPE_QNAME = "0x1::account::CoinRegisterEvent";
+        function type(): TypeDescriptor<CoinRegisterEvent>;
+    }
+    interface CoinRegisterEventInstance extends TypedEventInstance<CoinRegisterEvent> {
+        data_decoded: CoinRegisterEvent;
+        type_arguments: [];
+    }
+    interface KeyRotationEvent {
+        old_authentication_key: string;
+        new_authentication_key: string;
+    }
+    namespace KeyRotationEvent {
+        const TYPE_QNAME = "0x1::account::KeyRotationEvent";
+        function type(): TypeDescriptor<KeyRotationEvent>;
+    }
+    interface KeyRotationEventInstance extends TypedEventInstance<KeyRotationEvent> {
+        data_decoded: KeyRotationEvent;
+        type_arguments: [];
+    }
+    interface OriginatingAddress {
+        address_map: table.Table<Address, Address>;
+    }
+    namespace OriginatingAddress {
+        const TYPE_QNAME = "0x1::account::OriginatingAddress";
+        function type(): TypeDescriptor<OriginatingAddress>;
+    }
+    interface RotationCapability {
+        account: Address;
+    }
+    namespace RotationCapability {
+        const TYPE_QNAME = "0x1::account::RotationCapability";
+        function type(): TypeDescriptor<RotationCapability>;
+    }
+    interface RotationCapabilityInstance extends TypedEventInstance<RotationCapability> {
+        data_decoded: RotationCapability;
+        type_arguments: [];
+    }
+    interface RotationCapabilityOfferProofChallenge {
+        sequence_number: bigint;
+        recipient_address: Address;
+    }
+    namespace RotationCapabilityOfferProofChallenge {
+        const TYPE_QNAME = "0x1::account::RotationCapabilityOfferProofChallenge";
+        function type(): TypeDescriptor<RotationCapabilityOfferProofChallenge>;
+    }
+    interface RotationCapabilityOfferProofChallengeV2 {
+        chain_id: number;
+        sequence_number: bigint;
+        source_address: Address;
+        recipient_address: Address;
+    }
+    namespace RotationCapabilityOfferProofChallengeV2 {
+        const TYPE_QNAME = "0x1::account::RotationCapabilityOfferProofChallengeV2";
+        function type(): TypeDescriptor<RotationCapabilityOfferProofChallengeV2>;
+    }
+    interface RotationProofChallenge {
+        sequence_number: bigint;
+        originator: Address;
+        current_auth_key: Address;
+        new_public_key: string;
+    }
+    namespace RotationProofChallenge {
+        const TYPE_QNAME = "0x1::account::RotationProofChallenge";
+        function type(): TypeDescriptor<RotationProofChallenge>;
+    }
+    interface SignerCapability {
+        account: Address;
+    }
+    namespace SignerCapability {
+        const TYPE_QNAME = "0x1::account::SignerCapability";
+        function type(): TypeDescriptor<SignerCapability>;
+    }
+    interface SignerCapabilityInstance extends TypedEventInstance<SignerCapability> {
+        data_decoded: SignerCapability;
+        type_arguments: [];
+    }
+    interface SignerCapabilityOfferProofChallenge {
+        sequence_number: bigint;
+        recipient_address: Address;
+    }
+    namespace SignerCapabilityOfferProofChallenge {
+        const TYPE_QNAME = "0x1::account::SignerCapabilityOfferProofChallenge";
+        function type(): TypeDescriptor<SignerCapabilityOfferProofChallenge>;
+    }
+    interface SignerCapabilityOfferProofChallengeV2 {
+        sequence_number: bigint;
+        source_address: Address;
+        recipient_address: Address;
+    }
+    namespace SignerCapabilityOfferProofChallengeV2 {
+        const TYPE_QNAME = "0x1::account::SignerCapabilityOfferProofChallengeV2";
+        function type(): TypeDescriptor<SignerCapabilityOfferProofChallengeV2>;
+    }
+    namespace entry {
+        function offerRotationCapability(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [string, number, string, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function offerSignerCapability(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [string, number, string, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function revokeAnyRotationCapability(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function revokeAnySignerCapability(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function revokeRotationCapability(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function revokeSignerCapability(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function rotateAuthenticationKey(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [number, string, number, string, string, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function rotateAuthenticationKeyWithRotationCapability(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, number, string, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
+    namespace view {
+        function existsAt(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
+        function getAuthenticationKey(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[string]>;
+        function getGuidNextCreationNum(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function getSequenceNumber(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function getSignerCapabilityOfferFor(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address]>;
+        function isSignerCapabilityOffered(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
+    }
+}
+export declare namespace ed25519 {
+    interface Signature {
+        bytes: string;
+    }
+    namespace Signature {
+        const TYPE_QNAME = "0x1::ed25519::Signature";
+        function type(): TypeDescriptor<Signature>;
+    }
+    interface SignatureInstance extends TypedEventInstance<Signature> {
+        data_decoded: Signature;
+        type_arguments: [];
+    }
+    interface SignedMessage<T0> {
+        type_info: type_info.TypeInfo;
+        inner: T0;
+    }
+    namespace SignedMessage {
+        const TYPE_QNAME = "0x1::ed25519::SignedMessage";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<SignedMessage<T0>>;
+    }
+    interface UnvalidatedPublicKey {
+        bytes: string;
+    }
+    namespace UnvalidatedPublicKey {
+        const TYPE_QNAME = "0x1::ed25519::UnvalidatedPublicKey";
+        function type(): TypeDescriptor<UnvalidatedPublicKey>;
+    }
+    interface UnvalidatedPublicKeyInstance extends TypedEventInstance<UnvalidatedPublicKey> {
+        data_decoded: UnvalidatedPublicKey;
+        type_arguments: [];
+    }
+    interface ValidatedPublicKey {
+        bytes: string;
+    }
+    namespace ValidatedPublicKey {
+        const TYPE_QNAME = "0x1::ed25519::ValidatedPublicKey";
+        function type(): TypeDescriptor<ValidatedPublicKey>;
+    }
+    interface ValidatedPublicKeyInstance extends TypedEventInstance<ValidatedPublicKey> {
+        data_decoded: ValidatedPublicKey;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace genesis {
+    interface AccountMap {
+        account_address: Address;
+        balance: bigint;
+    }
+    namespace AccountMap {
+        const TYPE_QNAME = "0x1::genesis::AccountMap";
+        function type(): TypeDescriptor<AccountMap>;
+    }
+    interface EmployeeAccountMap {
+        accounts: Address[];
+        validator: genesis.ValidatorConfigurationWithCommission;
+        vesting_schedule_numerator: bigint[];
+        vesting_schedule_denominator: bigint;
+        beneficiary_resetter: Address;
+    }
+    namespace EmployeeAccountMap {
+        const TYPE_QNAME = "0x1::genesis::EmployeeAccountMap";
+        function type(): TypeDescriptor<EmployeeAccountMap>;
+    }
+    interface ValidatorConfiguration {
+        owner_address: Address;
+        operator_address: Address;
+        voter_address: Address;
+        stake_amount: bigint;
+        consensus_pubkey: string;
+        proof_of_possession: string;
+        network_addresses: string;
+        full_node_network_addresses: string;
+    }
+    namespace ValidatorConfiguration {
+        const TYPE_QNAME = "0x1::genesis::ValidatorConfiguration";
+        function type(): TypeDescriptor<ValidatorConfiguration>;
+    }
+    interface ValidatorConfigurationWithCommission {
+        validator_config: genesis.ValidatorConfiguration;
+        commission_percentage: bigint;
+        join_during_genesis: Boolean;
+    }
+    namespace ValidatorConfigurationWithCommission {
+        const TYPE_QNAME = "0x1::genesis::ValidatorConfigurationWithCommission";
+        function type(): TypeDescriptor<ValidatorConfigurationWithCommission>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace math128 {
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace version {
+    interface SetVersionCapability {
+        dummy_field: Boolean;
+    }
+    namespace SetVersionCapability {
+        const TYPE_QNAME = "0x1::version::SetVersionCapability";
+        function type(): TypeDescriptor<SetVersionCapability>;
+    }
+    interface Version {
+        major: bigint;
+    }
+    namespace Version {
+        const TYPE_QNAME = "0x1::version::Version";
+        function type(): TypeDescriptor<Version>;
+    }
+    namespace entry {
+        function setVersion(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
+    namespace view { }
+}
+export declare namespace vesting {
+    interface AdminStore {
+        vesting_contracts: Address[];
+        nonce: bigint;
+        create_events: event.EventHandle<vesting.CreateVestingContractEvent>;
+    }
+    namespace AdminStore {
+        const TYPE_QNAME = "0x1::vesting::AdminStore";
+        function type(): TypeDescriptor<AdminStore>;
+    }
+    interface AdminWithdrawEvent {
+        admin: Address;
+        vesting_contract_address: Address;
+        amount: bigint;
+    }
+    namespace AdminWithdrawEvent {
+        const TYPE_QNAME = "0x1::vesting::AdminWithdrawEvent";
+        function type(): TypeDescriptor<AdminWithdrawEvent>;
+    }
+    interface AdminWithdrawEventInstance extends TypedEventInstance<AdminWithdrawEvent> {
+        data_decoded: AdminWithdrawEvent;
+        type_arguments: [];
+    }
+    interface CreateVestingContractEvent {
+        operator: Address;
+        voter: Address;
+        grant_amount: bigint;
+        withdrawal_address: Address;
+        vesting_contract_address: Address;
+        staking_pool_address: Address;
+        commission_percentage: bigint;
+    }
+    namespace CreateVestingContractEvent {
+        const TYPE_QNAME = "0x1::vesting::CreateVestingContractEvent";
+        function type(): TypeDescriptor<CreateVestingContractEvent>;
+    }
+    interface CreateVestingContractEventInstance extends TypedEventInstance<CreateVestingContractEvent> {
+        data_decoded: CreateVestingContractEvent;
+        type_arguments: [];
+    }
+    interface DistributeEvent {
+        admin: Address;
+        vesting_contract_address: Address;
+        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 ResetLockupEvent {
+        admin: Address;
+        vesting_contract_address: Address;
+        staking_pool_address: Address;
+        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 SetBeneficiaryEvent {
+        admin: Address;
+        vesting_contract_address: Address;
+        shareholder: Address;
+        old_beneficiary: Address;
+        new_beneficiary: Address;
+    }
+    namespace SetBeneficiaryEvent {
+        const TYPE_QNAME = "0x1::vesting::SetBeneficiaryEvent";
+        function type(): TypeDescriptor<SetBeneficiaryEvent>;
+    }
+    interface SetBeneficiaryEventInstance extends TypedEventInstance<SetBeneficiaryEvent> {
+        data_decoded: SetBeneficiaryEvent;
+        type_arguments: [];
+    }
+    interface StakingInfo {
+        pool_address: Address;
+        operator: Address;
+        voter: Address;
+        commission_percentage: bigint;
+    }
+    namespace StakingInfo {
+        const TYPE_QNAME = "0x1::vesting::StakingInfo";
+        function type(): TypeDescriptor<StakingInfo>;
+    }
+    interface TerminateEvent {
+        admin: Address;
+        vesting_contract_address: Address;
+    }
+    namespace TerminateEvent {
+        const TYPE_QNAME = "0x1::vesting::TerminateEvent";
+        function type(): TypeDescriptor<TerminateEvent>;
+    }
+    interface TerminateEventInstance extends TypedEventInstance<TerminateEvent> {
+        data_decoded: TerminateEvent;
+        type_arguments: [];
+    }
+    interface UnlockRewardsEvent {
+        admin: Address;
+        vesting_contract_address: Address;
+        staking_pool_address: Address;
+        amount: bigint;
+    }
+    namespace UnlockRewardsEvent {
+        const TYPE_QNAME = "0x1::vesting::UnlockRewardsEvent";
+        function type(): TypeDescriptor<UnlockRewardsEvent>;
+    }
+    interface UnlockRewardsEventInstance extends TypedEventInstance<UnlockRewardsEvent> {
+        data_decoded: UnlockRewardsEvent;
+        type_arguments: [];
+    }
+    interface UpdateOperatorEvent {
+        admin: Address;
+        vesting_contract_address: Address;
+        staking_pool_address: Address;
+        old_operator: Address;
+        new_operator: Address;
+        commission_percentage: bigint;
+    }
+    namespace UpdateOperatorEvent {
+        const TYPE_QNAME = "0x1::vesting::UpdateOperatorEvent";
+        function type(): TypeDescriptor<UpdateOperatorEvent>;
+    }
+    interface UpdateOperatorEventInstance extends TypedEventInstance<UpdateOperatorEvent> {
+        data_decoded: UpdateOperatorEvent;
+        type_arguments: [];
+    }
+    interface UpdateVoterEvent {
+        admin: Address;
+        vesting_contract_address: Address;
+        staking_pool_address: Address;
+        old_voter: Address;
+        new_voter: Address;
+    }
+    namespace UpdateVoterEvent {
+        const TYPE_QNAME = "0x1::vesting::UpdateVoterEvent";
+        function type(): TypeDescriptor<UpdateVoterEvent>;
+    }
+    interface UpdateVoterEventInstance extends TypedEventInstance<UpdateVoterEvent> {
+        data_decoded: UpdateVoterEvent;
+        type_arguments: [];
+    }
+    interface VestEvent {
+        admin: Address;
+        vesting_contract_address: Address;
+        staking_pool_address: Address;
+        period_vested: bigint;
+        amount: bigint;
+    }
+    namespace VestEvent {
+        const TYPE_QNAME = "0x1::vesting::VestEvent";
+        function type(): TypeDescriptor<VestEvent>;
+    }
+    interface VestEventInstance extends TypedEventInstance<VestEvent> {
+        data_decoded: VestEvent;
+        type_arguments: [];
+    }
+    interface VestingAccountManagement {
+        roles: simple_map.SimpleMap<string, Address>;
+    }
+    namespace VestingAccountManagement {
+        const TYPE_QNAME = "0x1::vesting::VestingAccountManagement";
+        function type(): TypeDescriptor<VestingAccountManagement>;
+    }
+    interface VestingContract {
+        state: bigint;
+        admin: Address;
+        grant_pool: pool_u64.Pool;
+        beneficiaries: simple_map.SimpleMap<Address, Address>;
+        vesting_schedule: vesting.VestingSchedule;
+        withdrawal_address: Address;
+        staking: vesting.StakingInfo;
+        remaining_grant: bigint;
+        signer_cap: account.SignerCapability;
+        update_operator_events: event.EventHandle<vesting.UpdateOperatorEvent>;
+        update_voter_events: event.EventHandle<vesting.UpdateVoterEvent>;
+        reset_lockup_events: event.EventHandle<vesting.ResetLockupEvent>;
+        set_beneficiary_events: event.EventHandle<vesting.SetBeneficiaryEvent>;
+        unlock_rewards_events: event.EventHandle<vesting.UnlockRewardsEvent>;
+        vest_events: event.EventHandle<vesting.VestEvent>;
+        distribute_events: event.EventHandle<vesting.DistributeEvent>;
+        terminate_events: event.EventHandle<vesting.TerminateEvent>;
+        admin_withdraw_events: event.EventHandle<vesting.AdminWithdrawEvent>;
+    }
+    namespace VestingContract {
+        const TYPE_QNAME = "0x1::vesting::VestingContract";
+        function type(): TypeDescriptor<VestingContract>;
+    }
+    interface VestingSchedule {
+        schedule: fixed_point32.FixedPoint32[];
+        start_timestamp_secs: bigint;
+        period_duration: bigint;
+        last_vested_period: bigint;
+    }
+    namespace VestingSchedule {
+        const TYPE_QNAME = "0x1::vesting::VestingSchedule";
+        function type(): TypeDescriptor<VestingSchedule>;
+    }
+    interface VestingScheduleInstance extends TypedEventInstance<VestingSchedule> {
+        data_decoded: VestingSchedule;
+        type_arguments: [];
+    }
+    namespace entry {
+        function adminWithdraw(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function distribute(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function distributeMany(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function resetBeneficiary(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function resetLockup(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setBeneficiary(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setBeneficiaryResetter(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setManagementRole(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, string, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function terminateVestingContract(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function unlockRewards(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function unlockRewardsMany(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function updateOperator(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function updateOperatorWithSameCommission(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function updateVoter(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function vest(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function vestMany(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
+    namespace view {
+        function accumulatedRewards(client: AptosClient, request: {
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function beneficiary(client: AptosClient, request: {
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[Address]>;
+        function operator(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address]>;
+        function operatorCommissionPercentage(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function periodDurationSecs(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function remainingGrant(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function shareholder(client: AptosClient, request: {
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[Address]>;
+        function shareholders(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address[]]>;
+        function stakePoolAddress(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address]>;
+        function totalAccumulatedRewards(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function vestingContracts(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address[]]>;
+        function vestingSchedule(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[vesting.VestingSchedule]>;
+        function vestingStartSecs(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function voter(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address]>;
+    }
+}
+export declare namespace bls12381 {
+    interface AggrOrMultiSignature {
+        bytes: string;
+    }
+    namespace AggrOrMultiSignature {
+        const TYPE_QNAME = "0x1::bls12381::AggrOrMultiSignature";
+        function type(): TypeDescriptor<AggrOrMultiSignature>;
+    }
+    interface AggrOrMultiSignatureInstance extends TypedEventInstance<AggrOrMultiSignature> {
+        data_decoded: AggrOrMultiSignature;
+        type_arguments: [];
+    }
+    interface AggrPublicKeysWithPoP {
+        bytes: string;
+    }
+    namespace AggrPublicKeysWithPoP {
+        const TYPE_QNAME = "0x1::bls12381::AggrPublicKeysWithPoP";
+        function type(): TypeDescriptor<AggrPublicKeysWithPoP>;
+    }
+    interface AggrPublicKeysWithPoPInstance extends TypedEventInstance<AggrPublicKeysWithPoP> {
+        data_decoded: AggrPublicKeysWithPoP;
+        type_arguments: [];
+    }
+    interface ProofOfPossession {
+        bytes: string;
+    }
+    namespace ProofOfPossession {
+        const TYPE_QNAME = "0x1::bls12381::ProofOfPossession";
+        function type(): TypeDescriptor<ProofOfPossession>;
+    }
+    interface ProofOfPossessionInstance extends TypedEventInstance<ProofOfPossession> {
+        data_decoded: ProofOfPossession;
+        type_arguments: [];
+    }
+    interface PublicKey {
+        bytes: string;
+    }
+    namespace PublicKey {
+        const TYPE_QNAME = "0x1::bls12381::PublicKey";
+        function type(): TypeDescriptor<PublicKey>;
+    }
+    interface PublicKeyInstance extends TypedEventInstance<PublicKey> {
+        data_decoded: PublicKey;
+        type_arguments: [];
+    }
+    interface PublicKeyWithPoP {
+        bytes: string;
+    }
+    namespace PublicKeyWithPoP {
+        const TYPE_QNAME = "0x1::bls12381::PublicKeyWithPoP";
+        function type(): TypeDescriptor<PublicKeyWithPoP>;
+    }
+    interface PublicKeyWithPoPInstance extends TypedEventInstance<PublicKeyWithPoP> {
+        data_decoded: PublicKeyWithPoP;
+        type_arguments: [];
+    }
+    interface Signature {
+        bytes: string;
+    }
+    namespace Signature {
+        const TYPE_QNAME = "0x1::bls12381::Signature";
+        function type(): TypeDescriptor<Signature>;
+    }
+    interface SignatureInstance extends TypedEventInstance<Signature> {
+        data_decoded: Signature;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace chain_id {
+    interface ChainId {
+        id: number;
+    }
+    namespace ChainId {
+        const TYPE_QNAME = "0x1::chain_id::ChainId";
+        function type(): TypeDescriptor<ChainId>;
+    }
+    namespace entry { }
+    namespace view {
+        function get(client: AptosClient, version?: bigint): Promise<[number]>;
+    }
+}
+export declare namespace features {
+    interface Features {
+        features: string;
+    }
+    namespace Features {
+        const TYPE_QNAME = "0x1::features::Features";
+        function type(): TypeDescriptor<Features>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace from_bcs {
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace pool_u64 {
+    interface Pool {
+        shareholders_limit: bigint;
+        total_coins: bigint;
+        total_shares: bigint;
+        shares: simple_map.SimpleMap<Address, bigint>;
+        shareholders: Address[];
+        scaling_factor: bigint;
+    }
+    namespace Pool {
+        const TYPE_QNAME = "0x1::pool_u64::Pool";
+        function type(): TypeDescriptor<Pool>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace secp256k1 {
+    interface ECDSARawPublicKey {
+        bytes: string;
+    }
+    namespace ECDSARawPublicKey {
+        const TYPE_QNAME = "0x1::secp256k1::ECDSARawPublicKey";
+        function type(): TypeDescriptor<ECDSARawPublicKey>;
+    }
+    interface ECDSARawPublicKeyInstance extends TypedEventInstance<ECDSARawPublicKey> {
+        data_decoded: ECDSARawPublicKey;
+        type_arguments: [];
+    }
+    interface ECDSASignature {
+        bytes: string;
+    }
+    namespace ECDSASignature {
+        const TYPE_QNAME = "0x1::secp256k1::ECDSASignature";
+        function type(): TypeDescriptor<ECDSASignature>;
+    }
+    interface ECDSASignatureInstance extends TypedEventInstance<ECDSASignature> {
+        data_decoded: ECDSASignature;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace timestamp {
+    interface CurrentTimeMicroseconds {
+        microseconds: bigint;
+    }
+    namespace CurrentTimeMicroseconds {
+        const TYPE_QNAME = "0x1::timestamp::CurrentTimeMicroseconds";
+        function type(): TypeDescriptor<CurrentTimeMicroseconds>;
+    }
+    namespace entry { }
+    namespace view {
+        function nowMicroseconds(client: AptosClient, version?: bigint): Promise<[bigint]>;
+        function nowSeconds(client: AptosClient, version?: bigint): Promise<[bigint]>;
+    }
+}
+export declare namespace type_info {
+    interface TypeInfo {
+        account_address: Address;
+        module_name: string;
+        struct_name: string;
+    }
+    namespace TypeInfo {
+        const TYPE_QNAME = "0x1::type_info::TypeInfo";
+        function type(): TypeDescriptor<TypeInfo>;
+    }
+    interface TypeInfoInstance extends TypedEventInstance<TypeInfo> {
+        data_decoded: TypeInfo;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace aggregator {
+    interface Aggregator {
+        handle: Address;
+        key: Address;
+        limit: bigint;
+    }
+    namespace Aggregator {
+        const TYPE_QNAME = "0x1::aggregator::Aggregator";
+        function type(): TypeDescriptor<Aggregator>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace aptos_coin {
+    interface AptosCoin {
+        dummy_field: Boolean;
+    }
+    namespace AptosCoin {
+        const TYPE_QNAME = "0x1::aptos_coin::AptosCoin";
+        function type(): TypeDescriptor<AptosCoin>;
+    }
+    interface DelegatedMintCapability {
+        to: Address;
+    }
+    namespace DelegatedMintCapability {
+        const TYPE_QNAME = "0x1::aptos_coin::DelegatedMintCapability";
+        function type(): TypeDescriptor<DelegatedMintCapability>;
+    }
+    interface Delegations {
+        inner: aptos_coin.DelegatedMintCapability[];
+    }
+    namespace Delegations {
+        const TYPE_QNAME = "0x1::aptos_coin::Delegations";
+        function type(): TypeDescriptor<Delegations>;
+    }
+    interface MintCapStore {
+        mint_cap: coin.MintCapability<aptos_coin.AptosCoin>;
+    }
+    namespace MintCapStore {
+        const TYPE_QNAME = "0x1::aptos_coin::MintCapStore";
+        function type(): TypeDescriptor<MintCapStore>;
+    }
+    namespace entry {
+        function claimMintCapability(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function delegateMintCapability(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function mint(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
+    namespace view { }
+}
+export declare namespace aptos_hash {
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace big_vector {
+    interface BigVector<T0> {
+        buckets: table_with_length.TableWithLength<bigint, T0[] | string>;
+        end_index: bigint;
+        bucket_size: bigint;
+    }
+    namespace BigVector {
+        const TYPE_QNAME = "0x1::big_vector::BigVector";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<BigVector<T0>>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace bit_vector {
+    interface BitVector {
+        length: bigint;
+        bit_field: Boolean[];
+    }
+    namespace BitVector {
+        const TYPE_QNAME = "0x1::bit_vector::BitVector";
+        function type(): TypeDescriptor<BitVector>;
+    }
+    interface BitVectorInstance extends TypedEventInstance<BitVector> {
+        data_decoded: BitVector;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace capability {
+    interface Cap<T0> {
+        root: Address;
+    }
+    namespace Cap {
+        const TYPE_QNAME = "0x1::capability::Cap";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Cap<T0>>;
+    }
+    interface CapDelegateState<T0> {
+        root: Address;
+    }
+    namespace CapDelegateState {
+        const TYPE_QNAME = "0x1::capability::CapDelegateState";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<CapDelegateState<T0>>;
+    }
+    interface CapState<T0> {
+        delegates: Address[];
+    }
+    namespace CapState {
+        const TYPE_QNAME = "0x1::capability::CapState";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<CapState<T0>>;
+    }
+    interface LinearCap<T0> {
+        root: Address;
+    }
+    namespace LinearCap {
+        const TYPE_QNAME = "0x1::capability::LinearCap";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<LinearCap<T0>>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace comparator {
+    interface Result {
+        inner: number;
+    }
+    namespace Result {
+        const TYPE_QNAME = "0x1::comparator::Result";
+        function type(): TypeDescriptor<Result>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace math_fixed {
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace simple_map {
+    interface Element<T0, T1> {
+        key: T0;
+        value: T1;
+    }
+    namespace Element {
+        const TYPE_QNAME = "0x1::simple_map::Element";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Element<T0, T1>>;
+    }
+    interface ElementInstance extends TypedEventInstance<Element<any, any>> {
+        data_decoded: Element<any, any>;
+        type_arguments: [string, string];
+    }
+    interface SimpleMap<T0, T1> {
+        data: simple_map.Element<T0, T1>[];
+    }
+    namespace SimpleMap {
+        const TYPE_QNAME = "0x1::simple_map::SimpleMap";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<SimpleMap<T0, T1>>;
+    }
+    interface SimpleMapInstance extends TypedEventInstance<SimpleMap<any, any>> {
+        data_decoded: SimpleMap<any, any>;
+        type_arguments: [string, string];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace smart_table {
+    interface Entry<T0, T1> {
+        hash: bigint;
+        key: T0;
+        value: T1;
+    }
+    namespace Entry {
+        const TYPE_QNAME = "0x1::smart_table::Entry";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Entry<T0, T1>>;
+    }
+    interface EntryInstance extends TypedEventInstance<Entry<any, any>> {
+        data_decoded: Entry<any, any>;
+        type_arguments: [string, string];
+    }
+    interface SmartTable<T0, T1> {
+        buckets: table_with_length.TableWithLength<bigint, smart_table.Entry<T0, T1>[]>;
+        num_buckets: bigint;
+        level: number;
+        size: bigint;
+        split_load_threshold: number;
+        target_bucket_size: bigint;
+    }
+    namespace SmartTable {
+        const TYPE_QNAME = "0x1::smart_table::SmartTable";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<SmartTable<T0, T1>>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace storage_gas {
+    interface GasCurve {
+        min_gas: bigint;
+        max_gas: bigint;
+        points: storage_gas.Point[];
+    }
+    namespace GasCurve {
+        const TYPE_QNAME = "0x1::storage_gas::GasCurve";
+        function type(): TypeDescriptor<GasCurve>;
+    }
+    interface GasCurveInstance extends TypedEventInstance<GasCurve> {
+        data_decoded: GasCurve;
+        type_arguments: [];
+    }
+    interface Point {
+        x: bigint;
+        y: bigint;
+    }
+    namespace Point {
+        const TYPE_QNAME = "0x1::storage_gas::Point";
+        function type(): TypeDescriptor<Point>;
+    }
+    interface PointInstance extends TypedEventInstance<Point> {
+        data_decoded: Point;
+        type_arguments: [];
+    }
+    interface StorageGas {
+        per_item_read: bigint;
+        per_item_create: bigint;
+        per_item_write: bigint;
+        per_byte_read: bigint;
+        per_byte_create: bigint;
+        per_byte_write: bigint;
+    }
+    namespace StorageGas {
+        const TYPE_QNAME = "0x1::storage_gas::StorageGas";
+        function type(): TypeDescriptor<StorageGas>;
+    }
+    interface StorageGasConfig {
+        item_config: storage_gas.UsageGasConfig;
+        byte_config: storage_gas.UsageGasConfig;
+    }
+    namespace StorageGasConfig {
+        const TYPE_QNAME = "0x1::storage_gas::StorageGasConfig";
+        function type(): TypeDescriptor<StorageGasConfig>;
+    }
+    interface UsageGasConfig {
+        target_usage: bigint;
+        read_curve: storage_gas.GasCurve;
+        create_curve: storage_gas.GasCurve;
+        write_curve: storage_gas.GasCurve;
+    }
+    namespace UsageGasConfig {
+        const TYPE_QNAME = "0x1::storage_gas::UsageGasConfig";
+        function type(): TypeDescriptor<UsageGasConfig>;
+    }
+    interface UsageGasConfigInstance extends TypedEventInstance<UsageGasConfig> {
+        data_decoded: UsageGasConfig;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace chain_status {
+    interface GenesisEndMarker {
+        dummy_field: Boolean;
+    }
+    namespace GenesisEndMarker {
+        const TYPE_QNAME = "0x1::chain_status::GenesisEndMarker";
+        function type(): TypeDescriptor<GenesisEndMarker>;
+    }
+    namespace entry { }
+    namespace view {
+        function isGenesis(client: AptosClient, version?: bigint): Promise<[Boolean]>;
+        function isOperating(client: AptosClient, version?: bigint): Promise<[Boolean]>;
+    }
+}
+export declare namespace copyable_any {
+    interface Any {
+        type_name: string;
+        data: string;
+    }
+    namespace Any {
+        const TYPE_QNAME = "0x1::copyable_any::Any";
+        function type(): TypeDescriptor<Any>;
+    }
+    interface AnyInstance extends TypedEventInstance<Any> {
+        data_decoded: Any;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace gas_schedule {
+    interface GasEntry {
+        key: string;
+        val: bigint;
+    }
+    namespace GasEntry {
+        const TYPE_QNAME = "0x1::gas_schedule::GasEntry";
+        function type(): TypeDescriptor<GasEntry>;
+    }
+    interface GasEntryInstance extends TypedEventInstance<GasEntry> {
+        data_decoded: GasEntry;
+        type_arguments: [];
+    }
+    interface GasSchedule {
+        entries: gas_schedule.GasEntry[];
+    }
+    namespace GasSchedule {
+        const TYPE_QNAME = "0x1::gas_schedule::GasSchedule";
+        function type(): TypeDescriptor<GasSchedule>;
+    }
+    interface GasScheduleV2 {
+        feature_version: bigint;
+        entries: gas_schedule.GasEntry[];
+    }
+    namespace GasScheduleV2 {
+        const TYPE_QNAME = "0x1::gas_schedule::GasScheduleV2";
+        function type(): TypeDescriptor<GasScheduleV2>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace managed_coin {
+    interface Capabilities<T0> {
+        burn_cap: coin.BurnCapability<T0>;
+        freeze_cap: coin.FreezeCapability<T0>;
+        mint_cap: coin.MintCapability<T0>;
+    }
+    namespace Capabilities {
+        const TYPE_QNAME = "0x1::managed_coin::Capabilities";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Capabilities<T0>>;
+    }
+    namespace entry {
+        function burn<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function initialize<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [string, string, number, Boolean];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function mint<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function register<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
+    namespace view { }
+}
+export declare namespace math_fixed64 {
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace ristretto255 {
+    interface CompressedRistretto {
+        data: string;
+    }
+    namespace CompressedRistretto {
+        const TYPE_QNAME = "0x1::ristretto255::CompressedRistretto";
+        function type(): TypeDescriptor<CompressedRistretto>;
+    }
+    interface CompressedRistrettoInstance extends TypedEventInstance<CompressedRistretto> {
+        data_decoded: CompressedRistretto;
+        type_arguments: [];
+    }
+    interface RistrettoPoint {
+        handle: bigint;
+    }
+    namespace RistrettoPoint {
+        const TYPE_QNAME = "0x1::ristretto255::RistrettoPoint";
+        function type(): TypeDescriptor<RistrettoPoint>;
+    }
+    interface Scalar {
+        data: string;
+    }
+    namespace Scalar {
+        const TYPE_QNAME = "0x1::ristretto255::Scalar";
+        function type(): TypeDescriptor<Scalar>;
+    }
+    interface ScalarInstance extends TypedEventInstance<Scalar> {
+        data_decoded: Scalar;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace smart_vector {
+    interface SmartVector<T0> {
+        inline_vec: T0[] | string;
+        big_vec: option.Option<big_vector.BigVector<T0>>;
+        inline_capacity: option.Option<bigint>;
+        bucket_size: option.Option<bigint>;
+    }
+    namespace SmartVector {
+        const TYPE_QNAME = "0x1::smart_vector::SmartVector";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<SmartVector<T0>>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace string_utils {
+    interface Cons<T0, T1> {
+        car: T0;
+        cdr: T1;
+    }
+    namespace Cons {
+        const TYPE_QNAME = "0x1::string_utils::Cons";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Cons<T0, T1>>;
+    }
+    interface ConsInstance extends TypedEventInstance<Cons<any, any>> {
+        data_decoded: Cons<any, any>;
+        type_arguments: [string, string];
+    }
+    interface FakeCons<T0, T1> {
+        car: T0;
+        cdr: T1;
+    }
+    namespace FakeCons {
+        const TYPE_QNAME = "0x1::string_utils::FakeCons";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<FakeCons<T0, T1>>;
+    }
+    interface FakeConsInstance extends TypedEventInstance<FakeCons<any, any>> {
+        data_decoded: FakeCons<any, any>;
+        type_arguments: [string, string];
+    }
+    interface NIL {
+        dummy_field: Boolean;
+    }
+    namespace NIL {
+        const TYPE_QNAME = "0x1::string_utils::NIL";
+        function type(): TypeDescriptor<NIL>;
+    }
+    interface NILInstance extends TypedEventInstance<NIL> {
+        data_decoded: NIL;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace aptos_account {
+    interface DirectCoinTransferConfigUpdatedEvent {
+        new_allow_direct_transfers: Boolean;
+    }
+    namespace DirectCoinTransferConfigUpdatedEvent {
+        const TYPE_QNAME = "0x1::aptos_account::DirectCoinTransferConfigUpdatedEvent";
+        function type(): TypeDescriptor<DirectCoinTransferConfigUpdatedEvent>;
+    }
+    interface DirectCoinTransferConfigUpdatedEventInstance extends TypedEventInstance<DirectCoinTransferConfigUpdatedEvent> {
+        data_decoded: DirectCoinTransferConfigUpdatedEvent;
+        type_arguments: [];
+    }
+    interface DirectTransferConfig {
+        allow_arbitrary_coin_transfers: Boolean;
+        update_coin_transfer_events: event.EventHandle<aptos_account.DirectCoinTransferConfigUpdatedEvent>;
+    }
+    namespace DirectTransferConfig {
+        const TYPE_QNAME = "0x1::aptos_account::DirectTransferConfig";
+        function type(): TypeDescriptor<DirectTransferConfig>;
+    }
+    namespace entry {
+        function batchTransfer(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address[], bigint[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function batchTransferCoins<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [Address[], bigint[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createAccount(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setAllowDirectCoinTransfers(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Boolean];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function transfer(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function transferCoins<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
+    namespace view {
+        function canReceiveDirectCoinTransfers(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
+    }
+}
+export declare namespace create_signer {
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace fixed_point32 {
+    interface FixedPoint32 {
+        value: bigint;
+    }
+    namespace FixedPoint32 {
+        const TYPE_QNAME = "0x1::fixed_point32::FixedPoint32";
+        function type(): TypeDescriptor<FixedPoint32>;
+    }
+    interface FixedPoint32Instance extends TypedEventInstance<FixedPoint32> {
+        data_decoded: FixedPoint32;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace fixed_point64 {
+    interface FixedPoint64 {
+        value: bigint;
+    }
+    namespace FixedPoint64 {
+        const TYPE_QNAME = "0x1::fixed_point64::FixedPoint64";
+        function type(): TypeDescriptor<FixedPoint64>;
+    }
+    interface FixedPoint64Instance extends TypedEventInstance<FixedPoint64> {
+        data_decoded: FixedPoint64;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace multi_ed25519 {
+    interface Signature {
+        bytes: string;
+    }
+    namespace Signature {
+        const TYPE_QNAME = "0x1::multi_ed25519::Signature";
+        function type(): TypeDescriptor<Signature>;
+    }
+    interface SignatureInstance extends TypedEventInstance<Signature> {
+        data_decoded: Signature;
+        type_arguments: [];
+    }
+    interface UnvalidatedPublicKey {
+        bytes: string;
+    }
+    namespace UnvalidatedPublicKey {
+        const TYPE_QNAME = "0x1::multi_ed25519::UnvalidatedPublicKey";
+        function type(): TypeDescriptor<UnvalidatedPublicKey>;
+    }
+    interface UnvalidatedPublicKeyInstance extends TypedEventInstance<UnvalidatedPublicKey> {
+        data_decoded: UnvalidatedPublicKey;
+        type_arguments: [];
+    }
+    interface ValidatedPublicKey {
+        bytes: string;
+    }
+    namespace ValidatedPublicKey {
+        const TYPE_QNAME = "0x1::multi_ed25519::ValidatedPublicKey";
+        function type(): TypeDescriptor<ValidatedPublicKey>;
+    }
+    interface ValidatedPublicKeyInstance extends TypedEventInstance<ValidatedPublicKey> {
+        data_decoded: ValidatedPublicKey;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace staking_proxy {
+    namespace entry {
+        function setOperator(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setStakePoolOperator(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setStakePoolVoter(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setStakingContractOperator(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setStakingContractVoter(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setVestingContractOperator(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setVestingContractVoter(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setVoter(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
+    namespace view { }
+}
+export declare namespace state_storage {
+    interface GasParameter {
+        usage: state_storage.Usage;
+    }
+    namespace GasParameter {
+        const TYPE_QNAME = "0x1::state_storage::GasParameter";
+        function type(): TypeDescriptor<GasParameter>;
+    }
+    interface StateStorageUsage {
+        epoch: bigint;
+        usage: state_storage.Usage;
+    }
+    namespace StateStorageUsage {
+        const TYPE_QNAME = "0x1::state_storage::StateStorageUsage";
+        function type(): TypeDescriptor<StateStorageUsage>;
+    }
+    interface Usage {
+        items: bigint;
+        bytes: bigint;
+    }
+    namespace Usage {
+        const TYPE_QNAME = "0x1::state_storage::Usage";
+        function type(): TypeDescriptor<Usage>;
+    }
+    interface UsageInstance extends TypedEventInstance<Usage> {
+        data_decoded: Usage;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace crypto_algebra {
+    interface Element<T0> {
+        handle: bigint;
+    }
+    namespace Element {
+        const TYPE_QNAME = "0x1::crypto_algebra::Element";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Element<T0>>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace fungible_asset {
+    interface BurnRef {
+        metadata: object_.Object<fungible_asset.Metadata>;
+    }
+    namespace BurnRef {
+        const TYPE_QNAME = "0x1::fungible_asset::BurnRef";
+        function type(): TypeDescriptor<BurnRef>;
+    }
+    interface BurnRefInstance extends TypedEventInstance<BurnRef> {
+        data_decoded: BurnRef;
+        type_arguments: [];
+    }
+    interface DepositEvent {
+        amount: bigint;
+    }
+    namespace DepositEvent {
+        const TYPE_QNAME = "0x1::fungible_asset::DepositEvent";
+        function type(): TypeDescriptor<DepositEvent>;
+    }
+    interface DepositEventInstance extends TypedEventInstance<DepositEvent> {
+        data_decoded: DepositEvent;
+        type_arguments: [];
+    }
+    interface FrozenEvent {
+        frozen: Boolean;
+    }
+    namespace FrozenEvent {
+        const TYPE_QNAME = "0x1::fungible_asset::FrozenEvent";
+        function type(): TypeDescriptor<FrozenEvent>;
+    }
+    interface FrozenEventInstance extends TypedEventInstance<FrozenEvent> {
+        data_decoded: FrozenEvent;
+        type_arguments: [];
+    }
+    interface FungibleAsset {
+        metadata: object_.Object<fungible_asset.Metadata>;
+        amount: bigint;
+    }
+    namespace FungibleAsset {
+        const TYPE_QNAME = "0x1::fungible_asset::FungibleAsset";
+        function type(): TypeDescriptor<FungibleAsset>;
+    }
+    interface FungibleAssetEvents {
+        deposit_events: event.EventHandle<fungible_asset.DepositEvent>;
+        withdraw_events: event.EventHandle<fungible_asset.WithdrawEvent>;
+        frozen_events: event.EventHandle<fungible_asset.FrozenEvent>;
+    }
+    namespace FungibleAssetEvents {
+        const TYPE_QNAME = "0x1::fungible_asset::FungibleAssetEvents";
+        function type(): TypeDescriptor<FungibleAssetEvents>;
+    }
+    interface FungibleStore {
+        metadata: object_.Object<fungible_asset.Metadata>;
+        balance: bigint;
+        frozen: Boolean;
+    }
+    namespace FungibleStore {
+        const TYPE_QNAME = "0x1::fungible_asset::FungibleStore";
+        function type(): TypeDescriptor<FungibleStore>;
+    }
+    interface Metadata {
+        name: string;
+        symbol: string;
+        decimals: number;
+        icon_uri: string;
+        project_uri: string;
+    }
+    namespace Metadata {
+        const TYPE_QNAME = "0x1::fungible_asset::Metadata";
+        function type(): TypeDescriptor<Metadata>;
+    }
+    interface MintRef {
+        metadata: object_.Object<fungible_asset.Metadata>;
+    }
+    namespace MintRef {
+        const TYPE_QNAME = "0x1::fungible_asset::MintRef";
+        function type(): TypeDescriptor<MintRef>;
+    }
+    interface MintRefInstance extends TypedEventInstance<MintRef> {
+        data_decoded: MintRef;
+        type_arguments: [];
+    }
+    interface Supply {
+        current: bigint;
+        maximum: option.Option<bigint>;
+    }
+    namespace Supply {
+        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 TransferRefInstance extends TypedEventInstance<TransferRef> {
+        data_decoded: TransferRef;
+        type_arguments: [];
+    }
+    interface WithdrawEvent {
+        amount: bigint;
+    }
+    namespace WithdrawEvent {
+        const TYPE_QNAME = "0x1::fungible_asset::WithdrawEvent";
+        function type(): TypeDescriptor<WithdrawEvent>;
+    }
+    interface WithdrawEventInstance extends TypedEventInstance<WithdrawEvent> {
+        data_decoded: WithdrawEvent;
+        type_arguments: [];
+    }
+    namespace entry {
+        function transfer<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>, object_.Object<T0>, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
+    namespace view {
+        function balance<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[bigint]>;
+        function decimals<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[number]>;
+        function isFrozen<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[Boolean]>;
+        function maximum<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[option.Option<bigint>]>;
+        function name<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[string]>;
+        function storeExists(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
+        function storeMetadata<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[object_.Object<fungible_asset.Metadata>]>;
+        function supply<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[option.Option<bigint>]>;
+        function symbol<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>];
+        }, version?: bigint): Promise<[string]>;
+    }
+}
+export declare namespace staking_config {
+    interface StakingConfig {
+        minimum_stake: bigint;
+        maximum_stake: bigint;
+        recurring_lockup_duration_secs: bigint;
+        allow_validator_set_change: Boolean;
+        rewards_rate: bigint;
+        rewards_rate_denominator: bigint;
+        voting_power_increase_limit: bigint;
+    }
+    namespace StakingConfig {
+        const TYPE_QNAME = "0x1::staking_config::StakingConfig";
+        function type(): TypeDescriptor<StakingConfig>;
+    }
+    interface StakingRewardsConfig {
+        rewards_rate: fixed_point64.FixedPoint64;
+        min_rewards_rate: fixed_point64.FixedPoint64;
+        rewards_rate_period_in_secs: bigint;
+        last_rewards_rate_period_start_in_secs: bigint;
+        rewards_rate_decrease_rate: fixed_point64.FixedPoint64;
+    }
+    namespace StakingRewardsConfig {
+        const TYPE_QNAME = "0x1::staking_config::StakingRewardsConfig";
+        function type(): TypeDescriptor<StakingRewardsConfig>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace delegation_pool {
+    interface AddStakeEvent {
+        pool_address: Address;
+        delegator_address: Address;
+        amount_added: bigint;
+        add_stake_fee: bigint;
+    }
+    namespace AddStakeEvent {
+        const TYPE_QNAME = "0x1::delegation_pool::AddStakeEvent";
+        function type(): TypeDescriptor<AddStakeEvent>;
+    }
+    interface AddStakeEventInstance extends TypedEventInstance<AddStakeEvent> {
+        data_decoded: AddStakeEvent;
+        type_arguments: [];
+    }
+    interface DelegationPool {
+        active_shares: pool_u64_unbound.Pool;
+        observed_lockup_cycle: delegation_pool.ObservedLockupCycle;
+        inactive_shares: table.Table<delegation_pool.ObservedLockupCycle, pool_u64_unbound.Pool>;
+        pending_withdrawals: table.Table<Address, delegation_pool.ObservedLockupCycle>;
+        stake_pool_signer_cap: account.SignerCapability;
+        total_coins_inactive: bigint;
+        operator_commission_percentage: bigint;
+        add_stake_events: event.EventHandle<delegation_pool.AddStakeEvent>;
+        reactivate_stake_events: event.EventHandle<delegation_pool.ReactivateStakeEvent>;
+        unlock_stake_events: event.EventHandle<delegation_pool.UnlockStakeEvent>;
+        withdraw_stake_events: event.EventHandle<delegation_pool.WithdrawStakeEvent>;
+        distribute_commission_events: event.EventHandle<delegation_pool.DistributeCommissionEvent>;
+    }
+    namespace DelegationPool {
+        const TYPE_QNAME = "0x1::delegation_pool::DelegationPool";
+        function type(): TypeDescriptor<DelegationPool>;
+    }
+    interface DelegationPoolOwnership {
+        pool_address: Address;
+    }
+    namespace DelegationPoolOwnership {
+        const TYPE_QNAME = "0x1::delegation_pool::DelegationPoolOwnership";
+        function type(): TypeDescriptor<DelegationPoolOwnership>;
+    }
+    interface DistributeCommissionEvent {
+        pool_address: Address;
+        operator: Address;
+        commission_active: bigint;
+        commission_pending_inactive: bigint;
+    }
+    namespace DistributeCommissionEvent {
+        const TYPE_QNAME = "0x1::delegation_pool::DistributeCommissionEvent";
+        function type(): TypeDescriptor<DistributeCommissionEvent>;
+    }
+    interface DistributeCommissionEventInstance extends TypedEventInstance<DistributeCommissionEvent> {
+        data_decoded: DistributeCommissionEvent;
+        type_arguments: [];
+    }
+    interface ObservedLockupCycle {
+        index: bigint;
+    }
+    namespace ObservedLockupCycle {
+        const TYPE_QNAME = "0x1::delegation_pool::ObservedLockupCycle";
+        function type(): TypeDescriptor<ObservedLockupCycle>;
+    }
+    interface ObservedLockupCycleInstance extends TypedEventInstance<ObservedLockupCycle> {
+        data_decoded: ObservedLockupCycle;
+        type_arguments: [];
+    }
+    interface ReactivateStakeEvent {
+        pool_address: Address;
+        delegator_address: Address;
+        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 UnlockStakeEvent {
+        pool_address: Address;
+        delegator_address: Address;
+        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 WithdrawStakeEvent {
+        pool_address: Address;
+        delegator_address: Address;
+        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 addStake(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function initializeDelegationPool(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function reactivateStake(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setDelegatedVoter(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function setOperator(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function synchronizeDelegationPool(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function unlock(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function withdraw(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
+    namespace view {
+        function canWithdrawPendingInactive(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
+        function delegationPoolExists(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
+        function getAddStakeFee(client: AptosClient, request: {
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[bigint]>;
+        function getDelegationPoolStake(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint, bigint, bigint, bigint]>;
+        function getOwnedPoolAddress(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address]>;
+        function getPendingWithdrawal(client: AptosClient, request: {
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[Boolean, bigint]>;
+        function getStake(client: AptosClient, request: {
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[bigint, bigint, bigint]>;
+        function observedLockupCycle(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function operatorCommissionPercentage(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function ownerCapExists(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Boolean]>;
+        function shareholdersCountActivePool(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+    }
+}
+export declare namespace reconfiguration {
+    interface Configuration {
+        epoch: bigint;
+        last_reconfiguration_time: bigint;
+        events: event.EventHandle<reconfiguration.NewEpochEvent>;
+    }
+    namespace Configuration {
+        const TYPE_QNAME = "0x1::reconfiguration::Configuration";
+        function type(): TypeDescriptor<Configuration>;
+    }
+    interface DisableReconfiguration {
+        dummy_field: Boolean;
+    }
+    namespace DisableReconfiguration {
+        const TYPE_QNAME = "0x1::reconfiguration::DisableReconfiguration";
+        function type(): TypeDescriptor<DisableReconfiguration>;
+    }
+    interface NewEpochEvent {
+        epoch: bigint;
+    }
+    namespace NewEpochEvent {
+        const TYPE_QNAME = "0x1::reconfiguration::NewEpochEvent";
+        function type(): TypeDescriptor<NewEpochEvent>;
+    }
+    interface NewEpochEventInstance extends TypedEventInstance<NewEpochEvent> {
+        data_decoded: NewEpochEvent;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace transaction_fee {
+    interface AptosCoinCapabilities {
+        burn_cap: coin.BurnCapability<aptos_coin.AptosCoin>;
+    }
+    namespace AptosCoinCapabilities {
+        const TYPE_QNAME = "0x1::transaction_fee::AptosCoinCapabilities";
+        function type(): TypeDescriptor<AptosCoinCapabilities>;
+    }
+    interface CollectedFeesPerBlock {
+        amount: coin.AggregatableCoin<aptos_coin.AptosCoin>;
+        proposer: option.Option<Address>;
+        burn_percentage: number;
+    }
+    namespace CollectedFeesPerBlock {
+        const TYPE_QNAME = "0x1::transaction_fee::CollectedFeesPerBlock";
+        function type(): TypeDescriptor<CollectedFeesPerBlock>;
+    }
+    namespace entry { }
+    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 CreateProposalEvent {
+        proposer: Address;
+        stake_pool: Address;
+        proposal_id: bigint;
+        execution_hash: string;
+        proposal_metadata: simple_map.SimpleMap<string, string>;
+    }
+    namespace CreateProposalEvent {
+        const TYPE_QNAME = "0x1::aptos_governance::CreateProposalEvent";
+        function type(): TypeDescriptor<CreateProposalEvent>;
+    }
+    interface CreateProposalEventInstance extends TypedEventInstance<CreateProposalEvent> {
+        data_decoded: CreateProposalEvent;
+        type_arguments: [];
+    }
+    interface GovernanceConfig {
+        min_voting_threshold: bigint;
+        required_proposer_stake: bigint;
+        voting_duration_secs: bigint;
+    }
+    namespace GovernanceConfig {
+        const TYPE_QNAME = "0x1::aptos_governance::GovernanceConfig";
+        function type(): TypeDescriptor<GovernanceConfig>;
+    }
+    interface GovernanceEvents {
+        create_proposal_events: event.EventHandle<aptos_governance.CreateProposalEvent>;
+        update_config_events: event.EventHandle<aptos_governance.UpdateConfigEvent>;
+        vote_events: event.EventHandle<aptos_governance.VoteEvent>;
+    }
+    namespace GovernanceEvents {
+        const TYPE_QNAME = "0x1::aptos_governance::GovernanceEvents";
+        function type(): TypeDescriptor<GovernanceEvents>;
+    }
+    interface GovernanceResponsbility {
+        signer_caps: simple_map.SimpleMap<Address, account.SignerCapability>;
+    }
+    namespace GovernanceResponsbility {
+        const TYPE_QNAME = "0x1::aptos_governance::GovernanceResponsbility";
+        function type(): TypeDescriptor<GovernanceResponsbility>;
+    }
+    interface RecordKey {
+        stake_pool: Address;
+        proposal_id: bigint;
+    }
+    namespace RecordKey {
+        const TYPE_QNAME = "0x1::aptos_governance::RecordKey";
+        function type(): TypeDescriptor<RecordKey>;
+    }
+    interface RecordKeyInstance extends TypedEventInstance<RecordKey> {
+        data_decoded: RecordKey;
+        type_arguments: [];
+    }
+    interface UpdateConfigEvent {
+        min_voting_threshold: bigint;
+        required_proposer_stake: bigint;
+        voting_duration_secs: bigint;
+    }
+    namespace UpdateConfigEvent {
+        const TYPE_QNAME = "0x1::aptos_governance::UpdateConfigEvent";
+        function type(): TypeDescriptor<UpdateConfigEvent>;
+    }
+    interface UpdateConfigEventInstance extends TypedEventInstance<UpdateConfigEvent> {
+        data_decoded: UpdateConfigEvent;
+        type_arguments: [];
+    }
+    interface VoteEvent {
+        proposal_id: bigint;
+        voter: Address;
+        stake_pool: Address;
+        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>;
+    }
+    namespace VotingRecords {
+        const TYPE_QNAME = "0x1::aptos_governance::VotingRecords";
+        function type(): TypeDescriptor<VotingRecords>;
+    }
+    namespace entry {
+        function addApprovedScriptHashScript(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createProposal(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, string, string, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createProposalV2(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, string, string, string, Boolean];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function vote(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint, Boolean];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
+    namespace view {
+        function getMinVotingThreshold(client: AptosClient, version?: bigint): Promise<[bigint]>;
+        function getRequiredProposerStake(client: AptosClient, version?: bigint): Promise<[bigint]>;
+        function getVotingDurationSecs(client: AptosClient, version?: bigint): Promise<[bigint]>;
+    }
+}
+export declare namespace bls12381_algebra {
+    interface FormatFq12LscLsb {
+        dummy_field: Boolean;
+    }
+    namespace FormatFq12LscLsb {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatFq12LscLsb";
+        function type(): TypeDescriptor<FormatFq12LscLsb>;
+    }
+    interface FormatFrLsb {
+        dummy_field: Boolean;
+    }
+    namespace FormatFrLsb {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatFrLsb";
+        function type(): TypeDescriptor<FormatFrLsb>;
+    }
+    interface FormatFrMsb {
+        dummy_field: Boolean;
+    }
+    namespace FormatFrMsb {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatFrMsb";
+        function type(): TypeDescriptor<FormatFrMsb>;
+    }
+    interface FormatG1Compr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG1Compr {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatG1Compr";
+        function type(): TypeDescriptor<FormatG1Compr>;
+    }
+    interface FormatG1Uncompr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG1Uncompr {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatG1Uncompr";
+        function type(): TypeDescriptor<FormatG1Uncompr>;
+    }
+    interface FormatG2Compr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG2Compr {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatG2Compr";
+        function type(): TypeDescriptor<FormatG2Compr>;
+    }
+    interface FormatG2Uncompr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG2Uncompr {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatG2Uncompr";
+        function type(): TypeDescriptor<FormatG2Uncompr>;
+    }
+    interface FormatGt {
+        dummy_field: Boolean;
+    }
+    namespace FormatGt {
+        const TYPE_QNAME = "0x1::bls12381_algebra::FormatGt";
+        function type(): TypeDescriptor<FormatGt>;
+    }
+    interface Fq12 {
+        dummy_field: Boolean;
+    }
+    namespace Fq12 {
+        const TYPE_QNAME = "0x1::bls12381_algebra::Fq12";
+        function type(): TypeDescriptor<Fq12>;
+    }
+    interface Fr {
+        dummy_field: Boolean;
+    }
+    namespace Fr {
+        const TYPE_QNAME = "0x1::bls12381_algebra::Fr";
+        function type(): TypeDescriptor<Fr>;
+    }
+    interface G1 {
+        dummy_field: Boolean;
+    }
+    namespace G1 {
+        const TYPE_QNAME = "0x1::bls12381_algebra::G1";
+        function type(): TypeDescriptor<G1>;
+    }
+    interface G2 {
+        dummy_field: Boolean;
+    }
+    namespace G2 {
+        const TYPE_QNAME = "0x1::bls12381_algebra::G2";
+        function type(): TypeDescriptor<G2>;
+    }
+    interface Gt {
+        dummy_field: Boolean;
+    }
+    namespace Gt {
+        const TYPE_QNAME = "0x1::bls12381_algebra::Gt";
+        function type(): TypeDescriptor<Gt>;
+    }
+    interface HashG1XmdSha256SswuRo {
+        dummy_field: Boolean;
+    }
+    namespace HashG1XmdSha256SswuRo {
+        const TYPE_QNAME = "0x1::bls12381_algebra::HashG1XmdSha256SswuRo";
+        function type(): TypeDescriptor<HashG1XmdSha256SswuRo>;
+    }
+    interface HashG2XmdSha256SswuRo {
+        dummy_field: Boolean;
+    }
+    namespace HashG2XmdSha256SswuRo {
+        const TYPE_QNAME = "0x1::bls12381_algebra::HashG2XmdSha256SswuRo";
+        function type(): TypeDescriptor<HashG2XmdSha256SswuRo>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace consensus_config {
+    interface ConsensusConfig {
+        config: string;
+    }
+    namespace ConsensusConfig {
+        const TYPE_QNAME = "0x1::consensus_config::ConsensusConfig";
+        function type(): TypeDescriptor<ConsensusConfig>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace execution_config {
+    interface ExecutionConfig {
+        config: string;
+    }
+    namespace ExecutionConfig {
+        const TYPE_QNAME = "0x1::execution_config::ExecutionConfig";
+        function type(): TypeDescriptor<ExecutionConfig>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace multisig_account {
+    interface AddOwnersEvent {
+        owners_added: Address[];
+    }
+    namespace AddOwnersEvent {
+        const TYPE_QNAME = "0x1::multisig_account::AddOwnersEvent";
+        function type(): TypeDescriptor<AddOwnersEvent>;
+    }
+    interface AddOwnersEventInstance extends TypedEventInstance<AddOwnersEvent> {
+        data_decoded: AddOwnersEvent;
+        type_arguments: [];
+    }
+    interface CreateTransactionEvent {
+        creator: Address;
+        sequence_number: bigint;
+        transaction: multisig_account.MultisigTransaction;
+    }
+    namespace CreateTransactionEvent {
+        const TYPE_QNAME = "0x1::multisig_account::CreateTransactionEvent";
+        function type(): TypeDescriptor<CreateTransactionEvent>;
+    }
+    interface CreateTransactionEventInstance extends TypedEventInstance<CreateTransactionEvent> {
+        data_decoded: CreateTransactionEvent;
+        type_arguments: [];
+    }
+    interface ExecuteRejectedTransactionEvent {
+        sequence_number: bigint;
+        num_rejections: bigint;
+        executor: Address;
+    }
+    namespace ExecuteRejectedTransactionEvent {
+        const TYPE_QNAME = "0x1::multisig_account::ExecuteRejectedTransactionEvent";
+        function type(): TypeDescriptor<ExecuteRejectedTransactionEvent>;
+    }
+    interface ExecuteRejectedTransactionEventInstance extends TypedEventInstance<ExecuteRejectedTransactionEvent> {
+        data_decoded: ExecuteRejectedTransactionEvent;
+        type_arguments: [];
+    }
+    interface ExecutionError {
+        abort_location: string;
+        error_type: string;
+        error_code: bigint;
+    }
+    namespace ExecutionError {
+        const TYPE_QNAME = "0x1::multisig_account::ExecutionError";
+        function type(): TypeDescriptor<ExecutionError>;
+    }
+    interface ExecutionErrorInstance extends TypedEventInstance<ExecutionError> {
+        data_decoded: ExecutionError;
+        type_arguments: [];
+    }
+    interface MetadataUpdatedEvent {
+        old_metadata: simple_map.SimpleMap<string, string>;
+        new_metadata: simple_map.SimpleMap<string, string>;
+    }
+    namespace MetadataUpdatedEvent {
+        const TYPE_QNAME = "0x1::multisig_account::MetadataUpdatedEvent";
+        function type(): TypeDescriptor<MetadataUpdatedEvent>;
+    }
+    interface MetadataUpdatedEventInstance extends TypedEventInstance<MetadataUpdatedEvent> {
+        data_decoded: MetadataUpdatedEvent;
+        type_arguments: [];
+    }
+    interface MultisigAccount {
+        owners: Address[];
+        num_signatures_required: bigint;
+        transactions: table.Table<bigint, multisig_account.MultisigTransaction>;
+        last_executed_sequence_number: bigint;
+        next_sequence_number: bigint;
+        signer_cap: option.Option<account.SignerCapability>;
+        metadata: simple_map.SimpleMap<string, string>;
+        add_owners_events: event.EventHandle<multisig_account.AddOwnersEvent>;
+        remove_owners_events: event.EventHandle<multisig_account.RemoveOwnersEvent>;
+        update_signature_required_events: event.EventHandle<multisig_account.UpdateSignaturesRequiredEvent>;
+        create_transaction_events: event.EventHandle<multisig_account.CreateTransactionEvent>;
+        vote_events: event.EventHandle<multisig_account.VoteEvent>;
+        execute_rejected_transaction_events: event.EventHandle<multisig_account.ExecuteRejectedTransactionEvent>;
+        execute_transaction_events: event.EventHandle<multisig_account.TransactionExecutionSucceededEvent>;
+        transaction_execution_failed_events: event.EventHandle<multisig_account.TransactionExecutionFailedEvent>;
+        metadata_updated_events: event.EventHandle<multisig_account.MetadataUpdatedEvent>;
+    }
+    namespace MultisigAccount {
+        const TYPE_QNAME = "0x1::multisig_account::MultisigAccount";
+        function type(): TypeDescriptor<MultisigAccount>;
+    }
+    interface MultisigAccountCreationMessage {
+        chain_id: number;
+        account_address: Address;
+        sequence_number: bigint;
+        owners: Address[];
+        num_signatures_required: bigint;
+    }
+    namespace MultisigAccountCreationMessage {
+        const TYPE_QNAME = "0x1::multisig_account::MultisigAccountCreationMessage";
+        function type(): TypeDescriptor<MultisigAccountCreationMessage>;
+    }
+    interface MultisigTransaction {
+        payload: option.Option<string>;
+        payload_hash: option.Option<string>;
+        votes: simple_map.SimpleMap<Address, Boolean>;
+        creator: Address;
+        creation_time_secs: bigint;
+    }
+    namespace MultisigTransaction {
+        const TYPE_QNAME = "0x1::multisig_account::MultisigTransaction";
+        function type(): TypeDescriptor<MultisigTransaction>;
+    }
+    interface MultisigTransactionInstance extends TypedEventInstance<MultisigTransaction> {
+        data_decoded: MultisigTransaction;
+        type_arguments: [];
+    }
+    interface RemoveOwnersEvent {
+        owners_removed: Address[];
+    }
+    namespace RemoveOwnersEvent {
+        const TYPE_QNAME = "0x1::multisig_account::RemoveOwnersEvent";
+        function type(): TypeDescriptor<RemoveOwnersEvent>;
+    }
+    interface RemoveOwnersEventInstance extends TypedEventInstance<RemoveOwnersEvent> {
+        data_decoded: RemoveOwnersEvent;
+        type_arguments: [];
+    }
+    interface TransactionExecutionFailedEvent {
+        executor: Address;
+        sequence_number: bigint;
+        transaction_payload: string;
+        num_approvals: bigint;
+        execution_error: multisig_account.ExecutionError;
+    }
+    namespace TransactionExecutionFailedEvent {
+        const TYPE_QNAME = "0x1::multisig_account::TransactionExecutionFailedEvent";
+        function type(): TypeDescriptor<TransactionExecutionFailedEvent>;
+    }
+    interface TransactionExecutionFailedEventInstance extends TypedEventInstance<TransactionExecutionFailedEvent> {
+        data_decoded: TransactionExecutionFailedEvent;
+        type_arguments: [];
+    }
+    interface TransactionExecutionSucceededEvent {
+        executor: Address;
+        sequence_number: bigint;
+        transaction_payload: string;
+        num_approvals: bigint;
+    }
+    namespace TransactionExecutionSucceededEvent {
+        const TYPE_QNAME = "0x1::multisig_account::TransactionExecutionSucceededEvent";
+        function type(): TypeDescriptor<TransactionExecutionSucceededEvent>;
+    }
+    interface TransactionExecutionSucceededEventInstance extends TypedEventInstance<TransactionExecutionSucceededEvent> {
+        data_decoded: TransactionExecutionSucceededEvent;
+        type_arguments: [];
+    }
+    interface UpdateSignaturesRequiredEvent {
+        old_num_signatures_required: bigint;
+        new_num_signatures_required: bigint;
+    }
+    namespace UpdateSignaturesRequiredEvent {
+        const TYPE_QNAME = "0x1::multisig_account::UpdateSignaturesRequiredEvent";
+        function type(): TypeDescriptor<UpdateSignaturesRequiredEvent>;
+    }
+    interface UpdateSignaturesRequiredEventInstance extends TypedEventInstance<UpdateSignaturesRequiredEvent> {
+        data_decoded: UpdateSignaturesRequiredEvent;
+        type_arguments: [];
+    }
+    interface VoteEvent {
+        owner: Address;
+        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 addOwner(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function addOwners(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function approveTransaction(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function create(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint, string[], string[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createTransaction(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createTransactionWithHash(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createWithExistingAccount(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [
+                Address,
+                Address[],
+                bigint,
+                number,
+                string,
+                string,
+                string[],
+                string[]
+            ];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createWithOwners(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address[], bigint, string[], string[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function executeRejectedTransaction(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function rejectTransaction(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function removeOwner(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function removeOwners(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function updateMetadata(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [string[], string[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function updateSignaturesRequired(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function voteTransanction(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint, Boolean];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
+    namespace view {
+        function canBeExecuted(client: AptosClient, request: {
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[Boolean]>;
+        function canBeRejected(client: AptosClient, request: {
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[Boolean]>;
+        function getNextMultisigAccountAddress(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address]>;
+        function getNextTransactionPayload(client: AptosClient, request: {
+            arguments: [Address, string];
+        }, version?: bigint): Promise<[string]>;
+        function getPendingTransactions(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[multisig_account.MultisigTransaction[]]>;
+        function getTransaction(client: AptosClient, request: {
+            arguments: [Address, bigint];
+        }, version?: bigint): Promise<[multisig_account.MultisigTransaction]>;
+        function lastResolvedSequenceNumber(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function metadata(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[simple_map.SimpleMap<string, string>]>;
+        function nextSequenceNumber(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function numSignaturesRequired(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function owners(client: AptosClient, request: {
+            arguments: [Address];
+        }, version?: bigint): Promise<[Address[]]>;
+        function vote(client: AptosClient, request: {
+            arguments: [Address, bigint, Address];
+        }, version?: bigint): Promise<[Boolean, Boolean]>;
+    }
+}
+export declare namespace pool_u64_unbound {
+    interface Pool {
+        total_coins: bigint;
+        total_shares: bigint;
+        shares: table_with_length.TableWithLength<Address, bigint>;
+        scaling_factor: bigint;
+    }
+    namespace Pool {
+        const TYPE_QNAME = "0x1::pool_u64_unbound::Pool";
+        function type(): TypeDescriptor<Pool>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace resource_account {
+    interface Container {
+        store: simple_map.SimpleMap<Address, account.SignerCapability>;
+    }
+    namespace Container {
+        const TYPE_QNAME = "0x1::resource_account::Container";
+        function type(): TypeDescriptor<Container>;
+    }
+    namespace entry {
+        function createResourceAccount(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [string, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createResourceAccountAndFund(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [string, string, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createResourceAccountAndPublishPackage(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [string, string, string[]];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
+    namespace view { }
+}
+export declare namespace staking_contract {
+    interface AddDistributionEvent {
+        operator: Address;
+        pool_address: Address;
+        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 AddStakeEvent {
+        operator: Address;
+        pool_address: Address;
+        amount: bigint;
+    }
+    namespace AddStakeEvent {
+        const TYPE_QNAME = "0x1::staking_contract::AddStakeEvent";
+        function type(): TypeDescriptor<AddStakeEvent>;
+    }
+    interface AddStakeEventInstance extends TypedEventInstance<AddStakeEvent> {
+        data_decoded: AddStakeEvent;
+        type_arguments: [];
+    }
+    interface CreateStakingContractEvent {
+        operator: Address;
+        voter: Address;
+        pool_address: Address;
+        principal: bigint;
+        commission_percentage: bigint;
+    }
+    namespace CreateStakingContractEvent {
+        const TYPE_QNAME = "0x1::staking_contract::CreateStakingContractEvent";
+        function type(): TypeDescriptor<CreateStakingContractEvent>;
+    }
+    interface CreateStakingContractEventInstance extends TypedEventInstance<CreateStakingContractEvent> {
+        data_decoded: CreateStakingContractEvent;
+        type_arguments: [];
+    }
+    interface DistributeEvent {
+        operator: Address;
+        pool_address: Address;
+        recipient: Address;
+        amount: bigint;
+    }
+    namespace DistributeEvent {
+        const TYPE_QNAME = "0x1::staking_contract::DistributeEvent";
+        function type(): TypeDescriptor<DistributeEvent>;
+    }
+    interface DistributeEventInstance extends TypedEventInstance<DistributeEvent> {
+        data_decoded: DistributeEvent;
+        type_arguments: [];
+    }
+    interface RequestCommissionEvent {
+        operator: Address;
+        pool_address: Address;
+        accumulated_rewards: bigint;
+        commission_amount: bigint;
+    }
+    namespace RequestCommissionEvent {
+        const TYPE_QNAME = "0x1::staking_contract::RequestCommissionEvent";
+        function type(): TypeDescriptor<RequestCommissionEvent>;
+    }
+    interface RequestCommissionEventInstance extends TypedEventInstance<RequestCommissionEvent> {
+        data_decoded: RequestCommissionEvent;
+        type_arguments: [];
+    }
+    interface ResetLockupEvent {
+        operator: Address;
+        pool_address: Address;
+    }
+    namespace ResetLockupEvent {
+        const TYPE_QNAME = "0x1::staking_contract::ResetLockupEvent";
+        function type(): TypeDescriptor<ResetLockupEvent>;
+    }
+    interface ResetLockupEventInstance extends TypedEventInstance<ResetLockupEvent> {
+        data_decoded: ResetLockupEvent;
+        type_arguments: [];
+    }
+    interface StakingContract {
+        principal: bigint;
+        pool_address: Address;
+        owner_cap: stake.OwnerCapability;
+        commission_percentage: bigint;
+        distribution_pool: pool_u64.Pool;
+        signer_cap: account.SignerCapability;
+    }
+    namespace StakingContract {
+        const TYPE_QNAME = "0x1::staking_contract::StakingContract";
+        function type(): TypeDescriptor<StakingContract>;
+    }
+    interface StakingGroupContainer {
+        dummy_field: Boolean;
+    }
+    namespace StakingGroupContainer {
+        const TYPE_QNAME = "0x1::staking_contract::StakingGroupContainer";
+        function type(): TypeDescriptor<StakingGroupContainer>;
+    }
+    interface StakingGroupUpdateCommissionEvent {
+        update_commission_events: event.EventHandle<staking_contract.UpdateCommissionEvent>;
+    }
+    namespace StakingGroupUpdateCommissionEvent {
+        const TYPE_QNAME = "0x1::staking_contract::StakingGroupUpdateCommissionEvent";
+        function type(): TypeDescriptor<StakingGroupUpdateCommissionEvent>;
+    }
+    interface Store {
+        staking_contracts: simple_map.SimpleMap<Address, staking_contract.StakingContract>;
+        create_staking_contract_events: event.EventHandle<staking_contract.CreateStakingContractEvent>;
+        update_voter_events: event.EventHandle<staking_contract.UpdateVoterEvent>;
+        reset_lockup_events: event.EventHandle<staking_contract.ResetLockupEvent>;
+        add_stake_events: event.EventHandle<staking_contract.AddStakeEvent>;
+        request_commission_events: event.EventHandle<staking_contract.RequestCommissionEvent>;
+        unlock_stake_events: event.EventHandle<staking_contract.UnlockStakeEvent>;
+        switch_operator_events: event.EventHandle<staking_contract.SwitchOperatorEvent>;
+        add_distribution_events: event.EventHandle<staking_contract.AddDistributionEvent>;
+        distribute_events: event.EventHandle<staking_contract.DistributeEvent>;
+    }
+    namespace Store {
+        const TYPE_QNAME = "0x1::staking_contract::Store";
+        function type(): TypeDescriptor<Store>;
+    }
+    interface SwitchOperatorEvent {
+        old_operator: Address;
+        new_operator: Address;
+        pool_address: Address;
+    }
+    namespace SwitchOperatorEvent {
+        const TYPE_QNAME = "0x1::staking_contract::SwitchOperatorEvent";
+        function type(): TypeDescriptor<SwitchOperatorEvent>;
+    }
+    interface SwitchOperatorEventInstance extends TypedEventInstance<SwitchOperatorEvent> {
+        data_decoded: SwitchOperatorEvent;
+        type_arguments: [];
+    }
+    interface UnlockStakeEvent {
+        operator: Address;
+        pool_address: Address;
+        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 UpdateCommissionEvent {
+        staker: Address;
+        operator: Address;
+        old_commission_percentage: bigint;
+        new_commission_percentage: bigint;
+    }
+    namespace UpdateCommissionEvent {
+        const TYPE_QNAME = "0x1::staking_contract::UpdateCommissionEvent";
+        function type(): TypeDescriptor<UpdateCommissionEvent>;
+    }
+    interface UpdateCommissionEventInstance extends TypedEventInstance<UpdateCommissionEvent> {
+        data_decoded: UpdateCommissionEvent;
+        type_arguments: [];
+    }
+    interface UpdateVoterEvent {
+        operator: Address;
+        pool_address: Address;
+        old_voter: Address;
+        new_voter: Address;
+    }
+    namespace UpdateVoterEvent {
+        const TYPE_QNAME = "0x1::staking_contract::UpdateVoterEvent";
+        function type(): TypeDescriptor<UpdateVoterEvent>;
+    }
+    interface UpdateVoterEventInstance extends TypedEventInstance<UpdateVoterEvent> {
+        data_decoded: UpdateVoterEvent;
+        type_arguments: [];
+    }
+    namespace entry {
+        function addStake(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function createStakingContract(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address, bigint, bigint, string];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function distribute(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function requestCommission(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function resetLockup(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function switchOperator(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function switchOperatorWithSameCommission(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function unlockRewards(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function unlockStake(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function updateCommision(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+        function updateVoter(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [];
+            arguments: [Address, Address];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
+    namespace view {
+        function commissionPercentage(client: AptosClient, request: {
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function lastRecordedPrincipal(client: AptosClient, request: {
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function pendingDistributionCounts(client: AptosClient, request: {
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[bigint]>;
+        function stakePoolAddress(client: AptosClient, request: {
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[Address]>;
+        function stakingContractAmounts(client: AptosClient, request: {
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[bigint, bigint, bigint]>;
+        function stakingContractExists(client: AptosClient, request: {
+            arguments: [Address, Address];
+        }, version?: bigint): Promise<[Boolean]>;
+    }
+}
+export declare namespace system_addresses {
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace table_with_length {
+    interface TableWithLength<T0, T1> {
+        inner: table.Table<T0, T1>;
+        length: bigint;
+    }
+    namespace TableWithLength {
+        const TYPE_QNAME = "0x1::table_with_length::TableWithLength";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<TableWithLength<T0, T1>>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace aggregator_factory {
+    interface AggregatorFactory {
+        phantom_table: table.Table<Address, bigint>;
+    }
+    namespace AggregatorFactory {
+        const TYPE_QNAME = "0x1::aggregator_factory::AggregatorFactory";
+        function type(): TypeDescriptor<AggregatorFactory>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace governance_proposal {
+    interface GovernanceProposal {
+        dummy_field: Boolean;
+    }
+    namespace GovernanceProposal {
+        const TYPE_QNAME = "0x1::governance_proposal::GovernanceProposal";
+        function type(): TypeDescriptor<GovernanceProposal>;
+    }
+    interface GovernanceProposalInstance extends TypedEventInstance<GovernanceProposal> {
+        data_decoded: GovernanceProposal;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace optional_aggregator {
+    interface Integer {
+        value: bigint;
+        limit: bigint;
+    }
+    namespace Integer {
+        const TYPE_QNAME = "0x1::optional_aggregator::Integer";
+        function type(): TypeDescriptor<Integer>;
+    }
+    interface OptionalAggregator {
+        aggregator: option.Option<aggregator.Aggregator>;
+        integer: option.Option<optional_aggregator.Integer>;
+    }
+    namespace OptionalAggregator {
+        const TYPE_QNAME = "0x1::optional_aggregator::OptionalAggregator";
+        function type(): TypeDescriptor<OptionalAggregator>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace transaction_context {
+    namespace entry { }
+    namespace view { }
+}
+export declare namespace primary_fungible_store {
+    interface DeriveRefPod {
+        metadata_derive_ref: object_.DeriveRef;
+    }
+    namespace DeriveRefPod {
+        const TYPE_QNAME = "0x1::primary_fungible_store::DeriveRefPod";
+        function type(): TypeDescriptor<DeriveRefPod>;
+    }
+    namespace entry {
+        function transfer<T0 = any>(client: AptosClient, account: AptosAccount, request: {
+            type_arguments: [string];
+            arguments: [object_.Object<T0>, Address, bigint];
+        }, extraArgs?: OptionalTransactionArgs): Promise<Types.PendingTransaction>;
+    }
+    namespace view {
+        function balance<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, object_.Object<T0>];
+        }, version?: bigint): Promise<[bigint]>;
+        function isFrozen<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, object_.Object<T0>];
+        }, version?: bigint): Promise<[Boolean]>;
+        function primaryStore<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, object_.Object<T0>];
+        }, version?: bigint): Promise<[object_.Object<fungible_asset.FungibleStore>]>;
+        function primaryStoreAddress<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, object_.Object<T0>];
+        }, version?: bigint): Promise<[Address]>;
+        function primaryStoreExists<T0 = any>(client: AptosClient, request: {
+            type_arguments: [string];
+            arguments: [Address, object_.Object<T0>];
+        }, version?: bigint): Promise<[Boolean]>;
+    }
+}
+export declare namespace transaction_validation {
+    interface TransactionValidation {
+        module_addr: Address;
+        module_name: string;
+        script_prologue_name: string;
+        module_prologue_name: string;
+        multi_agent_prologue_name: string;
+        user_epilogue_name: string;
+    }
+    namespace TransactionValidation {
+        const TYPE_QNAME = "0x1::transaction_validation::TransactionValidation";
+        function type(): TypeDescriptor<TransactionValidation>;
+    }
+    namespace entry { }
+    namespace view { }
+}
+export declare function loadAllTypes(coder: MoveCoder): void;
+//# sourceMappingURL=0x1.d.ts.map