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

package/src/aptos/builtin/0x1.ts

@@ -4,7 +4,7 @@
 
 /* Generated modules for account 0x1 */
 
-import { CallFilter } from "@sentio/sdk/move";
+import { CallFilter, TypeDescriptor, ANY_TYPE } from "@sentio/sdk/move";
 import {
   MoveCoder,
   defaultMoveCoder,
@@ -19,18 +19,36 @@ import { MoveFetchConfig } from "@sentio/protos";
 import { Address, ModuleClient } from "@sentio/sdk/aptos";
 
 export namespace acl {
-  export class ACL {
-    static TYPE_QNAME = "0x1::acl::ACL";
+  export interface ACL {
     list: Address[];
   }
+
+  export namespace ACL {
+    export const TYPE_QNAME = "0x1::acl::ACL";
+
+    const TYPE = new TypeDescriptor<ACL>(ACL.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<ACL> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace any_ {
-  export class Any {
-    static TYPE_QNAME = "0x1::any::Any";
+  export interface Any {
     type_name: string;
     data: string;
   }
+
+  export namespace Any {
+    export const TYPE_QNAME = "0x1::any::Any";
+
+    const TYPE = new TypeDescriptor<Any>(Any.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Any> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace bcs {}
@@ -66,28 +84,54 @@ export class code extends AptosBaseProcessor {
 }
 
 export namespace code {
-  export class AllowedDep {
-    static TYPE_QNAME = "0x1::code::AllowedDep";
+  export interface AllowedDep {
     account: Address;
     module_name: string;
   }
 
-  export class ModuleMetadata {
-    static TYPE_QNAME = "0x1::code::ModuleMetadata";
+  export namespace AllowedDep {
+    export const TYPE_QNAME = "0x1::code::AllowedDep";
+
+    const TYPE = new TypeDescriptor<AllowedDep>(AllowedDep.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<AllowedDep> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface ModuleMetadata {
     name: string;
     source: string;
     source_map: string;
     extension: option.Option<copyable_any.Any>;
   }
 
-  export class PackageDep {
-    static TYPE_QNAME = "0x1::code::PackageDep";
+  export namespace ModuleMetadata {
+    export const TYPE_QNAME = "0x1::code::ModuleMetadata";
+
+    const TYPE = new TypeDescriptor<ModuleMetadata>(ModuleMetadata.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<ModuleMetadata> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface PackageDep {
     account: Address;
     package_name: string;
   }
 
-  export class PackageMetadata {
-    static TYPE_QNAME = "0x1::code::PackageMetadata";
+  export namespace PackageDep {
+    export const TYPE_QNAME = "0x1::code::PackageDep";
+
+    const TYPE = new TypeDescriptor<PackageDep>(PackageDep.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<PackageDep> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface PackageMetadata {
     name: string;
     upgrade_policy: code.UpgradePolicy;
     upgrade_number: bigint;
@@ -98,16 +142,48 @@ export namespace code {
     extension: option.Option<copyable_any.Any>;
   }
 
-  export class PackageRegistry {
-    static TYPE_QNAME = "0x1::code::PackageRegistry";
+  export namespace PackageMetadata {
+    export const TYPE_QNAME = "0x1::code::PackageMetadata";
+
+    const TYPE = new TypeDescriptor<PackageMetadata>(
+      PackageMetadata.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<PackageMetadata> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface PackageRegistry {
     packages: code.PackageMetadata[];
   }
 
-  export class UpgradePolicy {
-    static TYPE_QNAME = "0x1::code::UpgradePolicy";
+  export namespace PackageRegistry {
+    export const TYPE_QNAME = "0x1::code::PackageRegistry";
+
+    const TYPE = new TypeDescriptor<PackageRegistry>(
+      PackageRegistry.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<PackageRegistry> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface UpgradePolicy {
     policy: number;
   }
 
+  export namespace UpgradePolicy {
+    export const TYPE_QNAME = "0x1::code::UpgradePolicy";
+
+    const TYPE = new TypeDescriptor<UpgradePolicy>(UpgradePolicy.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<UpgradePolicy> {
+      return TYPE.apply();
+    }
+  }
+
   export interface PublishPackageTxnPayload
     extends TypedFunctionPayload<[string, string[]]> {
     arguments_decoded: [string, string[]];
@@ -222,68 +298,180 @@ export class coin extends AptosBaseProcessor {
 }
 
 export namespace coin {
-  export class AggregatableCoin<T0> {
-    static TYPE_QNAME = "0x1::coin::AggregatableCoin";
+  export interface AggregatableCoin<T0> {
     value: aggregator.Aggregator;
   }
 
-  export class BurnCapability<T0> {
-    static TYPE_QNAME = "0x1::coin::BurnCapability";
+  export namespace AggregatableCoin {
+    export const TYPE_QNAME = "0x1::coin::AggregatableCoin";
+
+    const TYPE = new TypeDescriptor<AggregatableCoin<any>>(
+      AggregatableCoin.TYPE_QNAME
+    );
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<AggregatableCoin<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface BurnCapability<T0> {
     dummy_field: Boolean;
   }
 
-  export class Coin<T0> {
-    static TYPE_QNAME = "0x1::coin::Coin";
+  export namespace BurnCapability {
+    export const TYPE_QNAME = "0x1::coin::BurnCapability";
+
+    const TYPE = new TypeDescriptor<BurnCapability<any>>(
+      BurnCapability.TYPE_QNAME
+    );
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<BurnCapability<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface Coin<T0> {
     value: bigint;
   }
 
-  export class CoinInfo<T0> {
-    static TYPE_QNAME = "0x1::coin::CoinInfo";
+  export namespace Coin {
+    export const TYPE_QNAME = "0x1::coin::Coin";
+
+    const TYPE = new TypeDescriptor<Coin<any>>(Coin.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<Coin<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface CoinInfo<T0> {
     name: string;
     symbol: string;
     decimals: number;
     supply: option.Option<optional_aggregator.OptionalAggregator>;
   }
 
-  export class CoinStore<T0> {
-    static TYPE_QNAME = "0x1::coin::CoinStore";
+  export namespace CoinInfo {
+    export const TYPE_QNAME = "0x1::coin::CoinInfo";
+
+    const TYPE = new TypeDescriptor<CoinInfo<any>>(CoinInfo.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<CoinInfo<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface CoinStore<T0> {
     coin: coin.Coin<T0>;
     frozen: Boolean;
     deposit_events: event.EventHandle<coin.DepositEvent>;
     withdraw_events: event.EventHandle<coin.WithdrawEvent>;
   }
 
-  export class DepositEvent {
-    static TYPE_QNAME = "0x1::coin::DepositEvent";
+  export namespace CoinStore {
+    export const TYPE_QNAME = "0x1::coin::CoinStore";
+
+    const TYPE = new TypeDescriptor<CoinStore<any>>(CoinStore.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<CoinStore<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface DepositEvent {
     amount: bigint;
   }
 
+  export namespace DepositEvent {
+    export const TYPE_QNAME = "0x1::coin::DepositEvent";
+
+    const TYPE = new TypeDescriptor<DepositEvent>(DepositEvent.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<DepositEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface DepositEventInstance
     extends TypedEventInstance<DepositEvent> {
     data_decoded: DepositEvent;
     type_arguments: [];
   }
 
-  export class FreezeCapability<T0> {
-    static TYPE_QNAME = "0x1::coin::FreezeCapability";
+  export interface FreezeCapability<T0> {
     dummy_field: Boolean;
   }
 
-  export class MintCapability<T0> {
-    static TYPE_QNAME = "0x1::coin::MintCapability";
+  export namespace FreezeCapability {
+    export const TYPE_QNAME = "0x1::coin::FreezeCapability";
+
+    const TYPE = new TypeDescriptor<FreezeCapability<any>>(
+      FreezeCapability.TYPE_QNAME
+    );
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<FreezeCapability<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface MintCapability<T0> {
     dummy_field: Boolean;
   }
 
-  export class SupplyConfig {
-    static TYPE_QNAME = "0x1::coin::SupplyConfig";
+  export namespace MintCapability {
+    export const TYPE_QNAME = "0x1::coin::MintCapability";
+
+    const TYPE = new TypeDescriptor<MintCapability<any>>(
+      MintCapability.TYPE_QNAME
+    );
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<MintCapability<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface SupplyConfig {
     allow_upgrades: Boolean;
   }
 
-  export class WithdrawEvent {
-    static TYPE_QNAME = "0x1::coin::WithdrawEvent";
+  export namespace SupplyConfig {
+    export const TYPE_QNAME = "0x1::coin::SupplyConfig";
+
+    const TYPE = new TypeDescriptor<SupplyConfig>(SupplyConfig.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<SupplyConfig> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface WithdrawEvent {
     amount: bigint;
   }
 
+  export namespace WithdrawEvent {
+    export const TYPE_QNAME = "0x1::coin::WithdrawEvent";
+
+    const TYPE = new TypeDescriptor<WithdrawEvent>(WithdrawEvent.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<WithdrawEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface WithdrawEventInstance
     extends TypedEventInstance<WithdrawEvent> {
     data_decoded: WithdrawEvent;
@@ -316,16 +504,34 @@ export namespace coin {
 }
 
 export namespace guid {
-  export class GUID {
-    static TYPE_QNAME = "0x1::guid::GUID";
+  export interface GUID {
     id: guid.ID;
   }
 
-  export class ID {
-    static TYPE_QNAME = "0x1::guid::ID";
+  export namespace GUID {
+    export const TYPE_QNAME = "0x1::guid::GUID";
+
+    const TYPE = new TypeDescriptor<GUID>(GUID.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<GUID> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface ID {
     creation_num: bigint;
     addr: Address;
   }
+
+  export namespace ID {
+    export const TYPE_QNAME = "0x1::guid::ID";
+
+    const TYPE = new TypeDescriptor<ID>(ID.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<ID> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace hash {}
@@ -378,16 +584,24 @@ export class block extends AptosBaseProcessor {
 }
 
 export namespace block {
-  export class BlockResource {
-    static TYPE_QNAME = "0x1::block::BlockResource";
+  export interface BlockResource {
     height: bigint;
     epoch_interval: bigint;
     new_block_events: event.EventHandle<block.NewBlockEvent>;
     update_epoch_interval_events: event.EventHandle<block.UpdateEpochIntervalEvent>;
   }
 
-  export class NewBlockEvent {
-    static TYPE_QNAME = "0x1::block::NewBlockEvent";
+  export namespace BlockResource {
+    export const TYPE_QNAME = "0x1::block::BlockResource";
+
+    const TYPE = new TypeDescriptor<BlockResource>(BlockResource.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<BlockResource> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface NewBlockEvent {
     hash: Address;
     epoch: bigint;
     round: bigint;
@@ -398,18 +612,39 @@ export namespace block {
     time_microseconds: bigint;
   }
 
+  export namespace NewBlockEvent {
+    export const TYPE_QNAME = "0x1::block::NewBlockEvent";
+
+    const TYPE = new TypeDescriptor<NewBlockEvent>(NewBlockEvent.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<NewBlockEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface NewBlockEventInstance
     extends TypedEventInstance<NewBlockEvent> {
     data_decoded: NewBlockEvent;
     type_arguments: [];
   }
 
-  export class UpdateEpochIntervalEvent {
-    static TYPE_QNAME = "0x1::block::UpdateEpochIntervalEvent";
+  export interface UpdateEpochIntervalEvent {
     old_epoch_interval: bigint;
     new_epoch_interval: bigint;
   }
 
+  export namespace UpdateEpochIntervalEvent {
+    export const TYPE_QNAME = "0x1::block::UpdateEpochIntervalEvent";
+
+    const TYPE = new TypeDescriptor<UpdateEpochIntervalEvent>(
+      UpdateEpochIntervalEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<UpdateEpochIntervalEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface UpdateEpochIntervalEventInstance
     extends TypedEventInstance<UpdateEpochIntervalEvent> {
     data_decoded: UpdateEpochIntervalEvent;
@@ -422,11 +657,22 @@ export namespace debug {}
 export namespace error {}
 
 export namespace event {
-  export class EventHandle<T0> {
-    static TYPE_QNAME = "0x1::event::EventHandle";
+  export interface EventHandle<T0> {
     counter: bigint;
     guid: guid.GUID;
   }
+
+  export namespace EventHandle {
+    export const TYPE_QNAME = "0x1::event::EventHandle";
+
+    const TYPE = new TypeDescriptor<EventHandle<any>>(EventHandle.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<EventHandle<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
 }
 
 export class stake extends AptosBaseProcessor {
@@ -844,137 +1090,277 @@ export class stake extends AptosBaseProcessor {
 }
 
 export namespace stake {
-  export class AddStakeEvent {
-    static TYPE_QNAME = "0x1::stake::AddStakeEvent";
+  export interface AddStakeEvent {
     pool_address: Address;
     amount_added: bigint;
   }
 
+  export namespace AddStakeEvent {
+    export const TYPE_QNAME = "0x1::stake::AddStakeEvent";
+
+    const TYPE = new TypeDescriptor<AddStakeEvent>(AddStakeEvent.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<AddStakeEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface AddStakeEventInstance
     extends TypedEventInstance<AddStakeEvent> {
     data_decoded: AddStakeEvent;
     type_arguments: [];
   }
 
-  export class AllowedValidators {
-    static TYPE_QNAME = "0x1::stake::AllowedValidators";
+  export interface AllowedValidators {
     accounts: Address[];
   }
 
-  export class AptosCoinCapabilities {
-    static TYPE_QNAME = "0x1::stake::AptosCoinCapabilities";
+  export namespace AllowedValidators {
+    export const TYPE_QNAME = "0x1::stake::AllowedValidators";
+
+    const TYPE = new TypeDescriptor<AllowedValidators>(
+      AllowedValidators.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<AllowedValidators> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface AptosCoinCapabilities {
     mint_cap: coin.MintCapability<aptos_coin.AptosCoin>;
   }
 
-  export class DistributeRewardsEvent {
-    static TYPE_QNAME = "0x1::stake::DistributeRewardsEvent";
+  export namespace AptosCoinCapabilities {
+    export const TYPE_QNAME = "0x1::stake::AptosCoinCapabilities";
+
+    const TYPE = new TypeDescriptor<AptosCoinCapabilities>(
+      AptosCoinCapabilities.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<AptosCoinCapabilities> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface DistributeRewardsEvent {
     pool_address: Address;
     rewards_amount: bigint;
   }
 
+  export namespace DistributeRewardsEvent {
+    export const TYPE_QNAME = "0x1::stake::DistributeRewardsEvent";
+
+    const TYPE = new TypeDescriptor<DistributeRewardsEvent>(
+      DistributeRewardsEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<DistributeRewardsEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface DistributeRewardsEventInstance
     extends TypedEventInstance<DistributeRewardsEvent> {
     data_decoded: DistributeRewardsEvent;
     type_arguments: [];
   }
 
-  export class IncreaseLockupEvent {
-    static TYPE_QNAME = "0x1::stake::IncreaseLockupEvent";
+  export interface IncreaseLockupEvent {
     pool_address: Address;
     old_locked_until_secs: bigint;
     new_locked_until_secs: bigint;
   }
 
+  export namespace IncreaseLockupEvent {
+    export const TYPE_QNAME = "0x1::stake::IncreaseLockupEvent";
+
+    const TYPE = new TypeDescriptor<IncreaseLockupEvent>(
+      IncreaseLockupEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<IncreaseLockupEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface IncreaseLockupEventInstance
     extends TypedEventInstance<IncreaseLockupEvent> {
     data_decoded: IncreaseLockupEvent;
     type_arguments: [];
   }
 
-  export class IndividualValidatorPerformance {
-    static TYPE_QNAME = "0x1::stake::IndividualValidatorPerformance";
+  export interface IndividualValidatorPerformance {
     successful_proposals: bigint;
     failed_proposals: bigint;
   }
 
-  export class JoinValidatorSetEvent {
-    static TYPE_QNAME = "0x1::stake::JoinValidatorSetEvent";
+  export namespace IndividualValidatorPerformance {
+    export const TYPE_QNAME = "0x1::stake::IndividualValidatorPerformance";
+
+    const TYPE = new TypeDescriptor<IndividualValidatorPerformance>(
+      IndividualValidatorPerformance.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<IndividualValidatorPerformance> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface JoinValidatorSetEvent {
     pool_address: Address;
   }
 
+  export namespace JoinValidatorSetEvent {
+    export const TYPE_QNAME = "0x1::stake::JoinValidatorSetEvent";
+
+    const TYPE = new TypeDescriptor<JoinValidatorSetEvent>(
+      JoinValidatorSetEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<JoinValidatorSetEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface JoinValidatorSetEventInstance
     extends TypedEventInstance<JoinValidatorSetEvent> {
     data_decoded: JoinValidatorSetEvent;
     type_arguments: [];
   }
 
-  export class LeaveValidatorSetEvent {
-    static TYPE_QNAME = "0x1::stake::LeaveValidatorSetEvent";
+  export interface LeaveValidatorSetEvent {
     pool_address: Address;
   }
 
+  export namespace LeaveValidatorSetEvent {
+    export const TYPE_QNAME = "0x1::stake::LeaveValidatorSetEvent";
+
+    const TYPE = new TypeDescriptor<LeaveValidatorSetEvent>(
+      LeaveValidatorSetEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<LeaveValidatorSetEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface LeaveValidatorSetEventInstance
     extends TypedEventInstance<LeaveValidatorSetEvent> {
     data_decoded: LeaveValidatorSetEvent;
     type_arguments: [];
   }
 
-  export class OwnerCapability {
-    static TYPE_QNAME = "0x1::stake::OwnerCapability";
+  export interface OwnerCapability {
     pool_address: Address;
   }
 
-  export class ReactivateStakeEvent {
-    static TYPE_QNAME = "0x1::stake::ReactivateStakeEvent";
+  export namespace OwnerCapability {
+    export const TYPE_QNAME = "0x1::stake::OwnerCapability";
+
+    const TYPE = new TypeDescriptor<OwnerCapability>(
+      OwnerCapability.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<OwnerCapability> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface ReactivateStakeEvent {
     pool_address: Address;
     amount: bigint;
   }
 
+  export namespace ReactivateStakeEvent {
+    export const TYPE_QNAME = "0x1::stake::ReactivateStakeEvent";
+
+    const TYPE = new TypeDescriptor<ReactivateStakeEvent>(
+      ReactivateStakeEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ReactivateStakeEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface ReactivateStakeEventInstance
     extends TypedEventInstance<ReactivateStakeEvent> {
     data_decoded: ReactivateStakeEvent;
     type_arguments: [];
   }
 
-  export class RegisterValidatorCandidateEvent {
-    static TYPE_QNAME = "0x1::stake::RegisterValidatorCandidateEvent";
+  export interface RegisterValidatorCandidateEvent {
     pool_address: Address;
   }
 
+  export namespace RegisterValidatorCandidateEvent {
+    export const TYPE_QNAME = "0x1::stake::RegisterValidatorCandidateEvent";
+
+    const TYPE = new TypeDescriptor<RegisterValidatorCandidateEvent>(
+      RegisterValidatorCandidateEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<RegisterValidatorCandidateEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface RegisterValidatorCandidateEventInstance
     extends TypedEventInstance<RegisterValidatorCandidateEvent> {
     data_decoded: RegisterValidatorCandidateEvent;
     type_arguments: [];
   }
 
-  export class RotateConsensusKeyEvent {
-    static TYPE_QNAME = "0x1::stake::RotateConsensusKeyEvent";
+  export interface RotateConsensusKeyEvent {
     pool_address: Address;
     old_consensus_pubkey: string;
     new_consensus_pubkey: string;
   }
 
+  export namespace RotateConsensusKeyEvent {
+    export const TYPE_QNAME = "0x1::stake::RotateConsensusKeyEvent";
+
+    const TYPE = new TypeDescriptor<RotateConsensusKeyEvent>(
+      RotateConsensusKeyEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<RotateConsensusKeyEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface RotateConsensusKeyEventInstance
     extends TypedEventInstance<RotateConsensusKeyEvent> {
     data_decoded: RotateConsensusKeyEvent;
     type_arguments: [];
   }
 
-  export class SetOperatorEvent {
-    static TYPE_QNAME = "0x1::stake::SetOperatorEvent";
+  export interface SetOperatorEvent {
     pool_address: Address;
     old_operator: Address;
     new_operator: Address;
   }
 
+  export namespace SetOperatorEvent {
+    export const TYPE_QNAME = "0x1::stake::SetOperatorEvent";
+
+    const TYPE = new TypeDescriptor<SetOperatorEvent>(
+      SetOperatorEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<SetOperatorEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface SetOperatorEventInstance
     extends TypedEventInstance<SetOperatorEvent> {
     data_decoded: SetOperatorEvent;
     type_arguments: [];
   }
 
-  export class StakePool {
-    static TYPE_QNAME = "0x1::stake::StakePool";
+  export interface StakePool {
     active: coin.Coin<aptos_coin.AptosCoin>;
     inactive: coin.Coin<aptos_coin.AptosCoin>;
     pending_active: coin.Coin<aptos_coin.AptosCoin>;
@@ -996,20 +1382,40 @@ export namespace stake {
     leave_validator_set_events: event.EventHandle<stake.LeaveValidatorSetEvent>;
   }
 
-  export class UnlockStakeEvent {
-    static TYPE_QNAME = "0x1::stake::UnlockStakeEvent";
+  export namespace StakePool {
+    export const TYPE_QNAME = "0x1::stake::StakePool";
+
+    const TYPE = new TypeDescriptor<StakePool>(StakePool.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<StakePool> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface UnlockStakeEvent {
     pool_address: Address;
     amount_unlocked: bigint;
   }
 
+  export namespace UnlockStakeEvent {
+    export const TYPE_QNAME = "0x1::stake::UnlockStakeEvent";
+
+    const TYPE = new TypeDescriptor<UnlockStakeEvent>(
+      UnlockStakeEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<UnlockStakeEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface UnlockStakeEventInstance
     extends TypedEventInstance<UnlockStakeEvent> {
     data_decoded: UnlockStakeEvent;
     type_arguments: [];
   }
 
-  export class UpdateNetworkAndFullnodeAddressesEvent {
-    static TYPE_QNAME = "0x1::stake::UpdateNetworkAndFullnodeAddressesEvent";
+  export interface UpdateNetworkAndFullnodeAddressesEvent {
     pool_address: Address;
     old_network_addresses: string;
     new_network_addresses: string;
@@ -1017,39 +1423,91 @@ export namespace stake {
     new_fullnode_addresses: string;
   }
 
+  export namespace UpdateNetworkAndFullnodeAddressesEvent {
+    export const TYPE_QNAME =
+      "0x1::stake::UpdateNetworkAndFullnodeAddressesEvent";
+
+    const TYPE = new TypeDescriptor<UpdateNetworkAndFullnodeAddressesEvent>(
+      UpdateNetworkAndFullnodeAddressesEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<UpdateNetworkAndFullnodeAddressesEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface UpdateNetworkAndFullnodeAddressesEventInstance
     extends TypedEventInstance<UpdateNetworkAndFullnodeAddressesEvent> {
     data_decoded: UpdateNetworkAndFullnodeAddressesEvent;
     type_arguments: [];
   }
 
-  export class ValidatorConfig {
-    static TYPE_QNAME = "0x1::stake::ValidatorConfig";
+  export interface ValidatorConfig {
     consensus_pubkey: string;
     network_addresses: string;
     fullnode_addresses: string;
     validator_index: bigint;
   }
 
-  export class ValidatorFees {
-    static TYPE_QNAME = "0x1::stake::ValidatorFees";
+  export namespace ValidatorConfig {
+    export const TYPE_QNAME = "0x1::stake::ValidatorConfig";
+
+    const TYPE = new TypeDescriptor<ValidatorConfig>(
+      ValidatorConfig.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ValidatorConfig> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface ValidatorFees {
     fees_table: table.Table<Address, coin.Coin<aptos_coin.AptosCoin>>;
   }
 
-  export class ValidatorInfo {
-    static TYPE_QNAME = "0x1::stake::ValidatorInfo";
+  export namespace ValidatorFees {
+    export const TYPE_QNAME = "0x1::stake::ValidatorFees";
+
+    const TYPE = new TypeDescriptor<ValidatorFees>(ValidatorFees.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<ValidatorFees> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface ValidatorInfo {
     addr: Address;
     voting_power: bigint;
     config: stake.ValidatorConfig;
   }
 
-  export class ValidatorPerformance {
-    static TYPE_QNAME = "0x1::stake::ValidatorPerformance";
+  export namespace ValidatorInfo {
+    export const TYPE_QNAME = "0x1::stake::ValidatorInfo";
+
+    const TYPE = new TypeDescriptor<ValidatorInfo>(ValidatorInfo.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<ValidatorInfo> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface ValidatorPerformance {
     validators: stake.IndividualValidatorPerformance[];
   }
 
-  export class ValidatorSet {
-    static TYPE_QNAME = "0x1::stake::ValidatorSet";
+  export namespace ValidatorPerformance {
+    export const TYPE_QNAME = "0x1::stake::ValidatorPerformance";
+
+    const TYPE = new TypeDescriptor<ValidatorPerformance>(
+      ValidatorPerformance.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ValidatorPerformance> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface ValidatorSet {
     consensus_scheme: number;
     active_validators: stake.ValidatorInfo[];
     pending_inactive: stake.ValidatorInfo[];
@@ -1058,12 +1516,33 @@ export namespace stake {
     total_joining_power: bigint;
   }
 
-  export class WithdrawStakeEvent {
-    static TYPE_QNAME = "0x1::stake::WithdrawStakeEvent";
+  export namespace ValidatorSet {
+    export const TYPE_QNAME = "0x1::stake::ValidatorSet";
+
+    const TYPE = new TypeDescriptor<ValidatorSet>(ValidatorSet.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<ValidatorSet> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface WithdrawStakeEvent {
     pool_address: Address;
     amount_withdrawn: bigint;
   }
 
+  export namespace WithdrawStakeEvent {
+    export const TYPE_QNAME = "0x1::stake::WithdrawStakeEvent";
+
+    const TYPE = new TypeDescriptor<WithdrawStakeEvent>(
+      WithdrawStakeEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<WithdrawStakeEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface WithdrawStakeEventInstance
     extends TypedEventInstance<WithdrawStakeEvent> {
     data_decoded: WithdrawStakeEvent;
@@ -1145,15 +1624,38 @@ export namespace stake {
 }
 
 export namespace table {
-  export class Box<T0> {
-    static TYPE_QNAME = "0x1::table::Box";
+  export interface Box<T0> {
     val: T0;
   }
 
-  export class Table<T0, T1> {
-    static TYPE_QNAME = "0x1::table::Table";
+  export namespace Box {
+    export const TYPE_QNAME = "0x1::table::Box";
+
+    const TYPE = new TypeDescriptor<Box<any>>(Box.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<Box<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface Table<T0, T1> {
     handle: Address;
   }
+
+  export namespace Table {
+    export const TYPE_QNAME = "0x1::table::Table";
+
+    const TYPE = new TypeDescriptor<Table<any, any>>(Table.TYPE_QNAME);
+
+    export function type<T0, T1>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE,
+      arg1: TypeDescriptor<T1> = ANY_TYPE
+    ): TypeDescriptor<Table<T0, T1>> {
+      return TYPE.apply(arg0, arg1);
+    }
+  }
 }
 
 export namespace math64 {}
@@ -1203,64 +1705,149 @@ export class object_ extends AptosBaseProcessor {
 }
 
 export namespace object_ {
-  export class ConstructorRef {
-    static TYPE_QNAME = "0x1::object::ConstructorRef";
+  export interface ConstructorRef {
     self: Address;
     can_delete: Boolean;
   }
 
-  export class DeleteRef {
-    static TYPE_QNAME = "0x1::object::DeleteRef";
+  export namespace ConstructorRef {
+    export const TYPE_QNAME = "0x1::object::ConstructorRef";
+
+    const TYPE = new TypeDescriptor<ConstructorRef>(ConstructorRef.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<ConstructorRef> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface DeleteRef {
     self: Address;
   }
 
-  export class ExtendRef {
-    static TYPE_QNAME = "0x1::object::ExtendRef";
+  export namespace DeleteRef {
+    export const TYPE_QNAME = "0x1::object::DeleteRef";
+
+    const TYPE = new TypeDescriptor<DeleteRef>(DeleteRef.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<DeleteRef> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface ExtendRef {
     self: Address;
   }
 
-  export class LinearTransferRef {
-    static TYPE_QNAME = "0x1::object::LinearTransferRef";
+  export namespace ExtendRef {
+    export const TYPE_QNAME = "0x1::object::ExtendRef";
+
+    const TYPE = new TypeDescriptor<ExtendRef>(ExtendRef.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<ExtendRef> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface LinearTransferRef {
     self: Address;
     owner: Address;
   }
 
-  export class Object<T0> {
-    static TYPE_QNAME = "0x1::object::Object";
+  export namespace LinearTransferRef {
+    export const TYPE_QNAME = "0x1::object::LinearTransferRef";
+
+    const TYPE = new TypeDescriptor<LinearTransferRef>(
+      LinearTransferRef.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<LinearTransferRef> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface Object<T0> {
     inner: Address;
   }
 
-  export class ObjectCore {
-    static TYPE_QNAME = "0x1::object::ObjectCore";
+  export namespace Object {
+    export const TYPE_QNAME = "0x1::object::Object";
+
+    const TYPE = new TypeDescriptor<Object<any>>(Object.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<Object<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface ObjectCore {
     guid_creation_num: bigint;
     owner: Address;
     allow_ungated_transfer: Boolean;
     transfer_events: event.EventHandle<object_.TransferEvent>;
   }
 
-  export class ObjectGroup {
-    static TYPE_QNAME = "0x1::object::ObjectGroup";
+  export namespace ObjectCore {
+    export const TYPE_QNAME = "0x1::object::ObjectCore";
+
+    const TYPE = new TypeDescriptor<ObjectCore>(ObjectCore.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<ObjectCore> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface ObjectGroup {
     dummy_field: Boolean;
   }
 
-  export class TransferEvent {
-    static TYPE_QNAME = "0x1::object::TransferEvent";
+  export namespace ObjectGroup {
+    export const TYPE_QNAME = "0x1::object::ObjectGroup";
+
+    const TYPE = new TypeDescriptor<ObjectGroup>(ObjectGroup.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<ObjectGroup> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface TransferEvent {
     object: Address;
     from: Address;
     to: Address;
   }
 
+  export namespace TransferEvent {
+    export const TYPE_QNAME = "0x1::object::TransferEvent";
+
+    const TYPE = new TypeDescriptor<TransferEvent>(TransferEvent.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<TransferEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface TransferEventInstance
     extends TypedEventInstance<TransferEvent> {
     data_decoded: TransferEvent;
     type_arguments: [];
   }
 
-  export class TransferRef {
-    static TYPE_QNAME = "0x1::object::TransferRef";
+  export interface TransferRef {
     self: Address;
   }
 
+  export namespace TransferRef {
+    export const TYPE_QNAME = "0x1::object::TransferRef";
+
+    const TYPE = new TypeDescriptor<TransferRef>(TransferRef.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<TransferRef> {
+      return TYPE.apply();
+    }
+  }
+
   export interface TransferCallPayload
     extends TypedFunctionPayload<[Address, Address]> {
     arguments_decoded: [Address, Address];
@@ -1269,19 +1856,39 @@ export namespace object_ {
 }
 
 export namespace option {
-  export class Option<T0> {
-    static TYPE_QNAME = "0x1::option::Option";
+  export interface Option<T0> {
     vec: T0[] | string;
   }
+
+  export namespace Option {
+    export const TYPE_QNAME = "0x1::option::Option";
+
+    const TYPE = new TypeDescriptor<Option<any>>(Option.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<Option<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
 }
 
 export namespace signer {}
 
 export namespace string_ {
-  export class String {
-    static TYPE_QNAME = "0x1::string::String";
+  export interface String {
     bytes: string;
   }
+
+  export namespace String {
+    export const TYPE_QNAME = "0x1::string::String";
+
+    const TYPE = new TypeDescriptor<String>(String.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<String> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace vector {}
@@ -1360,8 +1967,7 @@ export class voting extends AptosBaseProcessor {
 }
 
 export namespace voting {
-  export class CreateProposalEvent {
-    static TYPE_QNAME = "0x1::voting::CreateProposalEvent";
+  export interface CreateProposalEvent {
     proposal_id: bigint;
     early_resolution_vote_threshold: option.Option<bigint>;
     execution_hash: string;
@@ -1370,14 +1976,25 @@ export namespace voting {
     min_vote_threshold: bigint;
   }
 
+  export namespace CreateProposalEvent {
+    export const TYPE_QNAME = "0x1::voting::CreateProposalEvent";
+
+    const TYPE = new TypeDescriptor<CreateProposalEvent>(
+      CreateProposalEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<CreateProposalEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface CreateProposalEventInstance
     extends TypedEventInstance<CreateProposalEvent> {
     data_decoded: CreateProposalEvent;
     type_arguments: [];
   }
 
-  export class Proposal<T0> {
-    static TYPE_QNAME = "0x1::voting::Proposal";
+  export interface Proposal<T0> {
     proposer: Address;
     execution_content: option.Option<T0>;
     metadata: simple_map.SimpleMap<string, string>;
@@ -1392,57 +2009,120 @@ export namespace voting {
     resolution_time_secs: bigint;
   }
 
-  export class RegisterForumEvent {
-    static TYPE_QNAME = "0x1::voting::RegisterForumEvent";
+  export namespace Proposal {
+    export const TYPE_QNAME = "0x1::voting::Proposal";
+
+    const TYPE = new TypeDescriptor<Proposal<any>>(Proposal.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<Proposal<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface RegisterForumEvent {
     hosting_account: Address;
     proposal_type_info: type_info.TypeInfo;
   }
 
+  export namespace RegisterForumEvent {
+    export const TYPE_QNAME = "0x1::voting::RegisterForumEvent";
+
+    const TYPE = new TypeDescriptor<RegisterForumEvent>(
+      RegisterForumEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<RegisterForumEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface RegisterForumEventInstance
     extends TypedEventInstance<RegisterForumEvent> {
     data_decoded: RegisterForumEvent;
     type_arguments: [];
   }
 
-  export class ResolveProposal {
-    static TYPE_QNAME = "0x1::voting::ResolveProposal";
+  export interface ResolveProposal {
     proposal_id: bigint;
     yes_votes: bigint;
     no_votes: bigint;
     resolved_early: Boolean;
   }
 
+  export namespace ResolveProposal {
+    export const TYPE_QNAME = "0x1::voting::ResolveProposal";
+
+    const TYPE = new TypeDescriptor<ResolveProposal>(
+      ResolveProposal.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ResolveProposal> {
+      return TYPE.apply();
+    }
+  }
+
   export interface ResolveProposalInstance
     extends TypedEventInstance<ResolveProposal> {
     data_decoded: ResolveProposal;
     type_arguments: [];
   }
 
-  export class VoteEvent {
-    static TYPE_QNAME = "0x1::voting::VoteEvent";
+  export interface VoteEvent {
     proposal_id: bigint;
     num_votes: bigint;
   }
 
+  export namespace VoteEvent {
+    export const TYPE_QNAME = "0x1::voting::VoteEvent";
+
+    const TYPE = new TypeDescriptor<VoteEvent>(VoteEvent.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<VoteEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
     data_decoded: VoteEvent;
     type_arguments: [];
   }
 
-  export class VotingEvents {
-    static TYPE_QNAME = "0x1::voting::VotingEvents";
+  export 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>;
   }
 
-  export class VotingForum<T0> {
-    static TYPE_QNAME = "0x1::voting::VotingForum";
+  export namespace VotingEvents {
+    export const TYPE_QNAME = "0x1::voting::VotingEvents";
+
+    const TYPE = new TypeDescriptor<VotingEvents>(VotingEvents.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<VotingEvents> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface VotingForum<T0> {
     proposals: table.Table<bigint, voting.Proposal<T0>>;
     events: voting.VotingEvents;
     next_proposal_id: bigint;
   }
+
+  export namespace VotingForum {
+    export const TYPE_QNAME = "0x1::voting::VotingForum";
+
+    const TYPE = new TypeDescriptor<VotingForum<any>>(VotingForum.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<VotingForum<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
 }
 
 export class account extends AptosBaseProcessor {
@@ -1640,8 +2320,7 @@ export class account extends AptosBaseProcessor {
 }
 
 export namespace account {
-  export class Account {
-    static TYPE_QNAME = "0x1::account::Account";
+  export interface Account {
     authentication_key: string;
     sequence_number: bigint;
     guid_creation_num: bigint;
@@ -1651,84 +2330,221 @@ export namespace account {
     signer_capability_offer: account.CapabilityOffer<account.SignerCapability>;
   }
 
-  export class CapabilityOffer<T0> {
-    static TYPE_QNAME = "0x1::account::CapabilityOffer";
+  export namespace Account {
+    export const TYPE_QNAME = "0x1::account::Account";
+
+    const TYPE = new TypeDescriptor<Account>(Account.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Account> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface CapabilityOffer<T0> {
     for: option.Option<Address>;
   }
 
-  export class CoinRegisterEvent {
-    static TYPE_QNAME = "0x1::account::CoinRegisterEvent";
+  export namespace CapabilityOffer {
+    export const TYPE_QNAME = "0x1::account::CapabilityOffer";
+
+    const TYPE = new TypeDescriptor<CapabilityOffer<any>>(
+      CapabilityOffer.TYPE_QNAME
+    );
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<CapabilityOffer<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface CoinRegisterEvent {
     type_info: type_info.TypeInfo;
   }
 
+  export namespace CoinRegisterEvent {
+    export const TYPE_QNAME = "0x1::account::CoinRegisterEvent";
+
+    const TYPE = new TypeDescriptor<CoinRegisterEvent>(
+      CoinRegisterEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<CoinRegisterEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface CoinRegisterEventInstance
     extends TypedEventInstance<CoinRegisterEvent> {
     data_decoded: CoinRegisterEvent;
     type_arguments: [];
   }
 
-  export class KeyRotationEvent {
-    static TYPE_QNAME = "0x1::account::KeyRotationEvent";
+  export interface KeyRotationEvent {
     old_authentication_key: string;
     new_authentication_key: string;
   }
 
+  export namespace KeyRotationEvent {
+    export const TYPE_QNAME = "0x1::account::KeyRotationEvent";
+
+    const TYPE = new TypeDescriptor<KeyRotationEvent>(
+      KeyRotationEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<KeyRotationEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface KeyRotationEventInstance
     extends TypedEventInstance<KeyRotationEvent> {
     data_decoded: KeyRotationEvent;
     type_arguments: [];
   }
 
-  export class OriginatingAddress {
-    static TYPE_QNAME = "0x1::account::OriginatingAddress";
+  export interface OriginatingAddress {
     address_map: table.Table<Address, Address>;
   }
 
-  export class RotationCapability {
-    static TYPE_QNAME = "0x1::account::RotationCapability";
+  export namespace OriginatingAddress {
+    export const TYPE_QNAME = "0x1::account::OriginatingAddress";
+
+    const TYPE = new TypeDescriptor<OriginatingAddress>(
+      OriginatingAddress.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<OriginatingAddress> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface RotationCapability {
     account: Address;
   }
 
-  export class RotationCapabilityOfferProofChallenge {
-    static TYPE_QNAME = "0x1::account::RotationCapabilityOfferProofChallenge";
+  export namespace RotationCapability {
+    export const TYPE_QNAME = "0x1::account::RotationCapability";
+
+    const TYPE = new TypeDescriptor<RotationCapability>(
+      RotationCapability.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<RotationCapability> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface RotationCapabilityOfferProofChallenge {
     sequence_number: bigint;
     recipient_address: Address;
   }
 
-  export class RotationCapabilityOfferProofChallengeV2 {
-    static TYPE_QNAME = "0x1::account::RotationCapabilityOfferProofChallengeV2";
+  export namespace RotationCapabilityOfferProofChallenge {
+    export const TYPE_QNAME =
+      "0x1::account::RotationCapabilityOfferProofChallenge";
+
+    const TYPE = new TypeDescriptor<RotationCapabilityOfferProofChallenge>(
+      RotationCapabilityOfferProofChallenge.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<RotationCapabilityOfferProofChallenge> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface RotationCapabilityOfferProofChallengeV2 {
     chain_id: number;
     sequence_number: bigint;
     source_address: Address;
     recipient_address: Address;
   }
 
-  export class RotationProofChallenge {
-    static TYPE_QNAME = "0x1::account::RotationProofChallenge";
+  export namespace RotationCapabilityOfferProofChallengeV2 {
+    export const TYPE_QNAME =
+      "0x1::account::RotationCapabilityOfferProofChallengeV2";
+
+    const TYPE = new TypeDescriptor<RotationCapabilityOfferProofChallengeV2>(
+      RotationCapabilityOfferProofChallengeV2.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<RotationCapabilityOfferProofChallengeV2> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface RotationProofChallenge {
     sequence_number: bigint;
     originator: Address;
     current_auth_key: Address;
     new_public_key: string;
   }
 
-  export class SignerCapability {
-    static TYPE_QNAME = "0x1::account::SignerCapability";
+  export namespace RotationProofChallenge {
+    export const TYPE_QNAME = "0x1::account::RotationProofChallenge";
+
+    const TYPE = new TypeDescriptor<RotationProofChallenge>(
+      RotationProofChallenge.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<RotationProofChallenge> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface SignerCapability {
     account: Address;
   }
 
-  export class SignerCapabilityOfferProofChallenge {
-    static TYPE_QNAME = "0x1::account::SignerCapabilityOfferProofChallenge";
+  export namespace SignerCapability {
+    export const TYPE_QNAME = "0x1::account::SignerCapability";
+
+    const TYPE = new TypeDescriptor<SignerCapability>(
+      SignerCapability.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<SignerCapability> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface SignerCapabilityOfferProofChallenge {
     sequence_number: bigint;
     recipient_address: Address;
   }
 
-  export class SignerCapabilityOfferProofChallengeV2 {
-    static TYPE_QNAME = "0x1::account::SignerCapabilityOfferProofChallengeV2";
+  export namespace SignerCapabilityOfferProofChallenge {
+    export const TYPE_QNAME =
+      "0x1::account::SignerCapabilityOfferProofChallenge";
+
+    const TYPE = new TypeDescriptor<SignerCapabilityOfferProofChallenge>(
+      SignerCapabilityOfferProofChallenge.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<SignerCapabilityOfferProofChallenge> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface SignerCapabilityOfferProofChallengeV2 {
     sequence_number: bigint;
     source_address: Address;
     recipient_address: Address;
   }
 
+  export namespace SignerCapabilityOfferProofChallengeV2 {
+    export const TYPE_QNAME =
+      "0x1::account::SignerCapabilityOfferProofChallengeV2";
+
+    const TYPE = new TypeDescriptor<SignerCapabilityOfferProofChallengeV2>(
+      SignerCapabilityOfferProofChallengeV2.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<SignerCapabilityOfferProofChallengeV2> {
+      return TYPE.apply();
+    }
+  }
+
   export interface OfferRotationCapabilityPayload
     extends TypedFunctionPayload<[string, number, string, Address]> {
     arguments_decoded: [string, number, string, Address];
@@ -1781,37 +2597,89 @@ export namespace account {
 }
 
 export namespace ed25519 {
-  export class Signature {
-    static TYPE_QNAME = "0x1::ed25519::Signature";
+  export interface Signature {
     bytes: string;
   }
 
-  export class SignedMessage<T0> {
-    static TYPE_QNAME = "0x1::ed25519::SignedMessage";
+  export namespace Signature {
+    export const TYPE_QNAME = "0x1::ed25519::Signature";
+
+    const TYPE = new TypeDescriptor<Signature>(Signature.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Signature> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface SignedMessage<T0> {
     type_info: type_info.TypeInfo;
     inner: T0;
   }
 
-  export class UnvalidatedPublicKey {
-    static TYPE_QNAME = "0x1::ed25519::UnvalidatedPublicKey";
+  export namespace SignedMessage {
+    export const TYPE_QNAME = "0x1::ed25519::SignedMessage";
+
+    const TYPE = new TypeDescriptor<SignedMessage<any>>(
+      SignedMessage.TYPE_QNAME
+    );
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<SignedMessage<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface UnvalidatedPublicKey {
     bytes: string;
   }
 
-  export class ValidatedPublicKey {
-    static TYPE_QNAME = "0x1::ed25519::ValidatedPublicKey";
+  export namespace UnvalidatedPublicKey {
+    export const TYPE_QNAME = "0x1::ed25519::UnvalidatedPublicKey";
+
+    const TYPE = new TypeDescriptor<UnvalidatedPublicKey>(
+      UnvalidatedPublicKey.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<UnvalidatedPublicKey> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface ValidatedPublicKey {
     bytes: string;
   }
+
+  export namespace ValidatedPublicKey {
+    export const TYPE_QNAME = "0x1::ed25519::ValidatedPublicKey";
+
+    const TYPE = new TypeDescriptor<ValidatedPublicKey>(
+      ValidatedPublicKey.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ValidatedPublicKey> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace genesis {
-  export class AccountMap {
-    static TYPE_QNAME = "0x1::genesis::AccountMap";
+  export interface AccountMap {
     account_address: Address;
     balance: bigint;
   }
 
-  export class EmployeeAccountMap {
-    static TYPE_QNAME = "0x1::genesis::EmployeeAccountMap";
+  export namespace AccountMap {
+    export const TYPE_QNAME = "0x1::genesis::AccountMap";
+
+    const TYPE = new TypeDescriptor<AccountMap>(AccountMap.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<AccountMap> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface EmployeeAccountMap {
     accounts: Address[];
     validator: genesis.ValidatorConfigurationWithCommission;
     vesting_schedule_numerator: bigint[];
@@ -1819,8 +2687,19 @@ export namespace genesis {
     beneficiary_resetter: Address;
   }
 
-  export class ValidatorConfiguration {
-    static TYPE_QNAME = "0x1::genesis::ValidatorConfiguration";
+  export namespace EmployeeAccountMap {
+    export const TYPE_QNAME = "0x1::genesis::EmployeeAccountMap";
+
+    const TYPE = new TypeDescriptor<EmployeeAccountMap>(
+      EmployeeAccountMap.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<EmployeeAccountMap> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface ValidatorConfiguration {
     owner_address: Address;
     operator_address: Address;
     voter_address: Address;
@@ -1831,12 +2710,36 @@ export namespace genesis {
     full_node_network_addresses: string;
   }
 
-  export class ValidatorConfigurationWithCommission {
-    static TYPE_QNAME = "0x1::genesis::ValidatorConfigurationWithCommission";
+  export namespace ValidatorConfiguration {
+    export const TYPE_QNAME = "0x1::genesis::ValidatorConfiguration";
+
+    const TYPE = new TypeDescriptor<ValidatorConfiguration>(
+      ValidatorConfiguration.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ValidatorConfiguration> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface ValidatorConfigurationWithCommission {
     validator_config: genesis.ValidatorConfiguration;
     commission_percentage: bigint;
     join_during_genesis: Boolean;
   }
+
+  export namespace ValidatorConfigurationWithCommission {
+    export const TYPE_QNAME =
+      "0x1::genesis::ValidatorConfigurationWithCommission";
+
+    const TYPE = new TypeDescriptor<ValidatorConfigurationWithCommission>(
+      ValidatorConfigurationWithCommission.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ValidatorConfigurationWithCommission> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace math128 {}
@@ -1872,16 +2775,36 @@ export class version extends AptosBaseProcessor {
 }
 
 export namespace version {
-  export class SetVersionCapability {
-    static TYPE_QNAME = "0x1::version::SetVersionCapability";
+  export interface SetVersionCapability {
     dummy_field: Boolean;
   }
 
-  export class Version {
-    static TYPE_QNAME = "0x1::version::Version";
+  export namespace SetVersionCapability {
+    export const TYPE_QNAME = "0x1::version::SetVersionCapability";
+
+    const TYPE = new TypeDescriptor<SetVersionCapability>(
+      SetVersionCapability.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<SetVersionCapability> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface Version {
     major: bigint;
   }
 
+  export namespace Version {
+    export const TYPE_QNAME = "0x1::version::Version";
+
+    const TYPE = new TypeDescriptor<Version>(Version.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Version> {
+      return TYPE.apply();
+    }
+  }
+
   export interface SetVersionPayload extends TypedFunctionPayload<[bigint]> {
     arguments_decoded: [bigint];
     type_arguments: [];
@@ -2323,28 +3246,47 @@ export class vesting extends AptosBaseProcessor {
 }
 
 export namespace vesting {
-  export class AdminStore {
-    static TYPE_QNAME = "0x1::vesting::AdminStore";
+  export interface AdminStore {
     vesting_contracts: Address[];
     nonce: bigint;
     create_events: event.EventHandle<vesting.CreateVestingContractEvent>;
   }
 
-  export class AdminWithdrawEvent {
-    static TYPE_QNAME = "0x1::vesting::AdminWithdrawEvent";
+  export namespace AdminStore {
+    export const TYPE_QNAME = "0x1::vesting::AdminStore";
+
+    const TYPE = new TypeDescriptor<AdminStore>(AdminStore.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<AdminStore> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface AdminWithdrawEvent {
     admin: Address;
     vesting_contract_address: Address;
     amount: bigint;
   }
 
+  export namespace AdminWithdrawEvent {
+    export const TYPE_QNAME = "0x1::vesting::AdminWithdrawEvent";
+
+    const TYPE = new TypeDescriptor<AdminWithdrawEvent>(
+      AdminWithdrawEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<AdminWithdrawEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface AdminWithdrawEventInstance
     extends TypedEventInstance<AdminWithdrawEvent> {
     data_decoded: AdminWithdrawEvent;
     type_arguments: [];
   }
 
-  export class CreateVestingContractEvent {
-    static TYPE_QNAME = "0x1::vesting::CreateVestingContractEvent";
+  export interface CreateVestingContractEvent {
     operator: Address;
     voter: Address;
     grant_amount: bigint;
@@ -2354,41 +3296,74 @@ export namespace vesting {
     commission_percentage: bigint;
   }
 
+  export namespace CreateVestingContractEvent {
+    export const TYPE_QNAME = "0x1::vesting::CreateVestingContractEvent";
+
+    const TYPE = new TypeDescriptor<CreateVestingContractEvent>(
+      CreateVestingContractEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<CreateVestingContractEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface CreateVestingContractEventInstance
     extends TypedEventInstance<CreateVestingContractEvent> {
     data_decoded: CreateVestingContractEvent;
     type_arguments: [];
   }
 
-  export class DistributeEvent {
-    static TYPE_QNAME = "0x1::vesting::DistributeEvent";
+  export interface DistributeEvent {
     admin: Address;
     vesting_contract_address: Address;
     amount: bigint;
   }
 
+  export namespace DistributeEvent {
+    export const TYPE_QNAME = "0x1::vesting::DistributeEvent";
+
+    const TYPE = new TypeDescriptor<DistributeEvent>(
+      DistributeEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<DistributeEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface DistributeEventInstance
     extends TypedEventInstance<DistributeEvent> {
     data_decoded: DistributeEvent;
     type_arguments: [];
   }
 
-  export class ResetLockupEvent {
-    static TYPE_QNAME = "0x1::vesting::ResetLockupEvent";
+  export interface ResetLockupEvent {
     admin: Address;
     vesting_contract_address: Address;
     staking_pool_address: Address;
     new_lockup_expiration_secs: bigint;
   }
 
+  export namespace ResetLockupEvent {
+    export const TYPE_QNAME = "0x1::vesting::ResetLockupEvent";
+
+    const TYPE = new TypeDescriptor<ResetLockupEvent>(
+      ResetLockupEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ResetLockupEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface ResetLockupEventInstance
     extends TypedEventInstance<ResetLockupEvent> {
     data_decoded: ResetLockupEvent;
     type_arguments: [];
   }
 
-  export class SetBeneficiaryEvent {
-    static TYPE_QNAME = "0x1::vesting::SetBeneficiaryEvent";
+  export interface SetBeneficiaryEvent {
     admin: Address;
     vesting_contract_address: Address;
     shareholder: Address;
@@ -2396,48 +3371,88 @@ export namespace vesting {
     new_beneficiary: Address;
   }
 
+  export namespace SetBeneficiaryEvent {
+    export const TYPE_QNAME = "0x1::vesting::SetBeneficiaryEvent";
+
+    const TYPE = new TypeDescriptor<SetBeneficiaryEvent>(
+      SetBeneficiaryEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<SetBeneficiaryEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface SetBeneficiaryEventInstance
     extends TypedEventInstance<SetBeneficiaryEvent> {
     data_decoded: SetBeneficiaryEvent;
     type_arguments: [];
   }
 
-  export class StakingInfo {
-    static TYPE_QNAME = "0x1::vesting::StakingInfo";
+  export interface StakingInfo {
     pool_address: Address;
     operator: Address;
     voter: Address;
     commission_percentage: bigint;
   }
 
-  export class TerminateEvent {
-    static TYPE_QNAME = "0x1::vesting::TerminateEvent";
+  export namespace StakingInfo {
+    export const TYPE_QNAME = "0x1::vesting::StakingInfo";
+
+    const TYPE = new TypeDescriptor<StakingInfo>(StakingInfo.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<StakingInfo> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface TerminateEvent {
     admin: Address;
     vesting_contract_address: Address;
   }
 
+  export namespace TerminateEvent {
+    export const TYPE_QNAME = "0x1::vesting::TerminateEvent";
+
+    const TYPE = new TypeDescriptor<TerminateEvent>(TerminateEvent.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<TerminateEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface TerminateEventInstance
     extends TypedEventInstance<TerminateEvent> {
     data_decoded: TerminateEvent;
     type_arguments: [];
   }
 
-  export class UnlockRewardsEvent {
-    static TYPE_QNAME = "0x1::vesting::UnlockRewardsEvent";
+  export interface UnlockRewardsEvent {
     admin: Address;
     vesting_contract_address: Address;
     staking_pool_address: Address;
     amount: bigint;
   }
 
+  export namespace UnlockRewardsEvent {
+    export const TYPE_QNAME = "0x1::vesting::UnlockRewardsEvent";
+
+    const TYPE = new TypeDescriptor<UnlockRewardsEvent>(
+      UnlockRewardsEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<UnlockRewardsEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface UnlockRewardsEventInstance
     extends TypedEventInstance<UnlockRewardsEvent> {
     data_decoded: UnlockRewardsEvent;
     type_arguments: [];
   }
 
-  export class UpdateOperatorEvent {
-    static TYPE_QNAME = "0x1::vesting::UpdateOperatorEvent";
+  export interface UpdateOperatorEvent {
     admin: Address;
     vesting_contract_address: Address;
     staking_pool_address: Address;
@@ -2446,14 +3461,25 @@ export namespace vesting {
     commission_percentage: bigint;
   }
 
+  export namespace UpdateOperatorEvent {
+    export const TYPE_QNAME = "0x1::vesting::UpdateOperatorEvent";
+
+    const TYPE = new TypeDescriptor<UpdateOperatorEvent>(
+      UpdateOperatorEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<UpdateOperatorEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface UpdateOperatorEventInstance
     extends TypedEventInstance<UpdateOperatorEvent> {
     data_decoded: UpdateOperatorEvent;
     type_arguments: [];
   }
 
-  export class UpdateVoterEvent {
-    static TYPE_QNAME = "0x1::vesting::UpdateVoterEvent";
+  export interface UpdateVoterEvent {
     admin: Address;
     vesting_contract_address: Address;
     staking_pool_address: Address;
@@ -2461,14 +3487,25 @@ export namespace vesting {
     new_voter: Address;
   }
 
+  export namespace UpdateVoterEvent {
+    export const TYPE_QNAME = "0x1::vesting::UpdateVoterEvent";
+
+    const TYPE = new TypeDescriptor<UpdateVoterEvent>(
+      UpdateVoterEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<UpdateVoterEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface UpdateVoterEventInstance
     extends TypedEventInstance<UpdateVoterEvent> {
     data_decoded: UpdateVoterEvent;
     type_arguments: [];
   }
 
-  export class VestEvent {
-    static TYPE_QNAME = "0x1::vesting::VestEvent";
+  export interface VestEvent {
     admin: Address;
     vesting_contract_address: Address;
     staking_pool_address: Address;
@@ -2476,18 +3513,38 @@ export namespace vesting {
     amount: bigint;
   }
 
+  export namespace VestEvent {
+    export const TYPE_QNAME = "0x1::vesting::VestEvent";
+
+    const TYPE = new TypeDescriptor<VestEvent>(VestEvent.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<VestEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface VestEventInstance extends TypedEventInstance<VestEvent> {
     data_decoded: VestEvent;
     type_arguments: [];
   }
 
-  export class VestingAccountManagement {
-    static TYPE_QNAME = "0x1::vesting::VestingAccountManagement";
+  export interface VestingAccountManagement {
     roles: simple_map.SimpleMap<string, Address>;
   }
 
-  export class VestingContract {
-    static TYPE_QNAME = "0x1::vesting::VestingContract";
+  export namespace VestingAccountManagement {
+    export const TYPE_QNAME = "0x1::vesting::VestingAccountManagement";
+
+    const TYPE = new TypeDescriptor<VestingAccountManagement>(
+      VestingAccountManagement.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<VestingAccountManagement> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface VestingContract {
     state: bigint;
     admin: Address;
     grant_pool: pool_u64.Pool;
@@ -2508,14 +3565,37 @@ export namespace vesting {
     admin_withdraw_events: event.EventHandle<vesting.AdminWithdrawEvent>;
   }
 
-  export class VestingSchedule {
-    static TYPE_QNAME = "0x1::vesting::VestingSchedule";
+  export namespace VestingContract {
+    export const TYPE_QNAME = "0x1::vesting::VestingContract";
+
+    const TYPE = new TypeDescriptor<VestingContract>(
+      VestingContract.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<VestingContract> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface VestingSchedule {
     schedule: fixed_point32.FixedPoint32[];
     start_timestamp_secs: bigint;
     period_duration: bigint;
     last_vested_period: bigint;
   }
 
+  export namespace VestingSchedule {
+    export const TYPE_QNAME = "0x1::vesting::VestingSchedule";
+
+    const TYPE = new TypeDescriptor<VestingSchedule>(
+      VestingSchedule.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<VestingSchedule> {
+      return TYPE.apply();
+    }
+  }
+
   export interface AdminWithdrawPayload
     extends TypedFunctionPayload<[Address]> {
     arguments_decoded: [Address];
@@ -2598,68 +3678,147 @@ export namespace vesting {
     type_arguments: [];
   }
 
-  export interface VestPayload extends TypedFunctionPayload<[Address]> {
-    arguments_decoded: [Address];
-    type_arguments: [];
+  export interface VestPayload extends TypedFunctionPayload<[Address]> {
+    arguments_decoded: [Address];
+    type_arguments: [];
+  }
+
+  export interface VestManyPayload extends TypedFunctionPayload<[Address[]]> {
+    arguments_decoded: [Address[]];
+    type_arguments: [];
+  }
+}
+
+export namespace bls12381 {
+  export interface AggrOrMultiSignature {
+    bytes: string;
+  }
+
+  export namespace AggrOrMultiSignature {
+    export const TYPE_QNAME = "0x1::bls12381::AggrOrMultiSignature";
+
+    const TYPE = new TypeDescriptor<AggrOrMultiSignature>(
+      AggrOrMultiSignature.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<AggrOrMultiSignature> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface AggrPublicKeysWithPoP {
+    bytes: string;
+  }
+
+  export namespace AggrPublicKeysWithPoP {
+    export const TYPE_QNAME = "0x1::bls12381::AggrPublicKeysWithPoP";
+
+    const TYPE = new TypeDescriptor<AggrPublicKeysWithPoP>(
+      AggrPublicKeysWithPoP.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<AggrPublicKeysWithPoP> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface ProofOfPossession {
+    bytes: string;
   }
 
-  export interface VestManyPayload extends TypedFunctionPayload<[Address[]]> {
-    arguments_decoded: [Address[]];
-    type_arguments: [];
+  export namespace ProofOfPossession {
+    export const TYPE_QNAME = "0x1::bls12381::ProofOfPossession";
+
+    const TYPE = new TypeDescriptor<ProofOfPossession>(
+      ProofOfPossession.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ProofOfPossession> {
+      return TYPE.apply();
+    }
   }
-}
 
-export namespace bls12381 {
-  export class AggrOrMultiSignature {
-    static TYPE_QNAME = "0x1::bls12381::AggrOrMultiSignature";
+  export interface PublicKey {
     bytes: string;
   }
 
-  export class AggrPublicKeysWithPoP {
-    static TYPE_QNAME = "0x1::bls12381::AggrPublicKeysWithPoP";
-    bytes: string;
+  export namespace PublicKey {
+    export const TYPE_QNAME = "0x1::bls12381::PublicKey";
+
+    const TYPE = new TypeDescriptor<PublicKey>(PublicKey.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<PublicKey> {
+      return TYPE.apply();
+    }
   }
 
-  export class ProofOfPossession {
-    static TYPE_QNAME = "0x1::bls12381::ProofOfPossession";
+  export interface PublicKeyWithPoP {
     bytes: string;
   }
 
-  export class PublicKey {
-    static TYPE_QNAME = "0x1::bls12381::PublicKey";
-    bytes: string;
+  export namespace PublicKeyWithPoP {
+    export const TYPE_QNAME = "0x1::bls12381::PublicKeyWithPoP";
+
+    const TYPE = new TypeDescriptor<PublicKeyWithPoP>(
+      PublicKeyWithPoP.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<PublicKeyWithPoP> {
+      return TYPE.apply();
+    }
   }
 
-  export class PublicKeyWithPoP {
-    static TYPE_QNAME = "0x1::bls12381::PublicKeyWithPoP";
+  export interface Signature {
     bytes: string;
   }
 
-  export class Signature {
-    static TYPE_QNAME = "0x1::bls12381::Signature";
-    bytes: string;
+  export namespace Signature {
+    export const TYPE_QNAME = "0x1::bls12381::Signature";
+
+    const TYPE = new TypeDescriptor<Signature>(Signature.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Signature> {
+      return TYPE.apply();
+    }
   }
 }
 
 export namespace chain_id {
-  export class ChainId {
-    static TYPE_QNAME = "0x1::chain_id::ChainId";
+  export interface ChainId {
     id: number;
   }
+
+  export namespace ChainId {
+    export const TYPE_QNAME = "0x1::chain_id::ChainId";
+
+    const TYPE = new TypeDescriptor<ChainId>(ChainId.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<ChainId> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace features {
-  export class Features {
-    static TYPE_QNAME = "0x1::features::Features";
+  export interface Features {
     features: string;
   }
+
+  export namespace Features {
+    export const TYPE_QNAME = "0x1::features::Features";
+
+    const TYPE = new TypeDescriptor<Features>(Features.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Features> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace from_bcs {}
 
 export namespace pool_u64 {
-  export class Pool {
-    static TYPE_QNAME = "0x1::pool_u64::Pool";
+  export interface Pool {
     shareholders_limit: bigint;
     total_coins: bigint;
     total_shares: bigint;
@@ -2667,43 +3826,102 @@ export namespace pool_u64 {
     shareholders: Address[];
     scaling_factor: bigint;
   }
+
+  export namespace Pool {
+    export const TYPE_QNAME = "0x1::pool_u64::Pool";
+
+    const TYPE = new TypeDescriptor<Pool>(Pool.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Pool> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace secp256k1 {
-  export class ECDSARawPublicKey {
-    static TYPE_QNAME = "0x1::secp256k1::ECDSARawPublicKey";
+  export interface ECDSARawPublicKey {
     bytes: string;
   }
 
-  export class ECDSASignature {
-    static TYPE_QNAME = "0x1::secp256k1::ECDSASignature";
+  export namespace ECDSARawPublicKey {
+    export const TYPE_QNAME = "0x1::secp256k1::ECDSARawPublicKey";
+
+    const TYPE = new TypeDescriptor<ECDSARawPublicKey>(
+      ECDSARawPublicKey.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ECDSARawPublicKey> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface ECDSASignature {
     bytes: string;
   }
+
+  export namespace ECDSASignature {
+    export const TYPE_QNAME = "0x1::secp256k1::ECDSASignature";
+
+    const TYPE = new TypeDescriptor<ECDSASignature>(ECDSASignature.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<ECDSASignature> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace timestamp {
-  export class CurrentTimeMicroseconds {
-    static TYPE_QNAME = "0x1::timestamp::CurrentTimeMicroseconds";
+  export interface CurrentTimeMicroseconds {
     microseconds: bigint;
   }
+
+  export namespace CurrentTimeMicroseconds {
+    export const TYPE_QNAME = "0x1::timestamp::CurrentTimeMicroseconds";
+
+    const TYPE = new TypeDescriptor<CurrentTimeMicroseconds>(
+      CurrentTimeMicroseconds.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<CurrentTimeMicroseconds> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace type_info {
-  export class TypeInfo {
-    static TYPE_QNAME = "0x1::type_info::TypeInfo";
+  export interface TypeInfo {
     account_address: Address;
     module_name: string;
     struct_name: string;
   }
+
+  export namespace TypeInfo {
+    export const TYPE_QNAME = "0x1::type_info::TypeInfo";
+
+    const TYPE = new TypeDescriptor<TypeInfo>(TypeInfo.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<TypeInfo> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace aggregator {
-  export class Aggregator {
-    static TYPE_QNAME = "0x1::aggregator::Aggregator";
+  export interface Aggregator {
     handle: Address;
     key: Address;
     limit: bigint;
   }
+
+  export namespace Aggregator {
+    export const TYPE_QNAME = "0x1::aggregator::Aggregator";
+
+    const TYPE = new TypeDescriptor<Aggregator>(Aggregator.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Aggregator> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export class aptos_coin extends AptosBaseProcessor {
@@ -2775,26 +3993,64 @@ export class aptos_coin extends AptosBaseProcessor {
 }
 
 export namespace aptos_coin {
-  export class AptosCoin {
-    static TYPE_QNAME = "0x1::aptos_coin::AptosCoin";
+  export interface AptosCoin {
     dummy_field: Boolean;
   }
 
-  export class DelegatedMintCapability {
-    static TYPE_QNAME = "0x1::aptos_coin::DelegatedMintCapability";
+  export namespace AptosCoin {
+    export const TYPE_QNAME = "0x1::aptos_coin::AptosCoin";
+
+    const TYPE = new TypeDescriptor<AptosCoin>(AptosCoin.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<AptosCoin> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface DelegatedMintCapability {
     to: Address;
   }
 
-  export class Delegations {
-    static TYPE_QNAME = "0x1::aptos_coin::Delegations";
+  export namespace DelegatedMintCapability {
+    export const TYPE_QNAME = "0x1::aptos_coin::DelegatedMintCapability";
+
+    const TYPE = new TypeDescriptor<DelegatedMintCapability>(
+      DelegatedMintCapability.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<DelegatedMintCapability> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface Delegations {
     inner: aptos_coin.DelegatedMintCapability[];
   }
 
-  export class MintCapStore {
-    static TYPE_QNAME = "0x1::aptos_coin::MintCapStore";
+  export namespace Delegations {
+    export const TYPE_QNAME = "0x1::aptos_coin::Delegations";
+
+    const TYPE = new TypeDescriptor<Delegations>(Delegations.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Delegations> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface MintCapStore {
     mint_cap: coin.MintCapability<aptos_coin.AptosCoin>;
   }
 
+  export namespace MintCapStore {
+    export const TYPE_QNAME = "0x1::aptos_coin::MintCapStore";
+
+    const TYPE = new TypeDescriptor<MintCapStore>(MintCapStore.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<MintCapStore> {
+      return TYPE.apply();
+    }
+  }
+
   export interface ClaimMintCapabilityPayload extends TypedFunctionPayload<[]> {
     arguments_decoded: [];
     type_arguments: [];
@@ -2815,76 +4071,186 @@ export namespace aptos_coin {
 export namespace aptos_hash {}
 
 export namespace big_vector {
-  export class BigVector<T0> {
-    static TYPE_QNAME = "0x1::big_vector::BigVector";
+  export interface BigVector<T0> {
     buckets: table_with_length.TableWithLength<bigint, T0[] | string>;
     end_index: bigint;
     bucket_size: bigint;
   }
+
+  export namespace BigVector {
+    export const TYPE_QNAME = "0x1::big_vector::BigVector";
+
+    const TYPE = new TypeDescriptor<BigVector<any>>(BigVector.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<BigVector<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
 }
 
 export namespace bit_vector {
-  export class BitVector {
-    static TYPE_QNAME = "0x1::bit_vector::BitVector";
+  export interface BitVector {
     length: bigint;
     bit_field: Boolean[];
   }
+
+  export namespace BitVector {
+    export const TYPE_QNAME = "0x1::bit_vector::BitVector";
+
+    const TYPE = new TypeDescriptor<BitVector>(BitVector.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<BitVector> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace capability {
-  export class Cap<T0> {
-    static TYPE_QNAME = "0x1::capability::Cap";
+  export interface Cap<T0> {
     root: Address;
   }
 
-  export class CapDelegateState<T0> {
-    static TYPE_QNAME = "0x1::capability::CapDelegateState";
+  export namespace Cap {
+    export const TYPE_QNAME = "0x1::capability::Cap";
+
+    const TYPE = new TypeDescriptor<Cap<any>>(Cap.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<Cap<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface CapDelegateState<T0> {
     root: Address;
   }
 
-  export class CapState<T0> {
-    static TYPE_QNAME = "0x1::capability::CapState";
+  export namespace CapDelegateState {
+    export const TYPE_QNAME = "0x1::capability::CapDelegateState";
+
+    const TYPE = new TypeDescriptor<CapDelegateState<any>>(
+      CapDelegateState.TYPE_QNAME
+    );
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<CapDelegateState<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface CapState<T0> {
     delegates: Address[];
   }
 
-  export class LinearCap<T0> {
-    static TYPE_QNAME = "0x1::capability::LinearCap";
+  export namespace CapState {
+    export const TYPE_QNAME = "0x1::capability::CapState";
+
+    const TYPE = new TypeDescriptor<CapState<any>>(CapState.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<CapState<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface LinearCap<T0> {
     root: Address;
   }
+
+  export namespace LinearCap {
+    export const TYPE_QNAME = "0x1::capability::LinearCap";
+
+    const TYPE = new TypeDescriptor<LinearCap<any>>(LinearCap.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<LinearCap<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
 }
 
 export namespace comparator {
-  export class Result {
-    static TYPE_QNAME = "0x1::comparator::Result";
+  export interface Result {
     inner: number;
   }
+
+  export namespace Result {
+    export const TYPE_QNAME = "0x1::comparator::Result";
+
+    const TYPE = new TypeDescriptor<Result>(Result.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Result> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace math_fixed {}
 
 export namespace simple_map {
-  export class Element<T0, T1> {
-    static TYPE_QNAME = "0x1::simple_map::Element";
+  export interface Element<T0, T1> {
     key: T0;
     value: T1;
   }
 
-  export class SimpleMap<T0, T1> {
-    static TYPE_QNAME = "0x1::simple_map::SimpleMap";
+  export namespace Element {
+    export const TYPE_QNAME = "0x1::simple_map::Element";
+
+    const TYPE = new TypeDescriptor<Element<any, any>>(Element.TYPE_QNAME);
+
+    export function type<T0, T1>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE,
+      arg1: TypeDescriptor<T1> = ANY_TYPE
+    ): TypeDescriptor<Element<T0, T1>> {
+      return TYPE.apply(arg0, arg1);
+    }
+  }
+
+  export interface SimpleMap<T0, T1> {
     data: simple_map.Element<T0, T1>[];
   }
+
+  export namespace SimpleMap {
+    export const TYPE_QNAME = "0x1::simple_map::SimpleMap";
+
+    const TYPE = new TypeDescriptor<SimpleMap<any, any>>(SimpleMap.TYPE_QNAME);
+
+    export function type<T0, T1>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE,
+      arg1: TypeDescriptor<T1> = ANY_TYPE
+    ): TypeDescriptor<SimpleMap<T0, T1>> {
+      return TYPE.apply(arg0, arg1);
+    }
+  }
 }
 
 export namespace smart_table {
-  export class Entry<T0, T1> {
-    static TYPE_QNAME = "0x1::smart_table::Entry";
+  export interface Entry<T0, T1> {
     hash: bigint;
     key: T0;
     value: T1;
   }
 
-  export class SmartTable<T0, T1> {
-    static TYPE_QNAME = "0x1::smart_table::SmartTable";
+  export namespace Entry {
+    export const TYPE_QNAME = "0x1::smart_table::Entry";
+
+    const TYPE = new TypeDescriptor<Entry<any, any>>(Entry.TYPE_QNAME);
+
+    export function type<T0, T1>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE,
+      arg1: TypeDescriptor<T1> = ANY_TYPE
+    ): TypeDescriptor<Entry<T0, T1>> {
+      return TYPE.apply(arg0, arg1);
+    }
+  }
+
+  export interface SmartTable<T0, T1> {
     buckets: table_with_length.TableWithLength<
       bigint,
       smart_table.Entry<T0, T1>[]
@@ -2895,24 +4261,56 @@ export namespace smart_table {
     split_load_threshold: number;
     target_bucket_size: bigint;
   }
+
+  export namespace SmartTable {
+    export const TYPE_QNAME = "0x1::smart_table::SmartTable";
+
+    const TYPE = new TypeDescriptor<SmartTable<any, any>>(
+      SmartTable.TYPE_QNAME
+    );
+
+    export function type<T0, T1>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE,
+      arg1: TypeDescriptor<T1> = ANY_TYPE
+    ): TypeDescriptor<SmartTable<T0, T1>> {
+      return TYPE.apply(arg0, arg1);
+    }
+  }
 }
 
 export namespace storage_gas {
-  export class GasCurve {
-    static TYPE_QNAME = "0x1::storage_gas::GasCurve";
+  export interface GasCurve {
     min_gas: bigint;
     max_gas: bigint;
     points: storage_gas.Point[];
   }
 
-  export class Point {
-    static TYPE_QNAME = "0x1::storage_gas::Point";
+  export namespace GasCurve {
+    export const TYPE_QNAME = "0x1::storage_gas::GasCurve";
+
+    const TYPE = new TypeDescriptor<GasCurve>(GasCurve.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<GasCurve> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface Point {
     x: bigint;
     y: bigint;
   }
 
-  export class StorageGas {
-    static TYPE_QNAME = "0x1::storage_gas::StorageGas";
+  export namespace Point {
+    export const TYPE_QNAME = "0x1::storage_gas::Point";
+
+    const TYPE = new TypeDescriptor<Point>(Point.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Point> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface StorageGas {
     per_item_read: bigint;
     per_item_create: bigint;
     per_item_write: bigint;
@@ -2921,53 +4319,130 @@ export namespace storage_gas {
     per_byte_write: bigint;
   }
 
-  export class StorageGasConfig {
-    static TYPE_QNAME = "0x1::storage_gas::StorageGasConfig";
+  export namespace StorageGas {
+    export const TYPE_QNAME = "0x1::storage_gas::StorageGas";
+
+    const TYPE = new TypeDescriptor<StorageGas>(StorageGas.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<StorageGas> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface StorageGasConfig {
     item_config: storage_gas.UsageGasConfig;
     byte_config: storage_gas.UsageGasConfig;
   }
 
-  export class UsageGasConfig {
-    static TYPE_QNAME = "0x1::storage_gas::UsageGasConfig";
+  export namespace StorageGasConfig {
+    export const TYPE_QNAME = "0x1::storage_gas::StorageGasConfig";
+
+    const TYPE = new TypeDescriptor<StorageGasConfig>(
+      StorageGasConfig.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<StorageGasConfig> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface UsageGasConfig {
     target_usage: bigint;
     read_curve: storage_gas.GasCurve;
     create_curve: storage_gas.GasCurve;
     write_curve: storage_gas.GasCurve;
   }
+
+  export namespace UsageGasConfig {
+    export const TYPE_QNAME = "0x1::storage_gas::UsageGasConfig";
+
+    const TYPE = new TypeDescriptor<UsageGasConfig>(UsageGasConfig.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<UsageGasConfig> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace chain_status {
-  export class GenesisEndMarker {
-    static TYPE_QNAME = "0x1::chain_status::GenesisEndMarker";
+  export interface GenesisEndMarker {
     dummy_field: Boolean;
   }
+
+  export namespace GenesisEndMarker {
+    export const TYPE_QNAME = "0x1::chain_status::GenesisEndMarker";
+
+    const TYPE = new TypeDescriptor<GenesisEndMarker>(
+      GenesisEndMarker.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<GenesisEndMarker> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace copyable_any {
-  export class Any {
-    static TYPE_QNAME = "0x1::copyable_any::Any";
+  export interface Any {
     type_name: string;
     data: string;
   }
+
+  export namespace Any {
+    export const TYPE_QNAME = "0x1::copyable_any::Any";
+
+    const TYPE = new TypeDescriptor<Any>(Any.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Any> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace gas_schedule {
-  export class GasEntry {
-    static TYPE_QNAME = "0x1::gas_schedule::GasEntry";
+  export interface GasEntry {
     key: string;
     val: bigint;
   }
 
-  export class GasSchedule {
-    static TYPE_QNAME = "0x1::gas_schedule::GasSchedule";
+  export namespace GasEntry {
+    export const TYPE_QNAME = "0x1::gas_schedule::GasEntry";
+
+    const TYPE = new TypeDescriptor<GasEntry>(GasEntry.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<GasEntry> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface GasSchedule {
     entries: gas_schedule.GasEntry[];
   }
 
-  export class GasScheduleV2 {
-    static TYPE_QNAME = "0x1::gas_schedule::GasScheduleV2";
+  export namespace GasSchedule {
+    export const TYPE_QNAME = "0x1::gas_schedule::GasSchedule";
+
+    const TYPE = new TypeDescriptor<GasSchedule>(GasSchedule.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<GasSchedule> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface GasScheduleV2 {
     feature_version: bigint;
     entries: gas_schedule.GasEntry[];
   }
+
+  export namespace GasScheduleV2 {
+    export const TYPE_QNAME = "0x1::gas_schedule::GasScheduleV2";
+
+    const TYPE = new TypeDescriptor<GasScheduleV2>(GasScheduleV2.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<GasScheduleV2> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export class managed_coin extends AptosBaseProcessor {
@@ -3049,13 +4524,24 @@ export class managed_coin extends AptosBaseProcessor {
 }
 
 export namespace managed_coin {
-  export class Capabilities<T0> {
-    static TYPE_QNAME = "0x1::managed_coin::Capabilities";
+  export interface Capabilities<T0> {
     burn_cap: coin.BurnCapability<T0>;
     freeze_cap: coin.FreezeCapability<T0>;
     mint_cap: coin.MintCapability<T0>;
   }
 
+  export namespace Capabilities {
+    export const TYPE_QNAME = "0x1::managed_coin::Capabilities";
+
+    const TYPE = new TypeDescriptor<Capabilities<any>>(Capabilities.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<Capabilities<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
   export interface BurnPayload<T0 = any>
     extends TypedFunctionPayload<[bigint]> {
     arguments_decoded: [bigint];
@@ -3081,30 +4567,70 @@ export namespace managed_coin {
 }
 
 export namespace ristretto255 {
-  export class CompressedRistretto {
-    static TYPE_QNAME = "0x1::ristretto255::CompressedRistretto";
+  export interface CompressedRistretto {
     data: string;
   }
 
-  export class RistrettoPoint {
-    static TYPE_QNAME = "0x1::ristretto255::RistrettoPoint";
+  export namespace CompressedRistretto {
+    export const TYPE_QNAME = "0x1::ristretto255::CompressedRistretto";
+
+    const TYPE = new TypeDescriptor<CompressedRistretto>(
+      CompressedRistretto.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<CompressedRistretto> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface RistrettoPoint {
     handle: bigint;
   }
 
-  export class Scalar {
-    static TYPE_QNAME = "0x1::ristretto255::Scalar";
+  export namespace RistrettoPoint {
+    export const TYPE_QNAME = "0x1::ristretto255::RistrettoPoint";
+
+    const TYPE = new TypeDescriptor<RistrettoPoint>(RistrettoPoint.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<RistrettoPoint> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface Scalar {
     data: string;
   }
+
+  export namespace Scalar {
+    export const TYPE_QNAME = "0x1::ristretto255::Scalar";
+
+    const TYPE = new TypeDescriptor<Scalar>(Scalar.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Scalar> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace smart_vector {
-  export class SmartVector<T0> {
-    static TYPE_QNAME = "0x1::smart_vector::SmartVector";
+  export interface SmartVector<T0> {
     inline_vec: T0[] | string;
     big_vec: big_vector.BigVector<T0>[];
     inline_capacity: option.Option<bigint>;
     bucket_size: option.Option<bigint>;
   }
+
+  export namespace SmartVector {
+    export const TYPE_QNAME = "0x1::smart_vector::SmartVector";
+
+    const TYPE = new TypeDescriptor<SmartVector<any>>(SmartVector.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<SmartVector<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
 }
 
 export class aptos_account extends AptosBaseProcessor {
@@ -3241,24 +4767,46 @@ export class aptos_account extends AptosBaseProcessor {
 }
 
 export namespace aptos_account {
-  export class DirectCoinTransferConfigUpdatedEvent {
-    static TYPE_QNAME =
-      "0x1::aptos_account::DirectCoinTransferConfigUpdatedEvent";
+  export interface DirectCoinTransferConfigUpdatedEvent {
     new_allow_direct_transfers: Boolean;
   }
 
+  export namespace DirectCoinTransferConfigUpdatedEvent {
+    export const TYPE_QNAME =
+      "0x1::aptos_account::DirectCoinTransferConfigUpdatedEvent";
+
+    const TYPE = new TypeDescriptor<DirectCoinTransferConfigUpdatedEvent>(
+      DirectCoinTransferConfigUpdatedEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<DirectCoinTransferConfigUpdatedEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface DirectCoinTransferConfigUpdatedEventInstance
     extends TypedEventInstance<DirectCoinTransferConfigUpdatedEvent> {
     data_decoded: DirectCoinTransferConfigUpdatedEvent;
     type_arguments: [];
   }
 
-  export class DirectTransferConfig {
-    static TYPE_QNAME = "0x1::aptos_account::DirectTransferConfig";
+  export interface DirectTransferConfig {
     allow_arbitrary_coin_transfers: Boolean;
     update_coin_transfer_events: event.EventHandle<aptos_account.DirectCoinTransferConfigUpdatedEvent>;
   }
 
+  export namespace DirectTransferConfig {
+    export const TYPE_QNAME = "0x1::aptos_account::DirectTransferConfig";
+
+    const TYPE = new TypeDescriptor<DirectTransferConfig>(
+      DirectTransferConfig.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<DirectTransferConfig> {
+      return TYPE.apply();
+    }
+  }
+
   export interface BatchTransferPayload
     extends TypedFunctionPayload<[Address[], bigint[]]> {
     arguments_decoded: [Address[], bigint[]];
@@ -3299,27 +4847,67 @@ export namespace aptos_account {
 export namespace create_signer {}
 
 export namespace fixed_point32 {
-  export class FixedPoint32 {
-    static TYPE_QNAME = "0x1::fixed_point32::FixedPoint32";
+  export interface FixedPoint32 {
     value: bigint;
   }
+
+  export namespace FixedPoint32 {
+    export const TYPE_QNAME = "0x1::fixed_point32::FixedPoint32";
+
+    const TYPE = new TypeDescriptor<FixedPoint32>(FixedPoint32.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<FixedPoint32> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace multi_ed25519 {
-  export class Signature {
-    static TYPE_QNAME = "0x1::multi_ed25519::Signature";
+  export interface Signature {
     bytes: string;
   }
 
-  export class UnvalidatedPublicKey {
-    static TYPE_QNAME = "0x1::multi_ed25519::UnvalidatedPublicKey";
+  export namespace Signature {
+    export const TYPE_QNAME = "0x1::multi_ed25519::Signature";
+
+    const TYPE = new TypeDescriptor<Signature>(Signature.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Signature> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface UnvalidatedPublicKey {
     bytes: string;
   }
 
-  export class ValidatedPublicKey {
-    static TYPE_QNAME = "0x1::multi_ed25519::ValidatedPublicKey";
+  export namespace UnvalidatedPublicKey {
+    export const TYPE_QNAME = "0x1::multi_ed25519::UnvalidatedPublicKey";
+
+    const TYPE = new TypeDescriptor<UnvalidatedPublicKey>(
+      UnvalidatedPublicKey.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<UnvalidatedPublicKey> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface ValidatedPublicKey {
     bytes: string;
   }
+
+  export namespace ValidatedPublicKey {
+    export const TYPE_QNAME = "0x1::multi_ed25519::ValidatedPublicKey";
+
+    const TYPE = new TypeDescriptor<ValidatedPublicKey>(
+      ValidatedPublicKey.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ValidatedPublicKey> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export class staking_proxy extends AptosBaseProcessor {
@@ -3533,27 +5121,55 @@ export namespace staking_proxy {
 }
 
 export namespace state_storage {
-  export class GasParameter {
-    static TYPE_QNAME = "0x1::state_storage::GasParameter";
+  export interface GasParameter {
     usage: state_storage.Usage;
   }
 
-  export class StateStorageUsage {
-    static TYPE_QNAME = "0x1::state_storage::StateStorageUsage";
+  export namespace GasParameter {
+    export const TYPE_QNAME = "0x1::state_storage::GasParameter";
+
+    const TYPE = new TypeDescriptor<GasParameter>(GasParameter.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<GasParameter> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface StateStorageUsage {
     epoch: bigint;
     usage: state_storage.Usage;
   }
 
-  export class Usage {
-    static TYPE_QNAME = "0x1::state_storage::Usage";
+  export namespace StateStorageUsage {
+    export const TYPE_QNAME = "0x1::state_storage::StateStorageUsage";
+
+    const TYPE = new TypeDescriptor<StateStorageUsage>(
+      StateStorageUsage.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<StateStorageUsage> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface Usage {
     items: bigint;
     bytes: bigint;
   }
+
+  export namespace Usage {
+    export const TYPE_QNAME = "0x1::state_storage::Usage";
+
+    const TYPE = new TypeDescriptor<Usage>(Usage.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Usage> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace staking_config {
-  export class StakingConfig {
-    static TYPE_QNAME = "0x1::staking_config::StakingConfig";
+  export interface StakingConfig {
     minimum_stake: bigint;
     maximum_stake: bigint;
     recurring_lockup_duration_secs: bigint;
@@ -3562,6 +5178,16 @@ export namespace staking_config {
     rewards_rate_denominator: bigint;
     voting_power_increase_limit: bigint;
   }
+
+  export namespace StakingConfig {
+    export const TYPE_QNAME = "0x1::staking_config::StakingConfig";
+
+    const TYPE = new TypeDescriptor<StakingConfig>(StakingConfig.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<StakingConfig> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export class delegation_pool extends AptosBaseProcessor {
@@ -3807,22 +5433,30 @@ export class delegation_pool extends AptosBaseProcessor {
 }
 
 export namespace delegation_pool {
-  export class AddStakeEvent {
-    static TYPE_QNAME = "0x1::delegation_pool::AddStakeEvent";
+  export interface AddStakeEvent {
     pool_address: Address;
     delegator_address: Address;
     amount_added: bigint;
     add_stake_fee: bigint;
   }
 
+  export namespace AddStakeEvent {
+    export const TYPE_QNAME = "0x1::delegation_pool::AddStakeEvent";
+
+    const TYPE = new TypeDescriptor<AddStakeEvent>(AddStakeEvent.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<AddStakeEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface AddStakeEventInstance
     extends TypedEventInstance<AddStakeEvent> {
     data_decoded: AddStakeEvent;
     type_arguments: [];
   }
 
-  export class DelegationPool {
-    static TYPE_QNAME = "0x1::delegation_pool::DelegationPool";
+  export interface DelegationPool {
     active_shares: pool_u64_unbound.Pool;
     observed_lockup_cycle: delegation_pool.ObservedLockupCycle;
     inactive_shares: table.Table<
@@ -3843,63 +5477,139 @@ export namespace delegation_pool {
     distribute_commission_events: event.EventHandle<delegation_pool.DistributeCommissionEvent>;
   }
 
-  export class DelegationPoolOwnership {
-    static TYPE_QNAME = "0x1::delegation_pool::DelegationPoolOwnership";
+  export namespace DelegationPool {
+    export const TYPE_QNAME = "0x1::delegation_pool::DelegationPool";
+
+    const TYPE = new TypeDescriptor<DelegationPool>(DelegationPool.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<DelegationPool> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface DelegationPoolOwnership {
     pool_address: Address;
   }
 
-  export class DistributeCommissionEvent {
-    static TYPE_QNAME = "0x1::delegation_pool::DistributeCommissionEvent";
+  export namespace DelegationPoolOwnership {
+    export const TYPE_QNAME = "0x1::delegation_pool::DelegationPoolOwnership";
+
+    const TYPE = new TypeDescriptor<DelegationPoolOwnership>(
+      DelegationPoolOwnership.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<DelegationPoolOwnership> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface DistributeCommissionEvent {
     pool_address: Address;
     operator: Address;
     commission_active: bigint;
     commission_pending_inactive: bigint;
   }
 
+  export namespace DistributeCommissionEvent {
+    export const TYPE_QNAME = "0x1::delegation_pool::DistributeCommissionEvent";
+
+    const TYPE = new TypeDescriptor<DistributeCommissionEvent>(
+      DistributeCommissionEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<DistributeCommissionEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface DistributeCommissionEventInstance
     extends TypedEventInstance<DistributeCommissionEvent> {
     data_decoded: DistributeCommissionEvent;
     type_arguments: [];
   }
 
-  export class ObservedLockupCycle {
-    static TYPE_QNAME = "0x1::delegation_pool::ObservedLockupCycle";
+  export interface ObservedLockupCycle {
     index: bigint;
   }
 
-  export class ReactivateStakeEvent {
-    static TYPE_QNAME = "0x1::delegation_pool::ReactivateStakeEvent";
+  export namespace ObservedLockupCycle {
+    export const TYPE_QNAME = "0x1::delegation_pool::ObservedLockupCycle";
+
+    const TYPE = new TypeDescriptor<ObservedLockupCycle>(
+      ObservedLockupCycle.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ObservedLockupCycle> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface ReactivateStakeEvent {
     pool_address: Address;
     delegator_address: Address;
     amount_reactivated: bigint;
   }
 
+  export namespace ReactivateStakeEvent {
+    export const TYPE_QNAME = "0x1::delegation_pool::ReactivateStakeEvent";
+
+    const TYPE = new TypeDescriptor<ReactivateStakeEvent>(
+      ReactivateStakeEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ReactivateStakeEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface ReactivateStakeEventInstance
     extends TypedEventInstance<ReactivateStakeEvent> {
     data_decoded: ReactivateStakeEvent;
     type_arguments: [];
   }
 
-  export class UnlockStakeEvent {
-    static TYPE_QNAME = "0x1::delegation_pool::UnlockStakeEvent";
+  export interface UnlockStakeEvent {
     pool_address: Address;
     delegator_address: Address;
     amount_unlocked: bigint;
   }
 
+  export namespace UnlockStakeEvent {
+    export const TYPE_QNAME = "0x1::delegation_pool::UnlockStakeEvent";
+
+    const TYPE = new TypeDescriptor<UnlockStakeEvent>(
+      UnlockStakeEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<UnlockStakeEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface UnlockStakeEventInstance
     extends TypedEventInstance<UnlockStakeEvent> {
     data_decoded: UnlockStakeEvent;
     type_arguments: [];
   }
 
-  export class WithdrawStakeEvent {
-    static TYPE_QNAME = "0x1::delegation_pool::WithdrawStakeEvent";
+  export interface WithdrawStakeEvent {
     pool_address: Address;
     delegator_address: Address;
     amount_withdrawn: bigint;
   }
 
+  export namespace WithdrawStakeEvent {
+    export const TYPE_QNAME = "0x1::delegation_pool::WithdrawStakeEvent";
+
+    const TYPE = new TypeDescriptor<WithdrawStakeEvent>(
+      WithdrawStakeEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<WithdrawStakeEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface WithdrawStakeEventInstance
     extends TypedEventInstance<WithdrawStakeEvent> {
     data_decoded: WithdrawStakeEvent;
@@ -3989,23 +5699,52 @@ export class reconfiguration extends AptosBaseProcessor {
 }
 
 export namespace reconfiguration {
-  export class Configuration {
-    static TYPE_QNAME = "0x1::reconfiguration::Configuration";
+  export interface Configuration {
     epoch: bigint;
     last_reconfiguration_time: bigint;
     events: event.EventHandle<reconfiguration.NewEpochEvent>;
   }
 
-  export class DisableReconfiguration {
-    static TYPE_QNAME = "0x1::reconfiguration::DisableReconfiguration";
+  export namespace Configuration {
+    export const TYPE_QNAME = "0x1::reconfiguration::Configuration";
+
+    const TYPE = new TypeDescriptor<Configuration>(Configuration.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Configuration> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface DisableReconfiguration {
     dummy_field: Boolean;
   }
 
-  export class NewEpochEvent {
-    static TYPE_QNAME = "0x1::reconfiguration::NewEpochEvent";
+  export namespace DisableReconfiguration {
+    export const TYPE_QNAME = "0x1::reconfiguration::DisableReconfiguration";
+
+    const TYPE = new TypeDescriptor<DisableReconfiguration>(
+      DisableReconfiguration.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<DisableReconfiguration> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface NewEpochEvent {
     epoch: bigint;
   }
 
+  export namespace NewEpochEvent {
+    export const TYPE_QNAME = "0x1::reconfiguration::NewEpochEvent";
+
+    const TYPE = new TypeDescriptor<NewEpochEvent>(NewEpochEvent.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<NewEpochEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface NewEpochEventInstance
     extends TypedEventInstance<NewEpochEvent> {
     data_decoded: NewEpochEvent;
@@ -4014,17 +5753,39 @@ export namespace reconfiguration {
 }
 
 export namespace transaction_fee {
-  export class AptosCoinCapabilities {
-    static TYPE_QNAME = "0x1::transaction_fee::AptosCoinCapabilities";
+  export interface AptosCoinCapabilities {
     burn_cap: coin.BurnCapability<aptos_coin.AptosCoin>;
   }
 
-  export class CollectedFeesPerBlock {
-    static TYPE_QNAME = "0x1::transaction_fee::CollectedFeesPerBlock";
+  export namespace AptosCoinCapabilities {
+    export const TYPE_QNAME = "0x1::transaction_fee::AptosCoinCapabilities";
+
+    const TYPE = new TypeDescriptor<AptosCoinCapabilities>(
+      AptosCoinCapabilities.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<AptosCoinCapabilities> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface CollectedFeesPerBlock {
     amount: coin.AggregatableCoin<aptos_coin.AptosCoin>;
     proposer: option.Option<Address>;
     burn_percentage: number;
   }
+
+  export namespace CollectedFeesPerBlock {
+    export const TYPE_QNAME = "0x1::transaction_fee::CollectedFeesPerBlock";
+
+    const TYPE = new TypeDescriptor<CollectedFeesPerBlock>(
+      CollectedFeesPerBlock.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<CollectedFeesPerBlock> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export class aptos_governance extends AptosBaseProcessor {
@@ -4169,13 +5930,23 @@ export class aptos_governance extends AptosBaseProcessor {
 }
 
 export namespace aptos_governance {
-  export class ApprovedExecutionHashes {
-    static TYPE_QNAME = "0x1::aptos_governance::ApprovedExecutionHashes";
+  export interface ApprovedExecutionHashes {
     hashes: simple_map.SimpleMap<bigint, string>;
   }
 
-  export class CreateProposalEvent {
-    static TYPE_QNAME = "0x1::aptos_governance::CreateProposalEvent";
+  export namespace ApprovedExecutionHashes {
+    export const TYPE_QNAME = "0x1::aptos_governance::ApprovedExecutionHashes";
+
+    const TYPE = new TypeDescriptor<ApprovedExecutionHashes>(
+      ApprovedExecutionHashes.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ApprovedExecutionHashes> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface CreateProposalEvent {
     proposer: Address;
     stake_pool: Address;
     proposal_id: bigint;
@@ -4183,52 +5954,116 @@ export namespace aptos_governance {
     proposal_metadata: simple_map.SimpleMap<string, string>;
   }
 
+  export namespace CreateProposalEvent {
+    export const TYPE_QNAME = "0x1::aptos_governance::CreateProposalEvent";
+
+    const TYPE = new TypeDescriptor<CreateProposalEvent>(
+      CreateProposalEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<CreateProposalEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface CreateProposalEventInstance
     extends TypedEventInstance<CreateProposalEvent> {
     data_decoded: CreateProposalEvent;
     type_arguments: [];
   }
 
-  export class GovernanceConfig {
-    static TYPE_QNAME = "0x1::aptos_governance::GovernanceConfig";
+  export interface GovernanceConfig {
     min_voting_threshold: bigint;
     required_proposer_stake: bigint;
     voting_duration_secs: bigint;
   }
 
-  export class GovernanceEvents {
-    static TYPE_QNAME = "0x1::aptos_governance::GovernanceEvents";
+  export namespace GovernanceConfig {
+    export const TYPE_QNAME = "0x1::aptos_governance::GovernanceConfig";
+
+    const TYPE = new TypeDescriptor<GovernanceConfig>(
+      GovernanceConfig.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<GovernanceConfig> {
+      return TYPE.apply();
+    }
+  }
+
+  export 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>;
   }
 
-  export class GovernanceResponsbility {
-    static TYPE_QNAME = "0x1::aptos_governance::GovernanceResponsbility";
+  export namespace GovernanceEvents {
+    export const TYPE_QNAME = "0x1::aptos_governance::GovernanceEvents";
+
+    const TYPE = new TypeDescriptor<GovernanceEvents>(
+      GovernanceEvents.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<GovernanceEvents> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface GovernanceResponsbility {
     signer_caps: simple_map.SimpleMap<Address, account.SignerCapability>;
   }
 
-  export class RecordKey {
-    static TYPE_QNAME = "0x1::aptos_governance::RecordKey";
+  export namespace GovernanceResponsbility {
+    export const TYPE_QNAME = "0x1::aptos_governance::GovernanceResponsbility";
+
+    const TYPE = new TypeDescriptor<GovernanceResponsbility>(
+      GovernanceResponsbility.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<GovernanceResponsbility> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface RecordKey {
     stake_pool: Address;
     proposal_id: bigint;
   }
 
-  export class UpdateConfigEvent {
-    static TYPE_QNAME = "0x1::aptos_governance::UpdateConfigEvent";
+  export namespace RecordKey {
+    export const TYPE_QNAME = "0x1::aptos_governance::RecordKey";
+
+    const TYPE = new TypeDescriptor<RecordKey>(RecordKey.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<RecordKey> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface UpdateConfigEvent {
     min_voting_threshold: bigint;
     required_proposer_stake: bigint;
     voting_duration_secs: bigint;
   }
 
+  export namespace UpdateConfigEvent {
+    export const TYPE_QNAME = "0x1::aptos_governance::UpdateConfigEvent";
+
+    const TYPE = new TypeDescriptor<UpdateConfigEvent>(
+      UpdateConfigEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<UpdateConfigEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface UpdateConfigEventInstance
     extends TypedEventInstance<UpdateConfigEvent> {
     data_decoded: UpdateConfigEvent;
     type_arguments: [];
   }
 
-  export class VoteEvent {
-    static TYPE_QNAME = "0x1::aptos_governance::VoteEvent";
+  export interface VoteEvent {
     proposal_id: bigint;
     voter: Address;
     stake_pool: Address;
@@ -4236,16 +6071,35 @@ export namespace aptos_governance {
     should_pass: Boolean;
   }
 
+  export namespace VoteEvent {
+    export const TYPE_QNAME = "0x1::aptos_governance::VoteEvent";
+
+    const TYPE = new TypeDescriptor<VoteEvent>(VoteEvent.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<VoteEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
     data_decoded: VoteEvent;
     type_arguments: [];
   }
 
-  export class VotingRecords {
-    static TYPE_QNAME = "0x1::aptos_governance::VotingRecords";
+  export interface VotingRecords {
     votes: table.Table<aptos_governance.RecordKey, Boolean>;
   }
 
+  export namespace VotingRecords {
+    export const TYPE_QNAME = "0x1::aptos_governance::VotingRecords";
+
+    const TYPE = new TypeDescriptor<VotingRecords>(VotingRecords.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<VotingRecords> {
+      return TYPE.apply();
+    }
+  }
+
   export interface AddApprovedScriptHashScriptPayload
     extends TypedFunctionPayload<[bigint]> {
     arguments_decoded: [bigint];
@@ -4272,10 +6126,21 @@ export namespace aptos_governance {
 }
 
 export namespace consensus_config {
-  export class ConsensusConfig {
-    static TYPE_QNAME = "0x1::consensus_config::ConsensusConfig";
+  export interface ConsensusConfig {
     config: string;
   }
+
+  export namespace ConsensusConfig {
+    export const TYPE_QNAME = "0x1::consensus_config::ConsensusConfig";
+
+    const TYPE = new TypeDescriptor<ConsensusConfig>(
+      ConsensusConfig.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ConsensusConfig> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export class multisig_account extends AptosBaseProcessor {
@@ -4725,65 +6590,115 @@ export class multisig_account extends AptosBaseProcessor {
 }
 
 export namespace multisig_account {
-  export class AddOwnersEvent {
-    static TYPE_QNAME = "0x1::multisig_account::AddOwnersEvent";
+  export interface AddOwnersEvent {
     owners_added: Address[];
   }
 
+  export namespace AddOwnersEvent {
+    export const TYPE_QNAME = "0x1::multisig_account::AddOwnersEvent";
+
+    const TYPE = new TypeDescriptor<AddOwnersEvent>(AddOwnersEvent.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<AddOwnersEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface AddOwnersEventInstance
     extends TypedEventInstance<AddOwnersEvent> {
     data_decoded: AddOwnersEvent;
     type_arguments: [];
   }
 
-  export class CreateTransactionEvent {
-    static TYPE_QNAME = "0x1::multisig_account::CreateTransactionEvent";
+  export interface CreateTransactionEvent {
     creator: Address;
     sequence_number: bigint;
     transaction: multisig_account.MultisigTransaction;
   }
 
+  export namespace CreateTransactionEvent {
+    export const TYPE_QNAME = "0x1::multisig_account::CreateTransactionEvent";
+
+    const TYPE = new TypeDescriptor<CreateTransactionEvent>(
+      CreateTransactionEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<CreateTransactionEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface CreateTransactionEventInstance
     extends TypedEventInstance<CreateTransactionEvent> {
     data_decoded: CreateTransactionEvent;
     type_arguments: [];
   }
 
-  export class ExecuteRejectedTransactionEvent {
-    static TYPE_QNAME =
-      "0x1::multisig_account::ExecuteRejectedTransactionEvent";
+  export interface ExecuteRejectedTransactionEvent {
     sequence_number: bigint;
     num_rejections: bigint;
     executor: Address;
   }
 
+  export namespace ExecuteRejectedTransactionEvent {
+    export const TYPE_QNAME =
+      "0x1::multisig_account::ExecuteRejectedTransactionEvent";
+
+    const TYPE = new TypeDescriptor<ExecuteRejectedTransactionEvent>(
+      ExecuteRejectedTransactionEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ExecuteRejectedTransactionEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface ExecuteRejectedTransactionEventInstance
     extends TypedEventInstance<ExecuteRejectedTransactionEvent> {
     data_decoded: ExecuteRejectedTransactionEvent;
     type_arguments: [];
   }
 
-  export class ExecutionError {
-    static TYPE_QNAME = "0x1::multisig_account::ExecutionError";
+  export interface ExecutionError {
     abort_location: string;
     error_type: string;
     error_code: bigint;
   }
 
-  export class MetadataUpdatedEvent {
-    static TYPE_QNAME = "0x1::multisig_account::MetadataUpdatedEvent";
+  export namespace ExecutionError {
+    export const TYPE_QNAME = "0x1::multisig_account::ExecutionError";
+
+    const TYPE = new TypeDescriptor<ExecutionError>(ExecutionError.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<ExecutionError> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface MetadataUpdatedEvent {
     old_metadata: simple_map.SimpleMap<string, string>;
     new_metadata: simple_map.SimpleMap<string, string>;
   }
 
+  export namespace MetadataUpdatedEvent {
+    export const TYPE_QNAME = "0x1::multisig_account::MetadataUpdatedEvent";
+
+    const TYPE = new TypeDescriptor<MetadataUpdatedEvent>(
+      MetadataUpdatedEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<MetadataUpdatedEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface MetadataUpdatedEventInstance
     extends TypedEventInstance<MetadataUpdatedEvent> {
     data_decoded: MetadataUpdatedEvent;
     type_arguments: [];
   }
 
-  export class MultisigAccount {
-    static TYPE_QNAME = "0x1::multisig_account::MultisigAccount";
+  export interface MultisigAccount {
     owners: Address[];
     num_signatures_required: bigint;
     transactions: table.Table<bigint, multisig_account.MultisigTransaction>;
@@ -4802,8 +6717,19 @@ export namespace multisig_account {
     metadata_updated_events: event.EventHandle<multisig_account.MetadataUpdatedEvent>;
   }
 
-  export class MultisigAccountCreationMessage {
-    static TYPE_QNAME = "0x1::multisig_account::MultisigAccountCreationMessage";
+  export namespace MultisigAccount {
+    export const TYPE_QNAME = "0x1::multisig_account::MultisigAccount";
+
+    const TYPE = new TypeDescriptor<MultisigAccount>(
+      MultisigAccount.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<MultisigAccount> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface MultisigAccountCreationMessage {
     chain_id: number;
     account_address: Address;
     sequence_number: bigint;
@@ -4811,8 +6737,20 @@ export namespace multisig_account {
     num_signatures_required: bigint;
   }
 
-  export class MultisigTransaction {
-    static TYPE_QNAME = "0x1::multisig_account::MultisigTransaction";
+  export namespace MultisigAccountCreationMessage {
+    export const TYPE_QNAME =
+      "0x1::multisig_account::MultisigAccountCreationMessage";
+
+    const TYPE = new TypeDescriptor<MultisigAccountCreationMessage>(
+      MultisigAccountCreationMessage.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<MultisigAccountCreationMessage> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface MultisigTransaction {
     payload: option.Option<string>;
     payload_hash: option.Option<string>;
     votes: simple_map.SimpleMap<Address, Boolean>;
@@ -4820,20 +6758,41 @@ export namespace multisig_account {
     creation_time_secs: bigint;
   }
 
-  export class RemoveOwnersEvent {
-    static TYPE_QNAME = "0x1::multisig_account::RemoveOwnersEvent";
+  export namespace MultisigTransaction {
+    export const TYPE_QNAME = "0x1::multisig_account::MultisigTransaction";
+
+    const TYPE = new TypeDescriptor<MultisigTransaction>(
+      MultisigTransaction.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<MultisigTransaction> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface RemoveOwnersEvent {
     owners_removed: Address[];
   }
 
+  export namespace RemoveOwnersEvent {
+    export const TYPE_QNAME = "0x1::multisig_account::RemoveOwnersEvent";
+
+    const TYPE = new TypeDescriptor<RemoveOwnersEvent>(
+      RemoveOwnersEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<RemoveOwnersEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface RemoveOwnersEventInstance
     extends TypedEventInstance<RemoveOwnersEvent> {
     data_decoded: RemoveOwnersEvent;
     type_arguments: [];
   }
 
-  export class TransactionExecutionFailedEvent {
-    static TYPE_QNAME =
-      "0x1::multisig_account::TransactionExecutionFailedEvent";
+  export interface TransactionExecutionFailedEvent {
     executor: Address;
     sequence_number: bigint;
     transaction_payload: string;
@@ -4841,46 +6800,91 @@ export namespace multisig_account {
     execution_error: multisig_account.ExecutionError;
   }
 
+  export namespace TransactionExecutionFailedEvent {
+    export const TYPE_QNAME =
+      "0x1::multisig_account::TransactionExecutionFailedEvent";
+
+    const TYPE = new TypeDescriptor<TransactionExecutionFailedEvent>(
+      TransactionExecutionFailedEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<TransactionExecutionFailedEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface TransactionExecutionFailedEventInstance
     extends TypedEventInstance<TransactionExecutionFailedEvent> {
     data_decoded: TransactionExecutionFailedEvent;
     type_arguments: [];
   }
 
-  export class TransactionExecutionSucceededEvent {
-    static TYPE_QNAME =
-      "0x1::multisig_account::TransactionExecutionSucceededEvent";
+  export interface TransactionExecutionSucceededEvent {
     executor: Address;
     sequence_number: bigint;
     transaction_payload: string;
     num_approvals: bigint;
   }
 
+  export namespace TransactionExecutionSucceededEvent {
+    export const TYPE_QNAME =
+      "0x1::multisig_account::TransactionExecutionSucceededEvent";
+
+    const TYPE = new TypeDescriptor<TransactionExecutionSucceededEvent>(
+      TransactionExecutionSucceededEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<TransactionExecutionSucceededEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface TransactionExecutionSucceededEventInstance
     extends TypedEventInstance<TransactionExecutionSucceededEvent> {
     data_decoded: TransactionExecutionSucceededEvent;
     type_arguments: [];
   }
 
-  export class UpdateSignaturesRequiredEvent {
-    static TYPE_QNAME = "0x1::multisig_account::UpdateSignaturesRequiredEvent";
+  export interface UpdateSignaturesRequiredEvent {
     old_num_signatures_required: bigint;
     new_num_signatures_required: bigint;
   }
 
+  export namespace UpdateSignaturesRequiredEvent {
+    export const TYPE_QNAME =
+      "0x1::multisig_account::UpdateSignaturesRequiredEvent";
+
+    const TYPE = new TypeDescriptor<UpdateSignaturesRequiredEvent>(
+      UpdateSignaturesRequiredEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<UpdateSignaturesRequiredEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface UpdateSignaturesRequiredEventInstance
     extends TypedEventInstance<UpdateSignaturesRequiredEvent> {
     data_decoded: UpdateSignaturesRequiredEvent;
     type_arguments: [];
   }
 
-  export class VoteEvent {
-    static TYPE_QNAME = "0x1::multisig_account::VoteEvent";
+  export interface VoteEvent {
     owner: Address;
     sequence_number: bigint;
     approved: Boolean;
   }
 
+  export namespace VoteEvent {
+    export const TYPE_QNAME = "0x1::multisig_account::VoteEvent";
+
+    const TYPE = new TypeDescriptor<VoteEvent>(VoteEvent.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<VoteEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface VoteEventInstance extends TypedEventInstance<VoteEvent> {
     data_decoded: VoteEvent;
     type_arguments: [];
@@ -4986,13 +6990,22 @@ export namespace multisig_account {
 }
 
 export namespace pool_u64_unbound {
-  export class Pool {
-    static TYPE_QNAME = "0x1::pool_u64_unbound::Pool";
+  export interface Pool {
     total_coins: bigint;
     total_shares: bigint;
     shares: table_with_length.TableWithLength<Address, bigint>;
     scaling_factor: bigint;
   }
+
+  export namespace Pool {
+    export const TYPE_QNAME = "0x1::pool_u64_unbound::Pool";
+
+    const TYPE = new TypeDescriptor<Pool>(Pool.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Pool> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export class resource_account extends AptosBaseProcessor {
@@ -5071,11 +7084,20 @@ export class resource_account extends AptosBaseProcessor {
 }
 
 export namespace resource_account {
-  export class Container {
-    static TYPE_QNAME = "0x1::resource_account::Container";
+  export interface Container {
     store: simple_map.SimpleMap<Address, account.SignerCapability>;
   }
 
+  export namespace Container {
+    export const TYPE_QNAME = "0x1::resource_account::Container";
+
+    const TYPE = new TypeDescriptor<Container>(Container.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Container> {
+      return TYPE.apply();
+    }
+  }
+
   export interface CreateResourceAccountPayload
     extends TypedFunctionPayload<[string, string]> {
     arguments_decoded: [string, string];
@@ -5486,34 +7508,53 @@ export class staking_contract extends AptosBaseProcessor {
 }
 
 export namespace staking_contract {
-  export class AddDistributionEvent {
-    static TYPE_QNAME = "0x1::staking_contract::AddDistributionEvent";
+  export interface AddDistributionEvent {
     operator: Address;
     pool_address: Address;
     amount: bigint;
   }
 
+  export namespace AddDistributionEvent {
+    export const TYPE_QNAME = "0x1::staking_contract::AddDistributionEvent";
+
+    const TYPE = new TypeDescriptor<AddDistributionEvent>(
+      AddDistributionEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<AddDistributionEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface AddDistributionEventInstance
     extends TypedEventInstance<AddDistributionEvent> {
     data_decoded: AddDistributionEvent;
     type_arguments: [];
   }
 
-  export class AddStakeEvent {
-    static TYPE_QNAME = "0x1::staking_contract::AddStakeEvent";
+  export interface AddStakeEvent {
     operator: Address;
     pool_address: Address;
     amount: bigint;
   }
 
+  export namespace AddStakeEvent {
+    export const TYPE_QNAME = "0x1::staking_contract::AddStakeEvent";
+
+    const TYPE = new TypeDescriptor<AddStakeEvent>(AddStakeEvent.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<AddStakeEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface AddStakeEventInstance
     extends TypedEventInstance<AddStakeEvent> {
     data_decoded: AddStakeEvent;
     type_arguments: [];
   }
 
-  export class CreateStakingContractEvent {
-    static TYPE_QNAME = "0x1::staking_contract::CreateStakingContractEvent";
+  export interface CreateStakingContractEvent {
     operator: Address;
     voter: Address;
     pool_address: Address;
@@ -5521,54 +7562,99 @@ export namespace staking_contract {
     commission_percentage: bigint;
   }
 
+  export namespace CreateStakingContractEvent {
+    export const TYPE_QNAME =
+      "0x1::staking_contract::CreateStakingContractEvent";
+
+    const TYPE = new TypeDescriptor<CreateStakingContractEvent>(
+      CreateStakingContractEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<CreateStakingContractEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface CreateStakingContractEventInstance
     extends TypedEventInstance<CreateStakingContractEvent> {
     data_decoded: CreateStakingContractEvent;
     type_arguments: [];
   }
 
-  export class DistributeEvent {
-    static TYPE_QNAME = "0x1::staking_contract::DistributeEvent";
+  export interface DistributeEvent {
     operator: Address;
     pool_address: Address;
     recipient: Address;
     amount: bigint;
   }
 
+  export namespace DistributeEvent {
+    export const TYPE_QNAME = "0x1::staking_contract::DistributeEvent";
+
+    const TYPE = new TypeDescriptor<DistributeEvent>(
+      DistributeEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<DistributeEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface DistributeEventInstance
     extends TypedEventInstance<DistributeEvent> {
     data_decoded: DistributeEvent;
     type_arguments: [];
   }
 
-  export class RequestCommissionEvent {
-    static TYPE_QNAME = "0x1::staking_contract::RequestCommissionEvent";
+  export interface RequestCommissionEvent {
     operator: Address;
     pool_address: Address;
     accumulated_rewards: bigint;
     commission_amount: bigint;
   }
 
+  export namespace RequestCommissionEvent {
+    export const TYPE_QNAME = "0x1::staking_contract::RequestCommissionEvent";
+
+    const TYPE = new TypeDescriptor<RequestCommissionEvent>(
+      RequestCommissionEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<RequestCommissionEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface RequestCommissionEventInstance
     extends TypedEventInstance<RequestCommissionEvent> {
     data_decoded: RequestCommissionEvent;
     type_arguments: [];
   }
 
-  export class ResetLockupEvent {
-    static TYPE_QNAME = "0x1::staking_contract::ResetLockupEvent";
+  export interface ResetLockupEvent {
     operator: Address;
     pool_address: Address;
   }
 
+  export namespace ResetLockupEvent {
+    export const TYPE_QNAME = "0x1::staking_contract::ResetLockupEvent";
+
+    const TYPE = new TypeDescriptor<ResetLockupEvent>(
+      ResetLockupEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<ResetLockupEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface ResetLockupEventInstance
     extends TypedEventInstance<ResetLockupEvent> {
     data_decoded: ResetLockupEvent;
     type_arguments: [];
   }
 
-  export class StakingContract {
-    static TYPE_QNAME = "0x1::staking_contract::StakingContract";
+  export interface StakingContract {
     principal: bigint;
     pool_address: Address;
     owner_cap: stake.OwnerCapability;
@@ -5577,19 +7663,52 @@ export namespace staking_contract {
     signer_cap: account.SignerCapability;
   }
 
-  export class StakingGroupContainer {
-    static TYPE_QNAME = "0x1::staking_contract::StakingGroupContainer";
+  export namespace StakingContract {
+    export const TYPE_QNAME = "0x1::staking_contract::StakingContract";
+
+    const TYPE = new TypeDescriptor<StakingContract>(
+      StakingContract.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<StakingContract> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface StakingGroupContainer {
     dummy_field: Boolean;
   }
 
-  export class StakingGroupUpdateCommissionEvent {
-    static TYPE_QNAME =
-      "0x1::staking_contract::StakingGroupUpdateCommissionEvent";
+  export namespace StakingGroupContainer {
+    export const TYPE_QNAME = "0x1::staking_contract::StakingGroupContainer";
+
+    const TYPE = new TypeDescriptor<StakingGroupContainer>(
+      StakingGroupContainer.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<StakingGroupContainer> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface StakingGroupUpdateCommissionEvent {
     update_commission_events: event.EventHandle<staking_contract.UpdateCommissionEvent>;
   }
 
-  export class Store {
-    static TYPE_QNAME = "0x1::staking_contract::Store";
+  export namespace StakingGroupUpdateCommissionEvent {
+    export const TYPE_QNAME =
+      "0x1::staking_contract::StakingGroupUpdateCommissionEvent";
+
+    const TYPE = new TypeDescriptor<StakingGroupUpdateCommissionEvent>(
+      StakingGroupUpdateCommissionEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<StakingGroupUpdateCommissionEvent> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface Store {
     staking_contracts: simple_map.SimpleMap<
       Address,
       staking_contract.StakingContract
@@ -5605,55 +7724,109 @@ export namespace staking_contract {
     distribute_events: event.EventHandle<staking_contract.DistributeEvent>;
   }
 
-  export class SwitchOperatorEvent {
-    static TYPE_QNAME = "0x1::staking_contract::SwitchOperatorEvent";
+  export namespace Store {
+    export const TYPE_QNAME = "0x1::staking_contract::Store";
+
+    const TYPE = new TypeDescriptor<Store>(Store.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Store> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface SwitchOperatorEvent {
     old_operator: Address;
     new_operator: Address;
     pool_address: Address;
   }
 
+  export namespace SwitchOperatorEvent {
+    export const TYPE_QNAME = "0x1::staking_contract::SwitchOperatorEvent";
+
+    const TYPE = new TypeDescriptor<SwitchOperatorEvent>(
+      SwitchOperatorEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<SwitchOperatorEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface SwitchOperatorEventInstance
     extends TypedEventInstance<SwitchOperatorEvent> {
     data_decoded: SwitchOperatorEvent;
     type_arguments: [];
   }
 
-  export class UnlockStakeEvent {
-    static TYPE_QNAME = "0x1::staking_contract::UnlockStakeEvent";
+  export interface UnlockStakeEvent {
     operator: Address;
     pool_address: Address;
     amount: bigint;
     commission_paid: bigint;
   }
 
+  export namespace UnlockStakeEvent {
+    export const TYPE_QNAME = "0x1::staking_contract::UnlockStakeEvent";
+
+    const TYPE = new TypeDescriptor<UnlockStakeEvent>(
+      UnlockStakeEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<UnlockStakeEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface UnlockStakeEventInstance
     extends TypedEventInstance<UnlockStakeEvent> {
     data_decoded: UnlockStakeEvent;
     type_arguments: [];
   }
 
-  export class UpdateCommissionEvent {
-    static TYPE_QNAME = "0x1::staking_contract::UpdateCommissionEvent";
+  export interface UpdateCommissionEvent {
     staker: Address;
     operator: Address;
     old_commission_percentage: bigint;
     new_commission_percentage: bigint;
   }
 
+  export namespace UpdateCommissionEvent {
+    export const TYPE_QNAME = "0x1::staking_contract::UpdateCommissionEvent";
+
+    const TYPE = new TypeDescriptor<UpdateCommissionEvent>(
+      UpdateCommissionEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<UpdateCommissionEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface UpdateCommissionEventInstance
     extends TypedEventInstance<UpdateCommissionEvent> {
     data_decoded: UpdateCommissionEvent;
     type_arguments: [];
   }
 
-  export class UpdateVoterEvent {
-    static TYPE_QNAME = "0x1::staking_contract::UpdateVoterEvent";
+  export interface UpdateVoterEvent {
     operator: Address;
     pool_address: Address;
     old_voter: Address;
     new_voter: Address;
   }
 
+  export namespace UpdateVoterEvent {
+    export const TYPE_QNAME = "0x1::staking_contract::UpdateVoterEvent";
+
+    const TYPE = new TypeDescriptor<UpdateVoterEvent>(
+      UpdateVoterEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<UpdateVoterEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface UpdateVoterEventInstance
     extends TypedEventInstance<UpdateVoterEvent> {
     data_decoded: UpdateVoterEvent;
@@ -5729,46 +7902,101 @@ export namespace staking_contract {
 export namespace system_addresses {}
 
 export namespace table_with_length {
-  export class TableWithLength<T0, T1> {
-    static TYPE_QNAME = "0x1::table_with_length::TableWithLength";
+  export interface TableWithLength<T0, T1> {
     inner: table.Table<T0, T1>;
     length: bigint;
   }
+
+  export namespace TableWithLength {
+    export const TYPE_QNAME = "0x1::table_with_length::TableWithLength";
+
+    const TYPE = new TypeDescriptor<TableWithLength<any, any>>(
+      TableWithLength.TYPE_QNAME
+    );
+
+    export function type<T0, T1>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE,
+      arg1: TypeDescriptor<T1> = ANY_TYPE
+    ): TypeDescriptor<TableWithLength<T0, T1>> {
+      return TYPE.apply(arg0, arg1);
+    }
+  }
 }
 
 export namespace aggregator_factory {
-  export class AggregatorFactory {
-    static TYPE_QNAME = "0x1::aggregator_factory::AggregatorFactory";
+  export interface AggregatorFactory {
     phantom_table: table.Table<Address, bigint>;
   }
+
+  export namespace AggregatorFactory {
+    export const TYPE_QNAME = "0x1::aggregator_factory::AggregatorFactory";
+
+    const TYPE = new TypeDescriptor<AggregatorFactory>(
+      AggregatorFactory.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<AggregatorFactory> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace governance_proposal {
-  export class GovernanceProposal {
-    static TYPE_QNAME = "0x1::governance_proposal::GovernanceProposal";
+  export interface GovernanceProposal {
     dummy_field: Boolean;
   }
+
+  export namespace GovernanceProposal {
+    export const TYPE_QNAME = "0x1::governance_proposal::GovernanceProposal";
+
+    const TYPE = new TypeDescriptor<GovernanceProposal>(
+      GovernanceProposal.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<GovernanceProposal> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace optional_aggregator {
-  export class Integer {
-    static TYPE_QNAME = "0x1::optional_aggregator::Integer";
+  export interface Integer {
     value: bigint;
     limit: bigint;
   }
 
-  export class OptionalAggregator {
-    static TYPE_QNAME = "0x1::optional_aggregator::OptionalAggregator";
+  export namespace Integer {
+    export const TYPE_QNAME = "0x1::optional_aggregator::Integer";
+
+    const TYPE = new TypeDescriptor<Integer>(Integer.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Integer> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface OptionalAggregator {
     aggregator: option.Option<aggregator.Aggregator>;
     integer: option.Option<optional_aggregator.Integer>;
   }
+
+  export namespace OptionalAggregator {
+    export const TYPE_QNAME = "0x1::optional_aggregator::OptionalAggregator";
+
+    const TYPE = new TypeDescriptor<OptionalAggregator>(
+      OptionalAggregator.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<OptionalAggregator> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace transaction_context {}
 
 export namespace transaction_validation {
-  export class TransactionValidation {
-    static TYPE_QNAME = "0x1::transaction_validation::TransactionValidation";
+  export interface TransactionValidation {
     module_addr: Address;
     module_name: string;
     script_prologue_name: string;
@@ -5776,6 +8004,19 @@ export namespace transaction_validation {
     multi_agent_prologue_name: string;
     user_epilogue_name: string;
   }
+
+  export namespace TransactionValidation {
+    export const TYPE_QNAME =
+      "0x1::transaction_validation::TransactionValidation";
+
+    const TYPE = new TypeDescriptor<TransactionValidation>(
+      TransactionValidation.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<TransactionValidation> {
+      return TYPE.apply();
+    }
+  }
 }
 
 const MODULES = JSON.parse(