@suilend/sdk 1.0.0

package/mainnet/_generated/_framework/reified.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeFromJSONField = exports.fieldToJSON = exports.assertFieldsWithTypesArgsMatch = exports.assertReifiedTypeArgsMatch = exports.decodeFromFieldsWithTypes = exports.decodeFromFields = exports.extractType = exports.toBcs = exports.vector = exports.phantom = exports.Vector = void 0;
+const bcs_1 = require("@mysten/bcs");
+const util_1 = require("./util");
+class Vector {
+    constructor(fullTypeName, vec) {
+        this.kind = "VectorClass";
+        this.$fullTypeName = fullTypeName;
+        this.vec = vec;
+    }
+    toJSONField() {
+        return null;
+    }
+}
+exports.Vector = Vector;
+function phantom(type) {
+    if (typeof type === "string") {
+        return {
+            phantomType: type,
+            kind: "PhantomReified",
+        };
+    }
+    else {
+        return {
+            phantomType: type.fullTypeName,
+            kind: "PhantomReified",
+        };
+    }
+}
+exports.phantom = phantom;
+function vector(T) {
+    const fullTypeName = `vector<${extractType(T)}>`;
+    return {
+        fullTypeName,
+        bcs: bcs_1.bcs.vector(toBcs(T)),
+        fromFieldsWithTypes: (item) => {
+            return new Vector(fullTypeName, item.map((field) => decodeFromFieldsWithTypes(T, field)));
+        },
+        fromFields: (fields) => {
+            return new Vector(fullTypeName, fields.map((field) => decodeFromFields(T, field)));
+        },
+        fromJSONField: (field) => new Vector(fullTypeName, field.map((field) => decodeFromJSONField(T, field))),
+        kind: "VectorClassReified",
+    };
+}
+exports.vector = vector;
+const Address = bcs_1.bcs.bytes(32).transform({
+    input: (val) => (0, bcs_1.fromHEX)(val),
+    output: (val) => (0, bcs_1.toHEX)(val),
+});
+function toBcs(arg) {
+    switch (arg) {
+        case "bool":
+            return bcs_1.bcs.bool();
+        case "u8":
+            return bcs_1.bcs.u8();
+        case "u16":
+            return bcs_1.bcs.u16();
+        case "u32":
+            return bcs_1.bcs.u32();
+        case "u64":
+            return bcs_1.bcs.u64();
+        case "u128":
+            return bcs_1.bcs.u128();
+        case "u256":
+            return bcs_1.bcs.u256();
+        case "address":
+            return Address;
+        default:
+            return arg.bcs;
+    }
+}
+exports.toBcs = toBcs;
+function extractType(reified) {
+    switch (reified) {
+        case "u8":
+        case "u16":
+        case "u32":
+        case "u64":
+        case "u128":
+        case "u256":
+        case "bool":
+        case "address":
+            return reified;
+    }
+    switch (reified.kind) {
+        case "PhantomReified":
+            return reified.phantomType;
+        case "StructClassReified":
+            return reified.fullTypeName;
+        case "VectorClassReified":
+            return reified.fullTypeName;
+    }
+    throw new Error("unreachable");
+}
+exports.extractType = extractType;
+function decodeFromFields(reified, field) {
+    switch (reified) {
+        case "bool":
+        case "u8":
+        case "u16":
+        case "u32":
+            return field;
+        case "u64":
+        case "u128":
+        case "u256":
+            return BigInt(field);
+        case "address":
+            return `0x${field}`;
+    }
+    if (reified.kind === "VectorClassReified") {
+        return reified.fromFields(field).vec;
+    }
+    switch (reified.typeName) {
+        case "0x1::string::String":
+        case "0x1::ascii::String":
+            return new TextDecoder().decode(Uint8Array.from(field.bytes)).toString();
+        case "0x2::url::Url":
+            return new TextDecoder()
+                .decode(Uint8Array.from(field.url.bytes))
+                .toString();
+        case "0x2::object::ID":
+            return `0x${field.bytes}`;
+        case "0x2::object::UID":
+            return `0x${field.id.bytes}`;
+        case "0x1::option::Option": {
+            if (field.vec.length === 0) {
+                return null;
+            }
+            return reified.fromFields(field).vec[0];
+        }
+        default:
+            return reified.fromFields(field);
+    }
+}
+exports.decodeFromFields = decodeFromFields;
+function decodeFromFieldsWithTypes(reified, item) {
+    switch (reified) {
+        case "bool":
+        case "u8":
+        case "u16":
+        case "u32":
+            return item;
+        case "u64":
+        case "u128":
+        case "u256":
+            return BigInt(item);
+        case "address":
+            return item;
+    }
+    if (reified.kind === "VectorClassReified") {
+        return reified.fromFieldsWithTypes(item).vec;
+    }
+    switch (reified.typeName) {
+        case "0x1::string::String":
+        case "0x1::ascii::String":
+        case "0x2::url::Url":
+        case "0x2::object::ID":
+            return item;
+        case "0x2::object::UID":
+            return item.id;
+        case "0x2::balance::Balance":
+            return reified.fromFields({ value: BigInt(item) });
+        case "0x1::option::Option": {
+            if (item === null) {
+                return null;
+            }
+            return decodeFromFieldsWithTypes(reified.reifiedTypeArgs[0], item);
+        }
+        default:
+            return reified.fromFieldsWithTypes(item);
+    }
+}
+exports.decodeFromFieldsWithTypes = decodeFromFieldsWithTypes;
+function assertReifiedTypeArgsMatch(fullType, typeArgs, reifiedTypeArgs) {
+    if (reifiedTypeArgs.length !== typeArgs.length) {
+        throw new Error(`provided item has mismatching number of type argments ${fullType} (expected ${reifiedTypeArgs.length}, got ${typeArgs.length}))`);
+    }
+    for (let i = 0; i < typeArgs.length; i++) {
+        if ((0, util_1.compressSuiType)(typeArgs[i]) !==
+            (0, util_1.compressSuiType)(extractType(reifiedTypeArgs[i]))) {
+            throw new Error(`provided item has mismatching type argments ${fullType} (expected ${extractType(reifiedTypeArgs[i])}, got ${typeArgs[i]}))`);
+        }
+    }
+}
+exports.assertReifiedTypeArgsMatch = assertReifiedTypeArgsMatch;
+function assertFieldsWithTypesArgsMatch(item, reifiedTypeArgs) {
+    const { typeArgs: itemTypeArgs } = (0, util_1.parseTypeName)(item.type);
+    assertReifiedTypeArgsMatch(item.type, itemTypeArgs, reifiedTypeArgs);
+}
+exports.assertFieldsWithTypesArgsMatch = assertFieldsWithTypesArgsMatch;
+function fieldToJSON(type, field) {
+    const { typeName, typeArgs } = (0, util_1.parseTypeName)(type);
+    switch (typeName) {
+        case "bool":
+            return field;
+        case "u8":
+        case "u16":
+        case "u32":
+            return field;
+        case "u64":
+        case "u128":
+        case "u256":
+            return field.toString();
+        case "address":
+        case "signer":
+            return field;
+        case "vector":
+            return field.map((item) => fieldToJSON(typeArgs[0], item));
+        // handle special types
+        case "0x1::string::String":
+        case "0x1::ascii::String":
+        case "0x2::url::Url":
+        case "0x2::object::ID":
+        case "0x2::object::UID":
+            return field;
+        case "0x1::option::Option": {
+            if (field === null) {
+                return null;
+            }
+            return fieldToJSON(typeArgs[0], field);
+        }
+        default:
+            return field.toJSONField();
+    }
+}
+exports.fieldToJSON = fieldToJSON;
+function decodeFromJSONField(typeArg, field) {
+    switch (typeArg) {
+        case "bool":
+        case "u8":
+        case "u16":
+        case "u32":
+            return field;
+        case "u64":
+        case "u128":
+        case "u256":
+            return BigInt(field);
+        case "address":
+            return field;
+    }
+    if (typeArg.kind === "VectorClassReified") {
+        return typeArg.fromJSONField(field).vec;
+    }
+    switch (typeArg.typeName) {
+        case "0x1::string::String":
+        case "0x1::ascii::String":
+        case "0x2::url::Url":
+        case "0x2::object::ID":
+        case "0x2::object::UID":
+            return field;
+        case "0x1::option::Option": {
+            if (field === null) {
+                return null;
+            }
+            return decodeFromJSONField(typeArg.reifiedTypeArgs[0], field);
+        }
+        default:
+            return typeArg.fromJSONField(field);
+    }
+}
+exports.decodeFromJSONField = decodeFromJSONField;

