@suilend/sdk 12.7.0 → 13.0.0-next.g803bba0

package/_generated/_dependencies/source/0x1/ascii/structs.d.ts

@@ -1,84 +0,0 @@
-import * as reified from "../../../../_framework/reified";
-import { PhantomReified, Reified, StructClass, ToField, ToTypeStr } from "../../../../_framework/reified";
-import { FieldsWithTypes } from "../../../../_framework/util";
-import { Vector } from "../../../../_framework/vector";
-import { PKG_V13 } from "../index";
-import { SuiGrpcClient } from "@mysten/sui/grpc";
-export declare function isChar(type: string): boolean;
-export interface CharFields {
-    byte: ToField<"u8">;
-}
-export type CharReified = Reified<Char, CharFields>;
-export declare class Char implements StructClass {
-    __StructClass: true;
-    static readonly $typeName = "0x1::ascii::Char";
-    static readonly $numTypeParams = 0;
-    static readonly $isPhantom: readonly [];
-    readonly $typeName = "0x1::ascii::Char";
-    readonly $fullTypeName: `${typeof PKG_V13}::ascii::Char`;
-    readonly $typeArgs: [];
-    readonly $isPhantom: readonly [];
-    readonly byte: ToField<"u8">;
-    private constructor();
-    static reified(): CharReified;
-    static get r(): reified.StructClassReified<Char, CharFields>;
-    static phantom(): PhantomReified<ToTypeStr<Char>>;
-    static get p(): reified.PhantomReified<"0x1::ascii::Char">;
-    static get bcs(): import("@mysten/bcs").BcsStruct<{
-        byte: import("@mysten/bcs").BcsType<number, number, "u8">;
-    }, string>;
-    static fromFields(fields: Record<string, any>): Char;
-    static fromFieldsWithTypes(item: FieldsWithTypes): Char;
-    static fromBcs(data: Uint8Array): Char;
-    toJSONField(): {
-        byte: number;
-    };
-    toJSON(): {
-        byte: number;
-        $typeName: string;
-        $typeArgs: [];
-    };
-    static fromJSONField(field: any): Char;
-    static fromJSON(json: Record<string, any>): Char;
-    static fetch(client: SuiGrpcClient, id: string): Promise<Char>;
-}
-export declare function isString(type: string): boolean;
-export interface StringFields {
-    bytes: ToField<Vector<"u8">>;
-}
-export type StringReified = Reified<String, StringFields>;
-export declare class String implements StructClass {
-    __StructClass: true;
-    static readonly $typeName = "0x1::ascii::String";
-    static readonly $numTypeParams = 0;
-    static readonly $isPhantom: readonly [];
-    readonly $typeName = "0x1::ascii::String";
-    readonly $fullTypeName: `${typeof PKG_V13}::ascii::String`;
-    readonly $typeArgs: [];
-    readonly $isPhantom: readonly [];
-    readonly bytes: ToField<Vector<"u8">>;
-    private constructor();
-    static reified(): StringReified;
-    static get r(): reified.StructClassReified<String, StringFields>;
-    static phantom(): PhantomReified<ToTypeStr<String>>;
-    static get p(): reified.PhantomReified<"0x1::ascii::String">;
-    static get bcs(): import("@mysten/bcs").BcsStruct<{
-        bytes: import("@mysten/bcs").BcsType<number[], Iterable<number> & {
-            length: number;
-        }, string>;
-    }, string>;
-    static fromFields(fields: Record<string, any>): String;
-    static fromFieldsWithTypes(item: FieldsWithTypes): String;
-    static fromBcs(data: Uint8Array): String;
-    toJSONField(): {
-        bytes: number[];
-    };
-    toJSON(): {
-        bytes: number[];
-        $typeName: string;
-        $typeArgs: [];
-    };
-    static fromJSONField(field: any): String;
-    static fromJSON(json: Record<string, any>): String;
-    static fetch(client: SuiGrpcClient, id: string): Promise<String>;
-}

package/_generated/_dependencies/source/0x1/index.d.ts

