@typus/typus-sdk 1.4.3-d → 1.4.3-f

package/src/_dependencies/source/0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828/typus-nft/structs.ts

@@ -0,0 +1,856 @@
+import * as reified from "../../../../_framework/reified";
+import {PhantomReified, Reified, StructClass, ToField, ToTypeStr, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, phantom, ToTypeStr as ToPhantom} from "../../../../_framework/reified";
+import {FieldsWithTypes, composeSuiType, compressSuiType} from "../../../../_framework/util";
+import {String} from "../../0x1/string/structs";
+import {ID, UID} from "../../0x2/object/structs";
+import {TransferPolicyCap} from "../../0x2/transfer-policy/structs";
+import {Url} from "../../0x2/url/structs";
+import {VecMap} from "../../0x2/vec-map/structs";
+import {TableVec} from "../table-vec/structs";
+import {bcs, fromB64, fromHEX, toHEX} from "@mysten/bcs";
+import {SuiClient, SuiParsedData} from "@mysten/sui.js/client";
+
+/* ============================== ManagerCap =============================== */
+
+export function isManagerCap(type: string): boolean { type = compressSuiType(type); return type === "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::ManagerCap"; }
+
+export interface ManagerCapFields { id: ToField<UID> }
+
+export type ManagerCapReified = Reified< ManagerCap, ManagerCapFields >;
+
+export class ManagerCap implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::ManagerCap"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = ManagerCap.$typeName;
+
+ readonly $fullTypeName: "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::ManagerCap";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<UID>
+
+ private constructor(typeArgs: [], fields: ManagerCapFields, ) { this.$fullTypeName = composeSuiType( ManagerCap.$typeName, ...typeArgs ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::ManagerCap"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id; }
+
+ static reified( ): ManagerCapReified { return { typeName: ManagerCap.$typeName, fullTypeName: composeSuiType( ManagerCap.$typeName, ...[] ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::ManagerCap", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => ManagerCap.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => ManagerCap.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => ManagerCap.fromBcs( data, ), bcs: ManagerCap.bcs, fromJSONField: (field: any) => ManagerCap.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => ManagerCap.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => ManagerCap.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => ManagerCap.fetch( client, id, ), new: ( fields: ManagerCapFields, ) => { return new ManagerCap( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return ManagerCap.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<ManagerCap>> { return phantom(ManagerCap.reified( )); } static get p() { return ManagerCap.phantom() }
+
+ static get bcs() { return bcs.struct("ManagerCap", {
+
+ id: UID.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): ManagerCap { return ManagerCap.reified( ).new( { id: decodeFromFields(UID.reified(), fields.id) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): ManagerCap { if (!isManagerCap(item.type)) { throw new Error("not a ManagerCap type");
+
+ }
+
+ return ManagerCap.reified( ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id) } ) }
+
+ static fromBcs( data: Uint8Array ): ManagerCap { return ManagerCap.fromFields( ManagerCap.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): ManagerCap { return ManagerCap.reified( ).new( { id: decodeFromJSONField(UID.reified(), field.id) } ) }
+
+ static fromJSON( json: Record<string, any> ): ManagerCap { if (json.$typeName !== ManagerCap.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return ManagerCap.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): ManagerCap { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isManagerCap(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a ManagerCap object`); } return ManagerCap.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<ManagerCap> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching ManagerCap object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isManagerCap(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a ManagerCap object`); }
+ return ManagerCap.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== MintEvent =============================== */
+
+export function isMintEvent(type: string): boolean { type = compressSuiType(type); return type === "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::MintEvent"; }
+
+export interface MintEventFields { id: ToField<ID>; name: ToField<String>; description: ToField<String>; number: ToField<"u64">; url: ToField<Url>; attributes: ToField<VecMap<String, String>>; sender: ToField<"address"> }
+
+export type MintEventReified = Reified< MintEvent, MintEventFields >;
+
+export class MintEvent implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::MintEvent"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = MintEvent.$typeName;
+
+ readonly $fullTypeName: "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::MintEvent";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<ID>; readonly name: ToField<String>; readonly description: ToField<String>; readonly number: ToField<"u64">; readonly url: ToField<Url>; readonly attributes: ToField<VecMap<String, String>>; readonly sender: ToField<"address">
+
+ private constructor(typeArgs: [], fields: MintEventFields, ) { this.$fullTypeName = composeSuiType( MintEvent.$typeName, ...typeArgs ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::MintEvent"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.name = fields.name;; this.description = fields.description;; this.number = fields.number;; this.url = fields.url;; this.attributes = fields.attributes;; this.sender = fields.sender; }
+
+ static reified( ): MintEventReified { return { typeName: MintEvent.$typeName, fullTypeName: composeSuiType( MintEvent.$typeName, ...[] ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::MintEvent", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => MintEvent.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => MintEvent.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => MintEvent.fromBcs( data, ), bcs: MintEvent.bcs, fromJSONField: (field: any) => MintEvent.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => MintEvent.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => MintEvent.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => MintEvent.fetch( client, id, ), new: ( fields: MintEventFields, ) => { return new MintEvent( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return MintEvent.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<MintEvent>> { return phantom(MintEvent.reified( )); } static get p() { return MintEvent.phantom() }
+
+ static get bcs() { return bcs.struct("MintEvent", {
+
+ id: ID.bcs, name: String.bcs, description: String.bcs, number: bcs.u64(), url: Url.bcs, attributes: VecMap.bcs(String.bcs, String.bcs), sender: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val), })
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): MintEvent { return MintEvent.reified( ).new( { id: decodeFromFields(ID.reified(), fields.id), name: decodeFromFields(String.reified(), fields.name), description: decodeFromFields(String.reified(), fields.description), number: decodeFromFields("u64", fields.number), url: decodeFromFields(Url.reified(), fields.url), attributes: decodeFromFields(VecMap.reified(String.reified(), String.reified()), fields.attributes), sender: decodeFromFields("address", fields.sender) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): MintEvent { if (!isMintEvent(item.type)) { throw new Error("not a MintEvent type");
+
+ }
+
+ return MintEvent.reified( ).new( { id: decodeFromFieldsWithTypes(ID.reified(), item.fields.id), name: decodeFromFieldsWithTypes(String.reified(), item.fields.name), description: decodeFromFieldsWithTypes(String.reified(), item.fields.description), number: decodeFromFieldsWithTypes("u64", item.fields.number), url: decodeFromFieldsWithTypes(Url.reified(), item.fields.url), attributes: decodeFromFieldsWithTypes(VecMap.reified(String.reified(), String.reified()), item.fields.attributes), sender: decodeFromFieldsWithTypes("address", item.fields.sender) } ) }
+
+ static fromBcs( data: Uint8Array ): MintEvent { return MintEvent.fromFields( MintEvent.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,name: this.name,description: this.description,number: this.number.toString(),url: this.url,attributes: this.attributes.toJSONField(),sender: this.sender,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): MintEvent { return MintEvent.reified( ).new( { id: decodeFromJSONField(ID.reified(), field.id), name: decodeFromJSONField(String.reified(), field.name), description: decodeFromJSONField(String.reified(), field.description), number: decodeFromJSONField("u64", field.number), url: decodeFromJSONField(Url.reified(), field.url), attributes: decodeFromJSONField(VecMap.reified(String.reified(), String.reified()), field.attributes), sender: decodeFromJSONField("address", field.sender) } ) }
+
+ static fromJSON( json: Record<string, any> ): MintEvent { if (json.$typeName !== MintEvent.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return MintEvent.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): MintEvent { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isMintEvent(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a MintEvent object`); } return MintEvent.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<MintEvent> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching MintEvent object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isMintEvent(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a MintEvent object`); }
+ return MintEvent.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== ExpUpEvent =============================== */
+
+export function isExpUpEvent(type: string): boolean { type = compressSuiType(type); return type === "0x45d61e41640f8dc1c2e333789b5842adf508ceb9c98d7c1808092f9e2e45b615::typus_nft::ExpUpEvent"; }
+
+export interface ExpUpEventFields { nftId: ToField<ID>; number: ToField<"u64">; expEarn: ToField<"u64"> }
+
+export type ExpUpEventReified = Reified< ExpUpEvent, ExpUpEventFields >;
+
+export class ExpUpEvent implements StructClass { static readonly $typeName = "0x45d61e41640f8dc1c2e333789b5842adf508ceb9c98d7c1808092f9e2e45b615::typus_nft::ExpUpEvent"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = ExpUpEvent.$typeName;
+
+ readonly $fullTypeName: "0x45d61e41640f8dc1c2e333789b5842adf508ceb9c98d7c1808092f9e2e45b615::typus_nft::ExpUpEvent";
+
+ readonly $typeArgs: [];
+
+ readonly nftId: ToField<ID>; readonly number: ToField<"u64">; readonly expEarn: ToField<"u64">
+
+ private constructor(typeArgs: [], fields: ExpUpEventFields, ) { this.$fullTypeName = composeSuiType( ExpUpEvent.$typeName, ...typeArgs ) as "0x45d61e41640f8dc1c2e333789b5842adf508ceb9c98d7c1808092f9e2e45b615::typus_nft::ExpUpEvent"; this.$typeArgs = typeArgs;
+
+ this.nftId = fields.nftId;; this.number = fields.number;; this.expEarn = fields.expEarn; }
+
+ static reified( ): ExpUpEventReified { return { typeName: ExpUpEvent.$typeName, fullTypeName: composeSuiType( ExpUpEvent.$typeName, ...[] ) as "0x45d61e41640f8dc1c2e333789b5842adf508ceb9c98d7c1808092f9e2e45b615::typus_nft::ExpUpEvent", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => ExpUpEvent.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => ExpUpEvent.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => ExpUpEvent.fromBcs( data, ), bcs: ExpUpEvent.bcs, fromJSONField: (field: any) => ExpUpEvent.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => ExpUpEvent.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => ExpUpEvent.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => ExpUpEvent.fetch( client, id, ), new: ( fields: ExpUpEventFields, ) => { return new ExpUpEvent( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return ExpUpEvent.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<ExpUpEvent>> { return phantom(ExpUpEvent.reified( )); } static get p() { return ExpUpEvent.phantom() }
+
+ static get bcs() { return bcs.struct("ExpUpEvent", {
+
+ nft_id: ID.bcs, number: bcs.u64(), exp_earn: bcs.u64()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): ExpUpEvent { return ExpUpEvent.reified( ).new( { nftId: decodeFromFields(ID.reified(), fields.nft_id), number: decodeFromFields("u64", fields.number), expEarn: decodeFromFields("u64", fields.exp_earn) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): ExpUpEvent { if (!isExpUpEvent(item.type)) { throw new Error("not a ExpUpEvent type");
+
+ }
+
+ return ExpUpEvent.reified( ).new( { nftId: decodeFromFieldsWithTypes(ID.reified(), item.fields.nft_id), number: decodeFromFieldsWithTypes("u64", item.fields.number), expEarn: decodeFromFieldsWithTypes("u64", item.fields.exp_earn) } ) }
+
+ static fromBcs( data: Uint8Array ): ExpUpEvent { return ExpUpEvent.fromFields( ExpUpEvent.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ nftId: this.nftId,number: this.number.toString(),expEarn: this.expEarn.toString(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): ExpUpEvent { return ExpUpEvent.reified( ).new( { nftId: decodeFromJSONField(ID.reified(), field.nftId), number: decodeFromJSONField("u64", field.number), expEarn: decodeFromJSONField("u64", field.expEarn) } ) }
+
+ static fromJSON( json: Record<string, any> ): ExpUpEvent { if (json.$typeName !== ExpUpEvent.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return ExpUpEvent.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): ExpUpEvent { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isExpUpEvent(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a ExpUpEvent object`); } return ExpUpEvent.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<ExpUpEvent> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching ExpUpEvent object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isExpUpEvent(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a ExpUpEvent object`); }
+ return ExpUpEvent.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== FirstBidEvent =============================== */
+
+export function isFirstBidEvent(type: string): boolean { type = compressSuiType(type); return type === "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::FirstBidEvent"; }
+
+export interface FirstBidEventFields { nftId: ToField<ID>; number: ToField<"u64">; expEarn: ToField<"u64"> }
+
+export type FirstBidEventReified = Reified< FirstBidEvent, FirstBidEventFields >;
+
+export class FirstBidEvent implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::FirstBidEvent"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = FirstBidEvent.$typeName;
+
+ readonly $fullTypeName: "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::FirstBidEvent";
+
+ readonly $typeArgs: [];
+
+ readonly nftId: ToField<ID>; readonly number: ToField<"u64">; readonly expEarn: ToField<"u64">
+
+ private constructor(typeArgs: [], fields: FirstBidEventFields, ) { this.$fullTypeName = composeSuiType( FirstBidEvent.$typeName, ...typeArgs ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::FirstBidEvent"; this.$typeArgs = typeArgs;
+
+ this.nftId = fields.nftId;; this.number = fields.number;; this.expEarn = fields.expEarn; }
+
+ static reified( ): FirstBidEventReified { return { typeName: FirstBidEvent.$typeName, fullTypeName: composeSuiType( FirstBidEvent.$typeName, ...[] ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::FirstBidEvent", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => FirstBidEvent.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => FirstBidEvent.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => FirstBidEvent.fromBcs( data, ), bcs: FirstBidEvent.bcs, fromJSONField: (field: any) => FirstBidEvent.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => FirstBidEvent.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => FirstBidEvent.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => FirstBidEvent.fetch( client, id, ), new: ( fields: FirstBidEventFields, ) => { return new FirstBidEvent( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return FirstBidEvent.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<FirstBidEvent>> { return phantom(FirstBidEvent.reified( )); } static get p() { return FirstBidEvent.phantom() }
+
+ static get bcs() { return bcs.struct("FirstBidEvent", {
+
+ nft_id: ID.bcs, number: bcs.u64(), exp_earn: bcs.u64()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): FirstBidEvent { return FirstBidEvent.reified( ).new( { nftId: decodeFromFields(ID.reified(), fields.nft_id), number: decodeFromFields("u64", fields.number), expEarn: decodeFromFields("u64", fields.exp_earn) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): FirstBidEvent { if (!isFirstBidEvent(item.type)) { throw new Error("not a FirstBidEvent type");
+
+ }
+
+ return FirstBidEvent.reified( ).new( { nftId: decodeFromFieldsWithTypes(ID.reified(), item.fields.nft_id), number: decodeFromFieldsWithTypes("u64", item.fields.number), expEarn: decodeFromFieldsWithTypes("u64", item.fields.exp_earn) } ) }
+
+ static fromBcs( data: Uint8Array ): FirstBidEvent { return FirstBidEvent.fromFields( FirstBidEvent.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ nftId: this.nftId,number: this.number.toString(),expEarn: this.expEarn.toString(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): FirstBidEvent { return FirstBidEvent.reified( ).new( { nftId: decodeFromJSONField(ID.reified(), field.nftId), number: decodeFromJSONField("u64", field.number), expEarn: decodeFromJSONField("u64", field.expEarn) } ) }
+
+ static fromJSON( json: Record<string, any> ): FirstBidEvent { if (json.$typeName !== FirstBidEvent.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return FirstBidEvent.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): FirstBidEvent { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isFirstBidEvent(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a FirstBidEvent object`); } return FirstBidEvent.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<FirstBidEvent> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching FirstBidEvent object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isFirstBidEvent(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a FirstBidEvent object`); }
+ return FirstBidEvent.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== FirstDepositEvent =============================== */
+
+export function isFirstDepositEvent(type: string): boolean { type = compressSuiType(type); return type === "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::FirstDepositEvent"; }
+
+export interface FirstDepositEventFields { nftId: ToField<ID>; number: ToField<"u64">; expEarn: ToField<"u64"> }
+
+export type FirstDepositEventReified = Reified< FirstDepositEvent, FirstDepositEventFields >;
+
+export class FirstDepositEvent implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::FirstDepositEvent"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = FirstDepositEvent.$typeName;
+
+ readonly $fullTypeName: "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::FirstDepositEvent";
+
+ readonly $typeArgs: [];
+
+ readonly nftId: ToField<ID>; readonly number: ToField<"u64">; readonly expEarn: ToField<"u64">
+
+ private constructor(typeArgs: [], fields: FirstDepositEventFields, ) { this.$fullTypeName = composeSuiType( FirstDepositEvent.$typeName, ...typeArgs ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::FirstDepositEvent"; this.$typeArgs = typeArgs;
+
+ this.nftId = fields.nftId;; this.number = fields.number;; this.expEarn = fields.expEarn; }
+
+ static reified( ): FirstDepositEventReified { return { typeName: FirstDepositEvent.$typeName, fullTypeName: composeSuiType( FirstDepositEvent.$typeName, ...[] ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::FirstDepositEvent", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => FirstDepositEvent.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => FirstDepositEvent.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => FirstDepositEvent.fromBcs( data, ), bcs: FirstDepositEvent.bcs, fromJSONField: (field: any) => FirstDepositEvent.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => FirstDepositEvent.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => FirstDepositEvent.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => FirstDepositEvent.fetch( client, id, ), new: ( fields: FirstDepositEventFields, ) => { return new FirstDepositEvent( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return FirstDepositEvent.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<FirstDepositEvent>> { return phantom(FirstDepositEvent.reified( )); } static get p() { return FirstDepositEvent.phantom() }
+
+ static get bcs() { return bcs.struct("FirstDepositEvent", {
+
+ nft_id: ID.bcs, number: bcs.u64(), exp_earn: bcs.u64()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): FirstDepositEvent { return FirstDepositEvent.reified( ).new( { nftId: decodeFromFields(ID.reified(), fields.nft_id), number: decodeFromFields("u64", fields.number), expEarn: decodeFromFields("u64", fields.exp_earn) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): FirstDepositEvent { if (!isFirstDepositEvent(item.type)) { throw new Error("not a FirstDepositEvent type");
+
+ }
+
+ return FirstDepositEvent.reified( ).new( { nftId: decodeFromFieldsWithTypes(ID.reified(), item.fields.nft_id), number: decodeFromFieldsWithTypes("u64", item.fields.number), expEarn: decodeFromFieldsWithTypes("u64", item.fields.exp_earn) } ) }
+
+ static fromBcs( data: Uint8Array ): FirstDepositEvent { return FirstDepositEvent.fromFields( FirstDepositEvent.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ nftId: this.nftId,number: this.number.toString(),expEarn: this.expEarn.toString(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): FirstDepositEvent { return FirstDepositEvent.reified( ).new( { nftId: decodeFromJSONField(ID.reified(), field.nftId), number: decodeFromJSONField("u64", field.number), expEarn: decodeFromJSONField("u64", field.expEarn) } ) }
+
+ static fromJSON( json: Record<string, any> ): FirstDepositEvent { if (json.$typeName !== FirstDepositEvent.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return FirstDepositEvent.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): FirstDepositEvent { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isFirstDepositEvent(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a FirstDepositEvent object`); } return FirstDepositEvent.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<FirstDepositEvent> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching FirstDepositEvent object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isFirstDepositEvent(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a FirstDepositEvent object`); }
+ return FirstDepositEvent.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== LevelUpEvent =============================== */
+
+export function isLevelUpEvent(type: string): boolean { type = compressSuiType(type); return type === "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::LevelUpEvent"; }
+
+export interface LevelUpEventFields { nftId: ToField<ID>; level: ToField<"u64"> }
+
+export type LevelUpEventReified = Reified< LevelUpEvent, LevelUpEventFields >;
+
+export class LevelUpEvent implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::LevelUpEvent"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = LevelUpEvent.$typeName;
+
+ readonly $fullTypeName: "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::LevelUpEvent";
+
+ readonly $typeArgs: [];
+
+ readonly nftId: ToField<ID>; readonly level: ToField<"u64">
+
+ private constructor(typeArgs: [], fields: LevelUpEventFields, ) { this.$fullTypeName = composeSuiType( LevelUpEvent.$typeName, ...typeArgs ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::LevelUpEvent"; this.$typeArgs = typeArgs;
+
+ this.nftId = fields.nftId;; this.level = fields.level; }
+
+ static reified( ): LevelUpEventReified { return { typeName: LevelUpEvent.$typeName, fullTypeName: composeSuiType( LevelUpEvent.$typeName, ...[] ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::LevelUpEvent", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => LevelUpEvent.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => LevelUpEvent.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => LevelUpEvent.fromBcs( data, ), bcs: LevelUpEvent.bcs, fromJSONField: (field: any) => LevelUpEvent.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => LevelUpEvent.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => LevelUpEvent.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => LevelUpEvent.fetch( client, id, ), new: ( fields: LevelUpEventFields, ) => { return new LevelUpEvent( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return LevelUpEvent.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<LevelUpEvent>> { return phantom(LevelUpEvent.reified( )); } static get p() { return LevelUpEvent.phantom() }
+
+ static get bcs() { return bcs.struct("LevelUpEvent", {
+
+ nft_id: ID.bcs, level: bcs.u64()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): LevelUpEvent { return LevelUpEvent.reified( ).new( { nftId: decodeFromFields(ID.reified(), fields.nft_id), level: decodeFromFields("u64", fields.level) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): LevelUpEvent { if (!isLevelUpEvent(item.type)) { throw new Error("not a LevelUpEvent type");
+
+ }
+
+ return LevelUpEvent.reified( ).new( { nftId: decodeFromFieldsWithTypes(ID.reified(), item.fields.nft_id), level: decodeFromFieldsWithTypes("u64", item.fields.level) } ) }
+
+ static fromBcs( data: Uint8Array ): LevelUpEvent { return LevelUpEvent.fromFields( LevelUpEvent.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ nftId: this.nftId,level: this.level.toString(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): LevelUpEvent { return LevelUpEvent.reified( ).new( { nftId: decodeFromJSONField(ID.reified(), field.nftId), level: decodeFromJSONField("u64", field.level) } ) }
+
+ static fromJSON( json: Record<string, any> ): LevelUpEvent { if (json.$typeName !== LevelUpEvent.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return LevelUpEvent.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): LevelUpEvent { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isLevelUpEvent(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a LevelUpEvent object`); } return LevelUpEvent.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<LevelUpEvent> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching LevelUpEvent object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isLevelUpEvent(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a LevelUpEvent object`); }
+ return LevelUpEvent.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== NewManagerCapEvent =============================== */
+
+export function isNewManagerCapEvent(type: string): boolean { type = compressSuiType(type); return type === "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::NewManagerCapEvent"; }
+
+export interface NewManagerCapEventFields { id: ToField<ID>; sender: ToField<"address"> }
+
+export type NewManagerCapEventReified = Reified< NewManagerCapEvent, NewManagerCapEventFields >;
+
+export class NewManagerCapEvent implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::NewManagerCapEvent"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = NewManagerCapEvent.$typeName;
+
+ readonly $fullTypeName: "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::NewManagerCapEvent";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<ID>; readonly sender: ToField<"address">
+
+ private constructor(typeArgs: [], fields: NewManagerCapEventFields, ) { this.$fullTypeName = composeSuiType( NewManagerCapEvent.$typeName, ...typeArgs ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::NewManagerCapEvent"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.sender = fields.sender; }
+
+ static reified( ): NewManagerCapEventReified { return { typeName: NewManagerCapEvent.$typeName, fullTypeName: composeSuiType( NewManagerCapEvent.$typeName, ...[] ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::NewManagerCapEvent", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => NewManagerCapEvent.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => NewManagerCapEvent.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => NewManagerCapEvent.fromBcs( data, ), bcs: NewManagerCapEvent.bcs, fromJSONField: (field: any) => NewManagerCapEvent.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => NewManagerCapEvent.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => NewManagerCapEvent.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => NewManagerCapEvent.fetch( client, id, ), new: ( fields: NewManagerCapEventFields, ) => { return new NewManagerCapEvent( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return NewManagerCapEvent.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<NewManagerCapEvent>> { return phantom(NewManagerCapEvent.reified( )); } static get p() { return NewManagerCapEvent.phantom() }
+
+ static get bcs() { return bcs.struct("NewManagerCapEvent", {
+
+ id: ID.bcs, sender: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val), })
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): NewManagerCapEvent { return NewManagerCapEvent.reified( ).new( { id: decodeFromFields(ID.reified(), fields.id), sender: decodeFromFields("address", fields.sender) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): NewManagerCapEvent { if (!isNewManagerCapEvent(item.type)) { throw new Error("not a NewManagerCapEvent type");
+
+ }
+
+ return NewManagerCapEvent.reified( ).new( { id: decodeFromFieldsWithTypes(ID.reified(), item.fields.id), sender: decodeFromFieldsWithTypes("address", item.fields.sender) } ) }
+
+ static fromBcs( data: Uint8Array ): NewManagerCapEvent { return NewManagerCapEvent.fromFields( NewManagerCapEvent.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,sender: this.sender,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): NewManagerCapEvent { return NewManagerCapEvent.reified( ).new( { id: decodeFromJSONField(ID.reified(), field.id), sender: decodeFromJSONField("address", field.sender) } ) }
+
+ static fromJSON( json: Record<string, any> ): NewManagerCapEvent { if (json.$typeName !== NewManagerCapEvent.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return NewManagerCapEvent.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): NewManagerCapEvent { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isNewManagerCapEvent(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a NewManagerCapEvent object`); } return NewManagerCapEvent.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<NewManagerCapEvent> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching NewManagerCapEvent object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isNewManagerCapEvent(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a NewManagerCapEvent object`); }
+ return NewManagerCapEvent.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== Pool =============================== */
+
+export function isPool(type: string): boolean { type = compressSuiType(type); return type === "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Pool"; }
+
+export interface PoolFields { id: ToField<UID>; tails: ToField<TableVec<ToPhantom<Tails>>>; num: ToField<"u64">; isLive: ToField<"bool">; startMs: ToField<"u64"> }
+
+export type PoolReified = Reified< Pool, PoolFields >;
+
+export class Pool implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Pool"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = Pool.$typeName;
+
+ readonly $fullTypeName: "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Pool";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<UID>; readonly tails: ToField<TableVec<ToPhantom<Tails>>>; readonly num: ToField<"u64">; readonly isLive: ToField<"bool">; readonly startMs: ToField<"u64">
+
+ private constructor(typeArgs: [], fields: PoolFields, ) { this.$fullTypeName = composeSuiType( Pool.$typeName, ...typeArgs ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Pool"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.tails = fields.tails;; this.num = fields.num;; this.isLive = fields.isLive;; this.startMs = fields.startMs; }
+
+ static reified( ): PoolReified { return { typeName: Pool.$typeName, fullTypeName: composeSuiType( Pool.$typeName, ...[] ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Pool", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Pool.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Pool.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Pool.fromBcs( data, ), bcs: Pool.bcs, fromJSONField: (field: any) => Pool.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Pool.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Pool.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Pool.fetch( client, id, ), new: ( fields: PoolFields, ) => { return new Pool( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Pool.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<Pool>> { return phantom(Pool.reified( )); } static get p() { return Pool.phantom() }
+
+ static get bcs() { return bcs.struct("Pool", {
+
+ id: UID.bcs, tails: TableVec.bcs, num: bcs.u64(), is_live: bcs.bool(), start_ms: bcs.u64()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): Pool { return Pool.reified( ).new( { id: decodeFromFields(UID.reified(), fields.id), tails: decodeFromFields(TableVec.reified(reified.phantom(Tails.reified())), fields.tails), num: decodeFromFields("u64", fields.num), isLive: decodeFromFields("bool", fields.is_live), startMs: decodeFromFields("u64", fields.start_ms) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): Pool { if (!isPool(item.type)) { throw new Error("not a Pool type");
+
+ }
+
+ return Pool.reified( ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id), tails: decodeFromFieldsWithTypes(TableVec.reified(reified.phantom(Tails.reified())), item.fields.tails), num: decodeFromFieldsWithTypes("u64", item.fields.num), isLive: decodeFromFieldsWithTypes("bool", item.fields.is_live), startMs: decodeFromFieldsWithTypes("u64", item.fields.start_ms) } ) }
+
+ static fromBcs( data: Uint8Array ): Pool { return Pool.fromFields( Pool.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,tails: this.tails.toJSONField(),num: this.num.toString(),isLive: this.isLive,startMs: this.startMs.toString(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): Pool { return Pool.reified( ).new( { id: decodeFromJSONField(UID.reified(), field.id), tails: decodeFromJSONField(TableVec.reified(reified.phantom(Tails.reified())), field.tails), num: decodeFromJSONField("u64", field.num), isLive: decodeFromJSONField("bool", field.isLive), startMs: decodeFromJSONField("u64", field.startMs) } ) }
+
+ static fromJSON( json: Record<string, any> ): Pool { if (json.$typeName !== Pool.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return Pool.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): Pool { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isPool(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Pool object`); } return Pool.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<Pool> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Pool object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isPool(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Pool object`); }
+ return Pool.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== Royalty =============================== */
+
+export function isRoyalty(type: string): boolean { type = compressSuiType(type); return type === "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Royalty"; }
+
+export interface RoyaltyFields { id: ToField<UID>; recipients: ToField<VecMap<"address", "u64">>; policyCap: ToField<TransferPolicyCap<ToPhantom<Tails>>> }
+
+export type RoyaltyReified = Reified< Royalty, RoyaltyFields >;
+
+export class Royalty implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Royalty"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = Royalty.$typeName;
+
+ readonly $fullTypeName: "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Royalty";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<UID>; readonly recipients: ToField<VecMap<"address", "u64">>; readonly policyCap: ToField<TransferPolicyCap<ToPhantom<Tails>>>
+
+ private constructor(typeArgs: [], fields: RoyaltyFields, ) { this.$fullTypeName = composeSuiType( Royalty.$typeName, ...typeArgs ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Royalty"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.recipients = fields.recipients;; this.policyCap = fields.policyCap; }
+
+ static reified( ): RoyaltyReified { return { typeName: Royalty.$typeName, fullTypeName: composeSuiType( Royalty.$typeName, ...[] ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Royalty", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Royalty.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Royalty.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Royalty.fromBcs( data, ), bcs: Royalty.bcs, fromJSONField: (field: any) => Royalty.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Royalty.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Royalty.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Royalty.fetch( client, id, ), new: ( fields: RoyaltyFields, ) => { return new Royalty( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Royalty.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<Royalty>> { return phantom(Royalty.reified( )); } static get p() { return Royalty.phantom() }
+
+ static get bcs() { return bcs.struct("Royalty", {
+
+ id: UID.bcs, recipients: VecMap.bcs(bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val), }), bcs.u64()), policy_cap: TransferPolicyCap.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): Royalty { return Royalty.reified( ).new( { id: decodeFromFields(UID.reified(), fields.id), recipients: decodeFromFields(VecMap.reified("address", "u64"), fields.recipients), policyCap: decodeFromFields(TransferPolicyCap.reified(reified.phantom(Tails.reified())), fields.policy_cap) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): Royalty { if (!isRoyalty(item.type)) { throw new Error("not a Royalty type");
+
+ }
+
+ return Royalty.reified( ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id), recipients: decodeFromFieldsWithTypes(VecMap.reified("address", "u64"), item.fields.recipients), policyCap: decodeFromFieldsWithTypes(TransferPolicyCap.reified(reified.phantom(Tails.reified())), item.fields.policy_cap) } ) }
+
+ static fromBcs( data: Uint8Array ): Royalty { return Royalty.fromFields( Royalty.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,recipients: this.recipients.toJSONField(),policyCap: this.policyCap.toJSONField(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): Royalty { return Royalty.reified( ).new( { id: decodeFromJSONField(UID.reified(), field.id), recipients: decodeFromJSONField(VecMap.reified("address", "u64"), field.recipients), policyCap: decodeFromJSONField(TransferPolicyCap.reified(reified.phantom(Tails.reified())), field.policyCap) } ) }
+
+ static fromJSON( json: Record<string, any> ): Royalty { if (json.$typeName !== Royalty.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return Royalty.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): Royalty { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isRoyalty(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Royalty object`); } return Royalty.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<Royalty> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Royalty object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isRoyalty(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Royalty object`); }
+ return Royalty.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== RoyaltyUpdateEvent =============================== */
+
+export function isRoyaltyUpdateEvent(type: string): boolean { type = compressSuiType(type); return type === "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::RoyaltyUpdateEvent"; }
+
+export interface RoyaltyUpdateEventFields { sender: ToField<"address">; recipients: ToField<VecMap<"address", "u64">> }
+
+export type RoyaltyUpdateEventReified = Reified< RoyaltyUpdateEvent, RoyaltyUpdateEventFields >;
+
+export class RoyaltyUpdateEvent implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::RoyaltyUpdateEvent"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = RoyaltyUpdateEvent.$typeName;
+
+ readonly $fullTypeName: "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::RoyaltyUpdateEvent";
+
+ readonly $typeArgs: [];
+
+ readonly sender: ToField<"address">; readonly recipients: ToField<VecMap<"address", "u64">>
+
+ private constructor(typeArgs: [], fields: RoyaltyUpdateEventFields, ) { this.$fullTypeName = composeSuiType( RoyaltyUpdateEvent.$typeName, ...typeArgs ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::RoyaltyUpdateEvent"; this.$typeArgs = typeArgs;
+
+ this.sender = fields.sender;; this.recipients = fields.recipients; }
+
+ static reified( ): RoyaltyUpdateEventReified { return { typeName: RoyaltyUpdateEvent.$typeName, fullTypeName: composeSuiType( RoyaltyUpdateEvent.$typeName, ...[] ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::RoyaltyUpdateEvent", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => RoyaltyUpdateEvent.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => RoyaltyUpdateEvent.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => RoyaltyUpdateEvent.fromBcs( data, ), bcs: RoyaltyUpdateEvent.bcs, fromJSONField: (field: any) => RoyaltyUpdateEvent.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => RoyaltyUpdateEvent.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => RoyaltyUpdateEvent.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => RoyaltyUpdateEvent.fetch( client, id, ), new: ( fields: RoyaltyUpdateEventFields, ) => { return new RoyaltyUpdateEvent( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return RoyaltyUpdateEvent.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<RoyaltyUpdateEvent>> { return phantom(RoyaltyUpdateEvent.reified( )); } static get p() { return RoyaltyUpdateEvent.phantom() }
+
+ static get bcs() { return bcs.struct("RoyaltyUpdateEvent", {
+
+ sender: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val), }), recipients: VecMap.bcs(bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val), }), bcs.u64())
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): RoyaltyUpdateEvent { return RoyaltyUpdateEvent.reified( ).new( { sender: decodeFromFields("address", fields.sender), recipients: decodeFromFields(VecMap.reified("address", "u64"), fields.recipients) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): RoyaltyUpdateEvent { if (!isRoyaltyUpdateEvent(item.type)) { throw new Error("not a RoyaltyUpdateEvent type");
+
+ }
+
+ return RoyaltyUpdateEvent.reified( ).new( { sender: decodeFromFieldsWithTypes("address", item.fields.sender), recipients: decodeFromFieldsWithTypes(VecMap.reified("address", "u64"), item.fields.recipients) } ) }
+
+ static fromBcs( data: Uint8Array ): RoyaltyUpdateEvent { return RoyaltyUpdateEvent.fromFields( RoyaltyUpdateEvent.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ sender: this.sender,recipients: this.recipients.toJSONField(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): RoyaltyUpdateEvent { return RoyaltyUpdateEvent.reified( ).new( { sender: decodeFromJSONField("address", field.sender), recipients: decodeFromJSONField(VecMap.reified("address", "u64"), field.recipients) } ) }
+
+ static fromJSON( json: Record<string, any> ): RoyaltyUpdateEvent { if (json.$typeName !== RoyaltyUpdateEvent.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return RoyaltyUpdateEvent.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): RoyaltyUpdateEvent { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isRoyaltyUpdateEvent(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a RoyaltyUpdateEvent object`); } return RoyaltyUpdateEvent.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<RoyaltyUpdateEvent> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching RoyaltyUpdateEvent object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isRoyaltyUpdateEvent(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a RoyaltyUpdateEvent object`); }
+ return RoyaltyUpdateEvent.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== TYPUS_NFT =============================== */
+
+export function isTYPUS_NFT(type: string): boolean { type = compressSuiType(type); return type === "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::TYPUS_NFT"; }
+
+export interface TYPUS_NFTFields { dummyField: ToField<"bool"> }
+
+export type TYPUS_NFTReified = Reified< TYPUS_NFT, TYPUS_NFTFields >;
+
+export class TYPUS_NFT implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::TYPUS_NFT"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = TYPUS_NFT.$typeName;
+
+ readonly $fullTypeName: "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::TYPUS_NFT";
+
+ readonly $typeArgs: [];
+
+ readonly dummyField: ToField<"bool">
+
+ private constructor(typeArgs: [], fields: TYPUS_NFTFields, ) { this.$fullTypeName = composeSuiType( TYPUS_NFT.$typeName, ...typeArgs ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::TYPUS_NFT"; this.$typeArgs = typeArgs;
+
+ this.dummyField = fields.dummyField; }
+
+ static reified( ): TYPUS_NFTReified { return { typeName: TYPUS_NFT.$typeName, fullTypeName: composeSuiType( TYPUS_NFT.$typeName, ...[] ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::TYPUS_NFT", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => TYPUS_NFT.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => TYPUS_NFT.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => TYPUS_NFT.fromBcs( data, ), bcs: TYPUS_NFT.bcs, fromJSONField: (field: any) => TYPUS_NFT.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => TYPUS_NFT.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => TYPUS_NFT.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => TYPUS_NFT.fetch( client, id, ), new: ( fields: TYPUS_NFTFields, ) => { return new TYPUS_NFT( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return TYPUS_NFT.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<TYPUS_NFT>> { return phantom(TYPUS_NFT.reified( )); } static get p() { return TYPUS_NFT.phantom() }
+
+ static get bcs() { return bcs.struct("TYPUS_NFT", {
+
+ dummy_field: bcs.bool()
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): TYPUS_NFT { return TYPUS_NFT.reified( ).new( { dummyField: decodeFromFields("bool", fields.dummy_field) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): TYPUS_NFT { if (!isTYPUS_NFT(item.type)) { throw new Error("not a TYPUS_NFT type");
+
+ }
+
+ return TYPUS_NFT.reified( ).new( { dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) } ) }
+
+ static fromBcs( data: Uint8Array ): TYPUS_NFT { return TYPUS_NFT.fromFields( TYPUS_NFT.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ dummyField: this.dummyField,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): TYPUS_NFT { return TYPUS_NFT.reified( ).new( { dummyField: decodeFromJSONField("bool", field.dummyField) } ) }
+
+ static fromJSON( json: Record<string, any> ): TYPUS_NFT { if (json.$typeName !== TYPUS_NFT.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return TYPUS_NFT.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): TYPUS_NFT { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isTYPUS_NFT(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a TYPUS_NFT object`); } return TYPUS_NFT.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<TYPUS_NFT> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching TYPUS_NFT object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isTYPUS_NFT(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a TYPUS_NFT object`); }
+ return TYPUS_NFT.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== Tails =============================== */
+
+export function isTails(type: string): boolean { type = compressSuiType(type); return type === "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Tails"; }
+
+export interface TailsFields { id: ToField<UID>; name: ToField<String>; description: ToField<String>; number: ToField<"u64">; url: ToField<Url>; attributes: ToField<VecMap<String, String>>; level: ToField<"u64">; exp: ToField<"u64">; firstBid: ToField<"bool">; firstDeposit: ToField<"bool">; firstDepositNft: ToField<"bool">; u64Padding: ToField<VecMap<String, "u64">> }
+
+export type TailsReified = Reified< Tails, TailsFields >;
+
+export class Tails implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Tails"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = Tails.$typeName;
+
+ readonly $fullTypeName: "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Tails";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<UID>; readonly name: ToField<String>; readonly description: ToField<String>; readonly number: ToField<"u64">; readonly url: ToField<Url>; readonly attributes: ToField<VecMap<String, String>>; readonly level: ToField<"u64">; readonly exp: ToField<"u64">; readonly firstBid: ToField<"bool">; readonly firstDeposit: ToField<"bool">; readonly firstDepositNft: ToField<"bool">; readonly u64Padding: ToField<VecMap<String, "u64">>
+
+ private constructor(typeArgs: [], fields: TailsFields, ) { this.$fullTypeName = composeSuiType( Tails.$typeName, ...typeArgs ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Tails"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.name = fields.name;; this.description = fields.description;; this.number = fields.number;; this.url = fields.url;; this.attributes = fields.attributes;; this.level = fields.level;; this.exp = fields.exp;; this.firstBid = fields.firstBid;; this.firstDeposit = fields.firstDeposit;; this.firstDepositNft = fields.firstDepositNft;; this.u64Padding = fields.u64Padding; }
+
+ static reified( ): TailsReified { return { typeName: Tails.$typeName, fullTypeName: composeSuiType( Tails.$typeName, ...[] ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Tails", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Tails.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Tails.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Tails.fromBcs( data, ), bcs: Tails.bcs, fromJSONField: (field: any) => Tails.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Tails.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Tails.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Tails.fetch( client, id, ), new: ( fields: TailsFields, ) => { return new Tails( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Tails.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<Tails>> { return phantom(Tails.reified( )); } static get p() { return Tails.phantom() }
+
+ static get bcs() { return bcs.struct("Tails", {
+
+ id: UID.bcs, name: String.bcs, description: String.bcs, number: bcs.u64(), url: Url.bcs, attributes: VecMap.bcs(String.bcs, String.bcs), level: bcs.u64(), exp: bcs.u64(), first_bid: bcs.bool(), first_deposit: bcs.bool(), first_deposit_nft: bcs.bool(), u64_padding: VecMap.bcs(String.bcs, bcs.u64())
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): Tails { return Tails.reified( ).new( { id: decodeFromFields(UID.reified(), fields.id), name: decodeFromFields(String.reified(), fields.name), description: decodeFromFields(String.reified(), fields.description), number: decodeFromFields("u64", fields.number), url: decodeFromFields(Url.reified(), fields.url), attributes: decodeFromFields(VecMap.reified(String.reified(), String.reified()), fields.attributes), level: decodeFromFields("u64", fields.level), exp: decodeFromFields("u64", fields.exp), firstBid: decodeFromFields("bool", fields.first_bid), firstDeposit: decodeFromFields("bool", fields.first_deposit), firstDepositNft: decodeFromFields("bool", fields.first_deposit_nft), u64Padding: decodeFromFields(VecMap.reified(String.reified(), "u64"), fields.u64_padding) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): Tails { if (!isTails(item.type)) { throw new Error("not a Tails type");
+
+ }
+
+ return Tails.reified( ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id), name: decodeFromFieldsWithTypes(String.reified(), item.fields.name), description: decodeFromFieldsWithTypes(String.reified(), item.fields.description), number: decodeFromFieldsWithTypes("u64", item.fields.number), url: decodeFromFieldsWithTypes(Url.reified(), item.fields.url), attributes: decodeFromFieldsWithTypes(VecMap.reified(String.reified(), String.reified()), item.fields.attributes), level: decodeFromFieldsWithTypes("u64", item.fields.level), exp: decodeFromFieldsWithTypes("u64", item.fields.exp), firstBid: decodeFromFieldsWithTypes("bool", item.fields.first_bid), firstDeposit: decodeFromFieldsWithTypes("bool", item.fields.first_deposit), firstDepositNft: decodeFromFieldsWithTypes("bool", item.fields.first_deposit_nft), u64Padding: decodeFromFieldsWithTypes(VecMap.reified(String.reified(), "u64"), item.fields.u64_padding) } ) }
+
+ static fromBcs( data: Uint8Array ): Tails { return Tails.fromFields( Tails.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,name: this.name,description: this.description,number: this.number.toString(),url: this.url,attributes: this.attributes.toJSONField(),level: this.level.toString(),exp: this.exp.toString(),firstBid: this.firstBid,firstDeposit: this.firstDeposit,firstDepositNft: this.firstDepositNft,u64Padding: this.u64Padding.toJSONField(),
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): Tails { return Tails.reified( ).new( { id: decodeFromJSONField(UID.reified(), field.id), name: decodeFromJSONField(String.reified(), field.name), description: decodeFromJSONField(String.reified(), field.description), number: decodeFromJSONField("u64", field.number), url: decodeFromJSONField(Url.reified(), field.url), attributes: decodeFromJSONField(VecMap.reified(String.reified(), String.reified()), field.attributes), level: decodeFromJSONField("u64", field.level), exp: decodeFromJSONField("u64", field.exp), firstBid: decodeFromJSONField("bool", field.firstBid), firstDeposit: decodeFromJSONField("bool", field.firstDeposit), firstDepositNft: decodeFromJSONField("bool", field.firstDepositNft), u64Padding: decodeFromJSONField(VecMap.reified(String.reified(), "u64"), field.u64Padding) } ) }
+
+ static fromJSON( json: Record<string, any> ): Tails { if (json.$typeName !== Tails.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return Tails.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): Tails { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isTails(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Tails object`); } return Tails.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<Tails> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Tails object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isTails(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Tails object`); }
+ return Tails.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }
+
+/* ============================== Whitelist =============================== */
+
+export function isWhitelist(type: string): boolean { type = compressSuiType(type); return type === "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Whitelist"; }
+
+export interface WhitelistFields { id: ToField<UID>; for: ToField<ID> }
+
+export type WhitelistReified = Reified< Whitelist, WhitelistFields >;
+
+export class Whitelist implements StructClass { static readonly $typeName = "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Whitelist"; static readonly $numTypeParams = 0;
+
+ readonly $typeName = Whitelist.$typeName;
+
+ readonly $fullTypeName: "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Whitelist";
+
+ readonly $typeArgs: [];
+
+ readonly id: ToField<UID>; readonly for: ToField<ID>
+
+ private constructor(typeArgs: [], fields: WhitelistFields, ) { this.$fullTypeName = composeSuiType( Whitelist.$typeName, ...typeArgs ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Whitelist"; this.$typeArgs = typeArgs;
+
+ this.id = fields.id;; this.for = fields.for; }
+
+ static reified( ): WhitelistReified { return { typeName: Whitelist.$typeName, fullTypeName: composeSuiType( Whitelist.$typeName, ...[] ) as "0x5cfd0819411be98034cba544cbffab192c2c35674a05ff57f4f1c5042875b828::typus_nft::Whitelist", typeArgs: [ ] as [], reifiedTypeArgs: [], fromFields: (fields: Record<string, any>) => Whitelist.fromFields( fields, ), fromFieldsWithTypes: (item: FieldsWithTypes) => Whitelist.fromFieldsWithTypes( item, ), fromBcs: (data: Uint8Array) => Whitelist.fromBcs( data, ), bcs: Whitelist.bcs, fromJSONField: (field: any) => Whitelist.fromJSONField( field, ), fromJSON: (json: Record<string, any>) => Whitelist.fromJSON( json, ), fromSuiParsedData: (content: SuiParsedData) => Whitelist.fromSuiParsedData( content, ), fetch: async (client: SuiClient, id: string) => Whitelist.fetch( client, id, ), new: ( fields: WhitelistFields, ) => { return new Whitelist( [], fields ) }, kind: "StructClassReified", } }
+
+ static get r() { return Whitelist.reified() }
+
+ static phantom( ): PhantomReified<ToTypeStr<Whitelist>> { return phantom(Whitelist.reified( )); } static get p() { return Whitelist.phantom() }
+
+ static get bcs() { return bcs.struct("Whitelist", {
+
+ id: UID.bcs, for: ID.bcs
+
+}) };
+
+ static fromFields( fields: Record<string, any> ): Whitelist { return Whitelist.reified( ).new( { id: decodeFromFields(UID.reified(), fields.id), for: decodeFromFields(ID.reified(), fields.for) } ) }
+
+ static fromFieldsWithTypes( item: FieldsWithTypes ): Whitelist { if (!isWhitelist(item.type)) { throw new Error("not a Whitelist type");
+
+ }
+
+ return Whitelist.reified( ).new( { id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id), for: decodeFromFieldsWithTypes(ID.reified(), item.fields.for) } ) }
+
+ static fromBcs( data: Uint8Array ): Whitelist { return Whitelist.fromFields( Whitelist.bcs.parse(data) ) }
+
+ toJSONField() { return {
+
+ id: this.id,for: this.for,
+
+} }
+
+ toJSON() { return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() } }
+
+ static fromJSONField( field: any ): Whitelist { return Whitelist.reified( ).new( { id: decodeFromJSONField(UID.reified(), field.id), for: decodeFromJSONField(ID.reified(), field.for) } ) }
+
+ static fromJSON( json: Record<string, any> ): Whitelist { if (json.$typeName !== Whitelist.$typeName) { throw new Error("not a WithTwoGenerics json object") };
+
+ return Whitelist.fromJSONField( json, ) }
+
+ static fromSuiParsedData( content: SuiParsedData ): Whitelist { if (content.dataType !== "moveObject") { throw new Error("not an object"); } if (!isWhitelist(content.type)) { throw new Error(`object at ${(content.fields as any).id} is not a Whitelist object`); } return Whitelist.fromFieldsWithTypes( content ); }
+
+ static async fetch( client: SuiClient, id: string ): Promise<Whitelist> { const res = await client.getObject({ id, options: { showBcs: true, }, }); if (res.error) { throw new Error(`error fetching Whitelist object at id ${id}: ${res.error.code}`); } if (res.data?.bcs?.dataType !== "moveObject" || !isWhitelist(res.data.bcs.type)) { throw new Error(`object at id ${id} is not a Whitelist object`); }
+ return Whitelist.fromBcs( fromB64(res.data.bcs.bcsBytes) ); }
+
+ }