3land_sdk 1.0.0 → 1.0.2

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

@@ -0,0 +1,57 @@
+import * as types from "../types";
+import * as borsh from "@coral-xyz/borsh";
+export interface HiddenBySystemJSON {
+    kind: "HiddenBySystem";
+}
+export declare class HiddenBySystem {
+    static readonly discriminator = 0;
+    static readonly kind = "HiddenBySystem";
+    readonly discriminator = 0;
+    readonly kind = "HiddenBySystem";
+    toJSON(): HiddenBySystemJSON;
+    toEncodable(): {
+        HiddenBySystem: {};
+    };
+}
+export interface PublicJSON {
+    kind: "Public";
+}
+export declare class Public {
+    static readonly discriminator = 1;
+    static readonly kind = "Public";
+    readonly discriminator = 1;
+    readonly kind = "Public";
+    toJSON(): PublicJSON;
+    toEncodable(): {
+        Public: {};
+    };
+}
+export interface HiddenByUserJSON {
+    kind: "HiddenByUser";
+}
+export declare class HiddenByUser {
+    static readonly discriminator = 2;
+    static readonly kind = "HiddenByUser";
+    readonly discriminator = 2;
+    readonly kind = "HiddenByUser";
+    toJSON(): HiddenByUserJSON;
+    toEncodable(): {
+        HiddenByUser: {};
+    };
+}
+export interface FlaggedPirateJSON {
+    kind: "FlaggedPirate";
+}
+export declare class FlaggedPirate {
+    static readonly discriminator = 3;
+    static readonly kind = "FlaggedPirate";
+    readonly discriminator = 3;
+    readonly kind = "FlaggedPirate";
+    toJSON(): FlaggedPirateJSON;
+    toEncodable(): {
+        FlaggedPirate: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.GlobalStateKind;
+export declare function fromJSON(obj: types.GlobalStateJSON): types.GlobalStateKind;
+export declare function layout(property?: string): borsh.EnumLayout<unknown>;

package/dist/cjs/types/types/GlobalState.js

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

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

@@ -0,0 +1,41 @@
+import * as types from "../types";
+export interface IndexDateFields {
+    hour: number;
+    day: number;
+    week: number;
+    month: number;
+    minRelative: number;
+}
+export interface IndexDateJSON {
+    hour: number;
+    day: number;
+    week: number;
+    month: number;
+    minRelative: number;
+}
+export declare class IndexDate {
+    readonly hour: number;
+    readonly day: number;
+    readonly week: number;
+    readonly month: number;
+    readonly minRelative: number;
+    constructor(fields: IndexDateFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): types.IndexDate;
+    static toEncodable(fields: IndexDateFields): {
+        hour: number;
+        day: number;
+        week: number;
+        month: number;
+        minRelative: number;
+    };
+    toJSON(): IndexDateJSON;
+    static fromJSON(obj: IndexDateJSON): IndexDate;
+    toEncodable(): {
+        hour: number;
+        day: number;
+        week: number;
+        month: number;
+        minRelative: number;
+    };
+}

package/dist/cjs/types/types/IndexDate.js

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

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

@@ -0,0 +1,50 @@
+import * as types from "../types";
+export interface IndexDatesFields {
+    created: types.IndexDateFields;
+    activity: types.IndexDateFields;
+}
+export interface IndexDatesJSON {
+    created: types.IndexDateJSON;
+    activity: types.IndexDateJSON;
+}
+export declare class IndexDates {
+    readonly created: types.IndexDate;
+    readonly activity: types.IndexDate;
+    constructor(fields: IndexDatesFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): types.IndexDates;
+    static toEncodable(fields: IndexDatesFields): {
+        created: {
+            hour: number;
+            day: number;
+            week: number;
+            month: number;
+            minRelative: number;
+        };
+        activity: {
+            hour: number;
+            day: number;
+            week: number;
+            month: number;
+            minRelative: number;
+        };
+    };
+    toJSON(): IndexDatesJSON;
+    static fromJSON(obj: IndexDatesJSON): IndexDates;
+    toEncodable(): {
+        created: {
+            hour: number;
+            day: number;
+            week: number;
+            month: number;
+            minRelative: number;
+        };
+        activity: {
+            hour: number;
+            day: number;
+            week: number;
+            month: number;
+            minRelative: number;
+        };
+    };
+}

package/dist/cjs/types/types/IndexDates.js

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

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

@@ -0,0 +1,107 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import * as types from "../types";
+export interface ItemFields {
+    metadata: types.MetadataArgsFields;
+}
+export interface ItemJSON {
+    metadata: types.MetadataArgsJSON;
+}
+export declare class Item {
+    readonly metadata: types.MetadataArgs;
+    constructor(fields: ItemFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): types.Item;
+    static toEncodable(fields: ItemFields): {
+        metadata: {
+            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(): ItemJSON;
+    static fromJSON(obj: ItemJSON): Item;
+    toEncodable(): {
+        metadata: {
+            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/Item.js

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

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

@@ -0,0 +1,31 @@
+import * as types from "../types";
+import * as borsh from "@coral-xyz/borsh";
+export interface SingleJSON {
+    kind: "Single";
+}
+export declare class Single {
+    static readonly discriminator = 0;
+    static readonly kind = "Single";
+    readonly discriminator = 0;
+    readonly kind = "Single";
+    toJSON(): SingleJSON;
+    toEncodable(): {
+        Single: {};
+    };
+}
+export interface PackJSON {
+    kind: "Pack";
+}
+export declare class Pack {
+    static readonly discriminator = 1;
+    static readonly kind = "Pack";
+    readonly discriminator = 1;
+    readonly kind = "Pack";
+    toJSON(): PackJSON;
+    toEncodable(): {
+        Pack: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.ItemClassKind;
+export declare function fromJSON(obj: types.ItemClassJSON): types.ItemClassKind;
+export declare function layout(property?: string): borsh.EnumLayout<unknown>;