@sentio/sdk 2.40.1-rc.10 → 2.40.1-rc.11

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

@@ -43,6 +43,63 @@ export declare namespace any_ {
     }
 }
 export declare namespace bcs { }
+export declare class dkg extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): dkg;
+    onEventDKGSessionMetadata(func: (event: dkg.DKGSessionMetadataInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): dkg;
+    onEventDKGSessionState(func: (event: dkg.DKGSessionStateInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): dkg;
+    onEventDKGStartEvent(func: (event: dkg.DKGStartEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): dkg;
+}
+export declare namespace dkg {
+    interface DKGSessionMetadata {
+        dealer_epoch: bigint;
+        randomness_config: randomness_config.RandomnessConfig;
+        dealer_validator_set: validator_consensus_info.ValidatorConsensusInfo[];
+        target_validator_set: validator_consensus_info.ValidatorConsensusInfo[];
+    }
+    namespace DKGSessionMetadata {
+        const TYPE_QNAME = "0x1::dkg::DKGSessionMetadata";
+        function type(): TypeDescriptor<DKGSessionMetadata>;
+    }
+    interface DKGSessionMetadataInstance extends TypedEventInstance<DKGSessionMetadata> {
+        data_decoded: DKGSessionMetadata;
+        type_arguments: [];
+    }
+    interface DKGSessionState {
+        metadata: dkg.DKGSessionMetadata;
+        start_time_us: bigint;
+        transcript: string;
+    }
+    namespace DKGSessionState {
+        const TYPE_QNAME = "0x1::dkg::DKGSessionState";
+        function type(): TypeDescriptor<DKGSessionState>;
+    }
+    interface DKGSessionStateInstance extends TypedEventInstance<DKGSessionState> {
+        data_decoded: DKGSessionState;
+        type_arguments: [];
+    }
+    interface DKGStartEvent {
+        session_metadata: dkg.DKGSessionMetadata;
+        start_time_us: bigint;
+    }
+    namespace DKGStartEvent {
+        const TYPE_QNAME = "0x1::dkg::DKGStartEvent";
+        function type(): TypeDescriptor<DKGStartEvent>;
+    }
+    interface DKGStartEventInstance extends TypedEventInstance<DKGStartEvent> {
+        data_decoded: DKGStartEvent;
+        type_arguments: [];
+    }
+    interface DKGState {
+        last_completed: option.Option<dkg.DKGSessionState>;
+        in_progress: option.Option<dkg.DKGSessionState>;
+    }
+    namespace DKGState {
+        const TYPE_QNAME = "0x1::dkg::DKGState";
+        function type(): TypeDescriptor<DKGState>;
+    }
+}
 export declare class code extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -52,6 +109,7 @@ export declare class code extends AptosBaseProcessor {
     onEventPackageDep(func: (event: code.PackageDepInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): code;
     onEventPackageMetadata(func: (event: code.PackageMetadataInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): code;
     onEventPackageRegistry(func: (event: code.PackageRegistryInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): code;
+    onEventPublishPackage(func: (event: code.PublishPackageInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): code;
     onEventUpgradePolicy(func: (event: code.UpgradePolicyInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): code;
 }
 export declare namespace code {
@@ -118,6 +176,18 @@ export declare namespace code {
         data_decoded: PackageRegistry;
         type_arguments: [];
     }
+    interface PublishPackage {
+        code_address: MoveAddressType;
+        is_upgrade: Boolean;
+    }
+    namespace PublishPackage {
+        const TYPE_QNAME = "0x1::code::PublishPackage";
+        function type(): TypeDescriptor<PublishPackage>;
+    }
+    interface PublishPackageInstance extends TypedEventInstance<PublishPackage> {
+        data_decoded: PublishPackage;
+        type_arguments: [];
+    }
     interface UpgradePolicy {
         policy: number;
     }
@@ -138,11 +208,18 @@ export declare class coin extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): coin;
+    onEntryCreateCoinConversionMap(func: (call: coin.CreateCoinConversionMapPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): coin;
+    onEntryCreatePairing(func: (call: coin.CreatePairingPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): coin;
     onEntryFreezeCoinStore(func: (call: coin.FreezeCoinStorePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): coin;
+    onEntryMigrateToFungibleStore(func: (call: coin.MigrateToFungibleStorePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): coin;
     onEntryTransfer(func: (call: coin.TransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): coin;
     onEntryUnfreezeCoinStore(func: (call: coin.UnfreezeCoinStorePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): coin;
     onEntryUpgradeSupply(func: (call: coin.UpgradeSupplyPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): coin;
+    onEventCoinEventHandleDeletion(func: (event: coin.CoinEventHandleDeletionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): coin;
+    onEventDeposit(func: (event: coin.DepositInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): coin;
     onEventDepositEvent(func: (event: coin.DepositEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): coin;
+    onEventPairCreation(func: (event: coin.PairCreationInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): coin;
+    onEventWithdraw(func: (event: coin.WithdrawInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): coin;
     onEventWithdrawEvent(func: (event: coin.WithdrawEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): coin;
 }
 export declare namespace coin {
@@ -160,6 +237,13 @@ export declare namespace coin {
         const TYPE_QNAME = "0x1::coin::BurnCapability";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<BurnCapability<T0>>;
     }
+    interface BurnRefReceipt {
+        metadata: object_.Object<fungible_asset.Metadata>;
+    }
+    namespace BurnRefReceipt {
+        const TYPE_QNAME = "0x1::coin::BurnRefReceipt";
+        function type(): TypeDescriptor<BurnRefReceipt>;
+    }
     interface Coin<T0> {
         value: bigint;
     }
@@ -167,6 +251,26 @@ export declare namespace coin {
         const TYPE_QNAME = "0x1::coin::Coin";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Coin<T0>>;
     }
+    interface CoinConversionMap {
+        coin_to_fungible_asset_map: table.Table<type_info.TypeInfo, object_.Object<fungible_asset.Metadata>>;
+    }
+    namespace CoinConversionMap {
+        const TYPE_QNAME = "0x1::coin::CoinConversionMap";
+        function type(): TypeDescriptor<CoinConversionMap>;
+    }
+    interface CoinEventHandleDeletion {
+        event_handle_creation_address: MoveAddressType;
+        deleted_deposit_event_handle_creation_number: bigint;
+        deleted_withdraw_event_handle_creation_number: bigint;
+    }
+    namespace CoinEventHandleDeletion {
+        const TYPE_QNAME = "0x1::coin::CoinEventHandleDeletion";
+        function type(): TypeDescriptor<CoinEventHandleDeletion>;
+    }
+    interface CoinEventHandleDeletionInstance extends TypedEventInstance<CoinEventHandleDeletion> {
+        data_decoded: CoinEventHandleDeletion;
+        type_arguments: [];
+    }
     interface CoinInfo<T0> {
         name: string;
         symbol: string;
@@ -187,6 +291,18 @@ export declare namespace coin {
         const TYPE_QNAME = "0x1::coin::CoinStore";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<CoinStore<T0>>;
     }
+    interface Deposit<T0> {
+        account: MoveAddressType;
+        amount: bigint;
+    }
+    namespace Deposit {
+        const TYPE_QNAME = "0x1::coin::Deposit";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Deposit<T0>>;
+    }
+    interface DepositInstance extends TypedEventInstance<Deposit<any>> {
+        data_decoded: Deposit<any>;
+        type_arguments: [string];
+    }
     interface DepositEvent {
         amount: bigint;
     }
@@ -205,6 +321,13 @@ export declare namespace coin {
         const TYPE_QNAME = "0x1::coin::FreezeCapability";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<FreezeCapability<T0>>;
     }
+    interface MigrationFlag {
+        dummy_field: Boolean;
+    }
+    namespace MigrationFlag {
+        const TYPE_QNAME = "0x1::coin::MigrationFlag";
+        function type(): TypeDescriptor<MigrationFlag>;
+    }
     interface MintCapability<T0> {
         dummy_field: Boolean;
     }
@@ -212,6 +335,41 @@ export declare namespace coin {
         const TYPE_QNAME = "0x1::coin::MintCapability";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<MintCapability<T0>>;
     }
+    interface MintRefReceipt {
+        metadata: object_.Object<fungible_asset.Metadata>;
+    }
+    namespace MintRefReceipt {
+        const TYPE_QNAME = "0x1::coin::MintRefReceipt";
+        function type(): TypeDescriptor<MintRefReceipt>;
+    }
+    interface PairCreation {
+        coin_type: type_info.TypeInfo;
+        fungible_asset_metadata_address: MoveAddressType;
+    }
+    namespace PairCreation {
+        const TYPE_QNAME = "0x1::coin::PairCreation";
+        function type(): TypeDescriptor<PairCreation>;
+    }
+    interface PairCreationInstance extends TypedEventInstance<PairCreation> {
+        data_decoded: PairCreation;
+        type_arguments: [];
+    }
+    interface PairedCoinType {
+        type: type_info.TypeInfo;
+    }
+    namespace PairedCoinType {
+        const TYPE_QNAME = "0x1::coin::PairedCoinType";
+        function type(): TypeDescriptor<PairedCoinType>;
+    }
+    interface PairedFungibleAssetRefs {
+        mint_ref_opt: option.Option<fungible_asset.MintRef>;
+        transfer_ref_opt: option.Option<fungible_asset.TransferRef>;
+        burn_ref_opt: option.Option<fungible_asset.BurnRef>;
+    }
+    namespace PairedFungibleAssetRefs {
+        const TYPE_QNAME = "0x1::coin::PairedFungibleAssetRefs";
+        function type(): TypeDescriptor<PairedFungibleAssetRefs>;
+    }
     interface SupplyConfig {
         allow_upgrades: Boolean;
     }
@@ -219,6 +377,25 @@ export declare namespace coin {
         const TYPE_QNAME = "0x1::coin::SupplyConfig";
         function type(): TypeDescriptor<SupplyConfig>;
     }
+    interface TransferRefReceipt {
+        metadata: object_.Object<fungible_asset.Metadata>;
+    }
+    namespace TransferRefReceipt {
+        const TYPE_QNAME = "0x1::coin::TransferRefReceipt";
+        function type(): TypeDescriptor<TransferRefReceipt>;
+    }
+    interface Withdraw<T0> {
+        account: MoveAddressType;
+        amount: bigint;
+    }
+    namespace Withdraw {
+        const TYPE_QNAME = "0x1::coin::Withdraw";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Withdraw<T0>>;
+    }
+    interface WithdrawInstance extends TypedEventInstance<Withdraw<any>> {
+        data_decoded: Withdraw<any>;
+        type_arguments: [string];
+    }
     interface WithdrawEvent {
         amount: bigint;
     }
@@ -230,10 +407,22 @@ export declare namespace coin {
         data_decoded: WithdrawEvent;
         type_arguments: [];
     }
+    interface CreateCoinConversionMapPayload extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
+    interface CreatePairingPayload<T0 = any> extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [string];
+    }
     interface FreezeCoinStorePayload<T0 = any> extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
         arguments_decoded: [MoveAddressType, MoveAddressType];
         type_arguments: [string];
     }
+    interface MigrateToFungibleStorePayload<T0 = any> extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [string];
+    }
     interface TransferPayload<T0 = any> extends TypedFunctionPayload<[MoveAddressType, bigint]> {
         arguments_decoded: [MoveAddressType, bigint];
         type_arguments: [string];
@@ -280,12 +469,214 @@ export declare namespace guid {
     }
 }
 export declare namespace hash { }
+export declare class jwks extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): jwks;
+    onEventAllProvidersJWKs(func: (event: jwks.AllProvidersJWKsInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): jwks;
+    onEventJWK(func: (event: jwks.JWKInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): jwks;
+    onEventOIDCProvider(func: (event: jwks.OIDCProviderInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): jwks;
+    onEventObservedJWKs(func: (event: jwks.ObservedJWKsInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): jwks;
+    onEventObservedJWKsUpdated(func: (event: jwks.ObservedJWKsUpdatedInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): jwks;
+    onEventPatch(func: (event: jwks.PatchInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): jwks;
+    onEventPatchRemoveAll(func: (event: jwks.PatchRemoveAllInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): jwks;
+    onEventPatchRemoveIssuer(func: (event: jwks.PatchRemoveIssuerInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): jwks;
+    onEventPatchRemoveJWK(func: (event: jwks.PatchRemoveJWKInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): jwks;
+    onEventPatchUpsertJWK(func: (event: jwks.PatchUpsertJWKInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): jwks;
+    onEventProviderJWKs(func: (event: jwks.ProviderJWKsInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): jwks;
+    onEventRSA_JWK(func: (event: jwks.RSA_JWKInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): jwks;
+    onEventSupportedOIDCProviders(func: (event: jwks.SupportedOIDCProvidersInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): jwks;
+    onEventUnsupportedJWK(func: (event: jwks.UnsupportedJWKInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): jwks;
+}
+export declare namespace jwks {
+    interface AllProvidersJWKs {
+        entries: jwks.ProviderJWKs[];
+    }
+    namespace AllProvidersJWKs {
+        const TYPE_QNAME = "0x1::jwks::AllProvidersJWKs";
+        function type(): TypeDescriptor<AllProvidersJWKs>;
+    }
+    interface AllProvidersJWKsInstance extends TypedEventInstance<AllProvidersJWKs> {
+        data_decoded: AllProvidersJWKs;
+        type_arguments: [];
+    }
+    interface JWK {
+        variant: copyable_any.Any;
+    }
+    namespace JWK {
+        const TYPE_QNAME = "0x1::jwks::JWK";
+        function type(): TypeDescriptor<JWK>;
+    }
+    interface JWKInstance extends TypedEventInstance<JWK> {
+        data_decoded: JWK;
+        type_arguments: [];
+    }
+    interface OIDCProvider {
+        name: string;
+        config_url: string;
+    }
+    namespace OIDCProvider {
+        const TYPE_QNAME = "0x1::jwks::OIDCProvider";
+        function type(): TypeDescriptor<OIDCProvider>;
+    }
+    interface OIDCProviderInstance extends TypedEventInstance<OIDCProvider> {
+        data_decoded: OIDCProvider;
+        type_arguments: [];
+    }
+    interface ObservedJWKs {
+        jwks: jwks.AllProvidersJWKs;
+    }
+    namespace ObservedJWKs {
+        const TYPE_QNAME = "0x1::jwks::ObservedJWKs";
+        function type(): TypeDescriptor<ObservedJWKs>;
+    }
+    interface ObservedJWKsInstance extends TypedEventInstance<ObservedJWKs> {
+        data_decoded: ObservedJWKs;
+        type_arguments: [];
+    }
+    interface ObservedJWKsUpdated {
+        epoch: bigint;
+        jwks: jwks.AllProvidersJWKs;
+    }
+    namespace ObservedJWKsUpdated {
+        const TYPE_QNAME = "0x1::jwks::ObservedJWKsUpdated";
+        function type(): TypeDescriptor<ObservedJWKsUpdated>;
+    }
+    interface ObservedJWKsUpdatedInstance extends TypedEventInstance<ObservedJWKsUpdated> {
+        data_decoded: ObservedJWKsUpdated;
+        type_arguments: [];
+    }
+    interface Patch {
+        variant: copyable_any.Any;
+    }
+    namespace Patch {
+        const TYPE_QNAME = "0x1::jwks::Patch";
+        function type(): TypeDescriptor<Patch>;
+    }
+    interface PatchInstance extends TypedEventInstance<Patch> {
+        data_decoded: Patch;
+        type_arguments: [];
+    }
+    interface PatchRemoveAll {
+        dummy_field: Boolean;
+    }
+    namespace PatchRemoveAll {
+        const TYPE_QNAME = "0x1::jwks::PatchRemoveAll";
+        function type(): TypeDescriptor<PatchRemoveAll>;
+    }
+    interface PatchRemoveAllInstance extends TypedEventInstance<PatchRemoveAll> {
+        data_decoded: PatchRemoveAll;
+        type_arguments: [];
+    }
+    interface PatchRemoveIssuer {
+        issuer: string;
+    }
+    namespace PatchRemoveIssuer {
+        const TYPE_QNAME = "0x1::jwks::PatchRemoveIssuer";
+        function type(): TypeDescriptor<PatchRemoveIssuer>;
+    }
+    interface PatchRemoveIssuerInstance extends TypedEventInstance<PatchRemoveIssuer> {
+        data_decoded: PatchRemoveIssuer;
+        type_arguments: [];
+    }
+    interface PatchRemoveJWK {
+        issuer: string;
+        jwk_id: string;
+    }
+    namespace PatchRemoveJWK {
+        const TYPE_QNAME = "0x1::jwks::PatchRemoveJWK";
+        function type(): TypeDescriptor<PatchRemoveJWK>;
+    }
+    interface PatchRemoveJWKInstance extends TypedEventInstance<PatchRemoveJWK> {
+        data_decoded: PatchRemoveJWK;
+        type_arguments: [];
+    }
+    interface PatchUpsertJWK {
+        issuer: string;
+        jwk: jwks.JWK;
+    }
+    namespace PatchUpsertJWK {
+        const TYPE_QNAME = "0x1::jwks::PatchUpsertJWK";
+        function type(): TypeDescriptor<PatchUpsertJWK>;
+    }
+    interface PatchUpsertJWKInstance extends TypedEventInstance<PatchUpsertJWK> {
+        data_decoded: PatchUpsertJWK;
+        type_arguments: [];
+    }
+    interface PatchedJWKs {
+        jwks: jwks.AllProvidersJWKs;
+    }
+    namespace PatchedJWKs {
+        const TYPE_QNAME = "0x1::jwks::PatchedJWKs";
+        function type(): TypeDescriptor<PatchedJWKs>;
+    }
+    interface Patches {
+        patches: jwks.Patch[];
+    }
+    namespace Patches {
+        const TYPE_QNAME = "0x1::jwks::Patches";
+        function type(): TypeDescriptor<Patches>;
+    }
+    interface ProviderJWKs {
+        issuer: string;
+        version: bigint;
+        jwks: jwks.JWK[];
+    }
+    namespace ProviderJWKs {
+        const TYPE_QNAME = "0x1::jwks::ProviderJWKs";
+        function type(): TypeDescriptor<ProviderJWKs>;
+    }
+    interface ProviderJWKsInstance extends TypedEventInstance<ProviderJWKs> {
+        data_decoded: ProviderJWKs;
+        type_arguments: [];
+    }
+    interface RSA_JWK {
+        kid: string;
+        kty: string;
+        alg: string;
+        e: string;
+        n: string;
+    }
+    namespace RSA_JWK {
+        const TYPE_QNAME = "0x1::jwks::RSA_JWK";
+        function type(): TypeDescriptor<RSA_JWK>;
+    }
+    interface RSA_JWKInstance extends TypedEventInstance<RSA_JWK> {
+        data_decoded: RSA_JWK;
+        type_arguments: [];
+    }
+    interface SupportedOIDCProviders {
+        providers: jwks.OIDCProvider[];
+    }
+    namespace SupportedOIDCProviders {
+        const TYPE_QNAME = "0x1::jwks::SupportedOIDCProviders";
+        function type(): TypeDescriptor<SupportedOIDCProviders>;
+    }
+    interface SupportedOIDCProvidersInstance extends TypedEventInstance<SupportedOIDCProviders> {
+        data_decoded: SupportedOIDCProviders;
+        type_arguments: [];
+    }
+    interface UnsupportedJWK {
+        id: string;
+        payload: string;
+    }
+    namespace UnsupportedJWK {
+        const TYPE_QNAME = "0x1::jwks::UnsupportedJWK";
+        function type(): TypeDescriptor<UnsupportedJWK>;
+    }
+    interface UnsupportedJWKInstance extends TypedEventInstance<UnsupportedJWK> {
+        data_decoded: UnsupportedJWK;
+        type_arguments: [];
+    }
+}
 export declare namespace util { }
 export declare class block extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): block;
+    onEventNewBlock(func: (event: block.NewBlockInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): block;
     onEventNewBlockEvent(func: (event: block.NewBlockEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): block;
+    onEventUpdateEpochInterval(func: (event: block.UpdateEpochIntervalInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): block;
     onEventUpdateEpochIntervalEvent(func: (event: block.UpdateEpochIntervalEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): block;
 }
 export declare namespace block {
@@ -299,6 +690,33 @@ export declare namespace block {
         const TYPE_QNAME = "0x1::block::BlockResource";
         function type(): TypeDescriptor<BlockResource>;
     }
+    interface CommitHistory {
+        max_capacity: number;
+        next_idx: number;
+        table: table_with_length.TableWithLength<number, block.NewBlockEvent>;
+    }
+    namespace CommitHistory {
+        const TYPE_QNAME = "0x1::block::CommitHistory";
+        function type(): TypeDescriptor<CommitHistory>;
+    }
+    interface NewBlock {
+        hash: MoveAddressType;
+        epoch: bigint;
+        round: bigint;
+        height: bigint;
+        previous_block_votes_bitvec: string;
+        proposer: MoveAddressType;
+        failed_proposer_indices: bigint[];
+        time_microseconds: bigint;
+    }
+    namespace NewBlock {
+        const TYPE_QNAME = "0x1::block::NewBlock";
+        function type(): TypeDescriptor<NewBlock>;
+    }
+    interface NewBlockInstance extends TypedEventInstance<NewBlock> {
+        data_decoded: NewBlock;
+        type_arguments: [];
+    }
     interface NewBlockEvent {
         hash: MoveAddressType;
         epoch: bigint;
@@ -317,6 +735,18 @@ export declare namespace block {
         data_decoded: NewBlockEvent;
         type_arguments: [];
     }
+    interface UpdateEpochInterval {
+        old_epoch_interval: bigint;
+        new_epoch_interval: bigint;
+    }
+    namespace UpdateEpochInterval {
+        const TYPE_QNAME = "0x1::block::UpdateEpochInterval";
+        function type(): TypeDescriptor<UpdateEpochInterval>;
+    }
+    interface UpdateEpochIntervalInstance extends TypedEventInstance<UpdateEpochInterval> {
+        data_decoded: UpdateEpochInterval;
+        type_arguments: [];
+    }
     interface UpdateEpochIntervalEvent {
         old_epoch_interval: bigint;
         new_epoch_interval: bigint;
@@ -359,23 +789,48 @@ export declare class stake extends AptosBaseProcessor {
     onEntryUnlock(func: (call: stake.UnlockPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEntryUpdateNetworkAndFullnodeAddresses(func: (call: stake.UpdateNetworkAndFullnodeAddressesPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEntryWithdraw(func: (call: stake.WithdrawPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): stake;
+    onEventAddStake(func: (event: stake.AddStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventAddStakeEvent(func: (event: stake.AddStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
+    onEventDistributeRewards(func: (event: stake.DistributeRewardsInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventDistributeRewardsEvent(func: (event: stake.DistributeRewardsEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
+    onEventIncreaseLockup(func: (event: stake.IncreaseLockupInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventIncreaseLockupEvent(func: (event: stake.IncreaseLockupEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventIndividualValidatorPerformance(func: (event: stake.IndividualValidatorPerformanceInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
+    onEventJoinValidatorSet(func: (event: stake.JoinValidatorSetInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventJoinValidatorSetEvent(func: (event: stake.JoinValidatorSetEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
+    onEventLeaveValidatorSet(func: (event: stake.LeaveValidatorSetInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventLeaveValidatorSetEvent(func: (event: stake.LeaveValidatorSetEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
+    onEventReactivateStake(func: (event: stake.ReactivateStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventReactivateStakeEvent(func: (event: stake.ReactivateStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
+    onEventRegisterValidatorCandidate(func: (event: stake.RegisterValidatorCandidateInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventRegisterValidatorCandidateEvent(func: (event: stake.RegisterValidatorCandidateEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
+    onEventRotateConsensusKey(func: (event: stake.RotateConsensusKeyInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventRotateConsensusKeyEvent(func: (event: stake.RotateConsensusKeyEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
+    onEventSetOperator(func: (event: stake.SetOperatorInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventSetOperatorEvent(func: (event: stake.SetOperatorEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
+    onEventUnlockStake(func: (event: stake.UnlockStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventUnlockStakeEvent(func: (event: stake.UnlockStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
+    onEventUpdateNetworkAndFullnodeAddresses(func: (event: stake.UpdateNetworkAndFullnodeAddressesInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventUpdateNetworkAndFullnodeAddressesEvent(func: (event: stake.UpdateNetworkAndFullnodeAddressesEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventValidatorConfig(func: (event: stake.ValidatorConfigInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventValidatorInfo(func: (event: stake.ValidatorInfoInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
+    onEventValidatorSet(func: (event: stake.ValidatorSetInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
+    onEventWithdrawStake(func: (event: stake.WithdrawStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventWithdrawStakeEvent(func: (event: stake.WithdrawStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
 }
 export declare namespace stake {
+    interface AddStake {
+        pool_address: MoveAddressType;
+        amount_added: bigint;
+    }
+    namespace AddStake {
+        const TYPE_QNAME = "0x1::stake::AddStake";
+        function type(): TypeDescriptor<AddStake>;
+    }
+    interface AddStakeInstance extends TypedEventInstance<AddStake> {
+        data_decoded: AddStake;
+        type_arguments: [];
+    }
     interface AddStakeEvent {
         pool_address: MoveAddressType;
         amount_added: bigint;
@@ -402,6 +857,18 @@ export declare namespace stake {
         const TYPE_QNAME = "0x1::stake::AptosCoinCapabilities";
         function type(): TypeDescriptor<AptosCoinCapabilities>;
     }
+    interface DistributeRewards {
+        pool_address: MoveAddressType;
+        rewards_amount: bigint;
+    }
+    namespace DistributeRewards {
+        const TYPE_QNAME = "0x1::stake::DistributeRewards";
+        function type(): TypeDescriptor<DistributeRewards>;
+    }
+    interface DistributeRewardsInstance extends TypedEventInstance<DistributeRewards> {
+        data_decoded: DistributeRewards;
+        type_arguments: [];
+    }
     interface DistributeRewardsEvent {
         pool_address: MoveAddressType;
         rewards_amount: bigint;
@@ -414,6 +881,19 @@ export declare namespace stake {
         data_decoded: DistributeRewardsEvent;
         type_arguments: [];
     }
+    interface IncreaseLockup {
+        pool_address: MoveAddressType;
+        old_locked_until_secs: bigint;
+        new_locked_until_secs: bigint;
+    }
+    namespace IncreaseLockup {
+        const TYPE_QNAME = "0x1::stake::IncreaseLockup";
+        function type(): TypeDescriptor<IncreaseLockup>;
+    }
+    interface IncreaseLockupInstance extends TypedEventInstance<IncreaseLockup> {
+        data_decoded: IncreaseLockup;
+        type_arguments: [];
+    }
     interface IncreaseLockupEvent {
         pool_address: MoveAddressType;
         old_locked_until_secs: bigint;
@@ -439,6 +919,17 @@ export declare namespace stake {
         data_decoded: IndividualValidatorPerformance;
         type_arguments: [];
     }
+    interface JoinValidatorSet {
+        pool_address: MoveAddressType;
+    }
+    namespace JoinValidatorSet {
+        const TYPE_QNAME = "0x1::stake::JoinValidatorSet";
+        function type(): TypeDescriptor<JoinValidatorSet>;
+    }
+    interface JoinValidatorSetInstance extends TypedEventInstance<JoinValidatorSet> {
+        data_decoded: JoinValidatorSet;
+        type_arguments: [];
+    }
     interface JoinValidatorSetEvent {
         pool_address: MoveAddressType;
     }
@@ -450,6 +941,17 @@ export declare namespace stake {
         data_decoded: JoinValidatorSetEvent;
         type_arguments: [];
     }
+    interface LeaveValidatorSet {
+        pool_address: MoveAddressType;
+    }
+    namespace LeaveValidatorSet {
+        const TYPE_QNAME = "0x1::stake::LeaveValidatorSet";
+        function type(): TypeDescriptor<LeaveValidatorSet>;
+    }
+    interface LeaveValidatorSetInstance extends TypedEventInstance<LeaveValidatorSet> {
+        data_decoded: LeaveValidatorSet;
+        type_arguments: [];
+    }
     interface LeaveValidatorSetEvent {
         pool_address: MoveAddressType;
     }
@@ -468,6 +970,18 @@ export declare namespace stake {
         const TYPE_QNAME = "0x1::stake::OwnerCapability";
         function type(): TypeDescriptor<OwnerCapability>;
     }
+    interface ReactivateStake {
+        pool_address: MoveAddressType;
+        amount: bigint;
+    }
+    namespace ReactivateStake {
+        const TYPE_QNAME = "0x1::stake::ReactivateStake";
+        function type(): TypeDescriptor<ReactivateStake>;
+    }
+    interface ReactivateStakeInstance extends TypedEventInstance<ReactivateStake> {
+        data_decoded: ReactivateStake;
+        type_arguments: [];
+    }
     interface ReactivateStakeEvent {
         pool_address: MoveAddressType;
         amount: bigint;
@@ -480,6 +994,17 @@ export declare namespace stake {
         data_decoded: ReactivateStakeEvent;
         type_arguments: [];
     }
+    interface RegisterValidatorCandidate {
+        pool_address: MoveAddressType;
+    }
+    namespace RegisterValidatorCandidate {
+        const TYPE_QNAME = "0x1::stake::RegisterValidatorCandidate";
+        function type(): TypeDescriptor<RegisterValidatorCandidate>;
+    }
+    interface RegisterValidatorCandidateInstance extends TypedEventInstance<RegisterValidatorCandidate> {
+        data_decoded: RegisterValidatorCandidate;
+        type_arguments: [];
+    }
     interface RegisterValidatorCandidateEvent {
         pool_address: MoveAddressType;
     }
@@ -491,6 +1016,19 @@ export declare namespace stake {
         data_decoded: RegisterValidatorCandidateEvent;
         type_arguments: [];
     }
+    interface RotateConsensusKey {
+        pool_address: MoveAddressType;
+        old_consensus_pubkey: string;
+        new_consensus_pubkey: string;
+    }
+    namespace RotateConsensusKey {
+        const TYPE_QNAME = "0x1::stake::RotateConsensusKey";
+        function type(): TypeDescriptor<RotateConsensusKey>;
+    }
+    interface RotateConsensusKeyInstance extends TypedEventInstance<RotateConsensusKey> {
+        data_decoded: RotateConsensusKey;
+        type_arguments: [];
+    }
     interface RotateConsensusKeyEvent {
         pool_address: MoveAddressType;
         old_consensus_pubkey: string;
@@ -504,6 +1042,19 @@ export declare namespace stake {
         data_decoded: RotateConsensusKeyEvent;
         type_arguments: [];
     }
+    interface SetOperator {
+        pool_address: MoveAddressType;
+        old_operator: MoveAddressType;
+        new_operator: MoveAddressType;
+    }
+    namespace SetOperator {
+        const TYPE_QNAME = "0x1::stake::SetOperator";
+        function type(): TypeDescriptor<SetOperator>;
+    }
+    interface SetOperatorInstance extends TypedEventInstance<SetOperator> {
+        data_decoded: SetOperator;
+        type_arguments: [];
+    }
     interface SetOperatorEvent {
         pool_address: MoveAddressType;
         old_operator: MoveAddressType;
@@ -542,6 +1093,18 @@ export declare namespace stake {
         const TYPE_QNAME = "0x1::stake::StakePool";
         function type(): TypeDescriptor<StakePool>;
     }
+    interface UnlockStake {
+        pool_address: MoveAddressType;
+        amount_unlocked: bigint;
+    }
+    namespace UnlockStake {
+        const TYPE_QNAME = "0x1::stake::UnlockStake";
+        function type(): TypeDescriptor<UnlockStake>;
+    }
+    interface UnlockStakeInstance extends TypedEventInstance<UnlockStake> {
+        data_decoded: UnlockStake;
+        type_arguments: [];
+    }
     interface UnlockStakeEvent {
         pool_address: MoveAddressType;
         amount_unlocked: bigint;
@@ -554,6 +1117,21 @@ export declare namespace stake {
         data_decoded: UnlockStakeEvent;
         type_arguments: [];
     }
+    interface UpdateNetworkAndFullnodeAddresses {
+        pool_address: MoveAddressType;
+        old_network_addresses: string;
+        new_network_addresses: string;
+        old_fullnode_addresses: string;
+        new_fullnode_addresses: string;
+    }
+    namespace UpdateNetworkAndFullnodeAddresses {
+        const TYPE_QNAME = "0x1::stake::UpdateNetworkAndFullnodeAddresses";
+        function type(): TypeDescriptor<UpdateNetworkAndFullnodeAddresses>;
+    }
+    interface UpdateNetworkAndFullnodeAddressesInstance extends TypedEventInstance<UpdateNetworkAndFullnodeAddresses> {
+        data_decoded: UpdateNetworkAndFullnodeAddresses;
+        type_arguments: [];
+    }
     interface UpdateNetworkAndFullnodeAddressesEvent {
         pool_address: MoveAddressType;
         old_network_addresses: string;
@@ -622,6 +1200,22 @@ export declare namespace stake {
         const TYPE_QNAME = "0x1::stake::ValidatorSet";
         function type(): TypeDescriptor<ValidatorSet>;
     }
+    interface ValidatorSetInstance extends TypedEventInstance<ValidatorSet> {
+        data_decoded: ValidatorSet;
+        type_arguments: [];
+    }
+    interface WithdrawStake {
+        pool_address: MoveAddressType;
+        amount_withdrawn: bigint;
+    }
+    namespace WithdrawStake {
+        const TYPE_QNAME = "0x1::stake::WithdrawStake";
+        function type(): TypeDescriptor<WithdrawStake>;
+    }
+    interface WithdrawStakeInstance extends TypedEventInstance<WithdrawStake> {
+        data_decoded: WithdrawStake;
+        type_arguments: [];
+    }
     interface WithdrawStakeEvent {
         pool_address: MoveAddressType;
         amount_withdrawn: bigint;
@@ -727,6 +1321,7 @@ export declare class object_ extends AptosBaseProcessor {
     onEventDeriveRef(func: (event: object_.DeriveRefInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): object_;
     onEventExtendRef(func: (event: object_.ExtendRefInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): object_;
     onEventObject(func: (event: object_.ObjectInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): object_;
+    onEventTransfer(func: (event: object_.TransferInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): object_;
     onEventTransferEvent(func: (event: object_.TransferEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): object_;
     onEventTransferRef(func: (event: object_.TransferRefInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): object_;
 }
@@ -815,6 +1410,19 @@ export declare namespace object_ {
         const TYPE_QNAME = "0x1::object::TombStone";
         function type(): TypeDescriptor<TombStone>;
     }
+    interface Transfer {
+        object: MoveAddressType;
+        from: MoveAddressType;
+        to: MoveAddressType;
+    }
+    namespace Transfer {
+        const TYPE_QNAME = "0x1::object::Transfer";
+        function type(): TypeDescriptor<Transfer>;
+    }
+    interface TransferInstance extends TypedEventInstance<Transfer> {
+        data_decoded: Transfer;
+        type_arguments: [];
+    }
     interface TransferEvent {
         object: MoveAddressType;
         from: MoveAddressType;
@@ -839,6 +1447,13 @@ export declare namespace object_ {
         data_decoded: TransferRef;
         type_arguments: [];
     }
+    interface Untransferable {
+        dummy_field: Boolean;
+    }
+    namespace Untransferable {
+        const TYPE_QNAME = "0x1::object::Untransferable";
+        function type(): TypeDescriptor<Untransferable>;
+    }
     interface BurnPayload<T0 = any> extends TypedFunctionPayload<[object_.Object<T0>]> {
         arguments_decoded: [object_.Object<T0>];
         type_arguments: [string];
@@ -904,12 +1519,31 @@ export declare class voting extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): voting;
+    onEventCreateProposal(func: (event: voting.CreateProposalInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): voting;
     onEventCreateProposalEvent(func: (event: voting.CreateProposalEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): voting;
+    onEventRegisterForum(func: (event: voting.RegisterForumInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): voting;
     onEventRegisterForumEvent(func: (event: voting.RegisterForumEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): voting;
     onEventResolveProposal(func: (event: voting.ResolveProposalInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): voting;
+    onEventVote(func: (event: voting.VoteInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): voting;
     onEventVoteEvent(func: (event: voting.VoteEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): voting;
 }
 export declare namespace voting {
+    interface CreateProposal {
+        proposal_id: bigint;
+        early_resolution_vote_threshold: option.Option<bigint>;
+        execution_hash: string;
+        expiration_secs: bigint;
+        metadata: simple_map.SimpleMap<string, string>;
+        min_vote_threshold: bigint;
+    }
+    namespace CreateProposal {
+        const TYPE_QNAME = "0x1::voting::CreateProposal";
+        function type(): TypeDescriptor<CreateProposal>;
+    }
+    interface CreateProposalInstance extends TypedEventInstance<CreateProposal> {
+        data_decoded: CreateProposal;
+        type_arguments: [];
+    }
     interface CreateProposalEvent {
         proposal_id: bigint;
         early_resolution_vote_threshold: option.Option<bigint>;
@@ -944,12 +1578,24 @@ export declare namespace voting {
         const TYPE_QNAME = "0x1::voting::Proposal";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Proposal<T0>>;
     }
-    interface RegisterForumEvent {
+    interface RegisterForum {
         hosting_account: MoveAddressType;
         proposal_type_info: type_info.TypeInfo;
     }
-    namespace RegisterForumEvent {
-        const TYPE_QNAME = "0x1::voting::RegisterForumEvent";
+    namespace RegisterForum {
+        const TYPE_QNAME = "0x1::voting::RegisterForum";
+        function type(): TypeDescriptor<RegisterForum>;
+    }
+    interface RegisterForumInstance extends TypedEventInstance<RegisterForum> {
+        data_decoded: RegisterForum;
+        type_arguments: [];
+    }
+    interface RegisterForumEvent {
+        hosting_account: MoveAddressType;
+        proposal_type_info: type_info.TypeInfo;
+    }
+    namespace RegisterForumEvent {
+        const TYPE_QNAME = "0x1::voting::RegisterForumEvent";
         function type(): TypeDescriptor<RegisterForumEvent>;
     }
     interface RegisterForumEventInstance extends TypedEventInstance<RegisterForumEvent> {
@@ -970,6 +1616,18 @@ export declare namespace voting {
         data_decoded: ResolveProposal;
         type_arguments: [];
     }
+    interface Vote {
+        proposal_id: bigint;
+        num_votes: bigint;
+    }
+    namespace Vote {
+        const TYPE_QNAME = "0x1::voting::Vote";
+        function type(): TypeDescriptor<Vote>;
+    }
+    interface VoteInstance extends TypedEventInstance<Vote> {
+        data_decoded: Vote;
+        type_arguments: [];
+    }
     interface VoteEvent {
         proposal_id: bigint;
         num_votes: bigint;
@@ -1013,8 +1671,10 @@ export declare class account extends AptosBaseProcessor {
     onEntryRevokeRotationCapability(func: (call: account.RevokeRotationCapabilityPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account;
     onEntryRevokeSignerCapability(func: (call: account.RevokeSignerCapabilityPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account;
     onEntryRotateAuthenticationKey(func: (call: account.RotateAuthenticationKeyPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account;
+    onEntryRotateAuthenticationKeyCall(func: (call: account.RotateAuthenticationKeyCallPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account;
     onEntryRotateAuthenticationKeyWithRotationCapability(func: (call: account.RotateAuthenticationKeyWithRotationCapabilityPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): account;
     onEventCoinRegisterEvent(func: (event: account.CoinRegisterEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): account;
+    onEventKeyRotation(func: (event: account.KeyRotationInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): account;
     onEventKeyRotationEvent(func: (event: account.KeyRotationEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): account;
     onEventRotationCapability(func: (event: account.RotationCapabilityInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): account;
     onEventSignerCapability(func: (event: account.SignerCapabilityInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): account;
@@ -1051,6 +1711,19 @@ export declare namespace account {
         data_decoded: CoinRegisterEvent;
         type_arguments: [];
     }
+    interface KeyRotation {
+        account: MoveAddressType;
+        old_authentication_key: string;
+        new_authentication_key: string;
+    }
+    namespace KeyRotation {
+        const TYPE_QNAME = "0x1::account::KeyRotation";
+        function type(): TypeDescriptor<KeyRotation>;
+    }
+    interface KeyRotationInstance extends TypedEventInstance<KeyRotation> {
+        data_decoded: KeyRotation;
+        type_arguments: [];
+    }
     interface KeyRotationEvent {
         old_authentication_key: string;
         new_authentication_key: string;
@@ -1172,6 +1845,10 @@ export declare namespace account {
         arguments_decoded: [number, string, number, string, string, string];
         type_arguments: [];
     }
+    interface RotateAuthenticationKeyCallPayload extends TypedFunctionPayload<[string]> {
+        arguments_decoded: [string];
+        type_arguments: [];
+    }
     interface RotateAuthenticationKeyWithRotationCapabilityPayload extends TypedFunctionPayload<[MoveAddressType, number, string, string]> {
         arguments_decoded: [MoveAddressType, number, string, string];
         type_arguments: [];
@@ -1277,7 +1954,9 @@ export declare class version extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): version;
+    onEntrySetForNextEpoch(func: (call: version.SetForNextEpochPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): version;
     onEntrySetVersion(func: (call: version.SetVersionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): version;
+    onEventVersion(func: (event: version.VersionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): version;
 }
 export declare namespace version {
     interface SetVersionCapability {
@@ -1294,6 +1973,14 @@ export declare namespace version {
         const TYPE_QNAME = "0x1::version::Version";
         function type(): TypeDescriptor<Version>;
     }
+    interface VersionInstance extends TypedEventInstance<Version> {
+        data_decoded: Version;
+        type_arguments: [];
+    }
+    interface SetForNextEpochPayload extends TypedFunctionPayload<[bigint]> {
+        arguments_decoded: [bigint];
+        type_arguments: [];
+    }
     interface SetVersionPayload extends TypedFunctionPayload<[bigint]> {
         arguments_decoded: [bigint];
         type_arguments: [];
@@ -1309,6 +1996,7 @@ export declare class vesting extends AptosBaseProcessor {
     onEntryResetBeneficiary(func: (call: vesting.ResetBeneficiaryPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEntryResetLockup(func: (call: vesting.ResetLockupPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEntrySetBeneficiary(func: (call: vesting.SetBeneficiaryPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEntrySetBeneficiaryForOperator(func: (call: vesting.SetBeneficiaryForOperatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEntrySetBeneficiaryResetter(func: (call: vesting.SetBeneficiaryResetterPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEntrySetManagementRole(func: (call: vesting.SetManagementRolePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEntryTerminateVestingContract(func: (call: vesting.TerminateVestingContractPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
@@ -1320,15 +2008,25 @@ export declare class vesting extends AptosBaseProcessor {
     onEntryUpdateVoter(func: (call: vesting.UpdateVoterPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEntryVest(func: (call: vesting.VestPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEntryVestMany(func: (call: vesting.VestManyPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventAdminWithdraw(func: (event: vesting.AdminWithdrawInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventAdminWithdrawEvent(func: (event: vesting.AdminWithdrawEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventCreateVestingContract(func: (event: vesting.CreateVestingContractInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventCreateVestingContractEvent(func: (event: vesting.CreateVestingContractEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventDistribute(func: (event: vesting.DistributeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventDistributeEvent(func: (event: vesting.DistributeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventResetLockup(func: (event: vesting.ResetLockupInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventResetLockupEvent(func: (event: vesting.ResetLockupEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventSetBeneficiary(func: (event: vesting.SetBeneficiaryInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventSetBeneficiaryEvent(func: (event: vesting.SetBeneficiaryEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventTerminate(func: (event: vesting.TerminateInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventTerminateEvent(func: (event: vesting.TerminateEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventUnlockRewards(func: (event: vesting.UnlockRewardsInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventUnlockRewardsEvent(func: (event: vesting.UnlockRewardsEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventUpdateOperator(func: (event: vesting.UpdateOperatorInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventUpdateOperatorEvent(func: (event: vesting.UpdateOperatorEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventUpdateVoter(func: (event: vesting.UpdateVoterInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventUpdateVoterEvent(func: (event: vesting.UpdateVoterEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventVest(func: (event: vesting.VestInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventVestEvent(func: (event: vesting.VestEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventVestingSchedule(func: (event: vesting.VestingScheduleInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
 }
@@ -1342,6 +2040,19 @@ export declare namespace vesting {
         const TYPE_QNAME = "0x1::vesting::AdminStore";
         function type(): TypeDescriptor<AdminStore>;
     }
+    interface AdminWithdraw {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        amount: bigint;
+    }
+    namespace AdminWithdraw {
+        const TYPE_QNAME = "0x1::vesting::AdminWithdraw";
+        function type(): TypeDescriptor<AdminWithdraw>;
+    }
+    interface AdminWithdrawInstance extends TypedEventInstance<AdminWithdraw> {
+        data_decoded: AdminWithdraw;
+        type_arguments: [];
+    }
     interface AdminWithdrawEvent {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
@@ -1355,6 +2066,23 @@ export declare namespace vesting {
         data_decoded: AdminWithdrawEvent;
         type_arguments: [];
     }
+    interface CreateVestingContract {
+        operator: MoveAddressType;
+        voter: MoveAddressType;
+        grant_amount: bigint;
+        withdrawal_address: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
+        commission_percentage: bigint;
+    }
+    namespace CreateVestingContract {
+        const TYPE_QNAME = "0x1::vesting::CreateVestingContract";
+        function type(): TypeDescriptor<CreateVestingContract>;
+    }
+    interface CreateVestingContractInstance extends TypedEventInstance<CreateVestingContract> {
+        data_decoded: CreateVestingContract;
+        type_arguments: [];
+    }
     interface CreateVestingContractEvent {
         operator: MoveAddressType;
         voter: MoveAddressType;
@@ -1372,6 +2100,19 @@ export declare namespace vesting {
         data_decoded: CreateVestingContractEvent;
         type_arguments: [];
     }
+    interface Distribute {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        amount: bigint;
+    }
+    namespace Distribute {
+        const TYPE_QNAME = "0x1::vesting::Distribute";
+        function type(): TypeDescriptor<Distribute>;
+    }
+    interface DistributeInstance extends TypedEventInstance<Distribute> {
+        data_decoded: Distribute;
+        type_arguments: [];
+    }
     interface DistributeEvent {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
@@ -1385,6 +2126,20 @@ export declare namespace vesting {
         data_decoded: DistributeEvent;
         type_arguments: [];
     }
+    interface ResetLockup {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
+        new_lockup_expiration_secs: bigint;
+    }
+    namespace ResetLockup {
+        const TYPE_QNAME = "0x1::vesting::ResetLockup";
+        function type(): TypeDescriptor<ResetLockup>;
+    }
+    interface ResetLockupInstance extends TypedEventInstance<ResetLockup> {
+        data_decoded: ResetLockup;
+        type_arguments: [];
+    }
     interface ResetLockupEvent {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
@@ -1399,6 +2154,21 @@ export declare namespace vesting {
         data_decoded: ResetLockupEvent;
         type_arguments: [];
     }
+    interface SetBeneficiary {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        shareholder: MoveAddressType;
+        old_beneficiary: MoveAddressType;
+        new_beneficiary: MoveAddressType;
+    }
+    namespace SetBeneficiary {
+        const TYPE_QNAME = "0x1::vesting::SetBeneficiary";
+        function type(): TypeDescriptor<SetBeneficiary>;
+    }
+    interface SetBeneficiaryInstance extends TypedEventInstance<SetBeneficiary> {
+        data_decoded: SetBeneficiary;
+        type_arguments: [];
+    }
     interface SetBeneficiaryEvent {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
@@ -1424,6 +2194,18 @@ export declare namespace vesting {
         const TYPE_QNAME = "0x1::vesting::StakingInfo";
         function type(): TypeDescriptor<StakingInfo>;
     }
+    interface Terminate {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+    }
+    namespace Terminate {
+        const TYPE_QNAME = "0x1::vesting::Terminate";
+        function type(): TypeDescriptor<Terminate>;
+    }
+    interface TerminateInstance extends TypedEventInstance<Terminate> {
+        data_decoded: Terminate;
+        type_arguments: [];
+    }
     interface TerminateEvent {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
@@ -1436,6 +2218,20 @@ export declare namespace vesting {
         data_decoded: TerminateEvent;
         type_arguments: [];
     }
+    interface UnlockRewards {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
+        amount: bigint;
+    }
+    namespace UnlockRewards {
+        const TYPE_QNAME = "0x1::vesting::UnlockRewards";
+        function type(): TypeDescriptor<UnlockRewards>;
+    }
+    interface UnlockRewardsInstance extends TypedEventInstance<UnlockRewards> {
+        data_decoded: UnlockRewards;
+        type_arguments: [];
+    }
     interface UnlockRewardsEvent {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
@@ -1450,6 +2246,22 @@ export declare namespace vesting {
         data_decoded: UnlockRewardsEvent;
         type_arguments: [];
     }
+    interface UpdateOperator {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
+        old_operator: MoveAddressType;
+        new_operator: MoveAddressType;
+        commission_percentage: bigint;
+    }
+    namespace UpdateOperator {
+        const TYPE_QNAME = "0x1::vesting::UpdateOperator";
+        function type(): TypeDescriptor<UpdateOperator>;
+    }
+    interface UpdateOperatorInstance extends TypedEventInstance<UpdateOperator> {
+        data_decoded: UpdateOperator;
+        type_arguments: [];
+    }
     interface UpdateOperatorEvent {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
@@ -1466,6 +2278,21 @@ export declare namespace vesting {
         data_decoded: UpdateOperatorEvent;
         type_arguments: [];
     }
+    interface UpdateVoter {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
+        old_voter: MoveAddressType;
+        new_voter: MoveAddressType;
+    }
+    namespace UpdateVoter {
+        const TYPE_QNAME = "0x1::vesting::UpdateVoter";
+        function type(): TypeDescriptor<UpdateVoter>;
+    }
+    interface UpdateVoterInstance extends TypedEventInstance<UpdateVoter> {
+        data_decoded: UpdateVoter;
+        type_arguments: [];
+    }
     interface UpdateVoterEvent {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
@@ -1481,6 +2308,21 @@ export declare namespace vesting {
         data_decoded: UpdateVoterEvent;
         type_arguments: [];
     }
+    interface Vest {
+        admin: MoveAddressType;
+        vesting_contract_address: MoveAddressType;
+        staking_pool_address: MoveAddressType;
+        period_vested: bigint;
+        amount: bigint;
+    }
+    namespace Vest {
+        const TYPE_QNAME = "0x1::vesting::Vest";
+        function type(): TypeDescriptor<Vest>;
+    }
+    interface VestInstance extends TypedEventInstance<Vest> {
+        data_decoded: Vest;
+        type_arguments: [];
+    }
     interface VestEvent {
         admin: MoveAddressType;
         vesting_contract_address: MoveAddressType;
@@ -1569,6 +2411,10 @@ export declare namespace vesting {
         arguments_decoded: [MoveAddressType, MoveAddressType, MoveAddressType];
         type_arguments: [];
     }
+    interface SetBeneficiaryForOperatorPayload extends TypedFunctionPayload<[MoveAddressType]> {
+        arguments_decoded: [MoveAddressType];
+        type_arguments: [];
+    }
     interface SetBeneficiaryResetterPayload extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
         arguments_decoded: [MoveAddressType, MoveAddressType];
         type_arguments: [];
@@ -1710,6 +2556,13 @@ export declare namespace features {
         const TYPE_QNAME = "0x1::features::Features";
         function type(): TypeDescriptor<Features>;
     }
+    interface PendingFeatures {
+        features: string;
+    }
+    namespace PendingFeatures {
+        const TYPE_QNAME = "0x1::features::PendingFeatures";
+        function type(): TypeDescriptor<PendingFeatures>;
+    }
 }
 export declare namespace from_bcs { }
 export declare namespace pool_u64 {
@@ -1920,6 +2773,34 @@ export declare namespace comparator {
     }
 }
 export declare namespace math_fixed { }
+export declare class randomness extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): randomness;
+    onEventRandomnessGeneratedEvent(func: (event: randomness.RandomnessGeneratedEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): randomness;
+}
+export declare namespace randomness {
+    interface PerBlockRandomness {
+        epoch: bigint;
+        round: bigint;
+        seed: option.Option<string>;
+    }
+    namespace PerBlockRandomness {
+        const TYPE_QNAME = "0x1::randomness::PerBlockRandomness";
+        function type(): TypeDescriptor<PerBlockRandomness>;
+    }
+    interface RandomnessGeneratedEvent {
+        dummy_field: Boolean;
+    }
+    namespace RandomnessGeneratedEvent {
+        const TYPE_QNAME = "0x1::randomness::RandomnessGeneratedEvent";
+        function type(): TypeDescriptor<RandomnessGeneratedEvent>;
+    }
+    interface RandomnessGeneratedEventInstance extends TypedEventInstance<RandomnessGeneratedEvent> {
+        data_decoded: RandomnessGeneratedEvent;
+        type_arguments: [];
+    }
+}
 export declare class simple_map extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -2088,6 +2969,7 @@ export declare class gas_schedule extends AptosBaseProcessor {
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): gas_schedule;
     onEventGasEntry(func: (event: gas_schedule.GasEntryInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): gas_schedule;
+    onEventGasScheduleV2(func: (event: gas_schedule.GasScheduleV2Instance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): gas_schedule;
 }
 export declare namespace gas_schedule {
     interface GasEntry {
@@ -2117,6 +2999,10 @@ export declare namespace gas_schedule {
         const TYPE_QNAME = "0x1::gas_schedule::GasScheduleV2";
         function type(): TypeDescriptor<GasScheduleV2>;
     }
+    interface GasScheduleV2Instance extends TypedEventInstance<GasScheduleV2> {
+        data_decoded: GasScheduleV2;
+        type_arguments: [];
+    }
 }
 export declare class managed_coin extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -2254,9 +3140,23 @@ export declare class aggregator_v2 extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): aggregator_v2;
+    onEventAggregator(func: (event: aggregator_v2.AggregatorInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aggregator_v2;
     onEventAggregatorSnapshot(func: (event: aggregator_v2.AggregatorSnapshotInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aggregator_v2;
+    onEventDerivedStringSnapshot(func: (event: aggregator_v2.DerivedStringSnapshotInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aggregator_v2;
 }
 export declare namespace aggregator_v2 {
+    interface Aggregator<T0> {
+        value: T0;
+        max_value: T0;
+    }
+    namespace Aggregator {
+        const TYPE_QNAME = "0x1::aggregator_v2::Aggregator";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Aggregator<T0>>;
+    }
+    interface AggregatorInstance extends TypedEventInstance<Aggregator<any>> {
+        data_decoded: Aggregator<any>;
+        type_arguments: [string];
+    }
     interface AggregatorSnapshot<T0> {
         value: T0;
     }
@@ -2268,6 +3168,18 @@ export declare namespace aggregator_v2 {
         data_decoded: AggregatorSnapshot<any>;
         type_arguments: [string];
     }
+    interface DerivedStringSnapshot {
+        value: string;
+        padding: string;
+    }
+    namespace DerivedStringSnapshot {
+        const TYPE_QNAME = "0x1::aggregator_v2::DerivedStringSnapshot";
+        function type(): TypeDescriptor<DerivedStringSnapshot>;
+    }
+    interface DerivedStringSnapshotInstance extends TypedEventInstance<DerivedStringSnapshot> {
+        data_decoded: DerivedStringSnapshot;
+        type_arguments: [];
+    }
 }
 export declare class aptos_account extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -2279,9 +3191,22 @@ export declare class aptos_account extends AptosBaseProcessor {
     onEntrySetAllowDirectCoinTransfers(func: (call: aptos_account.SetAllowDirectCoinTransfersPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
     onEntryTransfer(func: (call: aptos_account.TransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
     onEntryTransferCoins(func: (call: aptos_account.TransferCoinsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
+    onEventDirectCoinTransferConfigUpdated(func: (event: aptos_account.DirectCoinTransferConfigUpdatedInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
     onEventDirectCoinTransferConfigUpdatedEvent(func: (event: aptos_account.DirectCoinTransferConfigUpdatedEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
 }
 export declare namespace aptos_account {
+    interface DirectCoinTransferConfigUpdated {
+        account: MoveAddressType;
+        new_allow_direct_transfers: Boolean;
+    }
+    namespace DirectCoinTransferConfigUpdated {
+        const TYPE_QNAME = "0x1::aptos_account::DirectCoinTransferConfigUpdated";
+        function type(): TypeDescriptor<DirectCoinTransferConfigUpdated>;
+    }
+    interface DirectCoinTransferConfigUpdatedInstance extends TypedEventInstance<DirectCoinTransferConfigUpdated> {
+        data_decoded: DirectCoinTransferConfigUpdated;
+        type_arguments: [];
+    }
     interface DirectCoinTransferConfigUpdatedEvent {
         new_allow_direct_transfers: Boolean;
     }
@@ -2326,6 +3251,129 @@ export declare namespace aptos_account {
         type_arguments: [string];
     }
 }
+export declare namespace bn254_algebra {
+    interface FormatFq12LscLsb {
+        dummy_field: Boolean;
+    }
+    namespace FormatFq12LscLsb {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatFq12LscLsb";
+        function type(): TypeDescriptor<FormatFq12LscLsb>;
+    }
+    interface FormatFqLsb {
+        dummy_field: Boolean;
+    }
+    namespace FormatFqLsb {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatFqLsb";
+        function type(): TypeDescriptor<FormatFqLsb>;
+    }
+    interface FormatFqMsb {
+        dummy_field: Boolean;
+    }
+    namespace FormatFqMsb {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatFqMsb";
+        function type(): TypeDescriptor<FormatFqMsb>;
+    }
+    interface FormatFrLsb {
+        dummy_field: Boolean;
+    }
+    namespace FormatFrLsb {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatFrLsb";
+        function type(): TypeDescriptor<FormatFrLsb>;
+    }
+    interface FormatFrMsb {
+        dummy_field: Boolean;
+    }
+    namespace FormatFrMsb {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatFrMsb";
+        function type(): TypeDescriptor<FormatFrMsb>;
+    }
+    interface FormatG1Compr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG1Compr {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatG1Compr";
+        function type(): TypeDescriptor<FormatG1Compr>;
+    }
+    interface FormatG1Uncompr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG1Uncompr {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatG1Uncompr";
+        function type(): TypeDescriptor<FormatG1Uncompr>;
+    }
+    interface FormatG2Compr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG2Compr {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatG2Compr";
+        function type(): TypeDescriptor<FormatG2Compr>;
+    }
+    interface FormatG2Uncompr {
+        dummy_field: Boolean;
+    }
+    namespace FormatG2Uncompr {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatG2Uncompr";
+        function type(): TypeDescriptor<FormatG2Uncompr>;
+    }
+    interface FormatGt {
+        dummy_field: Boolean;
+    }
+    namespace FormatGt {
+        const TYPE_QNAME = "0x1::bn254_algebra::FormatGt";
+        function type(): TypeDescriptor<FormatGt>;
+    }
+    interface Fq {
+        dummy_field: Boolean;
+    }
+    namespace Fq {
+        const TYPE_QNAME = "0x1::bn254_algebra::Fq";
+        function type(): TypeDescriptor<Fq>;
+    }
+    interface Fq12 {
+        dummy_field: Boolean;
+    }
+    namespace Fq12 {
+        const TYPE_QNAME = "0x1::bn254_algebra::Fq12";
+        function type(): TypeDescriptor<Fq12>;
+    }
+    interface Fr {
+        dummy_field: Boolean;
+    }
+    namespace Fr {
+        const TYPE_QNAME = "0x1::bn254_algebra::Fr";
+        function type(): TypeDescriptor<Fr>;
+    }
+    interface G1 {
+        dummy_field: Boolean;
+    }
+    namespace G1 {
+        const TYPE_QNAME = "0x1::bn254_algebra::G1";
+        function type(): TypeDescriptor<G1>;
+    }
+    interface G2 {
+        dummy_field: Boolean;
+    }
+    namespace G2 {
+        const TYPE_QNAME = "0x1::bn254_algebra::G2";
+        function type(): TypeDescriptor<G2>;
+    }
+    interface Gt {
+        dummy_field: Boolean;
+    }
+    namespace Gt {
+        const TYPE_QNAME = "0x1::bn254_algebra::Gt";
+        function type(): TypeDescriptor<Gt>;
+    }
+}
+export declare namespace config_buffer {
+    interface PendingConfigs {
+        configs: simple_map.SimpleMap<string, any_.Any>;
+    }
+    namespace PendingConfigs {
+        const TYPE_QNAME = "0x1::config_buffer::PendingConfigs";
+        function type(): TypeDescriptor<PendingConfigs>;
+    }
+}
 export declare namespace create_signer { }
 export declare class fixed_point32 extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -2365,6 +3413,27 @@ export declare namespace fixed_point64 {
         type_arguments: [];
     }
 }
+export declare class function_info extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): function_info;
+    onEventFunctionInfo(func: (event: function_info.FunctionInfoInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): function_info;
+}
+export declare namespace function_info {
+    interface FunctionInfo {
+        module_address: MoveAddressType;
+        module_name: string;
+        function_name: string;
+    }
+    namespace FunctionInfo {
+        const TYPE_QNAME = "0x1::function_info::FunctionInfo";
+        function type(): TypeDescriptor<FunctionInfo>;
+    }
+    interface FunctionInfoInstance extends TypedEventInstance<FunctionInfo> {
+        data_decoded: FunctionInfo;
+        type_arguments: [];
+    }
+}
 export declare class multi_ed25519 extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -2504,11 +3573,15 @@ export declare class fungible_asset extends AptosBaseProcessor {
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): fungible_asset;
     onEntryTransfer(func: (call: fungible_asset.TransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): fungible_asset;
+    onEntryUpgradeStoreToConcurrent(func: (call: fungible_asset.UpgradeStoreToConcurrentPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): fungible_asset;
     onEventBurnRef(func: (event: fungible_asset.BurnRefInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): fungible_asset;
+    onEventDeposit(func: (event: fungible_asset.DepositInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): fungible_asset;
     onEventDepositEvent(func: (event: fungible_asset.DepositEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): fungible_asset;
+    onEventFrozen(func: (event: fungible_asset.FrozenInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): fungible_asset;
     onEventFrozenEvent(func: (event: fungible_asset.FrozenEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): fungible_asset;
     onEventMintRef(func: (event: fungible_asset.MintRefInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): fungible_asset;
     onEventTransferRef(func: (event: fungible_asset.TransferRefInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): fungible_asset;
+    onEventWithdraw(func: (event: fungible_asset.WithdrawInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): fungible_asset;
     onEventWithdrawEvent(func: (event: fungible_asset.WithdrawEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): fungible_asset;
 }
 export declare namespace fungible_asset {
@@ -2523,17 +3596,64 @@ export declare namespace fungible_asset {
         data_decoded: BurnRef;
         type_arguments: [];
     }
-    interface DepositEvent {
-        amount: bigint;
+    interface ConcurrentFungibleBalance {
+        balance: aggregator_v2.Aggregator<bigint>;
     }
-    namespace DepositEvent {
-        const TYPE_QNAME = "0x1::fungible_asset::DepositEvent";
-        function type(): TypeDescriptor<DepositEvent>;
+    namespace ConcurrentFungibleBalance {
+        const TYPE_QNAME = "0x1::fungible_asset::ConcurrentFungibleBalance";
+        function type(): TypeDescriptor<ConcurrentFungibleBalance>;
     }
-    interface DepositEventInstance extends TypedEventInstance<DepositEvent> {
+    interface ConcurrentSupply {
+        current: aggregator_v2.Aggregator<bigint>;
+    }
+    namespace ConcurrentSupply {
+        const TYPE_QNAME = "0x1::fungible_asset::ConcurrentSupply";
+        function type(): TypeDescriptor<ConcurrentSupply>;
+    }
+    interface Deposit {
+        store: MoveAddressType;
+        amount: bigint;
+    }
+    namespace Deposit {
+        const TYPE_QNAME = "0x1::fungible_asset::Deposit";
+        function type(): TypeDescriptor<Deposit>;
+    }
+    interface DepositInstance extends TypedEventInstance<Deposit> {
+        data_decoded: Deposit;
+        type_arguments: [];
+    }
+    interface DepositEvent {
+        amount: bigint;
+    }
+    namespace DepositEvent {
+        const TYPE_QNAME = "0x1::fungible_asset::DepositEvent";
+        function type(): TypeDescriptor<DepositEvent>;
+    }
+    interface DepositEventInstance extends TypedEventInstance<DepositEvent> {
         data_decoded: DepositEvent;
         type_arguments: [];
     }
+    interface DispatchFunctionStore {
+        withdraw_function: option.Option<function_info.FunctionInfo>;
+        deposit_function: option.Option<function_info.FunctionInfo>;
+        derived_balance_function: option.Option<function_info.FunctionInfo>;
+    }
+    namespace DispatchFunctionStore {
+        const TYPE_QNAME = "0x1::fungible_asset::DispatchFunctionStore";
+        function type(): TypeDescriptor<DispatchFunctionStore>;
+    }
+    interface Frozen {
+        store: MoveAddressType;
+        frozen: Boolean;
+    }
+    namespace Frozen {
+        const TYPE_QNAME = "0x1::fungible_asset::Frozen";
+        function type(): TypeDescriptor<Frozen>;
+    }
+    interface FrozenInstance extends TypedEventInstance<Frozen> {
+        data_decoded: Frozen;
+        type_arguments: [];
+    }
     interface FrozenEvent {
         frozen: Boolean;
     }
@@ -2612,6 +3732,25 @@ export declare namespace fungible_asset {
         data_decoded: TransferRef;
         type_arguments: [];
     }
+    interface Untransferable {
+        dummy_field: Boolean;
+    }
+    namespace Untransferable {
+        const TYPE_QNAME = "0x1::fungible_asset::Untransferable";
+        function type(): TypeDescriptor<Untransferable>;
+    }
+    interface Withdraw {
+        store: MoveAddressType;
+        amount: bigint;
+    }
+    namespace Withdraw {
+        const TYPE_QNAME = "0x1::fungible_asset::Withdraw";
+        function type(): TypeDescriptor<Withdraw>;
+    }
+    interface WithdrawInstance extends TypedEventInstance<Withdraw> {
+        data_decoded: Withdraw;
+        type_arguments: [];
+    }
     interface WithdrawEvent {
         amount: bigint;
     }
@@ -2631,6 +3770,10 @@ export declare namespace fungible_asset {
         arguments_decoded: [object_.Object<T0>, object_.Object<T0>, bigint];
         type_arguments: [string];
     }
+    interface UpgradeStoreToConcurrentPayload<T0 = any> extends TypedFunctionPayload<[object_.Object<T0>]> {
+        arguments_decoded: [object_.Object<T0>];
+        type_arguments: [string];
+    }
 }
 export declare namespace staking_config {
     interface StakingConfig {
@@ -2663,31 +3806,67 @@ export declare class delegation_pool extends AptosBaseProcessor {
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): delegation_pool;
     onEntryAddStake(func: (call: delegation_pool.AddStakePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEntryAllowlistDelegator(func: (call: delegation_pool.AllowlistDelegatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntryCreateProposal(func: (call: delegation_pool.CreateProposalPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntryDelegateVotingPower(func: (call: delegation_pool.DelegateVotingPowerPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEntryDisableDelegatorsAllowlisting(func: (call: delegation_pool.DisableDelegatorsAllowlistingPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEntryEnableDelegatorsAllowlisting(func: (call: delegation_pool.EnableDelegatorsAllowlistingPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntryEnablePartialGovernanceVoting(func: (call: delegation_pool.EnablePartialGovernanceVotingPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEntryEvictDelegator(func: (call: delegation_pool.EvictDelegatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntryInitializeDelegationPool(func: (call: delegation_pool.InitializeDelegationPoolPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntryReactivateStake(func: (call: delegation_pool.ReactivateStakePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEntryRemoveDelegatorFromAllowlist(func: (call: delegation_pool.RemoveDelegatorFromAllowlistPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEntrySetBeneficiaryForOperator(func: (call: delegation_pool.SetBeneficiaryForOperatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntrySetDelegatedVoter(func: (call: delegation_pool.SetDelegatedVoterPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntrySetOperator(func: (call: delegation_pool.SetOperatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntrySynchronizeDelegationPool(func: (call: delegation_pool.SynchronizeDelegationPoolPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntryUnlock(func: (call: delegation_pool.UnlockPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEntryUpdateCommissionPercentage(func: (call: delegation_pool.UpdateCommissionPercentagePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntryVote(func: (call: delegation_pool.VotePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEntryWithdraw(func: (call: delegation_pool.WithdrawPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventAddStake(func: (event: delegation_pool.AddStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventAddStakeEvent(func: (event: delegation_pool.AddStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventAllowlistDelegator(func: (event: delegation_pool.AllowlistDelegatorInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventCommissionPercentageChange(func: (event: delegation_pool.CommissionPercentageChangeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventCreateProposal(func: (event: delegation_pool.CreateProposalInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventCreateProposalEvent(func: (event: delegation_pool.CreateProposalEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventDelegateVotingPower(func: (event: delegation_pool.DelegateVotingPowerInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventDelegateVotingPowerEvent(func: (event: delegation_pool.DelegateVotingPowerEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventDelegatedVotes(func: (event: delegation_pool.DelegatedVotesInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventDisableDelegatorsAllowlisting(func: (event: delegation_pool.DisableDelegatorsAllowlistingInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventDistributeCommission(func: (event: delegation_pool.DistributeCommissionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventDistributeCommissionEvent(func: (event: delegation_pool.DistributeCommissionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventEnableDelegatorsAllowlisting(func: (event: delegation_pool.EnableDelegatorsAllowlistingInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventEvictDelegator(func: (event: delegation_pool.EvictDelegatorInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventObservedLockupCycle(func: (event: delegation_pool.ObservedLockupCycleInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventReactivateStake(func: (event: delegation_pool.ReactivateStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventReactivateStakeEvent(func: (event: delegation_pool.ReactivateStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventRemoveDelegatorFromAllowlist(func: (event: delegation_pool.RemoveDelegatorFromAllowlistInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventSetBeneficiaryForOperator(func: (event: delegation_pool.SetBeneficiaryForOperatorInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventUnlockStake(func: (event: delegation_pool.UnlockStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventUnlockStakeEvent(func: (event: delegation_pool.UnlockStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventVote(func: (event: delegation_pool.VoteInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventVoteDelegation(func: (event: delegation_pool.VoteDelegationInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventVoteEvent(func: (event: delegation_pool.VoteEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventVotingRecordKey(func: (event: delegation_pool.VotingRecordKeyInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventWithdrawStake(func: (event: delegation_pool.WithdrawStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventWithdrawStakeEvent(func: (event: delegation_pool.WithdrawStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
 }
 export declare namespace delegation_pool {
+    interface AddStake {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+        amount_added: bigint;
+        add_stake_fee: bigint;
+    }
+    namespace AddStake {
+        const TYPE_QNAME = "0x1::delegation_pool::AddStake";
+        function type(): TypeDescriptor<AddStake>;
+    }
+    interface AddStakeInstance extends TypedEventInstance<AddStake> {
+        data_decoded: AddStake;
+        type_arguments: [];
+    }
     interface AddStakeEvent {
         pool_address: MoveAddressType;
         delegator_address: MoveAddressType;
@@ -2702,6 +3881,51 @@ export declare namespace delegation_pool {
         data_decoded: AddStakeEvent;
         type_arguments: [];
     }
+    interface AllowlistDelegator {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+    }
+    namespace AllowlistDelegator {
+        const TYPE_QNAME = "0x1::delegation_pool::AllowlistDelegator";
+        function type(): TypeDescriptor<AllowlistDelegator>;
+    }
+    interface AllowlistDelegatorInstance extends TypedEventInstance<AllowlistDelegator> {
+        data_decoded: AllowlistDelegator;
+        type_arguments: [];
+    }
+    interface BeneficiaryForOperator {
+        beneficiary_for_operator: MoveAddressType;
+    }
+    namespace BeneficiaryForOperator {
+        const TYPE_QNAME = "0x1::delegation_pool::BeneficiaryForOperator";
+        function type(): TypeDescriptor<BeneficiaryForOperator>;
+    }
+    interface CommissionPercentageChange {
+        pool_address: MoveAddressType;
+        owner: MoveAddressType;
+        commission_percentage_next_lockup_cycle: bigint;
+    }
+    namespace CommissionPercentageChange {
+        const TYPE_QNAME = "0x1::delegation_pool::CommissionPercentageChange";
+        function type(): TypeDescriptor<CommissionPercentageChange>;
+    }
+    interface CommissionPercentageChangeInstance extends TypedEventInstance<CommissionPercentageChange> {
+        data_decoded: CommissionPercentageChange;
+        type_arguments: [];
+    }
+    interface CreateProposal {
+        proposal_id: bigint;
+        voter: MoveAddressType;
+        delegation_pool: MoveAddressType;
+    }
+    namespace CreateProposal {
+        const TYPE_QNAME = "0x1::delegation_pool::CreateProposal";
+        function type(): TypeDescriptor<CreateProposal>;
+    }
+    interface CreateProposalInstance extends TypedEventInstance<CreateProposal> {
+        data_decoded: CreateProposal;
+        type_arguments: [];
+    }
     interface CreateProposalEvent {
         proposal_id: bigint;
         voter: MoveAddressType;
@@ -2715,6 +3939,19 @@ export declare namespace delegation_pool {
         data_decoded: CreateProposalEvent;
         type_arguments: [];
     }
+    interface DelegateVotingPower {
+        pool_address: MoveAddressType;
+        delegator: MoveAddressType;
+        voter: MoveAddressType;
+    }
+    namespace DelegateVotingPower {
+        const TYPE_QNAME = "0x1::delegation_pool::DelegateVotingPower";
+        function type(): TypeDescriptor<DelegateVotingPower>;
+    }
+    interface DelegateVotingPowerInstance extends TypedEventInstance<DelegateVotingPower> {
+        data_decoded: DelegateVotingPower;
+        type_arguments: [];
+    }
     interface DelegateVotingPowerEvent {
         pool_address: MoveAddressType;
         delegator: MoveAddressType;
@@ -2760,6 +3997,13 @@ export declare namespace delegation_pool {
         const TYPE_QNAME = "0x1::delegation_pool::DelegationPool";
         function type(): TypeDescriptor<DelegationPool>;
     }
+    interface DelegationPoolAllowlisting {
+        allowlist: smart_table.SmartTable<MoveAddressType, Boolean>;
+    }
+    namespace DelegationPoolAllowlisting {
+        const TYPE_QNAME = "0x1::delegation_pool::DelegationPoolAllowlisting";
+        function type(): TypeDescriptor<DelegationPoolAllowlisting>;
+    }
     interface DelegationPoolOwnership {
         pool_address: MoveAddressType;
     }
@@ -2767,6 +4011,32 @@ export declare namespace delegation_pool {
         const TYPE_QNAME = "0x1::delegation_pool::DelegationPoolOwnership";
         function type(): TypeDescriptor<DelegationPoolOwnership>;
     }
+    interface DisableDelegatorsAllowlisting {
+        pool_address: MoveAddressType;
+    }
+    namespace DisableDelegatorsAllowlisting {
+        const TYPE_QNAME = "0x1::delegation_pool::DisableDelegatorsAllowlisting";
+        function type(): TypeDescriptor<DisableDelegatorsAllowlisting>;
+    }
+    interface DisableDelegatorsAllowlistingInstance extends TypedEventInstance<DisableDelegatorsAllowlisting> {
+        data_decoded: DisableDelegatorsAllowlisting;
+        type_arguments: [];
+    }
+    interface DistributeCommission {
+        pool_address: MoveAddressType;
+        operator: MoveAddressType;
+        beneficiary: MoveAddressType;
+        commission_active: bigint;
+        commission_pending_inactive: bigint;
+    }
+    namespace DistributeCommission {
+        const TYPE_QNAME = "0x1::delegation_pool::DistributeCommission";
+        function type(): TypeDescriptor<DistributeCommission>;
+    }
+    interface DistributeCommissionInstance extends TypedEventInstance<DistributeCommission> {
+        data_decoded: DistributeCommission;
+        type_arguments: [];
+    }
     interface DistributeCommissionEvent {
         pool_address: MoveAddressType;
         operator: MoveAddressType;
@@ -2781,6 +4051,29 @@ export declare namespace delegation_pool {
         data_decoded: DistributeCommissionEvent;
         type_arguments: [];
     }
+    interface EnableDelegatorsAllowlisting {
+        pool_address: MoveAddressType;
+    }
+    namespace EnableDelegatorsAllowlisting {
+        const TYPE_QNAME = "0x1::delegation_pool::EnableDelegatorsAllowlisting";
+        function type(): TypeDescriptor<EnableDelegatorsAllowlisting>;
+    }
+    interface EnableDelegatorsAllowlistingInstance extends TypedEventInstance<EnableDelegatorsAllowlisting> {
+        data_decoded: EnableDelegatorsAllowlisting;
+        type_arguments: [];
+    }
+    interface EvictDelegator {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+    }
+    namespace EvictDelegator {
+        const TYPE_QNAME = "0x1::delegation_pool::EvictDelegator";
+        function type(): TypeDescriptor<EvictDelegator>;
+    }
+    interface EvictDelegatorInstance extends TypedEventInstance<EvictDelegator> {
+        data_decoded: EvictDelegator;
+        type_arguments: [];
+    }
     interface GovernanceRecords {
         votes: smart_table.SmartTable<delegation_pool.VotingRecordKey, bigint>;
         votes_per_proposal: smart_table.SmartTable<bigint, bigint>;
@@ -2794,6 +4087,14 @@ export declare namespace delegation_pool {
         const TYPE_QNAME = "0x1::delegation_pool::GovernanceRecords";
         function type(): TypeDescriptor<GovernanceRecords>;
     }
+    interface NextCommissionPercentage {
+        commission_percentage_next_lockup_cycle: bigint;
+        effective_after_secs: bigint;
+    }
+    namespace NextCommissionPercentage {
+        const TYPE_QNAME = "0x1::delegation_pool::NextCommissionPercentage";
+        function type(): TypeDescriptor<NextCommissionPercentage>;
+    }
     interface ObservedLockupCycle {
         index: bigint;
     }
@@ -2805,6 +4106,19 @@ export declare namespace delegation_pool {
         data_decoded: ObservedLockupCycle;
         type_arguments: [];
     }
+    interface ReactivateStake {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+        amount_reactivated: bigint;
+    }
+    namespace ReactivateStake {
+        const TYPE_QNAME = "0x1::delegation_pool::ReactivateStake";
+        function type(): TypeDescriptor<ReactivateStake>;
+    }
+    interface ReactivateStakeInstance extends TypedEventInstance<ReactivateStake> {
+        data_decoded: ReactivateStake;
+        type_arguments: [];
+    }
     interface ReactivateStakeEvent {
         pool_address: MoveAddressType;
         delegator_address: MoveAddressType;
@@ -2818,6 +4132,44 @@ export declare namespace delegation_pool {
         data_decoded: ReactivateStakeEvent;
         type_arguments: [];
     }
+    interface RemoveDelegatorFromAllowlist {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+    }
+    namespace RemoveDelegatorFromAllowlist {
+        const TYPE_QNAME = "0x1::delegation_pool::RemoveDelegatorFromAllowlist";
+        function type(): TypeDescriptor<RemoveDelegatorFromAllowlist>;
+    }
+    interface RemoveDelegatorFromAllowlistInstance extends TypedEventInstance<RemoveDelegatorFromAllowlist> {
+        data_decoded: RemoveDelegatorFromAllowlist;
+        type_arguments: [];
+    }
+    interface SetBeneficiaryForOperator {
+        operator: MoveAddressType;
+        old_beneficiary: MoveAddressType;
+        new_beneficiary: MoveAddressType;
+    }
+    namespace SetBeneficiaryForOperator {
+        const TYPE_QNAME = "0x1::delegation_pool::SetBeneficiaryForOperator";
+        function type(): TypeDescriptor<SetBeneficiaryForOperator>;
+    }
+    interface SetBeneficiaryForOperatorInstance extends TypedEventInstance<SetBeneficiaryForOperator> {
+        data_decoded: SetBeneficiaryForOperator;
+        type_arguments: [];
+    }
+    interface UnlockStake {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+        amount_unlocked: bigint;
+    }
+    namespace UnlockStake {
+        const TYPE_QNAME = "0x1::delegation_pool::UnlockStake";
+        function type(): TypeDescriptor<UnlockStake>;
+    }
+    interface UnlockStakeInstance extends TypedEventInstance<UnlockStake> {
+        data_decoded: UnlockStake;
+        type_arguments: [];
+    }
     interface UnlockStakeEvent {
         pool_address: MoveAddressType;
         delegator_address: MoveAddressType;
@@ -2831,6 +4183,21 @@ export declare namespace delegation_pool {
         data_decoded: UnlockStakeEvent;
         type_arguments: [];
     }
+    interface Vote {
+        voter: MoveAddressType;
+        proposal_id: bigint;
+        delegation_pool: MoveAddressType;
+        num_votes: bigint;
+        should_pass: Boolean;
+    }
+    namespace Vote {
+        const TYPE_QNAME = "0x1::delegation_pool::Vote";
+        function type(): TypeDescriptor<Vote>;
+    }
+    interface VoteInstance extends TypedEventInstance<Vote> {
+        data_decoded: Vote;
+        type_arguments: [];
+    }
     interface VoteDelegation {
         voter: MoveAddressType;
         pending_voter: MoveAddressType;
@@ -2871,6 +4238,19 @@ export declare namespace delegation_pool {
         data_decoded: VotingRecordKey;
         type_arguments: [];
     }
+    interface WithdrawStake {
+        pool_address: MoveAddressType;
+        delegator_address: MoveAddressType;
+        amount_withdrawn: bigint;
+    }
+    namespace WithdrawStake {
+        const TYPE_QNAME = "0x1::delegation_pool::WithdrawStake";
+        function type(): TypeDescriptor<WithdrawStake>;
+    }
+    interface WithdrawStakeInstance extends TypedEventInstance<WithdrawStake> {
+        data_decoded: WithdrawStake;
+        type_arguments: [];
+    }
     interface WithdrawStakeEvent {
         pool_address: MoveAddressType;
         delegator_address: MoveAddressType;
@@ -2888,6 +4268,10 @@ export declare namespace delegation_pool {
         arguments_decoded: [MoveAddressType, bigint];
         type_arguments: [];
     }
+    interface AllowlistDelegatorPayload extends TypedFunctionPayload<[MoveAddressType]> {
+        arguments_decoded: [MoveAddressType];
+        type_arguments: [];
+    }
     interface CreateProposalPayload extends TypedFunctionPayload<[
         MoveAddressType,
         string,
@@ -2902,10 +4286,22 @@ export declare namespace delegation_pool {
         arguments_decoded: [MoveAddressType, MoveAddressType];
         type_arguments: [];
     }
+    interface DisableDelegatorsAllowlistingPayload extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
+    interface EnableDelegatorsAllowlistingPayload extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
     interface EnablePartialGovernanceVotingPayload extends TypedFunctionPayload<[MoveAddressType]> {
         arguments_decoded: [MoveAddressType];
         type_arguments: [];
     }
+    interface EvictDelegatorPayload extends TypedFunctionPayload<[MoveAddressType]> {
+        arguments_decoded: [MoveAddressType];
+        type_arguments: [];
+    }
     interface InitializeDelegationPoolPayload extends TypedFunctionPayload<[bigint, string]> {
         arguments_decoded: [bigint, string];
         type_arguments: [];
@@ -2914,6 +4310,14 @@ export declare namespace delegation_pool {
         arguments_decoded: [MoveAddressType, bigint];
         type_arguments: [];
     }
+    interface RemoveDelegatorFromAllowlistPayload extends TypedFunctionPayload<[MoveAddressType]> {
+        arguments_decoded: [MoveAddressType];
+        type_arguments: [];
+    }
+    interface SetBeneficiaryForOperatorPayload extends TypedFunctionPayload<[MoveAddressType]> {
+        arguments_decoded: [MoveAddressType];
+        type_arguments: [];
+    }
     interface SetDelegatedVoterPayload extends TypedFunctionPayload<[MoveAddressType]> {
         arguments_decoded: [MoveAddressType];
         type_arguments: [];
@@ -2930,6 +4334,10 @@ export declare namespace delegation_pool {
         arguments_decoded: [MoveAddressType, bigint];
         type_arguments: [];
     }
+    interface UpdateCommissionPercentagePayload extends TypedFunctionPayload<[bigint]> {
+        arguments_decoded: [bigint];
+        type_arguments: [];
+    }
     interface VotePayload extends TypedFunctionPayload<[MoveAddressType, bigint, bigint, Boolean]> {
         arguments_decoded: [MoveAddressType, bigint, bigint, Boolean];
         type_arguments: [];
@@ -2939,10 +4347,60 @@ export declare namespace delegation_pool {
         type_arguments: [];
     }
 }
+export declare class keyless_account extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): keyless_account;
+    onEventConfiguration(func: (event: keyless_account.ConfigurationInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): keyless_account;
+    onEventGroth16VerificationKey(func: (event: keyless_account.Groth16VerificationKeyInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): keyless_account;
+}
+export declare namespace keyless_account {
+    interface Configuration {
+        override_aud_vals: string[];
+        max_signatures_per_txn: number;
+        max_exp_horizon_secs: bigint;
+        training_wheels_pubkey: option.Option<string>;
+        max_commited_epk_bytes: number;
+        max_iss_val_bytes: number;
+        max_extra_field_bytes: number;
+        max_jwt_header_b64_bytes: number;
+    }
+    namespace Configuration {
+        const TYPE_QNAME = "0x1::keyless_account::Configuration";
+        function type(): TypeDescriptor<Configuration>;
+    }
+    interface ConfigurationInstance extends TypedEventInstance<Configuration> {
+        data_decoded: Configuration;
+        type_arguments: [];
+    }
+    interface Groth16VerificationKey {
+        alpha_g1: string;
+        beta_g2: string;
+        gamma_g2: string;
+        delta_g2: string;
+        gamma_abc_g1: string[];
+    }
+    namespace Groth16VerificationKey {
+        const TYPE_QNAME = "0x1::keyless_account::Groth16VerificationKey";
+        function type(): TypeDescriptor<Groth16VerificationKey>;
+    }
+    interface Groth16VerificationKeyInstance extends TypedEventInstance<Groth16VerificationKey> {
+        data_decoded: Groth16VerificationKey;
+        type_arguments: [];
+    }
+    interface Group {
+        dummy_field: Boolean;
+    }
+    namespace Group {
+        const TYPE_QNAME = "0x1::keyless_account::Group";
+        function type(): TypeDescriptor<Group>;
+    }
+}
 export declare class reconfiguration extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): reconfiguration;
+    onEventNewEpoch(func: (event: reconfiguration.NewEpochInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): reconfiguration;
     onEventNewEpochEvent(func: (event: reconfiguration.NewEpochEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): reconfiguration;
 }
 export declare namespace reconfiguration {
@@ -2962,6 +4420,17 @@ export declare namespace reconfiguration {
         const TYPE_QNAME = "0x1::reconfiguration::DisableReconfiguration";
         function type(): TypeDescriptor<DisableReconfiguration>;
     }
+    interface NewEpoch {
+        epoch: bigint;
+    }
+    namespace NewEpoch {
+        const TYPE_QNAME = "0x1::reconfiguration::NewEpoch";
+        function type(): TypeDescriptor<NewEpoch>;
+    }
+    interface NewEpochInstance extends TypedEventInstance<NewEpoch> {
+        data_decoded: NewEpoch;
+        type_arguments: [];
+    }
     interface NewEpochEvent {
         epoch: bigint;
     }
@@ -2978,6 +4447,7 @@ export declare class transaction_fee extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): transaction_fee;
+    onEntryConvertToAptosFaBurnRef(func: (call: transaction_fee.ConvertToAptosFaBurnRefPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): transaction_fee;
     onEventFeeStatement(func: (event: transaction_fee.FeeStatementInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): transaction_fee;
 }
 export declare namespace transaction_fee {
@@ -2995,6 +4465,13 @@ export declare namespace transaction_fee {
         const TYPE_QNAME = "0x1::transaction_fee::AptosCoinMintCapability";
         function type(): TypeDescriptor<AptosCoinMintCapability>;
     }
+    interface AptosFABurnCapabilities {
+        burn_ref: fungible_asset.BurnRef;
+    }
+    namespace AptosFABurnCapabilities {
+        const TYPE_QNAME = "0x1::transaction_fee::AptosFABurnCapabilities";
+        function type(): TypeDescriptor<AptosFABurnCapabilities>;
+    }
     interface CollectedFeesPerBlock {
         amount: coin.AggregatableCoin<aptos_coin.AptosCoin>;
         proposer: option.Option<MoveAddressType>;
@@ -3019,19 +4496,31 @@ export declare namespace transaction_fee {
         data_decoded: FeeStatement;
         type_arguments: [];
     }
+    interface ConvertToAptosFaBurnRefPayload extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
 }
 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?: Partial<MoveFetchConfig>): aptos_governance;
+    onEntryBatchPartialVote(func: (call: aptos_governance.BatchPartialVotePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
+    onEntryBatchVote(func: (call: aptos_governance.BatchVotePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEntryCreateProposal(func: (call: aptos_governance.CreateProposalPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEntryCreateProposalV2(func: (call: aptos_governance.CreateProposalV2Payload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
+    onEntryForceEndEpoch(func: (call: aptos_governance.ForceEndEpochPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
+    onEntryForceEndEpochTestOnly(func: (call: aptos_governance.ForceEndEpochTestOnlyPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEntryPartialVote(func: (call: aptos_governance.PartialVotePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
+    onEntryReconfigure(func: (call: aptos_governance.ReconfigurePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEntryVote(func: (call: aptos_governance.VotePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
+    onEventCreateProposal(func: (event: aptos_governance.CreateProposalInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEventCreateProposalEvent(func: (event: aptos_governance.CreateProposalEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEventRecordKey(func: (event: aptos_governance.RecordKeyInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
+    onEventUpdateConfig(func: (event: aptos_governance.UpdateConfigInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEventUpdateConfigEvent(func: (event: aptos_governance.UpdateConfigEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
+    onEventVote(func: (event: aptos_governance.VoteInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEventVoteEvent(func: (event: aptos_governance.VoteEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
 }
 export declare namespace aptos_governance {
@@ -3042,6 +4531,21 @@ export declare namespace aptos_governance {
         const TYPE_QNAME = "0x1::aptos_governance::ApprovedExecutionHashes";
         function type(): TypeDescriptor<ApprovedExecutionHashes>;
     }
+    interface CreateProposal {
+        proposer: MoveAddressType;
+        stake_pool: MoveAddressType;
+        proposal_id: bigint;
+        execution_hash: string;
+        proposal_metadata: simple_map.SimpleMap<string, string>;
+    }
+    namespace CreateProposal {
+        const TYPE_QNAME = "0x1::aptos_governance::CreateProposal";
+        function type(): TypeDescriptor<CreateProposal>;
+    }
+    interface CreateProposalInstance extends TypedEventInstance<CreateProposal> {
+        data_decoded: CreateProposal;
+        type_arguments: [];
+    }
     interface CreateProposalEvent {
         proposer: MoveAddressType;
         stake_pool: MoveAddressType;
@@ -3094,6 +4598,19 @@ export declare namespace aptos_governance {
         data_decoded: RecordKey;
         type_arguments: [];
     }
+    interface UpdateConfig {
+        min_voting_threshold: bigint;
+        required_proposer_stake: bigint;
+        voting_duration_secs: bigint;
+    }
+    namespace UpdateConfig {
+        const TYPE_QNAME = "0x1::aptos_governance::UpdateConfig";
+        function type(): TypeDescriptor<UpdateConfig>;
+    }
+    interface UpdateConfigInstance extends TypedEventInstance<UpdateConfig> {
+        data_decoded: UpdateConfig;
+        type_arguments: [];
+    }
     interface UpdateConfigEvent {
         min_voting_threshold: bigint;
         required_proposer_stake: bigint;
@@ -3107,6 +4624,21 @@ export declare namespace aptos_governance {
         data_decoded: UpdateConfigEvent;
         type_arguments: [];
     }
+    interface Vote {
+        proposal_id: bigint;
+        voter: MoveAddressType;
+        stake_pool: MoveAddressType;
+        num_votes: bigint;
+        should_pass: Boolean;
+    }
+    namespace Vote {
+        const TYPE_QNAME = "0x1::aptos_governance::Vote";
+        function type(): TypeDescriptor<Vote>;
+    }
+    interface VoteInstance extends TypedEventInstance<Vote> {
+        data_decoded: Vote;
+        type_arguments: [];
+    }
     interface VoteEvent {
         proposal_id: bigint;
         voter: MoveAddressType;
@@ -3140,6 +4672,14 @@ export declare namespace aptos_governance {
         arguments_decoded: [bigint];
         type_arguments: [];
     }
+    interface BatchPartialVotePayload extends TypedFunctionPayload<[MoveAddressType[], bigint, bigint, Boolean]> {
+        arguments_decoded: [MoveAddressType[], bigint, bigint, Boolean];
+        type_arguments: [];
+    }
+    interface BatchVotePayload extends TypedFunctionPayload<[MoveAddressType[], bigint, Boolean]> {
+        arguments_decoded: [MoveAddressType[], bigint, Boolean];
+        type_arguments: [];
+    }
     interface CreateProposalPayload extends TypedFunctionPayload<[MoveAddressType, string, string, string]> {
         arguments_decoded: [MoveAddressType, string, string, string];
         type_arguments: [];
@@ -3154,10 +4694,22 @@ export declare namespace aptos_governance {
         arguments_decoded: [MoveAddressType, string, string, string, Boolean];
         type_arguments: [];
     }
+    interface ForceEndEpochPayload extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
+    interface ForceEndEpochTestOnlyPayload extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
     interface PartialVotePayload extends TypedFunctionPayload<[MoveAddressType, bigint, bigint, Boolean]> {
         arguments_decoded: [MoveAddressType, bigint, bigint, Boolean];
         type_arguments: [];
     }
+    interface ReconfigurePayload extends TypedFunctionPayload<[]> {
+        arguments_decoded: [];
+        type_arguments: [];
+    }
     interface VotePayload extends TypedFunctionPayload<[MoveAddressType, bigint, Boolean]> {
         arguments_decoded: [MoveAddressType, bigint, Boolean];
         type_arguments: [];
@@ -3270,6 +4822,12 @@ export declare namespace bls12381_algebra {
         function type(): TypeDescriptor<HashG2XmdSha256SswuRo>;
     }
 }
+export declare class consensus_config extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): consensus_config;
+    onEventConsensusConfig(func: (event: consensus_config.ConsensusConfigInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): consensus_config;
+}
 export declare namespace consensus_config {
     interface ConsensusConfig {
         config: string;
@@ -3278,6 +4836,16 @@ export declare namespace consensus_config {
         const TYPE_QNAME = "0x1::consensus_config::ConsensusConfig";
         function type(): TypeDescriptor<ConsensusConfig>;
     }
+    interface ConsensusConfigInstance extends TypedEventInstance<ConsensusConfig> {
+        data_decoded: ConsensusConfig;
+        type_arguments: [];
+    }
+}
+export declare class execution_config extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): execution_config;
+    onEventExecutionConfig(func: (event: execution_config.ExecutionConfigInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): execution_config;
 }
 export declare namespace execution_config {
     interface ExecutionConfig {
@@ -3287,6 +4855,10 @@ export declare namespace execution_config {
         const TYPE_QNAME = "0x1::execution_config::ExecutionConfig";
         function type(): TypeDescriptor<ExecutionConfig>;
     }
+    interface ExecutionConfigInstance extends TypedEventInstance<ExecutionConfig> {
+        data_decoded: ExecutionConfig;
+        type_arguments: [];
+    }
 }
 export declare class multisig_account extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -3304,6 +4876,7 @@ export declare class multisig_account extends AptosBaseProcessor {
     onEntryCreateWithOwners(func: (call: multisig_account.CreateWithOwnersPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryCreateWithOwnersThenRemoveBootstrapper(func: (call: multisig_account.CreateWithOwnersThenRemoveBootstrapperPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryExecuteRejectedTransaction(func: (call: multisig_account.ExecuteRejectedTransactionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEntryExecuteRejectedTransactions(func: (call: multisig_account.ExecuteRejectedTransactionsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryRejectTransaction(func: (call: multisig_account.RejectTransactionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryRemoveOwner(func: (call: multisig_account.RemoveOwnerPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryRemoveOwners(func: (call: multisig_account.RemoveOwnersPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
@@ -3312,20 +4885,43 @@ export declare class multisig_account extends AptosBaseProcessor {
     onEntrySwapOwnersAndUpdateSignaturesRequired(func: (call: multisig_account.SwapOwnersAndUpdateSignaturesRequiredPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryUpdateMetadata(func: (call: multisig_account.UpdateMetadataPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryUpdateSignaturesRequired(func: (call: multisig_account.UpdateSignaturesRequiredPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEntryVoteTransaction(func: (call: multisig_account.VoteTransactionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEntryVoteTransactions(func: (call: multisig_account.VoteTransactionsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEntryVoteTransanction(func: (call: multisig_account.VoteTransanctionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEventAddOwners(func: (event: multisig_account.AddOwnersInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEventAddOwnersEvent(func: (event: multisig_account.AddOwnersEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEventCreateTransaction(func: (event: multisig_account.CreateTransactionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEventCreateTransactionEvent(func: (event: multisig_account.CreateTransactionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEventExecuteRejectedTransaction(func: (event: multisig_account.ExecuteRejectedTransactionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEventExecuteRejectedTransactionEvent(func: (event: multisig_account.ExecuteRejectedTransactionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEventExecutionError(func: (event: multisig_account.ExecutionErrorInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEventMetadataUpdated(func: (event: multisig_account.MetadataUpdatedInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEventMetadataUpdatedEvent(func: (event: multisig_account.MetadataUpdatedEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEventMultisigTransaction(func: (event: multisig_account.MultisigTransactionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEventRemoveOwners(func: (event: multisig_account.RemoveOwnersInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEventRemoveOwnersEvent(func: (event: multisig_account.RemoveOwnersEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEventTransactionExecutionFailed(func: (event: multisig_account.TransactionExecutionFailedInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEventTransactionExecutionFailedEvent(func: (event: multisig_account.TransactionExecutionFailedEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEventTransactionExecutionSucceeded(func: (event: multisig_account.TransactionExecutionSucceededInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEventTransactionExecutionSucceededEvent(func: (event: multisig_account.TransactionExecutionSucceededEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEventUpdateSignaturesRequired(func: (event: multisig_account.UpdateSignaturesRequiredInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEventUpdateSignaturesRequiredEvent(func: (event: multisig_account.UpdateSignaturesRequiredEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEventVote(func: (event: multisig_account.VoteInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEventVoteEvent(func: (event: multisig_account.VoteEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
 }
 export declare namespace multisig_account {
+    interface AddOwners {
+        multisig_account: MoveAddressType;
+        owners_added: MoveAddressType[];
+    }
+    namespace AddOwners {
+        const TYPE_QNAME = "0x1::multisig_account::AddOwners";
+        function type(): TypeDescriptor<AddOwners>;
+    }
+    interface AddOwnersInstance extends TypedEventInstance<AddOwners> {
+        data_decoded: AddOwners;
+        type_arguments: [];
+    }
     interface AddOwnersEvent {
         owners_added: MoveAddressType[];
     }
@@ -3337,6 +4933,20 @@ export declare namespace multisig_account {
         data_decoded: AddOwnersEvent;
         type_arguments: [];
     }
+    interface CreateTransaction {
+        multisig_account: MoveAddressType;
+        creator: MoveAddressType;
+        sequence_number: bigint;
+        transaction: multisig_account.MultisigTransaction;
+    }
+    namespace CreateTransaction {
+        const TYPE_QNAME = "0x1::multisig_account::CreateTransaction";
+        function type(): TypeDescriptor<CreateTransaction>;
+    }
+    interface CreateTransactionInstance extends TypedEventInstance<CreateTransaction> {
+        data_decoded: CreateTransaction;
+        type_arguments: [];
+    }
     interface CreateTransactionEvent {
         creator: MoveAddressType;
         sequence_number: bigint;
@@ -3350,6 +4960,20 @@ export declare namespace multisig_account {
         data_decoded: CreateTransactionEvent;
         type_arguments: [];
     }
+    interface ExecuteRejectedTransaction {
+        multisig_account: MoveAddressType;
+        sequence_number: bigint;
+        num_rejections: bigint;
+        executor: MoveAddressType;
+    }
+    namespace ExecuteRejectedTransaction {
+        const TYPE_QNAME = "0x1::multisig_account::ExecuteRejectedTransaction";
+        function type(): TypeDescriptor<ExecuteRejectedTransaction>;
+    }
+    interface ExecuteRejectedTransactionInstance extends TypedEventInstance<ExecuteRejectedTransaction> {
+        data_decoded: ExecuteRejectedTransaction;
+        type_arguments: [];
+    }
     interface ExecuteRejectedTransactionEvent {
         sequence_number: bigint;
         num_rejections: bigint;
@@ -3376,6 +5000,19 @@ export declare namespace multisig_account {
         data_decoded: ExecutionError;
         type_arguments: [];
     }
+    interface MetadataUpdated {
+        multisig_account: MoveAddressType;
+        old_metadata: simple_map.SimpleMap<string, string>;
+        new_metadata: simple_map.SimpleMap<string, string>;
+    }
+    namespace MetadataUpdated {
+        const TYPE_QNAME = "0x1::multisig_account::MetadataUpdated";
+        function type(): TypeDescriptor<MetadataUpdated>;
+    }
+    interface MetadataUpdatedInstance extends TypedEventInstance<MetadataUpdated> {
+        data_decoded: MetadataUpdated;
+        type_arguments: [];
+    }
     interface MetadataUpdatedEvent {
         old_metadata: simple_map.SimpleMap<string, string>;
         new_metadata: simple_map.SimpleMap<string, string>;
@@ -3447,6 +5084,18 @@ export declare namespace multisig_account {
         data_decoded: MultisigTransaction;
         type_arguments: [];
     }
+    interface RemoveOwners {
+        multisig_account: MoveAddressType;
+        owners_removed: MoveAddressType[];
+    }
+    namespace RemoveOwners {
+        const TYPE_QNAME = "0x1::multisig_account::RemoveOwners";
+        function type(): TypeDescriptor<RemoveOwners>;
+    }
+    interface RemoveOwnersInstance extends TypedEventInstance<RemoveOwners> {
+        data_decoded: RemoveOwners;
+        type_arguments: [];
+    }
     interface RemoveOwnersEvent {
         owners_removed: MoveAddressType[];
     }
@@ -3458,6 +5107,22 @@ export declare namespace multisig_account {
         data_decoded: RemoveOwnersEvent;
         type_arguments: [];
     }
+    interface TransactionExecutionFailed {
+        multisig_account: MoveAddressType;
+        executor: MoveAddressType;
+        sequence_number: bigint;
+        transaction_payload: string;
+        num_approvals: bigint;
+        execution_error: multisig_account.ExecutionError;
+    }
+    namespace TransactionExecutionFailed {
+        const TYPE_QNAME = "0x1::multisig_account::TransactionExecutionFailed";
+        function type(): TypeDescriptor<TransactionExecutionFailed>;
+    }
+    interface TransactionExecutionFailedInstance extends TypedEventInstance<TransactionExecutionFailed> {
+        data_decoded: TransactionExecutionFailed;
+        type_arguments: [];
+    }
     interface TransactionExecutionFailedEvent {
         executor: MoveAddressType;
         sequence_number: bigint;
@@ -3473,6 +5138,21 @@ export declare namespace multisig_account {
         data_decoded: TransactionExecutionFailedEvent;
         type_arguments: [];
     }
+    interface TransactionExecutionSucceeded {
+        multisig_account: MoveAddressType;
+        executor: MoveAddressType;
+        sequence_number: bigint;
+        transaction_payload: string;
+        num_approvals: bigint;
+    }
+    namespace TransactionExecutionSucceeded {
+        const TYPE_QNAME = "0x1::multisig_account::TransactionExecutionSucceeded";
+        function type(): TypeDescriptor<TransactionExecutionSucceeded>;
+    }
+    interface TransactionExecutionSucceededInstance extends TypedEventInstance<TransactionExecutionSucceeded> {
+        data_decoded: TransactionExecutionSucceeded;
+        type_arguments: [];
+    }
     interface TransactionExecutionSucceededEvent {
         executor: MoveAddressType;
         sequence_number: bigint;
@@ -3487,6 +5167,19 @@ export declare namespace multisig_account {
         data_decoded: TransactionExecutionSucceededEvent;
         type_arguments: [];
     }
+    interface UpdateSignaturesRequired {
+        multisig_account: MoveAddressType;
+        old_num_signatures_required: bigint;
+        new_num_signatures_required: bigint;
+    }
+    namespace UpdateSignaturesRequired {
+        const TYPE_QNAME = "0x1::multisig_account::UpdateSignaturesRequired";
+        function type(): TypeDescriptor<UpdateSignaturesRequired>;
+    }
+    interface UpdateSignaturesRequiredInstance extends TypedEventInstance<UpdateSignaturesRequired> {
+        data_decoded: UpdateSignaturesRequired;
+        type_arguments: [];
+    }
     interface UpdateSignaturesRequiredEvent {
         old_num_signatures_required: bigint;
         new_num_signatures_required: bigint;
@@ -3499,6 +5192,20 @@ export declare namespace multisig_account {
         data_decoded: UpdateSignaturesRequiredEvent;
         type_arguments: [];
     }
+    interface Vote {
+        multisig_account: MoveAddressType;
+        owner: MoveAddressType;
+        sequence_number: bigint;
+        approved: Boolean;
+    }
+    namespace Vote {
+        const TYPE_QNAME = "0x1::multisig_account::Vote";
+        function type(): TypeDescriptor<Vote>;
+    }
+    interface VoteInstance extends TypedEventInstance<Vote> {
+        data_decoded: Vote;
+        type_arguments: [];
+    }
     interface VoteEvent {
         owner: MoveAddressType;
         sequence_number: bigint;
@@ -3606,6 +5313,10 @@ export declare namespace multisig_account {
         arguments_decoded: [MoveAddressType];
         type_arguments: [];
     }
+    interface ExecuteRejectedTransactionsPayload extends TypedFunctionPayload<[MoveAddressType, bigint]> {
+        arguments_decoded: [MoveAddressType, bigint];
+        type_arguments: [];
+    }
     interface RejectTransactionPayload extends TypedFunctionPayload<[MoveAddressType, bigint]> {
         arguments_decoded: [MoveAddressType, bigint];
         type_arguments: [];
@@ -3642,6 +5353,14 @@ export declare namespace multisig_account {
         arguments_decoded: [bigint];
         type_arguments: [];
     }
+    interface VoteTransactionPayload extends TypedFunctionPayload<[MoveAddressType, bigint, Boolean]> {
+        arguments_decoded: [MoveAddressType, bigint, Boolean];
+        type_arguments: [];
+    }
+    interface VoteTransactionsPayload extends TypedFunctionPayload<[MoveAddressType, bigint, bigint, Boolean]> {
+        arguments_decoded: [MoveAddressType, bigint, bigint, Boolean];
+        type_arguments: [];
+    }
     interface VoteTransanctionPayload extends TypedFunctionPayload<[MoveAddressType, bigint, Boolean]> {
         arguments_decoded: [MoveAddressType, bigint, Boolean];
         type_arguments: [];
@@ -3697,24 +5416,49 @@ export declare class staking_contract extends AptosBaseProcessor {
     onEntryDistribute(func: (call: staking_contract.DistributePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEntryRequestCommission(func: (call: staking_contract.RequestCommissionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEntryResetLockup(func: (call: staking_contract.ResetLockupPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEntrySetBeneficiaryForOperator(func: (call: staking_contract.SetBeneficiaryForOperatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEntrySwitchOperator(func: (call: staking_contract.SwitchOperatorPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEntrySwitchOperatorWithSameCommission(func: (call: staking_contract.SwitchOperatorWithSameCommissionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEntryUnlockRewards(func: (call: staking_contract.UnlockRewardsPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEntryUnlockStake(func: (call: staking_contract.UnlockStakePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEntryUpdateCommision(func: (call: staking_contract.UpdateCommisionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEntryUpdateVoter(func: (call: staking_contract.UpdateVoterPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventAddDistribution(func: (event: staking_contract.AddDistributionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventAddDistributionEvent(func: (event: staking_contract.AddDistributionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventAddStake(func: (event: staking_contract.AddStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventAddStakeEvent(func: (event: staking_contract.AddStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventCreateStakingContract(func: (event: staking_contract.CreateStakingContractInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventCreateStakingContractEvent(func: (event: staking_contract.CreateStakingContractEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventDistribute(func: (event: staking_contract.DistributeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventDistributeEvent(func: (event: staking_contract.DistributeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventRequestCommission(func: (event: staking_contract.RequestCommissionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventRequestCommissionEvent(func: (event: staking_contract.RequestCommissionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventResetLockup(func: (event: staking_contract.ResetLockupInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventResetLockupEvent(func: (event: staking_contract.ResetLockupEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventSetBeneficiaryForOperator(func: (event: staking_contract.SetBeneficiaryForOperatorInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventSwitchOperator(func: (event: staking_contract.SwitchOperatorInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventSwitchOperatorEvent(func: (event: staking_contract.SwitchOperatorEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventUnlockStake(func: (event: staking_contract.UnlockStakeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventUnlockStakeEvent(func: (event: staking_contract.UnlockStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventUpdateCommission(func: (event: staking_contract.UpdateCommissionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventUpdateCommissionEvent(func: (event: staking_contract.UpdateCommissionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventUpdateVoter(func: (event: staking_contract.UpdateVoterInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventUpdateVoterEvent(func: (event: staking_contract.UpdateVoterEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
 }
 export declare namespace staking_contract {
+    interface AddDistribution {
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
+        amount: bigint;
+    }
+    namespace AddDistribution {
+        const TYPE_QNAME = "0x1::staking_contract::AddDistribution";
+        function type(): TypeDescriptor<AddDistribution>;
+    }
+    interface AddDistributionInstance extends TypedEventInstance<AddDistribution> {
+        data_decoded: AddDistribution;
+        type_arguments: [];
+    }
     interface AddDistributionEvent {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
@@ -3728,6 +5472,19 @@ export declare namespace staking_contract {
         data_decoded: AddDistributionEvent;
         type_arguments: [];
     }
+    interface AddStake {
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
+        amount: bigint;
+    }
+    namespace AddStake {
+        const TYPE_QNAME = "0x1::staking_contract::AddStake";
+        function type(): TypeDescriptor<AddStake>;
+    }
+    interface AddStakeInstance extends TypedEventInstance<AddStake> {
+        data_decoded: AddStake;
+        type_arguments: [];
+    }
     interface AddStakeEvent {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
@@ -3741,6 +5498,28 @@ export declare namespace staking_contract {
         data_decoded: AddStakeEvent;
         type_arguments: [];
     }
+    interface BeneficiaryForOperator {
+        beneficiary_for_operator: MoveAddressType;
+    }
+    namespace BeneficiaryForOperator {
+        const TYPE_QNAME = "0x1::staking_contract::BeneficiaryForOperator";
+        function type(): TypeDescriptor<BeneficiaryForOperator>;
+    }
+    interface CreateStakingContract {
+        operator: MoveAddressType;
+        voter: MoveAddressType;
+        pool_address: MoveAddressType;
+        principal: bigint;
+        commission_percentage: bigint;
+    }
+    namespace CreateStakingContract {
+        const TYPE_QNAME = "0x1::staking_contract::CreateStakingContract";
+        function type(): TypeDescriptor<CreateStakingContract>;
+    }
+    interface CreateStakingContractInstance extends TypedEventInstance<CreateStakingContract> {
+        data_decoded: CreateStakingContract;
+        type_arguments: [];
+    }
     interface CreateStakingContractEvent {
         operator: MoveAddressType;
         voter: MoveAddressType;
@@ -3756,6 +5535,20 @@ export declare namespace staking_contract {
         data_decoded: CreateStakingContractEvent;
         type_arguments: [];
     }
+    interface Distribute {
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
+        recipient: MoveAddressType;
+        amount: bigint;
+    }
+    namespace Distribute {
+        const TYPE_QNAME = "0x1::staking_contract::Distribute";
+        function type(): TypeDescriptor<Distribute>;
+    }
+    interface DistributeInstance extends TypedEventInstance<Distribute> {
+        data_decoded: Distribute;
+        type_arguments: [];
+    }
     interface DistributeEvent {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
@@ -3770,6 +5563,20 @@ export declare namespace staking_contract {
         data_decoded: DistributeEvent;
         type_arguments: [];
     }
+    interface RequestCommission {
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
+        accumulated_rewards: bigint;
+        commission_amount: bigint;
+    }
+    namespace RequestCommission {
+        const TYPE_QNAME = "0x1::staking_contract::RequestCommission";
+        function type(): TypeDescriptor<RequestCommission>;
+    }
+    interface RequestCommissionInstance extends TypedEventInstance<RequestCommission> {
+        data_decoded: RequestCommission;
+        type_arguments: [];
+    }
     interface RequestCommissionEvent {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
@@ -3784,6 +5591,18 @@ export declare namespace staking_contract {
         data_decoded: RequestCommissionEvent;
         type_arguments: [];
     }
+    interface ResetLockup {
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
+    }
+    namespace ResetLockup {
+        const TYPE_QNAME = "0x1::staking_contract::ResetLockup";
+        function type(): TypeDescriptor<ResetLockup>;
+    }
+    interface ResetLockupInstance extends TypedEventInstance<ResetLockup> {
+        data_decoded: ResetLockup;
+        type_arguments: [];
+    }
     interface ResetLockupEvent {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
@@ -3796,6 +5615,19 @@ export declare namespace staking_contract {
         data_decoded: ResetLockupEvent;
         type_arguments: [];
     }
+    interface SetBeneficiaryForOperator {
+        operator: MoveAddressType;
+        old_beneficiary: MoveAddressType;
+        new_beneficiary: MoveAddressType;
+    }
+    namespace SetBeneficiaryForOperator {
+        const TYPE_QNAME = "0x1::staking_contract::SetBeneficiaryForOperator";
+        function type(): TypeDescriptor<SetBeneficiaryForOperator>;
+    }
+    interface SetBeneficiaryForOperatorInstance extends TypedEventInstance<SetBeneficiaryForOperator> {
+        data_decoded: SetBeneficiaryForOperator;
+        type_arguments: [];
+    }
     interface StakingContract {
         principal: bigint;
         pool_address: MoveAddressType;
@@ -3838,6 +5670,19 @@ export declare namespace staking_contract {
         const TYPE_QNAME = "0x1::staking_contract::Store";
         function type(): TypeDescriptor<Store>;
     }
+    interface SwitchOperator {
+        old_operator: MoveAddressType;
+        new_operator: MoveAddressType;
+        pool_address: MoveAddressType;
+    }
+    namespace SwitchOperator {
+        const TYPE_QNAME = "0x1::staking_contract::SwitchOperator";
+        function type(): TypeDescriptor<SwitchOperator>;
+    }
+    interface SwitchOperatorInstance extends TypedEventInstance<SwitchOperator> {
+        data_decoded: SwitchOperator;
+        type_arguments: [];
+    }
     interface SwitchOperatorEvent {
         old_operator: MoveAddressType;
         new_operator: MoveAddressType;
@@ -3851,6 +5696,20 @@ export declare namespace staking_contract {
         data_decoded: SwitchOperatorEvent;
         type_arguments: [];
     }
+    interface UnlockStake {
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
+        amount: bigint;
+        commission_paid: bigint;
+    }
+    namespace UnlockStake {
+        const TYPE_QNAME = "0x1::staking_contract::UnlockStake";
+        function type(): TypeDescriptor<UnlockStake>;
+    }
+    interface UnlockStakeInstance extends TypedEventInstance<UnlockStake> {
+        data_decoded: UnlockStake;
+        type_arguments: [];
+    }
     interface UnlockStakeEvent {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
@@ -3865,6 +5724,20 @@ export declare namespace staking_contract {
         data_decoded: UnlockStakeEvent;
         type_arguments: [];
     }
+    interface UpdateCommission {
+        staker: MoveAddressType;
+        operator: MoveAddressType;
+        old_commission_percentage: bigint;
+        new_commission_percentage: bigint;
+    }
+    namespace UpdateCommission {
+        const TYPE_QNAME = "0x1::staking_contract::UpdateCommission";
+        function type(): TypeDescriptor<UpdateCommission>;
+    }
+    interface UpdateCommissionInstance extends TypedEventInstance<UpdateCommission> {
+        data_decoded: UpdateCommission;
+        type_arguments: [];
+    }
     interface UpdateCommissionEvent {
         staker: MoveAddressType;
         operator: MoveAddressType;
@@ -3879,6 +5752,20 @@ export declare namespace staking_contract {
         data_decoded: UpdateCommissionEvent;
         type_arguments: [];
     }
+    interface UpdateVoter {
+        operator: MoveAddressType;
+        pool_address: MoveAddressType;
+        old_voter: MoveAddressType;
+        new_voter: MoveAddressType;
+    }
+    namespace UpdateVoter {
+        const TYPE_QNAME = "0x1::staking_contract::UpdateVoter";
+        function type(): TypeDescriptor<UpdateVoter>;
+    }
+    interface UpdateVoterInstance extends TypedEventInstance<UpdateVoter> {
+        data_decoded: UpdateVoter;
+        type_arguments: [];
+    }
     interface UpdateVoterEvent {
         operator: MoveAddressType;
         pool_address: MoveAddressType;
@@ -3925,6 +5812,10 @@ export declare namespace staking_contract {
         arguments_decoded: [MoveAddressType];
         type_arguments: [];
     }
+    interface SetBeneficiaryForOperatorPayload extends TypedFunctionPayload<[MoveAddressType]> {
+        arguments_decoded: [MoveAddressType];
+        type_arguments: [];
+    }
     interface SwitchOperatorPayload extends TypedFunctionPayload<[MoveAddressType, MoveAddressType, bigint]> {
         arguments_decoded: [MoveAddressType, MoveAddressType, bigint];
         type_arguments: [];
@@ -3951,6 +5842,64 @@ export declare namespace staking_contract {
     }
 }
 export declare namespace system_addresses { }
+export declare class randomness_config extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): randomness_config;
+    onEventConfigOff(func: (event: randomness_config.ConfigOffInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): randomness_config;
+    onEventConfigV1(func: (event: randomness_config.ConfigV1Instance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): randomness_config;
+    onEventConfigV2(func: (event: randomness_config.ConfigV2Instance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): randomness_config;
+    onEventRandomnessConfig(func: (event: randomness_config.RandomnessConfigInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): randomness_config;
+}
+export declare namespace randomness_config {
+    interface ConfigOff {
+        dummy_field: Boolean;
+    }
+    namespace ConfigOff {
+        const TYPE_QNAME = "0x1::randomness_config::ConfigOff";
+        function type(): TypeDescriptor<ConfigOff>;
+    }
+    interface ConfigOffInstance extends TypedEventInstance<ConfigOff> {
+        data_decoded: ConfigOff;
+        type_arguments: [];
+    }
+    interface ConfigV1 {
+        secrecy_threshold: fixed_point64.FixedPoint64;
+        reconstruction_threshold: fixed_point64.FixedPoint64;
+    }
+    namespace ConfigV1 {
+        const TYPE_QNAME = "0x1::randomness_config::ConfigV1";
+        function type(): TypeDescriptor<ConfigV1>;
+    }
+    interface ConfigV1Instance extends TypedEventInstance<ConfigV1> {
+        data_decoded: ConfigV1;
+        type_arguments: [];
+    }
+    interface ConfigV2 {
+        secrecy_threshold: fixed_point64.FixedPoint64;
+        reconstruction_threshold: fixed_point64.FixedPoint64;
+        fast_path_secrecy_threshold: fixed_point64.FixedPoint64;
+    }
+    namespace ConfigV2 {
+        const TYPE_QNAME = "0x1::randomness_config::ConfigV2";
+        function type(): TypeDescriptor<ConfigV2>;
+    }
+    interface ConfigV2Instance extends TypedEventInstance<ConfigV2> {
+        data_decoded: ConfigV2;
+        type_arguments: [];
+    }
+    interface RandomnessConfig {
+        variant: copyable_any.Any;
+    }
+    namespace RandomnessConfig {
+        const TYPE_QNAME = "0x1::randomness_config::RandomnessConfig";
+        function type(): TypeDescriptor<RandomnessConfig>;
+    }
+    interface RandomnessConfigInstance extends TypedEventInstance<RandomnessConfig> {
+        data_decoded: RandomnessConfig;
+        type_arguments: [];
+    }
+}
 export declare namespace table_with_length {
     interface TableWithLength<T0, T1> {
         inner: table.Table<T0, T1>;
@@ -4025,6 +5974,81 @@ export declare namespace transaction_context {
         data_decoded: AUID;
         type_arguments: [];
     }
+    interface EntryFunctionPayload {
+        account_address: MoveAddressType;
+        module_name: string;
+        function_name: string;
+        ty_args_names: string[];
+        args: string[];
+    }
+    namespace EntryFunctionPayload {
+        const TYPE_QNAME = "0x1::transaction_context::EntryFunctionPayload";
+        function type(): TypeDescriptor<EntryFunctionPayload>;
+    }
+    interface MultisigPayload {
+        multisig_address: MoveAddressType;
+        entry_function_payload: option.Option<transaction_context.EntryFunctionPayload>;
+    }
+    namespace MultisigPayload {
+        const TYPE_QNAME = "0x1::transaction_context::MultisigPayload";
+        function type(): TypeDescriptor<MultisigPayload>;
+    }
+}
+export declare class jwk_consensus_config extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): jwk_consensus_config;
+    onEventConfigOff(func: (event: jwk_consensus_config.ConfigOffInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): jwk_consensus_config;
+    onEventConfigV1(func: (event: jwk_consensus_config.ConfigV1Instance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): jwk_consensus_config;
+    onEventJWKConsensusConfig(func: (event: jwk_consensus_config.JWKConsensusConfigInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): jwk_consensus_config;
+    onEventOIDCProvider(func: (event: jwk_consensus_config.OIDCProviderInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): jwk_consensus_config;
+}
+export declare namespace jwk_consensus_config {
+    interface ConfigOff {
+        dummy_field: Boolean;
+    }
+    namespace ConfigOff {
+        const TYPE_QNAME = "0x1::jwk_consensus_config::ConfigOff";
+        function type(): TypeDescriptor<ConfigOff>;
+    }
+    interface ConfigOffInstance extends TypedEventInstance<ConfigOff> {
+        data_decoded: ConfigOff;
+        type_arguments: [];
+    }
+    interface ConfigV1 {
+        oidc_providers: jwk_consensus_config.OIDCProvider[];
+    }
+    namespace ConfigV1 {
+        const TYPE_QNAME = "0x1::jwk_consensus_config::ConfigV1";
+        function type(): TypeDescriptor<ConfigV1>;
+    }
+    interface ConfigV1Instance extends TypedEventInstance<ConfigV1> {
+        data_decoded: ConfigV1;
+        type_arguments: [];
+    }
+    interface JWKConsensusConfig {
+        variant: copyable_any.Any;
+    }
+    namespace JWKConsensusConfig {
+        const TYPE_QNAME = "0x1::jwk_consensus_config::JWKConsensusConfig";
+        function type(): TypeDescriptor<JWKConsensusConfig>;
+    }
+    interface JWKConsensusConfigInstance extends TypedEventInstance<JWKConsensusConfig> {
+        data_decoded: JWKConsensusConfig;
+        type_arguments: [];
+    }
+    interface OIDCProvider {
+        name: string;
+        config_url: string;
+    }
+    namespace OIDCProvider {
+        const TYPE_QNAME = "0x1::jwk_consensus_config::OIDCProvider";
+        function type(): TypeDescriptor<OIDCProvider>;
+    }
+    interface OIDCProviderInstance extends TypedEventInstance<OIDCProvider> {
+        data_decoded: OIDCProvider;
+        type_arguments: [];
+    }
 }
 export declare class ristretto255_elgamal extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -4066,6 +6090,44 @@ export declare namespace ristretto255_elgamal {
         type_arguments: [];
     }
 }
+export declare class reconfiguration_state extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): reconfiguration_state;
+    onEventStateActive(func: (event: reconfiguration_state.StateActiveInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): reconfiguration_state;
+    onEventStateInactive(func: (event: reconfiguration_state.StateInactiveInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): reconfiguration_state;
+}
+export declare namespace reconfiguration_state {
+    interface State {
+        variant: copyable_any.Any;
+    }
+    namespace State {
+        const TYPE_QNAME = "0x1::reconfiguration_state::State";
+        function type(): TypeDescriptor<State>;
+    }
+    interface StateActive {
+        start_time_secs: bigint;
+    }
+    namespace StateActive {
+        const TYPE_QNAME = "0x1::reconfiguration_state::StateActive";
+        function type(): TypeDescriptor<StateActive>;
+    }
+    interface StateActiveInstance extends TypedEventInstance<StateActive> {
+        data_decoded: StateActive;
+        type_arguments: [];
+    }
+    interface StateInactive {
+        dummy_field: Boolean;
+    }
+    namespace StateInactive {
+        const TYPE_QNAME = "0x1::reconfiguration_state::StateInactive";
+        function type(): TypeDescriptor<StateInactive>;
+    }
+    interface StateInactiveInstance extends TypedEventInstance<StateInactive> {
+        data_decoded: StateInactive;
+        type_arguments: [];
+    }
+}
 export declare namespace ristretto255_pedersen {
     interface Commitment {
         point: ristretto255.RistrettoPoint;
@@ -4075,11 +6137,81 @@ export declare namespace ristretto255_pedersen {
         function type(): TypeDescriptor<Commitment>;
     }
 }
+export declare class object_code_deployment extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): object_code_deployment;
+    onEntryFreezeCodeObject(func: (call: object_code_deployment.FreezeCodeObjectPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): object_code_deployment;
+    onEntryPublish(func: (call: object_code_deployment.PublishPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): object_code_deployment;
+    onEntryUpgrade(func: (call: object_code_deployment.UpgradePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): object_code_deployment;
+    onEventFreeze(func: (event: object_code_deployment.FreezeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): object_code_deployment;
+    onEventPublish(func: (event: object_code_deployment.PublishInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): object_code_deployment;
+    onEventUpgrade(func: (event: object_code_deployment.UpgradeInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): object_code_deployment;
+}
+export declare namespace object_code_deployment {
+    interface Freeze {
+        object_address: MoveAddressType;
+    }
+    namespace Freeze {
+        const TYPE_QNAME = "0x1::object_code_deployment::Freeze";
+        function type(): TypeDescriptor<Freeze>;
+    }
+    interface FreezeInstance extends TypedEventInstance<Freeze> {
+        data_decoded: Freeze;
+        type_arguments: [];
+    }
+    interface ManagingRefs {
+        extend_ref: object_.ExtendRef;
+    }
+    namespace ManagingRefs {
+        const TYPE_QNAME = "0x1::object_code_deployment::ManagingRefs";
+        function type(): TypeDescriptor<ManagingRefs>;
+    }
+    interface Publish {
+        object_address: MoveAddressType;
+    }
+    namespace Publish {
+        const TYPE_QNAME = "0x1::object_code_deployment::Publish";
+        function type(): TypeDescriptor<Publish>;
+    }
+    interface PublishInstance extends TypedEventInstance<Publish> {
+        data_decoded: Publish;
+        type_arguments: [];
+    }
+    interface Upgrade {
+        object_address: MoveAddressType;
+    }
+    namespace Upgrade {
+        const TYPE_QNAME = "0x1::object_code_deployment::Upgrade";
+        function type(): TypeDescriptor<Upgrade>;
+    }
+    interface UpgradeInstance extends TypedEventInstance<Upgrade> {
+        data_decoded: Upgrade;
+        type_arguments: [];
+    }
+    interface FreezeCodeObjectPayload extends TypedFunctionPayload<[object_.Object<code.PackageRegistry>]> {
+        arguments_decoded: [object_.Object<code.PackageRegistry>];
+        type_arguments: [];
+    }
+    interface PublishPayload extends TypedFunctionPayload<[string, string[]]> {
+        arguments_decoded: [string, string[]];
+        type_arguments: [];
+    }
+    interface UpgradePayload extends TypedFunctionPayload<[
+        string,
+        string[],
+        object_.Object<code.PackageRegistry>
+    ]> {
+        arguments_decoded: [string, string[], object_.Object<code.PackageRegistry>];
+        type_arguments: [];
+    }
+}
 export declare class primary_fungible_store extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): primary_fungible_store;
     onEntryTransfer(func: (call: primary_fungible_store.TransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): primary_fungible_store;
+    onEntryTransferAssertMinimumDeposit(func: (call: primary_fungible_store.TransferAssertMinimumDepositPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): primary_fungible_store;
 }
 export declare namespace primary_fungible_store {
     interface DeriveRefPod {
@@ -4097,6 +6229,15 @@ export declare namespace primary_fungible_store {
         arguments_decoded: [object_.Object<T0>, MoveAddressType, bigint];
         type_arguments: [string];
     }
+    interface TransferAssertMinimumDepositPayload<T0 = any> extends TypedFunctionPayload<[
+        object_.Object<T0>,
+        MoveAddressType,
+        bigint,
+        bigint
+    ]> {
+        arguments_decoded: [object_.Object<T0>, MoveAddressType, bigint, bigint];
+        type_arguments: [string];
+    }
 }
 export declare namespace transaction_validation {
     interface TransactionValidation {
@@ -4112,6 +6253,78 @@ export declare namespace transaction_validation {
         function type(): TypeDescriptor<TransactionValidation>;
     }
 }
+export declare class randomness_api_v0_config extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): randomness_api_v0_config;
+    onEventAllowCustomMaxGasFlag(func: (event: randomness_api_v0_config.AllowCustomMaxGasFlagInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): randomness_api_v0_config;
+    onEventRequiredGasDeposit(func: (event: randomness_api_v0_config.RequiredGasDepositInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): randomness_api_v0_config;
+}
+export declare namespace randomness_api_v0_config {
+    interface AllowCustomMaxGasFlag {
+        value: Boolean;
+    }
+    namespace AllowCustomMaxGasFlag {
+        const TYPE_QNAME = "0x1::randomness_api_v0_config::AllowCustomMaxGasFlag";
+        function type(): TypeDescriptor<AllowCustomMaxGasFlag>;
+    }
+    interface AllowCustomMaxGasFlagInstance extends TypedEventInstance<AllowCustomMaxGasFlag> {
+        data_decoded: AllowCustomMaxGasFlag;
+        type_arguments: [];
+    }
+    interface RequiredGasDeposit {
+        gas_amount: option.Option<bigint>;
+    }
+    namespace RequiredGasDeposit {
+        const TYPE_QNAME = "0x1::randomness_api_v0_config::RequiredGasDeposit";
+        function type(): TypeDescriptor<RequiredGasDeposit>;
+    }
+    interface RequiredGasDepositInstance extends TypedEventInstance<RequiredGasDeposit> {
+        data_decoded: RequiredGasDeposit;
+        type_arguments: [];
+    }
+}
+export declare class randomness_config_seqnum extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): randomness_config_seqnum;
+    onEventRandomnessConfigSeqNum(func: (event: randomness_config_seqnum.RandomnessConfigSeqNumInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): randomness_config_seqnum;
+}
+export declare namespace randomness_config_seqnum {
+    interface RandomnessConfigSeqNum {
+        seq_num: bigint;
+    }
+    namespace RandomnessConfigSeqNum {
+        const TYPE_QNAME = "0x1::randomness_config_seqnum::RandomnessConfigSeqNum";
+        function type(): TypeDescriptor<RandomnessConfigSeqNum>;
+    }
+    interface RandomnessConfigSeqNumInstance extends TypedEventInstance<RandomnessConfigSeqNum> {
+        data_decoded: RandomnessConfigSeqNum;
+        type_arguments: [];
+    }
+}
+export declare namespace reconfiguration_with_dkg { }
+export declare class validator_consensus_info extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): validator_consensus_info;
+    onEventValidatorConsensusInfo(func: (event: validator_consensus_info.ValidatorConsensusInfoInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): validator_consensus_info;
+}
+export declare namespace validator_consensus_info {
+    interface ValidatorConsensusInfo {
+        addr: MoveAddressType;
+        pk_bytes: string;
+        voting_power: bigint;
+    }
+    namespace ValidatorConsensusInfo {
+        const TYPE_QNAME = "0x1::validator_consensus_info::ValidatorConsensusInfo";
+        function type(): TypeDescriptor<ValidatorConsensusInfo>;
+    }
+    interface ValidatorConsensusInfoInstance extends TypedEventInstance<ValidatorConsensusInfo> {
+        data_decoded: ValidatorConsensusInfo;
+        type_arguments: [];
+    }
+}
 export declare class ristretto255_bulletproofs extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
     static DEFAULT_OPTIONS: AptosBindOptions;
@@ -4131,5 +6344,38 @@ export declare namespace ristretto255_bulletproofs {
         type_arguments: [];
     }
 }
+export declare class dispatchable_fungible_asset extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): dispatchable_fungible_asset;
+    onEntryTransfer(func: (call: dispatchable_fungible_asset.TransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): dispatchable_fungible_asset;
+    onEntryTransferAssertMinimumDeposit(func: (call: dispatchable_fungible_asset.TransferAssertMinimumDepositPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): dispatchable_fungible_asset;
+}
+export declare namespace dispatchable_fungible_asset {
+    interface TransferRefStore {
+        transfer_ref: fungible_asset.TransferRef;
+    }
+    namespace TransferRefStore {
+        const TYPE_QNAME = "0x1::dispatchable_fungible_asset::TransferRefStore";
+        function type(): TypeDescriptor<TransferRefStore>;
+    }
+    interface TransferPayload<T0 = any> extends TypedFunctionPayload<[
+        object_.Object<T0>,
+        object_.Object<T0>,
+        bigint
+    ]> {
+        arguments_decoded: [object_.Object<T0>, object_.Object<T0>, bigint];
+        type_arguments: [string];
+    }
+    interface TransferAssertMinimumDepositPayload<T0 = any> extends TypedFunctionPayload<[
+        object_.Object<T0>,
+        object_.Object<T0>,
+        bigint,
+        bigint
+    ]> {
+        arguments_decoded: [object_.Object<T0>, object_.Object<T0>, bigint, bigint];
+        type_arguments: [string];
+    }
+}
 export declare function loadAllTypes(coder: MoveCoder): void;
 //# sourceMappingURL=0x1.d.ts.map