@sentio/sdk 2.13.0-rc.1 → 2.13.0-rc.11

package/lib/sui/builtin/0x2.d.ts

@@ -1,37 +1,43 @@
-import { CallFilter } from "@sentio/sdk/move";
+import { CallFilter, TypeDescriptor } from "@sentio/sdk/move";
 import { MoveCoder, SuiBindOptions, SuiBaseProcessor, TypedEventInstance, TypedFunctionPayload, SuiContext } from "@sentio/sdk/sui";
 import { MoveFetchConfig } from "@sentio/protos";
 import { SuiAddress } from "@sentio/sdk/sui";
 import * as _0x1 from "./0x1.js";
 export declare namespace address { }
 export declare namespace bag {
-    class Bag {
-        static TYPE_QNAME: string;
+    interface Bag {
         id: object_.UID;
         size: bigint;
     }
+    namespace Bag {
+        const TYPE_QNAME = "0x2::bag::Bag";
+        function type(): TypeDescriptor<Bag>;
+    }
 }
 export declare namespace balance {
-    class Balance<T0> {
-        static TYPE_QNAME: string;
+    type Balance<T> = string;
+    interface Supply<T0> {
         value: bigint;
     }
-    class Supply<T0> {
-        static TYPE_QNAME: string;
-        value: bigint;
+    namespace Supply {
+        const TYPE_QNAME = "0x2::balance::Supply";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Supply<T0>>;
     }
 }
 export declare class bcs extends SuiBaseProcessor {
     constructor(options: SuiBindOptions);
     static DEFAULT_OPTIONS: SuiBindOptions;
     static bind(options?: Partial<SuiBindOptions>): bcs;
-    onEventBCS(func: (event: bcs.BCSInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): bcs;
+    onEventBCS(func: (event: bcs.BCSInstance, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): bcs;
 }
 export declare namespace bcs {
-    class BCS {
-        static TYPE_QNAME: string;
+    interface BCS {
         bytes: number[];
     }
+    namespace BCS {
+        const TYPE_QNAME = "0x2::bcs::BCS";
+        function type(): TypeDescriptor<BCS>;
+    }
     interface BCSInstance extends TypedEventInstance<BCS> {
         data_decoded: BCS;
         type_arguments: [];
@@ -39,23 +45,32 @@ export declare namespace bcs {
 }
 export declare namespace bls12381 { }
 export declare namespace borrow {
-    class Borrow {
-        static TYPE_QNAME: string;
+    interface Borrow {
         ref: SuiAddress;
         obj: object_.ID;
     }
-    class Referent<T0> {
-        static TYPE_QNAME: string;
+    namespace Borrow {
+        const TYPE_QNAME = "0x2::borrow::Borrow";
+        function type(): TypeDescriptor<Borrow>;
+    }
+    interface Referent<T0> {
         id: SuiAddress;
         value: _0x1.option.Option<T0>;
     }
+    namespace Referent {
+        const TYPE_QNAME = "0x2::borrow::Referent";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Referent<T0>>;
+    }
 }
 export declare namespace clock {
-    class Clock {
-        static TYPE_QNAME: string;
+    interface Clock {
         id: object_.UID;
         timestamp_ms: bigint;
     }
+    namespace Clock {
+        const TYPE_QNAME = "0x2::clock::Clock";
+        function type(): TypeDescriptor<Clock>;
+    }
 }
 export declare class coin extends SuiBaseProcessor {
     constructor(options: SuiBindOptions);
@@ -68,12 +83,11 @@ export declare class coin extends SuiBaseProcessor {
     onEntryUpdateIconUrl(func: (call: coin.UpdateIconUrlPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): coin;
     onEntryUpdateName(func: (call: coin.UpdateNamePayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): coin;
     onEntryUpdateSymbol(func: (call: coin.UpdateSymbolPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): coin;
-    onEventCurrencyCreated(func: (event: coin.CurrencyCreatedInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): coin;
+    onEventCurrencyCreated(func: (event: coin.CurrencyCreatedInstance, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): coin;
 }
 export declare namespace coin {
     type Coin<T> = string;
-    class CoinMetadata<T0> {
-        static TYPE_QNAME: string;
+    interface CoinMetadata<T0> {
         id: object_.UID;
         decimals: number;
         name: string;
@@ -81,19 +95,29 @@ export declare namespace coin {
         description: string;
         icon_url: _0x1.option.Option<url.Url>;
     }
-    class CurrencyCreated<T0> {
-        static TYPE_QNAME: string;
+    namespace CoinMetadata {
+        const TYPE_QNAME = "0x2::coin::CoinMetadata";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<CoinMetadata<T0>>;
+    }
+    interface CurrencyCreated<T0> {
         decimals: number;
     }
+    namespace CurrencyCreated {
+        const TYPE_QNAME = "0x2::coin::CurrencyCreated";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<CurrencyCreated<T0>>;
+    }
     interface CurrencyCreatedInstance extends TypedEventInstance<CurrencyCreated<any>> {
         data_decoded: CurrencyCreated<any>;
         type_arguments: [string];
     }
-    class TreasuryCap<T0> {
-        static TYPE_QNAME: string;
+    interface TreasuryCap<T0> {
         id: object_.UID;
         total_supply: balance.Supply<T0>;
     }
+    namespace TreasuryCap {
+        const TYPE_QNAME = "0x2::coin::TreasuryCap";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<TreasuryCap<T0>>;
+    }
     interface BurnPayload<T0 = any> extends TypedFunctionPayload<[SuiAddress | undefined]> {
         arguments_decoded: [SuiAddress | undefined];
         type_arguments: [string];
@@ -153,30 +177,39 @@ export declare class display extends SuiBaseProcessor {
     onEntryEdit(func: (call: display.EditPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): display;
     onEntryRemove(func: (call: display.RemovePayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): display;
     onEntryUpdateVersion(func: (call: display.UpdateVersionPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): display;
-    onEventDisplayCreated(func: (event: display.DisplayCreatedInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): display;
-    onEventVersionUpdated(func: (event: display.VersionUpdatedInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): display;
+    onEventDisplayCreated(func: (event: display.DisplayCreatedInstance, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): display;
+    onEventVersionUpdated(func: (event: display.VersionUpdatedInstance, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): display;
 }
 export declare namespace display {
-    class Display<T0> {
-        static TYPE_QNAME: string;
+    interface Display<T0> {
         id: object_.UID;
         fields: vec_map.VecMap<string, string>;
         version: number;
     }
-    class DisplayCreated<T0> {
-        static TYPE_QNAME: string;
+    namespace Display {
+        const TYPE_QNAME = "0x2::display::Display";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Display<T0>>;
+    }
+    interface DisplayCreated<T0> {
         id: object_.ID;
     }
+    namespace DisplayCreated {
+        const TYPE_QNAME = "0x2::display::DisplayCreated";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<DisplayCreated<T0>>;
+    }
     interface DisplayCreatedInstance extends TypedEventInstance<DisplayCreated<any>> {
         data_decoded: DisplayCreated<any>;
         type_arguments: [string];
     }
-    class VersionUpdated<T0> {
-        static TYPE_QNAME: string;
+    interface VersionUpdated<T0> {
         id: object_.ID;
         version: number;
         fields: vec_map.VecMap<string, string>;
     }
+    namespace VersionUpdated {
+        const TYPE_QNAME = "0x2::display::VersionUpdated";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<VersionUpdated<T0>>;
+    }
     interface VersionUpdatedInstance extends TypedEventInstance<VersionUpdated<any>> {
         data_decoded: VersionUpdated<any>;
         type_arguments: [string];
@@ -210,24 +243,30 @@ export declare namespace display {
     }
 }
 export declare namespace dynamic_field {
-    class Field<T0, T1> {
-        static TYPE_QNAME: string;
+    interface Field<T0, T1> {
         id: object_.UID;
         name: T0;
         value: T1;
     }
+    namespace Field {
+        const TYPE_QNAME = "0x2::dynamic_field::Field";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Field<T0, T1>>;
+    }
 }
 export declare class dynamic_object_field extends SuiBaseProcessor {
     constructor(options: SuiBindOptions);
     static DEFAULT_OPTIONS: SuiBindOptions;
     static bind(options?: Partial<SuiBindOptions>): dynamic_object_field;
-    onEventWrapper(func: (event: dynamic_object_field.WrapperInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): dynamic_object_field;
+    onEventWrapper(func: (event: dynamic_object_field.WrapperInstance, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): dynamic_object_field;
 }
 export declare namespace dynamic_object_field {
-    class Wrapper<T0> {
-        static TYPE_QNAME: string;
+    interface Wrapper<T0> {
         name: T0;
     }
+    namespace Wrapper {
+        const TYPE_QNAME = "0x2::dynamic_object_field::Wrapper";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Wrapper<T0>>;
+    }
     interface WrapperInstance extends TypedEventInstance<Wrapper<any>> {
         data_decoded: Wrapper<any>;
         type_arguments: [string];
@@ -242,43 +281,55 @@ export declare class groth16 extends SuiBaseProcessor {
     constructor(options: SuiBindOptions);
     static DEFAULT_OPTIONS: SuiBindOptions;
     static bind(options?: Partial<SuiBindOptions>): groth16;
-    onEventCurve(func: (event: groth16.CurveInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): groth16;
-    onEventPreparedVerifyingKey(func: (event: groth16.PreparedVerifyingKeyInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): groth16;
-    onEventProofPoints(func: (event: groth16.ProofPointsInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): groth16;
-    onEventPublicProofInputs(func: (event: groth16.PublicProofInputsInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): groth16;
+    onEventCurve(func: (event: groth16.CurveInstance, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): groth16;
+    onEventPreparedVerifyingKey(func: (event: groth16.PreparedVerifyingKeyInstance, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): groth16;
+    onEventProofPoints(func: (event: groth16.ProofPointsInstance, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): groth16;
+    onEventPublicProofInputs(func: (event: groth16.PublicProofInputsInstance, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): groth16;
 }
 export declare namespace groth16 {
-    class Curve {
-        static TYPE_QNAME: string;
+    interface Curve {
         id: number;
     }
+    namespace Curve {
+        const TYPE_QNAME = "0x2::groth16::Curve";
+        function type(): TypeDescriptor<Curve>;
+    }
     interface CurveInstance extends TypedEventInstance<Curve> {
         data_decoded: Curve;
         type_arguments: [];
     }
-    class PreparedVerifyingKey {
-        static TYPE_QNAME: string;
+    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[];
     }
+    namespace PreparedVerifyingKey {
+        const TYPE_QNAME = "0x2::groth16::PreparedVerifyingKey";
+        function type(): TypeDescriptor<PreparedVerifyingKey>;
+    }
     interface PreparedVerifyingKeyInstance extends TypedEventInstance<PreparedVerifyingKey> {
         data_decoded: PreparedVerifyingKey;
         type_arguments: [];
     }
-    class ProofPoints {
-        static TYPE_QNAME: string;
+    interface ProofPoints {
         bytes: number[];
     }
+    namespace ProofPoints {
+        const TYPE_QNAME = "0x2::groth16::ProofPoints";
+        function type(): TypeDescriptor<ProofPoints>;
+    }
     interface ProofPointsInstance extends TypedEventInstance<ProofPoints> {
         data_decoded: ProofPoints;
         type_arguments: [];
     }
-    class PublicProofInputs {
-        static TYPE_QNAME: string;
+    interface PublicProofInputs {
         bytes: number[];
     }
+    namespace PublicProofInputs {
+        const TYPE_QNAME = "0x2::groth16::PublicProofInputs";
+        function type(): TypeDescriptor<PublicProofInputs>;
+    }
     interface PublicProofInputsInstance extends TypedEventInstance<PublicProofInputs> {
         data_decoded: PublicProofInputs;
         type_arguments: [];
@@ -291,104 +342,140 @@ export declare class kiosk extends SuiBaseProcessor {
     constructor(options: SuiBindOptions);
     static DEFAULT_OPTIONS: SuiBindOptions;
     static bind(options?: Partial<SuiBindOptions>): kiosk;
-    onEventItem(func: (event: kiosk.ItemInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): kiosk;
-    onEventItemListed(func: (event: kiosk.ItemListedInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): kiosk;
-    onEventListing(func: (event: kiosk.ListingInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): kiosk;
-    onEventLock(func: (event: kiosk.LockInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): kiosk;
+    onEventItem(func: (event: kiosk.ItemInstance, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): kiosk;
+    onEventItemListed(func: (event: kiosk.ItemListedInstance, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): kiosk;
+    onEventListing(func: (event: kiosk.ListingInstance, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): kiosk;
+    onEventLock(func: (event: kiosk.LockInstance, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): kiosk;
 }
 export declare namespace kiosk {
-    class Item {
-        static TYPE_QNAME: string;
+    interface Item {
         id: object_.ID;
     }
+    namespace Item {
+        const TYPE_QNAME = "0x2::kiosk::Item";
+        function type(): TypeDescriptor<Item>;
+    }
     interface ItemInstance extends TypedEventInstance<Item> {
         data_decoded: Item;
         type_arguments: [];
     }
-    class ItemListed<T0> {
-        static TYPE_QNAME: string;
+    interface ItemListed<T0> {
         kiosk: object_.ID;
         id: object_.ID;
         price: bigint;
     }
+    namespace ItemListed {
+        const TYPE_QNAME = "0x2::kiosk::ItemListed";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<ItemListed<T0>>;
+    }
     interface ItemListedInstance extends TypedEventInstance<ItemListed<any>> {
         data_decoded: ItemListed<any>;
         type_arguments: [string];
     }
-    class Kiosk {
-        static TYPE_QNAME: string;
+    interface Kiosk {
         id: object_.UID;
         profits: balance.Balance<sui.SUI>;
         owner: SuiAddress;
         item_count: number;
         allow_extensions: Boolean;
     }
-    class KioskOwnerCap {
-        static TYPE_QNAME: string;
+    namespace Kiosk {
+        const TYPE_QNAME = "0x2::kiosk::Kiosk";
+        function type(): TypeDescriptor<Kiosk>;
+    }
+    interface KioskOwnerCap {
         id: object_.UID;
         for: object_.ID;
     }
-    class Listing {
-        static TYPE_QNAME: string;
+    namespace KioskOwnerCap {
+        const TYPE_QNAME = "0x2::kiosk::KioskOwnerCap";
+        function type(): TypeDescriptor<KioskOwnerCap>;
+    }
+    interface Listing {
         id: object_.ID;
         is_exclusive: Boolean;
     }
+    namespace Listing {
+        const TYPE_QNAME = "0x2::kiosk::Listing";
+        function type(): TypeDescriptor<Listing>;
+    }
     interface ListingInstance extends TypedEventInstance<Listing> {
         data_decoded: Listing;
         type_arguments: [];
     }
-    class Lock {
-        static TYPE_QNAME: string;
+    interface Lock {
         id: object_.ID;
     }
+    namespace Lock {
+        const TYPE_QNAME = "0x2::kiosk::Lock";
+        function type(): TypeDescriptor<Lock>;
+    }
     interface LockInstance extends TypedEventInstance<Lock> {
         data_decoded: Lock;
         type_arguments: [];
     }
-    class PurchaseCap<T0> {
-        static TYPE_QNAME: string;
+    interface PurchaseCap<T0> {
         id: object_.UID;
         kiosk_id: object_.ID;
         item_id: object_.ID;
         min_price: bigint;
     }
+    namespace PurchaseCap {
+        const TYPE_QNAME = "0x2::kiosk::PurchaseCap";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<PurchaseCap<T0>>;
+    }
 }
 export declare namespace linked_table {
-    class LinkedTable<T0, T1> {
-        static TYPE_QNAME: string;
+    interface LinkedTable<T0, T1> {
         id: object_.UID;
         size: bigint;
         head: _0x1.option.Option<T0>;
         tail: _0x1.option.Option<T0>;
     }
-    class Node<T0, T1> {
-        static TYPE_QNAME: string;
+    namespace LinkedTable {
+        const TYPE_QNAME = "0x2::linked_table::LinkedTable";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<LinkedTable<T0, T1>>;
+    }
+    interface Node<T0, T1> {
         prev: _0x1.option.Option<T0>;
         next: _0x1.option.Option<T0>;
         value: T1;
     }
+    namespace Node {
+        const TYPE_QNAME = "0x2::linked_table::Node";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Node<T0, T1>>;
+    }
 }
 export declare namespace math { }
 export declare namespace object_ {
     type ID = string;
-    class UID {
-        static TYPE_QNAME: string;
+    interface UID {
         id: object_.ID;
     }
+    namespace UID {
+        const TYPE_QNAME = "0x2::object::UID";
+        function type(): TypeDescriptor<UID>;
+    }
 }
 export declare namespace object_bag {
-    class ObjectBag {
-        static TYPE_QNAME: string;
+    interface ObjectBag {
         id: object_.UID;
         size: bigint;
     }
+    namespace ObjectBag {
+        const TYPE_QNAME = "0x2::object_bag::ObjectBag";
+        function type(): TypeDescriptor<ObjectBag>;
+    }
 }
 export declare namespace object_table {
-    class ObjectTable<T0, T1> {
-        static TYPE_QNAME: string;
+    interface ObjectTable<T0, T1> {
         id: object_.UID;
         size: bigint;
     }
+    namespace ObjectTable {
+        const TYPE_QNAME = "0x2::object_table::ObjectTable";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<ObjectTable<T0, T1>>;
+    }
 }
 export declare class package_ extends SuiBaseProcessor {
     constructor(options: SuiBindOptions);
@@ -399,31 +486,43 @@ export declare class package_ extends SuiBaseProcessor {
     onEntryOnlyDepUpgrades(func: (call: package_.OnlyDepUpgradesPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): package_;
 }
 export declare namespace package_ {
-    class Publisher {
-        static TYPE_QNAME: string;
+    interface Publisher {
         id: object_.UID;
         package: _0x1.ascii.String;
         module_name: _0x1.ascii.String;
     }
-    class UpgradeCap {
-        static TYPE_QNAME: string;
+    namespace Publisher {
+        const TYPE_QNAME = "0x2::package::Publisher";
+        function type(): TypeDescriptor<Publisher>;
+    }
+    interface UpgradeCap {
         id: object_.UID;
         package: object_.ID;
         version: bigint;
         policy: number;
     }
-    class UpgradeReceipt {
-        static TYPE_QNAME: string;
+    namespace UpgradeCap {
+        const TYPE_QNAME = "0x2::package::UpgradeCap";
+        function type(): TypeDescriptor<UpgradeCap>;
+    }
+    interface UpgradeReceipt {
         cap: object_.ID;
         package: object_.ID;
     }
-    class UpgradeTicket {
-        static TYPE_QNAME: string;
+    namespace UpgradeReceipt {
+        const TYPE_QNAME = "0x2::package::UpgradeReceipt";
+        function type(): TypeDescriptor<UpgradeReceipt>;
+    }
+    interface UpgradeTicket {
         cap: object_.ID;
         package: object_.ID;
         policy: number;
         digest: number[];
     }
+    namespace UpgradeTicket {
+        const TYPE_QNAME = "0x2::package::UpgradeTicket";
+        function type(): TypeDescriptor<UpgradeTicket>;
+    }
     interface MakeImmutablePayload extends TypedFunctionPayload<[]> {
         arguments_decoded: [];
         type_arguments: [];
@@ -491,15 +590,21 @@ export declare namespace pay {
     }
 }
 export declare namespace priority_queue {
-    class Entry<T0> {
-        static TYPE_QNAME: string;
+    interface Entry<T0> {
         priority: bigint;
         value: T0;
     }
-    class PriorityQueue<T0> {
-        static TYPE_QNAME: string;
+    namespace Entry {
+        const TYPE_QNAME = "0x2::priority_queue::Entry";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<Entry<T0>>;
+    }
+    interface PriorityQueue<T0> {
         entries: priority_queue.Entry<T0>[];
     }
+    namespace PriorityQueue {
+        const TYPE_QNAME = "0x2::priority_queue::PriorityQueue";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<PriorityQueue<T0>>;
+    }
 }
 export declare namespace prover { }
 export declare class sui extends SuiBaseProcessor {
@@ -509,94 +614,124 @@ export declare class sui extends SuiBaseProcessor {
     onEntryTransfer(func: (call: sui.TransferPayload, ctx: SuiContext) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): sui;
 }
 export declare namespace sui {
-    class SUI {
-        static TYPE_QNAME: string;
+    interface SUI {
         dummy_field: Boolean;
     }
+    namespace SUI {
+        const TYPE_QNAME = "0x2::sui::SUI";
+        function type(): TypeDescriptor<SUI>;
+    }
     interface TransferPayload extends TypedFunctionPayload<[coin.Coin<sui.SUI> | undefined]> {
         arguments_decoded: [coin.Coin<sui.SUI> | undefined];
         type_arguments: [];
     }
 }
 export declare namespace table {
-    class Table<T0, T1> {
-        static TYPE_QNAME: string;
+    interface Table<T0, T1> {
         id: object_.UID;
         size: bigint;
     }
+    namespace Table {
+        const TYPE_QNAME = "0x2::table::Table";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Table<T0, T1>>;
+    }
 }
 export declare namespace table_vec {
-    class TableVec<T0> {
-        static TYPE_QNAME: string;
+    interface TableVec<T0> {
         contents: table.Table<bigint, T0>;
     }
+    namespace TableVec {
+        const TYPE_QNAME = "0x2::table_vec::TableVec";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<TableVec<T0>>;
+    }
 }
 export declare namespace transfer { }
 export declare class transfer_policy extends SuiBaseProcessor {
     constructor(options: SuiBindOptions);
     static DEFAULT_OPTIONS: SuiBindOptions;
     static bind(options?: Partial<SuiBindOptions>): transfer_policy;
-    onEventRuleKey(func: (event: transfer_policy.RuleKeyInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): transfer_policy;
-    onEventTransferPolicyCreated(func: (event: transfer_policy.TransferPolicyCreatedInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): transfer_policy;
+    onEventRuleKey(func: (event: transfer_policy.RuleKeyInstance, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): transfer_policy;
+    onEventTransferPolicyCreated(func: (event: transfer_policy.TransferPolicyCreatedInstance, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): transfer_policy;
 }
 export declare namespace transfer_policy {
-    class RuleKey<T0> {
-        static TYPE_QNAME: string;
+    interface RuleKey<T0> {
         dummy_field: Boolean;
     }
+    namespace RuleKey {
+        const TYPE_QNAME = "0x2::transfer_policy::RuleKey";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<RuleKey<T0>>;
+    }
     interface RuleKeyInstance extends TypedEventInstance<RuleKey<any>> {
         data_decoded: RuleKey<any>;
         type_arguments: [string];
     }
-    class TransferPolicy<T0> {
-        static TYPE_QNAME: string;
+    interface TransferPolicy<T0> {
         id: object_.UID;
         balance: balance.Balance<sui.SUI>;
         rules: vec_set.VecSet<_0x1.type_name.TypeName>;
     }
-    class TransferPolicyCap<T0> {
-        static TYPE_QNAME: string;
+    namespace TransferPolicy {
+        const TYPE_QNAME = "0x2::transfer_policy::TransferPolicy";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<TransferPolicy<T0>>;
+    }
+    interface TransferPolicyCap<T0> {
         id: object_.UID;
         policy_id: object_.ID;
     }
-    class TransferPolicyCreated<T0> {
-        static TYPE_QNAME: string;
+    namespace TransferPolicyCap {
+        const TYPE_QNAME = "0x2::transfer_policy::TransferPolicyCap";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<TransferPolicyCap<T0>>;
+    }
+    interface TransferPolicyCreated<T0> {
         id: object_.ID;
     }
+    namespace TransferPolicyCreated {
+        const TYPE_QNAME = "0x2::transfer_policy::TransferPolicyCreated";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<TransferPolicyCreated<T0>>;
+    }
     interface TransferPolicyCreatedInstance extends TypedEventInstance<TransferPolicyCreated<any>> {
         data_decoded: TransferPolicyCreated<any>;
         type_arguments: [string];
     }
-    class TransferRequest<T0> {
-        static TYPE_QNAME: string;
+    interface TransferRequest<T0> {
         item: object_.ID;
         paid: bigint;
         from: object_.ID;
         receipts: vec_set.VecSet<_0x1.type_name.TypeName>;
     }
+    namespace TransferRequest {
+        const TYPE_QNAME = "0x2::transfer_policy::TransferRequest";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<TransferRequest<T0>>;
+    }
 }
 export declare namespace tx_context {
-    class TxContext {
-        static TYPE_QNAME: string;
+    interface TxContext {
         sender: SuiAddress;
         tx_hash: number[];
         epoch: bigint;
         epoch_timestamp_ms: bigint;
         ids_created: bigint;
     }
+    namespace TxContext {
+        const TYPE_QNAME = "0x2::tx_context::TxContext";
+        function type(): TypeDescriptor<TxContext>;
+    }
 }
 export declare namespace types { }
 export declare class url extends SuiBaseProcessor {
     constructor(options: SuiBindOptions);
     static DEFAULT_OPTIONS: SuiBindOptions;
     static bind(options?: Partial<SuiBindOptions>): url;
-    onEventUrl(func: (event: url.UrlInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): url;
+    onEventUrl(func: (event: url.UrlInstance, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): url;
 }
 export declare namespace url {
-    class Url {
-        static TYPE_QNAME: string;
+    interface Url {
         url: _0x1.ascii.String;
     }
+    namespace Url {
+        const TYPE_QNAME = "0x2::url::Url";
+        function type(): TypeDescriptor<Url>;
+    }
     interface UrlInstance extends TypedEventInstance<Url> {
         data_decoded: Url;
         type_arguments: [];
@@ -606,23 +741,29 @@ export declare class vec_map extends SuiBaseProcessor {
     constructor(options: SuiBindOptions);
     static DEFAULT_OPTIONS: SuiBindOptions;
     static bind(options?: Partial<SuiBindOptions>): vec_map;
-    onEventEntry(func: (event: vec_map.EntryInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): vec_map;
-    onEventVecMap(func: (event: vec_map.VecMapInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): vec_map;
+    onEventEntry(func: (event: vec_map.EntryInstance, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vec_map;
+    onEventVecMap(func: (event: vec_map.VecMapInstance, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vec_map;
 }
 export declare namespace vec_map {
-    class Entry<T0, T1> {
-        static TYPE_QNAME: string;
+    interface Entry<T0, T1> {
         key: T0;
         value: T1;
     }
+    namespace Entry {
+        const TYPE_QNAME = "0x2::vec_map::Entry";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<Entry<T0, T1>>;
+    }
     interface EntryInstance extends TypedEventInstance<Entry<any, any>> {
         data_decoded: Entry<any, any>;
         type_arguments: [string, string];
     }
-    class VecMap<T0, T1> {
-        static TYPE_QNAME: string;
+    interface VecMap<T0, T1> {
         contents: vec_map.Entry<T0, T1>[];
     }
+    namespace VecMap {
+        const TYPE_QNAME = "0x2::vec_map::VecMap";
+        function type<T0, T1>(arg0?: TypeDescriptor<T0>, arg1?: TypeDescriptor<T1>): TypeDescriptor<VecMap<T0, T1>>;
+    }
     interface VecMapInstance extends TypedEventInstance<VecMap<any, any>> {
         data_decoded: VecMap<any, any>;
         type_arguments: [string, string];
@@ -632,28 +773,37 @@ export declare class vec_set extends SuiBaseProcessor {
     constructor(options: SuiBindOptions);
     static DEFAULT_OPTIONS: SuiBindOptions;
     static bind(options?: Partial<SuiBindOptions>): vec_set;
-    onEventVecSet(func: (event: vec_set.VecSetInstance, ctx: SuiContext) => void, fetchConfig?: MoveFetchConfig): vec_set;
+    onEventVecSet(func: (event: vec_set.VecSetInstance, ctx: SuiContext) => void, fetchConfig?: Partial<MoveFetchConfig>): vec_set;
 }
 export declare namespace vec_set {
-    class VecSet<T0> {
-        static TYPE_QNAME: string;
+    interface VecSet<T0> {
         contents: T0[] | string;
     }
+    namespace VecSet {
+        const TYPE_QNAME = "0x2::vec_set::VecSet";
+        function type<T0>(arg0?: TypeDescriptor<T0>): TypeDescriptor<VecSet<T0>>;
+    }
     interface VecSetInstance extends TypedEventInstance<VecSet<any>> {
         data_decoded: VecSet<any>;
         type_arguments: [string];
     }
 }
 export declare namespace versioned {
-    class VersionChangeCap {
-        static TYPE_QNAME: string;
+    interface VersionChangeCap {
         versioned_id: object_.ID;
         old_version: bigint;
     }
-    class Versioned {
-        static TYPE_QNAME: string;
+    namespace VersionChangeCap {
+        const TYPE_QNAME = "0x2::versioned::VersionChangeCap";
+        function type(): TypeDescriptor<VersionChangeCap>;
+    }
+    interface Versioned {
         id: object_.UID;
         version: bigint;
     }
+    namespace Versioned {
+        const TYPE_QNAME = "0x2::versioned::Versioned";
+        function type(): TypeDescriptor<Versioned>;
+    }
 }
 export declare function loadAllTypes(coder: MoveCoder): void;