@@ -1,3 +0,0 @@
-export declare const PACKAGE_ID = "0x1";
-export declare const PUBLISHED_AT = "0x1";
-export declare const PKG_V13 = "0x1";

package/_generated/_dependencies/source/0x1/index.js

@@ -1,3 +0,0 @@
-export const PACKAGE_ID = "0x1";
-export const PUBLISHED_AT = "0x1";
-export const PKG_V13 = "0x1";

package/_generated/_dependencies/source/0x1/option/structs.js

@@ -1,110 +0,0 @@
-import * as reified from "../../../../_framework/reified.js";
-import { assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, fieldToJSON, phantom, toBcs, } from "../../../../_framework/reified.js";
-import { composeSuiType, compressSuiType, } from "../../../../_framework/util.js";
-import { PKG_V13 } from "../index.js";
-import { bcs } from "@mysten/sui/bcs";
-/* ============================== Option =============================== */
-export function isOption(type) {
-    type = compressSuiType(type);
-    return type.startsWith(`${PKG_V13}::option::Option` + "<");
-}
-export class Option {
-    __StructClass = true;
-    static $typeName = `${PKG_V13}::option::Option`;
-    static $numTypeParams = 1;
-    static $isPhantom = [false];
-    __inner = null; // for type checking in reified.ts
-    $typeName = Option.$typeName;
-    $fullTypeName;
-    $typeArgs;
-    $isPhantom = Option.$isPhantom;
-    vec;
-    constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(Option.$typeName, ...typeArgs);
-        this.$typeArgs = typeArgs;
-        this.vec = fields.vec;
-    }
-    static reified(Element) {
-        return {
-            typeName: Option.$typeName,
-            fullTypeName: composeSuiType(Option.$typeName, ...[extractType(Element)]),
-            typeArgs: [extractType(Element)],
-            isPhantom: Option.$isPhantom,
-            reifiedTypeArgs: [Element],
-            fromFields: (fields) => Option.fromFields(Element, fields),
-            fromFieldsWithTypes: (item) => Option.fromFieldsWithTypes(Element, item),
-            fromBcs: (data) => Option.fromBcs(Element, data),
-            bcs: Option.bcs(toBcs(Element)),
-            fromJSONField: (field) => Option.fromJSONField(Element, field),
-            fromJSON: (json) => Option.fromJSON(Element, json),
-            fetch: async (client, id) => Option.fetch(client, Element, id),
-            new: (fields) => {
-                return new Option([extractType(Element)], fields);
-            },
-            kind: "StructClassReified",
-        };
-    }
-    static get r() {
-        return Option.reified;
-    }
-    static phantom(Element) {
-        return phantom(Option.reified(Element));
-    }
-    static get p() {
-        return Option.phantom;
-    }
-    static get bcs() {
-        return (Element) => bcs.struct(`Option<${Element.name}>`, {
-            vec: bcs.vector(Element),
-        });
-    }
-    static fromFields(typeArg, fields) {
-        return Option.reified(typeArg).new({
-            vec: decodeFromFields(reified.vector(typeArg), fields.vec),
-        });
-    }
-    static fromFieldsWithTypes(typeArg, item) {
-        if (!isOption(item.type)) {
-            throw new Error("not a Option type");
-        }
-        assertFieldsWithTypesArgsMatch(item, [typeArg]);
-        return Option.reified(typeArg).new({
-            vec: decodeFromFieldsWithTypes(reified.vector(typeArg), item.fields.vec),
-        });
-    }
-    static fromBcs(typeArg, data) {
-        const typeArgs = [typeArg];
-        return Option.fromFields(typeArg, Option.bcs(toBcs(typeArgs[0])).parse(data));
-    }
-    toJSONField() {
-        return {
-            vec: fieldToJSON(`vector<${this.$typeArgs[0]}>`, this.vec),
-        };
-    }
-    toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
-    }
-    static fromJSONField(typeArg, field) {
-        return Option.reified(typeArg).new({
-            vec: decodeFromJSONField(reified.vector(typeArg), field.vec),
-        });
-    }
-    static fromJSON(typeArg, json) {
-        if (json.$typeName !== Option.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
-        }
-        assertReifiedTypeArgsMatch(composeSuiType(Option.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg]);
-        return Option.fromJSONField(typeArg, json);
-    }
-    static async fetch(client, typeArg, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isOption(object.type)) {
-            throw new Error(`object at id ${id} is not a Option object`);
-        }
-        return Option.fromBcs(typeArg, object.content);
-    }
-}