package/mainnet/_generated/_framework/util.d.ts

@@ -0,0 +1,53 @@
+import { TransactionArgument, TransactionBlock, TransactionObjectArgument } from "@mysten/sui.js/transactions";
+import { ObjectArg as SuiObjectArg } from "@mysten/sui.js/bcs";
+export interface FieldsWithTypes {
+    fields: Record<string, any>;
+    type: string;
+}
+export type ObjectId = string;
+export type ObjectCallArg = {
+    Object: SuiObjectArg;
+};
+export type ObjectArg = string | ObjectCallArg | TransactionArgument;
+export type PureArg = bigint | string | number | boolean | null | TransactionArgument | Array<PureArg>;
+export type GenericArg = ObjectArg | PureArg | Array<ObjectArg> | Array<PureArg> | Array<GenericArg>;
+export declare function parseTypeName(name: string): {
+    typeName: string;
+    typeArgs: string[];
+};
+export declare function isTransactionArgument(arg: GenericArg): arg is TransactionArgument;
+export declare function isTransactionObjectArgument(arg: GenericArg): arg is TransactionObjectArgument;
+export declare function obj(txb: TransactionBlock, arg: ObjectArg): {
+    type: "pure";
+    index: number;
+    kind: "Input";
+    value?: any;
+} | TransactionObjectArgument;
+export declare function pure(txb: TransactionBlock, arg: PureArg, type: string): {
+    type: "pure";
+    index: number;
+    kind: "Input";
+    value?: any;
+} | TransactionObjectArgument;
+export declare function option(txb: TransactionBlock, type: string, arg: GenericArg | null): {
+    type: "pure";
+    index: number;
+    kind: "Input";
+    value?: any;
+} | TransactionObjectArgument;
+export declare function generic(txb: TransactionBlock, type: string, arg: GenericArg): {
+    type: "pure";
+    index: number;
+    kind: "Input";
+    value?: any;
+} | TransactionObjectArgument;
+export declare function vector(txb: TransactionBlock, itemType: string, items: Array<GenericArg> | TransactionArgument): {
+    type: "pure";
+    index: number;
+    kind: "Input";
+    value?: any;
+} | TransactionObjectArgument;
+export declare function typeArgIsPure(type: string): boolean;
+export declare function compressSuiAddress(addr: string): string;
+export declare function compressSuiType(type: string): string;
+export declare function composeSuiType(typeName: string, ...typeArgs: string[]): string;

