@sentio/sdk 2.26.1-rc.1 → 2.26.1-rc.3

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

@@ -3,6 +3,12 @@ import { MoveCoder, TypedEventInstance } from "@typemove/aptos";
 import { Address } from "@typemove/aptos";
 import { CallFilter, MoveFetchConfig } from "@sentio/sdk/move";
 import { AptosBindOptions, AptosBaseProcessor, TypedFunctionPayload, AptosContext } from "@sentio/sdk/aptos";
+export declare class acl extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): acl;
+    onEventACL(func: (event: acl.ACLInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): acl;
+}
 export declare namespace acl {
     interface ACL {
         list: Address[];
@@ -11,6 +17,16 @@ export declare namespace acl {
         const TYPE_QNAME = "0x1::acl::ACL";
         function type(): TypeDescriptor<ACL>;
     }
+    interface ACLInstance extends TypedEventInstance<ACL> {
+        data_decoded: ACL;
+        type_arguments: [];
+    }
+}
+export declare class any_ extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): any_;
+    onEventAny(func: (event: any_.AnyInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): any_;
 }
 export declare namespace any_ {
     interface Any {
@@ -21,6 +37,10 @@ export declare namespace any_ {
         const TYPE_QNAME = "0x1::any::Any";
         function type(): TypeDescriptor<Any>;
     }
+    interface AnyInstance extends TypedEventInstance<Any> {
+        data_decoded: Any;
+        type_arguments: [];
+    }
 }
 export declare namespace bcs { }
 export declare class code extends AptosBaseProcessor {
@@ -28,6 +48,11 @@ export declare class code extends AptosBaseProcessor {
     static DEFAULT_OPTIONS: AptosBindOptions;
     static bind(options?: Partial<AptosBindOptions>): code;
     onEntryPublishPackageTxn(func: (call: code.PublishPackageTxnPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): code;
+    onEventModuleMetadata(func: (event: code.ModuleMetadataInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): code;
+    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;
+    onEventUpgradePolicy(func: (event: code.UpgradePolicyInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): code;
 }
 export declare namespace code {
     interface AllowedDep {
@@ -48,6 +73,10 @@ export declare namespace code {
         const TYPE_QNAME = "0x1::code::ModuleMetadata";
         function type(): TypeDescriptor<ModuleMetadata>;
     }
+    interface ModuleMetadataInstance extends TypedEventInstance<ModuleMetadata> {
+        data_decoded: ModuleMetadata;
+        type_arguments: [];
+    }
     interface PackageDep {
         account: Address;
         package_name: string;
@@ -56,6 +85,10 @@ export declare namespace code {
         const TYPE_QNAME = "0x1::code::PackageDep";
         function type(): TypeDescriptor<PackageDep>;
     }
+    interface PackageDepInstance extends TypedEventInstance<PackageDep> {
+        data_decoded: PackageDep;
+        type_arguments: [];
+    }
     interface PackageMetadata {
         name: string;
         upgrade_policy: code.UpgradePolicy;
@@ -70,6 +103,10 @@ export declare namespace code {
         const TYPE_QNAME = "0x1::code::PackageMetadata";
         function type(): TypeDescriptor<PackageMetadata>;
     }
+    interface PackageMetadataInstance extends TypedEventInstance<PackageMetadata> {
+        data_decoded: PackageMetadata;
+        type_arguments: [];
+    }
     interface PackageRegistry {
         packages: code.PackageMetadata[];
     }
@@ -77,6 +114,10 @@ export declare namespace code {
         const TYPE_QNAME = "0x1::code::PackageRegistry";
         function type(): TypeDescriptor<PackageRegistry>;
     }
+    interface PackageRegistryInstance extends TypedEventInstance<PackageRegistry> {
+        data_decoded: PackageRegistry;
+        type_arguments: [];
+    }
     interface UpgradePolicy {
         policy: number;
     }
@@ -84,6 +125,10 @@ export declare namespace code {
         const TYPE_QNAME = "0x1::code::UpgradePolicy";
         function type(): TypeDescriptor<UpgradePolicy>;
     }
+    interface UpgradePolicyInstance extends TypedEventInstance<UpgradePolicy> {
+        data_decoded: UpgradePolicy;
+        type_arguments: [];
+    }
     interface PublishPackageTxnPayload extends TypedFunctionPayload<[string, string[]]> {
         arguments_decoded: [string, string[]];
         type_arguments: [];
@@ -202,6 +247,13 @@ export declare namespace coin {
         type_arguments: [string];
     }
 }
+export declare class guid extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): guid;
+    onEventGUID(func: (event: guid.GUIDInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): guid;
+    onEventID(func: (event: guid.IDInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): guid;
+}
 export declare namespace guid {
     interface GUID {
         id: guid.ID;
@@ -210,6 +262,10 @@ export declare namespace guid {
         const TYPE_QNAME = "0x1::guid::GUID";
         function type(): TypeDescriptor<GUID>;
     }
+    interface GUIDInstance extends TypedEventInstance<GUID> {
+        data_decoded: GUID;
+        type_arguments: [];
+    }
     interface ID {
         creation_num: bigint;
         addr: Address;
@@ -218,6 +274,10 @@ export declare namespace guid {
         const TYPE_QNAME = "0x1::guid::ID";
         function type(): TypeDescriptor<ID>;
     }
+    interface IDInstance extends TypedEventInstance<ID> {
+        data_decoded: ID;
+        type_arguments: [];
+    }
 }
 export declare namespace hash { }
 export declare namespace util { }
@@ -299,18 +359,21 @@ 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;
-    onEventRegisterValidatorCandidateEvent(func: (event: stake.RegisterValidatorCandidateEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
-    onEventSetOperatorEvent(func: (event: stake.SetOperatorEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventAddStakeEvent(func: (event: stake.AddStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
-    onEventReactivateStakeEvent(func: (event: stake.ReactivateStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
-    onEventRotateConsensusKeyEvent(func: (event: stake.RotateConsensusKeyEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
-    onEventUpdateNetworkAndFullnodeAddressesEvent(func: (event: stake.UpdateNetworkAndFullnodeAddressesEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
+    onEventDistributeRewardsEvent(func: (event: stake.DistributeRewardsEventInstance, 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;
     onEventJoinValidatorSetEvent(func: (event: stake.JoinValidatorSetEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
-    onEventDistributeRewardsEvent(func: (event: stake.DistributeRewardsEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
+    onEventLeaveValidatorSetEvent(func: (event: stake.LeaveValidatorSetEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
+    onEventReactivateStakeEvent(func: (event: stake.ReactivateStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
+    onEventRegisterValidatorCandidateEvent(func: (event: stake.RegisterValidatorCandidateEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
+    onEventRotateConsensusKeyEvent(func: (event: stake.RotateConsensusKeyEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
+    onEventSetOperatorEvent(func: (event: stake.SetOperatorEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
     onEventUnlockStakeEvent(func: (event: stake.UnlockStakeEventInstance, 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;
     onEventWithdrawStakeEvent(func: (event: stake.WithdrawStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
-    onEventLeaveValidatorSetEvent(func: (event: stake.LeaveValidatorSetEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
 }
 export declare namespace stake {
     interface AddStakeEvent {
@@ -372,6 +435,10 @@ export declare namespace stake {
         const TYPE_QNAME = "0x1::stake::IndividualValidatorPerformance";
         function type(): TypeDescriptor<IndividualValidatorPerformance>;
     }
+    interface IndividualValidatorPerformanceInstance extends TypedEventInstance<IndividualValidatorPerformance> {
+        data_decoded: IndividualValidatorPerformance;
+        type_arguments: [];
+    }
     interface JoinValidatorSetEvent {
         pool_address: Address;
     }
@@ -512,6 +579,10 @@ export declare namespace stake {
         const TYPE_QNAME = "0x1::stake::ValidatorConfig";
         function type(): TypeDescriptor<ValidatorConfig>;
     }
+    interface ValidatorConfigInstance extends TypedEventInstance<ValidatorConfig> {
+        data_decoded: ValidatorConfig;
+        type_arguments: [];
+    }
     interface ValidatorFees {
         fees_table: table.Table<Address, coin.Coin<aptos_coin.AptosCoin>>;
     }
@@ -528,6 +599,10 @@ export declare namespace stake {
         const TYPE_QNAME = "0x1::stake::ValidatorInfo";
         function type(): TypeDescriptor<ValidatorInfo>;
     }
+    interface ValidatorInfoInstance extends TypedEventInstance<ValidatorInfo> {
+        data_decoded: ValidatorInfo;
+        type_arguments: [];
+    }
     interface ValidatorPerformance {
         validators: stake.IndividualValidatorPerformance[];
     }
@@ -612,6 +687,12 @@ export declare namespace stake {
         type_arguments: [];
     }
 }
+export declare class table extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): table;
+    onEventBox(func: (event: table.BoxInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): table;
+}
 export declare namespace table {
     interface Box<T0> {
         val: T0;
@@ -620,6 +701,10 @@ export declare namespace table {
         const TYPE_QNAME = "0x1::table::Box";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Box<T0>>;
     }
+    interface BoxInstance extends TypedEventInstance<Box<any>> {
+        data_decoded: Box<any>;
+        type_arguments: [string];
+    }
     interface Table<T0, T1> {
         handle: Address;
     }
@@ -636,7 +721,12 @@ export declare class object_ extends AptosBaseProcessor {
     onEntryTransfer(func: (call: object_.TransferPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): object_;
     onEntryTransferCall(func: (call: object_.TransferCallPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): object_;
     onEntryTransferToObject(func: (call: object_.TransferToObjectPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): object_;
+    onEventDeleteRef(func: (event: object_.DeleteRefInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): object_;
+    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_;
     onEventTransferEvent(func: (event: object_.TransferEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): object_;
+    onEventTransferRef(func: (event: object_.TransferRefInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): object_;
 }
 export declare namespace object_ {
     interface ConstructorRef {
@@ -654,6 +744,10 @@ export declare namespace object_ {
         const TYPE_QNAME = "0x1::object::DeleteRef";
         function type(): TypeDescriptor<DeleteRef>;
     }
+    interface DeleteRefInstance extends TypedEventInstance<DeleteRef> {
+        data_decoded: DeleteRef;
+        type_arguments: [];
+    }
     interface DeriveRef {
         self: Address;
     }
@@ -661,6 +755,10 @@ export declare namespace object_ {
         const TYPE_QNAME = "0x1::object::DeriveRef";
         function type(): TypeDescriptor<DeriveRef>;
     }
+    interface DeriveRefInstance extends TypedEventInstance<DeriveRef> {
+        data_decoded: DeriveRef;
+        type_arguments: [];
+    }
     interface ExtendRef {
         self: Address;
     }
@@ -668,6 +766,10 @@ export declare namespace object_ {
         const TYPE_QNAME = "0x1::object::ExtendRef";
         function type(): TypeDescriptor<ExtendRef>;
     }
+    interface ExtendRefInstance extends TypedEventInstance<ExtendRef> {
+        data_decoded: ExtendRef;
+        type_arguments: [];
+    }
     interface LinearTransferRef {
         self: Address;
         owner: Address;
@@ -683,6 +785,10 @@ export declare namespace object_ {
         const TYPE_QNAME = "0x1::object::Object";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Object<T0>>;
     }
+    interface ObjectInstance extends TypedEventInstance<Object<any>> {
+        data_decoded: Object<any>;
+        type_arguments: [string];
+    }
     interface ObjectCore {
         guid_creation_num: bigint;
         owner: Address;
@@ -720,6 +826,10 @@ export declare namespace object_ {
         const TYPE_QNAME = "0x1::object::TransferRef";
         function type(): TypeDescriptor<TransferRef>;
     }
+    interface TransferRefInstance extends TypedEventInstance<TransferRef> {
+        data_decoded: TransferRef;
+        type_arguments: [];
+    }
     interface TransferPayload<T0 = any> extends TypedFunctionPayload<[object_.Object<T0>, Address]> {
         arguments_decoded: [object_.Object<T0>, Address];
         type_arguments: [string];
@@ -733,6 +843,12 @@ export declare namespace object_ {
         type_arguments: [string, string];
     }
 }
+export declare class option extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): option;
+    onEventOption(func: (event: option.OptionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): option;
+}
 export declare namespace option {
     interface Option<T0> {
         vec: T0[] | string;
@@ -741,8 +857,18 @@ export declare namespace option {
         const TYPE_QNAME = "0x1::option::Option";
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Option<T0>>;
     }
+    interface OptionInstance extends TypedEventInstance<Option<any>> {
+        data_decoded: Option<any>;
+        type_arguments: [string];
+    }
 }
 export declare namespace signer { }
+export declare class string_ extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): string_;
+    onEventString(func: (event: string_.StringInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): string_;
+}
 export declare namespace string_ {
     interface String {
         bytes: string;
@@ -751,6 +877,10 @@ export declare namespace string_ {
         const TYPE_QNAME = "0x1::string::String";
         function type(): TypeDescriptor<String>;
     }
+    interface StringInstance extends TypedEventInstance<String> {
+        data_decoded: String;
+        type_arguments: [];
+    }
 }
 export declare namespace vector { }
 export declare class voting extends AptosBaseProcessor {
@@ -869,6 +999,8 @@ export declare class account extends AptosBaseProcessor {
     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;
     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;
 }
 export declare namespace account {
     interface Account {
@@ -928,6 +1060,10 @@ export declare namespace account {
         const TYPE_QNAME = "0x1::account::RotationCapability";
         function type(): TypeDescriptor<RotationCapability>;
     }
+    interface RotationCapabilityInstance extends TypedEventInstance<RotationCapability> {
+        data_decoded: RotationCapability;
+        type_arguments: [];
+    }
     interface RotationCapabilityOfferProofChallenge {
         sequence_number: bigint;
         recipient_address: Address;
@@ -963,6 +1099,10 @@ export declare namespace account {
         const TYPE_QNAME = "0x1::account::SignerCapability";
         function type(): TypeDescriptor<SignerCapability>;
     }
+    interface SignerCapabilityInstance extends TypedEventInstance<SignerCapability> {
+        data_decoded: SignerCapability;
+        type_arguments: [];
+    }
     interface SignerCapabilityOfferProofChallenge {
         sequence_number: bigint;
         recipient_address: Address;
@@ -1020,6 +1160,14 @@ export declare namespace account {
         type_arguments: [];
     }
 }
+export declare class ed25519 extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): ed25519;
+    onEventSignature(func: (event: ed25519.SignatureInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): ed25519;
+    onEventUnvalidatedPublicKey(func: (event: ed25519.UnvalidatedPublicKeyInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): ed25519;
+    onEventValidatedPublicKey(func: (event: ed25519.ValidatedPublicKeyInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): ed25519;
+}
 export declare namespace ed25519 {
     interface Signature {
         bytes: string;
@@ -1028,6 +1176,10 @@ export declare namespace ed25519 {
         const TYPE_QNAME = "0x1::ed25519::Signature";
         function type(): TypeDescriptor<Signature>;
     }
+    interface SignatureInstance extends TypedEventInstance<Signature> {
+        data_decoded: Signature;
+        type_arguments: [];
+    }
     interface SignedMessage<T0> {
         type_info: type_info.TypeInfo;
         inner: T0;
@@ -1043,6 +1195,10 @@ export declare namespace ed25519 {
         const TYPE_QNAME = "0x1::ed25519::UnvalidatedPublicKey";
         function type(): TypeDescriptor<UnvalidatedPublicKey>;
     }
+    interface UnvalidatedPublicKeyInstance extends TypedEventInstance<UnvalidatedPublicKey> {
+        data_decoded: UnvalidatedPublicKey;
+        type_arguments: [];
+    }
     interface ValidatedPublicKey {
         bytes: string;
     }
@@ -1050,6 +1206,10 @@ export declare namespace ed25519 {
         const TYPE_QNAME = "0x1::ed25519::ValidatedPublicKey";
         function type(): TypeDescriptor<ValidatedPublicKey>;
     }
+    interface ValidatedPublicKeyInstance extends TypedEventInstance<ValidatedPublicKey> {
+        data_decoded: ValidatedPublicKey;
+        type_arguments: [];
+    }
 }
 export declare namespace genesis {
     interface AccountMap {
@@ -1142,16 +1302,17 @@ 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;
+    onEventAdminWithdrawEvent(func: (event: vesting.AdminWithdrawEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventCreateVestingContractEvent(func: (event: vesting.CreateVestingContractEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
-    onEventUpdateOperatorEvent(func: (event: vesting.UpdateOperatorEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
-    onEventUpdateVoterEvent(func: (event: vesting.UpdateVoterEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventDistributeEvent(func: (event: vesting.DistributeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventResetLockupEvent(func: (event: vesting.ResetLockupEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventSetBeneficiaryEvent(func: (event: vesting.SetBeneficiaryEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventTerminateEvent(func: (event: vesting.TerminateEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventUnlockRewardsEvent(func: (event: vesting.UnlockRewardsEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventUpdateOperatorEvent(func: (event: vesting.UpdateOperatorEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventUpdateVoterEvent(func: (event: vesting.UpdateVoterEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
     onEventVestEvent(func: (event: vesting.VestEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
-    onEventDistributeEvent(func: (event: vesting.DistributeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
-    onEventTerminateEvent(func: (event: vesting.TerminateEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
-    onEventAdminWithdrawEvent(func: (event: vesting.AdminWithdrawEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
+    onEventVestingSchedule(func: (event: vesting.VestingScheduleInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
 }
 export declare namespace vesting {
     interface AdminStore {
@@ -1358,6 +1519,10 @@ export declare namespace vesting {
         const TYPE_QNAME = "0x1::vesting::VestingSchedule";
         function type(): TypeDescriptor<VestingSchedule>;
     }
+    interface VestingScheduleInstance extends TypedEventInstance<VestingSchedule> {
+        data_decoded: VestingSchedule;
+        type_arguments: [];
+    }
     interface AdminWithdrawPayload extends TypedFunctionPayload<[Address]> {
         arguments_decoded: [Address];
         type_arguments: [];
@@ -1423,6 +1588,17 @@ export declare namespace vesting {
         type_arguments: [];
     }
 }
+export declare class bls12381 extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): bls12381;
+    onEventAggrOrMultiSignature(func: (event: bls12381.AggrOrMultiSignatureInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): bls12381;
+    onEventAggrPublicKeysWithPoP(func: (event: bls12381.AggrPublicKeysWithPoPInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): bls12381;
+    onEventProofOfPossession(func: (event: bls12381.ProofOfPossessionInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): bls12381;
+    onEventPublicKey(func: (event: bls12381.PublicKeyInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): bls12381;
+    onEventPublicKeyWithPoP(func: (event: bls12381.PublicKeyWithPoPInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): bls12381;
+    onEventSignature(func: (event: bls12381.SignatureInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): bls12381;
+}
 export declare namespace bls12381 {
     interface AggrOrMultiSignature {
         bytes: string;
@@ -1431,6 +1607,10 @@ export declare namespace bls12381 {
         const TYPE_QNAME = "0x1::bls12381::AggrOrMultiSignature";
         function type(): TypeDescriptor<AggrOrMultiSignature>;
     }
+    interface AggrOrMultiSignatureInstance extends TypedEventInstance<AggrOrMultiSignature> {
+        data_decoded: AggrOrMultiSignature;
+        type_arguments: [];
+    }
     interface AggrPublicKeysWithPoP {
         bytes: string;
     }
@@ -1438,6 +1618,10 @@ export declare namespace bls12381 {
         const TYPE_QNAME = "0x1::bls12381::AggrPublicKeysWithPoP";
         function type(): TypeDescriptor<AggrPublicKeysWithPoP>;
     }
+    interface AggrPublicKeysWithPoPInstance extends TypedEventInstance<AggrPublicKeysWithPoP> {
+        data_decoded: AggrPublicKeysWithPoP;
+        type_arguments: [];
+    }
     interface ProofOfPossession {
         bytes: string;
     }
@@ -1445,6 +1629,10 @@ export declare namespace bls12381 {
         const TYPE_QNAME = "0x1::bls12381::ProofOfPossession";
         function type(): TypeDescriptor<ProofOfPossession>;
     }
+    interface ProofOfPossessionInstance extends TypedEventInstance<ProofOfPossession> {
+        data_decoded: ProofOfPossession;
+        type_arguments: [];
+    }
     interface PublicKey {
         bytes: string;
     }
@@ -1452,6 +1640,10 @@ export declare namespace bls12381 {
         const TYPE_QNAME = "0x1::bls12381::PublicKey";
         function type(): TypeDescriptor<PublicKey>;
     }
+    interface PublicKeyInstance extends TypedEventInstance<PublicKey> {
+        data_decoded: PublicKey;
+        type_arguments: [];
+    }
     interface PublicKeyWithPoP {
         bytes: string;
     }
@@ -1459,6 +1651,10 @@ export declare namespace bls12381 {
         const TYPE_QNAME = "0x1::bls12381::PublicKeyWithPoP";
         function type(): TypeDescriptor<PublicKeyWithPoP>;
     }
+    interface PublicKeyWithPoPInstance extends TypedEventInstance<PublicKeyWithPoP> {
+        data_decoded: PublicKeyWithPoP;
+        type_arguments: [];
+    }
     interface Signature {
         bytes: string;
     }
@@ -1466,6 +1662,10 @@ export declare namespace bls12381 {
         const TYPE_QNAME = "0x1::bls12381::Signature";
         function type(): TypeDescriptor<Signature>;
     }
+    interface SignatureInstance extends TypedEventInstance<Signature> {
+        data_decoded: Signature;
+        type_arguments: [];
+    }
 }
 export declare namespace chain_id {
     interface ChainId {
@@ -1500,6 +1700,13 @@ export declare namespace pool_u64 {
         function type(): TypeDescriptor<Pool>;
     }
 }
+export declare class secp256k1 extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): secp256k1;
+    onEventECDSARawPublicKey(func: (event: secp256k1.ECDSARawPublicKeyInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): secp256k1;
+    onEventECDSASignature(func: (event: secp256k1.ECDSASignatureInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): secp256k1;
+}
 export declare namespace secp256k1 {
     interface ECDSARawPublicKey {
         bytes: string;
@@ -1508,6 +1715,10 @@ export declare namespace secp256k1 {
         const TYPE_QNAME = "0x1::secp256k1::ECDSARawPublicKey";
         function type(): TypeDescriptor<ECDSARawPublicKey>;
     }
+    interface ECDSARawPublicKeyInstance extends TypedEventInstance<ECDSARawPublicKey> {
+        data_decoded: ECDSARawPublicKey;
+        type_arguments: [];
+    }
     interface ECDSASignature {
         bytes: string;
     }
@@ -1515,6 +1726,10 @@ export declare namespace secp256k1 {
         const TYPE_QNAME = "0x1::secp256k1::ECDSASignature";
         function type(): TypeDescriptor<ECDSASignature>;
     }
+    interface ECDSASignatureInstance extends TypedEventInstance<ECDSASignature> {
+        data_decoded: ECDSASignature;
+        type_arguments: [];
+    }
 }
 export declare namespace timestamp {
     interface CurrentTimeMicroseconds {
@@ -1525,6 +1740,12 @@ export declare namespace timestamp {
         function type(): TypeDescriptor<CurrentTimeMicroseconds>;
     }
 }
+export declare class type_info extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): type_info;
+    onEventTypeInfo(func: (event: type_info.TypeInfoInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): type_info;
+}
 export declare namespace type_info {
     interface TypeInfo {
         account_address: Address;
@@ -1535,6 +1756,10 @@ export declare namespace type_info {
         const TYPE_QNAME = "0x1::type_info::TypeInfo";
         function type(): TypeDescriptor<TypeInfo>;
     }
+    interface TypeInfoInstance extends TypedEventInstance<TypeInfo> {
+        data_decoded: TypeInfo;
+        type_arguments: [];
+    }
 }
 export declare namespace aggregator {
     interface Aggregator {
@@ -1609,6 +1834,12 @@ export declare namespace big_vector {
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<BigVector<T0>>;
     }
 }
+export declare class bit_vector extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): bit_vector;
+    onEventBitVector(func: (event: bit_vector.BitVectorInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): bit_vector;
+}
 export declare namespace bit_vector {
     interface BitVector {
         length: bigint;
@@ -1618,6 +1849,10 @@ export declare namespace bit_vector {
         const TYPE_QNAME = "0x1::bit_vector::BitVector";
         function type(): TypeDescriptor<BitVector>;
     }
+    interface BitVectorInstance extends TypedEventInstance<BitVector> {
+        data_decoded: BitVector;
+        type_arguments: [];
+    }
 }
 export declare namespace capability {
     interface Cap<T0> {
@@ -1659,6 +1894,13 @@ export declare namespace comparator {
     }
 }
 export declare namespace math_fixed { }
+export declare class simple_map extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): simple_map;
+    onEventElement(func: (event: simple_map.ElementInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): simple_map;
+    onEventSimpleMap(func: (event: simple_map.SimpleMapInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): simple_map;
+}
 export declare namespace simple_map {
     interface Element<T0, T1> {
         key: T0;
@@ -1668,6 +1910,10 @@ export declare namespace simple_map {
         const TYPE_QNAME = "0x1::simple_map::Element";
         function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Element<T0, T1>>;
     }
+    interface ElementInstance extends TypedEventInstance<Element<any, any>> {
+        data_decoded: Element<any, any>;
+        type_arguments: [string, string];
+    }
     interface SimpleMap<T0, T1> {
         data: simple_map.Element<T0, T1>[];
     }
@@ -1675,6 +1921,16 @@ export declare namespace simple_map {
         const TYPE_QNAME = "0x1::simple_map::SimpleMap";
         function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<SimpleMap<T0, T1>>;
     }
+    interface SimpleMapInstance extends TypedEventInstance<SimpleMap<any, any>> {
+        data_decoded: SimpleMap<any, any>;
+        type_arguments: [string, string];
+    }
+}
+export declare class smart_table extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): smart_table;
+    onEventEntry(func: (event: smart_table.EntryInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): smart_table;
 }
 export declare namespace smart_table {
     interface Entry<T0, T1> {
@@ -1686,6 +1942,10 @@ export declare namespace smart_table {
         const TYPE_QNAME = "0x1::smart_table::Entry";
         function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Entry<T0, T1>>;
     }
+    interface EntryInstance extends TypedEventInstance<Entry<any, any>> {
+        data_decoded: Entry<any, any>;
+        type_arguments: [string, string];
+    }
     interface SmartTable<T0, T1> {
         buckets: table_with_length.TableWithLength<bigint, smart_table.Entry<T0, T1>[]>;
         num_buckets: bigint;
@@ -1699,6 +1959,14 @@ export declare namespace smart_table {
         function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<SmartTable<T0, T1>>;
     }
 }
+export declare class storage_gas extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): storage_gas;
+    onEventGasCurve(func: (event: storage_gas.GasCurveInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): storage_gas;
+    onEventPoint(func: (event: storage_gas.PointInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): storage_gas;
+    onEventUsageGasConfig(func: (event: storage_gas.UsageGasConfigInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): storage_gas;
+}
 export declare namespace storage_gas {
     interface GasCurve {
         min_gas: bigint;
@@ -1709,6 +1977,10 @@ export declare namespace storage_gas {
         const TYPE_QNAME = "0x1::storage_gas::GasCurve";
         function type(): TypeDescriptor<GasCurve>;
     }
+    interface GasCurveInstance extends TypedEventInstance<GasCurve> {
+        data_decoded: GasCurve;
+        type_arguments: [];
+    }
     interface Point {
         x: bigint;
         y: bigint;
@@ -1717,6 +1989,10 @@ export declare namespace storage_gas {
         const TYPE_QNAME = "0x1::storage_gas::Point";
         function type(): TypeDescriptor<Point>;
     }
+    interface PointInstance extends TypedEventInstance<Point> {
+        data_decoded: Point;
+        type_arguments: [];
+    }
     interface StorageGas {
         per_item_read: bigint;
         per_item_create: bigint;
@@ -1747,6 +2023,10 @@ export declare namespace storage_gas {
         const TYPE_QNAME = "0x1::storage_gas::UsageGasConfig";
         function type(): TypeDescriptor<UsageGasConfig>;
     }
+    interface UsageGasConfigInstance extends TypedEventInstance<UsageGasConfig> {
+        data_decoded: UsageGasConfig;
+        type_arguments: [];
+    }
 }
 export declare namespace chain_status {
     interface GenesisEndMarker {
@@ -1757,6 +2037,12 @@ export declare namespace chain_status {
         function type(): TypeDescriptor<GenesisEndMarker>;
     }
 }
+export declare class copyable_any extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): copyable_any;
+    onEventAny(func: (event: copyable_any.AnyInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): copyable_any;
+}
 export declare namespace copyable_any {
     interface Any {
         type_name: string;
@@ -1766,6 +2052,16 @@ export declare namespace copyable_any {
         const TYPE_QNAME = "0x1::copyable_any::Any";
         function type(): TypeDescriptor<Any>;
     }
+    interface AnyInstance extends TypedEventInstance<Any> {
+        data_decoded: Any;
+        type_arguments: [];
+    }
+}
+export declare class gas_schedule extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    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;
 }
 export declare namespace gas_schedule {
     interface GasEntry {
@@ -1776,6 +2072,10 @@ export declare namespace gas_schedule {
         const TYPE_QNAME = "0x1::gas_schedule::GasEntry";
         function type(): TypeDescriptor<GasEntry>;
     }
+    interface GasEntryInstance extends TypedEventInstance<GasEntry> {
+        data_decoded: GasEntry;
+        type_arguments: [];
+    }
     interface GasSchedule {
         entries: gas_schedule.GasEntry[];
     }
@@ -1829,6 +2129,13 @@ export declare namespace managed_coin {
     }
 }
 export declare namespace math_fixed64 { }
+export declare class ristretto255 extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): ristretto255;
+    onEventCompressedRistretto(func: (event: ristretto255.CompressedRistrettoInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): ristretto255;
+    onEventScalar(func: (event: ristretto255.ScalarInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): ristretto255;
+}
 export declare namespace ristretto255 {
     interface CompressedRistretto {
         data: string;
@@ -1837,6 +2144,10 @@ export declare namespace ristretto255 {
         const TYPE_QNAME = "0x1::ristretto255::CompressedRistretto";
         function type(): TypeDescriptor<CompressedRistretto>;
     }
+    interface CompressedRistrettoInstance extends TypedEventInstance<CompressedRistretto> {
+        data_decoded: CompressedRistretto;
+        type_arguments: [];
+    }
     interface RistrettoPoint {
         handle: bigint;
     }
@@ -1851,6 +2162,10 @@ export declare namespace ristretto255 {
         const TYPE_QNAME = "0x1::ristretto255::Scalar";
         function type(): TypeDescriptor<Scalar>;
     }
+    interface ScalarInstance extends TypedEventInstance<Scalar> {
+        data_decoded: Scalar;
+        type_arguments: [];
+    }
 }
 export declare namespace smart_vector {
     interface SmartVector<T0> {
@@ -1864,6 +2179,14 @@ export declare namespace smart_vector {
         function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<SmartVector<T0>>;
     }
 }
+export declare class string_utils extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): string_utils;
+    onEventCons(func: (event: string_utils.ConsInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): string_utils;
+    onEventFakeCons(func: (event: string_utils.FakeConsInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): string_utils;
+    onEventNIL(func: (event: string_utils.NILInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): string_utils;
+}
 export declare namespace string_utils {
     interface Cons<T0, T1> {
         car: T0;
@@ -1873,6 +2196,10 @@ export declare namespace string_utils {
         const TYPE_QNAME = "0x1::string_utils::Cons";
         function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Cons<T0, T1>>;
     }
+    interface ConsInstance extends TypedEventInstance<Cons<any, any>> {
+        data_decoded: Cons<any, any>;
+        type_arguments: [string, string];
+    }
     interface FakeCons<T0, T1> {
         car: T0;
         cdr: T1;
@@ -1881,6 +2208,10 @@ export declare namespace string_utils {
         const TYPE_QNAME = "0x1::string_utils::FakeCons";
         function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<FakeCons<T0, T1>>;
     }
+    interface FakeConsInstance extends TypedEventInstance<FakeCons<any, any>> {
+        data_decoded: FakeCons<any, any>;
+        type_arguments: [string, string];
+    }
     interface NIL {
         dummy_field: Boolean;
     }
@@ -1888,6 +2219,10 @@ export declare namespace string_utils {
         const TYPE_QNAME = "0x1::string_utils::NIL";
         function type(): TypeDescriptor<NIL>;
     }
+    interface NILInstance extends TypedEventInstance<NIL> {
+        data_decoded: NIL;
+        type_arguments: [];
+    }
 }
 export declare class aptos_account extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -1947,6 +2282,12 @@ export declare namespace aptos_account {
     }
 }
 export declare namespace create_signer { }
+export declare class fixed_point32 extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): fixed_point32;
+    onEventFixedPoint32(func: (event: fixed_point32.FixedPoint32Instance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): fixed_point32;
+}
 export declare namespace fixed_point32 {
     interface FixedPoint32 {
         value: bigint;
@@ -1955,6 +2296,16 @@ export declare namespace fixed_point32 {
         const TYPE_QNAME = "0x1::fixed_point32::FixedPoint32";
         function type(): TypeDescriptor<FixedPoint32>;
     }
+    interface FixedPoint32Instance extends TypedEventInstance<FixedPoint32> {
+        data_decoded: FixedPoint32;
+        type_arguments: [];
+    }
+}
+export declare class fixed_point64 extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): fixed_point64;
+    onEventFixedPoint64(func: (event: fixed_point64.FixedPoint64Instance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): fixed_point64;
 }
 export declare namespace fixed_point64 {
     interface FixedPoint64 {
@@ -1964,6 +2315,18 @@ export declare namespace fixed_point64 {
         const TYPE_QNAME = "0x1::fixed_point64::FixedPoint64";
         function type(): TypeDescriptor<FixedPoint64>;
     }
+    interface FixedPoint64Instance extends TypedEventInstance<FixedPoint64> {
+        data_decoded: FixedPoint64;
+        type_arguments: [];
+    }
+}
+export declare class multi_ed25519 extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): multi_ed25519;
+    onEventSignature(func: (event: multi_ed25519.SignatureInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multi_ed25519;
+    onEventUnvalidatedPublicKey(func: (event: multi_ed25519.UnvalidatedPublicKeyInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multi_ed25519;
+    onEventValidatedPublicKey(func: (event: multi_ed25519.ValidatedPublicKeyInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multi_ed25519;
 }
 export declare namespace multi_ed25519 {
     interface Signature {
@@ -1973,6 +2336,10 @@ export declare namespace multi_ed25519 {
         const TYPE_QNAME = "0x1::multi_ed25519::Signature";
         function type(): TypeDescriptor<Signature>;
     }
+    interface SignatureInstance extends TypedEventInstance<Signature> {
+        data_decoded: Signature;
+        type_arguments: [];
+    }
     interface UnvalidatedPublicKey {
         bytes: string;
     }
@@ -1980,6 +2347,10 @@ export declare namespace multi_ed25519 {
         const TYPE_QNAME = "0x1::multi_ed25519::UnvalidatedPublicKey";
         function type(): TypeDescriptor<UnvalidatedPublicKey>;
     }
+    interface UnvalidatedPublicKeyInstance extends TypedEventInstance<UnvalidatedPublicKey> {
+        data_decoded: UnvalidatedPublicKey;
+        type_arguments: [];
+    }
     interface ValidatedPublicKey {
         bytes: string;
     }
@@ -1987,6 +2358,10 @@ export declare namespace multi_ed25519 {
         const TYPE_QNAME = "0x1::multi_ed25519::ValidatedPublicKey";
         function type(): TypeDescriptor<ValidatedPublicKey>;
     }
+    interface ValidatedPublicKeyInstance extends TypedEventInstance<ValidatedPublicKey> {
+        data_decoded: ValidatedPublicKey;
+        type_arguments: [];
+    }
 }
 export declare class staking_proxy extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -2035,6 +2410,12 @@ export declare namespace staking_proxy {
         type_arguments: [];
     }
 }
+export declare class state_storage extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): state_storage;
+    onEventUsage(func: (event: state_storage.UsageInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): state_storage;
+}
 export declare namespace state_storage {
     interface GasParameter {
         usage: state_storage.Usage;
@@ -2059,6 +2440,10 @@ export declare namespace state_storage {
         const TYPE_QNAME = "0x1::state_storage::Usage";
         function type(): TypeDescriptor<Usage>;
     }
+    interface UsageInstance extends TypedEventInstance<Usage> {
+        data_decoded: Usage;
+        type_arguments: [];
+    }
 }
 export declare namespace crypto_algebra {
     interface Element<T0> {
@@ -2074,9 +2459,12 @@ 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;
+    onEventBurnRef(func: (event: fungible_asset.BurnRefInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): fungible_asset;
     onEventDepositEvent(func: (event: fungible_asset.DepositEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): fungible_asset;
-    onEventWithdrawEvent(func: (event: fungible_asset.WithdrawEventInstance, 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;
+    onEventWithdrawEvent(func: (event: fungible_asset.WithdrawEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): fungible_asset;
 }
 export declare namespace fungible_asset {
     interface BurnRef {
@@ -2086,6 +2474,10 @@ export declare namespace fungible_asset {
         const TYPE_QNAME = "0x1::fungible_asset::BurnRef";
         function type(): TypeDescriptor<BurnRef>;
     }
+    interface BurnRefInstance extends TypedEventInstance<BurnRef> {
+        data_decoded: BurnRef;
+        type_arguments: [];
+    }
     interface DepositEvent {
         amount: bigint;
     }
@@ -2152,6 +2544,10 @@ export declare namespace fungible_asset {
         const TYPE_QNAME = "0x1::fungible_asset::MintRef";
         function type(): TypeDescriptor<MintRef>;
     }
+    interface MintRefInstance extends TypedEventInstance<MintRef> {
+        data_decoded: MintRef;
+        type_arguments: [];
+    }
     interface Supply {
         current: bigint;
         maximum: option.Option<bigint>;
@@ -2167,6 +2563,10 @@ export declare namespace fungible_asset {
         const TYPE_QNAME = "0x1::fungible_asset::TransferRef";
         function type(): TypeDescriptor<TransferRef>;
     }
+    interface TransferRefInstance extends TypedEventInstance<TransferRef> {
+        data_decoded: TransferRef;
+        type_arguments: [];
+    }
     interface WithdrawEvent {
         amount: bigint;
     }
@@ -2230,13 +2630,17 @@ export declare class delegation_pool extends AptosBaseProcessor {
     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;
     onEventAddStakeEvent(func: (event: delegation_pool.AddStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventCreateProposalEvent(func: (event: delegation_pool.CreateProposalEventInstance, 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;
+    onEventDistributeCommissionEvent(func: (event: delegation_pool.DistributeCommissionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventObservedLockupCycle(func: (event: delegation_pool.ObservedLockupCycleInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventReactivateStakeEvent(func: (event: delegation_pool.ReactivateStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
     onEventUnlockStakeEvent(func: (event: delegation_pool.UnlockStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEventWithdrawStakeEvent(func: (event: delegation_pool.WithdrawStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEventDistributeCommissionEvent(func: (event: delegation_pool.DistributeCommissionEventInstance, 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;
-    onEventCreateProposalEvent(func: (event: delegation_pool.CreateProposalEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
-    onEventDelegateVotingPowerEvent(func: (event: delegation_pool.DelegateVotingPowerEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
+    onEventVotingRecordKey(func: (event: delegation_pool.VotingRecordKeyInstance, 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 AddStakeEvent {
@@ -2289,6 +2693,10 @@ export declare namespace delegation_pool {
         const TYPE_QNAME = "0x1::delegation_pool::DelegatedVotes";
         function type(): TypeDescriptor<DelegatedVotes>;
     }
+    interface DelegatedVotesInstance extends TypedEventInstance<DelegatedVotes> {
+        data_decoded: DelegatedVotes;
+        type_arguments: [];
+    }
     interface DelegationPool {
         active_shares: pool_u64_unbound.Pool;
         observed_lockup_cycle: delegation_pool.ObservedLockupCycle;
@@ -2348,6 +2756,10 @@ export declare namespace delegation_pool {
         const TYPE_QNAME = "0x1::delegation_pool::ObservedLockupCycle";
         function type(): TypeDescriptor<ObservedLockupCycle>;
     }
+    interface ObservedLockupCycleInstance extends TypedEventInstance<ObservedLockupCycle> {
+        data_decoded: ObservedLockupCycle;
+        type_arguments: [];
+    }
     interface ReactivateStakeEvent {
         pool_address: Address;
         delegator_address: Address;
@@ -2383,6 +2795,10 @@ export declare namespace delegation_pool {
         const TYPE_QNAME = "0x1::delegation_pool::VoteDelegation";
         function type(): TypeDescriptor<VoteDelegation>;
     }
+    interface VoteDelegationInstance extends TypedEventInstance<VoteDelegation> {
+        data_decoded: VoteDelegation;
+        type_arguments: [];
+    }
     interface VoteEvent {
         voter: Address;
         proposal_id: bigint;
@@ -2406,6 +2822,10 @@ export declare namespace delegation_pool {
         const TYPE_QNAME = "0x1::delegation_pool::VotingRecordKey";
         function type(): TypeDescriptor<VotingRecordKey>;
     }
+    interface VotingRecordKeyInstance extends TypedEventInstance<VotingRecordKey> {
+        data_decoded: VotingRecordKey;
+        type_arguments: [];
+    }
     interface WithdrawStakeEvent {
         pool_address: Address;
         delegator_address: Address;
@@ -2531,6 +2951,7 @@ export declare class aptos_governance extends AptosBaseProcessor {
     onEntryPartialVote(func: (call: aptos_governance.PartialVotePayload, 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;
     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;
     onEventUpdateConfigEvent(func: (event: aptos_governance.UpdateConfigEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
     onEventVoteEvent(func: (event: aptos_governance.VoteEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
 }
@@ -2590,6 +3011,10 @@ export declare namespace aptos_governance {
         const TYPE_QNAME = "0x1::aptos_governance::RecordKey";
         function type(): TypeDescriptor<RecordKey>;
     }
+    interface RecordKeyInstance extends TypedEventInstance<RecordKey> {
+        data_decoded: RecordKey;
+        type_arguments: [];
+    }
     interface UpdateConfigEvent {
         min_voting_threshold: bigint;
         required_proposer_stake: bigint;
@@ -2804,14 +3229,16 @@ export declare class multisig_account extends AptosBaseProcessor {
     onEntryUpdateSignaturesRequired(func: (call: multisig_account.UpdateSignaturesRequiredPayload, 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;
     onEventAddOwnersEvent(func: (event: multisig_account.AddOwnersEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
-    onEventRemoveOwnersEvent(func: (event: multisig_account.RemoveOwnersEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
-    onEventUpdateSignaturesRequiredEvent(func: (event: multisig_account.UpdateSignaturesRequiredEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEventCreateTransactionEvent(func: (event: multisig_account.CreateTransactionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
-    onEventVoteEvent(func: (event: multisig_account.VoteEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
     onEventExecuteRejectedTransactionEvent(func: (event: multisig_account.ExecuteRejectedTransactionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
-    onEventTransactionExecutionSucceededEvent(func: (event: multisig_account.TransactionExecutionSucceededEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
-    onEventTransactionExecutionFailedEvent(func: (event: multisig_account.TransactionExecutionFailedEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEventExecutionError(func: (event: multisig_account.ExecutionErrorInstance, 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;
+    onEventRemoveOwnersEvent(func: (event: multisig_account.RemoveOwnersEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEventTransactionExecutionFailedEvent(func: (event: multisig_account.TransactionExecutionFailedEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEventTransactionExecutionSucceededEvent(func: (event: multisig_account.TransactionExecutionSucceededEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
+    onEventUpdateSignaturesRequiredEvent(func: (event: multisig_account.UpdateSignaturesRequiredEventInstance, 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 AddOwnersEvent {
@@ -2860,6 +3287,10 @@ export declare namespace multisig_account {
         const TYPE_QNAME = "0x1::multisig_account::ExecutionError";
         function type(): TypeDescriptor<ExecutionError>;
     }
+    interface ExecutionErrorInstance extends TypedEventInstance<ExecutionError> {
+        data_decoded: ExecutionError;
+        type_arguments: [];
+    }
     interface MetadataUpdatedEvent {
         old_metadata: simple_map.SimpleMap<string, string>;
         new_metadata: simple_map.SimpleMap<string, string>;
@@ -2927,6 +3358,10 @@ export declare namespace multisig_account {
         const TYPE_QNAME = "0x1::multisig_account::MultisigTransaction";
         function type(): TypeDescriptor<MultisigTransaction>;
     }
+    interface MultisigTransactionInstance extends TypedEventInstance<MultisigTransaction> {
+        data_decoded: MultisigTransaction;
+        type_arguments: [];
+    }
     interface RemoveOwnersEvent {
         owners_removed: Address[];
     }
@@ -3169,16 +3604,16 @@ export declare class staking_contract extends AptosBaseProcessor {
     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;
-    onEventUpdateCommissionEvent(func: (event: staking_contract.UpdateCommissionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
-    onEventCreateStakingContractEvent(func: (event: staking_contract.CreateStakingContractEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
-    onEventUpdateVoterEvent(func: (event: staking_contract.UpdateVoterEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
-    onEventResetLockupEvent(func: (event: staking_contract.ResetLockupEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventAddDistributionEvent(func: (event: staking_contract.AddDistributionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventAddStakeEvent(func: (event: staking_contract.AddStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventCreateStakingContractEvent(func: (event: staking_contract.CreateStakingContractEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventDistributeEvent(func: (event: staking_contract.DistributeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventRequestCommissionEvent(func: (event: staking_contract.RequestCommissionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
-    onEventUnlockStakeEvent(func: (event: staking_contract.UnlockStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventResetLockupEvent(func: (event: staking_contract.ResetLockupEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
     onEventSwitchOperatorEvent(func: (event: staking_contract.SwitchOperatorEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
-    onEventAddDistributionEvent(func: (event: staking_contract.AddDistributionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
-    onEventDistributeEvent(func: (event: staking_contract.DistributeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventUnlockStakeEvent(func: (event: staking_contract.UnlockStakeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
+    onEventUpdateCommissionEvent(func: (event: staking_contract.UpdateCommissionEventInstance, 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 AddDistributionEvent {
@@ -3424,6 +3859,12 @@ export declare namespace aggregator_factory {
         function type(): TypeDescriptor<AggregatorFactory>;
     }
 }
+export declare class governance_proposal extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): governance_proposal;
+    onEventGovernanceProposal(func: (event: governance_proposal.GovernanceProposalInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): governance_proposal;
+}
 export declare namespace governance_proposal {
     interface GovernanceProposal {
         dummy_field: Boolean;
@@ -3432,6 +3873,10 @@ export declare namespace governance_proposal {
         const TYPE_QNAME = "0x1::governance_proposal::GovernanceProposal";
         function type(): TypeDescriptor<GovernanceProposal>;
     }
+    interface GovernanceProposalInstance extends TypedEventInstance<GovernanceProposal> {
+        data_decoded: GovernanceProposal;
+        type_arguments: [];
+    }
 }
 export declare namespace optional_aggregator {
     interface Integer {
@@ -3451,6 +3896,12 @@ export declare namespace optional_aggregator {
         function type(): TypeDescriptor<OptionalAggregator>;
     }
 }
+export declare class transaction_context extends AptosBaseProcessor {
+    constructor(options: AptosBindOptions);
+    static DEFAULT_OPTIONS: AptosBindOptions;
+    static bind(options?: Partial<AptosBindOptions>): transaction_context;
+    onEventAUID(func: (event: transaction_context.AUIDInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): transaction_context;
+}
 export declare namespace transaction_context {
     interface AUID {
         unique_address: Address;
@@ -3459,6 +3910,10 @@ export declare namespace transaction_context {
         const TYPE_QNAME = "0x1::transaction_context::AUID";
         function type(): TypeDescriptor<AUID>;
     }
+    interface AUIDInstance extends TypedEventInstance<AUID> {
+        data_decoded: AUID;
+        type_arguments: [];
+    }
 }
 export declare class primary_fungible_store extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);