3land_sdk 1.0.1 → 1.0.2

package/dist/types/types/DepositState.d.ts

@@ -0,0 +1,30 @@
+import * as types from "../types";
+export interface AvailableJSON {
+    kind: "Available";
+}
+export declare class Available {
+    static readonly discriminator = 0;
+    static readonly kind = "Available";
+    readonly discriminator = 0;
+    readonly kind = "Available";
+    toJSON(): AvailableJSON;
+    toEncodable(): {
+        Available: {};
+    };
+}
+export interface BurningJSON {
+    kind: "Burning";
+}
+export declare class Burning {
+    static readonly discriminator = 1;
+    static readonly kind = "Burning";
+    readonly discriminator = 1;
+    readonly kind = "Burning";
+    toJSON(): BurningJSON;
+    toEncodable(): {
+        Burning: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.DepositStateKind;
+export declare function fromJSON(obj: types.DepositStateJSON): types.DepositStateKind;
+export declare function layout(property?: string): any;

package/dist/types/types/DepositState.js

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

package/dist/types/types/DepositSubtype.d.ts

@@ -0,0 +1,30 @@
+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 ThreeJSON {
+    kind: "Three";
+}
+export declare class Three {
+    static readonly discriminator = 1;
+    static readonly kind = "Three";
+    readonly discriminator = 1;
+    readonly kind = "Three";
+    toJSON(): ThreeJSON;
+    toEncodable(): {
+        Three: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.DepositSubtypeKind;
+export declare function fromJSON(obj: types.DepositSubtypeJSON): types.DepositSubtypeKind;
+export declare function layout(property?: string): any;

package/dist/types/types/DepositSubtype.js

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

package/dist/types/types/DepositTrack.d.ts

@@ -0,0 +1,26 @@
+import * as types from "../types";
+export interface DepositTrackFields {
+    depositTrackType: types.DepositTrackTypeKind;
+    depositState: types.DepositStateKind;
+}
+export interface DepositTrackJSON {
+    depositTrackType: types.DepositTrackTypeJSON;
+    depositState: types.DepositStateJSON;
+}
+export declare class DepositTrack {
+    readonly depositTrackType: types.DepositTrackTypeKind;
+    readonly depositState: types.DepositStateKind;
+    constructor(fields: DepositTrackFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): DepositTrack;
+    static toEncodable(fields: DepositTrackFields): {
+        depositTrackType: any;
+        depositState: any;
+    };
+    toJSON(): DepositTrackJSON;
+    static fromJSON(obj: DepositTrackJSON): DepositTrack;
+    toEncodable(): {
+        depositTrackType: any;
+        depositState: any;
+    };
+}

package/dist/types/types/DepositTrack.js

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

package/dist/types/types/DepositTrackType.d.ts

@@ -0,0 +1,43 @@
+import * as types from "../types";
+export interface CreatorJSON {
+    kind: "Creator";
+}
+export declare class Creator {
+    static readonly discriminator = 0;
+    static readonly kind = "Creator";
+    readonly discriminator = 0;
+    readonly kind = "Creator";
+    toJSON(): CreatorJSON;
+    toEncodable(): {
+        Creator: {};
+    };
+}
+export interface PdaCreatorJSON {
+    kind: "PdaCreator";
+}
+export declare class PdaCreator {
+    static readonly discriminator = 1;
+    static readonly kind = "PdaCreator";
+    readonly discriminator = 1;
+    readonly kind = "PdaCreator";
+    toJSON(): PdaCreatorJSON;
+    toEncodable(): {
+        PdaCreator: {};
+    };
+}
+export interface CollectionJSON {
+    kind: "Collection";
+}
+export declare class Collection {
+    static readonly discriminator = 2;
+    static readonly kind = "Collection";
+    readonly discriminator = 2;
+    readonly kind = "Collection";
+    toJSON(): CollectionJSON;
+    toEncodable(): {
+        Collection: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.DepositTrackTypeKind;
+export declare function fromJSON(obj: types.DepositTrackTypeJSON): types.DepositTrackTypeKind;
+export declare function layout(property?: string): any;

package/dist/types/types/DepositTrackType.js

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

package/dist/types/types/DepositType.d.ts

@@ -0,0 +1,90 @@
+import * as types from "../types";
+export type CreatorFields = {
+    creators: Array<types.CreatorFields>;
+};
+export type CreatorValue = {
+    creators: Array<types.Creator>;
+};
+export interface CreatorJSON {
+    kind: "Creator";
+    value: {
+        creators: Array<types.CreatorJSON>;
+    };
+}
+export declare class Creator {
+    static readonly discriminator = 0;
+    static readonly kind = "Creator";
+    readonly discriminator = 0;
+    readonly kind = "Creator";
+    readonly value: CreatorValue;
+    constructor(value: CreatorFields);
+    toJSON(): CreatorJSON;
+    toEncodable(): {
+        Creator: {
+            creators: any[];
+        };
+    };
+}
+export type PdaCreatorFields = {
+    creators: Array<types.CreatorFields>;
+    hasher: types.AccountHasherFields;
+};
+export type PdaCreatorValue = {
+    creators: Array<types.Creator>;
+    hasher: types.AccountHasher;
+};
+export interface PdaCreatorJSON {
+    kind: "PdaCreator";
+    value: {
+        creators: Array<types.CreatorJSON>;
+        hasher: types.AccountHasherJSON;
+    };
+}
+export declare class PdaCreator {
+    static readonly discriminator = 1;
+    static readonly kind = "PdaCreator";
+    readonly discriminator = 1;
+    readonly kind = "PdaCreator";
+    readonly value: PdaCreatorValue;
+    constructor(value: PdaCreatorFields);
+    toJSON(): PdaCreatorJSON;
+    toEncodable(): {
+        PdaCreator: {
+            creators: any[];
+            hasher: any;
+        };
+    };
+}
+export type CollectionFields = {
+    metadata: types.VerifyCollectionMetadataFields;
+    subtype: types.DepositSubtypeKind;
+};
+export type CollectionValue = {
+    metadata: types.VerifyCollectionMetadata;
+    subtype: types.DepositSubtypeKind;
+};
+export interface CollectionJSON {
+    kind: "Collection";
+    value: {
+        metadata: types.VerifyCollectionMetadataJSON;
+        subtype: types.DepositSubtypeJSON;
+    };
+}
+export declare class Collection {
+    static readonly discriminator = 2;
+    static readonly kind = "Collection";
+    readonly discriminator = 2;
+    readonly kind = "Collection";
+    readonly value: CollectionValue;
+    constructor(value: CollectionFields);
+    toJSON(): CollectionJSON;
+    toEncodable(): {
+        Collection: {
+            metadata: any;
+            subtype: any;
+        };
+    };
+}
+export declare function fromDecoded(obj: any): types.DepositTypeKind;
+export declare function fromJSON(obj: types.DepositTypeJSON): types.DepositTypeKind;
+export declare function layout(property?: string): any;

package/dist/types/types/DepositType.js

@@ -0,0 +1,151 @@
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh";
+export class Creator {
+    constructor(value) {
+        this.discriminator = 0;
+        this.kind = "Creator";
+        this.value = {
+            creators: value.creators.map((item) => new types.Creator(Object.assign({}, item))),
+        };
+    }
+    toJSON() {
+        return {
+            kind: "Creator",
+            value: {
+                creators: this.value.creators.map((item) => item.toJSON()),
+            },
+        };
+    }
+    toEncodable() {
+        return {
+            Creator: {
+                creators: this.value.creators.map((item) => types.Creator.toEncodable(item)),
+            },
+        };
+    }
+}
+Creator.discriminator = 0;
+Creator.kind = "Creator";
+export class PdaCreator {
+    constructor(value) {
+        this.discriminator = 1;
+        this.kind = "PdaCreator";
+        this.value = {
+            creators: value.creators.map((item) => new types.Creator(Object.assign({}, item))),
+            hasher: new types.AccountHasher(Object.assign({}, value.hasher)),
+        };
+    }
+    toJSON() {
+        return {
+            kind: "PdaCreator",
+            value: {
+                creators: this.value.creators.map((item) => item.toJSON()),
+                hasher: this.value.hasher.toJSON(),
+            },
+        };
+    }
+    toEncodable() {
+        return {
+            PdaCreator: {
+                creators: this.value.creators.map((item) => types.Creator.toEncodable(item)),
+                hasher: types.AccountHasher.toEncodable(this.value.hasher),
+            },
+        };
+    }
+}
+PdaCreator.discriminator = 1;
+PdaCreator.kind = "PdaCreator";
+export class Collection {
+    constructor(value) {
+        this.discriminator = 2;
+        this.kind = "Collection";
+        this.value = {
+            metadata: new types.VerifyCollectionMetadata(Object.assign({}, value.metadata)),
+            subtype: value.subtype,
+        };
+    }
+    toJSON() {
+        return {
+            kind: "Collection",
+            value: {
+                metadata: this.value.metadata.toJSON(),
+                subtype: this.value.subtype.toJSON(),
+            },
+        };
+    }
+    toEncodable() {
+        return {
+            Collection: {
+                metadata: types.VerifyCollectionMetadata.toEncodable(this.value.metadata),
+                subtype: this.value.subtype.toEncodable(),
+            },
+        };
+    }
+}
+Collection.discriminator = 2;
+Collection.kind = "Collection";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj) {
+    if (typeof obj !== "object") {
+        throw new Error("Invalid enum object");
+    }
+    if ("Creator" in obj) {
+        const val = obj["Creator"];
+        return new Creator({
+            creators: val["creators"].map((item /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.Creator.fromDecoded(item)),
+        });
+    }
+    if ("PdaCreator" in obj) {
+        const val = obj["PdaCreator"];
+        return new PdaCreator({
+            creators: val["creators"].map((item /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.Creator.fromDecoded(item)),
+            hasher: types.AccountHasher.fromDecoded(val["hasher"]),
+        });
+    }
+    if ("Collection" in obj) {
+        const val = obj["Collection"];
+        return new Collection({
+            metadata: types.VerifyCollectionMetadata.fromDecoded(val["metadata"]),
+            subtype: types.DepositSubtype.fromDecoded(val["subtype"]),
+        });
+    }
+    throw new Error("Invalid enum object");
+}
+export function fromJSON(obj) {
+    switch (obj.kind) {
+        case "Creator": {
+            return new Creator({
+                creators: obj.value.creators.map((item) => types.Creator.fromJSON(item)),
+            });
+        }
+        case "PdaCreator": {
+            return new PdaCreator({
+                creators: obj.value.creators.map((item) => types.Creator.fromJSON(item)),
+                hasher: types.AccountHasher.fromJSON(obj.value.hasher),
+            });
+        }
+        case "Collection": {
+            return new Collection({
+                metadata: types.VerifyCollectionMetadata.fromJSON(obj.value.metadata),
+                subtype: types.DepositSubtype.fromJSON(obj.value.subtype),
+            });
+        }
+    }
+}
+export function layout(property) {
+    const ret = borsh.rustEnum([
+        borsh.struct([borsh.vec(types.Creator.layout(), "creators")], "Creator"),
+        borsh.struct([
+            borsh.vec(types.Creator.layout(), "creators"),
+            types.AccountHasher.layout("hasher"),
+        ], "PdaCreator"),
+        borsh.struct([
+            types.VerifyCollectionMetadata.layout("metadata"),
+            types.DepositSubtype.layout("subtype"),
+        ], "Collection"),
+    ]);
+    if (property !== undefined) {
+        return ret.replicate(property);
+    }
+    return ret;
+}

package/dist/types/types/Earnings.d.ts

@@ -0,0 +1,13 @@
+export interface EarningsFields {
+}
+export interface EarningsJSON {
+}
+export declare class Earnings {
+    constructor(fields: EarningsFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): Earnings;
+    static toEncodable(fields: EarningsFields): {};
+    toJSON(): EarningsJSON;
+    static fromJSON(obj: EarningsJSON): Earnings;
+    toEncodable(): {};
+}

package/dist/types/types/Earnings.js

@@ -0,0 +1,23 @@
+import * as borsh from "@coral-xyz/borsh";
+export class Earnings {
+    constructor(fields) { }
+    static layout(property) {
+        return borsh.struct([], property);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromDecoded(obj) {
+        return new Earnings({});
+    }
+    static toEncodable(fields) {
+        return {};
+    }
+    toJSON() {
+        return {};
+    }
+    static fromJSON(obj) {
+        return new Earnings({});
+    }
+    toEncodable() {
+        return Earnings.toEncodable(this);
+    }
+}