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

package/src/sui/builtin/0x2.ts

@@ -4,7 +4,7 @@
 
 /* Generated modules for account 0x2 */
 
-import { CallFilter } from "@sentio/sdk/move";
+import { CallFilter, TypeDescriptor, ANY_TYPE } from "@sentio/sdk/move";
 import {
   MoveCoder,
   defaultMoveCoder,
@@ -23,20 +23,40 @@ import * as _0x1 from "./0x1.js";
 export namespace address {}
 
 export namespace bag {
-  export class Bag {
-    static TYPE_QNAME = "0x2::bag::Bag";
+  export interface Bag {
     id: object_.UID;
     size: bigint;
   }
+
+  export namespace Bag {
+    export const TYPE_QNAME = "0x2::bag::Bag";
+
+    const TYPE = new TypeDescriptor<Bag>(Bag.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Bag> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace balance {
   export type Balance<T> = string;
 
-  export class Supply<T0> {
-    static TYPE_QNAME = "0x2::balance::Supply";
+  export interface Supply<T0> {
     value: bigint;
   }
+
+  export namespace Supply {
+    export const TYPE_QNAME = "0x2::balance::Supply";
+
+    const TYPE = new TypeDescriptor<Supply<any>>(Supply.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<Supply<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
 }
 
 export class bcs extends SuiBaseProcessor {
@@ -68,11 +88,20 @@ export class bcs extends SuiBaseProcessor {
 }
 
 export namespace bcs {
-  export class BCS {
-    static TYPE_QNAME = "0x2::bcs::BCS";
+  export interface BCS {
     bytes: number[];
   }
 
+  export namespace BCS {
+    export const TYPE_QNAME = "0x2::bcs::BCS";
+
+    const TYPE = new TypeDescriptor<BCS>(BCS.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<BCS> {
+      return TYPE.apply();
+    }
+  }
+
   export interface BCSInstance extends TypedEventInstance<BCS> {
     data_decoded: BCS;
     type_arguments: [];
@@ -82,25 +111,54 @@ export namespace bcs {
 export namespace bls12381 {}
 
 export namespace borrow {
-  export class Borrow {
-    static TYPE_QNAME = "0x2::borrow::Borrow";
+  export interface Borrow {
     ref: SuiAddress;
     obj: object_.ID;
   }
 
-  export class Referent<T0> {
-    static TYPE_QNAME = "0x2::borrow::Referent";
+  export namespace Borrow {
+    export const TYPE_QNAME = "0x2::borrow::Borrow";
+
+    const TYPE = new TypeDescriptor<Borrow>(Borrow.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Borrow> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface Referent<T0> {
     id: SuiAddress;
     value: _0x1.option.Option<T0>;
   }
+
+  export namespace Referent {
+    export const TYPE_QNAME = "0x2::borrow::Referent";
+
+    const TYPE = new TypeDescriptor<Referent<any>>(Referent.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<Referent<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
 }
 
 export namespace clock {
-  export class Clock {
-    static TYPE_QNAME = "0x2::clock::Clock";
+  export interface Clock {
     id: object_.UID;
     timestamp_ms: bigint;
   }
+
+  export namespace Clock {
+    export const TYPE_QNAME = "0x2::clock::Clock";
+
+    const TYPE = new TypeDescriptor<Clock>(Clock.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Clock> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export class coin extends SuiBaseProcessor {
@@ -246,8 +304,7 @@ export class coin extends SuiBaseProcessor {
 export namespace coin {
   export type Coin<T> = string;
 
-  export class CoinMetadata<T0> {
-    static TYPE_QNAME = "0x2::coin::CoinMetadata";
+  export interface CoinMetadata<T0> {
     id: object_.UID;
     decimals: number;
     name: string;
@@ -256,23 +313,59 @@ export namespace coin {
     icon_url: _0x1.option.Option<url.Url>;
   }
 
-  export class CurrencyCreated<T0> {
-    static TYPE_QNAME = "0x2::coin::CurrencyCreated";
+  export namespace CoinMetadata {
+    export const TYPE_QNAME = "0x2::coin::CoinMetadata";
+
+    const TYPE = new TypeDescriptor<CoinMetadata<any>>(CoinMetadata.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<CoinMetadata<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface CurrencyCreated<T0> {
     decimals: number;
   }
 
+  export namespace CurrencyCreated {
+    export const TYPE_QNAME = "0x2::coin::CurrencyCreated";
+
+    const TYPE = new TypeDescriptor<CurrencyCreated<any>>(
+      CurrencyCreated.TYPE_QNAME
+    );
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<CurrencyCreated<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
   export interface CurrencyCreatedInstance
     extends TypedEventInstance<CurrencyCreated<any>> {
     data_decoded: CurrencyCreated<any>;
     type_arguments: [string];
   }
 
-  export class TreasuryCap<T0> {
-    static TYPE_QNAME = "0x2::coin::TreasuryCap";
+  export interface TreasuryCap<T0> {
     id: object_.UID;
     total_supply: balance.Supply<T0>;
   }
 
+  export namespace TreasuryCap {
+    export const TYPE_QNAME = "0x2::coin::TreasuryCap";
+
+    const TYPE = new TypeDescriptor<TreasuryCap<any>>(TreasuryCap.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<TreasuryCap<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
   export interface BurnPayload<T0 = any>
     extends TypedFunctionPayload<[SuiAddress | undefined]> {
     arguments_decoded: [SuiAddress | undefined];
@@ -469,31 +562,68 @@ export class display extends SuiBaseProcessor {
 }
 
 export namespace display {
-  export class Display<T0> {
-    static TYPE_QNAME = "0x2::display::Display";
+  export interface Display<T0> {
     id: object_.UID;
     fields: vec_map.VecMap<string, string>;
     version: number;
   }
 
-  export class DisplayCreated<T0> {
-    static TYPE_QNAME = "0x2::display::DisplayCreated";
+  export namespace Display {
+    export const TYPE_QNAME = "0x2::display::Display";
+
+    const TYPE = new TypeDescriptor<Display<any>>(Display.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<Display<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface DisplayCreated<T0> {
     id: object_.ID;
   }
 
+  export namespace DisplayCreated {
+    export const TYPE_QNAME = "0x2::display::DisplayCreated";
+
+    const TYPE = new TypeDescriptor<DisplayCreated<any>>(
+      DisplayCreated.TYPE_QNAME
+    );
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<DisplayCreated<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
   export interface DisplayCreatedInstance
     extends TypedEventInstance<DisplayCreated<any>> {
     data_decoded: DisplayCreated<any>;
     type_arguments: [string];
   }
 
-  export class VersionUpdated<T0> {
-    static TYPE_QNAME = "0x2::display::VersionUpdated";
+  export interface VersionUpdated<T0> {
     id: object_.ID;
     version: number;
     fields: vec_map.VecMap<string, string>;
   }
 
+  export namespace VersionUpdated {
+    export const TYPE_QNAME = "0x2::display::VersionUpdated";
+
+    const TYPE = new TypeDescriptor<VersionUpdated<any>>(
+      VersionUpdated.TYPE_QNAME
+    );
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<VersionUpdated<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
   export interface VersionUpdatedInstance
     extends TypedEventInstance<VersionUpdated<any>> {
     data_decoded: VersionUpdated<any>;
@@ -540,12 +670,24 @@ export namespace display {
 }
 
 export namespace dynamic_field {
-  export class Field<T0, T1> {
-    static TYPE_QNAME = "0x2::dynamic_field::Field";
+  export interface Field<T0, T1> {
     id: object_.UID;
     name: T0;
     value: T1;
   }
+
+  export namespace Field {
+    export const TYPE_QNAME = "0x2::dynamic_field::Field";
+
+    const TYPE = new TypeDescriptor<Field<any, any>>(Field.TYPE_QNAME);
+
+    export function type<T0, T1>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE,
+      arg1: TypeDescriptor<T1> = ANY_TYPE
+    ): TypeDescriptor<Field<T0, T1>> {
+      return TYPE.apply(arg0, arg1);
+    }
+  }
 }
 
 export class dynamic_object_field extends SuiBaseProcessor {
@@ -583,11 +725,22 @@ export class dynamic_object_field extends SuiBaseProcessor {
 }
 
 export namespace dynamic_object_field {
-  export class Wrapper<T0> {
-    static TYPE_QNAME = "0x2::dynamic_object_field::Wrapper";
+  export interface Wrapper<T0> {
     name: T0;
   }
 
+  export namespace Wrapper {
+    export const TYPE_QNAME = "0x2::dynamic_object_field::Wrapper";
+
+    const TYPE = new TypeDescriptor<Wrapper<any>>(Wrapper.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<Wrapper<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
   export interface WrapperInstance extends TypedEventInstance<Wrapper<any>> {
     data_decoded: Wrapper<any>;
     type_arguments: [string];
@@ -678,45 +831,85 @@ export class groth16 extends SuiBaseProcessor {
 }
 
 export namespace groth16 {
-  export class Curve {
-    static TYPE_QNAME = "0x2::groth16::Curve";
+  export interface Curve {
     id: number;
   }
 
+  export namespace Curve {
+    export const TYPE_QNAME = "0x2::groth16::Curve";
+
+    const TYPE = new TypeDescriptor<Curve>(Curve.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Curve> {
+      return TYPE.apply();
+    }
+  }
+
   export interface CurveInstance extends TypedEventInstance<Curve> {
     data_decoded: Curve;
     type_arguments: [];
   }
 
-  export class PreparedVerifyingKey {
-    static TYPE_QNAME = "0x2::groth16::PreparedVerifyingKey";
+  export interface PreparedVerifyingKey {
     vk_gamma_abc_g1_bytes: number[];
     alpha_g1_beta_g2_bytes: number[];
     gamma_g2_neg_pc_bytes: number[];
     delta_g2_neg_pc_bytes: number[];
   }
 
+  export namespace PreparedVerifyingKey {
+    export const TYPE_QNAME = "0x2::groth16::PreparedVerifyingKey";
+
+    const TYPE = new TypeDescriptor<PreparedVerifyingKey>(
+      PreparedVerifyingKey.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<PreparedVerifyingKey> {
+      return TYPE.apply();
+    }
+  }
+
   export interface PreparedVerifyingKeyInstance
     extends TypedEventInstance<PreparedVerifyingKey> {
     data_decoded: PreparedVerifyingKey;
     type_arguments: [];
   }
 
-  export class ProofPoints {
-    static TYPE_QNAME = "0x2::groth16::ProofPoints";
+  export interface ProofPoints {
     bytes: number[];
   }
 
+  export namespace ProofPoints {
+    export const TYPE_QNAME = "0x2::groth16::ProofPoints";
+
+    const TYPE = new TypeDescriptor<ProofPoints>(ProofPoints.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<ProofPoints> {
+      return TYPE.apply();
+    }
+  }
+
   export interface ProofPointsInstance extends TypedEventInstance<ProofPoints> {
     data_decoded: ProofPoints;
     type_arguments: [];
   }
 
-  export class PublicProofInputs {
-    static TYPE_QNAME = "0x2::groth16::PublicProofInputs";
+  export interface PublicProofInputs {
     bytes: number[];
   }
 
+  export namespace PublicProofInputs {
+    export const TYPE_QNAME = "0x2::groth16::PublicProofInputs";
+
+    const TYPE = new TypeDescriptor<PublicProofInputs>(
+      PublicProofInputs.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<PublicProofInputs> {
+      return TYPE.apply();
+    }
+  }
+
   export interface PublicProofInputsInstance
     extends TypedEventInstance<PublicProofInputs> {
     data_decoded: PublicProofInputs;
@@ -801,31 +994,50 @@ export class kiosk extends SuiBaseProcessor {
 }
 
 export namespace kiosk {
-  export class Item {
-    static TYPE_QNAME = "0x2::kiosk::Item";
+  export interface Item {
     id: object_.ID;
   }
 
+  export namespace Item {
+    export const TYPE_QNAME = "0x2::kiosk::Item";
+
+    const TYPE = new TypeDescriptor<Item>(Item.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Item> {
+      return TYPE.apply();
+    }
+  }
+
   export interface ItemInstance extends TypedEventInstance<Item> {
     data_decoded: Item;
     type_arguments: [];
   }
 
-  export class ItemListed<T0> {
-    static TYPE_QNAME = "0x2::kiosk::ItemListed";
+  export interface ItemListed<T0> {
     kiosk: object_.ID;
     id: object_.ID;
     price: bigint;
   }
 
+  export namespace ItemListed {
+    export const TYPE_QNAME = "0x2::kiosk::ItemListed";
+
+    const TYPE = new TypeDescriptor<ItemListed<any>>(ItemListed.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<ItemListed<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
   export interface ItemListedInstance
     extends TypedEventInstance<ItemListed<any>> {
     data_decoded: ItemListed<any>;
     type_arguments: [string];
   }
 
-  export class Kiosk {
-    static TYPE_QNAME = "0x2::kiosk::Kiosk";
+  export interface Kiosk {
     id: object_.UID;
     profits: balance.Balance<sui.SUI>;
     owner: SuiAddress;
@@ -833,57 +1045,131 @@ export namespace kiosk {
     allow_extensions: Boolean;
   }
 
-  export class KioskOwnerCap {
-    static TYPE_QNAME = "0x2::kiosk::KioskOwnerCap";
+  export namespace Kiosk {
+    export const TYPE_QNAME = "0x2::kiosk::Kiosk";
+
+    const TYPE = new TypeDescriptor<Kiosk>(Kiosk.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Kiosk> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface KioskOwnerCap {
     id: object_.UID;
     for: object_.ID;
   }
 
-  export class Listing {
-    static TYPE_QNAME = "0x2::kiosk::Listing";
+  export namespace KioskOwnerCap {
+    export const TYPE_QNAME = "0x2::kiosk::KioskOwnerCap";
+
+    const TYPE = new TypeDescriptor<KioskOwnerCap>(KioskOwnerCap.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<KioskOwnerCap> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface Listing {
     id: object_.ID;
     is_exclusive: Boolean;
   }
 
+  export namespace Listing {
+    export const TYPE_QNAME = "0x2::kiosk::Listing";
+
+    const TYPE = new TypeDescriptor<Listing>(Listing.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Listing> {
+      return TYPE.apply();
+    }
+  }
+
   export interface ListingInstance extends TypedEventInstance<Listing> {
     data_decoded: Listing;
     type_arguments: [];
   }
 
-  export class Lock {
-    static TYPE_QNAME = "0x2::kiosk::Lock";
+  export interface Lock {
     id: object_.ID;
   }
 
+  export namespace Lock {
+    export const TYPE_QNAME = "0x2::kiosk::Lock";
+
+    const TYPE = new TypeDescriptor<Lock>(Lock.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Lock> {
+      return TYPE.apply();
+    }
+  }
+
   export interface LockInstance extends TypedEventInstance<Lock> {
     data_decoded: Lock;
     type_arguments: [];
   }
 
-  export class PurchaseCap<T0> {
-    static TYPE_QNAME = "0x2::kiosk::PurchaseCap";
+  export interface PurchaseCap<T0> {
     id: object_.UID;
     kiosk_id: object_.ID;
     item_id: object_.ID;
     min_price: bigint;
   }
+
+  export namespace PurchaseCap {
+    export const TYPE_QNAME = "0x2::kiosk::PurchaseCap";
+
+    const TYPE = new TypeDescriptor<PurchaseCap<any>>(PurchaseCap.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<PurchaseCap<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
 }
 
 export namespace linked_table {
-  export class LinkedTable<T0, T1> {
-    static TYPE_QNAME = "0x2::linked_table::LinkedTable";
+  export interface LinkedTable<T0, T1> {
     id: object_.UID;
     size: bigint;
     head: _0x1.option.Option<T0>;
     tail: _0x1.option.Option<T0>;
   }
 
-  export class Node<T0, T1> {
-    static TYPE_QNAME = "0x2::linked_table::Node";
+  export namespace LinkedTable {
+    export const TYPE_QNAME = "0x2::linked_table::LinkedTable";
+
+    const TYPE = new TypeDescriptor<LinkedTable<any, any>>(
+      LinkedTable.TYPE_QNAME
+    );
+
+    export function type<T0, T1>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE,
+      arg1: TypeDescriptor<T1> = ANY_TYPE
+    ): TypeDescriptor<LinkedTable<T0, T1>> {
+      return TYPE.apply(arg0, arg1);
+    }
+  }
+
+  export interface Node<T0, T1> {
     prev: _0x1.option.Option<T0>;
     next: _0x1.option.Option<T0>;
     value: T1;
   }
+
+  export namespace Node {
+    export const TYPE_QNAME = "0x2::linked_table::Node";
+
+    const TYPE = new TypeDescriptor<Node<any, any>>(Node.TYPE_QNAME);
+
+    export function type<T0, T1>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE,
+      arg1: TypeDescriptor<T1> = ANY_TYPE
+    ): TypeDescriptor<Node<T0, T1>> {
+      return TYPE.apply(arg0, arg1);
+    }
+  }
 }
 
 export namespace math {}
@@ -891,26 +1177,58 @@ export namespace math {}
 export namespace object_ {
   export type ID = string;
 
-  export class UID {
-    static TYPE_QNAME = "0x2::object::UID";
+  export interface UID {
     id: object_.ID;
   }
+
+  export namespace UID {
+    export const TYPE_QNAME = "0x2::object::UID";
+
+    const TYPE = new TypeDescriptor<UID>(UID.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<UID> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace object_bag {
-  export class ObjectBag {
-    static TYPE_QNAME = "0x2::object_bag::ObjectBag";
+  export interface ObjectBag {
     id: object_.UID;
     size: bigint;
   }
+
+  export namespace ObjectBag {
+    export const TYPE_QNAME = "0x2::object_bag::ObjectBag";
+
+    const TYPE = new TypeDescriptor<ObjectBag>(ObjectBag.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<ObjectBag> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace object_table {
-  export class ObjectTable<T0, T1> {
-    static TYPE_QNAME = "0x2::object_table::ObjectTable";
+  export interface ObjectTable<T0, T1> {
     id: object_.UID;
     size: bigint;
   }
+
+  export namespace ObjectTable {
+    export const TYPE_QNAME = "0x2::object_table::ObjectTable";
+
+    const TYPE = new TypeDescriptor<ObjectTable<any, any>>(
+      ObjectTable.TYPE_QNAME
+    );
+
+    export function type<T0, T1>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE,
+      arg1: TypeDescriptor<T1> = ANY_TYPE
+    ): TypeDescriptor<ObjectTable<T0, T1>> {
+      return TYPE.apply(arg0, arg1);
+    }
+  }
 }
 
 export class package_ extends SuiBaseProcessor {
@@ -976,35 +1294,71 @@ export class package_ extends SuiBaseProcessor {
 }
 
 export namespace package_ {
-  export class Publisher {
-    static TYPE_QNAME = "0x2::package::Publisher";
+  export interface Publisher {
     id: object_.UID;
     package: _0x1.ascii.String;
     module_name: _0x1.ascii.String;
   }
 
-  export class UpgradeCap {
-    static TYPE_QNAME = "0x2::package::UpgradeCap";
+  export namespace Publisher {
+    export const TYPE_QNAME = "0x2::package::Publisher";
+
+    const TYPE = new TypeDescriptor<Publisher>(Publisher.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Publisher> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface UpgradeCap {
     id: object_.UID;
     package: object_.ID;
     version: bigint;
     policy: number;
   }
 
-  export class UpgradeReceipt {
-    static TYPE_QNAME = "0x2::package::UpgradeReceipt";
+  export namespace UpgradeCap {
+    export const TYPE_QNAME = "0x2::package::UpgradeCap";
+
+    const TYPE = new TypeDescriptor<UpgradeCap>(UpgradeCap.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<UpgradeCap> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface UpgradeReceipt {
     cap: object_.ID;
     package: object_.ID;
   }
 
-  export class UpgradeTicket {
-    static TYPE_QNAME = "0x2::package::UpgradeTicket";
+  export namespace UpgradeReceipt {
+    export const TYPE_QNAME = "0x2::package::UpgradeReceipt";
+
+    const TYPE = new TypeDescriptor<UpgradeReceipt>(UpgradeReceipt.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<UpgradeReceipt> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface UpgradeTicket {
     cap: object_.ID;
     package: object_.ID;
     policy: number;
     digest: number[];
   }
 
+  export namespace UpgradeTicket {
+    export const TYPE_QNAME = "0x2::package::UpgradeTicket";
+
+    const TYPE = new TypeDescriptor<UpgradeTicket>(UpgradeTicket.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<UpgradeTicket> {
+      return TYPE.apply();
+    }
+  }
+
   export interface MakeImmutablePayload extends TypedFunctionPayload<[]> {
     arguments_decoded: [];
     type_arguments: [];
@@ -1201,16 +1555,40 @@ export namespace pay {
 }
 
 export namespace priority_queue {
-  export class Entry<T0> {
-    static TYPE_QNAME = "0x2::priority_queue::Entry";
+  export interface Entry<T0> {
     priority: bigint;
     value: T0;
   }
 
-  export class PriorityQueue<T0> {
-    static TYPE_QNAME = "0x2::priority_queue::PriorityQueue";
+  export namespace Entry {
+    export const TYPE_QNAME = "0x2::priority_queue::Entry";
+
+    const TYPE = new TypeDescriptor<Entry<any>>(Entry.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<Entry<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface PriorityQueue<T0> {
     entries: priority_queue.Entry<T0>[];
   }
+
+  export namespace PriorityQueue {
+    export const TYPE_QNAME = "0x2::priority_queue::PriorityQueue";
+
+    const TYPE = new TypeDescriptor<PriorityQueue<any>>(
+      PriorityQueue.TYPE_QNAME
+    );
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<PriorityQueue<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
 }
 
 export namespace prover {}
@@ -1246,11 +1624,20 @@ export class sui extends SuiBaseProcessor {
 }
 
 export namespace sui {
-  export class SUI {
-    static TYPE_QNAME = "0x2::sui::SUI";
+  export interface SUI {
     dummy_field: Boolean;
   }
 
+  export namespace SUI {
+    export const TYPE_QNAME = "0x2::sui::SUI";
+
+    const TYPE = new TypeDescriptor<SUI>(SUI.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<SUI> {
+      return TYPE.apply();
+    }
+  }
+
   export interface TransferPayload
     extends TypedFunctionPayload<[coin.Coin<sui.SUI> | undefined]> {
     arguments_decoded: [coin.Coin<sui.SUI> | undefined];
@@ -1259,18 +1646,41 @@ export namespace sui {
 }
 
 export namespace table {
-  export class Table<T0, T1> {
-    static TYPE_QNAME = "0x2::table::Table";
+  export interface Table<T0, T1> {
     id: object_.UID;
     size: bigint;
   }
+
+  export namespace Table {
+    export const TYPE_QNAME = "0x2::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 table_vec {
-  export class TableVec<T0> {
-    static TYPE_QNAME = "0x2::table_vec::TableVec";
+  export interface TableVec<T0> {
     contents: table.Table<bigint, T0>;
   }
+
+  export namespace TableVec {
+    export const TYPE_QNAME = "0x2::table_vec::TableVec";
+
+    const TYPE = new TypeDescriptor<TableVec<any>>(TableVec.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<TableVec<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
 }
 
 export namespace transfer {}
@@ -1324,58 +1734,130 @@ export class transfer_policy extends SuiBaseProcessor {
 }
 
 export namespace transfer_policy {
-  export class RuleKey<T0> {
-    static TYPE_QNAME = "0x2::transfer_policy::RuleKey";
+  export interface RuleKey<T0> {
     dummy_field: Boolean;
   }
 
+  export namespace RuleKey {
+    export const TYPE_QNAME = "0x2::transfer_policy::RuleKey";
+
+    const TYPE = new TypeDescriptor<RuleKey<any>>(RuleKey.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<RuleKey<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
   export interface RuleKeyInstance extends TypedEventInstance<RuleKey<any>> {
     data_decoded: RuleKey<any>;
     type_arguments: [string];
   }
 
-  export class TransferPolicy<T0> {
-    static TYPE_QNAME = "0x2::transfer_policy::TransferPolicy";
+  export interface TransferPolicy<T0> {
     id: object_.UID;
     balance: balance.Balance<sui.SUI>;
     rules: vec_set.VecSet<_0x1.type_name.TypeName>;
   }
 
-  export class TransferPolicyCap<T0> {
-    static TYPE_QNAME = "0x2::transfer_policy::TransferPolicyCap";
+  export namespace TransferPolicy {
+    export const TYPE_QNAME = "0x2::transfer_policy::TransferPolicy";
+
+    const TYPE = new TypeDescriptor<TransferPolicy<any>>(
+      TransferPolicy.TYPE_QNAME
+    );
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<TransferPolicy<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface TransferPolicyCap<T0> {
     id: object_.UID;
     policy_id: object_.ID;
   }
 
-  export class TransferPolicyCreated<T0> {
-    static TYPE_QNAME = "0x2::transfer_policy::TransferPolicyCreated";
+  export namespace TransferPolicyCap {
+    export const TYPE_QNAME = "0x2::transfer_policy::TransferPolicyCap";
+
+    const TYPE = new TypeDescriptor<TransferPolicyCap<any>>(
+      TransferPolicyCap.TYPE_QNAME
+    );
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<TransferPolicyCap<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
+  export interface TransferPolicyCreated<T0> {
     id: object_.ID;
   }
 
+  export namespace TransferPolicyCreated {
+    export const TYPE_QNAME = "0x2::transfer_policy::TransferPolicyCreated";
+
+    const TYPE = new TypeDescriptor<TransferPolicyCreated<any>>(
+      TransferPolicyCreated.TYPE_QNAME
+    );
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<TransferPolicyCreated<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
   export interface TransferPolicyCreatedInstance
     extends TypedEventInstance<TransferPolicyCreated<any>> {
     data_decoded: TransferPolicyCreated<any>;
     type_arguments: [string];
   }
 
-  export class TransferRequest<T0> {
-    static TYPE_QNAME = "0x2::transfer_policy::TransferRequest";
+  export interface TransferRequest<T0> {
     item: object_.ID;
     paid: bigint;
     from: object_.ID;
     receipts: vec_set.VecSet<_0x1.type_name.TypeName>;
   }
+
+  export namespace TransferRequest {
+    export const TYPE_QNAME = "0x2::transfer_policy::TransferRequest";
+
+    const TYPE = new TypeDescriptor<TransferRequest<any>>(
+      TransferRequest.TYPE_QNAME
+    );
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<TransferRequest<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
 }
 
 export namespace tx_context {
-  export class TxContext {
-    static TYPE_QNAME = "0x2::tx_context::TxContext";
+  export interface TxContext {
     sender: SuiAddress;
     tx_hash: number[];
     epoch: bigint;
     epoch_timestamp_ms: bigint;
     ids_created: bigint;
   }
+
+  export namespace TxContext {
+    export const TYPE_QNAME = "0x2::tx_context::TxContext";
+
+    const TYPE = new TypeDescriptor<TxContext>(TxContext.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<TxContext> {
+      return TYPE.apply();
+    }
+  }
 }
 
 export namespace types {}
@@ -1409,11 +1891,20 @@ export class url extends SuiBaseProcessor {
 }
 
 export namespace url {
-  export class Url {
-    static TYPE_QNAME = "0x2::url::Url";
+  export interface Url {
     url: _0x1.ascii.String;
   }
 
+  export namespace Url {
+    export const TYPE_QNAME = "0x2::url::Url";
+
+    const TYPE = new TypeDescriptor<Url>(Url.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Url> {
+      return TYPE.apply();
+    }
+  }
+
   export interface UrlInstance extends TypedEventInstance<Url> {
     data_decoded: Url;
     type_arguments: [];
@@ -1463,22 +1954,46 @@ export class vec_map extends SuiBaseProcessor {
 }
 
 export namespace vec_map {
-  export class Entry<T0, T1> {
-    static TYPE_QNAME = "0x2::vec_map::Entry";
+  export interface Entry<T0, T1> {
     key: T0;
     value: T1;
   }
 
+  export namespace Entry {
+    export const TYPE_QNAME = "0x2::vec_map::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 EntryInstance extends TypedEventInstance<Entry<any, any>> {
     data_decoded: Entry<any, any>;
     type_arguments: [string, string];
   }
 
-  export class VecMap<T0, T1> {
-    static TYPE_QNAME = "0x2::vec_map::VecMap";
+  export interface VecMap<T0, T1> {
     contents: vec_map.Entry<T0, T1>[];
   }
 
+  export namespace VecMap {
+    export const TYPE_QNAME = "0x2::vec_map::VecMap";
+
+    const TYPE = new TypeDescriptor<VecMap<any, any>>(VecMap.TYPE_QNAME);
+
+    export function type<T0, T1>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE,
+      arg1: TypeDescriptor<T1> = ANY_TYPE
+    ): TypeDescriptor<VecMap<T0, T1>> {
+      return TYPE.apply(arg0, arg1);
+    }
+  }
+
   export interface VecMapInstance extends TypedEventInstance<VecMap<any, any>> {
     data_decoded: VecMap<any, any>;
     type_arguments: [string, string];
@@ -1514,11 +2029,22 @@ export class vec_set extends SuiBaseProcessor {
 }
 
 export namespace vec_set {
-  export class VecSet<T0> {
-    static TYPE_QNAME = "0x2::vec_set::VecSet";
+  export interface VecSet<T0> {
     contents: T0[] | string;
   }
 
+  export namespace VecSet {
+    export const TYPE_QNAME = "0x2::vec_set::VecSet";
+
+    const TYPE = new TypeDescriptor<VecSet<any>>(VecSet.TYPE_QNAME);
+
+    export function type<T0>(
+      arg0: TypeDescriptor<T0> = ANY_TYPE
+    ): TypeDescriptor<VecSet<T0>> {
+      return TYPE.apply(arg0);
+    }
+  }
+
   export interface VecSetInstance extends TypedEventInstance<VecSet<any>> {
     data_decoded: VecSet<any>;
     type_arguments: [string];
@@ -1526,17 +2052,37 @@ export namespace vec_set {
 }
 
 export namespace versioned {
-  export class VersionChangeCap {
-    static TYPE_QNAME = "0x2::versioned::VersionChangeCap";
+  export interface VersionChangeCap {
     versioned_id: object_.ID;
     old_version: bigint;
   }
 
-  export class Versioned {
-    static TYPE_QNAME = "0x2::versioned::Versioned";
+  export namespace VersionChangeCap {
+    export const TYPE_QNAME = "0x2::versioned::VersionChangeCap";
+
+    const TYPE = new TypeDescriptor<VersionChangeCap>(
+      VersionChangeCap.TYPE_QNAME
+    );
+
+    export function type(): TypeDescriptor<VersionChangeCap> {
+      return TYPE.apply();
+    }
+  }
+
+  export interface Versioned {
     id: object_.UID;
     version: bigint;
   }
+
+  export namespace Versioned {
+    export const TYPE_QNAME = "0x2::versioned::Versioned";
+
+    const TYPE = new TypeDescriptor<Versioned>(Versioned.TYPE_QNAME);
+
+    export function type(): TypeDescriptor<Versioned> {
+      return TYPE.apply();
+    }
+  }
 }
 
 const MODULES = JSON.parse(