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

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

@@ -4,7 +4,7 @@
 
 /* Generated modules for account 0x3 */
 
-import { CallFilter } from "@sentio/sdk/move";
+import { CallFilter, TypeDescriptor, ANY_TYPE } from "@sentio/sdk/move";
 import {
   MoveCoder,
   defaultMoveCoder,
@@ -305,20 +305,28 @@ export class token extends AptosBaseProcessor {
 }
 
 export namespace token {
-  export class BurnTokenEvent {
-    static TYPE_QNAME = "0x3::token::BurnTokenEvent";
+  export interface BurnTokenEvent {
     id: token.TokenId;
     amount: bigint;
   }
 
+  export namespace BurnTokenEvent {
+    export const TYPE_QNAME = "0x3::token::BurnTokenEvent";
+
+    const TYPE = new TypeDescriptor<BurnTokenEvent>(BurnTokenEvent.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<BurnTokenEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface BurnTokenEventInstance
     extends TypedEventInstance<BurnTokenEvent> {
     data_decoded: BurnTokenEvent;
     type_arguments: [];
   }
 
-  export class CollectionData {
-    static TYPE_QNAME = "0x3::token::CollectionData";
+  export interface CollectionData {
     description: string;
     name: string;
     uri: string;
@@ -327,15 +335,35 @@ export namespace token {
     mutability_config: token.CollectionMutabilityConfig;
   }
 
-  export class CollectionMutabilityConfig {
-    static TYPE_QNAME = "0x3::token::CollectionMutabilityConfig";
+  export namespace CollectionData {
+    export const TYPE_QNAME = "0x3::token::CollectionData";
+
+    const TYPE = new TypeDescriptor<CollectionData>(CollectionData.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<CollectionData> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface CollectionMutabilityConfig {
     description: Boolean;
     uri: Boolean;
     maximum: Boolean;
   }
 
-  export class Collections {
-    static TYPE_QNAME = "0x3::token::Collections";
+  export namespace CollectionMutabilityConfig {
+    export const TYPE_QNAME = "0x3::token::CollectionMutabilityConfig";
+
+    const TYPE = new TypeDescriptor<CollectionMutabilityConfig>(
+      CollectionMutabilityConfig.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<CollectionMutabilityConfig> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface Collections {
     collection_data: _0x1.table.Table<string, token.CollectionData>;
     token_data: _0x1.table.Table<token.TokenDataId, token.TokenData>;
     create_collection_events: _0x1.event.EventHandle<token.CreateCollectionEvent>;
@@ -343,8 +371,17 @@ export namespace token {
     mint_token_events: _0x1.event.EventHandle<token.MintTokenEvent>;
   }
 
-  export class CreateCollectionEvent {
-    static TYPE_QNAME = "0x3::token::CreateCollectionEvent";
+  export namespace Collections {
+    export const TYPE_QNAME = "0x3::token::Collections";
+
+    const TYPE = new TypeDescriptor<Collections>(Collections.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Collections> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface CreateCollectionEvent {
     creator: Address;
     collection_name: string;
     uri: string;
@@ -352,14 +389,25 @@ export namespace token {
     maximum: bigint;
   }
 
+  export namespace CreateCollectionEvent {
+    export const TYPE_QNAME = "0x3::token::CreateCollectionEvent";
+
+    const TYPE = new TypeDescriptor<CreateCollectionEvent>(
+      CreateCollectionEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<CreateCollectionEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface CreateCollectionEventInstance
     extends TypedEventInstance<CreateCollectionEvent> {
     data_decoded: CreateCollectionEvent;
     type_arguments: [];
   }
 
-  export class CreateTokenDataEvent {
-    static TYPE_QNAME = "0x3::token::CreateTokenDataEvent";
+  export interface CreateTokenDataEvent {
     id: token.TokenDataId;
     description: string;
     maximum: bigint;
@@ -374,38 +422,67 @@ export namespace token {
     property_types: string[];
   }
 
+  export namespace CreateTokenDataEvent {
+    export const TYPE_QNAME = "0x3::token::CreateTokenDataEvent";
+
+    const TYPE = new TypeDescriptor<CreateTokenDataEvent>(
+      CreateTokenDataEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<CreateTokenDataEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface CreateTokenDataEventInstance
     extends TypedEventInstance<CreateTokenDataEvent> {
     data_decoded: CreateTokenDataEvent;
     type_arguments: [];
   }
 
-  export class DepositEvent {
-    static TYPE_QNAME = "0x3::token::DepositEvent";
+  export interface DepositEvent {
     id: token.TokenId;
     amount: bigint;
   }
 
+  export namespace DepositEvent {
+    export const TYPE_QNAME = "0x3::token::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 MintTokenEvent {
-    static TYPE_QNAME = "0x3::token::MintTokenEvent";
+  export interface MintTokenEvent {
     id: token.TokenDataId;
     amount: bigint;
   }
 
+  export namespace MintTokenEvent {
+    export const TYPE_QNAME = "0x3::token::MintTokenEvent";
+
+    const TYPE = new TypeDescriptor<MintTokenEvent>(MintTokenEvent.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<MintTokenEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface MintTokenEventInstance
     extends TypedEventInstance<MintTokenEvent> {
     data_decoded: MintTokenEvent;
     type_arguments: [];
   }
 
-  export class MutateTokenPropertyMapEvent {
-    static TYPE_QNAME = "0x3::token::MutateTokenPropertyMapEvent";
+  export interface MutateTokenPropertyMapEvent {
     old_id: token.TokenId;
     new_id: token.TokenId;
     keys: string[];
@@ -413,28 +490,57 @@ export namespace token {
     types: string[];
   }
 
+  export namespace MutateTokenPropertyMapEvent {
+    export const TYPE_QNAME = "0x3::token::MutateTokenPropertyMapEvent";
+
+    const TYPE = new TypeDescriptor<MutateTokenPropertyMapEvent>(
+      MutateTokenPropertyMapEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<MutateTokenPropertyMapEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface MutateTokenPropertyMapEventInstance
     extends TypedEventInstance<MutateTokenPropertyMapEvent> {
     data_decoded: MutateTokenPropertyMapEvent;
     type_arguments: [];
   }
 
-  export class Royalty {
-    static TYPE_QNAME = "0x3::token::Royalty";
+  export interface Royalty {
     royalty_points_numerator: bigint;
     royalty_points_denominator: bigint;
     payee_address: Address;
   }
 
-  export class Token {
-    static TYPE_QNAME = "0x3::token::Token";
+  export namespace Royalty {
+    export const TYPE_QNAME = "0x3::token::Royalty";
+
+    const TYPE = new TypeDescriptor<Royalty>(Royalty.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Royalty> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface Token {
     id: token.TokenId;
     amount: bigint;
     token_properties: property_map.PropertyMap;
   }
 
-  export class TokenData {
-    static TYPE_QNAME = "0x3::token::TokenData";
+  export namespace Token {
+    export const TYPE_QNAME = "0x3::token::Token";
+
+    const TYPE = new TypeDescriptor<Token>(Token.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Token> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface TokenData {
     maximum: bigint;
     largest_property_version: bigint;
     supply: bigint;
@@ -446,21 +552,48 @@ export namespace token {
     mutability_config: token.TokenMutabilityConfig;
   }
 
-  export class TokenDataId {
-    static TYPE_QNAME = "0x3::token::TokenDataId";
+  export namespace TokenData {
+    export const TYPE_QNAME = "0x3::token::TokenData";
+
+    const TYPE = new TypeDescriptor<TokenData>(TokenData.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<TokenData> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface TokenDataId {
     creator: Address;
     collection: string;
     name: string;
   }
 
-  export class TokenId {
-    static TYPE_QNAME = "0x3::token::TokenId";
+  export namespace TokenDataId {
+    export const TYPE_QNAME = "0x3::token::TokenDataId";
+
+    const TYPE = new TypeDescriptor<TokenDataId>(TokenDataId.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<TokenDataId> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface TokenId {
     token_data_id: token.TokenDataId;
     property_version: bigint;
   }
 
-  export class TokenMutabilityConfig {
-    static TYPE_QNAME = "0x3::token::TokenMutabilityConfig";
+  export namespace TokenId {
+    export const TYPE_QNAME = "0x3::token::TokenId";
+
+    const TYPE = new TypeDescriptor<TokenId>(TokenId.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<TokenId> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface TokenMutabilityConfig {
     maximum: Boolean;
     uri: Boolean;
     royalty: Boolean;
@@ -468,8 +601,19 @@ export namespace token {
     properties: Boolean;
   }
 
-  export class TokenStore {
-    static TYPE_QNAME = "0x3::token::TokenStore";
+  export namespace TokenMutabilityConfig {
+    export const TYPE_QNAME = "0x3::token::TokenMutabilityConfig";
+
+    const TYPE = new TypeDescriptor<TokenMutabilityConfig>(
+      TokenMutabilityConfig.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<TokenMutabilityConfig> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface TokenStore {
     tokens: _0x1.table.Table<token.TokenId, token.Token>;
     direct_transfer: Boolean;
     deposit_events: _0x1.event.EventHandle<token.DepositEvent>;
@@ -478,20 +622,50 @@ export namespace token {
     mutate_token_property_events: _0x1.event.EventHandle<token.MutateTokenPropertyMapEvent>;
   }
 
-  export class WithdrawCapability {
-    static TYPE_QNAME = "0x3::token::WithdrawCapability";
+  export namespace TokenStore {
+    export const TYPE_QNAME = "0x3::token::TokenStore";
+
+    const TYPE = new TypeDescriptor<TokenStore>(TokenStore.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<TokenStore> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface WithdrawCapability {
     token_owner: Address;
     token_id: token.TokenId;
     amount: bigint;
     expiration_sec: bigint;
   }
 
-  export class WithdrawEvent {
-    static TYPE_QNAME = "0x3::token::WithdrawEvent";
+  export namespace WithdrawCapability {
+    export const TYPE_QNAME = "0x3::token::WithdrawCapability";
+
+    const TYPE = new TypeDescriptor<WithdrawCapability>(
+      WithdrawCapability.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<WithdrawCapability> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface WithdrawEvent {
     id: token.TokenId;
     amount: bigint;
   }
 
+  export namespace WithdrawEvent {
+    export const TYPE_QNAME = "0x3::token::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;
@@ -616,16 +790,34 @@ export namespace token {
 }
 
 export namespace property_map {
-  export class PropertyMap {
-    static TYPE_QNAME = "0x3::property_map::PropertyMap";
+  export interface PropertyMap {
     map: _0x1.simple_map.SimpleMap<string, property_map.PropertyValue>;
   }
 
-  export class PropertyValue {
-    static TYPE_QNAME = "0x3::property_map::PropertyValue";
+  export namespace PropertyMap {
+    export const TYPE_QNAME = "0x3::property_map::PropertyMap";
+
+    const TYPE = new TypeDescriptor<PropertyMap>(PropertyMap.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<PropertyMap> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface PropertyValue {
     value: string;
     type: string;
   }
+
+  export namespace PropertyValue {
+    export const TYPE_QNAME = "0x3::property_map::PropertyValue";
+
+    const TYPE = new TypeDescriptor<PropertyValue>(PropertyValue.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<PropertyValue> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export class token_coin_swap extends AptosBaseProcessor {
@@ -699,20 +891,41 @@ export class token_coin_swap extends AptosBaseProcessor {
 }
 
 export namespace token_coin_swap {
-  export class TokenCoinSwap<T0> {
-    static TYPE_QNAME = "0x3::token_coin_swap::TokenCoinSwap";
+  export interface TokenCoinSwap<T0> {
     token_amount: bigint;
     min_price_per_token: bigint;
   }
 
-  export class TokenEscrow {
-    static TYPE_QNAME = "0x3::token_coin_swap::TokenEscrow";
+  export namespace TokenCoinSwap {
+    export const TYPE_QNAME = "0x3::token_coin_swap::TokenCoinSwap";
+
+    const TYPE = new TypeDescriptor<TokenCoinSwap<any>>(
+      TokenCoinSwap.TYPE_QNAME
+    );
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<TokenCoinSwap<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface TokenEscrow {
     token: token.Token;
     locked_until_secs: bigint;
   }
 
-  export class TokenListingEvent {
-    static TYPE_QNAME = "0x3::token_coin_swap::TokenListingEvent";
+  export namespace TokenEscrow {
+    export const TYPE_QNAME = "0x3::token_coin_swap::TokenEscrow";
+
+    const TYPE = new TypeDescriptor<TokenEscrow>(TokenEscrow.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<TokenEscrow> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface TokenListingEvent {
     token_id: token.TokenId;
     amount: bigint;
     min_price: bigint;
@@ -720,14 +933,25 @@ export namespace token_coin_swap {
     coin_type_info: _0x1.type_info.TypeInfo;
   }
 
+  export namespace TokenListingEvent {
+    export const TYPE_QNAME = "0x3::token_coin_swap::TokenListingEvent";
+
+    const TYPE = new TypeDescriptor<TokenListingEvent>(
+      TokenListingEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<TokenListingEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface TokenListingEventInstance
     extends TypedEventInstance<TokenListingEvent> {
     data_decoded: TokenListingEvent;
     type_arguments: [];
   }
 
-  export class TokenListings<T0> {
-    static TYPE_QNAME = "0x3::token_coin_swap::TokenListings";
+  export interface TokenListings<T0> {
     listings: _0x1.table.Table<
       token.TokenId,
       token_coin_swap.TokenCoinSwap<T0>
@@ -736,13 +960,37 @@ export namespace token_coin_swap {
     swap_events: _0x1.event.EventHandle<token_coin_swap.TokenSwapEvent>;
   }
 
-  export class TokenStoreEscrow {
-    static TYPE_QNAME = "0x3::token_coin_swap::TokenStoreEscrow";
+  export namespace TokenListings {
+    export const TYPE_QNAME = "0x3::token_coin_swap::TokenListings";
+
+    const TYPE = new TypeDescriptor<TokenListings<any>>(
+      TokenListings.TYPE_QNAME
+    );
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<TokenListings<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface TokenStoreEscrow {
     token_escrows: _0x1.table.Table<token.TokenId, token_coin_swap.TokenEscrow>;
   }
 
-  export class TokenSwapEvent {
-    static TYPE_QNAME = "0x3::token_coin_swap::TokenSwapEvent";
+  export namespace TokenStoreEscrow {
+    export const TYPE_QNAME = "0x3::token_coin_swap::TokenStoreEscrow";
+
+    const TYPE = new TypeDescriptor<TokenStoreEscrow>(
+      TokenStoreEscrow.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<TokenStoreEscrow> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface TokenSwapEvent {
     token_id: token.TokenId;
     token_buyer: Address;
     token_amount: bigint;
@@ -750,6 +998,16 @@ export namespace token_coin_swap {
     coin_type_info: _0x1.type_info.TypeInfo;
   }
 
+  export namespace TokenSwapEvent {
+    export const TYPE_QNAME = "0x3::token_coin_swap::TokenSwapEvent";
+
+    const TYPE = new TypeDescriptor<TokenSwapEvent>(TokenSwapEvent.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<TokenSwapEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface TokenSwapEventInstance
     extends TypedEventInstance<TokenSwapEvent> {
     data_decoded: TokenSwapEvent;
@@ -893,59 +1151,110 @@ export class token_transfers extends AptosBaseProcessor {
 }
 
 export namespace token_transfers {
-  export class PendingClaims {
-    static TYPE_QNAME = "0x3::token_transfers::PendingClaims";
+  export interface PendingClaims {
     pending_claims: _0x1.table.Table<token_transfers.TokenOfferId, token.Token>;
     offer_events: _0x1.event.EventHandle<token_transfers.TokenOfferEvent>;
     cancel_offer_events: _0x1.event.EventHandle<token_transfers.TokenCancelOfferEvent>;
     claim_events: _0x1.event.EventHandle<token_transfers.TokenClaimEvent>;
   }
 
-  export class TokenCancelOfferEvent {
-    static TYPE_QNAME = "0x3::token_transfers::TokenCancelOfferEvent";
+  export namespace PendingClaims {
+    export const TYPE_QNAME = "0x3::token_transfers::PendingClaims";
+
+    const TYPE = new TypeDescriptor<PendingClaims>(PendingClaims.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<PendingClaims> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface TokenCancelOfferEvent {
     to_address: Address;
     token_id: token.TokenId;
     amount: bigint;
   }
 
+  export namespace TokenCancelOfferEvent {
+    export const TYPE_QNAME = "0x3::token_transfers::TokenCancelOfferEvent";
+
+    const TYPE = new TypeDescriptor<TokenCancelOfferEvent>(
+      TokenCancelOfferEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<TokenCancelOfferEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface TokenCancelOfferEventInstance
     extends TypedEventInstance<TokenCancelOfferEvent> {
     data_decoded: TokenCancelOfferEvent;
     type_arguments: [];
   }
 
-  export class TokenClaimEvent {
-    static TYPE_QNAME = "0x3::token_transfers::TokenClaimEvent";
+  export interface TokenClaimEvent {
     to_address: Address;
     token_id: token.TokenId;
     amount: bigint;
   }
 
+  export namespace TokenClaimEvent {
+    export const TYPE_QNAME = "0x3::token_transfers::TokenClaimEvent";
+
+    const TYPE = new TypeDescriptor<TokenClaimEvent>(
+      TokenClaimEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<TokenClaimEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface TokenClaimEventInstance
     extends TypedEventInstance<TokenClaimEvent> {
     data_decoded: TokenClaimEvent;
     type_arguments: [];
   }
 
-  export class TokenOfferEvent {
-    static TYPE_QNAME = "0x3::token_transfers::TokenOfferEvent";
+  export interface TokenOfferEvent {
     to_address: Address;
     token_id: token.TokenId;
     amount: bigint;
   }
 
+  export namespace TokenOfferEvent {
+    export const TYPE_QNAME = "0x3::token_transfers::TokenOfferEvent";
+
+    const TYPE = new TypeDescriptor<TokenOfferEvent>(
+      TokenOfferEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<TokenOfferEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface TokenOfferEventInstance
     extends TypedEventInstance<TokenOfferEvent> {
     data_decoded: TokenOfferEvent;
     type_arguments: [];
   }
 
-  export class TokenOfferId {
-    static TYPE_QNAME = "0x3::token_transfers::TokenOfferId";
+  export interface TokenOfferId {
     to_addr: Address;
     token_id: token.TokenId;
   }
 
+  export namespace TokenOfferId {
+    export const TYPE_QNAME = "0x3::token_transfers::TokenOfferId";
+
+    const TYPE = new TypeDescriptor<TokenOfferId>(TokenOfferId.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<TokenOfferId> {
+      return TYPE.apply();
+    }
+  }
+
   export interface CancelOfferScriptPayload
     extends TypedFunctionPayload<
       [Address, Address, Address, string, string, bigint]
@@ -1150,51 +1459,85 @@ export class token_event_store extends AptosBaseProcessor {
 }
 
 export namespace token_event_store {
-  export class CollectionDescriptionMutateEvent {
-    static TYPE_QNAME =
-      "0x3::token_event_store::CollectionDescriptionMutateEvent";
+  export interface CollectionDescriptionMutateEvent {
     creator_addr: Address;
     collection_name: string;
     old_description: string;
     new_description: string;
   }
 
+  export namespace CollectionDescriptionMutateEvent {
+    export const TYPE_QNAME =
+      "0x3::token_event_store::CollectionDescriptionMutateEvent";
+
+    const TYPE = new TypeDescriptor<CollectionDescriptionMutateEvent>(
+      CollectionDescriptionMutateEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<CollectionDescriptionMutateEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface CollectionDescriptionMutateEventInstance
     extends TypedEventInstance<CollectionDescriptionMutateEvent> {
     data_decoded: CollectionDescriptionMutateEvent;
     type_arguments: [];
   }
 
-  export class CollectionMaxiumMutateEvent {
-    static TYPE_QNAME = "0x3::token_event_store::CollectionMaxiumMutateEvent";
+  export interface CollectionMaxiumMutateEvent {
     creator_addr: Address;
     collection_name: string;
     old_maximum: bigint;
     new_maximum: bigint;
   }
 
+  export namespace CollectionMaxiumMutateEvent {
+    export const TYPE_QNAME =
+      "0x3::token_event_store::CollectionMaxiumMutateEvent";
+
+    const TYPE = new TypeDescriptor<CollectionMaxiumMutateEvent>(
+      CollectionMaxiumMutateEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<CollectionMaxiumMutateEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface CollectionMaxiumMutateEventInstance
     extends TypedEventInstance<CollectionMaxiumMutateEvent> {
     data_decoded: CollectionMaxiumMutateEvent;
     type_arguments: [];
   }
 
-  export class CollectionUriMutateEvent {
-    static TYPE_QNAME = "0x3::token_event_store::CollectionUriMutateEvent";
+  export interface CollectionUriMutateEvent {
     creator_addr: Address;
     collection_name: string;
     old_uri: string;
     new_uri: string;
   }
 
+  export namespace CollectionUriMutateEvent {
+    export const TYPE_QNAME =
+      "0x3::token_event_store::CollectionUriMutateEvent";
+
+    const TYPE = new TypeDescriptor<CollectionUriMutateEvent>(
+      CollectionUriMutateEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<CollectionUriMutateEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface CollectionUriMutateEventInstance
     extends TypedEventInstance<CollectionUriMutateEvent> {
     data_decoded: CollectionUriMutateEvent;
     type_arguments: [];
   }
 
-  export class DefaultPropertyMutateEvent {
-    static TYPE_QNAME = "0x3::token_event_store::DefaultPropertyMutateEvent";
+  export interface DefaultPropertyMutateEvent {
     creator: Address;
     collection: string;
     token: string;
@@ -1203,14 +1546,26 @@ export namespace token_event_store {
     new_values: property_map.PropertyValue[];
   }
 
+  export namespace DefaultPropertyMutateEvent {
+    export const TYPE_QNAME =
+      "0x3::token_event_store::DefaultPropertyMutateEvent";
+
+    const TYPE = new TypeDescriptor<DefaultPropertyMutateEvent>(
+      DefaultPropertyMutateEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<DefaultPropertyMutateEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface DefaultPropertyMutateEventInstance
     extends TypedEventInstance<DefaultPropertyMutateEvent> {
     data_decoded: DefaultPropertyMutateEvent;
     type_arguments: [];
   }
 
-  export class DescriptionMutateEvent {
-    static TYPE_QNAME = "0x3::token_event_store::DescriptionMutateEvent";
+  export interface DescriptionMutateEvent {
     creator: Address;
     collection: string;
     token: string;
@@ -1218,14 +1573,25 @@ export namespace token_event_store {
     new_description: string;
   }
 
+  export namespace DescriptionMutateEvent {
+    export const TYPE_QNAME = "0x3::token_event_store::DescriptionMutateEvent";
+
+    const TYPE = new TypeDescriptor<DescriptionMutateEvent>(
+      DescriptionMutateEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<DescriptionMutateEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface DescriptionMutateEventInstance
     extends TypedEventInstance<DescriptionMutateEvent> {
     data_decoded: DescriptionMutateEvent;
     type_arguments: [];
   }
 
-  export class MaxiumMutateEvent {
-    static TYPE_QNAME = "0x3::token_event_store::MaxiumMutateEvent";
+  export interface MaxiumMutateEvent {
     creator: Address;
     collection: string;
     token: string;
@@ -1233,25 +1599,47 @@ export namespace token_event_store {
     new_maximum: bigint;
   }
 
+  export namespace MaxiumMutateEvent {
+    export const TYPE_QNAME = "0x3::token_event_store::MaxiumMutateEvent";
+
+    const TYPE = new TypeDescriptor<MaxiumMutateEvent>(
+      MaxiumMutateEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<MaxiumMutateEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface MaxiumMutateEventInstance
     extends TypedEventInstance<MaxiumMutateEvent> {
     data_decoded: MaxiumMutateEvent;
     type_arguments: [];
   }
 
-  export class OptInTransferEvent {
-    static TYPE_QNAME = "0x3::token_event_store::OptInTransferEvent";
+  export interface OptInTransferEvent {
     opt_in: Boolean;
   }
 
+  export namespace OptInTransferEvent {
+    export const TYPE_QNAME = "0x3::token_event_store::OptInTransferEvent";
+
+    const TYPE = new TypeDescriptor<OptInTransferEvent>(
+      OptInTransferEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<OptInTransferEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface OptInTransferEventInstance
     extends TypedEventInstance<OptInTransferEvent> {
     data_decoded: OptInTransferEvent;
     type_arguments: [];
   }
 
-  export class RoyaltyMutateEvent {
-    static TYPE_QNAME = "0x3::token_event_store::RoyaltyMutateEvent";
+  export interface RoyaltyMutateEvent {
     creator: Address;
     collection: string;
     token: string;
@@ -1263,14 +1651,25 @@ export namespace token_event_store {
     new_royalty_payee_addr: Address;
   }
 
+  export namespace RoyaltyMutateEvent {
+    export const TYPE_QNAME = "0x3::token_event_store::RoyaltyMutateEvent";
+
+    const TYPE = new TypeDescriptor<RoyaltyMutateEvent>(
+      RoyaltyMutateEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<RoyaltyMutateEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface RoyaltyMutateEventInstance
     extends TypedEventInstance<RoyaltyMutateEvent> {
     data_decoded: RoyaltyMutateEvent;
     type_arguments: [];
   }
 
-  export class TokenEventStoreV1 {
-    static TYPE_QNAME = "0x3::token_event_store::TokenEventStoreV1";
+  export interface TokenEventStoreV1 {
     collection_uri_mutate_events: _0x1.event.EventHandle<token_event_store.CollectionUriMutateEvent>;
     collection_maximum_mutate_events: _0x1.event.EventHandle<token_event_store.CollectionMaxiumMutateEvent>;
     collection_description_mutate_events: _0x1.event.EventHandle<token_event_store.CollectionDescriptionMutateEvent>;
@@ -1283,8 +1682,19 @@ export namespace token_event_store {
     extension: _0x1.option.Option<_0x1.any_.Any>;
   }
 
-  export class UriMutationEvent {
-    static TYPE_QNAME = "0x3::token_event_store::UriMutationEvent";
+  export namespace TokenEventStoreV1 {
+    export const TYPE_QNAME = "0x3::token_event_store::TokenEventStoreV1";
+
+    const TYPE = new TypeDescriptor<TokenEventStoreV1>(
+      TokenEventStoreV1.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<TokenEventStoreV1> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface UriMutationEvent {
     creator: Address;
     collection: string;
     token: string;
@@ -1292,6 +1702,18 @@ export namespace token_event_store {
     new_uri: string;
   }
 
+  export namespace UriMutationEvent {
+    export const TYPE_QNAME = "0x3::token_event_store::UriMutationEvent";
+
+    const TYPE = new TypeDescriptor<UriMutationEvent>(
+      UriMutationEvent.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<UriMutationEvent> {
+      return TYPE.apply();
+    }
+  }
+
   export interface UriMutationEventInstance
     extends TypedEventInstance<UriMutationEvent> {
     data_decoded: UriMutationEvent;