3land_sdk 1.0.0 → 1.0.2

package/dist/types/types/TimeRangeType.d.ts

@@ -0,0 +1,43 @@
+import * as types from "../types";
+export interface BetweenHoursJSON {
+    kind: "BetweenHours";
+}
+export declare class BetweenHours {
+    static readonly discriminator = 0;
+    static readonly kind = "BetweenHours";
+    readonly discriminator = 0;
+    readonly kind = "BetweenHours";
+    toJSON(): BetweenHoursJSON;
+    toEncodable(): {
+        BetweenHours: {};
+    };
+}
+export interface BetweenDaysJSON {
+    kind: "BetweenDays";
+}
+export declare class BetweenDays {
+    static readonly discriminator = 1;
+    static readonly kind = "BetweenDays";
+    readonly discriminator = 1;
+    readonly kind = "BetweenDays";
+    toJSON(): BetweenDaysJSON;
+    toEncodable(): {
+        BetweenDays: {};
+    };
+}
+export interface BetweenHoursNegateJSON {
+    kind: "BetweenHoursNegate";
+}
+export declare class BetweenHoursNegate {
+    static readonly discriminator = 2;
+    static readonly kind = "BetweenHoursNegate";
+    readonly discriminator = 2;
+    readonly kind = "BetweenHoursNegate";
+    toJSON(): BetweenHoursNegateJSON;
+    toEncodable(): {
+        BetweenHoursNegate: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.TimeRangeTypeKind;
+export declare function fromJSON(obj: types.TimeRangeTypeJSON): types.TimeRangeTypeKind;
+export declare function layout(property?: string): any;

package/dist/types/types/TimeRangeType.js

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

package/dist/types/types/TimedPerWalletArgs.d.ts

@@ -0,0 +1,20 @@
+export interface TimedPerWalletArgsFields {
+    amount: number;
+}
+export interface TimedPerWalletArgsJSON {
+    amount: number;
+}
+export declare class TimedPerWalletArgs {
+    readonly amount: number;
+    constructor(fields: TimedPerWalletArgsFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): TimedPerWalletArgs;
+    static toEncodable(fields: TimedPerWalletArgsFields): {
+        amount: number;
+    };
+    toJSON(): TimedPerWalletArgsJSON;
+    static fromJSON(obj: TimedPerWalletArgsJSON): TimedPerWalletArgs;
+    toEncodable(): {
+        amount: number;
+    };
+}

package/dist/types/types/TimedPerWalletArgs.js

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

package/dist/types/types/TokenMetadata.d.ts

@@ -0,0 +1,30 @@
+export interface TokenMetadataFields {
+    name: string;
+    symbol: string;
+    arweave: string;
+}
+export interface TokenMetadataJSON {
+    name: string;
+    symbol: string;
+    arweave: string;
+}
+export declare class TokenMetadata {
+    readonly name: string;
+    readonly symbol: string;
+    readonly arweave: string;
+    constructor(fields: TokenMetadataFields);
+    static layout(property?: string): any;
+    static fromDecoded(obj: any): TokenMetadata;
+    static toEncodable(fields: TokenMetadataFields): {
+        name: string;
+        symbol: string;
+        arweave: string;
+    };
+    toJSON(): TokenMetadataJSON;
+    static fromJSON(obj: TokenMetadataJSON): TokenMetadata;
+    toEncodable(): {
+        name: string;
+        symbol: string;
+        arweave: string;
+    };
+}

package/dist/types/types/TokenMetadata.js

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

package/dist/types/types/TokenProgramVersion.d.ts

@@ -0,0 +1,30 @@
+import * as types from "../types";
+export interface OriginalJSON {
+    kind: "Original";
+}
+export declare class Original {
+    static readonly discriminator = 0;
+    static readonly kind = "Original";
+    readonly discriminator = 0;
+    readonly kind = "Original";
+    toJSON(): OriginalJSON;
+    toEncodable(): {
+        Original: {};
+    };
+}
+export interface Token2022JSON {
+    kind: "Token2022";
+}
+export declare class Token2022 {
+    static readonly discriminator = 1;
+    static readonly kind = "Token2022";
+    readonly discriminator = 1;
+    readonly kind = "Token2022";
+    toJSON(): Token2022JSON;
+    toEncodable(): {
+        Token2022: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.TokenProgramVersionKind;
+export declare function fromJSON(obj: types.TokenProgramVersionJSON): types.TokenProgramVersionKind;
+export declare function layout(property?: string): any;

package/dist/types/types/TokenProgramVersion.js

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

package/dist/types/types/TokenStandard.d.ts

@@ -0,0 +1,56 @@
+import * as types from "../types";
+export interface NonFungibleJSON {
+    kind: "NonFungible";
+}
+export declare class NonFungible {
+    static readonly discriminator = 0;
+    static readonly kind = "NonFungible";
+    readonly discriminator = 0;
+    readonly kind = "NonFungible";
+    toJSON(): NonFungibleJSON;
+    toEncodable(): {
+        NonFungible: {};
+    };
+}
+export interface FungibleAssetJSON {
+    kind: "FungibleAsset";
+}
+export declare class FungibleAsset {
+    static readonly discriminator = 1;
+    static readonly kind = "FungibleAsset";
+    readonly discriminator = 1;
+    readonly kind = "FungibleAsset";
+    toJSON(): FungibleAssetJSON;
+    toEncodable(): {
+        FungibleAsset: {};
+    };
+}
+export interface FungibleJSON {
+    kind: "Fungible";
+}
+export declare class Fungible {
+    static readonly discriminator = 2;
+    static readonly kind = "Fungible";
+    readonly discriminator = 2;
+    readonly kind = "Fungible";
+    toJSON(): FungibleJSON;
+    toEncodable(): {
+        Fungible: {};
+    };
+}
+export interface NonFungibleEditionJSON {
+    kind: "NonFungibleEdition";
+}
+export declare class NonFungibleEdition {
+    static readonly discriminator = 3;
+    static readonly kind = "NonFungibleEdition";
+    readonly discriminator = 3;
+    readonly kind = "NonFungibleEdition";
+    toJSON(): NonFungibleEditionJSON;
+    toEncodable(): {
+        NonFungibleEdition: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.TokenStandardKind;
+export declare function fromJSON(obj: types.TokenStandardJSON): types.TokenStandardKind;
+export declare function layout(property?: string): any;

package/dist/types/types/TokenStandard.js

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

package/dist/types/types/TokenState.d.ts

@@ -0,0 +1,30 @@
+import * as types from "../types";
+export interface NewJSON {
+    kind: "New";
+}
+export declare class New {
+    static readonly discriminator = 0;
+    static readonly kind = "New";
+    readonly discriminator = 0;
+    readonly kind = "New";
+    toJSON(): NewJSON;
+    toEncodable(): {
+        New: {};
+    };
+}
+export interface ActiveJSON {
+    kind: "Active";
+}
+export declare class Active {
+    static readonly discriminator = 1;
+    static readonly kind = "Active";
+    readonly discriminator = 1;
+    readonly kind = "Active";
+    toJSON(): ActiveJSON;
+    toEncodable(): {
+        Active: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.TokenStateKind;
+export declare function fromJSON(obj: types.TokenStateJSON): types.TokenStateKind;
+export declare function layout(property?: string): any;

package/dist/types/types/TokenState.js

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

package/dist/types/types/TokenType.d.ts

@@ -0,0 +1,30 @@
+import * as types from "../types";
+export interface BasicJSON {
+    kind: "Basic";
+}
+export declare class Basic {
+    static readonly discriminator = 0;
+    static readonly kind = "Basic";
+    readonly discriminator = 0;
+    readonly kind = "Basic";
+    toJSON(): BasicJSON;
+    toEncodable(): {
+        Basic: {};
+    };
+}
+export interface OnlyUpJSON {
+    kind: "OnlyUp";
+}
+export declare class OnlyUp {
+    static readonly discriminator = 1;
+    static readonly kind = "OnlyUp";
+    readonly discriminator = 1;
+    readonly kind = "OnlyUp";
+    toJSON(): OnlyUpJSON;
+    toEncodable(): {
+        OnlyUp: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.TokenTypeKind;
+export declare function fromJSON(obj: types.TokenTypeJSON): types.TokenTypeKind;
+export declare function layout(property?: string): any;