package/_generated/_dependencies/source/0x1/type-name/structs.d.ts

@@ -1,47 +0,0 @@
-import { PhantomReified, Reified, StructClass, ToField, ToTypeStr } from "../../../../_framework/reified";
-import { FieldsWithTypes } from "../../../../_framework/util";
-import { String } from "../ascii/structs";
-import { PKG_V13 } from "../index";
-import { SuiGrpcClient } from "@mysten/sui/grpc";
-export declare function isTypeName(type: string): boolean;
-export interface TypeNameFields {
-    name: ToField<String>;
-}
-export type TypeNameReified = Reified<TypeName, TypeNameFields>;
-export declare class TypeName implements StructClass {
-    __StructClass: true;
-    static readonly $typeName = "0x1::type_name::TypeName";
-    static readonly $numTypeParams = 0;
-    static readonly $isPhantom: readonly [];
-    readonly $typeName = "0x1::type_name::TypeName";
-    readonly $fullTypeName: `${typeof PKG_V13}::type_name::TypeName`;
-    readonly $typeArgs: [];
-    readonly $isPhantom: readonly [];
-    readonly name: ToField<String>;
-    private constructor();
-    static reified(): TypeNameReified;
-    static get r(): import("../../../../_framework/reified").StructClassReified<TypeName, TypeNameFields>;
-    static phantom(): PhantomReified<ToTypeStr<TypeName>>;
-    static get p(): PhantomReified<"0x1::type_name::TypeName">;
-    static get bcs(): import("@mysten/bcs").BcsStruct<{
-        name: import("@mysten/bcs").BcsStruct<{
-            bytes: import("@mysten/bcs").BcsType<number[], Iterable<number> & {
-                length: number;
-            }, string>;
-        }, string>;
-    }, string>;
-    static fromFields(fields: Record<string, any>): TypeName;
-    static fromFieldsWithTypes(item: FieldsWithTypes): TypeName;
-    static fromBcs(data: Uint8Array): TypeName;
-    toJSONField(): {
-        name: string;
-    };
-    toJSON(): {
-        name: string;
-        $typeName: string;
-        $typeArgs: [];
-    };
-    static fromJSONField(field: any): TypeName;
-    static fromJSON(json: Record<string, any>): TypeName;
-    static fetch(client: SuiGrpcClient, id: string): Promise<TypeName>;
-}

package/_generated/_dependencies/source/0x2/bag/structs.d.ts

@@ -1,52 +0,0 @@
-import { PhantomReified, Reified, StructClass, ToField, ToTypeStr } from "../../../../_framework/reified";
-import { FieldsWithTypes } from "../../../../_framework/util";
-import { PKG_V30 } from "../index";
-import { UID } from "../object/structs";
-import { SuiGrpcClient } from "@mysten/sui/grpc";
-export declare function isBag(type: string): boolean;
-export interface BagFields {
-    id: ToField<UID>;
-    size: ToField<"u64">;
-}
-export type BagReified = Reified<Bag, BagFields>;
-export declare class Bag implements StructClass {
-    __StructClass: true;
-    static readonly $typeName = "0x2::bag::Bag";
-    static readonly $numTypeParams = 0;
-    static readonly $isPhantom: readonly [];
-    readonly $typeName = "0x2::bag::Bag";
-    readonly $fullTypeName: `${typeof PKG_V30}::bag::Bag`;
-    readonly $typeArgs: [];
-    readonly $isPhantom: readonly [];
-    readonly id: ToField<UID>;
-    readonly size: ToField<"u64">;
-    private constructor();
-    static reified(): BagReified;
-    static get r(): import("../../../../_framework/reified").StructClassReified<Bag, BagFields>;
-    static phantom(): PhantomReified<ToTypeStr<Bag>>;
-    static get p(): PhantomReified<"0x2::bag::Bag">;
-    static get bcs(): import("@mysten/bcs").BcsStruct<{
-        id: import("@mysten/bcs").BcsStruct<{
-            id: import("@mysten/bcs").BcsStruct<{
-                bytes: import("@mysten/bcs").BcsType<string, string, string>;
-            }, string>;
-        }, string>;
-        size: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
-    }, string>;
-    static fromFields(fields: Record<string, any>): Bag;
-    static fromFieldsWithTypes(item: FieldsWithTypes): Bag;
-    static fromBcs(data: Uint8Array): Bag;
-    toJSONField(): {
-        id: string;
-        size: string;
-    };
-    toJSON(): {
-        id: string;
-        size: string;
-        $typeName: string;
-        $typeArgs: [];
-    };
-    static fromJSONField(field: any): Bag;
-    static fromJSON(json: Record<string, any>): Bag;
-    static fetch(client: SuiGrpcClient, id: string): Promise<Bag>;
-}