package/mainnet/_generated/_framework/util.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeSuiType = exports.compressSuiType = exports.compressSuiAddress = exports.typeArgIsPure = exports.vector = exports.generic = exports.option = exports.pure = exports.obj = exports.isTransactionObjectArgument = exports.isTransactionArgument = exports.parseTypeName = void 0;
+const bcs_1 = require("@mysten/sui.js/bcs");
+function parseTypeName(name) {
+    const parsed = bcs_1.bcs.parseTypeName(name);
+    return { typeName: parsed.name, typeArgs: parsed.params };
+}
+exports.parseTypeName = parseTypeName;
+function isTransactionArgument(arg) {
+    if (!arg || typeof arg !== "object" || Array.isArray(arg)) {
+        return false;
+    }
+    return "kind" in arg;
+}
+exports.isTransactionArgument = isTransactionArgument;
+function isTransactionObjectArgument(arg) {
+    if (!isTransactionArgument(arg)) {
+        return false;
+    }
+    if (arg.kind === "Input" && arg.type === "pure") {
+        return false;
+    }
+    return true;
+}
+exports.isTransactionObjectArgument = isTransactionObjectArgument;
+function obj(txb, arg) {
+    return isTransactionArgument(arg) ? arg : txb.object(arg);
+}
+exports.obj = obj;
+function pure(txb, arg, type) {
+    if (isTransactionArgument(arg)) {
+        return obj(txb, arg);
+    }
+    function getBcsForType(type) {
+        const { typeName, typeArgs } = parseTypeName(type);
+        switch (typeName) {
+            case "bool":
+                return bcs_1.bcs.Bool;
+            case "u8":
+                return bcs_1.bcs.U8;
+            case "u16":
+                return bcs_1.bcs.U16;
+            case "u32":
+                return bcs_1.bcs.U32;
+            case "u64":
+                return bcs_1.bcs.U64;
+            case "u128":
+                return bcs_1.bcs.U128;
+            case "u256":
+                return bcs_1.bcs.U256;
+            case "address":
+                return bcs_1.bcs.Address;
+            case "0x1::string::String":
+            case "0x1::ascii::String":
+                return bcs_1.bcs.String;
+            case "0x2::object::ID":
+                return bcs_1.bcs.Address;
+            case "0x1::option::Option":
+                return bcs_1.bcs.option(getBcsForType(typeArgs[0]));
+            case "vector":
+                return bcs_1.bcs.vector(getBcsForType(typeArgs[0]));
+            default:
+                throw new Error(`invalid primitive type ${type}`);
+        }
+    }
+    function isOrHasNestedTransactionArgument(arg) {
+        if (Array.isArray(arg)) {
+            return arg.some((item) => isOrHasNestedTransactionArgument(item));
+        }
+        return isTransactionArgument(arg);
+    }
+    // handle some cases when TransactionArgument is nested within a vector or option
+    const { typeName, typeArgs } = parseTypeName(type);
+    switch (typeName) {
+        case "0x1::option::Option":
+            if (arg === null) {
+                return txb.pure(bcs_1.bcs.option(bcs_1.bcs.Bool).serialize(null)); // bcs.Bool is arbitrary
+            }
+            if (isOrHasNestedTransactionArgument(arg)) {
+                throw new Error("nesting TransactionArgument is not supported");
+            }
+            break;
+        case "vector":
+            if (!Array.isArray(arg)) {
+                throw new Error("expected an array for vector type");
+            }
+            if (arg.length === 0) {
+                return txb.pure(bcs_1.bcs.vector(bcs_1.bcs.Bool).serialize([])); // bcs.Bool is arbitrary
+            }
+            if (arg.some((arg) => Array.isArray(arg) && isOrHasNestedTransactionArgument(arg))) {
+                throw new Error("nesting TransactionArgument is not supported");
+            }
+            if (isTransactionArgument(arg[0]) &&
+                arg.filter((arg) => !isTransactionArgument(arg)).length > 0) {
+                throw new Error("mixing TransactionArgument with other types is not supported");
+            }
+            if (isTransactionObjectArgument(arg[0])) {
+                return txb.makeMoveVec({
+                    objects: arg,
+                    type: typeArgs[0],
+                });
+            }
+    }
+    return txb.pure(getBcsForType(type).serialize(arg));
+}
+exports.pure = pure;
+function option(txb, type, arg) {
+    if (arg === null) {
+        return pure(txb, arg, `0x1::option::Option<${type}>`);
+    }
+    if (typeArgIsPure(type)) {
+        return pure(txb, arg, `0x1::option::Option<${type}>`);
+    }
+    else if (isTransactionArgument(arg)) {
+        return arg;
+    }
+    else {
+        if (arg === null) {
+            return pure(txb, arg, `vector<${type}>`);
+        }
+        // wrap it with some
+        const val = generic(txb, type, arg);
+        return txb.moveCall({
+            target: `0x1::option::some`,
+            typeArguments: [type],
+            arguments: [val],
+        });
+    }
+}
+exports.option = option;
+function generic(txb, type, arg) {
+    if (typeArgIsPure(type)) {
+        return pure(txb, arg, type);
+    }
+    else {
+        const { typeName, typeArgs } = parseTypeName(type);
+        if (typeName === "vector" && Array.isArray(arg)) {
+            const itemType = typeArgs[0];
+            return txb.makeMoveVec({
+                objects: arg.map((item) => obj(txb, item)),
+                type: itemType,
+            });
+        }
+        else {
+            return obj(txb, arg);
+        }
+    }
+}
+exports.generic = generic;
+function vector(txb, itemType, items) {
+    if (typeArgIsPure(itemType)) {
+        return pure(txb, items, `vector<${itemType}>`);
+    }
+    else if (isTransactionArgument(items)) {
+        return items;
+    }
+    else {
+        const { typeName: itemTypeName, typeArgs: itemTypeArgs } = parseTypeName(itemType);
+        if (itemTypeName === "0x1::option::Option") {
+            const objects = items.map((item) => option(txb, itemTypeArgs[0], item));
+            return txb.makeMoveVec({
+                objects,
+                type: itemType,
+            });
+        }
+        return txb.makeMoveVec({
+            objects: items,
+            type: itemType,
+        });
+    }
+}
+exports.vector = vector;
+function typeArgIsPure(type) {
+    const { typeName, typeArgs } = parseTypeName(type);
+    switch (typeName) {
+        case "bool":
+        case "u8":
+        case "u16":
+        case "u32":
+        case "u64":
+        case "u128":
+        case "u256":
+        case "address":
+        case "signer":
+            return true;
+        case "vector":
+            return typeArgIsPure(typeArgs[0]);
+        case "0x1::string::String":
+        case "0x1::ascii::String":
+        case "0x2::object::ID":
+            return true;
+        case "0x1::option::Option":
+            return typeArgIsPure(typeArgs[0]);
+        default:
+            return false;
+    }
+}
+exports.typeArgIsPure = typeArgIsPure;
+function compressSuiAddress(addr) {
+    // remove leading zeros
+    const stripped = addr.split("0x").join("");
+    for (let i = 0; i < stripped.length; i++) {
+        if (stripped[i] !== "0") {
+            return `0x${stripped.substring(i)}`;
+        }
+    }
+    return "0x0";
+}
+exports.compressSuiAddress = compressSuiAddress;
+// Recursively removes leading zeros from a type.
+// e.g. `0x00000002::module::Name<0x00001::a::C>` -> `0x2::module::Name<0x1::a::C>`
+function compressSuiType(type) {
+    const { typeName, typeArgs } = parseTypeName(type);
+    switch (typeName) {
+        case "bool":
+        case "u8":
+        case "u16":
+        case "u32":
+        case "u64":
+        case "u128":
+        case "u256":
+        case "address":
+        case "signer":
+            return typeName;
+        case "vector":
+            return `vector<${compressSuiType(typeArgs[0])}>`;
+        default: {
+            const tok = typeName.split("::");
+            tok[0] = compressSuiAddress(tok[0]);
+            const compressedName = tok.join("::");
+            if (typeArgs.length > 0) {
+                return `${compressedName}<${typeArgs.map((typeArg) => compressSuiType(typeArg)).join(",")}>`;
+            }
+            else {
+                return compressedName;
+            }
+        }
+    }
+}
+exports.compressSuiType = compressSuiType;
+function composeSuiType(typeName, ...typeArgs) {
+    if (typeArgs.length > 0) {
+        return `${typeName}<${typeArgs.join(", ")}>`;
+    }
+    else {
+        return typeName;
+    }
+}
+exports.composeSuiType = composeSuiType;

