@sentio/sdk 2.0.0-rc.9 → 2.0.1-rc.1

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

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