3land_sdk 1.0.2 → 1.0.3

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

@@ -1,43 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,120 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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;