3land_sdk 1.0.1 → 1.0.2

package/dist/types/types/BurnType.d.ts

@@ -0,0 +1,43 @@
+import * as types from "../types";
+export interface NoneJSON {
+    kind: "None";
+}
+export declare class None {
+    static readonly discriminator = 0;
+    static readonly kind = "None";
+    readonly discriminator = 0;
+    readonly kind = "None";
+    toJSON(): NoneJSON;
+    toEncodable(): {
+        None: {};
+    };
+}
+export interface InTXJSON {
+    kind: "InTX";
+}
+export declare class InTX {
+    static readonly discriminator = 1;
+    static readonly kind = "InTX";
+    readonly discriminator = 1;
+    readonly kind = "InTX";
+    toJSON(): InTXJSON;
+    toEncodable(): {
+        InTX: {};
+    };
+}
+export interface ProgressedJSON {
+    kind: "Progressed";
+}
+export declare class Progressed {
+    static readonly discriminator = 2;
+    static readonly kind = "Progressed";
+    readonly discriminator = 2;
+    readonly kind = "Progressed";
+    toJSON(): ProgressedJSON;
+    toEncodable(): {
+        Progressed: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.BurnTypeKind;
+export declare function fromJSON(obj: types.BurnTypeJSON): types.BurnTypeKind;
+export declare function layout(property?: string): any;

package/dist/types/types/BurnType.js

@@ -0,0 +1,95 @@
+import * as borsh from "@coral-xyz/borsh";
+export class None {
+    constructor() {
+        this.discriminator = 0;
+        this.kind = "None";
+    }
+    toJSON() {
+        return {
+            kind: "None",
+        };
+    }
+    toEncodable() {
+        return {
+            None: {},
+        };
+    }
+}
+None.discriminator = 0;
+None.kind = "None";
+export class InTX {
+    constructor() {
+        this.discriminator = 1;
+        this.kind = "InTX";
+    }
+    toJSON() {
+        return {
+            kind: "InTX",
+        };
+    }
+    toEncodable() {
+        return {
+            InTX: {},
+        };
+    }
+}
+InTX.discriminator = 1;
+InTX.kind = "InTX";
+export class Progressed {
+    constructor() {
+        this.discriminator = 2;
+        this.kind = "Progressed";
+    }
+    toJSON() {
+        return {
+            kind: "Progressed",
+        };
+    }
+    toEncodable() {
+        return {
+            Progressed: {},
+        };
+    }
+}
+Progressed.discriminator = 2;
+Progressed.kind = "Progressed";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj) {
+    if (typeof obj !== "object") {
+        throw new Error("Invalid enum object");
+    }
+    if ("None" in obj) {
+        return new None();
+    }
+    if ("InTX" in obj) {
+        return new InTX();
+    }
+    if ("Progressed" in obj) {
+        return new Progressed();
+    }
+    throw new Error("Invalid enum object");
+}
+export function fromJSON(obj) {
+    switch (obj.kind) {
+        case "None": {
+            return new None();
+        }
+        case "InTX": {
+            return new InTX();
+        }
+        case "Progressed": {
+            return new Progressed();
+        }
+    }
+}
+export function layout(property) {
+    const ret = borsh.rustEnum([
+        borsh.struct([], "None"),
+        borsh.struct([], "InTX"),
+        borsh.struct([], "Progressed"),
+    ]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

package/dist/types/types/BurnTypeBurn.d.ts

@@ -0,0 +1,17 @@
+import * as types from "../types";
+export interface CollectionBurnJSON {
+    kind: "CollectionBurn";
+}
+export declare class CollectionBurn {
+    static readonly discriminator = 0;
+    static readonly kind = "CollectionBurn";
+    readonly discriminator = 0;
+    readonly kind = "CollectionBurn";
+    toJSON(): CollectionBurnJSON;
+    toEncodable(): {
+        CollectionBurn: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.BurnTypeBurnKind;
+export declare function fromJSON(obj: types.BurnTypeBurnJSON): types.BurnTypeBurnKind;
+export declare function layout(property?: string): any;

package/dist/types/types/BurnTypeBurn.js

@@ -0,0 +1,43 @@
+import * as borsh from "@coral-xyz/borsh";
+export class CollectionBurn {
+    constructor() {
+        this.discriminator = 0;
+        this.kind = "CollectionBurn";
+    }
+    toJSON() {
+        return {
+            kind: "CollectionBurn",
+        };
+    }
+    toEncodable() {
+        return {
+            CollectionBurn: {},
+        };
+    }
+}
+CollectionBurn.discriminator = 0;
+CollectionBurn.kind = "CollectionBurn";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj) {
+    if (typeof obj !== "object") {
+        throw new Error("Invalid enum object");
+    }
+    if ("CollectionBurn" in obj) {
+        return new CollectionBurn();
+    }
+    throw new Error("Invalid enum object");
+}
+export function fromJSON(obj) {
+    switch (obj.kind) {
+        case "CollectionBurn": {
+            return new CollectionBurn();
+        }
+    }
+}
+export function layout(property) {
+    const ret = borsh.rustEnum([borsh.struct([], "CollectionBurn")]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

package/dist/types/types/BuyHistoryClass.d.ts

@@ -0,0 +1,30 @@
+import * as types from "../types";
+export interface SingleBuyV1JSON {
+    kind: "SingleBuyV1";
+}
+export declare class SingleBuyV1 {
+    static readonly discriminator = 0;
+    static readonly kind = "SingleBuyV1";
+    readonly discriminator = 0;
+    readonly kind = "SingleBuyV1";
+    toJSON(): SingleBuyV1JSON;
+    toEncodable(): {
+        SingleBuyV1: {};
+    };
+}
+export interface PackBuyV1JSON {
+    kind: "PackBuyV1";
+}
+export declare class PackBuyV1 {
+    static readonly discriminator = 1;
+    static readonly kind = "PackBuyV1";
+    readonly discriminator = 1;
+    readonly kind = "PackBuyV1";
+    toJSON(): PackBuyV1JSON;
+    toEncodable(): {
+        PackBuyV1: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.BuyHistoryClassKind;
+export declare function fromJSON(obj: types.BuyHistoryClassJSON): types.BuyHistoryClassKind;
+export declare function layout(property?: string): any;

package/dist/types/types/BuyHistoryClass.js

@@ -0,0 +1,70 @@
+import * as borsh from "@coral-xyz/borsh";
+export class SingleBuyV1 {
+    constructor() {
+        this.discriminator = 0;
+        this.kind = "SingleBuyV1";
+    }
+    toJSON() {
+        return {
+            kind: "SingleBuyV1",
+        };
+    }
+    toEncodable() {
+        return {
+            SingleBuyV1: {},
+        };
+    }
+}
+SingleBuyV1.discriminator = 0;
+SingleBuyV1.kind = "SingleBuyV1";
+export class PackBuyV1 {
+    constructor() {
+        this.discriminator = 1;
+        this.kind = "PackBuyV1";
+    }
+    toJSON() {
+        return {
+            kind: "PackBuyV1",
+        };
+    }
+    toEncodable() {
+        return {
+            PackBuyV1: {},
+        };
+    }
+}
+PackBuyV1.discriminator = 1;
+PackBuyV1.kind = "PackBuyV1";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj) {
+    if (typeof obj !== "object") {
+        throw new Error("Invalid enum object");
+    }
+    if ("SingleBuyV1" in obj) {
+        return new SingleBuyV1();
+    }
+    if ("PackBuyV1" in obj) {
+        return new PackBuyV1();
+    }
+    throw new Error("Invalid enum object");
+}
+export function fromJSON(obj) {
+    switch (obj.kind) {
+        case "SingleBuyV1": {
+            return new SingleBuyV1();
+        }
+        case "PackBuyV1": {
+            return new PackBuyV1();
+        }
+    }
+}
+export function layout(property) {
+    const ret = borsh.rustEnum([
+        borsh.struct([], "SingleBuyV1"),
+        borsh.struct([], "PackBuyV1"),
+    ]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

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

@@ -0,0 +1,17 @@
+import * as types from "../types";
+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): any;

package/dist/types/types/CardClass.js

@@ -0,0 +1,43 @@
+import * as borsh from "@coral-xyz/borsh";
+export class Normal {
+    constructor() {
+        this.discriminator = 0;
+        this.kind = "Normal";
+    }
+    toJSON() {
+        return {
+            kind: "Normal",
+        };
+    }
+    toEncodable() {
+        return {
+            Normal: {},
+        };
+    }
+}
+Normal.discriminator = 0;
+Normal.kind = "Normal";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export 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");
+}
+export function fromJSON(obj) {
+    switch (obj.kind) {
+        case "Normal": {
+            return new Normal();
+        }
+    }
+}
+export function layout(property) {
+    const ret = borsh.rustEnum([borsh.struct([], "Normal")]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

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

@@ -0,0 +1,95 @@
+import * as types from "../types";
+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): any;

package/dist/types/types/CardState.js

@@ -0,0 +1,195 @@
+import * as borsh from "@coral-xyz/borsh";
+export class Active {
+    constructor() {
+        this.discriminator = 0;
+        this.kind = "Active";
+    }
+    toJSON() {
+        return {
+            kind: "Active",
+        };
+    }
+    toEncodable() {
+        return {
+            Active: {},
+        };
+    }
+}
+Active.discriminator = 0;
+Active.kind = "Active";
+export class Hidden {
+    constructor() {
+        this.discriminator = 1;
+        this.kind = "Hidden";
+    }
+    toJSON() {
+        return {
+            kind: "Hidden",
+        };
+    }
+    toEncodable() {
+        return {
+            Hidden: {},
+        };
+    }
+}
+Hidden.discriminator = 1;
+Hidden.kind = "Hidden";
+export class Inactive {
+    constructor() {
+        this.discriminator = 2;
+        this.kind = "Inactive";
+    }
+    toJSON() {
+        return {
+            kind: "Inactive",
+        };
+    }
+    toEncodable() {
+        return {
+            Inactive: {},
+        };
+    }
+}
+Inactive.discriminator = 2;
+Inactive.kind = "Inactive";
+export class Retired {
+    constructor() {
+        this.discriminator = 3;
+        this.kind = "Retired";
+    }
+    toJSON() {
+        return {
+            kind: "Retired",
+        };
+    }
+    toEncodable() {
+        return {
+            Retired: {},
+        };
+    }
+}
+Retired.discriminator = 3;
+Retired.kind = "Retired";
+export class SoldOut {
+    constructor() {
+        this.discriminator = 4;
+        this.kind = "SoldOut";
+    }
+    toJSON() {
+        return {
+            kind: "SoldOut",
+        };
+    }
+    toEncodable() {
+        return {
+            SoldOut: {},
+        };
+    }
+}
+SoldOut.discriminator = 4;
+SoldOut.kind = "SoldOut";
+export class None {
+    constructor() {
+        this.discriminator = 5;
+        this.kind = "None";
+    }
+    toJSON() {
+        return {
+            kind: "None",
+        };
+    }
+    toEncodable() {
+        return {
+            None: {},
+        };
+    }
+}
+None.discriminator = 5;
+None.kind = "None";
+export class NotReady {
+    constructor() {
+        this.discriminator = 6;
+        this.kind = "NotReady";
+    }
+    toJSON() {
+        return {
+            kind: "NotReady",
+        };
+    }
+    toEncodable() {
+        return {
+            NotReady: {},
+        };
+    }
+}
+NotReady.discriminator = 6;
+NotReady.kind = "NotReady";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export 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");
+}
+export 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();
+        }
+    }
+}
+export 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/types/types/CardTrack.d.ts

@@ -0,0 +1,31 @@
+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): CardTrack;
+    static toEncodable(fields: CardTrackFields): {
+        supply: number;
+        created: number;
+        state: any;
+    };
+    toJSON(): CardTrackJSON;
+    static fromJSON(obj: CardTrackJSON): CardTrack;
+    toEncodable(): {
+        supply: number;
+        created: number;
+        state: any;
+    };
+}