@allbridge/bridge-core-sdk 3.20.0 → 3.21.0

package/dist/src/services/models/sui/_dependencies/source/0x346e3233f61eb0055713417bfaddda7dc3bf26816faad1f7606994a368b92917/treasury/structs.js

@@ -0,0 +1,623 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreasuryCapKey = exports.Treasury = exports.MintCap = exports.Burn = void 0;
+exports.isBurn = isBurn;
+exports.isMintCap = isMintCap;
+exports.isTreasury = isTreasury;
+exports.isTreasuryCapKey = isTreasuryCapKey;
+// @ts-nocheck
+const reified = __importStar(require("../../../../_framework/reified"));
+const reified_1 = require("../../../../_framework/reified");
+const util_1 = require("../../../../_framework/util");
+const structs_1 = require("../../../../sui/object/structs");
+const structs_2 = require("../../../../sui/table/structs");
+const structs_3 = require("../../../../sui/vec-set/structs");
+const index_1 = require("../index");
+const structs_4 = require("../mint-allowance/structs");
+const bcs_1 = require("@mysten/sui/bcs");
+const utils_1 = require("@mysten/sui/utils");
+/* ============================== Burn =============================== */
+function isBurn(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type.startsWith(`${index_1.PKG_V1}::treasury::Burn` + "<");
+}
+class Burn {
+    __StructClass = true;
+    static get $typeName() {
+        return `${index_1.PKG_V1}::treasury::Burn`;
+    }
+    static $numTypeParams = 1;
+    static $isPhantom = [true];
+    $typeName = Burn.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = Burn.$isPhantom;
+    mintCap;
+    amount;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = (0, util_1.composeSuiType)(Burn.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.mintCap = fields.mintCap;
+        this.amount = fields.amount;
+    }
+    static reified(T) {
+        return {
+            typeName: Burn.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(Burn.$typeName, ...[(0, reified_1.extractType)(T)]),
+            typeArgs: [(0, reified_1.extractType)(T)],
+            isPhantom: Burn.$isPhantom,
+            reifiedTypeArgs: [T],
+            fromFields: (fields) => Burn.fromFields(T, fields),
+            fromFieldsWithTypes: (item) => Burn.fromFieldsWithTypes(T, item),
+            fromBcs: (data) => Burn.fromBcs(T, data),
+            bcs: Burn.bcs,
+            fromJSONField: (field) => Burn.fromJSONField(T, field),
+            fromJSON: (json) => Burn.fromJSON(T, json),
+            fromSuiParsedData: (content) => Burn.fromSuiParsedData(T, content),
+            fromSuiObjectData: (content) => Burn.fromSuiObjectData(T, content),
+            fetch: async (client, id) => Burn.fetch(client, T, id),
+            new: (fields) => {
+                return new Burn([(0, reified_1.extractType)(T)], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return Burn.reified;
+    }
+    static phantom(T) {
+        return (0, reified_1.phantom)(Burn.reified(T));
+    }
+    static get p() {
+        return Burn.phantom;
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("Burn", {
+            mint_cap: structs_1.ID.bcs,
+            amount: bcs_1.bcs.u64(),
+        });
+    }
+    static fromFields(typeArg, fields) {
+        return Burn.reified(typeArg).new({
+            mintCap: (0, reified_1.decodeFromFields)(structs_1.ID.reified(), fields.mint_cap),
+            amount: (0, reified_1.decodeFromFields)("u64", fields.amount),
+        });
+    }
+    static fromFieldsWithTypes(typeArg, item) {
+        if (!isBurn(item.type)) {
+            throw new Error("not a Burn type");
+        }
+        (0, reified_1.assertFieldsWithTypesArgsMatch)(item, [typeArg]);
+        return Burn.reified(typeArg).new({
+            mintCap: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.ID.reified(), item.fields.mint_cap),
+            amount: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.amount),
+        });
+    }
+    static fromBcs(typeArg, data) {
+        return Burn.fromFields(typeArg, Burn.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            mintCap: this.mintCap,
+            amount: this.amount.toString(),
+        };
+    }
+    toJSON() {
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
+    }
+    static fromJSONField(typeArg, field) {
+        return Burn.reified(typeArg).new({
+            mintCap: (0, reified_1.decodeFromJSONField)(structs_1.ID.reified(), field.mintCap),
+            amount: (0, reified_1.decodeFromJSONField)("u64", field.amount),
+        });
+    }
+    static fromJSON(typeArg, json) {
+        if (json.$typeName !== Burn.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        (0, reified_1.assertReifiedTypeArgsMatch)((0, util_1.composeSuiType)(Burn.$typeName, (0, reified_1.extractType)(typeArg)), json.$typeArgs, [typeArg]);
+        return Burn.fromJSONField(typeArg, json);
+    }
+    static fromSuiParsedData(typeArg, content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isBurn(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a Burn object`);
+        }
+        return Burn.fromFieldsWithTypes(typeArg, content);
+    }
+    static fromSuiObjectData(typeArg, data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" || !isBurn(data.bcs.type)) {
+                throw new Error(`object at is not a Burn object`);
+            }
+            const gotTypeArgs = (0, util_1.parseTypeName)(data.bcs.type).typeArgs;
+            if (gotTypeArgs.length !== 1) {
+                throw new Error(`type argument mismatch: expected 1 type argument but got '${gotTypeArgs.length}'`);
+            }
+            const gotTypeArg = (0, util_1.compressSuiType)(gotTypeArgs[0]);
+            const expectedTypeArg = (0, util_1.compressSuiType)((0, reified_1.extractType)(typeArg));
+            if (gotTypeArg !== (0, util_1.compressSuiType)((0, reified_1.extractType)(typeArg))) {
+                throw new Error(`type argument mismatch: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+            return Burn.fromBcs(typeArg, (0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return Burn.fromSuiParsedData(typeArg, data.content);
+        }
+        throw new Error("Both `bcs` and `content` fields are missing from the data. Include `showBcs` or `showContent` in the request.");
+    }
+    static async fetch(client, typeArg, id) {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching Burn object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isBurn(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a Burn object`);
+        }
+        return Burn.fromSuiObjectData(typeArg, res.data);
+    }
+}
+exports.Burn = Burn;
+/* ============================== MintCap =============================== */
+function isMintCap(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type.startsWith(`${index_1.PKG_V1}::treasury::MintCap` + "<");
+}
+class MintCap {
+    __StructClass = true;
+    static get $typeName() {
+        return `${index_1.PKG_V1}::treasury::MintCap`;
+    }
+    static $numTypeParams = 1;
+    static $isPhantom = [true];
+    $typeName = MintCap.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = MintCap.$isPhantom;
+    id;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = (0, util_1.composeSuiType)(MintCap.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.id = fields.id;
+    }
+    static reified(T) {
+        return {
+            typeName: MintCap.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(MintCap.$typeName, ...[(0, reified_1.extractType)(T)]),
+            typeArgs: [(0, reified_1.extractType)(T)],
+            isPhantom: MintCap.$isPhantom,
+            reifiedTypeArgs: [T],
+            fromFields: (fields) => MintCap.fromFields(T, fields),
+            fromFieldsWithTypes: (item) => MintCap.fromFieldsWithTypes(T, item),
+            fromBcs: (data) => MintCap.fromBcs(T, data),
+            bcs: MintCap.bcs,
+            fromJSONField: (field) => MintCap.fromJSONField(T, field),
+            fromJSON: (json) => MintCap.fromJSON(T, json),
+            fromSuiParsedData: (content) => MintCap.fromSuiParsedData(T, content),
+            fromSuiObjectData: (content) => MintCap.fromSuiObjectData(T, content),
+            fetch: async (client, id) => MintCap.fetch(client, T, id),
+            new: (fields) => {
+                return new MintCap([(0, reified_1.extractType)(T)], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return MintCap.reified;
+    }
+    static phantom(T) {
+        return (0, reified_1.phantom)(MintCap.reified(T));
+    }
+    static get p() {
+        return MintCap.phantom;
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("MintCap", {
+            id: structs_1.UID.bcs,
+        });
+    }
+    static fromFields(typeArg, fields) {
+        return MintCap.reified(typeArg).new({
+            id: (0, reified_1.decodeFromFields)(structs_1.UID.reified(), fields.id),
+        });
+    }
+    static fromFieldsWithTypes(typeArg, item) {
+        if (!isMintCap(item.type)) {
+            throw new Error("not a MintCap type");
+        }
+        (0, reified_1.assertFieldsWithTypesArgsMatch)(item, [typeArg]);
+        return MintCap.reified(typeArg).new({
+            id: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.UID.reified(), item.fields.id),
+        });
+    }
+    static fromBcs(typeArg, data) {
+        return MintCap.fromFields(typeArg, MintCap.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            id: this.id,
+        };
+    }
+    toJSON() {
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
+    }
+    static fromJSONField(typeArg, field) {
+        return MintCap.reified(typeArg).new({
+            id: (0, reified_1.decodeFromJSONField)(structs_1.UID.reified(), field.id),
+        });
+    }
+    static fromJSON(typeArg, json) {
+        if (json.$typeName !== MintCap.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        (0, reified_1.assertReifiedTypeArgsMatch)((0, util_1.composeSuiType)(MintCap.$typeName, (0, reified_1.extractType)(typeArg)), json.$typeArgs, [typeArg]);
+        return MintCap.fromJSONField(typeArg, json);
+    }
+    static fromSuiParsedData(typeArg, content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isMintCap(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a MintCap object`);
+        }
+        return MintCap.fromFieldsWithTypes(typeArg, content);
+    }
+    static fromSuiObjectData(typeArg, data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" || !isMintCap(data.bcs.type)) {
+                throw new Error(`object at is not a MintCap object`);
+            }
+            const gotTypeArgs = (0, util_1.parseTypeName)(data.bcs.type).typeArgs;
+            if (gotTypeArgs.length !== 1) {
+                throw new Error(`type argument mismatch: expected 1 type argument but got '${gotTypeArgs.length}'`);
+            }
+            const gotTypeArg = (0, util_1.compressSuiType)(gotTypeArgs[0]);
+            const expectedTypeArg = (0, util_1.compressSuiType)((0, reified_1.extractType)(typeArg));
+            if (gotTypeArg !== (0, util_1.compressSuiType)((0, reified_1.extractType)(typeArg))) {
+                throw new Error(`type argument mismatch: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+            return MintCap.fromBcs(typeArg, (0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return MintCap.fromSuiParsedData(typeArg, data.content);
+        }
+        throw new Error("Both `bcs` and `content` fields are missing from the data. Include `showBcs` or `showContent` in the request.");
+    }
+    static async fetch(client, typeArg, id) {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching MintCap object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isMintCap(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a MintCap object`);
+        }
+        return MintCap.fromSuiObjectData(typeArg, res.data);
+    }
+}
+exports.MintCap = MintCap;
+/* ============================== Treasury =============================== */
+function isTreasury(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type.startsWith(`${index_1.PKG_V1}::treasury::Treasury` + "<");
+}
+class Treasury {
+    __StructClass = true;
+    static get $typeName() {
+        return `${index_1.PKG_V1}::treasury::Treasury`;
+    }
+    static $numTypeParams = 1;
+    static $isPhantom = [true];
+    $typeName = Treasury.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = Treasury.$isPhantom;
+    id;
+    controllers;
+    mintAllowances;
+    compatibleVersions;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = (0, util_1.composeSuiType)(Treasury.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.id = fields.id;
+        this.controllers = fields.controllers;
+        this.mintAllowances = fields.mintAllowances;
+        this.compatibleVersions = fields.compatibleVersions;
+    }
+    static reified(T) {
+        return {
+            typeName: Treasury.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(Treasury.$typeName, ...[(0, reified_1.extractType)(T)]),
+            typeArgs: [(0, reified_1.extractType)(T)],
+            isPhantom: Treasury.$isPhantom,
+            reifiedTypeArgs: [T],
+            fromFields: (fields) => Treasury.fromFields(T, fields),
+            fromFieldsWithTypes: (item) => Treasury.fromFieldsWithTypes(T, item),
+            fromBcs: (data) => Treasury.fromBcs(T, data),
+            bcs: Treasury.bcs,
+            fromJSONField: (field) => Treasury.fromJSONField(T, field),
+            fromJSON: (json) => Treasury.fromJSON(T, json),
+            fromSuiParsedData: (content) => Treasury.fromSuiParsedData(T, content),
+            fromSuiObjectData: (content) => Treasury.fromSuiObjectData(T, content),
+            fetch: async (client, id) => Treasury.fetch(client, T, id),
+            new: (fields) => {
+                return new Treasury([(0, reified_1.extractType)(T)], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return Treasury.reified;
+    }
+    static phantom(T) {
+        return (0, reified_1.phantom)(Treasury.reified(T));
+    }
+    static get p() {
+        return Treasury.phantom;
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("Treasury", {
+            id: structs_1.UID.bcs,
+            controllers: structs_2.Table.bcs,
+            mint_allowances: structs_2.Table.bcs,
+            compatible_versions: structs_3.VecSet.bcs(bcs_1.bcs.u64()),
+        });
+    }
+    static fromFields(typeArg, fields) {
+        return Treasury.reified(typeArg).new({
+            id: (0, reified_1.decodeFromFields)(structs_1.UID.reified(), fields.id),
+            controllers: (0, reified_1.decodeFromFields)(structs_2.Table.reified(reified.phantom("address"), reified.phantom(structs_1.ID.reified())), fields.controllers),
+            mintAllowances: (0, reified_1.decodeFromFields)(structs_2.Table.reified(reified.phantom(structs_1.ID.reified()), reified.phantom(structs_4.MintAllowance.reified(typeArg))), fields.mint_allowances),
+            compatibleVersions: (0, reified_1.decodeFromFields)(structs_3.VecSet.reified("u64"), fields.compatible_versions),
+        });
+    }
+    static fromFieldsWithTypes(typeArg, item) {
+        if (!isTreasury(item.type)) {
+            throw new Error("not a Treasury type");
+        }
+        (0, reified_1.assertFieldsWithTypesArgsMatch)(item, [typeArg]);
+        return Treasury.reified(typeArg).new({
+            id: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.UID.reified(), item.fields.id),
+            controllers: (0, reified_1.decodeFromFieldsWithTypes)(structs_2.Table.reified(reified.phantom("address"), reified.phantom(structs_1.ID.reified())), item.fields.controllers),
+            mintAllowances: (0, reified_1.decodeFromFieldsWithTypes)(structs_2.Table.reified(reified.phantom(structs_1.ID.reified()), reified.phantom(structs_4.MintAllowance.reified(typeArg))), item.fields.mint_allowances),
+            compatibleVersions: (0, reified_1.decodeFromFieldsWithTypes)(structs_3.VecSet.reified("u64"), item.fields.compatible_versions),
+        });
+    }
+    static fromBcs(typeArg, data) {
+        return Treasury.fromFields(typeArg, Treasury.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            id: this.id,
+            controllers: this.controllers.toJSONField(),
+            mintAllowances: this.mintAllowances.toJSONField(),
+            compatibleVersions: this.compatibleVersions.toJSONField(),
+        };
+    }
+    toJSON() {
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
+    }
+    static fromJSONField(typeArg, field) {
+        return Treasury.reified(typeArg).new({
+            id: (0, reified_1.decodeFromJSONField)(structs_1.UID.reified(), field.id),
+            controllers: (0, reified_1.decodeFromJSONField)(structs_2.Table.reified(reified.phantom("address"), reified.phantom(structs_1.ID.reified())), field.controllers),
+            mintAllowances: (0, reified_1.decodeFromJSONField)(structs_2.Table.reified(reified.phantom(structs_1.ID.reified()), reified.phantom(structs_4.MintAllowance.reified(typeArg))), field.mintAllowances),
+            compatibleVersions: (0, reified_1.decodeFromJSONField)(structs_3.VecSet.reified("u64"), field.compatibleVersions),
+        });
+    }
+    static fromJSON(typeArg, json) {
+        if (json.$typeName !== Treasury.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        (0, reified_1.assertReifiedTypeArgsMatch)((0, util_1.composeSuiType)(Treasury.$typeName, (0, reified_1.extractType)(typeArg)), json.$typeArgs, [typeArg]);
+        return Treasury.fromJSONField(typeArg, json);
+    }
+    static fromSuiParsedData(typeArg, content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isTreasury(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a Treasury object`);
+        }
+        return Treasury.fromFieldsWithTypes(typeArg, content);
+    }
+    static fromSuiObjectData(typeArg, data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" || !isTreasury(data.bcs.type)) {
+                throw new Error(`object at is not a Treasury object`);
+            }
+            const gotTypeArgs = (0, util_1.parseTypeName)(data.bcs.type).typeArgs;
+            if (gotTypeArgs.length !== 1) {
+                throw new Error(`type argument mismatch: expected 1 type argument but got '${gotTypeArgs.length}'`);
+            }
+            const gotTypeArg = (0, util_1.compressSuiType)(gotTypeArgs[0]);
+            const expectedTypeArg = (0, util_1.compressSuiType)((0, reified_1.extractType)(typeArg));
+            if (gotTypeArg !== (0, util_1.compressSuiType)((0, reified_1.extractType)(typeArg))) {
+                throw new Error(`type argument mismatch: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+            return Treasury.fromBcs(typeArg, (0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return Treasury.fromSuiParsedData(typeArg, data.content);
+        }
+        throw new Error("Both `bcs` and `content` fields are missing from the data. Include `showBcs` or `showContent` in the request.");
+    }
+    static async fetch(client, typeArg, id) {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching Treasury object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isTreasury(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a Treasury object`);
+        }
+        return Treasury.fromSuiObjectData(typeArg, res.data);
+    }
+}
+exports.Treasury = Treasury;
+/* ============================== TreasuryCapKey =============================== */
+function isTreasuryCapKey(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type === `${index_1.PKG_V1}::treasury::TreasuryCapKey`;
+}
+class TreasuryCapKey {
+    __StructClass = true;
+    static get $typeName() {
+        return `${index_1.PKG_V1}::treasury::TreasuryCapKey`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = TreasuryCapKey.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = TreasuryCapKey.$isPhantom;
+    dummyField;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = (0, util_1.composeSuiType)(TreasuryCapKey.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.dummyField = fields.dummyField;
+    }
+    static reified() {
+        return {
+            typeName: TreasuryCapKey.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(TreasuryCapKey.$typeName, ...[]),
+            typeArgs: [],
+            isPhantom: TreasuryCapKey.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => TreasuryCapKey.fromFields(fields),
+            fromFieldsWithTypes: (item) => TreasuryCapKey.fromFieldsWithTypes(item),
+            fromBcs: (data) => TreasuryCapKey.fromBcs(data),
+            bcs: TreasuryCapKey.bcs,
+            fromJSONField: (field) => TreasuryCapKey.fromJSONField(field),
+            fromJSON: (json) => TreasuryCapKey.fromJSON(json),
+            fromSuiParsedData: (content) => TreasuryCapKey.fromSuiParsedData(content),
+            fromSuiObjectData: (content) => TreasuryCapKey.fromSuiObjectData(content),
+            fetch: async (client, id) => TreasuryCapKey.fetch(client, id),
+            new: (fields) => {
+                return new TreasuryCapKey([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return TreasuryCapKey.reified();
+    }
+    static phantom() {
+        return (0, reified_1.phantom)(TreasuryCapKey.reified());
+    }
+    static get p() {
+        return TreasuryCapKey.phantom();
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("TreasuryCapKey", {
+            dummy_field: bcs_1.bcs.bool(),
+        });
+    }
+    static fromFields(fields) {
+        return TreasuryCapKey.reified().new({
+            dummyField: (0, reified_1.decodeFromFields)("bool", fields.dummy_field),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isTreasuryCapKey(item.type)) {
+            throw new Error("not a TreasuryCapKey type");
+        }
+        return TreasuryCapKey.reified().new({
+            dummyField: (0, reified_1.decodeFromFieldsWithTypes)("bool", item.fields.dummy_field),
+        });
+    }
+    static fromBcs(data) {
+        return TreasuryCapKey.fromFields(TreasuryCapKey.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            dummyField: this.dummyField,
+        };
+    }
+    toJSON() {
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
+    }
+    static fromJSONField(field) {
+        return TreasuryCapKey.reified().new({
+            dummyField: (0, reified_1.decodeFromJSONField)("bool", field.dummyField),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== TreasuryCapKey.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        return TreasuryCapKey.fromJSONField(json);
+    }
+    static fromSuiParsedData(content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isTreasuryCapKey(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a TreasuryCapKey object`);
+        }
+        return TreasuryCapKey.fromFieldsWithTypes(content);
+    }
+    static fromSuiObjectData(data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" || !isTreasuryCapKey(data.bcs.type)) {
+                throw new Error(`object at is not a TreasuryCapKey object`);
+            }
+            return TreasuryCapKey.fromBcs((0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return TreasuryCapKey.fromSuiParsedData(data.content);
+        }
+        throw new Error("Both `bcs` and `content` fields are missing from the data. Include `showBcs` or `showContent` in the request.");
+    }
+    static async fetch(client, id) {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching TreasuryCapKey object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isTreasuryCapKey(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a TreasuryCapKey object`);
+        }
+        return TreasuryCapKey.fromSuiObjectData(res.data);
+    }
+}
+exports.TreasuryCapKey = TreasuryCapKey;
+//# sourceMappingURL=structs.js.map