package/mainnet/_generated/suilend/cell/functions.d.ts

@@ -0,0 +1,10 @@
+import { GenericArg, ObjectArg } from "../../_framework/util";
+import { TransactionBlock } from "@mysten/sui.js/transactions";
+export declare function new_(txb: TransactionBlock, typeArg: string, element: GenericArg): import("@mysten/sui.js/transactions").TransactionResult;
+export interface SetArgs {
+    cell: ObjectArg;
+    element: GenericArg;
+}
+export declare function set(txb: TransactionBlock, typeArg: string, args: SetArgs): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function get(txb: TransactionBlock, typeArg: string, cell: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;
+export declare function destroy(txb: TransactionBlock, typeArg: string, cell: ObjectArg): import("@mysten/sui.js/transactions").TransactionResult;

package/mainnet/_generated/suilend/cell/functions.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destroy = exports.get = exports.set = exports.new_ = void 0;
+const __1 = require("..");
+const util_1 = require("../../_framework/util");
+function new_(txb, typeArg, element) {
+    return txb.moveCall({
+        target: `${__1.PUBLISHED_AT}::cell::new`,
+        typeArguments: [typeArg],
+        arguments: [(0, util_1.generic)(txb, `${typeArg}`, element)],
+    });
+}
+exports.new_ = new_;
+function set(txb, typeArg, args) {
+    return txb.moveCall({
+        target: `${__1.PUBLISHED_AT}::cell::set`,
+        typeArguments: [typeArg],
+        arguments: [(0, util_1.obj)(txb, args.cell), (0, util_1.generic)(txb, `${typeArg}`, args.element)],
+    });
+}
+exports.set = set;
+function get(txb, typeArg, cell) {
+    return txb.moveCall({
+        target: `${__1.PUBLISHED_AT}::cell::get`,
+        typeArguments: [typeArg],
+        arguments: [(0, util_1.obj)(txb, cell)],
+    });
+}
+exports.get = get;
+function destroy(txb, typeArg, cell) {
+    return txb.moveCall({
+        target: `${__1.PUBLISHED_AT}::cell::destroy`,
+        typeArguments: [typeArg],
+        arguments: [(0, util_1.obj)(txb, cell)],
+    });
+}
+exports.destroy = destroy;

package/mainnet/_generated/suilend/cell/structs.d.ts

@@ -0,0 +1,49 @@
+import { Option } from "../../_dependencies/source/0x1/option/structs";
+import { PhantomReified, Reified, StructClass, ToField, ToTypeArgument, ToTypeStr, TypeArgument } from "../../_framework/reified";
+import { FieldsWithTypes } from "../../_framework/util";
+import { BcsType } from "@mysten/bcs";
+import { SuiClient, SuiParsedData } from "@mysten/sui.js/client";
+export declare function isCell(type: string): boolean;
+export interface CellFields<Element extends TypeArgument> {
+    element: ToField<Option<Element>>;
+}
+export type CellReified<Element extends TypeArgument> = Reified<Cell<Element>, CellFields<Element>>;
+export declare class Cell<Element extends TypeArgument> implements StructClass {
+    static readonly $typeName = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::cell::Cell";
+    static readonly $numTypeParams = 1;
+    readonly $typeName = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::cell::Cell";
+    readonly $fullTypeName: `0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::cell::Cell<${ToTypeStr<Element>}>`;
+    readonly $typeArgs: [ToTypeStr<Element>];
+    readonly element: ToField<Option<Element>>;
+    private constructor();
+    static reified<Element extends Reified<TypeArgument, any>>(Element: Element): CellReified<ToTypeArgument<Element>>;
+    static get r(): typeof Cell.reified;
+    static phantom<Element extends Reified<TypeArgument, any>>(Element: Element): PhantomReified<ToTypeStr<Cell<ToTypeArgument<Element>>>>;
+    static get p(): typeof Cell.phantom;
+    static get bcs(): <Element extends BcsType<any, any>>(Element: Element) => BcsType<{
+        element: {
+            vec: any[];
+        };
+    }, {
+        element: {
+            vec: Iterable<any> & {
+                length: number;
+            };
+        };
+    }>;
+    static fromFields<Element extends Reified<TypeArgument, any>>(typeArg: Element, fields: Record<string, any>): Cell<ToTypeArgument<Element>>;
+    static fromFieldsWithTypes<Element extends Reified<TypeArgument, any>>(typeArg: Element, item: FieldsWithTypes): Cell<ToTypeArgument<Element>>;
+    static fromBcs<Element extends Reified<TypeArgument, any>>(typeArg: Element, data: Uint8Array): Cell<ToTypeArgument<Element>>;
+    toJSONField(): {
+        element: import("../../_framework/reified").ToJSON<Element> | null;
+    };
+    toJSON(): {
+        element: import("../../_framework/reified").ToJSON<Element> | null;
+        $typeName: string;
+        $typeArgs: [ToTypeStr<Element>];
+    };
+    static fromJSONField<Element extends Reified<TypeArgument, any>>(typeArg: Element, field: any): Cell<ToTypeArgument<Element>>;
+    static fromJSON<Element extends Reified<TypeArgument, any>>(typeArg: Element, json: Record<string, any>): Cell<ToTypeArgument<Element>>;
+    static fromSuiParsedData<Element extends Reified<TypeArgument, any>>(typeArg: Element, content: SuiParsedData): Cell<ToTypeArgument<Element>>;
+    static fetch<Element extends Reified<TypeArgument, any>>(client: SuiClient, typeArg: Element, id: string): Promise<Cell<ToTypeArgument<Element>>>;
+}