package/_generated/_dependencies/source/0x2/bag/structs.js

@@ -1,113 +0,0 @@
-import { decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, phantom, } from "../../../../_framework/reified.js";
-import { composeSuiType, compressSuiType, } from "../../../../_framework/util.js";
-import { PKG_V30 } from "../index.js";
-import { UID } from "../object/structs.js";
-import { bcs } from "@mysten/sui/bcs";
-/* ============================== Bag =============================== */
-export function isBag(type) {
-    type = compressSuiType(type);
-    return type === `${PKG_V30}::bag::Bag`;
-}
-export class Bag {
-    __StructClass = true;
-    static $typeName = `${PKG_V30}::bag::Bag`;
-    static $numTypeParams = 0;
-    static $isPhantom = [];
-    $typeName = Bag.$typeName;
-    $fullTypeName;
-    $typeArgs;
-    $isPhantom = Bag.$isPhantom;
-    id;
-    size;
-    constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(Bag.$typeName, ...typeArgs);
-        this.$typeArgs = typeArgs;
-        this.id = fields.id;
-        this.size = fields.size;
-    }
-    static reified() {
-        return {
-            typeName: Bag.$typeName,
-            fullTypeName: composeSuiType(Bag.$typeName, ...[]),
-            typeArgs: [],
-            isPhantom: Bag.$isPhantom,
-            reifiedTypeArgs: [],
-            fromFields: (fields) => Bag.fromFields(fields),
-            fromFieldsWithTypes: (item) => Bag.fromFieldsWithTypes(item),
-            fromBcs: (data) => Bag.fromBcs(data),
-            bcs: Bag.bcs,
-            fromJSONField: (field) => Bag.fromJSONField(field),
-            fromJSON: (json) => Bag.fromJSON(json),
-            fetch: async (client, id) => Bag.fetch(client, id),
-            new: (fields) => {
-                return new Bag([], fields);
-            },
-            kind: "StructClassReified",
-        };
-    }
-    static get r() {
-        return Bag.reified();
-    }
-    static phantom() {
-        return phantom(Bag.reified());
-    }
-    static get p() {
-        return Bag.phantom();
-    }
-    static get bcs() {
-        return bcs.struct("Bag", {
-            id: UID.bcs,
-            size: bcs.u64(),
-        });
-    }
-    static fromFields(fields) {
-        return Bag.reified().new({
-            id: decodeFromFields(UID.reified(), fields.id),
-            size: decodeFromFields("u64", fields.size),
-        });
-    }
-    static fromFieldsWithTypes(item) {
-        if (!isBag(item.type)) {
-            throw new Error("not a Bag type");
-        }
-        return Bag.reified().new({
-            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
-            size: decodeFromFieldsWithTypes("u64", item.fields.size),
-        });
-    }
-    static fromBcs(data) {
-        return Bag.fromFields(Bag.bcs.parse(data));
-    }
-    toJSONField() {
-        return {
-            id: this.id,
-            size: this.size.toString(),
-        };
-    }
-    toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
-    }
-    static fromJSONField(field) {
-        return Bag.reified().new({
-            id: decodeFromJSONField(UID.reified(), field.id),
-            size: decodeFromJSONField("u64", field.size),
-        });
-    }
-    static fromJSON(json) {
-        if (json.$typeName !== Bag.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
-        }
-        return Bag.fromJSONField(json);
-    }
-    static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isBag(object.type)) {
-            throw new Error(`object at id ${id} is not a Bag object`);
-        }
-        return Bag.fromBcs(object.content);
-    }
-}

