3land_sdk 1.0.0 → 1.0.2

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

@@ -0,0 +1,18 @@
+import * as types from "../types";
+import * as borsh from "@coral-xyz/borsh";
+export interface NormalJSON {
+    kind: "Normal";
+}
+export declare class Normal {
+    static readonly discriminator = 0;
+    static readonly kind = "Normal";
+    readonly discriminator = 0;
+    readonly kind = "Normal";
+    toJSON(): NormalJSON;
+    toEncodable(): {
+        Normal: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.CardClassKind;
+export declare function fromJSON(obj: types.CardClassJSON): types.CardClassKind;
+export declare function layout(property?: string): borsh.EnumLayout<unknown>;

package/dist/cjs/types/types/CardClass.js

@@ -0,0 +1,73 @@
+"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.Normal = void 0;
+exports.fromDecoded = fromDecoded;
+exports.fromJSON = fromJSON;
+exports.layout = layout;
+const borsh = __importStar(require("@coral-xyz/borsh"));
+class Normal {
+    constructor() {
+        this.discriminator = 0;
+        this.kind = "Normal";
+    }
+    toJSON() {
+        return {
+            kind: "Normal",
+        };
+    }
+    toEncodable() {
+        return {
+            Normal: {},
+        };
+    }
+}
+exports.Normal = Normal;
+Normal.discriminator = 0;
+Normal.kind = "Normal";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function fromDecoded(obj) {
+    if (typeof obj !== "object") {
+        throw new Error("Invalid enum object");
+    }
+    if ("Normal" in obj) {
+        return new Normal();
+    }
+    throw new Error("Invalid enum object");
+}
+function fromJSON(obj) {
+    switch (obj.kind) {
+        case "Normal": {
+            return new Normal();
+        }
+    }
+}
+function layout(property) {
+    const ret = borsh.rustEnum([borsh.struct([], "Normal")]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

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

@@ -0,0 +1,96 @@
+import * as types from "../types";
+import * as borsh from "@coral-xyz/borsh";
+export interface ActiveJSON {
+    kind: "Active";
+}
+export declare class Active {
+    static readonly discriminator = 0;
+    static readonly kind = "Active";
+    readonly discriminator = 0;
+    readonly kind = "Active";
+    toJSON(): ActiveJSON;
+    toEncodable(): {
+        Active: {};
+    };
+}
+export interface HiddenJSON {
+    kind: "Hidden";
+}
+export declare class Hidden {
+    static readonly discriminator = 1;
+    static readonly kind = "Hidden";
+    readonly discriminator = 1;
+    readonly kind = "Hidden";
+    toJSON(): HiddenJSON;
+    toEncodable(): {
+        Hidden: {};
+    };
+}
+export interface InactiveJSON {
+    kind: "Inactive";
+}
+export declare class Inactive {
+    static readonly discriminator = 2;
+    static readonly kind = "Inactive";
+    readonly discriminator = 2;
+    readonly kind = "Inactive";
+    toJSON(): InactiveJSON;
+    toEncodable(): {
+        Inactive: {};
+    };
+}
+export interface RetiredJSON {
+    kind: "Retired";
+}
+export declare class Retired {
+    static readonly discriminator = 3;
+    static readonly kind = "Retired";
+    readonly discriminator = 3;
+    readonly kind = "Retired";
+    toJSON(): RetiredJSON;
+    toEncodable(): {
+        Retired: {};
+    };
+}
+export interface SoldOutJSON {
+    kind: "SoldOut";
+}
+export declare class SoldOut {
+    static readonly discriminator = 4;
+    static readonly kind = "SoldOut";
+    readonly discriminator = 4;
+    readonly kind = "SoldOut";
+    toJSON(): SoldOutJSON;
+    toEncodable(): {
+        SoldOut: {};
+    };
+}
+export interface NoneJSON {
+    kind: "None";
+}
+export declare class None {
+    static readonly discriminator = 5;
+    static readonly kind = "None";
+    readonly discriminator = 5;
+    readonly kind = "None";
+    toJSON(): NoneJSON;
+    toEncodable(): {
+        None: {};
+    };
+}
+export interface NotReadyJSON {
+    kind: "NotReady";
+}
+export declare class NotReady {
+    static readonly discriminator = 6;
+    static readonly kind = "NotReady";
+    readonly discriminator = 6;
+    readonly kind = "NotReady";
+    toJSON(): NotReadyJSON;
+    toEncodable(): {
+        NotReady: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.CardStateKind;
+export declare function fromJSON(obj: types.CardStateJSON): types.CardStateKind;
+export declare function layout(property?: string): borsh.EnumLayout<unknown>;

package/dist/cjs/types/types/CardState.js

@@ -0,0 +1,231 @@
+"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.NotReady = exports.None = exports.SoldOut = exports.Retired = exports.Inactive = exports.Hidden = exports.Active = void 0;
+exports.fromDecoded = fromDecoded;
+exports.fromJSON = fromJSON;
+exports.layout = layout;
+const borsh = __importStar(require("@coral-xyz/borsh"));
+class Active {
+    constructor() {
+        this.discriminator = 0;
+        this.kind = "Active";
+    }
+    toJSON() {
+        return {
+            kind: "Active",
+        };
+    }
+    toEncodable() {
+        return {
+            Active: {},
+        };
+    }
+}
+exports.Active = Active;
+Active.discriminator = 0;
+Active.kind = "Active";
+class Hidden {
+    constructor() {
+        this.discriminator = 1;
+        this.kind = "Hidden";
+    }
+    toJSON() {
+        return {
+            kind: "Hidden",
+        };
+    }
+    toEncodable() {
+        return {
+            Hidden: {},
+        };
+    }
+}
+exports.Hidden = Hidden;
+Hidden.discriminator = 1;
+Hidden.kind = "Hidden";
+class Inactive {
+    constructor() {
+        this.discriminator = 2;
+        this.kind = "Inactive";
+    }
+    toJSON() {
+        return {
+            kind: "Inactive",
+        };
+    }
+    toEncodable() {
+        return {
+            Inactive: {},
+        };
+    }
+}
+exports.Inactive = Inactive;
+Inactive.discriminator = 2;
+Inactive.kind = "Inactive";
+class Retired {
+    constructor() {
+        this.discriminator = 3;
+        this.kind = "Retired";
+    }
+    toJSON() {
+        return {
+            kind: "Retired",
+        };
+    }
+    toEncodable() {
+        return {
+            Retired: {},
+        };
+    }
+}
+exports.Retired = Retired;
+Retired.discriminator = 3;
+Retired.kind = "Retired";
+class SoldOut {
+    constructor() {
+        this.discriminator = 4;
+        this.kind = "SoldOut";
+    }
+    toJSON() {
+        return {
+            kind: "SoldOut",
+        };
+    }
+    toEncodable() {
+        return {
+            SoldOut: {},
+        };
+    }
+}
+exports.SoldOut = SoldOut;
+SoldOut.discriminator = 4;
+SoldOut.kind = "SoldOut";
+class None {
+    constructor() {
+        this.discriminator = 5;
+        this.kind = "None";
+    }
+    toJSON() {
+        return {
+            kind: "None",
+        };
+    }
+    toEncodable() {
+        return {
+            None: {},
+        };
+    }
+}
+exports.None = None;
+None.discriminator = 5;
+None.kind = "None";
+class NotReady {
+    constructor() {
+        this.discriminator = 6;
+        this.kind = "NotReady";
+    }
+    toJSON() {
+        return {
+            kind: "NotReady",
+        };
+    }
+    toEncodable() {
+        return {
+            NotReady: {},
+        };
+    }
+}
+exports.NotReady = NotReady;
+NotReady.discriminator = 6;
+NotReady.kind = "NotReady";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function fromDecoded(obj) {
+    if (typeof obj !== "object") {
+        throw new Error("Invalid enum object");
+    }
+    if ("Active" in obj) {
+        return new Active();
+    }
+    if ("Hidden" in obj) {
+        return new Hidden();
+    }
+    if ("Inactive" in obj) {
+        return new Inactive();
+    }
+    if ("Retired" in obj) {
+        return new Retired();
+    }
+    if ("SoldOut" in obj) {
+        return new SoldOut();
+    }
+    if ("None" in obj) {
+        return new None();
+    }
+    if ("NotReady" in obj) {
+        return new NotReady();
+    }
+    throw new Error("Invalid enum object");
+}
+function fromJSON(obj) {
+    switch (obj.kind) {
+        case "Active": {
+            return new Active();
+        }
+        case "Hidden": {
+            return new Hidden();
+        }
+        case "Inactive": {
+            return new Inactive();
+        }
+        case "Retired": {
+            return new Retired();
+        }
+        case "SoldOut": {
+            return new SoldOut();
+        }
+        case "None": {
+            return new None();
+        }
+        case "NotReady": {
+            return new NotReady();
+        }
+    }
+}
+function layout(property) {
+    const ret = borsh.rustEnum([
+        borsh.struct([], "Active"),
+        borsh.struct([], "Hidden"),
+        borsh.struct([], "Inactive"),
+        borsh.struct([], "Retired"),
+        borsh.struct([], "SoldOut"),
+        borsh.struct([], "None"),
+        borsh.struct([], "NotReady"),
+    ]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

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

@@ -0,0 +1,59 @@
+import * as types from "../types";
+export interface CardTrackFields {
+    supply: number;
+    created: number;
+    state: types.CardStateKind;
+}
+export interface CardTrackJSON {
+    supply: number;
+    created: number;
+    state: types.CardStateJSON;
+}
+export declare class CardTrack {
+    readonly supply: number;
+    readonly created: number;
+    readonly state: types.CardStateKind;
+    constructor(fields: CardTrackFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): types.CardTrack;
+    static toEncodable(fields: CardTrackFields): {
+        supply: number;
+        created: number;
+        state: {
+            Active: {};
+        } | {
+            Hidden: {};
+        } | {
+            Inactive: {};
+        } | {
+            Retired: {};
+        } | {
+            SoldOut: {};
+        } | {
+            None: {};
+        } | {
+            NotReady: {};
+        };
+    };
+    toJSON(): CardTrackJSON;
+    static fromJSON(obj: CardTrackJSON): CardTrack;
+    toEncodable(): {
+        supply: number;
+        created: number;
+        state: {
+            Active: {};
+        } | {
+            Hidden: {};
+        } | {
+            Inactive: {};
+        } | {
+            Retired: {};
+        } | {
+            SoldOut: {};
+        } | {
+            None: {};
+        } | {
+            NotReady: {};
+        };
+    };
+}

package/dist/cjs/types/types/CardTrack.js

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

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

@@ -0,0 +1,31 @@
+import * as types from "../types";
+export interface CategoryFields {
+    cat1: number;
+    cat2: number;
+    cat3: number;
+}
+export interface CategoryJSON {
+    cat1: number;
+    cat2: number;
+    cat3: number;
+}
+export declare class Category {
+    readonly cat1: number;
+    readonly cat2: number;
+    readonly cat3: number;
+    constructor(fields: CategoryFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): types.Category;
+    static toEncodable(fields: CategoryFields): {
+        cat1: number;
+        cat2: number;
+        cat3: number;
+    };
+    toJSON(): CategoryJSON;
+    static fromJSON(obj: CategoryJSON): Category;
+    toEncodable(): {
+        cat1: number;
+        cat2: number;
+        cat3: number;
+    };
+}

package/dist/cjs/types/types/Category.js

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

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

@@ -0,0 +1,36 @@
+import * as types from "../types";
+export interface CnftDataFields {
+    root: Array<number>;
+    dataHash: Array<number>;
+    creatorHash: Array<number>;
+    index: number;
+}
+export interface CnftDataJSON {
+    root: Array<number>;
+    dataHash: Array<number>;
+    creatorHash: Array<number>;
+    index: number;
+}
+export declare class CnftData {
+    readonly root: Array<number>;
+    readonly dataHash: Array<number>;
+    readonly creatorHash: Array<number>;
+    readonly index: number;
+    constructor(fields: CnftDataFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): types.CnftData;
+    static toEncodable(fields: CnftDataFields): {
+        root: number[];
+        dataHash: number[];
+        creatorHash: number[];
+        index: number;
+    };
+    toJSON(): CnftDataJSON;
+    static fromJSON(obj: CnftDataJSON): CnftData;
+    toEncodable(): {
+        root: number[];
+        dataHash: number[];
+        creatorHash: number[];
+        index: number;
+    };
+}