3land_sdk 1.0.1 → 1.0.2

package/dist/types/types/FeeType.d.ts

@@ -0,0 +1,43 @@
+import * as types from "../types";
+export interface AllMintsJSON {
+    kind: "AllMints";
+}
+export declare class AllMints {
+    static readonly discriminator = 0;
+    static readonly kind = "AllMints";
+    readonly discriminator = 0;
+    readonly kind = "AllMints";
+    toJSON(): AllMintsJSON;
+    toEncodable(): {
+        AllMints: {};
+    };
+}
+export interface PricedMintsOnlyJSON {
+    kind: "PricedMintsOnly";
+}
+export declare class PricedMintsOnly {
+    static readonly discriminator = 1;
+    static readonly kind = "PricedMintsOnly";
+    readonly discriminator = 1;
+    readonly kind = "PricedMintsOnly";
+    toJSON(): PricedMintsOnlyJSON;
+    toEncodable(): {
+        PricedMintsOnly: {};
+    };
+}
+export interface SkipBurnMintsJSON {
+    kind: "SkipBurnMints";
+}
+export declare class SkipBurnMints {
+    static readonly discriminator = 2;
+    static readonly kind = "SkipBurnMints";
+    readonly discriminator = 2;
+    readonly kind = "SkipBurnMints";
+    toJSON(): SkipBurnMintsJSON;
+    toEncodable(): {
+        SkipBurnMints: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.FeeTypeKind;
+export declare function fromJSON(obj: types.FeeTypeJSON): types.FeeTypeKind;
+export declare function layout(property?: string): any;

package/dist/types/types/FeeType.js

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

package/dist/types/types/FeedingTraits.d.ts

@@ -0,0 +1,21 @@
+import * as types from "../types";
+export interface FeedingTraitsFields {
+    list: Array<types.TraitInitKind>;
+}
+export interface FeedingTraitsJSON {
+    list: Array<types.TraitInitJSON>;
+}
+export declare class FeedingTraits {
+    readonly list: Array<types.TraitInitKind>;
+    constructor(fields: FeedingTraitsFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): FeedingTraits;
+    static toEncodable(fields: FeedingTraitsFields): {
+        list: any[];
+    };
+    toJSON(): FeedingTraitsJSON;
+    static fromJSON(obj: FeedingTraitsJSON): FeedingTraits;
+    toEncodable(): {
+        list: any[];
+    };
+}

package/dist/types/types/FeedingTraits.js

@@ -0,0 +1,34 @@
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh";
+export class FeedingTraits {
+    constructor(fields) {
+        this.list = fields.list;
+    }
+    static layout(property) {
+        return borsh.struct([borsh.vec(types.TraitInit.layout(), "list")], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new FeedingTraits({
+            list: obj.list.map((item /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.TraitInit.fromDecoded(item)),
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            list: fields.list.map((item) => item.toEncodable()),
+        };
+    }
+    toJSON() {
+        return {
+            list: this.list.map((item) => item.toJSON()),
+        };
+    }
+    static fromJSON(obj) {
+        return new FeedingTraits({
+            list: obj.list.map((item) => types.TraitInit.fromJSON(item)),
+        });
+    }
+    toEncodable() {
+        return FeedingTraits.toEncodable(this);
+    }
+}

package/dist/types/types/Filter.d.ts

@@ -0,0 +1,26 @@
+import * as types from "../types";
+export interface FilterFields {
+    filter1: types.FilterTypeKind;
+    filter2: types.FilterTypeKind;
+}
+export interface FilterJSON {
+    filter1: types.FilterTypeJSON;
+    filter2: types.FilterTypeJSON;
+}
+export declare class Filter {
+    readonly filter1: types.FilterTypeKind;
+    readonly filter2: types.FilterTypeKind;
+    constructor(fields: FilterFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): Filter;
+    static toEncodable(fields: FilterFields): {
+        filter1: any;
+        filter2: any;
+    };
+    toJSON(): FilterJSON;
+    static fromJSON(obj: FilterJSON): Filter;
+    toEncodable(): {
+        filter1: any;
+        filter2: any;
+    };
+}

package/dist/types/types/Filter.js

@@ -0,0 +1,39 @@
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh";
+export class Filter {
+    constructor(fields) {
+        this.filter1 = fields.filter1;
+        this.filter2 = fields.filter2;
+    }
+    static layout(property) {
+        return borsh.struct([types.FilterType.layout("filter1"), types.FilterType.layout("filter2")], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new Filter({
+            filter1: types.FilterType.fromDecoded(obj.filter1),
+            filter2: types.FilterType.fromDecoded(obj.filter2),
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            filter1: fields.filter1.toEncodable(),
+            filter2: fields.filter2.toEncodable(),
+        };
+    }
+    toJSON() {
+        return {
+            filter1: this.filter1.toJSON(),
+            filter2: this.filter2.toJSON(),
+        };
+    }
+    static fromJSON(obj) {
+        return new Filter({
+            filter1: types.FilterType.fromJSON(obj.filter1),
+            filter2: types.FilterType.fromJSON(obj.filter2),
+        });
+    }
+    toEncodable() {
+        return Filter.toEncodable(this);
+    }
+}

package/dist/types/types/FilterType.d.ts

@@ -0,0 +1,17 @@
+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 declare function fromDecoded(obj: any): types.FilterTypeKind;
+export declare function fromJSON(obj: types.FilterTypeJSON): types.FilterTypeKind;
+export declare function layout(property?: string): any;

package/dist/types/types/FilterType.js

@@ -0,0 +1,43 @@
+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";
+// 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();
+    }
+    throw new Error("Invalid enum object");
+}
+export function fromJSON(obj) {
+    switch (obj.kind) {
+        case "None": {
+            return new None();
+        }
+    }
+}
+export function layout(property) {
+    const ret = borsh.rustEnum([borsh.struct([], "None")]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

package/dist/types/types/GeneralStore.d.ts

@@ -0,0 +1,17 @@
+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 declare function fromDecoded(obj: any): types.GeneralStoreKind;
+export declare function fromJSON(obj: types.GeneralStoreJSON): types.GeneralStoreKind;
+export declare function layout(property?: string): any;

package/dist/types/types/GeneralStore.js

@@ -0,0 +1,43 @@
+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";
+// 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();
+    }
+    throw new Error("Invalid enum object");
+}
+export function fromJSON(obj) {
+    switch (obj.kind) {
+        case "None": {
+            return new None();
+        }
+    }
+}
+export function layout(property) {
+    const ret = borsh.rustEnum([borsh.struct([], "None")]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

package/dist/types/types/GenericStore.d.ts

@@ -0,0 +1,26 @@
+import * as types from "../types";
+export interface GenericStoreFields {
+    storeType: number;
+    data: types.GenericValueKind;
+}
+export interface GenericStoreJSON {
+    storeType: number;
+    data: types.GenericValueJSON;
+}
+export declare class GenericStore {
+    readonly storeType: number;
+    readonly data: types.GenericValueKind;
+    constructor(fields: GenericStoreFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): GenericStore;
+    static toEncodable(fields: GenericStoreFields): {
+        storeType: number;
+        data: any;
+    };
+    toJSON(): GenericStoreJSON;
+    static fromJSON(obj: GenericStoreJSON): GenericStore;
+    toEncodable(): {
+        storeType: number;
+        data: any;
+    };
+}

package/dist/types/types/GenericStore.js

@@ -0,0 +1,39 @@
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh";
+export class GenericStore {
+    constructor(fields) {
+        this.storeType = fields.storeType;
+        this.data = fields.data;
+    }
+    static layout(property) {
+        return borsh.struct([borsh.u16("storeType"), types.GenericValue.layout("data")], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new GenericStore({
+            storeType: obj.storeType,
+            data: types.GenericValue.fromDecoded(obj.data),
+        });
+    }
+    static toEncodable(fields) {
+        return {
+            storeType: fields.storeType,
+            data: fields.data.toEncodable(),
+        };
+    }
+    toJSON() {
+        return {
+            storeType: this.storeType,
+            data: this.data.toJSON(),
+        };
+    }
+    static fromJSON(obj) {
+        return new GenericStore({
+            storeType: obj.storeType,
+            data: types.GenericValue.fromJSON(obj.data),
+        });
+    }
+    toEncodable() {
+        return GenericStore.toEncodable(this);
+    }
+}

package/dist/types/types/GenericValue.d.ts

@@ -0,0 +1,71 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+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 type KeyFields = {
+    value: PublicKey;
+};
+export type KeyValue = {
+    value: PublicKey;
+};
+export interface KeyJSON {
+    kind: "Key";
+    value: {
+        value: string;
+    };
+}
+export declare class Key {
+    static readonly discriminator = 1;
+    static readonly kind = "Key";
+    readonly discriminator = 1;
+    readonly kind = "Key";
+    readonly value: KeyValue;
+    constructor(value: KeyFields);
+    toJSON(): KeyJSON;
+    toEncodable(): {
+        Key: {
+            value: PublicKey;
+        };
+    };
+}
+export type EightBytesFields = {
+    value: BN;
+};
+export type EightBytesValue = {
+    value: BN;
+};
+export interface EightBytesJSON {
+    kind: "EightBytes";
+    value: {
+        value: string;
+    };
+}
+export declare class EightBytes {
+    static readonly discriminator = 2;
+    static readonly kind = "EightBytes";
+    readonly discriminator = 2;
+    readonly kind = "EightBytes";
+    readonly value: EightBytesValue;
+    constructor(value: EightBytesFields);
+    toJSON(): EightBytesJSON;
+    toEncodable(): {
+        EightBytes: {
+            value: BN;
+        };
+    };
+}
+export declare function fromDecoded(obj: any): types.GenericValueKind;
+export declare function fromJSON(obj: types.GenericValueJSON): types.GenericValueKind;
+export declare function layout(property?: string): any;

package/dist/types/types/GenericValue.js

@@ -0,0 +1,123 @@
+import { PublicKey } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+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 Key {
+    constructor(value) {
+        this.discriminator = 1;
+        this.kind = "Key";
+        this.value = {
+            value: value.value,
+        };
+    }
+    toJSON() {
+        return {
+            kind: "Key",
+            value: {
+                value: this.value.value.toString(),
+            },
+        };
+    }
+    toEncodable() {
+        return {
+            Key: {
+                value: this.value.value,
+            },
+        };
+    }
+}
+Key.discriminator = 1;
+Key.kind = "Key";
+export class EightBytes {
+    constructor(value) {
+        this.discriminator = 2;
+        this.kind = "EightBytes";
+        this.value = {
+            value: value.value,
+        };
+    }
+    toJSON() {
+        return {
+            kind: "EightBytes",
+            value: {
+                value: this.value.value.toString(),
+            },
+        };
+    }
+    toEncodable() {
+        return {
+            EightBytes: {
+                value: this.value.value,
+            },
+        };
+    }
+}
+EightBytes.discriminator = 2;
+EightBytes.kind = "EightBytes";
+// 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 ("Key" in obj) {
+        const val = obj["Key"];
+        return new Key({
+            value: val["value"],
+        });
+    }
+    if ("EightBytes" in obj) {
+        const val = obj["EightBytes"];
+        return new EightBytes({
+            value: val["value"],
+        });
+    }
+    throw new Error("Invalid enum object");
+}
+export function fromJSON(obj) {
+    switch (obj.kind) {
+        case "None": {
+            return new None();
+        }
+        case "Key": {
+            return new Key({
+                value: new PublicKey(obj.value.value),
+            });
+        }
+        case "EightBytes": {
+            return new EightBytes({
+                value: new BN(obj.value.value),
+            });
+        }
+    }
+}
+export function layout(property) {
+    const ret = borsh.rustEnum([
+        borsh.struct([], "None"),
+        borsh.struct([borsh.publicKey("value")], "Key"),
+        borsh.struct([borsh.u64("value")], "EightBytes"),
+    ]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

package/dist/types/types/GlobalFee.d.ts

@@ -0,0 +1,38 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import * as types from "../types";
+export interface GlobalFeeFields {
+    delegate: PublicKey;
+    fee: BN;
+    feePercentage: number;
+    feeType: types.FeeTypeKind;
+}
+export interface GlobalFeeJSON {
+    delegate: string;
+    fee: string;
+    feePercentage: number;
+    feeType: types.FeeTypeJSON;
+}
+export declare class GlobalFee {
+    readonly delegate: PublicKey;
+    readonly fee: BN;
+    readonly feePercentage: number;
+    readonly feeType: types.FeeTypeKind;
+    constructor(fields: GlobalFeeFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): GlobalFee;
+    static toEncodable(fields: GlobalFeeFields): {
+        delegate: PublicKey;
+        fee: BN;
+        feePercentage: number;
+        feeType: any;
+    };
+    toJSON(): GlobalFeeJSON;
+    static fromJSON(obj: GlobalFeeJSON): GlobalFee;
+    toEncodable(): {
+        delegate: PublicKey;
+        fee: BN;
+        feePercentage: number;
+        feeType: any;
+    };
+}