@sentio/sdk 2.13.0-rc.7 → 2.13.0-rc.8

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

@@ -1,19 +1,25 @@
-import { CallFilter } from "@sentio/sdk/move";
+import { CallFilter, TypeDescriptor } from "@sentio/sdk/move";
 import { MoveCoder, AptosBindOptions, AptosBaseProcessor, TypedEventInstance, TypedFunctionPayload, AptosContext } from "@sentio/sdk/aptos";
 import { MoveFetchConfig } from "@sentio/protos";
 import { Address } from "@sentio/sdk/aptos";
 export declare namespace acl {
-    class ACL {
-        static TYPE_QNAME: string;
+    interface ACL {
         list: Address[];
     }
+    namespace ACL {
+        const TYPE_QNAME = "0x1::acl::ACL";
+        function type(): TypeDescriptor<ACL>;
+    }
 }
 export declare namespace any_ {
-    class Any {
-        static TYPE_QNAME: string;
+    interface Any {
         type_name: string;
         data: string;
     }
+    namespace Any {
+        const TYPE_QNAME = "0x1::any::Any";
+        function type(): TypeDescriptor<Any>;
+    }
 }
 export declare namespace bcs { }
 export declare class code extends AptosBaseProcessor {
@@ -23,25 +29,33 @@ export declare class code extends AptosBaseProcessor {
     onEntryPublishPackageTxn(func: (call: code.PublishPackageTxnPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): code;
 }
 export declare namespace code {
-    class AllowedDep {
-        static TYPE_QNAME: string;
+    interface AllowedDep {
         account: Address;
         module_name: string;
     }
-    class ModuleMetadata {
-        static TYPE_QNAME: string;
+    namespace AllowedDep {
+        const TYPE_QNAME = "0x1::code::AllowedDep";
+        function type(): TypeDescriptor<AllowedDep>;
+    }
+    interface ModuleMetadata {
         name: string;
         source: string;
         source_map: string;
         extension: option.Option<copyable_any.Any>;
     }
-    class PackageDep {
-        static TYPE_QNAME: string;
+    namespace ModuleMetadata {
+        const TYPE_QNAME = "0x1::code::ModuleMetadata";
+        function type(): TypeDescriptor<ModuleMetadata>;
+    }
+    interface PackageDep {
         account: Address;
         package_name: string;
     }
-    class PackageMetadata {
-        static TYPE_QNAME: string;
+    namespace PackageDep {
+        const TYPE_QNAME = "0x1::code::PackageDep";
+        function type(): TypeDescriptor<PackageDep>;
+    }
+    interface PackageMetadata {
         name: string;
         upgrade_policy: code.UpgradePolicy;
         upgrade_number: bigint;
@@ -51,14 +65,24 @@ export declare namespace code {
         deps: code.PackageDep[];
         extension: option.Option<copyable_any.Any>;
     }
-    class PackageRegistry {
-        static TYPE_QNAME: string;
+    namespace PackageMetadata {
+        const TYPE_QNAME = "0x1::code::PackageMetadata";
+        function type(): TypeDescriptor<PackageMetadata>;
+    }
+    interface PackageRegistry {
         packages: code.PackageMetadata[];
     }
-    class UpgradePolicy {
-        static TYPE_QNAME: string;
+    namespace PackageRegistry {
+        const TYPE_QNAME = "0x1::code::PackageRegistry";
+        function type(): TypeDescriptor<PackageRegistry>;
+    }
+    interface UpgradePolicy {
         policy: number;
     }
+    namespace UpgradePolicy {
+        const TYPE_QNAME = "0x1::code::UpgradePolicy";
+        function type(): TypeDescriptor<UpgradePolicy>;
+    }
     interface PublishPackageTxnPayload extends TypedFunctionPayload<[string, string[]]> {
         arguments_decoded: [string, string[]];
         type_arguments: [];
@@ -76,56 +100,86 @@ export declare class coin extends AptosBaseProcessor {
     onEventWithdrawEvent(func: (event: coin.WithdrawEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): coin;
 }
 export declare namespace coin {
-    class AggregatableCoin<T0> {
-        static TYPE_QNAME: string;
+    interface AggregatableCoin<T0> {
         value: aggregator.Aggregator;
     }
-    class BurnCapability<T0> {
-        static TYPE_QNAME: string;
+    namespace AggregatableCoin {
+        const TYPE_QNAME = "0x1::coin::AggregatableCoin";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<AggregatableCoin<T0>>;
+    }
+    interface BurnCapability<T0> {
         dummy_field: Boolean;
     }
-    class Coin<T0> {
-        static TYPE_QNAME: string;
+    namespace BurnCapability {
+        const TYPE_QNAME = "0x1::coin::BurnCapability";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<BurnCapability<T0>>;
+    }
+    interface Coin<T0> {
         value: bigint;
     }
-    class CoinInfo<T0> {
-        static TYPE_QNAME: string;
+    namespace Coin {
+        const TYPE_QNAME = "0x1::coin::Coin";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Coin<T0>>;
+    }
+    interface CoinInfo<T0> {
         name: string;
         symbol: string;
         decimals: number;
         supply: option.Option<optional_aggregator.OptionalAggregator>;
     }
-    class CoinStore<T0> {
-        static TYPE_QNAME: string;
+    namespace CoinInfo {
+        const TYPE_QNAME = "0x1::coin::CoinInfo";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<CoinInfo<T0>>;
+    }
+    interface CoinStore<T0> {
         coin: coin.Coin<T0>;
         frozen: Boolean;
         deposit_events: event.EventHandle<coin.DepositEvent>;
         withdraw_events: event.EventHandle<coin.WithdrawEvent>;
     }
-    class DepositEvent {
-        static TYPE_QNAME: string;
+    namespace CoinStore {
+        const TYPE_QNAME = "0x1::coin::CoinStore";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<CoinStore<T0>>;
+    }
+    interface DepositEvent {
         amount: bigint;
     }
+    namespace DepositEvent {
+        const TYPE_QNAME = "0x1::coin::DepositEvent";
+        function type(): TypeDescriptor<DepositEvent>;
+    }
     interface DepositEventInstance extends TypedEventInstance<DepositEvent> {
         data_decoded: DepositEvent;
         type_arguments: [];
     }
-    class FreezeCapability<T0> {
-        static TYPE_QNAME: string;
+    interface FreezeCapability<T0> {
         dummy_field: Boolean;
     }
-    class MintCapability<T0> {
-        static TYPE_QNAME: string;
+    namespace FreezeCapability {
+        const TYPE_QNAME = "0x1::coin::FreezeCapability";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<FreezeCapability<T0>>;
+    }
+    interface MintCapability<T0> {
         dummy_field: Boolean;
     }
-    class SupplyConfig {
-        static TYPE_QNAME: string;
+    namespace MintCapability {
+        const TYPE_QNAME = "0x1::coin::MintCapability";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<MintCapability<T0>>;
+    }
+    interface SupplyConfig {
         allow_upgrades: Boolean;
     }
-    class WithdrawEvent {
-        static TYPE_QNAME: string;
+    namespace SupplyConfig {
+        const TYPE_QNAME = "0x1::coin::SupplyConfig";
+        function type(): TypeDescriptor<SupplyConfig>;
+    }
+    interface WithdrawEvent {
         amount: bigint;
     }
+    namespace WithdrawEvent {
+        const TYPE_QNAME = "0x1::coin::WithdrawEvent";
+        function type(): TypeDescriptor<WithdrawEvent>;
+    }
     interface WithdrawEventInstance extends TypedEventInstance<WithdrawEvent> {
         data_decoded: WithdrawEvent;
         type_arguments: [];
@@ -148,15 +202,21 @@ export declare namespace coin {
     }
 }
 export declare namespace guid {
-    class GUID {
-        static TYPE_QNAME: string;
+    interface GUID {
         id: guid.ID;
     }
-    class ID {
-        static TYPE_QNAME: string;
+    namespace GUID {
+        const TYPE_QNAME = "0x1::guid::GUID";
+        function type(): TypeDescriptor<GUID>;
+    }
+    interface ID {
         creation_num: bigint;
         addr: Address;
     }
+    namespace ID {
+        const TYPE_QNAME = "0x1::guid::ID";
+        function type(): TypeDescriptor<ID>;
+    }
 }
 export declare namespace hash { }
 export declare namespace util { }
@@ -168,15 +228,17 @@ export declare class block extends AptosBaseProcessor {
     onEventUpdateEpochIntervalEvent(func: (event: block.UpdateEpochIntervalEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): block;
 }
 export declare namespace block {
-    class BlockResource {
-        static TYPE_QNAME: string;
+    interface BlockResource {
         height: bigint;
         epoch_interval: bigint;
         new_block_events: event.EventHandle<block.NewBlockEvent>;
         update_epoch_interval_events: event.EventHandle<block.UpdateEpochIntervalEvent>;
     }
-    class NewBlockEvent {
-        static TYPE_QNAME: string;
+    namespace BlockResource {
+        const TYPE_QNAME = "0x1::block::BlockResource";
+        function type(): TypeDescriptor<BlockResource>;
+    }
+    interface NewBlockEvent {
         hash: Address;
         epoch: bigint;
         round: bigint;
@@ -186,15 +248,22 @@ export declare namespace block {
         failed_proposer_indices: bigint[];
         time_microseconds: bigint;
     }
+    namespace NewBlockEvent {
+        const TYPE_QNAME = "0x1::block::NewBlockEvent";
+        function type(): TypeDescriptor<NewBlockEvent>;
+    }
     interface NewBlockEventInstance extends TypedEventInstance<NewBlockEvent> {
         data_decoded: NewBlockEvent;
         type_arguments: [];
     }
-    class UpdateEpochIntervalEvent {
-        static TYPE_QNAME: string;
+    interface UpdateEpochIntervalEvent {
         old_epoch_interval: bigint;
         new_epoch_interval: bigint;
     }
+    namespace UpdateEpochIntervalEvent {
+        const TYPE_QNAME = "0x1::block::UpdateEpochIntervalEvent";
+        function type(): TypeDescriptor<UpdateEpochIntervalEvent>;
+    }
     interface UpdateEpochIntervalEventInstance extends TypedEventInstance<UpdateEpochIntervalEvent> {
         data_decoded: UpdateEpochIntervalEvent;
         type_arguments: [];
@@ -203,11 +272,14 @@ export declare namespace block {
 export declare namespace debug { }
 export declare namespace error { }
 export declare namespace event {
-    class EventHandle<T0> {
-        static TYPE_QNAME: string;
+    interface EventHandle<T0> {
         counter: bigint;
         guid: guid.GUID;
     }
+    namespace EventHandle {
+        const TYPE_QNAME = "0x1::event::EventHandle";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<EventHandle<T0>>;
+    }
 }
 export declare class stake extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -240,106 +312,144 @@ export declare class stake extends AptosBaseProcessor {
     onEventLeaveValidatorSetEvent(func: (event: stake.LeaveValidatorSetEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): stake;
 }
 export declare namespace stake {
-    class AddStakeEvent {
-        static TYPE_QNAME: string;
+    interface AddStakeEvent {
         pool_address: Address;
         amount_added: bigint;
     }
+    namespace AddStakeEvent {
+        const TYPE_QNAME = "0x1::stake::AddStakeEvent";
+        function type(): TypeDescriptor<AddStakeEvent>;
+    }
     interface AddStakeEventInstance extends TypedEventInstance<AddStakeEvent> {
         data_decoded: AddStakeEvent;
         type_arguments: [];
     }
-    class AllowedValidators {
-        static TYPE_QNAME: string;
+    interface AllowedValidators {
         accounts: Address[];
     }
-    class AptosCoinCapabilities {
-        static TYPE_QNAME: string;
+    namespace AllowedValidators {
+        const TYPE_QNAME = "0x1::stake::AllowedValidators";
+        function type(): TypeDescriptor<AllowedValidators>;
+    }
+    interface AptosCoinCapabilities {
         mint_cap: coin.MintCapability<aptos_coin.AptosCoin>;
     }
-    class DistributeRewardsEvent {
-        static TYPE_QNAME: string;
+    namespace AptosCoinCapabilities {
+        const TYPE_QNAME = "0x1::stake::AptosCoinCapabilities";
+        function type(): TypeDescriptor<AptosCoinCapabilities>;
+    }
+    interface DistributeRewardsEvent {
         pool_address: Address;
         rewards_amount: bigint;
     }
+    namespace DistributeRewardsEvent {
+        const TYPE_QNAME = "0x1::stake::DistributeRewardsEvent";
+        function type(): TypeDescriptor<DistributeRewardsEvent>;
+    }
     interface DistributeRewardsEventInstance extends TypedEventInstance<DistributeRewardsEvent> {
         data_decoded: DistributeRewardsEvent;
         type_arguments: [];
     }
-    class IncreaseLockupEvent {
-        static TYPE_QNAME: string;
+    interface IncreaseLockupEvent {
         pool_address: Address;
         old_locked_until_secs: bigint;
         new_locked_until_secs: bigint;
     }
+    namespace IncreaseLockupEvent {
+        const TYPE_QNAME = "0x1::stake::IncreaseLockupEvent";
+        function type(): TypeDescriptor<IncreaseLockupEvent>;
+    }
     interface IncreaseLockupEventInstance extends TypedEventInstance<IncreaseLockupEvent> {
         data_decoded: IncreaseLockupEvent;
         type_arguments: [];
     }
-    class IndividualValidatorPerformance {
-        static TYPE_QNAME: string;
+    interface IndividualValidatorPerformance {
         successful_proposals: bigint;
         failed_proposals: bigint;
     }
-    class JoinValidatorSetEvent {
-        static TYPE_QNAME: string;
+    namespace IndividualValidatorPerformance {
+        const TYPE_QNAME = "0x1::stake::IndividualValidatorPerformance";
+        function type(): TypeDescriptor<IndividualValidatorPerformance>;
+    }
+    interface JoinValidatorSetEvent {
         pool_address: Address;
     }
+    namespace JoinValidatorSetEvent {
+        const TYPE_QNAME = "0x1::stake::JoinValidatorSetEvent";
+        function type(): TypeDescriptor<JoinValidatorSetEvent>;
+    }
     interface JoinValidatorSetEventInstance extends TypedEventInstance<JoinValidatorSetEvent> {
         data_decoded: JoinValidatorSetEvent;
         type_arguments: [];
     }
-    class LeaveValidatorSetEvent {
-        static TYPE_QNAME: string;
+    interface LeaveValidatorSetEvent {
         pool_address: Address;
     }
+    namespace LeaveValidatorSetEvent {
+        const TYPE_QNAME = "0x1::stake::LeaveValidatorSetEvent";
+        function type(): TypeDescriptor<LeaveValidatorSetEvent>;
+    }
     interface LeaveValidatorSetEventInstance extends TypedEventInstance<LeaveValidatorSetEvent> {
         data_decoded: LeaveValidatorSetEvent;
         type_arguments: [];
     }
-    class OwnerCapability {
-        static TYPE_QNAME: string;
+    interface OwnerCapability {
         pool_address: Address;
     }
-    class ReactivateStakeEvent {
-        static TYPE_QNAME: string;
+    namespace OwnerCapability {
+        const TYPE_QNAME = "0x1::stake::OwnerCapability";
+        function type(): TypeDescriptor<OwnerCapability>;
+    }
+    interface ReactivateStakeEvent {
         pool_address: Address;
         amount: bigint;
     }
+    namespace ReactivateStakeEvent {
+        const TYPE_QNAME = "0x1::stake::ReactivateStakeEvent";
+        function type(): TypeDescriptor<ReactivateStakeEvent>;
+    }
     interface ReactivateStakeEventInstance extends TypedEventInstance<ReactivateStakeEvent> {
         data_decoded: ReactivateStakeEvent;
         type_arguments: [];
     }
-    class RegisterValidatorCandidateEvent {
-        static TYPE_QNAME: string;
+    interface RegisterValidatorCandidateEvent {
         pool_address: Address;
     }
+    namespace RegisterValidatorCandidateEvent {
+        const TYPE_QNAME = "0x1::stake::RegisterValidatorCandidateEvent";
+        function type(): TypeDescriptor<RegisterValidatorCandidateEvent>;
+    }
     interface RegisterValidatorCandidateEventInstance extends TypedEventInstance<RegisterValidatorCandidateEvent> {
         data_decoded: RegisterValidatorCandidateEvent;
         type_arguments: [];
     }
-    class RotateConsensusKeyEvent {
-        static TYPE_QNAME: string;
+    interface RotateConsensusKeyEvent {
         pool_address: Address;
         old_consensus_pubkey: string;
         new_consensus_pubkey: string;
     }
+    namespace RotateConsensusKeyEvent {
+        const TYPE_QNAME = "0x1::stake::RotateConsensusKeyEvent";
+        function type(): TypeDescriptor<RotateConsensusKeyEvent>;
+    }
     interface RotateConsensusKeyEventInstance extends TypedEventInstance<RotateConsensusKeyEvent> {
         data_decoded: RotateConsensusKeyEvent;
         type_arguments: [];
     }
-    class SetOperatorEvent {
-        static TYPE_QNAME: string;
+    interface SetOperatorEvent {
         pool_address: Address;
         old_operator: Address;
         new_operator: Address;
     }
+    namespace SetOperatorEvent {
+        const TYPE_QNAME = "0x1::stake::SetOperatorEvent";
+        function type(): TypeDescriptor<SetOperatorEvent>;
+    }
     interface SetOperatorEventInstance extends TypedEventInstance<SetOperatorEvent> {
         data_decoded: SetOperatorEvent;
         type_arguments: [];
     }
-    class StakePool {
-        static TYPE_QNAME: string;
+    interface StakePool {
         active: coin.Coin<aptos_coin.AptosCoin>;
         inactive: coin.Coin<aptos_coin.AptosCoin>;
         pending_active: coin.Coin<aptos_coin.AptosCoin>;
@@ -360,50 +470,71 @@ export declare namespace stake {
         withdraw_stake_events: event.EventHandle<stake.WithdrawStakeEvent>;
         leave_validator_set_events: event.EventHandle<stake.LeaveValidatorSetEvent>;
     }
-    class UnlockStakeEvent {
-        static TYPE_QNAME: string;
+    namespace StakePool {
+        const TYPE_QNAME = "0x1::stake::StakePool";
+        function type(): TypeDescriptor<StakePool>;
+    }
+    interface UnlockStakeEvent {
         pool_address: Address;
         amount_unlocked: bigint;
     }
+    namespace UnlockStakeEvent {
+        const TYPE_QNAME = "0x1::stake::UnlockStakeEvent";
+        function type(): TypeDescriptor<UnlockStakeEvent>;
+    }
     interface UnlockStakeEventInstance extends TypedEventInstance<UnlockStakeEvent> {
         data_decoded: UnlockStakeEvent;
         type_arguments: [];
     }
-    class UpdateNetworkAndFullnodeAddressesEvent {
-        static TYPE_QNAME: string;
+    interface UpdateNetworkAndFullnodeAddressesEvent {
         pool_address: Address;
         old_network_addresses: string;
         new_network_addresses: string;
         old_fullnode_addresses: string;
         new_fullnode_addresses: string;
     }
+    namespace UpdateNetworkAndFullnodeAddressesEvent {
+        const TYPE_QNAME = "0x1::stake::UpdateNetworkAndFullnodeAddressesEvent";
+        function type(): TypeDescriptor<UpdateNetworkAndFullnodeAddressesEvent>;
+    }
     interface UpdateNetworkAndFullnodeAddressesEventInstance extends TypedEventInstance<UpdateNetworkAndFullnodeAddressesEvent> {
         data_decoded: UpdateNetworkAndFullnodeAddressesEvent;
         type_arguments: [];
     }
-    class ValidatorConfig {
-        static TYPE_QNAME: string;
+    interface ValidatorConfig {
         consensus_pubkey: string;
         network_addresses: string;
         fullnode_addresses: string;
         validator_index: bigint;
     }
-    class ValidatorFees {
-        static TYPE_QNAME: string;
+    namespace ValidatorConfig {
+        const TYPE_QNAME = "0x1::stake::ValidatorConfig";
+        function type(): TypeDescriptor<ValidatorConfig>;
+    }
+    interface ValidatorFees {
         fees_table: table.Table<Address, coin.Coin<aptos_coin.AptosCoin>>;
     }
-    class ValidatorInfo {
-        static TYPE_QNAME: string;
+    namespace ValidatorFees {
+        const TYPE_QNAME = "0x1::stake::ValidatorFees";
+        function type(): TypeDescriptor<ValidatorFees>;
+    }
+    interface ValidatorInfo {
         addr: Address;
         voting_power: bigint;
         config: stake.ValidatorConfig;
     }
-    class ValidatorPerformance {
-        static TYPE_QNAME: string;
+    namespace ValidatorInfo {
+        const TYPE_QNAME = "0x1::stake::ValidatorInfo";
+        function type(): TypeDescriptor<ValidatorInfo>;
+    }
+    interface ValidatorPerformance {
         validators: stake.IndividualValidatorPerformance[];
     }
-    class ValidatorSet {
-        static TYPE_QNAME: string;
+    namespace ValidatorPerformance {
+        const TYPE_QNAME = "0x1::stake::ValidatorPerformance";
+        function type(): TypeDescriptor<ValidatorPerformance>;
+    }
+    interface ValidatorSet {
         consensus_scheme: number;
         active_validators: stake.ValidatorInfo[];
         pending_inactive: stake.ValidatorInfo[];
@@ -411,11 +542,18 @@ export declare namespace stake {
         total_voting_power: bigint;
         total_joining_power: bigint;
     }
-    class WithdrawStakeEvent {
-        static TYPE_QNAME: string;
+    namespace ValidatorSet {
+        const TYPE_QNAME = "0x1::stake::ValidatorSet";
+        function type(): TypeDescriptor<ValidatorSet>;
+    }
+    interface WithdrawStakeEvent {
         pool_address: Address;
         amount_withdrawn: bigint;
     }
+    namespace WithdrawStakeEvent {
+        const TYPE_QNAME = "0x1::stake::WithdrawStakeEvent";
+        function type(): TypeDescriptor<WithdrawStakeEvent>;
+    }
     interface WithdrawStakeEventInstance extends TypedEventInstance<WithdrawStakeEvent> {
         data_decoded: WithdrawStakeEvent;
         type_arguments: [];
@@ -474,14 +612,20 @@ export declare namespace stake {
     }
 }
 export declare namespace table {
-    class Box<T0> {
-        static TYPE_QNAME: string;
+    interface Box<T0> {
         val: T0;
     }
-    class Table<T0, T1> {
-        static TYPE_QNAME: string;
+    namespace Box {
+        const TYPE_QNAME = "0x1::table::Box";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Box<T0>>;
+    }
+    interface Table<T0, T1> {
         handle: Address;
     }
+    namespace Table {
+        const TYPE_QNAME = "0x1::table::Table";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Table<T0, T1>>;
+    }
 }
 export declare namespace math64 { }
 export declare class object_ extends AptosBaseProcessor {
@@ -492,70 +636,103 @@ export declare class object_ extends AptosBaseProcessor {
     onEventTransferEvent(func: (event: object_.TransferEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): object_;
 }
 export declare namespace object_ {
-    class ConstructorRef {
-        static TYPE_QNAME: string;
+    interface ConstructorRef {
         self: Address;
         can_delete: Boolean;
     }
-    class DeleteRef {
-        static TYPE_QNAME: string;
+    namespace ConstructorRef {
+        const TYPE_QNAME = "0x1::object::ConstructorRef";
+        function type(): TypeDescriptor<ConstructorRef>;
+    }
+    interface DeleteRef {
         self: Address;
     }
-    class ExtendRef {
-        static TYPE_QNAME: string;
+    namespace DeleteRef {
+        const TYPE_QNAME = "0x1::object::DeleteRef";
+        function type(): TypeDescriptor<DeleteRef>;
+    }
+    interface ExtendRef {
         self: Address;
     }
-    class LinearTransferRef {
-        static TYPE_QNAME: string;
+    namespace ExtendRef {
+        const TYPE_QNAME = "0x1::object::ExtendRef";
+        function type(): TypeDescriptor<ExtendRef>;
+    }
+    interface LinearTransferRef {
         self: Address;
         owner: Address;
     }
-    class Object<T0> {
-        static TYPE_QNAME: string;
+    namespace LinearTransferRef {
+        const TYPE_QNAME = "0x1::object::LinearTransferRef";
+        function type(): TypeDescriptor<LinearTransferRef>;
+    }
+    interface Object<T0> {
         inner: Address;
     }
-    class ObjectCore {
-        static TYPE_QNAME: string;
+    namespace Object {
+        const TYPE_QNAME = "0x1::object::Object";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Object<T0>>;
+    }
+    interface ObjectCore {
         guid_creation_num: bigint;
         owner: Address;
         allow_ungated_transfer: Boolean;
         transfer_events: event.EventHandle<object_.TransferEvent>;
     }
-    class ObjectGroup {
-        static TYPE_QNAME: string;
+    namespace ObjectCore {
+        const TYPE_QNAME = "0x1::object::ObjectCore";
+        function type(): TypeDescriptor<ObjectCore>;
+    }
+    interface ObjectGroup {
         dummy_field: Boolean;
     }
-    class TransferEvent {
-        static TYPE_QNAME: string;
+    namespace ObjectGroup {
+        const TYPE_QNAME = "0x1::object::ObjectGroup";
+        function type(): TypeDescriptor<ObjectGroup>;
+    }
+    interface TransferEvent {
         object: Address;
         from: Address;
         to: Address;
     }
+    namespace TransferEvent {
+        const TYPE_QNAME = "0x1::object::TransferEvent";
+        function type(): TypeDescriptor<TransferEvent>;
+    }
     interface TransferEventInstance extends TypedEventInstance<TransferEvent> {
         data_decoded: TransferEvent;
         type_arguments: [];
     }
-    class TransferRef {
-        static TYPE_QNAME: string;
+    interface TransferRef {
         self: Address;
     }
+    namespace TransferRef {
+        const TYPE_QNAME = "0x1::object::TransferRef";
+        function type(): TypeDescriptor<TransferRef>;
+    }
     interface TransferCallPayload extends TypedFunctionPayload<[Address, Address]> {
         arguments_decoded: [Address, Address];
         type_arguments: [];
     }
 }
 export declare namespace option {
-    class Option<T0> {
-        static TYPE_QNAME: string;
+    interface Option<T0> {
         vec: T0[] | string;
     }
+    namespace Option {
+        const TYPE_QNAME = "0x1::option::Option";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Option<T0>>;
+    }
 }
 export declare namespace signer { }
 export declare namespace string_ {
-    class String {
-        static TYPE_QNAME: string;
+    interface String {
         bytes: string;
     }
+    namespace String {
+        const TYPE_QNAME = "0x1::string::String";
+        function type(): TypeDescriptor<String>;
+    }
 }
 export declare namespace vector { }
 export declare class voting extends AptosBaseProcessor {
@@ -568,8 +745,7 @@ export declare class voting extends AptosBaseProcessor {
     onEventVoteEvent(func: (event: voting.VoteEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): voting;
 }
 export declare namespace voting {
-    class CreateProposalEvent {
-        static TYPE_QNAME: string;
+    interface CreateProposalEvent {
         proposal_id: bigint;
         early_resolution_vote_threshold: option.Option<bigint>;
         execution_hash: string;
@@ -577,12 +753,15 @@ export declare namespace voting {
         metadata: simple_map.SimpleMap<string, string>;
         min_vote_threshold: bigint;
     }
+    namespace CreateProposalEvent {
+        const TYPE_QNAME = "0x1::voting::CreateProposalEvent";
+        function type(): TypeDescriptor<CreateProposalEvent>;
+    }
     interface CreateProposalEventInstance extends TypedEventInstance<CreateProposalEvent> {
         data_decoded: CreateProposalEvent;
         type_arguments: [];
     }
-    class Proposal<T0> {
-        static TYPE_QNAME: string;
+    interface Proposal<T0> {
         proposer: Address;
         execution_content: option.Option<T0>;
         metadata: simple_map.SimpleMap<string, string>;
@@ -596,48 +775,67 @@ export declare namespace voting {
         is_resolved: Boolean;
         resolution_time_secs: bigint;
     }
-    class RegisterForumEvent {
-        static TYPE_QNAME: string;
+    namespace Proposal {
+        const TYPE_QNAME = "0x1::voting::Proposal";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Proposal<T0>>;
+    }
+    interface RegisterForumEvent {
         hosting_account: Address;
         proposal_type_info: type_info.TypeInfo;
     }
+    namespace RegisterForumEvent {
+        const TYPE_QNAME = "0x1::voting::RegisterForumEvent";
+        function type(): TypeDescriptor<RegisterForumEvent>;
+    }
     interface RegisterForumEventInstance extends TypedEventInstance<RegisterForumEvent> {
         data_decoded: RegisterForumEvent;
         type_arguments: [];
     }
-    class ResolveProposal {
-        static TYPE_QNAME: string;
+    interface ResolveProposal {
         proposal_id: bigint;
         yes_votes: bigint;
         no_votes: bigint;
         resolved_early: Boolean;
     }
+    namespace ResolveProposal {
+        const TYPE_QNAME = "0x1::voting::ResolveProposal";
+        function type(): TypeDescriptor<ResolveProposal>;
+    }
     interface ResolveProposalInstance extends TypedEventInstance<ResolveProposal> {
         data_decoded: ResolveProposal;
         type_arguments: [];
     }
-    class VoteEvent {
-        static TYPE_QNAME: string;
+    interface VoteEvent {
         proposal_id: bigint;
         num_votes: bigint;
     }
+    namespace VoteEvent {
+        const TYPE_QNAME = "0x1::voting::VoteEvent";
+        function type(): TypeDescriptor<VoteEvent>;
+    }
     interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
         data_decoded: VoteEvent;
         type_arguments: [];
     }
-    class VotingEvents {
-        static TYPE_QNAME: string;
+    interface VotingEvents {
         create_proposal_events: event.EventHandle<voting.CreateProposalEvent>;
         register_forum_events: event.EventHandle<voting.RegisterForumEvent>;
         resolve_proposal_events: event.EventHandle<voting.ResolveProposal>;
         vote_events: event.EventHandle<voting.VoteEvent>;
     }
-    class VotingForum<T0> {
-        static TYPE_QNAME: string;
+    namespace VotingEvents {
+        const TYPE_QNAME = "0x1::voting::VotingEvents";
+        function type(): TypeDescriptor<VotingEvents>;
+    }
+    interface VotingForum<T0> {
         proposals: table.Table<bigint, voting.Proposal<T0>>;
         events: voting.VotingEvents;
         next_proposal_id: bigint;
     }
+    namespace VotingForum {
+        const TYPE_QNAME = "0x1::voting::VotingForum";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<VotingForum<T0>>;
+    }
 }
 export declare class account extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -655,8 +853,7 @@ export declare class account extends AptosBaseProcessor {
     onEventKeyRotationEvent(func: (event: account.KeyRotationEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): account;
 }
 export declare namespace account {
-    class Account {
-        static TYPE_QNAME: string;
+    interface Account {
         authentication_key: string;
         sequence_number: bigint;
         guid_creation_num: bigint;
@@ -665,69 +862,106 @@ export declare namespace account {
         rotation_capability_offer: account.CapabilityOffer<account.RotationCapability>;
         signer_capability_offer: account.CapabilityOffer<account.SignerCapability>;
     }
-    class CapabilityOffer<T0> {
-        static TYPE_QNAME: string;
+    namespace Account {
+        const TYPE_QNAME = "0x1::account::Account";
+        function type(): TypeDescriptor<Account>;
+    }
+    interface CapabilityOffer<T0> {
         for: option.Option<Address>;
     }
-    class CoinRegisterEvent {
-        static TYPE_QNAME: string;
+    namespace CapabilityOffer {
+        const TYPE_QNAME = "0x1::account::CapabilityOffer";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<CapabilityOffer<T0>>;
+    }
+    interface CoinRegisterEvent {
         type_info: type_info.TypeInfo;
     }
+    namespace CoinRegisterEvent {
+        const TYPE_QNAME = "0x1::account::CoinRegisterEvent";
+        function type(): TypeDescriptor<CoinRegisterEvent>;
+    }
     interface CoinRegisterEventInstance extends TypedEventInstance<CoinRegisterEvent> {
         data_decoded: CoinRegisterEvent;
         type_arguments: [];
     }
-    class KeyRotationEvent {
-        static TYPE_QNAME: string;
+    interface KeyRotationEvent {
         old_authentication_key: string;
         new_authentication_key: string;
     }
+    namespace KeyRotationEvent {
+        const TYPE_QNAME = "0x1::account::KeyRotationEvent";
+        function type(): TypeDescriptor<KeyRotationEvent>;
+    }
     interface KeyRotationEventInstance extends TypedEventInstance<KeyRotationEvent> {
         data_decoded: KeyRotationEvent;
         type_arguments: [];
     }
-    class OriginatingAddress {
-        static TYPE_QNAME: string;
+    interface OriginatingAddress {
         address_map: table.Table<Address, Address>;
     }
-    class RotationCapability {
-        static TYPE_QNAME: string;
+    namespace OriginatingAddress {
+        const TYPE_QNAME = "0x1::account::OriginatingAddress";
+        function type(): TypeDescriptor<OriginatingAddress>;
+    }
+    interface RotationCapability {
         account: Address;
     }
-    class RotationCapabilityOfferProofChallenge {
-        static TYPE_QNAME: string;
+    namespace RotationCapability {
+        const TYPE_QNAME = "0x1::account::RotationCapability";
+        function type(): TypeDescriptor<RotationCapability>;
+    }
+    interface RotationCapabilityOfferProofChallenge {
         sequence_number: bigint;
         recipient_address: Address;
     }
-    class RotationCapabilityOfferProofChallengeV2 {
-        static TYPE_QNAME: string;
+    namespace RotationCapabilityOfferProofChallenge {
+        const TYPE_QNAME = "0x1::account::RotationCapabilityOfferProofChallenge";
+        function type(): TypeDescriptor<RotationCapabilityOfferProofChallenge>;
+    }
+    interface RotationCapabilityOfferProofChallengeV2 {
         chain_id: number;
         sequence_number: bigint;
         source_address: Address;
         recipient_address: Address;
     }
-    class RotationProofChallenge {
-        static TYPE_QNAME: string;
+    namespace RotationCapabilityOfferProofChallengeV2 {
+        const TYPE_QNAME = "0x1::account::RotationCapabilityOfferProofChallengeV2";
+        function type(): TypeDescriptor<RotationCapabilityOfferProofChallengeV2>;
+    }
+    interface RotationProofChallenge {
         sequence_number: bigint;
         originator: Address;
         current_auth_key: Address;
         new_public_key: string;
     }
-    class SignerCapability {
-        static TYPE_QNAME: string;
+    namespace RotationProofChallenge {
+        const TYPE_QNAME = "0x1::account::RotationProofChallenge";
+        function type(): TypeDescriptor<RotationProofChallenge>;
+    }
+    interface SignerCapability {
         account: Address;
     }
-    class SignerCapabilityOfferProofChallenge {
-        static TYPE_QNAME: string;
+    namespace SignerCapability {
+        const TYPE_QNAME = "0x1::account::SignerCapability";
+        function type(): TypeDescriptor<SignerCapability>;
+    }
+    interface SignerCapabilityOfferProofChallenge {
         sequence_number: bigint;
         recipient_address: Address;
     }
-    class SignerCapabilityOfferProofChallengeV2 {
-        static TYPE_QNAME: string;
+    namespace SignerCapabilityOfferProofChallenge {
+        const TYPE_QNAME = "0x1::account::SignerCapabilityOfferProofChallenge";
+        function type(): TypeDescriptor<SignerCapabilityOfferProofChallenge>;
+    }
+    interface SignerCapabilityOfferProofChallengeV2 {
         sequence_number: bigint;
         source_address: Address;
         recipient_address: Address;
     }
+    namespace SignerCapabilityOfferProofChallengeV2 {
+        const TYPE_QNAME = "0x1::account::SignerCapabilityOfferProofChallengeV2";
+        function type(): TypeDescriptor<SignerCapabilityOfferProofChallengeV2>;
+    }
     interface OfferRotationCapabilityPayload extends TypedFunctionPayload<[string, number, string, Address]> {
         arguments_decoded: [string, number, string, Address];
         type_arguments: [];
@@ -769,40 +1003,57 @@ export declare namespace account {
     }
 }
 export declare namespace ed25519 {
-    class Signature {
-        static TYPE_QNAME: string;
+    interface Signature {
         bytes: string;
     }
-    class SignedMessage<T0> {
-        static TYPE_QNAME: string;
+    namespace Signature {
+        const TYPE_QNAME = "0x1::ed25519::Signature";
+        function type(): TypeDescriptor<Signature>;
+    }
+    interface SignedMessage<T0> {
         type_info: type_info.TypeInfo;
         inner: T0;
     }
-    class UnvalidatedPublicKey {
-        static TYPE_QNAME: string;
+    namespace SignedMessage {
+        const TYPE_QNAME = "0x1::ed25519::SignedMessage";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<SignedMessage<T0>>;
+    }
+    interface UnvalidatedPublicKey {
         bytes: string;
     }
-    class ValidatedPublicKey {
-        static TYPE_QNAME: string;
+    namespace UnvalidatedPublicKey {
+        const TYPE_QNAME = "0x1::ed25519::UnvalidatedPublicKey";
+        function type(): TypeDescriptor<UnvalidatedPublicKey>;
+    }
+    interface ValidatedPublicKey {
         bytes: string;
     }
+    namespace ValidatedPublicKey {
+        const TYPE_QNAME = "0x1::ed25519::ValidatedPublicKey";
+        function type(): TypeDescriptor<ValidatedPublicKey>;
+    }
 }
 export declare namespace genesis {
-    class AccountMap {
-        static TYPE_QNAME: string;
+    interface AccountMap {
         account_address: Address;
         balance: bigint;
     }
-    class EmployeeAccountMap {
-        static TYPE_QNAME: string;
+    namespace AccountMap {
+        const TYPE_QNAME = "0x1::genesis::AccountMap";
+        function type(): TypeDescriptor<AccountMap>;
+    }
+    interface EmployeeAccountMap {
         accounts: Address[];
         validator: genesis.ValidatorConfigurationWithCommission;
         vesting_schedule_numerator: bigint[];
         vesting_schedule_denominator: bigint;
         beneficiary_resetter: Address;
     }
-    class ValidatorConfiguration {
-        static TYPE_QNAME: string;
+    namespace EmployeeAccountMap {
+        const TYPE_QNAME = "0x1::genesis::EmployeeAccountMap";
+        function type(): TypeDescriptor<EmployeeAccountMap>;
+    }
+    interface ValidatorConfiguration {
         owner_address: Address;
         operator_address: Address;
         voter_address: Address;
@@ -812,12 +1063,19 @@ export declare namespace genesis {
         network_addresses: string;
         full_node_network_addresses: string;
     }
-    class ValidatorConfigurationWithCommission {
-        static TYPE_QNAME: string;
+    namespace ValidatorConfiguration {
+        const TYPE_QNAME = "0x1::genesis::ValidatorConfiguration";
+        function type(): TypeDescriptor<ValidatorConfiguration>;
+    }
+    interface ValidatorConfigurationWithCommission {
         validator_config: genesis.ValidatorConfiguration;
         commission_percentage: bigint;
         join_during_genesis: Boolean;
     }
+    namespace ValidatorConfigurationWithCommission {
+        const TYPE_QNAME = "0x1::genesis::ValidatorConfigurationWithCommission";
+        function type(): TypeDescriptor<ValidatorConfigurationWithCommission>;
+    }
 }
 export declare namespace math128 { }
 export declare class version extends AptosBaseProcessor {
@@ -827,14 +1085,20 @@ export declare class version extends AptosBaseProcessor {
     onEntrySetVersion(func: (call: version.SetVersionPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): version;
 }
 export declare namespace version {
-    class SetVersionCapability {
-        static TYPE_QNAME: string;
+    interface SetVersionCapability {
         dummy_field: Boolean;
     }
-    class Version {
-        static TYPE_QNAME: string;
+    namespace SetVersionCapability {
+        const TYPE_QNAME = "0x1::version::SetVersionCapability";
+        function type(): TypeDescriptor<SetVersionCapability>;
+    }
+    interface Version {
         major: bigint;
     }
+    namespace Version {
+        const TYPE_QNAME = "0x1::version::Version";
+        function type(): TypeDescriptor<Version>;
+    }
     interface SetVersionPayload extends TypedFunctionPayload<[bigint]> {
         arguments_decoded: [bigint];
         type_arguments: [];
@@ -872,24 +1136,29 @@ export declare class vesting extends AptosBaseProcessor {
     onEventAdminWithdrawEvent(func: (event: vesting.AdminWithdrawEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vesting;
 }
 export declare namespace vesting {
-    class AdminStore {
-        static TYPE_QNAME: string;
+    interface AdminStore {
         vesting_contracts: Address[];
         nonce: bigint;
         create_events: event.EventHandle<vesting.CreateVestingContractEvent>;
     }
-    class AdminWithdrawEvent {
-        static TYPE_QNAME: string;
+    namespace AdminStore {
+        const TYPE_QNAME = "0x1::vesting::AdminStore";
+        function type(): TypeDescriptor<AdminStore>;
+    }
+    interface AdminWithdrawEvent {
         admin: Address;
         vesting_contract_address: Address;
         amount: bigint;
     }
+    namespace AdminWithdrawEvent {
+        const TYPE_QNAME = "0x1::vesting::AdminWithdrawEvent";
+        function type(): TypeDescriptor<AdminWithdrawEvent>;
+    }
     interface AdminWithdrawEventInstance extends TypedEventInstance<AdminWithdrawEvent> {
         data_decoded: AdminWithdrawEvent;
         type_arguments: [];
     }
-    class CreateVestingContractEvent {
-        static TYPE_QNAME: string;
+    interface CreateVestingContractEvent {
         operator: Address;
         voter: Address;
         grant_amount: bigint;
@@ -898,72 +1167,93 @@ export declare namespace vesting {
         staking_pool_address: Address;
         commission_percentage: bigint;
     }
+    namespace CreateVestingContractEvent {
+        const TYPE_QNAME = "0x1::vesting::CreateVestingContractEvent";
+        function type(): TypeDescriptor<CreateVestingContractEvent>;
+    }
     interface CreateVestingContractEventInstance extends TypedEventInstance<CreateVestingContractEvent> {
         data_decoded: CreateVestingContractEvent;
         type_arguments: [];
     }
-    class DistributeEvent {
-        static TYPE_QNAME: string;
+    interface DistributeEvent {
         admin: Address;
         vesting_contract_address: Address;
         amount: bigint;
     }
+    namespace DistributeEvent {
+        const TYPE_QNAME = "0x1::vesting::DistributeEvent";
+        function type(): TypeDescriptor<DistributeEvent>;
+    }
     interface DistributeEventInstance extends TypedEventInstance<DistributeEvent> {
         data_decoded: DistributeEvent;
         type_arguments: [];
     }
-    class ResetLockupEvent {
-        static TYPE_QNAME: string;
+    interface ResetLockupEvent {
         admin: Address;
         vesting_contract_address: Address;
         staking_pool_address: Address;
         new_lockup_expiration_secs: bigint;
     }
+    namespace ResetLockupEvent {
+        const TYPE_QNAME = "0x1::vesting::ResetLockupEvent";
+        function type(): TypeDescriptor<ResetLockupEvent>;
+    }
     interface ResetLockupEventInstance extends TypedEventInstance<ResetLockupEvent> {
         data_decoded: ResetLockupEvent;
         type_arguments: [];
     }
-    class SetBeneficiaryEvent {
-        static TYPE_QNAME: string;
+    interface SetBeneficiaryEvent {
         admin: Address;
         vesting_contract_address: Address;
         shareholder: Address;
         old_beneficiary: Address;
         new_beneficiary: Address;
     }
+    namespace SetBeneficiaryEvent {
+        const TYPE_QNAME = "0x1::vesting::SetBeneficiaryEvent";
+        function type(): TypeDescriptor<SetBeneficiaryEvent>;
+    }
     interface SetBeneficiaryEventInstance extends TypedEventInstance<SetBeneficiaryEvent> {
         data_decoded: SetBeneficiaryEvent;
         type_arguments: [];
     }
-    class StakingInfo {
-        static TYPE_QNAME: string;
+    interface StakingInfo {
         pool_address: Address;
         operator: Address;
         voter: Address;
         commission_percentage: bigint;
     }
-    class TerminateEvent {
-        static TYPE_QNAME: string;
+    namespace StakingInfo {
+        const TYPE_QNAME = "0x1::vesting::StakingInfo";
+        function type(): TypeDescriptor<StakingInfo>;
+    }
+    interface TerminateEvent {
         admin: Address;
         vesting_contract_address: Address;
     }
+    namespace TerminateEvent {
+        const TYPE_QNAME = "0x1::vesting::TerminateEvent";
+        function type(): TypeDescriptor<TerminateEvent>;
+    }
     interface TerminateEventInstance extends TypedEventInstance<TerminateEvent> {
         data_decoded: TerminateEvent;
         type_arguments: [];
     }
-    class UnlockRewardsEvent {
-        static TYPE_QNAME: string;
+    interface UnlockRewardsEvent {
         admin: Address;
         vesting_contract_address: Address;
         staking_pool_address: Address;
         amount: bigint;
     }
+    namespace UnlockRewardsEvent {
+        const TYPE_QNAME = "0x1::vesting::UnlockRewardsEvent";
+        function type(): TypeDescriptor<UnlockRewardsEvent>;
+    }
     interface UnlockRewardsEventInstance extends TypedEventInstance<UnlockRewardsEvent> {
         data_decoded: UnlockRewardsEvent;
         type_arguments: [];
     }
-    class UpdateOperatorEvent {
-        static TYPE_QNAME: string;
+    interface UpdateOperatorEvent {
         admin: Address;
         vesting_contract_address: Address;
         staking_pool_address: Address;
@@ -971,40 +1261,52 @@ export declare namespace vesting {
         new_operator: Address;
         commission_percentage: bigint;
     }
+    namespace UpdateOperatorEvent {
+        const TYPE_QNAME = "0x1::vesting::UpdateOperatorEvent";
+        function type(): TypeDescriptor<UpdateOperatorEvent>;
+    }
     interface UpdateOperatorEventInstance extends TypedEventInstance<UpdateOperatorEvent> {
         data_decoded: UpdateOperatorEvent;
         type_arguments: [];
     }
-    class UpdateVoterEvent {
-        static TYPE_QNAME: string;
+    interface UpdateVoterEvent {
         admin: Address;
         vesting_contract_address: Address;
         staking_pool_address: Address;
         old_voter: Address;
         new_voter: Address;
     }
+    namespace UpdateVoterEvent {
+        const TYPE_QNAME = "0x1::vesting::UpdateVoterEvent";
+        function type(): TypeDescriptor<UpdateVoterEvent>;
+    }
     interface UpdateVoterEventInstance extends TypedEventInstance<UpdateVoterEvent> {
         data_decoded: UpdateVoterEvent;
         type_arguments: [];
     }
-    class VestEvent {
-        static TYPE_QNAME: string;
+    interface VestEvent {
         admin: Address;
         vesting_contract_address: Address;
         staking_pool_address: Address;
         period_vested: bigint;
         amount: bigint;
     }
+    namespace VestEvent {
+        const TYPE_QNAME = "0x1::vesting::VestEvent";
+        function type(): TypeDescriptor<VestEvent>;
+    }
     interface VestEventInstance extends TypedEventInstance<VestEvent> {
         data_decoded: VestEvent;
         type_arguments: [];
     }
-    class VestingAccountManagement {
-        static TYPE_QNAME: string;
+    interface VestingAccountManagement {
         roles: simple_map.SimpleMap<string, Address>;
     }
-    class VestingContract {
-        static TYPE_QNAME: string;
+    namespace VestingAccountManagement {
+        const TYPE_QNAME = "0x1::vesting::VestingAccountManagement";
+        function type(): TypeDescriptor<VestingAccountManagement>;
+    }
+    interface VestingContract {
         state: bigint;
         admin: Address;
         grant_pool: pool_u64.Pool;
@@ -1024,13 +1326,20 @@ export declare namespace vesting {
         terminate_events: event.EventHandle<vesting.TerminateEvent>;
         admin_withdraw_events: event.EventHandle<vesting.AdminWithdrawEvent>;
     }
-    class VestingSchedule {
-        static TYPE_QNAME: string;
+    namespace VestingContract {
+        const TYPE_QNAME = "0x1::vesting::VestingContract";
+        function type(): TypeDescriptor<VestingContract>;
+    }
+    interface VestingSchedule {
         schedule: fixed_point32.FixedPoint32[];
         start_timestamp_secs: bigint;
         period_duration: bigint;
         last_vested_period: bigint;
     }
+    namespace VestingSchedule {
+        const TYPE_QNAME = "0x1::vesting::VestingSchedule";
+        function type(): TypeDescriptor<VestingSchedule>;
+    }
     interface AdminWithdrawPayload extends TypedFunctionPayload<[Address]> {
         arguments_decoded: [Address];
         type_arguments: [];
@@ -1097,47 +1406,70 @@ export declare namespace vesting {
     }
 }
 export declare namespace bls12381 {
-    class AggrOrMultiSignature {
-        static TYPE_QNAME: string;
+    interface AggrOrMultiSignature {
         bytes: string;
     }
-    class AggrPublicKeysWithPoP {
-        static TYPE_QNAME: string;
+    namespace AggrOrMultiSignature {
+        const TYPE_QNAME = "0x1::bls12381::AggrOrMultiSignature";
+        function type(): TypeDescriptor<AggrOrMultiSignature>;
+    }
+    interface AggrPublicKeysWithPoP {
         bytes: string;
     }
-    class ProofOfPossession {
-        static TYPE_QNAME: string;
+    namespace AggrPublicKeysWithPoP {
+        const TYPE_QNAME = "0x1::bls12381::AggrPublicKeysWithPoP";
+        function type(): TypeDescriptor<AggrPublicKeysWithPoP>;
+    }
+    interface ProofOfPossession {
         bytes: string;
     }
-    class PublicKey {
-        static TYPE_QNAME: string;
+    namespace ProofOfPossession {
+        const TYPE_QNAME = "0x1::bls12381::ProofOfPossession";
+        function type(): TypeDescriptor<ProofOfPossession>;
+    }
+    interface PublicKey {
         bytes: string;
     }
-    class PublicKeyWithPoP {
-        static TYPE_QNAME: string;
+    namespace PublicKey {
+        const TYPE_QNAME = "0x1::bls12381::PublicKey";
+        function type(): TypeDescriptor<PublicKey>;
+    }
+    interface PublicKeyWithPoP {
         bytes: string;
     }
-    class Signature {
-        static TYPE_QNAME: string;
+    namespace PublicKeyWithPoP {
+        const TYPE_QNAME = "0x1::bls12381::PublicKeyWithPoP";
+        function type(): TypeDescriptor<PublicKeyWithPoP>;
+    }
+    interface Signature {
         bytes: string;
     }
+    namespace Signature {
+        const TYPE_QNAME = "0x1::bls12381::Signature";
+        function type(): TypeDescriptor<Signature>;
+    }
 }
 export declare namespace chain_id {
-    class ChainId {
-        static TYPE_QNAME: string;
+    interface ChainId {
         id: number;
     }
+    namespace ChainId {
+        const TYPE_QNAME = "0x1::chain_id::ChainId";
+        function type(): TypeDescriptor<ChainId>;
+    }
 }
 export declare namespace features {
-    class Features {
-        static TYPE_QNAME: string;
+    interface Features {
         features: string;
     }
+    namespace Features {
+        const TYPE_QNAME = "0x1::features::Features";
+        function type(): TypeDescriptor<Features>;
+    }
 }
 export declare namespace from_bcs { }
 export declare namespace pool_u64 {
-    class Pool {
-        static TYPE_QNAME: string;
+    interface Pool {
         shareholders_limit: bigint;
         total_coins: bigint;
         total_shares: bigint;
@@ -1145,38 +1477,57 @@ export declare namespace pool_u64 {
         shareholders: Address[];
         scaling_factor: bigint;
     }
+    namespace Pool {
+        const TYPE_QNAME = "0x1::pool_u64::Pool";
+        function type(): TypeDescriptor<Pool>;
+    }
 }
 export declare namespace secp256k1 {
-    class ECDSARawPublicKey {
-        static TYPE_QNAME: string;
+    interface ECDSARawPublicKey {
         bytes: string;
     }
-    class ECDSASignature {
-        static TYPE_QNAME: string;
+    namespace ECDSARawPublicKey {
+        const TYPE_QNAME = "0x1::secp256k1::ECDSARawPublicKey";
+        function type(): TypeDescriptor<ECDSARawPublicKey>;
+    }
+    interface ECDSASignature {
         bytes: string;
     }
+    namespace ECDSASignature {
+        const TYPE_QNAME = "0x1::secp256k1::ECDSASignature";
+        function type(): TypeDescriptor<ECDSASignature>;
+    }
 }
 export declare namespace timestamp {
-    class CurrentTimeMicroseconds {
-        static TYPE_QNAME: string;
+    interface CurrentTimeMicroseconds {
         microseconds: bigint;
     }
+    namespace CurrentTimeMicroseconds {
+        const TYPE_QNAME = "0x1::timestamp::CurrentTimeMicroseconds";
+        function type(): TypeDescriptor<CurrentTimeMicroseconds>;
+    }
 }
 export declare namespace type_info {
-    class TypeInfo {
-        static TYPE_QNAME: string;
+    interface TypeInfo {
         account_address: Address;
         module_name: string;
         struct_name: string;
     }
+    namespace TypeInfo {
+        const TYPE_QNAME = "0x1::type_info::TypeInfo";
+        function type(): TypeDescriptor<TypeInfo>;
+    }
 }
 export declare namespace aggregator {
-    class Aggregator {
-        static TYPE_QNAME: string;
+    interface Aggregator {
         handle: Address;
         key: Address;
         limit: bigint;
     }
+    namespace Aggregator {
+        const TYPE_QNAME = "0x1::aggregator::Aggregator";
+        function type(): TypeDescriptor<Aggregator>;
+    }
 }
 export declare class aptos_coin extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -1187,22 +1538,34 @@ export declare class aptos_coin extends AptosBaseProcessor {
     onEntryMint(func: (call: aptos_coin.MintPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): aptos_coin;
 }
 export declare namespace aptos_coin {
-    class AptosCoin {
-        static TYPE_QNAME: string;
+    interface AptosCoin {
         dummy_field: Boolean;
     }
-    class DelegatedMintCapability {
-        static TYPE_QNAME: string;
+    namespace AptosCoin {
+        const TYPE_QNAME = "0x1::aptos_coin::AptosCoin";
+        function type(): TypeDescriptor<AptosCoin>;
+    }
+    interface DelegatedMintCapability {
         to: Address;
     }
-    class Delegations {
-        static TYPE_QNAME: string;
+    namespace DelegatedMintCapability {
+        const TYPE_QNAME = "0x1::aptos_coin::DelegatedMintCapability";
+        function type(): TypeDescriptor<DelegatedMintCapability>;
+    }
+    interface Delegations {
         inner: aptos_coin.DelegatedMintCapability[];
     }
-    class MintCapStore {
-        static TYPE_QNAME: string;
+    namespace Delegations {
+        const TYPE_QNAME = "0x1::aptos_coin::Delegations";
+        function type(): TypeDescriptor<Delegations>;
+    }
+    interface MintCapStore {
         mint_cap: coin.MintCapability<aptos_coin.AptosCoin>;
     }
+    namespace MintCapStore {
+        const TYPE_QNAME = "0x1::aptos_coin::MintCapStore";
+        function type(): TypeDescriptor<MintCapStore>;
+    }
     interface ClaimMintCapabilityPayload extends TypedFunctionPayload<[]> {
         arguments_decoded: [];
         type_arguments: [];
@@ -1218,65 +1581,94 @@ export declare namespace aptos_coin {
 }
 export declare namespace aptos_hash { }
 export declare namespace big_vector {
-    class BigVector<T0> {
-        static TYPE_QNAME: string;
+    interface BigVector<T0> {
         buckets: table_with_length.TableWithLength<bigint, T0[] | string>;
         end_index: bigint;
         bucket_size: bigint;
     }
+    namespace BigVector {
+        const TYPE_QNAME = "0x1::big_vector::BigVector";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<BigVector<T0>>;
+    }
 }
 export declare namespace bit_vector {
-    class BitVector {
-        static TYPE_QNAME: string;
+    interface BitVector {
         length: bigint;
         bit_field: Boolean[];
     }
+    namespace BitVector {
+        const TYPE_QNAME = "0x1::bit_vector::BitVector";
+        function type(): TypeDescriptor<BitVector>;
+    }
 }
 export declare namespace capability {
-    class Cap<T0> {
-        static TYPE_QNAME: string;
+    interface Cap<T0> {
         root: Address;
     }
-    class CapDelegateState<T0> {
-        static TYPE_QNAME: string;
+    namespace Cap {
+        const TYPE_QNAME = "0x1::capability::Cap";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Cap<T0>>;
+    }
+    interface CapDelegateState<T0> {
         root: Address;
     }
-    class CapState<T0> {
-        static TYPE_QNAME: string;
+    namespace CapDelegateState {
+        const TYPE_QNAME = "0x1::capability::CapDelegateState";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<CapDelegateState<T0>>;
+    }
+    interface CapState<T0> {
         delegates: Address[];
     }
-    class LinearCap<T0> {
-        static TYPE_QNAME: string;
+    namespace CapState {
+        const TYPE_QNAME = "0x1::capability::CapState";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<CapState<T0>>;
+    }
+    interface LinearCap<T0> {
         root: Address;
     }
+    namespace LinearCap {
+        const TYPE_QNAME = "0x1::capability::LinearCap";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<LinearCap<T0>>;
+    }
 }
 export declare namespace comparator {
-    class Result {
-        static TYPE_QNAME: string;
+    interface Result {
         inner: number;
     }
+    namespace Result {
+        const TYPE_QNAME = "0x1::comparator::Result";
+        function type(): TypeDescriptor<Result>;
+    }
 }
 export declare namespace math_fixed { }
 export declare namespace simple_map {
-    class Element<T0, T1> {
-        static TYPE_QNAME: string;
+    interface Element<T0, T1> {
         key: T0;
         value: T1;
     }
-    class SimpleMap<T0, T1> {
-        static TYPE_QNAME: string;
+    namespace Element {
+        const TYPE_QNAME = "0x1::simple_map::Element";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Element<T0, T1>>;
+    }
+    interface SimpleMap<T0, T1> {
         data: simple_map.Element<T0, T1>[];
     }
+    namespace SimpleMap {
+        const TYPE_QNAME = "0x1::simple_map::SimpleMap";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<SimpleMap<T0, T1>>;
+    }
 }
 export declare namespace smart_table {
-    class Entry<T0, T1> {
-        static TYPE_QNAME: string;
+    interface Entry<T0, T1> {
         hash: bigint;
         key: T0;
         value: T1;
     }
-    class SmartTable<T0, T1> {
-        static TYPE_QNAME: string;
+    namespace Entry {
+        const TYPE_QNAME = "0x1::smart_table::Entry";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Entry<T0, T1>>;
+    }
+    interface SmartTable<T0, T1> {
         buckets: table_with_length.TableWithLength<bigint, smart_table.Entry<T0, T1>[]>;
         num_buckets: bigint;
         level: number;
@@ -1284,21 +1676,30 @@ export declare namespace smart_table {
         split_load_threshold: number;
         target_bucket_size: bigint;
     }
+    namespace SmartTable {
+        const TYPE_QNAME = "0x1::smart_table::SmartTable";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<SmartTable<T0, T1>>;
+    }
 }
 export declare namespace storage_gas {
-    class GasCurve {
-        static TYPE_QNAME: string;
+    interface GasCurve {
         min_gas: bigint;
         max_gas: bigint;
         points: storage_gas.Point[];
     }
-    class Point {
-        static TYPE_QNAME: string;
+    namespace GasCurve {
+        const TYPE_QNAME = "0x1::storage_gas::GasCurve";
+        function type(): TypeDescriptor<GasCurve>;
+    }
+    interface Point {
         x: bigint;
         y: bigint;
     }
-    class StorageGas {
-        static TYPE_QNAME: string;
+    namespace Point {
+        const TYPE_QNAME = "0x1::storage_gas::Point";
+        function type(): TypeDescriptor<Point>;
+    }
+    interface StorageGas {
         per_item_read: bigint;
         per_item_create: bigint;
         per_item_write: bigint;
@@ -1306,47 +1707,72 @@ export declare namespace storage_gas {
         per_byte_create: bigint;
         per_byte_write: bigint;
     }
-    class StorageGasConfig {
-        static TYPE_QNAME: string;
+    namespace StorageGas {
+        const TYPE_QNAME = "0x1::storage_gas::StorageGas";
+        function type(): TypeDescriptor<StorageGas>;
+    }
+    interface StorageGasConfig {
         item_config: storage_gas.UsageGasConfig;
         byte_config: storage_gas.UsageGasConfig;
     }
-    class UsageGasConfig {
-        static TYPE_QNAME: string;
+    namespace StorageGasConfig {
+        const TYPE_QNAME = "0x1::storage_gas::StorageGasConfig";
+        function type(): TypeDescriptor<StorageGasConfig>;
+    }
+    interface UsageGasConfig {
         target_usage: bigint;
         read_curve: storage_gas.GasCurve;
         create_curve: storage_gas.GasCurve;
         write_curve: storage_gas.GasCurve;
     }
+    namespace UsageGasConfig {
+        const TYPE_QNAME = "0x1::storage_gas::UsageGasConfig";
+        function type(): TypeDescriptor<UsageGasConfig>;
+    }
 }
 export declare namespace chain_status {
-    class GenesisEndMarker {
-        static TYPE_QNAME: string;
+    interface GenesisEndMarker {
         dummy_field: Boolean;
     }
+    namespace GenesisEndMarker {
+        const TYPE_QNAME = "0x1::chain_status::GenesisEndMarker";
+        function type(): TypeDescriptor<GenesisEndMarker>;
+    }
 }
 export declare namespace copyable_any {
-    class Any {
-        static TYPE_QNAME: string;
+    interface Any {
         type_name: string;
         data: string;
     }
+    namespace Any {
+        const TYPE_QNAME = "0x1::copyable_any::Any";
+        function type(): TypeDescriptor<Any>;
+    }
 }
 export declare namespace gas_schedule {
-    class GasEntry {
-        static TYPE_QNAME: string;
+    interface GasEntry {
         key: string;
         val: bigint;
     }
-    class GasSchedule {
-        static TYPE_QNAME: string;
+    namespace GasEntry {
+        const TYPE_QNAME = "0x1::gas_schedule::GasEntry";
+        function type(): TypeDescriptor<GasEntry>;
+    }
+    interface GasSchedule {
         entries: gas_schedule.GasEntry[];
     }
-    class GasScheduleV2 {
-        static TYPE_QNAME: string;
+    namespace GasSchedule {
+        const TYPE_QNAME = "0x1::gas_schedule::GasSchedule";
+        function type(): TypeDescriptor<GasSchedule>;
+    }
+    interface GasScheduleV2 {
         feature_version: bigint;
         entries: gas_schedule.GasEntry[];
     }
+    namespace GasScheduleV2 {
+        const TYPE_QNAME = "0x1::gas_schedule::GasScheduleV2";
+        function type(): TypeDescriptor<GasScheduleV2>;
+    }
 }
 export declare class managed_coin extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -1358,12 +1784,15 @@ export declare class managed_coin extends AptosBaseProcessor {
     onEntryRegister(func: (call: managed_coin.RegisterPayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): managed_coin;
 }
 export declare namespace managed_coin {
-    class Capabilities<T0> {
-        static TYPE_QNAME: string;
+    interface Capabilities<T0> {
         burn_cap: coin.BurnCapability<T0>;
         freeze_cap: coin.FreezeCapability<T0>;
         mint_cap: coin.MintCapability<T0>;
     }
+    namespace Capabilities {
+        const TYPE_QNAME = "0x1::managed_coin::Capabilities";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Capabilities<T0>>;
+    }
     interface BurnPayload<T0 = any> extends TypedFunctionPayload<[bigint]> {
         arguments_decoded: [bigint];
         type_arguments: [string];
@@ -1382,27 +1811,39 @@ export declare namespace managed_coin {
     }
 }
 export declare namespace ristretto255 {
-    class CompressedRistretto {
-        static TYPE_QNAME: string;
+    interface CompressedRistretto {
         data: string;
     }
-    class RistrettoPoint {
-        static TYPE_QNAME: string;
+    namespace CompressedRistretto {
+        const TYPE_QNAME = "0x1::ristretto255::CompressedRistretto";
+        function type(): TypeDescriptor<CompressedRistretto>;
+    }
+    interface RistrettoPoint {
         handle: bigint;
     }
-    class Scalar {
-        static TYPE_QNAME: string;
+    namespace RistrettoPoint {
+        const TYPE_QNAME = "0x1::ristretto255::RistrettoPoint";
+        function type(): TypeDescriptor<RistrettoPoint>;
+    }
+    interface Scalar {
         data: string;
     }
+    namespace Scalar {
+        const TYPE_QNAME = "0x1::ristretto255::Scalar";
+        function type(): TypeDescriptor<Scalar>;
+    }
 }
 export declare namespace smart_vector {
-    class SmartVector<T0> {
-        static TYPE_QNAME: string;
+    interface SmartVector<T0> {
         inline_vec: T0[] | string;
         big_vec: big_vector.BigVector<T0>[];
         inline_capacity: option.Option<bigint>;
         bucket_size: option.Option<bigint>;
     }
+    namespace SmartVector {
+        const TYPE_QNAME = "0x1::smart_vector::SmartVector";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<SmartVector<T0>>;
+    }
 }
 export declare class aptos_account extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -1417,19 +1858,25 @@ export declare class aptos_account extends AptosBaseProcessor {
     onEventDirectCoinTransferConfigUpdatedEvent(func: (event: aptos_account.DirectCoinTransferConfigUpdatedEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_account;
 }
 export declare namespace aptos_account {
-    class DirectCoinTransferConfigUpdatedEvent {
-        static TYPE_QNAME: string;
+    interface DirectCoinTransferConfigUpdatedEvent {
         new_allow_direct_transfers: Boolean;
     }
+    namespace DirectCoinTransferConfigUpdatedEvent {
+        const TYPE_QNAME = "0x1::aptos_account::DirectCoinTransferConfigUpdatedEvent";
+        function type(): TypeDescriptor<DirectCoinTransferConfigUpdatedEvent>;
+    }
     interface DirectCoinTransferConfigUpdatedEventInstance extends TypedEventInstance<DirectCoinTransferConfigUpdatedEvent> {
         data_decoded: DirectCoinTransferConfigUpdatedEvent;
         type_arguments: [];
     }
-    class DirectTransferConfig {
-        static TYPE_QNAME: string;
+    interface DirectTransferConfig {
         allow_arbitrary_coin_transfers: Boolean;
         update_coin_transfer_events: event.EventHandle<aptos_account.DirectCoinTransferConfigUpdatedEvent>;
     }
+    namespace DirectTransferConfig {
+        const TYPE_QNAME = "0x1::aptos_account::DirectTransferConfig";
+        function type(): TypeDescriptor<DirectTransferConfig>;
+    }
     interface BatchTransferPayload extends TypedFunctionPayload<[Address[], bigint[]]> {
         arguments_decoded: [Address[], bigint[]];
         type_arguments: [];
@@ -1457,24 +1904,36 @@ export declare namespace aptos_account {
 }
 export declare namespace create_signer { }
 export declare namespace fixed_point32 {
-    class FixedPoint32 {
-        static TYPE_QNAME: string;
+    interface FixedPoint32 {
         value: bigint;
     }
+    namespace FixedPoint32 {
+        const TYPE_QNAME = "0x1::fixed_point32::FixedPoint32";
+        function type(): TypeDescriptor<FixedPoint32>;
+    }
 }
 export declare namespace multi_ed25519 {
-    class Signature {
-        static TYPE_QNAME: string;
+    interface Signature {
         bytes: string;
     }
-    class UnvalidatedPublicKey {
-        static TYPE_QNAME: string;
+    namespace Signature {
+        const TYPE_QNAME = "0x1::multi_ed25519::Signature";
+        function type(): TypeDescriptor<Signature>;
+    }
+    interface UnvalidatedPublicKey {
         bytes: string;
     }
-    class ValidatedPublicKey {
-        static TYPE_QNAME: string;
+    namespace UnvalidatedPublicKey {
+        const TYPE_QNAME = "0x1::multi_ed25519::UnvalidatedPublicKey";
+        function type(): TypeDescriptor<UnvalidatedPublicKey>;
+    }
+    interface ValidatedPublicKey {
         bytes: string;
     }
+    namespace ValidatedPublicKey {
+        const TYPE_QNAME = "0x1::multi_ed25519::ValidatedPublicKey";
+        function type(): TypeDescriptor<ValidatedPublicKey>;
+    }
 }
 export declare class staking_proxy extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -1524,24 +1983,32 @@ export declare namespace staking_proxy {
     }
 }
 export declare namespace state_storage {
-    class GasParameter {
-        static TYPE_QNAME: string;
+    interface GasParameter {
         usage: state_storage.Usage;
     }
-    class StateStorageUsage {
-        static TYPE_QNAME: string;
+    namespace GasParameter {
+        const TYPE_QNAME = "0x1::state_storage::GasParameter";
+        function type(): TypeDescriptor<GasParameter>;
+    }
+    interface StateStorageUsage {
         epoch: bigint;
         usage: state_storage.Usage;
     }
-    class Usage {
-        static TYPE_QNAME: string;
+    namespace StateStorageUsage {
+        const TYPE_QNAME = "0x1::state_storage::StateStorageUsage";
+        function type(): TypeDescriptor<StateStorageUsage>;
+    }
+    interface Usage {
         items: bigint;
         bytes: bigint;
     }
+    namespace Usage {
+        const TYPE_QNAME = "0x1::state_storage::Usage";
+        function type(): TypeDescriptor<Usage>;
+    }
 }
 export declare namespace staking_config {
-    class StakingConfig {
-        static TYPE_QNAME: string;
+    interface StakingConfig {
         minimum_stake: bigint;
         maximum_stake: bigint;
         recurring_lockup_duration_secs: bigint;
@@ -1550,6 +2017,10 @@ export declare namespace staking_config {
         rewards_rate_denominator: bigint;
         voting_power_increase_limit: bigint;
     }
+    namespace StakingConfig {
+        const TYPE_QNAME = "0x1::staking_config::StakingConfig";
+        function type(): TypeDescriptor<StakingConfig>;
+    }
 }
 export declare class delegation_pool extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -1570,19 +2041,21 @@ export declare class delegation_pool extends AptosBaseProcessor {
     onEventDistributeCommissionEvent(func: (event: delegation_pool.DistributeCommissionEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): delegation_pool;
 }
 export declare namespace delegation_pool {
-    class AddStakeEvent {
-        static TYPE_QNAME: string;
+    interface AddStakeEvent {
         pool_address: Address;
         delegator_address: Address;
         amount_added: bigint;
         add_stake_fee: bigint;
     }
+    namespace AddStakeEvent {
+        const TYPE_QNAME = "0x1::delegation_pool::AddStakeEvent";
+        function type(): TypeDescriptor<AddStakeEvent>;
+    }
     interface AddStakeEventInstance extends TypedEventInstance<AddStakeEvent> {
         data_decoded: AddStakeEvent;
         type_arguments: [];
     }
-    class DelegationPool {
-        static TYPE_QNAME: string;
+    interface DelegationPool {
         active_shares: pool_u64_unbound.Pool;
         observed_lockup_cycle: delegation_pool.ObservedLockupCycle;
         inactive_shares: table.Table<delegation_pool.ObservedLockupCycle, pool_u64_unbound.Pool>;
@@ -1596,51 +2069,73 @@ export declare namespace delegation_pool {
         withdraw_stake_events: event.EventHandle<delegation_pool.WithdrawStakeEvent>;
         distribute_commission_events: event.EventHandle<delegation_pool.DistributeCommissionEvent>;
     }
-    class DelegationPoolOwnership {
-        static TYPE_QNAME: string;
+    namespace DelegationPool {
+        const TYPE_QNAME = "0x1::delegation_pool::DelegationPool";
+        function type(): TypeDescriptor<DelegationPool>;
+    }
+    interface DelegationPoolOwnership {
         pool_address: Address;
     }
-    class DistributeCommissionEvent {
-        static TYPE_QNAME: string;
+    namespace DelegationPoolOwnership {
+        const TYPE_QNAME = "0x1::delegation_pool::DelegationPoolOwnership";
+        function type(): TypeDescriptor<DelegationPoolOwnership>;
+    }
+    interface DistributeCommissionEvent {
         pool_address: Address;
         operator: Address;
         commission_active: bigint;
         commission_pending_inactive: bigint;
     }
+    namespace DistributeCommissionEvent {
+        const TYPE_QNAME = "0x1::delegation_pool::DistributeCommissionEvent";
+        function type(): TypeDescriptor<DistributeCommissionEvent>;
+    }
     interface DistributeCommissionEventInstance extends TypedEventInstance<DistributeCommissionEvent> {
         data_decoded: DistributeCommissionEvent;
         type_arguments: [];
     }
-    class ObservedLockupCycle {
-        static TYPE_QNAME: string;
+    interface ObservedLockupCycle {
         index: bigint;
     }
-    class ReactivateStakeEvent {
-        static TYPE_QNAME: string;
+    namespace ObservedLockupCycle {
+        const TYPE_QNAME = "0x1::delegation_pool::ObservedLockupCycle";
+        function type(): TypeDescriptor<ObservedLockupCycle>;
+    }
+    interface ReactivateStakeEvent {
         pool_address: Address;
         delegator_address: Address;
         amount_reactivated: bigint;
     }
+    namespace ReactivateStakeEvent {
+        const TYPE_QNAME = "0x1::delegation_pool::ReactivateStakeEvent";
+        function type(): TypeDescriptor<ReactivateStakeEvent>;
+    }
     interface ReactivateStakeEventInstance extends TypedEventInstance<ReactivateStakeEvent> {
         data_decoded: ReactivateStakeEvent;
         type_arguments: [];
     }
-    class UnlockStakeEvent {
-        static TYPE_QNAME: string;
+    interface UnlockStakeEvent {
         pool_address: Address;
         delegator_address: Address;
         amount_unlocked: bigint;
     }
+    namespace UnlockStakeEvent {
+        const TYPE_QNAME = "0x1::delegation_pool::UnlockStakeEvent";
+        function type(): TypeDescriptor<UnlockStakeEvent>;
+    }
     interface UnlockStakeEventInstance extends TypedEventInstance<UnlockStakeEvent> {
         data_decoded: UnlockStakeEvent;
         type_arguments: [];
     }
-    class WithdrawStakeEvent {
-        static TYPE_QNAME: string;
+    interface WithdrawStakeEvent {
         pool_address: Address;
         delegator_address: Address;
         amount_withdrawn: bigint;
     }
+    namespace WithdrawStakeEvent {
+        const TYPE_QNAME = "0x1::delegation_pool::WithdrawStakeEvent";
+        function type(): TypeDescriptor<WithdrawStakeEvent>;
+    }
     interface WithdrawStakeEventInstance extends TypedEventInstance<WithdrawStakeEvent> {
         data_decoded: WithdrawStakeEvent;
         type_arguments: [];
@@ -1685,36 +2180,51 @@ export declare class reconfiguration extends AptosBaseProcessor {
     onEventNewEpochEvent(func: (event: reconfiguration.NewEpochEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): reconfiguration;
 }
 export declare namespace reconfiguration {
-    class Configuration {
-        static TYPE_QNAME: string;
+    interface Configuration {
         epoch: bigint;
         last_reconfiguration_time: bigint;
         events: event.EventHandle<reconfiguration.NewEpochEvent>;
     }
-    class DisableReconfiguration {
-        static TYPE_QNAME: string;
+    namespace Configuration {
+        const TYPE_QNAME = "0x1::reconfiguration::Configuration";
+        function type(): TypeDescriptor<Configuration>;
+    }
+    interface DisableReconfiguration {
         dummy_field: Boolean;
     }
-    class NewEpochEvent {
-        static TYPE_QNAME: string;
+    namespace DisableReconfiguration {
+        const TYPE_QNAME = "0x1::reconfiguration::DisableReconfiguration";
+        function type(): TypeDescriptor<DisableReconfiguration>;
+    }
+    interface NewEpochEvent {
         epoch: bigint;
     }
+    namespace NewEpochEvent {
+        const TYPE_QNAME = "0x1::reconfiguration::NewEpochEvent";
+        function type(): TypeDescriptor<NewEpochEvent>;
+    }
     interface NewEpochEventInstance extends TypedEventInstance<NewEpochEvent> {
         data_decoded: NewEpochEvent;
         type_arguments: [];
     }
 }
 export declare namespace transaction_fee {
-    class AptosCoinCapabilities {
-        static TYPE_QNAME: string;
+    interface AptosCoinCapabilities {
         burn_cap: coin.BurnCapability<aptos_coin.AptosCoin>;
     }
-    class CollectedFeesPerBlock {
-        static TYPE_QNAME: string;
+    namespace AptosCoinCapabilities {
+        const TYPE_QNAME = "0x1::transaction_fee::AptosCoinCapabilities";
+        function type(): TypeDescriptor<AptosCoinCapabilities>;
+    }
+    interface CollectedFeesPerBlock {
         amount: coin.AggregatableCoin<aptos_coin.AptosCoin>;
         proposer: option.Option<Address>;
         burn_percentage: number;
     }
+    namespace CollectedFeesPerBlock {
+        const TYPE_QNAME = "0x1::transaction_fee::CollectedFeesPerBlock";
+        function type(): TypeDescriptor<CollectedFeesPerBlock>;
+    }
 }
 export declare class aptos_governance extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -1729,69 +2239,96 @@ export declare class aptos_governance extends AptosBaseProcessor {
     onEventVoteEvent(func: (event: aptos_governance.VoteEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): aptos_governance;
 }
 export declare namespace aptos_governance {
-    class ApprovedExecutionHashes {
-        static TYPE_QNAME: string;
+    interface ApprovedExecutionHashes {
         hashes: simple_map.SimpleMap<bigint, string>;
     }
-    class CreateProposalEvent {
-        static TYPE_QNAME: string;
+    namespace ApprovedExecutionHashes {
+        const TYPE_QNAME = "0x1::aptos_governance::ApprovedExecutionHashes";
+        function type(): TypeDescriptor<ApprovedExecutionHashes>;
+    }
+    interface CreateProposalEvent {
         proposer: Address;
         stake_pool: Address;
         proposal_id: bigint;
         execution_hash: string;
         proposal_metadata: simple_map.SimpleMap<string, string>;
     }
+    namespace CreateProposalEvent {
+        const TYPE_QNAME = "0x1::aptos_governance::CreateProposalEvent";
+        function type(): TypeDescriptor<CreateProposalEvent>;
+    }
     interface CreateProposalEventInstance extends TypedEventInstance<CreateProposalEvent> {
         data_decoded: CreateProposalEvent;
         type_arguments: [];
     }
-    class GovernanceConfig {
-        static TYPE_QNAME: string;
+    interface GovernanceConfig {
         min_voting_threshold: bigint;
         required_proposer_stake: bigint;
         voting_duration_secs: bigint;
     }
-    class GovernanceEvents {
-        static TYPE_QNAME: string;
+    namespace GovernanceConfig {
+        const TYPE_QNAME = "0x1::aptos_governance::GovernanceConfig";
+        function type(): TypeDescriptor<GovernanceConfig>;
+    }
+    interface GovernanceEvents {
         create_proposal_events: event.EventHandle<aptos_governance.CreateProposalEvent>;
         update_config_events: event.EventHandle<aptos_governance.UpdateConfigEvent>;
         vote_events: event.EventHandle<aptos_governance.VoteEvent>;
     }
-    class GovernanceResponsbility {
-        static TYPE_QNAME: string;
+    namespace GovernanceEvents {
+        const TYPE_QNAME = "0x1::aptos_governance::GovernanceEvents";
+        function type(): TypeDescriptor<GovernanceEvents>;
+    }
+    interface GovernanceResponsbility {
         signer_caps: simple_map.SimpleMap<Address, account.SignerCapability>;
     }
-    class RecordKey {
-        static TYPE_QNAME: string;
+    namespace GovernanceResponsbility {
+        const TYPE_QNAME = "0x1::aptos_governance::GovernanceResponsbility";
+        function type(): TypeDescriptor<GovernanceResponsbility>;
+    }
+    interface RecordKey {
         stake_pool: Address;
         proposal_id: bigint;
     }
-    class UpdateConfigEvent {
-        static TYPE_QNAME: string;
+    namespace RecordKey {
+        const TYPE_QNAME = "0x1::aptos_governance::RecordKey";
+        function type(): TypeDescriptor<RecordKey>;
+    }
+    interface UpdateConfigEvent {
         min_voting_threshold: bigint;
         required_proposer_stake: bigint;
         voting_duration_secs: bigint;
     }
+    namespace UpdateConfigEvent {
+        const TYPE_QNAME = "0x1::aptos_governance::UpdateConfigEvent";
+        function type(): TypeDescriptor<UpdateConfigEvent>;
+    }
     interface UpdateConfigEventInstance extends TypedEventInstance<UpdateConfigEvent> {
         data_decoded: UpdateConfigEvent;
         type_arguments: [];
     }
-    class VoteEvent {
-        static TYPE_QNAME: string;
+    interface VoteEvent {
         proposal_id: bigint;
         voter: Address;
         stake_pool: Address;
         num_votes: bigint;
         should_pass: Boolean;
     }
+    namespace VoteEvent {
+        const TYPE_QNAME = "0x1::aptos_governance::VoteEvent";
+        function type(): TypeDescriptor<VoteEvent>;
+    }
     interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
         data_decoded: VoteEvent;
         type_arguments: [];
     }
-    class VotingRecords {
-        static TYPE_QNAME: string;
+    interface VotingRecords {
         votes: table.Table<aptos_governance.RecordKey, Boolean>;
     }
+    namespace VotingRecords {
+        const TYPE_QNAME = "0x1::aptos_governance::VotingRecords";
+        function type(): TypeDescriptor<VotingRecords>;
+    }
     interface AddApprovedScriptHashScriptPayload extends TypedFunctionPayload<[bigint]> {
         arguments_decoded: [bigint];
         type_arguments: [];
@@ -1810,10 +2347,13 @@ export declare namespace aptos_governance {
     }
 }
 export declare namespace consensus_config {
-    class ConsensusConfig {
-        static TYPE_QNAME: string;
+    interface ConsensusConfig {
         config: string;
     }
+    namespace ConsensusConfig {
+        const TYPE_QNAME = "0x1::consensus_config::ConsensusConfig";
+        function type(): TypeDescriptor<ConsensusConfig>;
+    }
 }
 export declare class multisig_account extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -1845,51 +2385,65 @@ export declare class multisig_account extends AptosBaseProcessor {
     onEventMetadataUpdatedEvent(func: (event: multisig_account.MetadataUpdatedEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): multisig_account;
 }
 export declare namespace multisig_account {
-    class AddOwnersEvent {
-        static TYPE_QNAME: string;
+    interface AddOwnersEvent {
         owners_added: Address[];
     }
+    namespace AddOwnersEvent {
+        const TYPE_QNAME = "0x1::multisig_account::AddOwnersEvent";
+        function type(): TypeDescriptor<AddOwnersEvent>;
+    }
     interface AddOwnersEventInstance extends TypedEventInstance<AddOwnersEvent> {
         data_decoded: AddOwnersEvent;
         type_arguments: [];
     }
-    class CreateTransactionEvent {
-        static TYPE_QNAME: string;
+    interface CreateTransactionEvent {
         creator: Address;
         sequence_number: bigint;
         transaction: multisig_account.MultisigTransaction;
     }
+    namespace CreateTransactionEvent {
+        const TYPE_QNAME = "0x1::multisig_account::CreateTransactionEvent";
+        function type(): TypeDescriptor<CreateTransactionEvent>;
+    }
     interface CreateTransactionEventInstance extends TypedEventInstance<CreateTransactionEvent> {
         data_decoded: CreateTransactionEvent;
         type_arguments: [];
     }
-    class ExecuteRejectedTransactionEvent {
-        static TYPE_QNAME: string;
+    interface ExecuteRejectedTransactionEvent {
         sequence_number: bigint;
         num_rejections: bigint;
         executor: Address;
     }
+    namespace ExecuteRejectedTransactionEvent {
+        const TYPE_QNAME = "0x1::multisig_account::ExecuteRejectedTransactionEvent";
+        function type(): TypeDescriptor<ExecuteRejectedTransactionEvent>;
+    }
     interface ExecuteRejectedTransactionEventInstance extends TypedEventInstance<ExecuteRejectedTransactionEvent> {
         data_decoded: ExecuteRejectedTransactionEvent;
         type_arguments: [];
     }
-    class ExecutionError {
-        static TYPE_QNAME: string;
+    interface ExecutionError {
         abort_location: string;
         error_type: string;
         error_code: bigint;
     }
-    class MetadataUpdatedEvent {
-        static TYPE_QNAME: string;
+    namespace ExecutionError {
+        const TYPE_QNAME = "0x1::multisig_account::ExecutionError";
+        function type(): TypeDescriptor<ExecutionError>;
+    }
+    interface MetadataUpdatedEvent {
         old_metadata: simple_map.SimpleMap<string, string>;
         new_metadata: simple_map.SimpleMap<string, string>;
     }
+    namespace MetadataUpdatedEvent {
+        const TYPE_QNAME = "0x1::multisig_account::MetadataUpdatedEvent";
+        function type(): TypeDescriptor<MetadataUpdatedEvent>;
+    }
     interface MetadataUpdatedEventInstance extends TypedEventInstance<MetadataUpdatedEvent> {
         data_decoded: MetadataUpdatedEvent;
         type_arguments: [];
     }
-    class MultisigAccount {
-        static TYPE_QNAME: string;
+    interface MultisigAccount {
         owners: Address[];
         num_signatures_required: bigint;
         transactions: table.Table<bigint, multisig_account.MultisigTransaction>;
@@ -1907,68 +2461,93 @@ export declare namespace multisig_account {
         transaction_execution_failed_events: event.EventHandle<multisig_account.TransactionExecutionFailedEvent>;
         metadata_updated_events: event.EventHandle<multisig_account.MetadataUpdatedEvent>;
     }
-    class MultisigAccountCreationMessage {
-        static TYPE_QNAME: string;
+    namespace MultisigAccount {
+        const TYPE_QNAME = "0x1::multisig_account::MultisigAccount";
+        function type(): TypeDescriptor<MultisigAccount>;
+    }
+    interface MultisigAccountCreationMessage {
         chain_id: number;
         account_address: Address;
         sequence_number: bigint;
         owners: Address[];
         num_signatures_required: bigint;
     }
-    class MultisigTransaction {
-        static TYPE_QNAME: string;
+    namespace MultisigAccountCreationMessage {
+        const TYPE_QNAME = "0x1::multisig_account::MultisigAccountCreationMessage";
+        function type(): TypeDescriptor<MultisigAccountCreationMessage>;
+    }
+    interface MultisigTransaction {
         payload: option.Option<string>;
         payload_hash: option.Option<string>;
         votes: simple_map.SimpleMap<Address, Boolean>;
         creator: Address;
         creation_time_secs: bigint;
     }
-    class RemoveOwnersEvent {
-        static TYPE_QNAME: string;
+    namespace MultisigTransaction {
+        const TYPE_QNAME = "0x1::multisig_account::MultisigTransaction";
+        function type(): TypeDescriptor<MultisigTransaction>;
+    }
+    interface RemoveOwnersEvent {
         owners_removed: Address[];
     }
+    namespace RemoveOwnersEvent {
+        const TYPE_QNAME = "0x1::multisig_account::RemoveOwnersEvent";
+        function type(): TypeDescriptor<RemoveOwnersEvent>;
+    }
     interface RemoveOwnersEventInstance extends TypedEventInstance<RemoveOwnersEvent> {
         data_decoded: RemoveOwnersEvent;
         type_arguments: [];
     }
-    class TransactionExecutionFailedEvent {
-        static TYPE_QNAME: string;
+    interface TransactionExecutionFailedEvent {
         executor: Address;
         sequence_number: bigint;
         transaction_payload: string;
         num_approvals: bigint;
         execution_error: multisig_account.ExecutionError;
     }
+    namespace TransactionExecutionFailedEvent {
+        const TYPE_QNAME = "0x1::multisig_account::TransactionExecutionFailedEvent";
+        function type(): TypeDescriptor<TransactionExecutionFailedEvent>;
+    }
     interface TransactionExecutionFailedEventInstance extends TypedEventInstance<TransactionExecutionFailedEvent> {
         data_decoded: TransactionExecutionFailedEvent;
         type_arguments: [];
     }
-    class TransactionExecutionSucceededEvent {
-        static TYPE_QNAME: string;
+    interface TransactionExecutionSucceededEvent {
         executor: Address;
         sequence_number: bigint;
         transaction_payload: string;
         num_approvals: bigint;
     }
+    namespace TransactionExecutionSucceededEvent {
+        const TYPE_QNAME = "0x1::multisig_account::TransactionExecutionSucceededEvent";
+        function type(): TypeDescriptor<TransactionExecutionSucceededEvent>;
+    }
     interface TransactionExecutionSucceededEventInstance extends TypedEventInstance<TransactionExecutionSucceededEvent> {
         data_decoded: TransactionExecutionSucceededEvent;
         type_arguments: [];
     }
-    class UpdateSignaturesRequiredEvent {
-        static TYPE_QNAME: string;
+    interface UpdateSignaturesRequiredEvent {
         old_num_signatures_required: bigint;
         new_num_signatures_required: bigint;
     }
+    namespace UpdateSignaturesRequiredEvent {
+        const TYPE_QNAME = "0x1::multisig_account::UpdateSignaturesRequiredEvent";
+        function type(): TypeDescriptor<UpdateSignaturesRequiredEvent>;
+    }
     interface UpdateSignaturesRequiredEventInstance extends TypedEventInstance<UpdateSignaturesRequiredEvent> {
         data_decoded: UpdateSignaturesRequiredEvent;
         type_arguments: [];
     }
-    class VoteEvent {
-        static TYPE_QNAME: string;
+    interface VoteEvent {
         owner: Address;
         sequence_number: bigint;
         approved: Boolean;
     }
+    namespace VoteEvent {
+        const TYPE_QNAME = "0x1::multisig_account::VoteEvent";
+        function type(): TypeDescriptor<VoteEvent>;
+    }
     interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
         data_decoded: VoteEvent;
         type_arguments: [];
@@ -2053,13 +2632,16 @@ export declare namespace multisig_account {
     }
 }
 export declare namespace pool_u64_unbound {
-    class Pool {
-        static TYPE_QNAME: string;
+    interface Pool {
         total_coins: bigint;
         total_shares: bigint;
         shares: table_with_length.TableWithLength<Address, bigint>;
         scaling_factor: bigint;
     }
+    namespace Pool {
+        const TYPE_QNAME = "0x1::pool_u64_unbound::Pool";
+        function type(): TypeDescriptor<Pool>;
+    }
 }
 export declare class resource_account extends AptosBaseProcessor {
     constructor(options: AptosBindOptions);
@@ -2070,10 +2652,13 @@ export declare class resource_account extends AptosBaseProcessor {
     onEntryCreateResourceAccountAndPublishPackage(func: (call: resource_account.CreateResourceAccountAndPublishPackagePayload, ctx: AptosContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): resource_account;
 }
 export declare namespace resource_account {
-    class Container {
-        static TYPE_QNAME: string;
+    interface Container {
         store: simple_map.SimpleMap<Address, account.SignerCapability>;
     }
+    namespace Container {
+        const TYPE_QNAME = "0x1::resource_account::Container";
+        function type(): TypeDescriptor<Container>;
+    }
     interface CreateResourceAccountPayload extends TypedFunctionPayload<[string, string]> {
         arguments_decoded: [string, string];
         type_arguments: [];
@@ -2114,71 +2699,88 @@ export declare class staking_contract extends AptosBaseProcessor {
     onEventDistributeEvent(func: (event: staking_contract.DistributeEventInstance, ctx: AptosContext) => void, fetchConfig?: Partial<MoveFetchConfig>): staking_contract;
 }
 export declare namespace staking_contract {
-    class AddDistributionEvent {
-        static TYPE_QNAME: string;
+    interface AddDistributionEvent {
         operator: Address;
         pool_address: Address;
         amount: bigint;
     }
+    namespace AddDistributionEvent {
+        const TYPE_QNAME = "0x1::staking_contract::AddDistributionEvent";
+        function type(): TypeDescriptor<AddDistributionEvent>;
+    }
     interface AddDistributionEventInstance extends TypedEventInstance<AddDistributionEvent> {
         data_decoded: AddDistributionEvent;
         type_arguments: [];
     }
-    class AddStakeEvent {
-        static TYPE_QNAME: string;
+    interface AddStakeEvent {
         operator: Address;
         pool_address: Address;
         amount: bigint;
     }
+    namespace AddStakeEvent {
+        const TYPE_QNAME = "0x1::staking_contract::AddStakeEvent";
+        function type(): TypeDescriptor<AddStakeEvent>;
+    }
     interface AddStakeEventInstance extends TypedEventInstance<AddStakeEvent> {
         data_decoded: AddStakeEvent;
         type_arguments: [];
     }
-    class CreateStakingContractEvent {
-        static TYPE_QNAME: string;
+    interface CreateStakingContractEvent {
         operator: Address;
         voter: Address;
         pool_address: Address;
         principal: bigint;
         commission_percentage: bigint;
     }
+    namespace CreateStakingContractEvent {
+        const TYPE_QNAME = "0x1::staking_contract::CreateStakingContractEvent";
+        function type(): TypeDescriptor<CreateStakingContractEvent>;
+    }
     interface CreateStakingContractEventInstance extends TypedEventInstance<CreateStakingContractEvent> {
         data_decoded: CreateStakingContractEvent;
         type_arguments: [];
     }
-    class DistributeEvent {
-        static TYPE_QNAME: string;
+    interface DistributeEvent {
         operator: Address;
         pool_address: Address;
         recipient: Address;
         amount: bigint;
     }
+    namespace DistributeEvent {
+        const TYPE_QNAME = "0x1::staking_contract::DistributeEvent";
+        function type(): TypeDescriptor<DistributeEvent>;
+    }
     interface DistributeEventInstance extends TypedEventInstance<DistributeEvent> {
         data_decoded: DistributeEvent;
         type_arguments: [];
     }
-    class RequestCommissionEvent {
-        static TYPE_QNAME: string;
+    interface RequestCommissionEvent {
         operator: Address;
         pool_address: Address;
         accumulated_rewards: bigint;
         commission_amount: bigint;
     }
+    namespace RequestCommissionEvent {
+        const TYPE_QNAME = "0x1::staking_contract::RequestCommissionEvent";
+        function type(): TypeDescriptor<RequestCommissionEvent>;
+    }
     interface RequestCommissionEventInstance extends TypedEventInstance<RequestCommissionEvent> {
         data_decoded: RequestCommissionEvent;
         type_arguments: [];
     }
-    class ResetLockupEvent {
-        static TYPE_QNAME: string;
+    interface ResetLockupEvent {
         operator: Address;
         pool_address: Address;
     }
+    namespace ResetLockupEvent {
+        const TYPE_QNAME = "0x1::staking_contract::ResetLockupEvent";
+        function type(): TypeDescriptor<ResetLockupEvent>;
+    }
     interface ResetLockupEventInstance extends TypedEventInstance<ResetLockupEvent> {
         data_decoded: ResetLockupEvent;
         type_arguments: [];
     }
-    class StakingContract {
-        static TYPE_QNAME: string;
+    interface StakingContract {
         principal: bigint;
         pool_address: Address;
         owner_cap: stake.OwnerCapability;
@@ -2186,16 +2788,25 @@ export declare namespace staking_contract {
         distribution_pool: pool_u64.Pool;
         signer_cap: account.SignerCapability;
     }
-    class StakingGroupContainer {
-        static TYPE_QNAME: string;
+    namespace StakingContract {
+        const TYPE_QNAME = "0x1::staking_contract::StakingContract";
+        function type(): TypeDescriptor<StakingContract>;
+    }
+    interface StakingGroupContainer {
         dummy_field: Boolean;
     }
-    class StakingGroupUpdateCommissionEvent {
-        static TYPE_QNAME: string;
+    namespace StakingGroupContainer {
+        const TYPE_QNAME = "0x1::staking_contract::StakingGroupContainer";
+        function type(): TypeDescriptor<StakingGroupContainer>;
+    }
+    interface StakingGroupUpdateCommissionEvent {
         update_commission_events: event.EventHandle<staking_contract.UpdateCommissionEvent>;
     }
-    class Store {
-        static TYPE_QNAME: string;
+    namespace StakingGroupUpdateCommissionEvent {
+        const TYPE_QNAME = "0x1::staking_contract::StakingGroupUpdateCommissionEvent";
+        function type(): TypeDescriptor<StakingGroupUpdateCommissionEvent>;
+    }
+    interface Store {
         staking_contracts: simple_map.SimpleMap<Address, staking_contract.StakingContract>;
         create_staking_contract_events: event.EventHandle<staking_contract.CreateStakingContractEvent>;
         update_voter_events: event.EventHandle<staking_contract.UpdateVoterEvent>;
@@ -2207,45 +2818,61 @@ export declare namespace staking_contract {
         add_distribution_events: event.EventHandle<staking_contract.AddDistributionEvent>;
         distribute_events: event.EventHandle<staking_contract.DistributeEvent>;
     }
-    class SwitchOperatorEvent {
-        static TYPE_QNAME: string;
+    namespace Store {
+        const TYPE_QNAME = "0x1::staking_contract::Store";
+        function type(): TypeDescriptor<Store>;
+    }
+    interface SwitchOperatorEvent {
         old_operator: Address;
         new_operator: Address;
         pool_address: Address;
     }
+    namespace SwitchOperatorEvent {
+        const TYPE_QNAME = "0x1::staking_contract::SwitchOperatorEvent";
+        function type(): TypeDescriptor<SwitchOperatorEvent>;
+    }
     interface SwitchOperatorEventInstance extends TypedEventInstance<SwitchOperatorEvent> {
         data_decoded: SwitchOperatorEvent;
         type_arguments: [];
     }
-    class UnlockStakeEvent {
-        static TYPE_QNAME: string;
+    interface UnlockStakeEvent {
         operator: Address;
         pool_address: Address;
         amount: bigint;
         commission_paid: bigint;
     }
+    namespace UnlockStakeEvent {
+        const TYPE_QNAME = "0x1::staking_contract::UnlockStakeEvent";
+        function type(): TypeDescriptor<UnlockStakeEvent>;
+    }
     interface UnlockStakeEventInstance extends TypedEventInstance<UnlockStakeEvent> {
         data_decoded: UnlockStakeEvent;
         type_arguments: [];
     }
-    class UpdateCommissionEvent {
-        static TYPE_QNAME: string;
+    interface UpdateCommissionEvent {
         staker: Address;
         operator: Address;
         old_commission_percentage: bigint;
         new_commission_percentage: bigint;
     }
+    namespace UpdateCommissionEvent {
+        const TYPE_QNAME = "0x1::staking_contract::UpdateCommissionEvent";
+        function type(): TypeDescriptor<UpdateCommissionEvent>;
+    }
     interface UpdateCommissionEventInstance extends TypedEventInstance<UpdateCommissionEvent> {
         data_decoded: UpdateCommissionEvent;
         type_arguments: [];
     }
-    class UpdateVoterEvent {
-        static TYPE_QNAME: string;
+    interface UpdateVoterEvent {
         operator: Address;
         pool_address: Address;
         old_voter: Address;
         new_voter: Address;
     }
+    namespace UpdateVoterEvent {
+        const TYPE_QNAME = "0x1::staking_contract::UpdateVoterEvent";
+        function type(): TypeDescriptor<UpdateVoterEvent>;
+    }
     interface UpdateVoterEventInstance extends TypedEventInstance<UpdateVoterEvent> {
         data_decoded: UpdateVoterEvent;
         type_arguments: [];
@@ -2297,40 +2924,54 @@ export declare namespace staking_contract {
 }
 export declare namespace system_addresses { }
 export declare namespace table_with_length {
-    class TableWithLength<T0, T1> {
-        static TYPE_QNAME: string;
+    interface TableWithLength<T0, T1> {
         inner: table.Table<T0, T1>;
         length: bigint;
     }
+    namespace TableWithLength {
+        const TYPE_QNAME = "0x1::table_with_length::TableWithLength";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<TableWithLength<T0, T1>>;
+    }
 }
 export declare namespace aggregator_factory {
-    class AggregatorFactory {
-        static TYPE_QNAME: string;
+    interface AggregatorFactory {
         phantom_table: table.Table<Address, bigint>;
     }
+    namespace AggregatorFactory {
+        const TYPE_QNAME = "0x1::aggregator_factory::AggregatorFactory";
+        function type(): TypeDescriptor<AggregatorFactory>;
+    }
 }
 export declare namespace governance_proposal {
-    class GovernanceProposal {
-        static TYPE_QNAME: string;
+    interface GovernanceProposal {
         dummy_field: Boolean;
     }
+    namespace GovernanceProposal {
+        const TYPE_QNAME = "0x1::governance_proposal::GovernanceProposal";
+        function type(): TypeDescriptor<GovernanceProposal>;
+    }
 }
 export declare namespace optional_aggregator {
-    class Integer {
-        static TYPE_QNAME: string;
+    interface Integer {
         value: bigint;
         limit: bigint;
     }
-    class OptionalAggregator {
-        static TYPE_QNAME: string;
+    namespace Integer {
+        const TYPE_QNAME = "0x1::optional_aggregator::Integer";
+        function type(): TypeDescriptor<Integer>;
+    }
+    interface OptionalAggregator {
         aggregator: option.Option<aggregator.Aggregator>;
         integer: option.Option<optional_aggregator.Integer>;
     }
+    namespace OptionalAggregator {
+        const TYPE_QNAME = "0x1::optional_aggregator::OptionalAggregator";
+        function type(): TypeDescriptor<OptionalAggregator>;
+    }
 }
 export declare namespace transaction_context { }
 export declare namespace transaction_validation {
-    class TransactionValidation {
-        static TYPE_QNAME: string;
+    interface TransactionValidation {
         module_addr: Address;
         module_name: string;
         script_prologue_name: string;
@@ -2338,5 +2979,9 @@ export declare namespace transaction_validation {
         multi_agent_prologue_name: string;
         user_epilogue_name: string;
     }
+    namespace TransactionValidation {
+        const TYPE_QNAME = "0x1::transaction_validation::TransactionValidation";
+        function type(): TypeDescriptor<TransactionValidation>;
+    }
 }
 export declare function loadAllTypes(coder: MoveCoder): void;