package/_generated/_dependencies/source/0x2/balance/structs.js

@@ -1,210 +0,0 @@
-import { assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, phantom, } from "../../../../_framework/reified.js";
-import { composeSuiType, compressSuiType, } from "../../../../_framework/util.js";
-import { PKG_V30 } from "../index.js";
-import { bcs } from "@mysten/sui/bcs";
-/* ============================== Balance =============================== */
-export function isBalance(type) {
-    type = compressSuiType(type);
-    return type.startsWith(`${PKG_V30}::balance::Balance` + "<");
-}
-export class Balance {
-    __StructClass = true;
-    static $typeName = `${PKG_V30}::balance::Balance`;
-    static $numTypeParams = 1;
-    static $isPhantom = [true];
-    $typeName = Balance.$typeName;
-    $fullTypeName;
-    $typeArgs;
-    $isPhantom = Balance.$isPhantom;
-    value;
-    constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(Balance.$typeName, ...typeArgs);
-        this.$typeArgs = typeArgs;
-        this.value = fields.value;
-    }
-    static reified(T) {
-        return {
-            typeName: Balance.$typeName,
-            fullTypeName: composeSuiType(Balance.$typeName, ...[extractType(T)]),
-            typeArgs: [extractType(T)],
-            isPhantom: Balance.$isPhantom,
-            reifiedTypeArgs: [T],
-            fromFields: (fields) => Balance.fromFields(T, fields),
-            fromFieldsWithTypes: (item) => Balance.fromFieldsWithTypes(T, item),
-            fromBcs: (data) => Balance.fromBcs(T, data),
-            bcs: Balance.bcs,
-            fromJSONField: (field) => Balance.fromJSONField(T, field),
-            fromJSON: (json) => Balance.fromJSON(T, json),
-            fetch: async (client, id) => Balance.fetch(client, T, id),
-            new: (fields) => {
-                return new Balance([extractType(T)], fields);
-            },
-            kind: "StructClassReified",
-        };
-    }
-    static get r() {
-        return Balance.reified;
-    }
-    static phantom(T) {
-        return phantom(Balance.reified(T));
-    }
-    static get p() {
-        return Balance.phantom;
-    }
-    static get bcs() {
-        return bcs.struct("Balance", {
-            value: bcs.u64(),
-        });
-    }
-    static fromFields(typeArg, fields) {
-        return Balance.reified(typeArg).new({
-            value: decodeFromFields("u64", fields.value),
-        });
-    }
-    static fromFieldsWithTypes(typeArg, item) {
-        if (!isBalance(item.type)) {
-            throw new Error("not a Balance type");
-        }
-        assertFieldsWithTypesArgsMatch(item, [typeArg]);
-        return Balance.reified(typeArg).new({
-            value: decodeFromFieldsWithTypes("u64", item.fields.value),
-        });
-    }
-    static fromBcs(typeArg, data) {
-        return Balance.fromFields(typeArg, Balance.bcs.parse(data));
-    }
-    toJSONField() {
-        return {
-            value: this.value.toString(),
-        };
-    }
-    toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
-    }
-    static fromJSONField(typeArg, field) {
-        return Balance.reified(typeArg).new({
-            value: decodeFromJSONField("u64", field.value),
-        });
-    }
-    static fromJSON(typeArg, json) {
-        if (json.$typeName !== Balance.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
-        }
-        assertReifiedTypeArgsMatch(composeSuiType(Balance.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg]);
-        return Balance.fromJSONField(typeArg, json);
-    }
-    static async fetch(client, typeArg, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isBalance(object.type)) {
-            throw new Error(`object at id ${id} is not a Balance object`);
-        }
-        return Balance.fromBcs(typeArg, object.content);
-    }
-}
-/* ============================== Supply =============================== */
-export function isSupply(type) {
-    type = compressSuiType(type);
-    return type.startsWith(`${PKG_V30}::balance::Supply` + "<");
-}
-export class Supply {
-    __StructClass = true;
-    static $typeName = `${PKG_V30}::balance::Supply`;
-    static $numTypeParams = 1;
-    static $isPhantom = [true];
-    $typeName = Supply.$typeName;
-    $fullTypeName;
-    $typeArgs;
-    $isPhantom = Supply.$isPhantom;
-    value;
-    constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(Supply.$typeName, ...typeArgs);
-        this.$typeArgs = typeArgs;
-        this.value = fields.value;
-    }
-    static reified(T) {
-        return {
-            typeName: Supply.$typeName,
-            fullTypeName: composeSuiType(Supply.$typeName, ...[extractType(T)]),
-            typeArgs: [extractType(T)],
-            isPhantom: Supply.$isPhantom,
-            reifiedTypeArgs: [T],
-            fromFields: (fields) => Supply.fromFields(T, fields),
-            fromFieldsWithTypes: (item) => Supply.fromFieldsWithTypes(T, item),
-            fromBcs: (data) => Supply.fromBcs(T, data),
-            bcs: Supply.bcs,
-            fromJSONField: (field) => Supply.fromJSONField(T, field),
-            fromJSON: (json) => Supply.fromJSON(T, json),
-            fetch: async (client, id) => Supply.fetch(client, T, id),
-            new: (fields) => {
-                return new Supply([extractType(T)], fields);
-            },
-            kind: "StructClassReified",
-        };
-    }
-    static get r() {
-        return Supply.reified;
-    }
-    static phantom(T) {
-        return phantom(Supply.reified(T));
-    }
-    static get p() {
-        return Supply.phantom;
-    }
-    static get bcs() {
-        return bcs.struct("Supply", {
-            value: bcs.u64(),
-        });
-    }
-    static fromFields(typeArg, fields) {
-        return Supply.reified(typeArg).new({
-            value: decodeFromFields("u64", fields.value),
-        });
-    }
-    static fromFieldsWithTypes(typeArg, item) {
-        if (!isSupply(item.type)) {
-            throw new Error("not a Supply type");
-        }
-        assertFieldsWithTypesArgsMatch(item, [typeArg]);
-        return Supply.reified(typeArg).new({
-            value: decodeFromFieldsWithTypes("u64", item.fields.value),
-        });
-    }
-    static fromBcs(typeArg, data) {
-        return Supply.fromFields(typeArg, Supply.bcs.parse(data));
-    }
-    toJSONField() {
-        return {
-            value: this.value.toString(),
-        };
-    }
-    toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
-    }
-    static fromJSONField(typeArg, field) {
-        return Supply.reified(typeArg).new({
-            value: decodeFromJSONField("u64", field.value),
-        });
-    }
-    static fromJSON(typeArg, json) {
-        if (json.$typeName !== Supply.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
-        }
-        assertReifiedTypeArgsMatch(composeSuiType(Supply.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg]);
-        return Supply.fromJSONField(typeArg, json);
-    }
-    static async fetch(client, typeArg, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isSupply(object.type)) {
-            throw new Error(`object at id ${id} is not a Supply object`);
-        }
-        return Supply.fromBcs(typeArg, object.content);
-    }
-}

package/_generated/_dependencies/source/0x2/index.d.ts

@@ -1,3 +0,0 @@
-export declare const PACKAGE_ID = "0x2";
-export declare const PUBLISHED_AT = "0x2";
-export declare const PKG_V30 = "0x2";

package/_generated/_dependencies/source/0x2/index.js

@@ -1,3 +0,0 @@
-export const PACKAGE_ID = "0x2";
-export const PUBLISHED_AT = "0x2";
-export const PKG_V30 = "0x2";