3land_sdk 1.0.0 → 1.0.2

package/dist/cjs/types/types/ListingPerWalletArgs.js

@@ -0,0 +1,60 @@
+"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.ListingPerWalletArgs = void 0;
+const borsh = __importStar(require("@coral-xyz/borsh"));
+class ListingPerWalletArgs {
+    constructor(fields) {
+        this.amount = fields.amount;
+    }
+    static layout(property) {
+        return borsh.struct([borsh.u16("amount")], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new ListingPerWalletArgs({
+            amount: obj.amount,
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            amount: fields.amount,
+        };
+    }
+    toJSON() {
+        return {
+            amount: this.amount,
+        };
+    }
+    static fromJSON(obj) {
+        return new ListingPerWalletArgs({
+            amount: obj.amount,
+        });
+    }
+    toEncodable() {
+        return ListingPerWalletArgs.toEncodable(this);
+    }
+}
+exports.ListingPerWalletArgs = ListingPerWalletArgs;

package/dist/cjs/types/types/MemeVaultProof.d.ts

@@ -0,0 +1,27 @@
+import BN from "bn.js";
+import * as types from "../types";
+export interface MemeVaultProofFields {
+    amount: BN;
+    halfCurrencyHash: number;
+}
+export interface MemeVaultProofJSON {
+    amount: string;
+    halfCurrencyHash: number;
+}
+export declare class MemeVaultProof {
+    readonly amount: BN;
+    readonly halfCurrencyHash: number;
+    constructor(fields: MemeVaultProofFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): types.MemeVaultProof;
+    static toEncodable(fields: MemeVaultProofFields): {
+        amount: BN;
+        halfCurrencyHash: number;
+    };
+    toJSON(): MemeVaultProofJSON;
+    static fromJSON(obj: MemeVaultProofJSON): MemeVaultProof;
+    toEncodable(): {
+        amount: BN;
+        halfCurrencyHash: number;
+    };
+}

package/dist/cjs/types/types/MemeVaultProof.js

@@ -0,0 +1,69 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemeVaultProof = void 0;
+const bn_js_1 = __importDefault(require("bn.js")); // eslint-disable-line @typescript-eslint/no-unused-vars
+const borsh = __importStar(require("@coral-xyz/borsh"));
+class MemeVaultProof {
+    constructor(fields) {
+        this.amount = fields.amount;
+        this.halfCurrencyHash = fields.halfCurrencyHash;
+    }
+    static layout(property) {
+        return borsh.struct([borsh.u64("amount"), borsh.u32("halfCurrencyHash")], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new MemeVaultProof({
+            amount: obj.amount,
+            halfCurrencyHash: obj.halfCurrencyHash,
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            amount: fields.amount,
+            halfCurrencyHash: fields.halfCurrencyHash,
+        };
+    }
+    toJSON() {
+        return {
+            amount: this.amount.toString(),
+            halfCurrencyHash: this.halfCurrencyHash,
+        };
+    }
+    static fromJSON(obj) {
+        return new MemeVaultProof({
+            amount: new bn_js_1.default(obj.amount),
+            halfCurrencyHash: obj.halfCurrencyHash,
+        });
+    }
+    toEncodable() {
+        return MemeVaultProof.toEncodable(this);
+    }
+}
+exports.MemeVaultProof = MemeVaultProof;

package/dist/cjs/types/types/MetadataArgs.d.ts

@@ -0,0 +1,160 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import * as types from "../types";
+export interface MetadataArgsFields {
+    /** The name of the asset */
+    name: string;
+    /** The symbol for the asset */
+    symbol: string;
+    /** URI pointing to JSON representing the asset */
+    uri: string;
+    /** Royalty basis points that goes to creators in secondary sales (0-10000) */
+    sellerFeeBasisPoints: number;
+    primarySaleHappened: boolean;
+    isMutable: boolean;
+    /** nonce for easy calculation of editions, if present */
+    editionNonce: number | null;
+    /** Since we cannot easily change Metadata, we add the new DataV2 fields here at the end. */
+    tokenStandard: types.TokenStandardKind | null;
+    /** Collection */
+    collection: types.CollectionFields | null;
+    /** Uses */
+    uses: types.UsesFields | null;
+    tokenProgramVersion: types.TokenProgramVersionKind;
+    creators: Array<types.CreatorFields>;
+}
+export interface MetadataArgsJSON {
+    /** The name of the asset */
+    name: string;
+    /** The symbol for the asset */
+    symbol: string;
+    /** URI pointing to JSON representing the asset */
+    uri: string;
+    /** Royalty basis points that goes to creators in secondary sales (0-10000) */
+    sellerFeeBasisPoints: number;
+    primarySaleHappened: boolean;
+    isMutable: boolean;
+    /** nonce for easy calculation of editions, if present */
+    editionNonce: number | null;
+    /** Since we cannot easily change Metadata, we add the new DataV2 fields here at the end. */
+    tokenStandard: types.TokenStandardJSON | null;
+    /** Collection */
+    collection: types.CollectionJSON | null;
+    /** Uses */
+    uses: types.UsesJSON | null;
+    tokenProgramVersion: types.TokenProgramVersionJSON;
+    creators: Array<types.CreatorJSON>;
+}
+export declare class MetadataArgs {
+    /** The name of the asset */
+    readonly name: string;
+    /** The symbol for the asset */
+    readonly symbol: string;
+    /** URI pointing to JSON representing the asset */
+    readonly uri: string;
+    /** Royalty basis points that goes to creators in secondary sales (0-10000) */
+    readonly sellerFeeBasisPoints: number;
+    readonly primarySaleHappened: boolean;
+    readonly isMutable: boolean;
+    /** nonce for easy calculation of editions, if present */
+    readonly editionNonce: number | null;
+    /** Since we cannot easily change Metadata, we add the new DataV2 fields here at the end. */
+    readonly tokenStandard: types.TokenStandardKind | null;
+    /** Collection */
+    readonly collection: types.Collection | null;
+    /** Uses */
+    readonly uses: types.Uses | null;
+    readonly tokenProgramVersion: types.TokenProgramVersionKind;
+    readonly creators: Array<types.Creator>;
+    constructor(fields: MetadataArgsFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): types.MetadataArgs;
+    static toEncodable(fields: MetadataArgsFields): {
+        name: string;
+        symbol: string;
+        uri: string;
+        sellerFeeBasisPoints: number;
+        primarySaleHappened: boolean;
+        isMutable: boolean;
+        editionNonce: number | null;
+        tokenStandard: {
+            NonFungible: {};
+        } | {
+            FungibleAsset: {};
+        } | {
+            Fungible: {};
+        } | {
+            NonFungibleEdition: {};
+        } | null;
+        collection: {
+            verified: boolean;
+            key: PublicKey;
+        } | null;
+        uses: {
+            useMethod: {
+                Burn: {};
+            } | {
+                Multiple: {};
+            } | {
+                Single: {};
+            };
+            remaining: BN;
+            total: BN;
+        } | null;
+        tokenProgramVersion: {
+            Original: {};
+        } | {
+            Token2022: {};
+        };
+        creators: {
+            address: PublicKey;
+            verified: boolean;
+            share: number;
+        }[];
+    };
+    toJSON(): MetadataArgsJSON;
+    static fromJSON(obj: MetadataArgsJSON): MetadataArgs;
+    toEncodable(): {
+        name: string;
+        symbol: string;
+        uri: string;
+        sellerFeeBasisPoints: number;
+        primarySaleHappened: boolean;
+        isMutable: boolean;
+        editionNonce: number | null;
+        tokenStandard: {
+            NonFungible: {};
+        } | {
+            FungibleAsset: {};
+        } | {
+            Fungible: {};
+        } | {
+            NonFungibleEdition: {};
+        } | null;
+        collection: {
+            verified: boolean;
+            key: PublicKey;
+        } | null;
+        uses: {
+            useMethod: {
+                Burn: {};
+            } | {
+                Multiple: {};
+            } | {
+                Single: {};
+            };
+            remaining: BN;
+            total: BN;
+        } | null;
+        tokenProgramVersion: {
+            Original: {};
+        } | {
+            Token2022: {};
+        };
+        creators: {
+            address: PublicKey;
+            verified: boolean;
+            share: number;
+        }[];
+    };
+}

package/dist/cjs/types/types/MetadataArgs.js

@@ -0,0 +1,138 @@
+"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.MetadataArgs = void 0;
+const types = __importStar(require("../types")); // eslint-disable-line @typescript-eslint/no-unused-vars
+const borsh = __importStar(require("@coral-xyz/borsh"));
+class MetadataArgs {
+    constructor(fields) {
+        this.name = fields.name;
+        this.symbol = fields.symbol;
+        this.uri = fields.uri;
+        this.sellerFeeBasisPoints = fields.sellerFeeBasisPoints;
+        this.primarySaleHappened = fields.primarySaleHappened;
+        this.isMutable = fields.isMutable;
+        this.editionNonce = fields.editionNonce;
+        this.tokenStandard = fields.tokenStandard;
+        this.collection =
+            (fields.collection && new types.Collection(Object.assign({}, fields.collection))) ||
+                null;
+        this.uses = (fields.uses && new types.Uses(Object.assign({}, fields.uses))) || null;
+        this.tokenProgramVersion = fields.tokenProgramVersion;
+        this.creators = fields.creators.map((item) => new types.Creator(Object.assign({}, item)));
+    }
+    static layout(property) {
+        return borsh.struct([
+            borsh.str("name"),
+            borsh.str("symbol"),
+            borsh.str("uri"),
+            borsh.u16("sellerFeeBasisPoints"),
+            borsh.bool("primarySaleHappened"),
+            borsh.bool("isMutable"),
+            borsh.option(borsh.u8(), "editionNonce"),
+            borsh.option(types.TokenStandard.layout(), "tokenStandard"),
+            borsh.option(types.Collection.layout(), "collection"),
+            borsh.option(types.Uses.layout(), "uses"),
+            types.TokenProgramVersion.layout("tokenProgramVersion"),
+            borsh.vec(types.Creator.layout(), "creators"),
+        ], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new MetadataArgs({
+            name: obj.name,
+            symbol: obj.symbol,
+            uri: obj.uri,
+            sellerFeeBasisPoints: obj.sellerFeeBasisPoints,
+            primarySaleHappened: obj.primarySaleHappened,
+            isMutable: obj.isMutable,
+            editionNonce: obj.editionNonce,
+            tokenStandard: (obj.tokenStandard &&
+                types.TokenStandard.fromDecoded(obj.tokenStandard)) ||
+                null,
+            collection: (obj.collection && types.Collection.fromDecoded(obj.collection)) ||
+                null,
+            uses: (obj.uses && types.Uses.fromDecoded(obj.uses)) || null,
+            tokenProgramVersion: types.TokenProgramVersion.fromDecoded(obj.tokenProgramVersion),
+            creators: obj.creators.map((item /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.Creator.fromDecoded(item)),
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            name: fields.name,
+            symbol: fields.symbol,
+            uri: fields.uri,
+            sellerFeeBasisPoints: fields.sellerFeeBasisPoints,
+            primarySaleHappened: fields.primarySaleHappened,
+            isMutable: fields.isMutable,
+            editionNonce: fields.editionNonce,
+            tokenStandard: (fields.tokenStandard && fields.tokenStandard.toEncodable()) || null,
+            collection: (fields.collection &&
+                types.Collection.toEncodable(fields.collection)) ||
+                null,
+            uses: (fields.uses && types.Uses.toEncodable(fields.uses)) || null,
+            tokenProgramVersion: fields.tokenProgramVersion.toEncodable(),
+            creators: fields.creators.map((item) => types.Creator.toEncodable(item)),
+        };
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            symbol: this.symbol,
+            uri: this.uri,
+            sellerFeeBasisPoints: this.sellerFeeBasisPoints,
+            primarySaleHappened: this.primarySaleHappened,
+            isMutable: this.isMutable,
+            editionNonce: this.editionNonce,
+            tokenStandard: (this.tokenStandard && this.tokenStandard.toJSON()) || null,
+            collection: (this.collection && this.collection.toJSON()) || null,
+            uses: (this.uses && this.uses.toJSON()) || null,
+            tokenProgramVersion: this.tokenProgramVersion.toJSON(),
+            creators: this.creators.map((item) => item.toJSON()),
+        };
+    }
+    static fromJSON(obj) {
+        return new MetadataArgs({
+            name: obj.name,
+            symbol: obj.symbol,
+            uri: obj.uri,
+            sellerFeeBasisPoints: obj.sellerFeeBasisPoints,
+            primarySaleHappened: obj.primarySaleHappened,
+            isMutable: obj.isMutable,
+            editionNonce: obj.editionNonce,
+            tokenStandard: (obj.tokenStandard &&
+                types.TokenStandard.fromJSON(obj.tokenStandard)) ||
+                null,
+            collection: (obj.collection && types.Collection.fromJSON(obj.collection)) || null,
+            uses: (obj.uses && types.Uses.fromJSON(obj.uses)) || null,
+            tokenProgramVersion: types.TokenProgramVersion.fromJSON(obj.tokenProgramVersion),
+            creators: obj.creators.map((item) => types.Creator.fromJSON(item)),
+        });
+    }
+    toEncodable() {
+        return MetadataArgs.toEncodable(this);
+    }
+}
+exports.MetadataArgs = MetadataArgs;

package/dist/cjs/types/types/NonFungibleTraitInit.d.ts

@@ -0,0 +1,27 @@
+import BN from "bn.js";
+import * as types from "../types";
+export interface NonFungibleTraitInitFields {
+    hash: BN;
+    values: Array<BN>;
+}
+export interface NonFungibleTraitInitJSON {
+    hash: string;
+    values: Array<string>;
+}
+export declare class NonFungibleTraitInit {
+    readonly hash: BN;
+    readonly values: Array<BN>;
+    constructor(fields: NonFungibleTraitInitFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): types.NonFungibleTraitInit;
+    static toEncodable(fields: NonFungibleTraitInitFields): {
+        hash: BN;
+        values: BN[];
+    };
+    toJSON(): NonFungibleTraitInitJSON;
+    static fromJSON(obj: NonFungibleTraitInitJSON): NonFungibleTraitInit;
+    toEncodable(): {
+        hash: BN;
+        values: BN[];
+    };
+}

package/dist/cjs/types/types/NonFungibleTraitInit.js

@@ -0,0 +1,69 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonFungibleTraitInit = void 0;
+const bn_js_1 = __importDefault(require("bn.js")); // eslint-disable-line @typescript-eslint/no-unused-vars
+const borsh = __importStar(require("@coral-xyz/borsh"));
+class NonFungibleTraitInit {
+    constructor(fields) {
+        this.hash = fields.hash;
+        this.values = fields.values;
+    }
+    static layout(property) {
+        return borsh.struct([borsh.u64("hash"), borsh.vec(borsh.u64(), "values")], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new NonFungibleTraitInit({
+            hash: obj.hash,
+            values: obj.values,
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            hash: fields.hash,
+            values: fields.values,
+        };
+    }
+    toJSON() {
+        return {
+            hash: this.hash.toString(),
+            values: this.values.map((item) => item.toString()),
+        };
+    }
+    static fromJSON(obj) {
+        return new NonFungibleTraitInit({
+            hash: new bn_js_1.default(obj.hash),
+            values: obj.values.map((item) => new bn_js_1.default(item)),
+        });
+    }
+    toEncodable() {
+        return NonFungibleTraitInit.toEncodable(this);
+    }
+}
+exports.NonFungibleTraitInit = NonFungibleTraitInit;

package/dist/cjs/types/types/NonFungibleTraitInitMap.d.ts

@@ -0,0 +1,38 @@
+import BN from "bn.js";
+import * as types from "../types";
+export interface NonFungibleTraitInitMapFields {
+    hash: BN;
+    values: Array<types.FakeTraitValueFields>;
+    index: number;
+}
+export interface NonFungibleTraitInitMapJSON {
+    hash: string;
+    values: Array<types.FakeTraitValueJSON>;
+    index: number;
+}
+export declare class NonFungibleTraitInitMap {
+    readonly hash: BN;
+    readonly values: Array<types.FakeTraitValue>;
+    readonly index: number;
+    constructor(fields: NonFungibleTraitInitMapFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): types.NonFungibleTraitInitMap;
+    static toEncodable(fields: NonFungibleTraitInitMapFields): {
+        hash: BN;
+        values: {
+            trait_value: BN;
+            state: number;
+        }[];
+        index: number;
+    };
+    toJSON(): NonFungibleTraitInitMapJSON;
+    static fromJSON(obj: NonFungibleTraitInitMapJSON): NonFungibleTraitInitMap;
+    toEncodable(): {
+        hash: BN;
+        values: {
+            trait_value: BN;
+            state: number;
+        }[];
+        index: number;
+    };
+}

package/dist/cjs/types/types/NonFungibleTraitInitMap.js

@@ -0,0 +1,79 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonFungibleTraitInitMap = void 0;
+const bn_js_1 = __importDefault(require("bn.js")); // eslint-disable-line @typescript-eslint/no-unused-vars
+const types = __importStar(require("../types")); // eslint-disable-line @typescript-eslint/no-unused-vars
+const borsh = __importStar(require("@coral-xyz/borsh"));
+class NonFungibleTraitInitMap {
+    constructor(fields) {
+        this.hash = fields.hash;
+        this.values = fields.values.map((item) => new types.FakeTraitValue(Object.assign({}, item)));
+        this.index = fields.index;
+    }
+    static layout(property) {
+        return borsh.struct([
+            borsh.u64("hash"),
+            borsh.vec(types.FakeTraitValue.layout(), "values"),
+            borsh.u32("index"),
+        ], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new NonFungibleTraitInitMap({
+            hash: obj.hash,
+            values: obj.values.map((item /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.FakeTraitValue.fromDecoded(item)),
+            index: obj.index,
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            hash: fields.hash,
+            values: fields.values.map((item) => types.FakeTraitValue.toEncodable(item)),
+            index: fields.index,
+        };
+    }
+    toJSON() {
+        return {
+            hash: this.hash.toString(),
+            values: this.values.map((item) => item.toJSON()),
+            index: this.index,
+        };
+    }
+    static fromJSON(obj) {
+        return new NonFungibleTraitInitMap({
+            hash: new bn_js_1.default(obj.hash),
+            values: obj.values.map((item) => types.FakeTraitValue.fromJSON(item)),
+            index: obj.index,
+        });
+    }
+    toEncodable() {
+        return NonFungibleTraitInitMap.toEncodable(this);
+    }
+}
+exports.NonFungibleTraitInitMap = NonFungibleTraitInitMap;