@sentio/sdk 1.20.2 → 1.21.0

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

@@ -0,0 +1,1624 @@
+import { aptos } from "@sentio/sdk";
+import { Address, MoveModule } from "aptos/src/generated";
+export declare namespace acl {
+    class ACL {
+        list: Address[];
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace any {
+    class Any {
+        type_name: string;
+        data: string;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace bcs {
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare class code extends aptos.AptosBaseProcessor {
+    constructor(options: aptos.AptosBindOptions);
+    static DEFAULT_OPTIONS: aptos.AptosBindOptions;
+    static bind(options?: Partial<aptos.AptosBindOptions>): code;
+    onEntryPublishPackageTxn(func: (call: code.PublishPackageTxnPayload, ctx: aptos.AptosContext) => void): code;
+    loadTypesInternal(registry: aptos.TypeRegistry): void;
+}
+export declare namespace code {
+    class AllowedDep {
+        account: Address;
+        module_name: string;
+    }
+    class ModuleMetadata {
+        name: string;
+        source: string;
+        source_map: string;
+        extension: option.Option<copyable_any.Any>;
+    }
+    class PackageDep {
+        account: Address;
+        package_name: string;
+    }
+    class 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>;
+    }
+    class PackageRegistry {
+        packages: code.PackageMetadata[];
+    }
+    class UpgradePolicy {
+        policy: number;
+    }
+    interface PublishPackageTxnPayload extends aptos.TypedEntryFunctionPayload<[string, string[]]> {
+        arguments_typed: [string, string[]];
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare class coin extends aptos.AptosBaseProcessor {
+    constructor(options: aptos.AptosBindOptions);
+    static DEFAULT_OPTIONS: aptos.AptosBindOptions;
+    static bind(options?: Partial<aptos.AptosBindOptions>): coin;
+    onEntryFreezeCoinStore<T0>(func: (call: coin.FreezeCoinStorePayload<T0>, ctx: aptos.AptosContext) => void): coin;
+    onEntryTransfer<T0>(func: (call: coin.TransferPayload<T0>, ctx: aptos.AptosContext) => void): coin;
+    onEntryUnfreezeCoinStore<T0>(func: (call: coin.UnfreezeCoinStorePayload<T0>, ctx: aptos.AptosContext) => void): coin;
+    onEntryUpgradeSupply<T0>(func: (call: coin.UpgradeSupplyPayload<T0>, ctx: aptos.AptosContext) => void): coin;
+    onEventDepositEvent(func: (event: coin.DepositEventInstance, ctx: aptos.AptosContext) => void): coin;
+    onEventWithdrawEvent(func: (event: coin.WithdrawEventInstance, ctx: aptos.AptosContext) => void): coin;
+    loadTypesInternal(registry: aptos.TypeRegistry): void;
+}
+export declare namespace coin {
+    class BurnCapability<T0> {
+        dummy_field: Boolean;
+    }
+    class Coin<T0> {
+        value: bigint;
+    }
+    class CoinInfo<T0> {
+        name: string;
+        symbol: string;
+        decimals: number;
+        supply: option.Option<optional_aggregator.OptionalAggregator>;
+    }
+    class CoinStore<T0> {
+        coin: coin.Coin<T0>;
+        frozen: Boolean;
+        deposit_events: event.EventHandle<coin.DepositEvent>;
+        withdraw_events: event.EventHandle<coin.WithdrawEvent>;
+    }
+    class DepositEvent {
+        amount: bigint;
+    }
+    interface DepositEventInstance extends aptos.TypedEventInstance<DepositEvent> {
+        data_typed: DepositEvent;
+    }
+    class FreezeCapability<T0> {
+        dummy_field: Boolean;
+    }
+    class MintCapability<T0> {
+        dummy_field: Boolean;
+    }
+    class SupplyConfig {
+        allow_upgrades: Boolean;
+    }
+    class WithdrawEvent {
+        amount: bigint;
+    }
+    interface WithdrawEventInstance extends aptos.TypedEventInstance<WithdrawEvent> {
+        data_typed: WithdrawEvent;
+    }
+    interface FreezeCoinStorePayload<T0> extends aptos.TypedEntryFunctionPayload<[Address]> {
+        arguments_typed: [Address];
+    }
+    interface TransferPayload<T0> extends aptos.TypedEntryFunctionPayload<[Address, bigint]> {
+        arguments_typed: [Address, bigint];
+    }
+    interface UnfreezeCoinStorePayload<T0> extends aptos.TypedEntryFunctionPayload<[Address]> {
+        arguments_typed: [Address];
+    }
+    interface UpgradeSupplyPayload<T0> extends aptos.TypedEntryFunctionPayload<[]> {
+        arguments_typed: [];
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace guid {
+    class GUID {
+        id: guid.ID;
+    }
+    class ID {
+        creation_num: bigint;
+        addr: Address;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace hash {
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace util {
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare class block extends aptos.AptosBaseProcessor {
+    constructor(options: aptos.AptosBindOptions);
+    static DEFAULT_OPTIONS: aptos.AptosBindOptions;
+    static bind(options?: Partial<aptos.AptosBindOptions>): block;
+    onEventNewBlockEvent(func: (event: block.NewBlockEventInstance, ctx: aptos.AptosContext) => void): block;
+    onEventUpdateEpochIntervalEvent(func: (event: block.UpdateEpochIntervalEventInstance, ctx: aptos.AptosContext) => void): block;
+    loadTypesInternal(registry: aptos.TypeRegistry): void;
+}
+export declare namespace block {
+    class BlockResource {
+        height: bigint;
+        epoch_interval: bigint;
+        new_block_events: event.EventHandle<block.NewBlockEvent>;
+        update_epoch_interval_events: event.EventHandle<block.UpdateEpochIntervalEvent>;
+    }
+    class NewBlockEvent {
+        hash: Address;
+        epoch: bigint;
+        round: bigint;
+        height: bigint;
+        previous_block_votes_bitvec: string;
+        proposer: Address;
+        failed_proposer_indices: bigint[];
+        time_microseconds: bigint;
+    }
+    interface NewBlockEventInstance extends aptos.TypedEventInstance<NewBlockEvent> {
+        data_typed: NewBlockEvent;
+    }
+    class UpdateEpochIntervalEvent {
+        old_epoch_interval: bigint;
+        new_epoch_interval: bigint;
+    }
+    interface UpdateEpochIntervalEventInstance extends aptos.TypedEventInstance<UpdateEpochIntervalEvent> {
+        data_typed: UpdateEpochIntervalEvent;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace debug {
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace error {
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace event {
+    class EventHandle<T0> {
+        counter: bigint;
+        guid: guid.GUID;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare class stake extends aptos.AptosBaseProcessor {
+    constructor(options: aptos.AptosBindOptions);
+    static DEFAULT_OPTIONS: aptos.AptosBindOptions;
+    static bind(options?: Partial<aptos.AptosBindOptions>): stake;
+    onEntryAddStake(func: (call: stake.AddStakePayload, ctx: aptos.AptosContext) => void): stake;
+    onEntryIncreaseLockup(func: (call: stake.IncreaseLockupPayload, ctx: aptos.AptosContext) => void): stake;
+    onEntryInitializeStakeOwner(func: (call: stake.InitializeStakeOwnerPayload, ctx: aptos.AptosContext) => void): stake;
+    onEntryInitializeValidator(func: (call: stake.InitializeValidatorPayload, ctx: aptos.AptosContext) => void): stake;
+    onEntryJoinValidatorSet(func: (call: stake.JoinValidatorSetPayload, ctx: aptos.AptosContext) => void): stake;
+    onEntryLeaveValidatorSet(func: (call: stake.LeaveValidatorSetPayload, ctx: aptos.AptosContext) => void): stake;
+    onEntryReactivateStake(func: (call: stake.ReactivateStakePayload, ctx: aptos.AptosContext) => void): stake;
+    onEntryRotateConsensusKey(func: (call: stake.RotateConsensusKeyPayload, ctx: aptos.AptosContext) => void): stake;
+    onEntrySetDelegatedVoter(func: (call: stake.SetDelegatedVoterPayload, ctx: aptos.AptosContext) => void): stake;
+    onEntrySetOperator(func: (call: stake.SetOperatorPayload, ctx: aptos.AptosContext) => void): stake;
+    onEntryUnlock(func: (call: stake.UnlockPayload, ctx: aptos.AptosContext) => void): stake;
+    onEntryUpdateNetworkAndFullnodeAddresses(func: (call: stake.UpdateNetworkAndFullnodeAddressesPayload, ctx: aptos.AptosContext) => void): stake;
+    onEntryWithdraw(func: (call: stake.WithdrawPayload, ctx: aptos.AptosContext) => void): stake;
+    onEventAddStakeEvent(func: (event: stake.AddStakeEventInstance, ctx: aptos.AptosContext) => void): stake;
+    onEventDistributeRewardsEvent(func: (event: stake.DistributeRewardsEventInstance, ctx: aptos.AptosContext) => void): stake;
+    onEventIncreaseLockupEvent(func: (event: stake.IncreaseLockupEventInstance, ctx: aptos.AptosContext) => void): stake;
+    onEventJoinValidatorSetEvent(func: (event: stake.JoinValidatorSetEventInstance, ctx: aptos.AptosContext) => void): stake;
+    onEventLeaveValidatorSetEvent(func: (event: stake.LeaveValidatorSetEventInstance, ctx: aptos.AptosContext) => void): stake;
+    onEventReactivateStakeEvent(func: (event: stake.ReactivateStakeEventInstance, ctx: aptos.AptosContext) => void): stake;
+    onEventRegisterValidatorCandidateEvent(func: (event: stake.RegisterValidatorCandidateEventInstance, ctx: aptos.AptosContext) => void): stake;
+    onEventRotateConsensusKeyEvent(func: (event: stake.RotateConsensusKeyEventInstance, ctx: aptos.AptosContext) => void): stake;
+    onEventSetOperatorEvent(func: (event: stake.SetOperatorEventInstance, ctx: aptos.AptosContext) => void): stake;
+    onEventUnlockStakeEvent(func: (event: stake.UnlockStakeEventInstance, ctx: aptos.AptosContext) => void): stake;
+    onEventUpdateNetworkAndFullnodeAddressesEvent(func: (event: stake.UpdateNetworkAndFullnodeAddressesEventInstance, ctx: aptos.AptosContext) => void): stake;
+    onEventWithdrawStakeEvent(func: (event: stake.WithdrawStakeEventInstance, ctx: aptos.AptosContext) => void): stake;
+    loadTypesInternal(registry: aptos.TypeRegistry): void;
+}
+export declare namespace stake {
+    class AddStakeEvent {
+        pool_address: Address;
+        amount_added: bigint;
+    }
+    interface AddStakeEventInstance extends aptos.TypedEventInstance<AddStakeEvent> {
+        data_typed: AddStakeEvent;
+    }
+    class AllowedValidators {
+        accounts: Address[];
+    }
+    class AptosCoinCapabilities {
+        mint_cap: coin.MintCapability<aptos_coin.AptosCoin>;
+    }
+    class DistributeRewardsEvent {
+        pool_address: Address;
+        rewards_amount: bigint;
+    }
+    interface DistributeRewardsEventInstance extends aptos.TypedEventInstance<DistributeRewardsEvent> {
+        data_typed: DistributeRewardsEvent;
+    }
+    class IncreaseLockupEvent {
+        pool_address: Address;
+        old_locked_until_secs: bigint;
+        new_locked_until_secs: bigint;
+    }
+    interface IncreaseLockupEventInstance extends aptos.TypedEventInstance<IncreaseLockupEvent> {
+        data_typed: IncreaseLockupEvent;
+    }
+    class IndividualValidatorPerformance {
+        successful_proposals: bigint;
+        failed_proposals: bigint;
+    }
+    class JoinValidatorSetEvent {
+        pool_address: Address;
+    }
+    interface JoinValidatorSetEventInstance extends aptos.TypedEventInstance<JoinValidatorSetEvent> {
+        data_typed: JoinValidatorSetEvent;
+    }
+    class LeaveValidatorSetEvent {
+        pool_address: Address;
+    }
+    interface LeaveValidatorSetEventInstance extends aptos.TypedEventInstance<LeaveValidatorSetEvent> {
+        data_typed: LeaveValidatorSetEvent;
+    }
+    class OwnerCapability {
+        pool_address: Address;
+    }
+    class ReactivateStakeEvent {
+        pool_address: Address;
+        amount: bigint;
+    }
+    interface ReactivateStakeEventInstance extends aptos.TypedEventInstance<ReactivateStakeEvent> {
+        data_typed: ReactivateStakeEvent;
+    }
+    class RegisterValidatorCandidateEvent {
+        pool_address: Address;
+    }
+    interface RegisterValidatorCandidateEventInstance extends aptos.TypedEventInstance<RegisterValidatorCandidateEvent> {
+        data_typed: RegisterValidatorCandidateEvent;
+    }
+    class RotateConsensusKeyEvent {
+        pool_address: Address;
+        old_consensus_pubkey: string;
+        new_consensus_pubkey: string;
+    }
+    interface RotateConsensusKeyEventInstance extends aptos.TypedEventInstance<RotateConsensusKeyEvent> {
+        data_typed: RotateConsensusKeyEvent;
+    }
+    class SetOperatorEvent {
+        pool_address: Address;
+        old_operator: Address;
+        new_operator: Address;
+    }
+    interface SetOperatorEventInstance extends aptos.TypedEventInstance<SetOperatorEvent> {
+        data_typed: SetOperatorEvent;
+    }
+    class 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>;
+    }
+    class UnlockStakeEvent {
+        pool_address: Address;
+        amount_unlocked: bigint;
+    }
+    interface UnlockStakeEventInstance extends aptos.TypedEventInstance<UnlockStakeEvent> {
+        data_typed: UnlockStakeEvent;
+    }
+    class UpdateNetworkAndFullnodeAddressesEvent {
+        pool_address: Address;
+        old_network_addresses: string;
+        new_network_addresses: string;
+        old_fullnode_addresses: string;
+        new_fullnode_addresses: string;
+    }
+    interface UpdateNetworkAndFullnodeAddressesEventInstance extends aptos.TypedEventInstance<UpdateNetworkAndFullnodeAddressesEvent> {
+        data_typed: UpdateNetworkAndFullnodeAddressesEvent;
+    }
+    class ValidatorConfig {
+        consensus_pubkey: string;
+        network_addresses: string;
+        fullnode_addresses: string;
+        validator_index: bigint;
+    }
+    class ValidatorInfo {
+        addr: Address;
+        voting_power: bigint;
+        config: stake.ValidatorConfig;
+    }
+    class ValidatorPerformance {
+        validators: stake.IndividualValidatorPerformance[];
+    }
+    class ValidatorSet {
+        consensus_scheme: number;
+        active_validators: stake.ValidatorInfo[];
+        pending_inactive: stake.ValidatorInfo[];
+        pending_active: stake.ValidatorInfo[];
+        total_voting_power: bigint;
+        total_joining_power: bigint;
+    }
+    class WithdrawStakeEvent {
+        pool_address: Address;
+        amount_withdrawn: bigint;
+    }
+    interface WithdrawStakeEventInstance extends aptos.TypedEventInstance<WithdrawStakeEvent> {
+        data_typed: WithdrawStakeEvent;
+    }
+    interface AddStakePayload extends aptos.TypedEntryFunctionPayload<[bigint]> {
+        arguments_typed: [bigint];
+    }
+    interface IncreaseLockupPayload extends aptos.TypedEntryFunctionPayload<[]> {
+        arguments_typed: [];
+    }
+    interface InitializeStakeOwnerPayload extends aptos.TypedEntryFunctionPayload<[bigint, Address, Address]> {
+        arguments_typed: [bigint, Address, Address];
+    }
+    interface InitializeValidatorPayload extends aptos.TypedEntryFunctionPayload<[string, string, string, string]> {
+        arguments_typed: [string, string, string, string];
+    }
+    interface JoinValidatorSetPayload extends aptos.TypedEntryFunctionPayload<[Address]> {
+        arguments_typed: [Address];
+    }
+    interface LeaveValidatorSetPayload extends aptos.TypedEntryFunctionPayload<[Address]> {
+        arguments_typed: [Address];
+    }
+    interface ReactivateStakePayload extends aptos.TypedEntryFunctionPayload<[bigint]> {
+        arguments_typed: [bigint];
+    }
+    interface RotateConsensusKeyPayload extends aptos.TypedEntryFunctionPayload<[Address, string, string]> {
+        arguments_typed: [Address, string, string];
+    }
+    interface SetDelegatedVoterPayload extends aptos.TypedEntryFunctionPayload<[Address]> {
+        arguments_typed: [Address];
+    }
+    interface SetOperatorPayload extends aptos.TypedEntryFunctionPayload<[Address]> {
+        arguments_typed: [Address];
+    }
+    interface UnlockPayload extends aptos.TypedEntryFunctionPayload<[bigint]> {
+        arguments_typed: [bigint];
+    }
+    interface UpdateNetworkAndFullnodeAddressesPayload extends aptos.TypedEntryFunctionPayload<[Address, string, string]> {
+        arguments_typed: [Address, string, string];
+    }
+    interface WithdrawPayload extends aptos.TypedEntryFunctionPayload<[bigint]> {
+        arguments_typed: [bigint];
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace table {
+    class Box<T0> {
+        val: T0;
+    }
+    class Table<T0, T1> {
+        handle: Address;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace math64 {
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace option {
+    class Option<T0> {
+        vec: T0[] | string;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace signer {
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace string {
+    class String {
+        bytes: string;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace vector {
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare class voting extends aptos.AptosBaseProcessor {
+    constructor(options: aptos.AptosBindOptions);
+    static DEFAULT_OPTIONS: aptos.AptosBindOptions;
+    static bind(options?: Partial<aptos.AptosBindOptions>): voting;
+    onEventCreateProposalEvent(func: (event: voting.CreateProposalEventInstance, ctx: aptos.AptosContext) => void): voting;
+    onEventRegisterForumEvent(func: (event: voting.RegisterForumEventInstance, ctx: aptos.AptosContext) => void): voting;
+    onEventVoteEvent(func: (event: voting.VoteEventInstance, ctx: aptos.AptosContext) => void): voting;
+    loadTypesInternal(registry: aptos.TypeRegistry): void;
+}
+export declare namespace voting {
+    class 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;
+    }
+    interface CreateProposalEventInstance extends aptos.TypedEventInstance<CreateProposalEvent> {
+        data_typed: CreateProposalEvent;
+    }
+    class 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;
+    }
+    class RegisterForumEvent {
+        hosting_account: Address;
+        proposal_type_info: type_info.TypeInfo;
+    }
+    interface RegisterForumEventInstance extends aptos.TypedEventInstance<RegisterForumEvent> {
+        data_typed: RegisterForumEvent;
+    }
+    class ResolveProposal {
+        proposal_id: bigint;
+        yes_votes: bigint;
+        no_votes: bigint;
+        resolved_early: Boolean;
+    }
+    class VoteEvent {
+        proposal_id: bigint;
+        num_votes: bigint;
+    }
+    interface VoteEventInstance extends aptos.TypedEventInstance<VoteEvent> {
+        data_typed: VoteEvent;
+    }
+    class 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>;
+    }
+    class VotingForum<T0> {
+        proposals: table.Table<bigint, voting.Proposal<T0>>;
+        events: voting.VotingEvents;
+        next_proposal_id: bigint;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare class account extends aptos.AptosBaseProcessor {
+    constructor(options: aptos.AptosBindOptions);
+    static DEFAULT_OPTIONS: aptos.AptosBindOptions;
+    static bind(options?: Partial<aptos.AptosBindOptions>): account;
+    onEntryOfferSignerCapability(func: (call: account.OfferSignerCapabilityPayload, ctx: aptos.AptosContext) => void): account;
+    onEntryRevokeSignerCapability(func: (call: account.RevokeSignerCapabilityPayload, ctx: aptos.AptosContext) => void): account;
+    onEntryRotateAuthenticationKey(func: (call: account.RotateAuthenticationKeyPayload, ctx: aptos.AptosContext) => void): account;
+    onEventCoinRegisterEvent(func: (event: account.CoinRegisterEventInstance, ctx: aptos.AptosContext) => void): account;
+    onEventKeyRotationEvent(func: (event: account.KeyRotationEventInstance, ctx: aptos.AptosContext) => void): account;
+    loadTypesInternal(registry: aptos.TypeRegistry): void;
+}
+export declare namespace account {
+    class 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>;
+    }
+    class CapabilityOffer<T0> {
+        for: option.Option<Address>;
+    }
+    class CoinRegisterEvent {
+        type_info: type_info.TypeInfo;
+    }
+    interface CoinRegisterEventInstance extends aptos.TypedEventInstance<CoinRegisterEvent> {
+        data_typed: CoinRegisterEvent;
+    }
+    class KeyRotationEvent {
+        old_authentication_key: string;
+        new_authentication_key: string;
+    }
+    interface KeyRotationEventInstance extends aptos.TypedEventInstance<KeyRotationEvent> {
+        data_typed: KeyRotationEvent;
+    }
+    class OriginatingAddress {
+        address_map: table.Table<Address, Address>;
+    }
+    class RotationCapability {
+        account: Address;
+    }
+    class RotationCapabilityOfferProofChallenge {
+        sequence_number: bigint;
+        recipient_address: Address;
+    }
+    class RotationProofChallenge {
+        sequence_number: bigint;
+        originator: Address;
+        current_auth_key: Address;
+        new_public_key: string;
+    }
+    class SignerCapability {
+        account: Address;
+    }
+    class SignerCapabilityOfferProofChallenge {
+        sequence_number: bigint;
+        recipient_address: Address;
+    }
+    class SignerCapabilityOfferProofChallengeV2 {
+        sequence_number: bigint;
+        source_address: Address;
+        recipient_address: Address;
+    }
+    interface OfferSignerCapabilityPayload extends aptos.TypedEntryFunctionPayload<[string, number, string, Address]> {
+        arguments_typed: [string, number, string, Address];
+    }
+    interface RevokeSignerCapabilityPayload extends aptos.TypedEntryFunctionPayload<[Address]> {
+        arguments_typed: [Address];
+    }
+    interface RotateAuthenticationKeyPayload extends aptos.TypedEntryFunctionPayload<[
+        number,
+        string,
+        number,
+        string,
+        string,
+        string
+    ]> {
+        arguments_typed: [number, string, number, string, string, string];
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace ed25519 {
+    class Signature {
+        bytes: string;
+    }
+    class SignedMessage<T0> {
+        type_info: type_info.TypeInfo;
+        inner: T0;
+    }
+    class UnvalidatedPublicKey {
+        bytes: string;
+    }
+    class ValidatedPublicKey {
+        bytes: string;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace genesis {
+    class AccountMap {
+        account_address: Address;
+        balance: bigint;
+    }
+    class EmployeeAccountMap {
+        accounts: Address[];
+        validator: genesis.ValidatorConfigurationWithCommission;
+        vesting_schedule_numerator: bigint[];
+        vesting_schedule_denominator: bigint;
+        beneficiary_resetter: Address;
+    }
+    class 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;
+    }
+    class ValidatorConfigurationWithCommission {
+        validator_config: genesis.ValidatorConfiguration;
+        commission_percentage: bigint;
+        join_during_genesis: Boolean;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace math128 {
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare class version extends aptos.AptosBaseProcessor {
+    constructor(options: aptos.AptosBindOptions);
+    static DEFAULT_OPTIONS: aptos.AptosBindOptions;
+    static bind(options?: Partial<aptos.AptosBindOptions>): version;
+    onEntrySetVersion(func: (call: version.SetVersionPayload, ctx: aptos.AptosContext) => void): version;
+    loadTypesInternal(registry: aptos.TypeRegistry): void;
+}
+export declare namespace version {
+    class SetVersionCapability {
+        dummy_field: Boolean;
+    }
+    class Version {
+        major: bigint;
+    }
+    interface SetVersionPayload extends aptos.TypedEntryFunctionPayload<[bigint]> {
+        arguments_typed: [bigint];
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare class vesting extends aptos.AptosBaseProcessor {
+    constructor(options: aptos.AptosBindOptions);
+    static DEFAULT_OPTIONS: aptos.AptosBindOptions;
+    static bind(options?: Partial<aptos.AptosBindOptions>): vesting;
+    onEntryAdminWithdraw(func: (call: vesting.AdminWithdrawPayload, ctx: aptos.AptosContext) => void): vesting;
+    onEntryDistribute(func: (call: vesting.DistributePayload, ctx: aptos.AptosContext) => void): vesting;
+    onEntryResetBeneficiary(func: (call: vesting.ResetBeneficiaryPayload, ctx: aptos.AptosContext) => void): vesting;
+    onEntryResetLockup(func: (call: vesting.ResetLockupPayload, ctx: aptos.AptosContext) => void): vesting;
+    onEntrySetBeneficiary(func: (call: vesting.SetBeneficiaryPayload, ctx: aptos.AptosContext) => void): vesting;
+    onEntrySetBeneficiaryResetter(func: (call: vesting.SetBeneficiaryResetterPayload, ctx: aptos.AptosContext) => void): vesting;
+    onEntrySetManagementRole(func: (call: vesting.SetManagementRolePayload, ctx: aptos.AptosContext) => void): vesting;
+    onEntryTerminateVestingContract(func: (call: vesting.TerminateVestingContractPayload, ctx: aptos.AptosContext) => void): vesting;
+    onEntryUnlockRewards(func: (call: vesting.UnlockRewardsPayload, ctx: aptos.AptosContext) => void): vesting;
+    onEntryUpdateOperator(func: (call: vesting.UpdateOperatorPayload, ctx: aptos.AptosContext) => void): vesting;
+    onEntryUpdateOperatorWithSameCommission(func: (call: vesting.UpdateOperatorWithSameCommissionPayload, ctx: aptos.AptosContext) => void): vesting;
+    onEntryUpdateVoter(func: (call: vesting.UpdateVoterPayload, ctx: aptos.AptosContext) => void): vesting;
+    onEntryVest(func: (call: vesting.VestPayload, ctx: aptos.AptosContext) => void): vesting;
+    onEventAdminWithdrawEvent(func: (event: vesting.AdminWithdrawEventInstance, ctx: aptos.AptosContext) => void): vesting;
+    onEventCreateVestingContractEvent(func: (event: vesting.CreateVestingContractEventInstance, ctx: aptos.AptosContext) => void): vesting;
+    onEventDistributeEvent(func: (event: vesting.DistributeEventInstance, ctx: aptos.AptosContext) => void): vesting;
+    onEventResetLockupEvent(func: (event: vesting.ResetLockupEventInstance, ctx: aptos.AptosContext) => void): vesting;
+    onEventSetBeneficiaryEvent(func: (event: vesting.SetBeneficiaryEventInstance, ctx: aptos.AptosContext) => void): vesting;
+    onEventTerminateEvent(func: (event: vesting.TerminateEventInstance, ctx: aptos.AptosContext) => void): vesting;
+    onEventUnlockRewardsEvent(func: (event: vesting.UnlockRewardsEventInstance, ctx: aptos.AptosContext) => void): vesting;
+    onEventUpdateOperatorEvent(func: (event: vesting.UpdateOperatorEventInstance, ctx: aptos.AptosContext) => void): vesting;
+    onEventUpdateVoterEvent(func: (event: vesting.UpdateVoterEventInstance, ctx: aptos.AptosContext) => void): vesting;
+    onEventVestEvent(func: (event: vesting.VestEventInstance, ctx: aptos.AptosContext) => void): vesting;
+    loadTypesInternal(registry: aptos.TypeRegistry): void;
+}
+export declare namespace vesting {
+    class AdminStore {
+        vesting_contracts: Address[];
+        nonce: bigint;
+        create_events: event.EventHandle<vesting.CreateVestingContractEvent>;
+    }
+    class AdminWithdrawEvent {
+        admin: Address;
+        vesting_contract_address: Address;
+        amount: bigint;
+    }
+    interface AdminWithdrawEventInstance extends aptos.TypedEventInstance<AdminWithdrawEvent> {
+        data_typed: AdminWithdrawEvent;
+    }
+    class CreateVestingContractEvent {
+        operator: Address;
+        voter: Address;
+        grant_amount: bigint;
+        withdrawal_address: Address;
+        vesting_contract_address: Address;
+        staking_pool_address: Address;
+        commission_percentage: bigint;
+    }
+    interface CreateVestingContractEventInstance extends aptos.TypedEventInstance<CreateVestingContractEvent> {
+        data_typed: CreateVestingContractEvent;
+    }
+    class DistributeEvent {
+        admin: Address;
+        vesting_contract_address: Address;
+        amount: bigint;
+    }
+    interface DistributeEventInstance extends aptos.TypedEventInstance<DistributeEvent> {
+        data_typed: DistributeEvent;
+    }
+    class ResetLockupEvent {
+        admin: Address;
+        vesting_contract_address: Address;
+        staking_pool_address: Address;
+        new_lockup_expiration_secs: bigint;
+    }
+    interface ResetLockupEventInstance extends aptos.TypedEventInstance<ResetLockupEvent> {
+        data_typed: ResetLockupEvent;
+    }
+    class SetBeneficiaryEvent {
+        admin: Address;
+        vesting_contract_address: Address;
+        shareholder: Address;
+        old_beneficiary: Address;
+        new_beneficiary: Address;
+    }
+    interface SetBeneficiaryEventInstance extends aptos.TypedEventInstance<SetBeneficiaryEvent> {
+        data_typed: SetBeneficiaryEvent;
+    }
+    class StakingInfo {
+        pool_address: Address;
+        operator: Address;
+        voter: Address;
+        commission_percentage: bigint;
+    }
+    class TerminateEvent {
+        admin: Address;
+        vesting_contract_address: Address;
+    }
+    interface TerminateEventInstance extends aptos.TypedEventInstance<TerminateEvent> {
+        data_typed: TerminateEvent;
+    }
+    class UnlockRewardsEvent {
+        admin: Address;
+        vesting_contract_address: Address;
+        staking_pool_address: Address;
+        amount: bigint;
+    }
+    interface UnlockRewardsEventInstance extends aptos.TypedEventInstance<UnlockRewardsEvent> {
+        data_typed: UnlockRewardsEvent;
+    }
+    class UpdateOperatorEvent {
+        admin: Address;
+        vesting_contract_address: Address;
+        staking_pool_address: Address;
+        old_operator: Address;
+        new_operator: Address;
+        commission_percentage: bigint;
+    }
+    interface UpdateOperatorEventInstance extends aptos.TypedEventInstance<UpdateOperatorEvent> {
+        data_typed: UpdateOperatorEvent;
+    }
+    class UpdateVoterEvent {
+        admin: Address;
+        vesting_contract_address: Address;
+        staking_pool_address: Address;
+        old_voter: Address;
+        new_voter: Address;
+    }
+    interface UpdateVoterEventInstance extends aptos.TypedEventInstance<UpdateVoterEvent> {
+        data_typed: UpdateVoterEvent;
+    }
+    class VestEvent {
+        admin: Address;
+        vesting_contract_address: Address;
+        staking_pool_address: Address;
+        period_vested: bigint;
+        amount: bigint;
+    }
+    interface VestEventInstance extends aptos.TypedEventInstance<VestEvent> {
+        data_typed: VestEvent;
+    }
+    class VestingAccountManagement {
+        roles: simple_map.SimpleMap<string, Address>;
+    }
+    class 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>;
+    }
+    class VestingSchedule {
+        schedule: fixed_point32.FixedPoint32[];
+        start_timestamp_secs: bigint;
+        period_duration: bigint;
+        last_vested_period: bigint;
+    }
+    interface AdminWithdrawPayload extends aptos.TypedEntryFunctionPayload<[Address]> {
+        arguments_typed: [Address];
+    }
+    interface DistributePayload extends aptos.TypedEntryFunctionPayload<[]> {
+        arguments_typed: [];
+    }
+    interface ResetBeneficiaryPayload extends aptos.TypedEntryFunctionPayload<[Address, Address]> {
+        arguments_typed: [Address, Address];
+    }
+    interface ResetLockupPayload extends aptos.TypedEntryFunctionPayload<[Address]> {
+        arguments_typed: [Address];
+    }
+    interface SetBeneficiaryPayload extends aptos.TypedEntryFunctionPayload<[Address, Address, Address]> {
+        arguments_typed: [Address, Address, Address];
+    }
+    interface SetBeneficiaryResetterPayload extends aptos.TypedEntryFunctionPayload<[Address, Address]> {
+        arguments_typed: [Address, Address];
+    }
+    interface SetManagementRolePayload extends aptos.TypedEntryFunctionPayload<[Address, string, Address]> {
+        arguments_typed: [Address, string, Address];
+    }
+    interface TerminateVestingContractPayload extends aptos.TypedEntryFunctionPayload<[Address]> {
+        arguments_typed: [Address];
+    }
+    interface UnlockRewardsPayload extends aptos.TypedEntryFunctionPayload<[]> {
+        arguments_typed: [];
+    }
+    interface UpdateOperatorPayload extends aptos.TypedEntryFunctionPayload<[Address, Address, bigint]> {
+        arguments_typed: [Address, Address, bigint];
+    }
+    interface UpdateOperatorWithSameCommissionPayload extends aptos.TypedEntryFunctionPayload<[Address, Address]> {
+        arguments_typed: [Address, Address];
+    }
+    interface UpdateVoterPayload extends aptos.TypedEntryFunctionPayload<[Address, Address]> {
+        arguments_typed: [Address, Address];
+    }
+    interface VestPayload extends aptos.TypedEntryFunctionPayload<[]> {
+        arguments_typed: [];
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace bls12381 {
+    class AggrOrMultiSignature {
+        bytes: string;
+    }
+    class AggrPublicKeysWithPoP {
+        bytes: string;
+    }
+    class ProofOfPossession {
+        bytes: string;
+    }
+    class PublicKey {
+        bytes: string;
+    }
+    class PublicKeyWithPoP {
+        bytes: string;
+    }
+    class Signature {
+        bytes: string;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace chain_id {
+    class ChainId {
+        id: number;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace features {
+    class Features {
+        features: string;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace from_bcs {
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace pool_u64 {
+    class Pool {
+        shareholders_limit: bigint;
+        total_coins: bigint;
+        total_shares: bigint;
+        shares: simple_map.SimpleMap<Address, bigint>;
+        shareholders: Address[];
+        scaling_factor: bigint;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace secp256k1 {
+    class ECDSARawPublicKey {
+        bytes: string;
+    }
+    class ECDSASignature {
+        bytes: string;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace timestamp {
+    class CurrentTimeMicroseconds {
+        microseconds: bigint;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace type_info {
+    class TypeInfo {
+        account_address: Address;
+        module_name: string;
+        struct_name: string;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace aggregator {
+    class Aggregator {
+        handle: Address;
+        key: Address;
+        limit: bigint;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare class aptos_coin extends aptos.AptosBaseProcessor {
+    constructor(options: aptos.AptosBindOptions);
+    static DEFAULT_OPTIONS: aptos.AptosBindOptions;
+    static bind(options?: Partial<aptos.AptosBindOptions>): aptos_coin;
+    onEntryClaimMintCapability(func: (call: aptos_coin.ClaimMintCapabilityPayload, ctx: aptos.AptosContext) => void): aptos_coin;
+    onEntryDelegateMintCapability(func: (call: aptos_coin.DelegateMintCapabilityPayload, ctx: aptos.AptosContext) => void): aptos_coin;
+    onEntryMint(func: (call: aptos_coin.MintPayload, ctx: aptos.AptosContext) => void): aptos_coin;
+    loadTypesInternal(registry: aptos.TypeRegistry): void;
+}
+export declare namespace aptos_coin {
+    class AptosCoin {
+        dummy_field: Boolean;
+    }
+    class DelegatedMintCapability {
+        to: Address;
+    }
+    class Delegations {
+        inner: aptos_coin.DelegatedMintCapability[];
+    }
+    class MintCapStore {
+        mint_cap: coin.MintCapability<aptos_coin.AptosCoin>;
+    }
+    interface ClaimMintCapabilityPayload extends aptos.TypedEntryFunctionPayload<[]> {
+        arguments_typed: [];
+    }
+    interface DelegateMintCapabilityPayload extends aptos.TypedEntryFunctionPayload<[Address]> {
+        arguments_typed: [Address];
+    }
+    interface MintPayload extends aptos.TypedEntryFunctionPayload<[Address, bigint]> {
+        arguments_typed: [Address, bigint];
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace aptos_hash {
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace bit_vector {
+    class BitVector {
+        length: bigint;
+        bit_field: Boolean[];
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace capability {
+    class Cap<T0> {
+        root: Address;
+    }
+    class CapDelegateState<T0> {
+        root: Address;
+    }
+    class CapState<T0> {
+        delegates: Address[];
+    }
+    class LinearCap<T0> {
+        root: Address;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace comparator {
+    class Result {
+        inner: number;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace simple_map {
+    class Element<T0, T1> {
+        key: T0;
+        value: T1;
+    }
+    class SimpleMap<T0, T1> {
+        data: simple_map.Element<T0, T1>[];
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace storage_gas {
+    class GasCurve {
+        min_gas: bigint;
+        max_gas: bigint;
+        points: storage_gas.Point[];
+    }
+    class Point {
+        x: bigint;
+        y: bigint;
+    }
+    class 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;
+    }
+    class StorageGasConfig {
+        item_config: storage_gas.UsageGasConfig;
+        byte_config: storage_gas.UsageGasConfig;
+    }
+    class UsageGasConfig {
+        target_usage: bigint;
+        read_curve: storage_gas.GasCurve;
+        create_curve: storage_gas.GasCurve;
+        write_curve: storage_gas.GasCurve;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace chain_status {
+    class GenesisEndMarker {
+        dummy_field: Boolean;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace copyable_any {
+    class Any {
+        type_name: string;
+        data: string;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace gas_schedule {
+    class GasEntry {
+        key: string;
+        val: bigint;
+    }
+    class GasSchedule {
+        entries: gas_schedule.GasEntry[];
+    }
+    class GasScheduleV2 {
+        feature_version: bigint;
+        entries: gas_schedule.GasEntry[];
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare class managed_coin extends aptos.AptosBaseProcessor {
+    constructor(options: aptos.AptosBindOptions);
+    static DEFAULT_OPTIONS: aptos.AptosBindOptions;
+    static bind(options?: Partial<aptos.AptosBindOptions>): managed_coin;
+    onEntryBurn<T0>(func: (call: managed_coin.BurnPayload<T0>, ctx: aptos.AptosContext) => void): managed_coin;
+    onEntryInitialize<T0>(func: (call: managed_coin.InitializePayload<T0>, ctx: aptos.AptosContext) => void): managed_coin;
+    onEntryMint<T0>(func: (call: managed_coin.MintPayload<T0>, ctx: aptos.AptosContext) => void): managed_coin;
+    onEntryRegister<T0>(func: (call: managed_coin.RegisterPayload<T0>, ctx: aptos.AptosContext) => void): managed_coin;
+    loadTypesInternal(registry: aptos.TypeRegistry): void;
+}
+export declare namespace managed_coin {
+    class Capabilities<T0> {
+        burn_cap: coin.BurnCapability<T0>;
+        freeze_cap: coin.FreezeCapability<T0>;
+        mint_cap: coin.MintCapability<T0>;
+    }
+    interface BurnPayload<T0> extends aptos.TypedEntryFunctionPayload<[bigint]> {
+        arguments_typed: [bigint];
+    }
+    interface InitializePayload<T0> extends aptos.TypedEntryFunctionPayload<[string, string, number, Boolean]> {
+        arguments_typed: [string, string, number, Boolean];
+    }
+    interface MintPayload<T0> extends aptos.TypedEntryFunctionPayload<[Address, bigint]> {
+        arguments_typed: [Address, bigint];
+    }
+    interface RegisterPayload<T0> extends aptos.TypedEntryFunctionPayload<[]> {
+        arguments_typed: [];
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace ristretto255 {
+    class CompressedRistretto {
+        data: string;
+    }
+    class RistrettoPoint {
+        handle: bigint;
+    }
+    class Scalar {
+        data: string;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare class aptos_account extends aptos.AptosBaseProcessor {
+    constructor(options: aptos.AptosBindOptions);
+    static DEFAULT_OPTIONS: aptos.AptosBindOptions;
+    static bind(options?: Partial<aptos.AptosBindOptions>): aptos_account;
+    onEntryCreateAccount(func: (call: aptos_account.CreateAccountPayload, ctx: aptos.AptosContext) => void): aptos_account;
+    onEntryTransfer(func: (call: aptos_account.TransferPayload, ctx: aptos.AptosContext) => void): aptos_account;
+    loadTypesInternal(registry: aptos.TypeRegistry): void;
+}
+export declare namespace aptos_account {
+    interface CreateAccountPayload extends aptos.TypedEntryFunctionPayload<[]> {
+        arguments_typed: [];
+    }
+    interface TransferPayload extends aptos.TypedEntryFunctionPayload<[Address, bigint]> {
+        arguments_typed: [Address, bigint];
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace fixed_point32 {
+    class FixedPoint32 {
+        value: bigint;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace multi_ed25519 {
+    class Signature {
+        bytes: string;
+    }
+    class UnvalidatedPublicKey {
+        bytes: string;
+    }
+    class ValidatedPublicKey {
+        bytes: string;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare class staking_proxy extends aptos.AptosBaseProcessor {
+    constructor(options: aptos.AptosBindOptions);
+    static DEFAULT_OPTIONS: aptos.AptosBindOptions;
+    static bind(options?: Partial<aptos.AptosBindOptions>): staking_proxy;
+    onEntrySetOperator(func: (call: staking_proxy.SetOperatorPayload, ctx: aptos.AptosContext) => void): staking_proxy;
+    onEntrySetStakePoolOperator(func: (call: staking_proxy.SetStakePoolOperatorPayload, ctx: aptos.AptosContext) => void): staking_proxy;
+    onEntrySetStakePoolVoter(func: (call: staking_proxy.SetStakePoolVoterPayload, ctx: aptos.AptosContext) => void): staking_proxy;
+    onEntrySetStakingContractOperator(func: (call: staking_proxy.SetStakingContractOperatorPayload, ctx: aptos.AptosContext) => void): staking_proxy;
+    onEntrySetStakingContractVoter(func: (call: staking_proxy.SetStakingContractVoterPayload, ctx: aptos.AptosContext) => void): staking_proxy;
+    onEntrySetVestingContractOperator(func: (call: staking_proxy.SetVestingContractOperatorPayload, ctx: aptos.AptosContext) => void): staking_proxy;
+    onEntrySetVestingContractVoter(func: (call: staking_proxy.SetVestingContractVoterPayload, ctx: aptos.AptosContext) => void): staking_proxy;
+    onEntrySetVoter(func: (call: staking_proxy.SetVoterPayload, ctx: aptos.AptosContext) => void): staking_proxy;
+    loadTypesInternal(registry: aptos.TypeRegistry): void;
+}
+export declare namespace staking_proxy {
+    interface SetOperatorPayload extends aptos.TypedEntryFunctionPayload<[Address, Address]> {
+        arguments_typed: [Address, Address];
+    }
+    interface SetStakePoolOperatorPayload extends aptos.TypedEntryFunctionPayload<[Address]> {
+        arguments_typed: [Address];
+    }
+    interface SetStakePoolVoterPayload extends aptos.TypedEntryFunctionPayload<[Address]> {
+        arguments_typed: [Address];
+    }
+    interface SetStakingContractOperatorPayload extends aptos.TypedEntryFunctionPayload<[Address, Address]> {
+        arguments_typed: [Address, Address];
+    }
+    interface SetStakingContractVoterPayload extends aptos.TypedEntryFunctionPayload<[Address, Address]> {
+        arguments_typed: [Address, Address];
+    }
+    interface SetVestingContractOperatorPayload extends aptos.TypedEntryFunctionPayload<[Address, Address]> {
+        arguments_typed: [Address, Address];
+    }
+    interface SetVestingContractVoterPayload extends aptos.TypedEntryFunctionPayload<[Address, Address]> {
+        arguments_typed: [Address, Address];
+    }
+    interface SetVoterPayload extends aptos.TypedEntryFunctionPayload<[Address, Address]> {
+        arguments_typed: [Address, Address];
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace state_storage {
+    class GasParameter {
+        usage: state_storage.Usage;
+    }
+    class StateStorageUsage {
+        epoch: bigint;
+        usage: state_storage.Usage;
+    }
+    class Usage {
+        items: bigint;
+        bytes: bigint;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace staking_config {
+    class 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;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare class reconfiguration extends aptos.AptosBaseProcessor {
+    constructor(options: aptos.AptosBindOptions);
+    static DEFAULT_OPTIONS: aptos.AptosBindOptions;
+    static bind(options?: Partial<aptos.AptosBindOptions>): reconfiguration;
+    onEventNewEpochEvent(func: (event: reconfiguration.NewEpochEventInstance, ctx: aptos.AptosContext) => void): reconfiguration;
+    loadTypesInternal(registry: aptos.TypeRegistry): void;
+}
+export declare namespace reconfiguration {
+    class Configuration {
+        epoch: bigint;
+        last_reconfiguration_time: bigint;
+        events: event.EventHandle<reconfiguration.NewEpochEvent>;
+    }
+    class DisableReconfiguration {
+        dummy_field: Boolean;
+    }
+    class NewEpochEvent {
+        epoch: bigint;
+    }
+    interface NewEpochEventInstance extends aptos.TypedEventInstance<NewEpochEvent> {
+        data_typed: NewEpochEvent;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace transaction_fee {
+    class AptosCoinCapabilities {
+        burn_cap: coin.BurnCapability<aptos_coin.AptosCoin>;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare class aptos_governance extends aptos.AptosBaseProcessor {
+    constructor(options: aptos.AptosBindOptions);
+    static DEFAULT_OPTIONS: aptos.AptosBindOptions;
+    static bind(options?: Partial<aptos.AptosBindOptions>): aptos_governance;
+    onEntryAddApprovedScriptHashScript(func: (call: aptos_governance.AddApprovedScriptHashScriptPayload, ctx: aptos.AptosContext) => void): aptos_governance;
+    onEntryCreateProposal(func: (call: aptos_governance.CreateProposalPayload, ctx: aptos.AptosContext) => void): aptos_governance;
+    onEntryVote(func: (call: aptos_governance.VotePayload, ctx: aptos.AptosContext) => void): aptos_governance;
+    onEventCreateProposalEvent(func: (event: aptos_governance.CreateProposalEventInstance, ctx: aptos.AptosContext) => void): aptos_governance;
+    onEventUpdateConfigEvent(func: (event: aptos_governance.UpdateConfigEventInstance, ctx: aptos.AptosContext) => void): aptos_governance;
+    onEventVoteEvent(func: (event: aptos_governance.VoteEventInstance, ctx: aptos.AptosContext) => void): aptos_governance;
+    loadTypesInternal(registry: aptos.TypeRegistry): void;
+}
+export declare namespace aptos_governance {
+    class ApprovedExecutionHashes {
+        hashes: simple_map.SimpleMap<bigint, string>;
+    }
+    class CreateProposalEvent {
+        proposer: Address;
+        stake_pool: Address;
+        proposal_id: bigint;
+        execution_hash: string;
+        proposal_metadata: simple_map.SimpleMap<string, string>;
+    }
+    interface CreateProposalEventInstance extends aptos.TypedEventInstance<CreateProposalEvent> {
+        data_typed: CreateProposalEvent;
+    }
+    class GovernanceConfig {
+        min_voting_threshold: bigint;
+        required_proposer_stake: bigint;
+        voting_duration_secs: bigint;
+    }
+    class GovernanceEvents {
+        create_proposal_events: event.EventHandle<aptos_governance.CreateProposalEvent>;
+        update_config_events: event.EventHandle<aptos_governance.UpdateConfigEvent>;
+        vote_events: event.EventHandle<aptos_governance.VoteEvent>;
+    }
+    class GovernanceResponsbility {
+        signer_caps: simple_map.SimpleMap<Address, account.SignerCapability>;
+    }
+    class RecordKey {
+        stake_pool: Address;
+        proposal_id: bigint;
+    }
+    class UpdateConfigEvent {
+        min_voting_threshold: bigint;
+        required_proposer_stake: bigint;
+        voting_duration_secs: bigint;
+    }
+    interface UpdateConfigEventInstance extends aptos.TypedEventInstance<UpdateConfigEvent> {
+        data_typed: UpdateConfigEvent;
+    }
+    class VoteEvent {
+        proposal_id: bigint;
+        voter: Address;
+        stake_pool: Address;
+        num_votes: bigint;
+        should_pass: Boolean;
+    }
+    interface VoteEventInstance extends aptos.TypedEventInstance<VoteEvent> {
+        data_typed: VoteEvent;
+    }
+    class VotingRecords {
+        votes: table.Table<aptos_governance.RecordKey, Boolean>;
+    }
+    interface AddApprovedScriptHashScriptPayload extends aptos.TypedEntryFunctionPayload<[]> {
+        arguments_typed: [];
+    }
+    interface CreateProposalPayload extends aptos.TypedEntryFunctionPayload<[Address, string, string, string]> {
+        arguments_typed: [Address, string, string, string];
+    }
+    interface VotePayload extends aptos.TypedEntryFunctionPayload<[Address, bigint, Boolean]> {
+        arguments_typed: [Address, bigint, Boolean];
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace consensus_config {
+    class ConsensusConfig {
+        config: string;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare class resource_account extends aptos.AptosBaseProcessor {
+    constructor(options: aptos.AptosBindOptions);
+    static DEFAULT_OPTIONS: aptos.AptosBindOptions;
+    static bind(options?: Partial<aptos.AptosBindOptions>): resource_account;
+    onEntryCreateResourceAccount(func: (call: resource_account.CreateResourceAccountPayload, ctx: aptos.AptosContext) => void): resource_account;
+    onEntryCreateResourceAccountAndFund(func: (call: resource_account.CreateResourceAccountAndFundPayload, ctx: aptos.AptosContext) => void): resource_account;
+    onEntryCreateResourceAccountAndPublishPackage(func: (call: resource_account.CreateResourceAccountAndPublishPackagePayload, ctx: aptos.AptosContext) => void): resource_account;
+    loadTypesInternal(registry: aptos.TypeRegistry): void;
+}
+export declare namespace resource_account {
+    class Container {
+        store: simple_map.SimpleMap<Address, account.SignerCapability>;
+    }
+    interface CreateResourceAccountPayload extends aptos.TypedEntryFunctionPayload<[string, string]> {
+        arguments_typed: [string, string];
+    }
+    interface CreateResourceAccountAndFundPayload extends aptos.TypedEntryFunctionPayload<[string, string, bigint]> {
+        arguments_typed: [string, string, bigint];
+    }
+    interface CreateResourceAccountAndPublishPackagePayload extends aptos.TypedEntryFunctionPayload<[string, string, string[]]> {
+        arguments_typed: [string, string, string[]];
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare class staking_contract extends aptos.AptosBaseProcessor {
+    constructor(options: aptos.AptosBindOptions);
+    static DEFAULT_OPTIONS: aptos.AptosBindOptions;
+    static bind(options?: Partial<aptos.AptosBindOptions>): staking_contract;
+    onEntryAddStake(func: (call: staking_contract.AddStakePayload, ctx: aptos.AptosContext) => void): staking_contract;
+    onEntryCreateStakingContract(func: (call: staking_contract.CreateStakingContractPayload, ctx: aptos.AptosContext) => void): staking_contract;
+    onEntryDistribute(func: (call: staking_contract.DistributePayload, ctx: aptos.AptosContext) => void): staking_contract;
+    onEntryRequestCommission(func: (call: staking_contract.RequestCommissionPayload, ctx: aptos.AptosContext) => void): staking_contract;
+    onEntryResetLockup(func: (call: staking_contract.ResetLockupPayload, ctx: aptos.AptosContext) => void): staking_contract;
+    onEntrySwitchOperator(func: (call: staking_contract.SwitchOperatorPayload, ctx: aptos.AptosContext) => void): staking_contract;
+    onEntrySwitchOperatorWithSameCommission(func: (call: staking_contract.SwitchOperatorWithSameCommissionPayload, ctx: aptos.AptosContext) => void): staking_contract;
+    onEntryUnlockRewards(func: (call: staking_contract.UnlockRewardsPayload, ctx: aptos.AptosContext) => void): staking_contract;
+    onEntryUnlockStake(func: (call: staking_contract.UnlockStakePayload, ctx: aptos.AptosContext) => void): staking_contract;
+    onEntryUpdateVoter(func: (call: staking_contract.UpdateVoterPayload, ctx: aptos.AptosContext) => void): staking_contract;
+    onEventAddDistributionEvent(func: (event: staking_contract.AddDistributionEventInstance, ctx: aptos.AptosContext) => void): staking_contract;
+    onEventAddStakeEvent(func: (event: staking_contract.AddStakeEventInstance, ctx: aptos.AptosContext) => void): staking_contract;
+    onEventCreateStakingContractEvent(func: (event: staking_contract.CreateStakingContractEventInstance, ctx: aptos.AptosContext) => void): staking_contract;
+    onEventDistributeEvent(func: (event: staking_contract.DistributeEventInstance, ctx: aptos.AptosContext) => void): staking_contract;
+    onEventRequestCommissionEvent(func: (event: staking_contract.RequestCommissionEventInstance, ctx: aptos.AptosContext) => void): staking_contract;
+    onEventResetLockupEvent(func: (event: staking_contract.ResetLockupEventInstance, ctx: aptos.AptosContext) => void): staking_contract;
+    onEventSwitchOperatorEvent(func: (event: staking_contract.SwitchOperatorEventInstance, ctx: aptos.AptosContext) => void): staking_contract;
+    onEventUnlockStakeEvent(func: (event: staking_contract.UnlockStakeEventInstance, ctx: aptos.AptosContext) => void): staking_contract;
+    onEventUpdateVoterEvent(func: (event: staking_contract.UpdateVoterEventInstance, ctx: aptos.AptosContext) => void): staking_contract;
+    loadTypesInternal(registry: aptos.TypeRegistry): void;
+}
+export declare namespace staking_contract {
+    class AddDistributionEvent {
+        operator: Address;
+        pool_address: Address;
+        amount: bigint;
+    }
+    interface AddDistributionEventInstance extends aptos.TypedEventInstance<AddDistributionEvent> {
+        data_typed: AddDistributionEvent;
+    }
+    class AddStakeEvent {
+        operator: Address;
+        pool_address: Address;
+        amount: bigint;
+    }
+    interface AddStakeEventInstance extends aptos.TypedEventInstance<AddStakeEvent> {
+        data_typed: AddStakeEvent;
+    }
+    class CreateStakingContractEvent {
+        operator: Address;
+        voter: Address;
+        pool_address: Address;
+        principal: bigint;
+        commission_percentage: bigint;
+    }
+    interface CreateStakingContractEventInstance extends aptos.TypedEventInstance<CreateStakingContractEvent> {
+        data_typed: CreateStakingContractEvent;
+    }
+    class DistributeEvent {
+        operator: Address;
+        pool_address: Address;
+        recipient: Address;
+        amount: bigint;
+    }
+    interface DistributeEventInstance extends aptos.TypedEventInstance<DistributeEvent> {
+        data_typed: DistributeEvent;
+    }
+    class RequestCommissionEvent {
+        operator: Address;
+        pool_address: Address;
+        accumulated_rewards: bigint;
+        commission_amount: bigint;
+    }
+    interface RequestCommissionEventInstance extends aptos.TypedEventInstance<RequestCommissionEvent> {
+        data_typed: RequestCommissionEvent;
+    }
+    class ResetLockupEvent {
+        operator: Address;
+        pool_address: Address;
+    }
+    interface ResetLockupEventInstance extends aptos.TypedEventInstance<ResetLockupEvent> {
+        data_typed: ResetLockupEvent;
+    }
+    class StakingContract {
+        principal: bigint;
+        pool_address: Address;
+        owner_cap: stake.OwnerCapability;
+        commission_percentage: bigint;
+        distribution_pool: pool_u64.Pool;
+        signer_cap: account.SignerCapability;
+    }
+    class 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>;
+    }
+    class SwitchOperatorEvent {
+        old_operator: Address;
+        new_operator: Address;
+        pool_address: Address;
+    }
+    interface SwitchOperatorEventInstance extends aptos.TypedEventInstance<SwitchOperatorEvent> {
+        data_typed: SwitchOperatorEvent;
+    }
+    class UnlockStakeEvent {
+        operator: Address;
+        pool_address: Address;
+        amount: bigint;
+        commission_paid: bigint;
+    }
+    interface UnlockStakeEventInstance extends aptos.TypedEventInstance<UnlockStakeEvent> {
+        data_typed: UnlockStakeEvent;
+    }
+    class UpdateVoterEvent {
+        operator: Address;
+        pool_address: Address;
+        old_voter: Address;
+        new_voter: Address;
+    }
+    interface UpdateVoterEventInstance extends aptos.TypedEventInstance<UpdateVoterEvent> {
+        data_typed: UpdateVoterEvent;
+    }
+    interface AddStakePayload extends aptos.TypedEntryFunctionPayload<[Address, bigint]> {
+        arguments_typed: [Address, bigint];
+    }
+    interface CreateStakingContractPayload extends aptos.TypedEntryFunctionPayload<[
+        Address,
+        Address,
+        bigint,
+        bigint,
+        string
+    ]> {
+        arguments_typed: [Address, Address, bigint, bigint, string];
+    }
+    interface DistributePayload extends aptos.TypedEntryFunctionPayload<[Address]> {
+        arguments_typed: [Address];
+    }
+    interface RequestCommissionPayload extends aptos.TypedEntryFunctionPayload<[Address, Address]> {
+        arguments_typed: [Address, Address];
+    }
+    interface ResetLockupPayload extends aptos.TypedEntryFunctionPayload<[Address]> {
+        arguments_typed: [Address];
+    }
+    interface SwitchOperatorPayload extends aptos.TypedEntryFunctionPayload<[Address, Address, bigint]> {
+        arguments_typed: [Address, Address, bigint];
+    }
+    interface SwitchOperatorWithSameCommissionPayload extends aptos.TypedEntryFunctionPayload<[Address, Address]> {
+        arguments_typed: [Address, Address];
+    }
+    interface UnlockRewardsPayload extends aptos.TypedEntryFunctionPayload<[Address]> {
+        arguments_typed: [Address];
+    }
+    interface UnlockStakePayload extends aptos.TypedEntryFunctionPayload<[Address, bigint]> {
+        arguments_typed: [Address, bigint];
+    }
+    interface UpdateVoterPayload extends aptos.TypedEntryFunctionPayload<[Address, Address]> {
+        arguments_typed: [Address, Address];
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace system_addresses {
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace table_with_length {
+    class TableWithLength<T0, T1> {
+        inner: table.Table<T0, T1>;
+        length: bigint;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace aggregator_factory {
+    class AggregatorFactory {
+        phantom_table: table.Table<Address, bigint>;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace governance_proposal {
+    class GovernanceProposal {
+        dummy_field: Boolean;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace optional_aggregator {
+    class Integer {
+        value: bigint;
+        limit: bigint;
+    }
+    class OptionalAggregator {
+        aggregator: option.Option<aggregator.Aggregator>;
+        integer: option.Option<optional_aggregator.Integer>;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace transaction_context {
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}
+export declare namespace transaction_validation {
+    class TransactionValidation {
+        module_addr: Address;
+        module_name: string;
+        script_prologue_name: string;
+        module_prologue_name: string;
+        multi_agent_prologue_name: string;
+        user_epilogue_name: string;
+    }
+    function loadTypes(registry: aptos.TypeRegistry): void;
+    const ABI: MoveModule;
+}