3land_sdk 1.0.0 → 1.0.2

package/dist/types/instructions/unwrapAndDestroy.js

@@ -0,0 +1,26 @@
+import { TransactionInstruction } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export const layout = borsh.struct([types.UnwrapMetadata.layout("metadata")]);
+export function unwrapAndDestroy(args, accounts, programId = PROGRAM_ID) {
+    const keys = [
+        { pubkey: accounts.itemAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.packAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.currency, isSigner: false, isWritable: false },
+        { pubkey: accounts.splVaultFrom, isSigner: false, isWritable: true },
+        { pubkey: accounts.splVaultTo, isSigner: false, isWritable: true },
+        { pubkey: accounts.merkleTree, isSigner: false, isWritable: false },
+        { pubkey: accounts.owner, isSigner: true, isWritable: false },
+        { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+        { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    ];
+    const identifier = Buffer.from([228, 12, 214, 168, 124, 166, 135, 250]);
+    const buffer = Buffer.alloc(1000);
+    const len = layout.encode({
+        metadata: types.UnwrapMetadata.toEncodable(args.metadata),
+    }, buffer);
+    const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+    const ix = new TransactionInstruction({ keys, programId, data });
+    return ix;
+}

package/dist/types/instructions/updateCard.d.ts

@@ -0,0 +1,16 @@
+import { PublicKey } from "@solana/web3.js";
+import * as types from "../types";
+export interface UpdateCardArgs {
+    supply: number | null;
+    metadata: types.MetadataArgsFields | null;
+    state: types.CardStateKind | null;
+}
+export interface UpdateCardAccounts {
+    packAccount: PublicKey;
+    cardAccount: PublicKey;
+    packContent: PublicKey;
+    creator: PublicKey;
+    systemProgram: PublicKey;
+}
+export declare const layout: any;
+export declare function updateCard(args: UpdateCardArgs, accounts: UpdateCardAccounts, programId?: PublicKey): any;

package/dist/types/instructions/updateCard.js

@@ -0,0 +1,29 @@
+import { TransactionInstruction } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export const layout = borsh.struct([
+    borsh.option(borsh.u32(), "supply"),
+    borsh.option(types.MetadataArgs.layout(), "metadata"),
+    borsh.option(types.CardState.layout(), "state"),
+]);
+export function updateCard(args, accounts, programId = PROGRAM_ID) {
+    const keys = [
+        { pubkey: accounts.packAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.cardAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.packContent, isSigner: false, isWritable: true },
+        { pubkey: accounts.creator, isSigner: true, isWritable: true },
+        { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    ];
+    const identifier = Buffer.from([216, 82, 240, 120, 78, 100, 66, 33]);
+    const buffer = Buffer.alloc(1000);
+    const len = layout.encode({
+        supply: args.supply,
+        metadata: (args.metadata && types.MetadataArgs.toEncodable(args.metadata)) ||
+            null,
+        state: (args.state && args.state.toEncodable()) || null,
+    }, buffer);
+    const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+    const ix = new TransactionInstruction({ keys, programId, data });
+    return ix;
+}

package/dist/types/instructions/updatePack.d.ts

@@ -0,0 +1,22 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import * as types from "../types";
+export interface UpdatePackArgs {
+    supply: BN | null;
+    metadata: types.MetadataArgsFields | null;
+    saleConfig: types.SaleConfigFields | null;
+    state: types.ItemStateKind | null;
+    category: Array<number> | null;
+    packConfig: types.PackConfigFields | null;
+}
+export interface UpdatePackAccounts {
+    storeAccount: PublicKey;
+    packAccount: PublicKey;
+    packContent: PublicKey;
+    packReserveList: PublicKey;
+    prevCreatorRegistry: PublicKey;
+    creator: PublicKey;
+    systemProgram: PublicKey;
+}
+export declare const layout: any;
+export declare function updatePack(args: UpdatePackArgs, accounts: UpdatePackAccounts, programId?: PublicKey): any;

package/dist/types/instructions/updatePack.js

@@ -0,0 +1,39 @@
+import { TransactionInstruction } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export const layout = borsh.struct([
+    borsh.option(borsh.u64(), "supply"),
+    borsh.option(types.MetadataArgs.layout(), "metadata"),
+    borsh.option(types.SaleConfig.layout(), "saleConfig"),
+    borsh.option(types.ItemState.layout(), "state"),
+    borsh.option(borsh.array(borsh.u16(), 3), "category"),
+    borsh.option(types.PackConfig.layout(), "packConfig"),
+]);
+export function updatePack(args, accounts, programId = PROGRAM_ID) {
+    const keys = [
+        { pubkey: accounts.storeAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.packAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.packContent, isSigner: false, isWritable: false },
+        { pubkey: accounts.packReserveList, isSigner: false, isWritable: true },
+        { pubkey: accounts.prevCreatorRegistry, isSigner: false, isWritable: true },
+        { pubkey: accounts.creator, isSigner: true, isWritable: true },
+        { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    ];
+    const identifier = Buffer.from([71, 204, 227, 31, 168, 43, 152, 234]);
+    const buffer = Buffer.alloc(1000);
+    const len = layout.encode({
+        supply: args.supply,
+        metadata: (args.metadata && types.MetadataArgs.toEncodable(args.metadata)) ||
+            null,
+        saleConfig: (args.saleConfig && types.SaleConfig.toEncodable(args.saleConfig)) ||
+            null,
+        state: (args.state && args.state.toEncodable()) || null,
+        category: args.category,
+        packConfig: (args.packConfig && types.PackConfig.toEncodable(args.packConfig)) ||
+            null,
+    }, buffer);
+    const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+    const ix = new TransactionInstruction({ keys, programId, data });
+    return ix;
+}

package/dist/types/instructions/updateSingle.d.ts

@@ -0,0 +1,20 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import * as types from "../types";
+export interface UpdateSingleArgs {
+    supply: BN | null;
+    metadata: types.MetadataArgsFields | null;
+    saleConfig: types.SaleConfigFields | null;
+    state: types.ItemStateKind | null;
+    category: Array<number> | null;
+}
+export interface UpdateSingleAccounts {
+    storeAccount: PublicKey;
+    itemAccount: PublicKey;
+    itemReserveList: PublicKey;
+    prevCreatorRegistry: PublicKey;
+    creator: PublicKey;
+    systemProgram: PublicKey;
+}
+export declare const layout: any;
+export declare function updateSingle(args: UpdateSingleArgs, accounts: UpdateSingleAccounts, programId?: PublicKey): any;

package/dist/types/instructions/updateSingle.js

@@ -0,0 +1,35 @@
+import { TransactionInstruction } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export const layout = borsh.struct([
+    borsh.option(borsh.u64(), "supply"),
+    borsh.option(types.MetadataArgs.layout(), "metadata"),
+    borsh.option(types.SaleConfig.layout(), "saleConfig"),
+    borsh.option(types.ItemState.layout(), "state"),
+    borsh.option(borsh.array(borsh.u16(), 3), "category"),
+]);
+export function updateSingle(args, accounts, programId = PROGRAM_ID) {
+    const keys = [
+        { pubkey: accounts.storeAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.itemAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.itemReserveList, isSigner: false, isWritable: true },
+        { pubkey: accounts.prevCreatorRegistry, isSigner: false, isWritable: true },
+        { pubkey: accounts.creator, isSigner: true, isWritable: true },
+        { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    ];
+    const identifier = Buffer.from([106, 229, 174, 154, 252, 16, 158, 144]);
+    const buffer = Buffer.alloc(1000);
+    const len = layout.encode({
+        supply: args.supply,
+        metadata: (args.metadata && types.MetadataArgs.toEncodable(args.metadata)) ||
+            null,
+        saleConfig: (args.saleConfig && types.SaleConfig.toEncodable(args.saleConfig)) ||
+            null,
+        state: (args.state && args.state.toEncodable()) || null,
+        category: args.category,
+    }, buffer);
+    const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+    const ix = new TransactionInstruction({ keys, programId, data });
+    return ix;
+}

package/dist/types/instructions/updateStore.d.ts

@@ -0,0 +1,14 @@
+import { PublicKey } from "@solana/web3.js";
+import * as types from "../types";
+export interface UpdateStoreArgs {
+    name: string;
+    storeConfig: types.StoreConfigFields;
+}
+export interface UpdateStoreAccounts {
+    holderAccount: PublicKey;
+    storeAccount: PublicKey;
+    creator: PublicKey;
+    systemProgram: PublicKey;
+}
+export declare const layout: any;
+export declare function updateStore(args: UpdateStoreArgs, accounts: UpdateStoreAccounts, programId?: PublicKey): any;

package/dist/types/instructions/updateStore.js

@@ -0,0 +1,25 @@
+import { TransactionInstruction } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export const layout = borsh.struct([
+    borsh.str("name"),
+    types.StoreConfig.layout("storeConfig"),
+]);
+export function updateStore(args, accounts, programId = PROGRAM_ID) {
+    const keys = [
+        { pubkey: accounts.holderAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.storeAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.creator, isSigner: true, isWritable: true },
+        { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    ];
+    const identifier = Buffer.from([169, 49, 137, 251, 233, 234, 172, 103]);
+    const buffer = Buffer.alloc(1000);
+    const len = layout.encode({
+        name: args.name,
+        storeConfig: types.StoreConfig.toEncodable(args.storeConfig),
+    }, buffer);
+    const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+    const ix = new TransactionInstruction({ keys, programId, data });
+    return ix;
+}

package/dist/types/instructions/withdrawFromStore.d.ts

@@ -0,0 +1,7 @@
+import { PublicKey } from "@solana/web3.js";
+export interface WithdrawFromStoreAccounts {
+    storeAccount: PublicKey;
+    creator: PublicKey;
+    systemProgram: PublicKey;
+}
+export declare function withdrawFromStore(accounts: WithdrawFromStoreAccounts, programId?: PublicKey): any;

package/dist/types/instructions/withdrawFromStore.js

@@ -0,0 +1,13 @@
+import { TransactionInstruction } from "@solana/web3.js"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export function withdrawFromStore(accounts, programId = PROGRAM_ID) {
+    const keys = [
+        { pubkey: accounts.storeAccount, isSigner: false, isWritable: true },
+        { pubkey: accounts.creator, isSigner: true, isWritable: true },
+        { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    ];
+    const identifier = Buffer.from([210, 94, 98, 179, 211, 206, 143, 252]);
+    const data = identifier;
+    const ix = new TransactionInstruction({ keys, programId, data });
+    return ix;
+}

package/dist/types/programId.d.ts

@@ -0,0 +1,13 @@
+import { PublicKey } from "@solana/web3.js";
+export declare const PROGRAM_ID_IDL: any;
+export declare const PROGRAM_ID: PublicKey;
+export declare const BUBBLEGUM_PROGRAM_ID: any;
+export declare const DEVNET_PROGRAM_ID: any;
+export declare const PROGRAM_CNFT: any;
+export declare const TOKEN_METADATA_PROGRAM_ID: any;
+export declare const TOKEN_PROGRAM_ID: any;
+export declare const SPL_ACCOUNT_COMPRESSION_PROGRAM_ID: any;
+export declare const SPL_NOOP_PROGRAM_ID: any;
+export declare const PROGRAM_CLAIMZ: any;
+export declare const SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID: any;
+export declare const SOLANA_ENDPOINT = "https://api.devnet.solana.com";

package/dist/types/programId.js

@@ -0,0 +1,16 @@
+import { PublicKey } from "@solana/web3.js";
+import { toPublicKey } from "../utility/PdaManager";
+// Program ID defined in the provided IDL. Do not edit, it will get overwritten.
+export const PROGRAM_ID_IDL = new PublicKey("HgtiJuEcdN6bN6WyYpamL3QKpyMcF8g8FxutDQNB96J9");
+// This constant will not get overwritten on subsequent code generations and it's safe to modify it's value.
+export const PROGRAM_ID = PROGRAM_ID_IDL;
+export const BUBBLEGUM_PROGRAM_ID = toPublicKey("BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY");
+export const DEVNET_PROGRAM_ID = toPublicKey("GyPCu89S63P9NcCQAtuSJesiefhhgpGWrNVJs4bF2cSK");
+export const PROGRAM_CNFT = toPublicKey("HgtiJuEcdN6bN6WyYpamL3QKpyMcF8g8FxutDQNB96J9");
+export const TOKEN_METADATA_PROGRAM_ID = toPublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+export const TOKEN_PROGRAM_ID = toPublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+export const SPL_ACCOUNT_COMPRESSION_PROGRAM_ID = toPublicKey("cmtDvXumGCrqC1Age74AVPhSRVXJMd8PJS91L8KbNCK");
+export const SPL_NOOP_PROGRAM_ID = toPublicKey("noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV");
+export const PROGRAM_CLAIMZ = toPublicKey("52zRX47uXYzpYDmW4PVQTnxjrNhYaCsVEauXm8xF9ARq");
+export const SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID = toPublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+export const SOLANA_ENDPOINT = "https://api.devnet.solana.com";

package/dist/types/types/AccountClass.d.ts

@@ -0,0 +1,368 @@
+import * as types from "../types";
+export interface HolderV1JSON {
+    kind: "HolderV1";
+}
+export declare class HolderV1 {
+    static readonly discriminator = 0;
+    static readonly kind = "HolderV1";
+    readonly discriminator = 0;
+    readonly kind = "HolderV1";
+    toJSON(): HolderV1JSON;
+    toEncodable(): {
+        HolderV1: {};
+    };
+}
+export interface StoreV1JSON {
+    kind: "StoreV1";
+}
+export declare class StoreV1 {
+    static readonly discriminator = 1;
+    static readonly kind = "StoreV1";
+    readonly discriminator = 1;
+    readonly kind = "StoreV1";
+    toJSON(): StoreV1JSON;
+    toEncodable(): {
+        StoreV1: {};
+    };
+}
+export interface SingleV1JSON {
+    kind: "SingleV1";
+}
+export declare class SingleV1 {
+    static readonly discriminator = 2;
+    static readonly kind = "SingleV1";
+    readonly discriminator = 2;
+    readonly kind = "SingleV1";
+    toJSON(): SingleV1JSON;
+    toEncodable(): {
+        SingleV1: {};
+    };
+}
+export interface PackV1JSON {
+    kind: "PackV1";
+}
+export declare class PackV1 {
+    static readonly discriminator = 3;
+    static readonly kind = "PackV1";
+    readonly discriminator = 3;
+    readonly kind = "PackV1";
+    toJSON(): PackV1JSON;
+    toEncodable(): {
+        PackV1: {};
+    };
+}
+export interface CardV1JSON {
+    kind: "CardV1";
+}
+export declare class CardV1 {
+    static readonly discriminator = 4;
+    static readonly kind = "CardV1";
+    readonly discriminator = 4;
+    readonly kind = "CardV1";
+    toJSON(): CardV1JSON;
+    toEncodable(): {
+        CardV1: {};
+    };
+}
+export interface PackReceiptV1JSON {
+    kind: "PackReceiptV1";
+}
+export declare class PackReceiptV1 {
+    static readonly discriminator = 5;
+    static readonly kind = "PackReceiptV1";
+    readonly discriminator = 5;
+    readonly kind = "PackReceiptV1";
+    toJSON(): PackReceiptV1JSON;
+    toEncodable(): {
+        PackReceiptV1: {};
+    };
+}
+export interface PackContentV1JSON {
+    kind: "PackContentV1";
+}
+export declare class PackContentV1 {
+    static readonly discriminator = 6;
+    static readonly kind = "PackContentV1";
+    readonly discriminator = 6;
+    readonly kind = "PackContentV1";
+    toJSON(): PackContentV1JSON;
+    toEncodable(): {
+        PackContentV1: {};
+    };
+}
+export interface PackOpenHolderV1JSON {
+    kind: "PackOpenHolderV1";
+}
+export declare class PackOpenHolderV1 {
+    static readonly discriminator = 7;
+    static readonly kind = "PackOpenHolderV1";
+    readonly discriminator = 7;
+    readonly kind = "PackOpenHolderV1";
+    toJSON(): PackOpenHolderV1JSON;
+    toEncodable(): {
+        PackOpenHolderV1: {};
+    };
+}
+export interface BuyTrackV1JSON {
+    kind: "BuyTrackV1";
+}
+export declare class BuyTrackV1 {
+    static readonly discriminator = 8;
+    static readonly kind = "BuyTrackV1";
+    readonly discriminator = 8;
+    readonly kind = "BuyTrackV1";
+    toJSON(): BuyTrackV1JSON;
+    toEncodable(): {
+        BuyTrackV1: {};
+    };
+}
+export interface SingleArchiveV1JSON {
+    kind: "SingleArchiveV1";
+}
+export declare class SingleArchiveV1 {
+    static readonly discriminator = 9;
+    static readonly kind = "SingleArchiveV1";
+    readonly discriminator = 9;
+    readonly kind = "SingleArchiveV1";
+    toJSON(): SingleArchiveV1JSON;
+    toEncodable(): {
+        SingleArchiveV1: {};
+    };
+}
+export interface PackArchiveV1JSON {
+    kind: "PackArchiveV1";
+}
+export declare class PackArchiveV1 {
+    static readonly discriminator = 10;
+    static readonly kind = "PackArchiveV1";
+    readonly discriminator = 10;
+    readonly kind = "PackArchiveV1";
+    toJSON(): PackArchiveV1JSON;
+    toEncodable(): {
+        PackArchiveV1: {};
+    };
+}
+export interface NoneJSON {
+    kind: "None";
+}
+export declare class None {
+    static readonly discriminator = 11;
+    static readonly kind = "None";
+    readonly discriminator = 11;
+    readonly kind = "None";
+    toJSON(): NoneJSON;
+    toEncodable(): {
+        None: {};
+    };
+}
+export interface CreatorRegistryV1JSON {
+    kind: "CreatorRegistryV1";
+}
+export declare class CreatorRegistryV1 {
+    static readonly discriminator = 12;
+    static readonly kind = "CreatorRegistryV1";
+    readonly discriminator = 12;
+    readonly kind = "CreatorRegistryV1";
+    toJSON(): CreatorRegistryV1JSON;
+    toEncodable(): {
+        CreatorRegistryV1: {};
+    };
+}
+export interface CollectorGlobalRegistryV1JSON {
+    kind: "CollectorGlobalRegistryV1";
+}
+export declare class CollectorGlobalRegistryV1 {
+    static readonly discriminator = 13;
+    static readonly kind = "CollectorGlobalRegistryV1";
+    readonly discriminator = 13;
+    readonly kind = "CollectorGlobalRegistryV1";
+    toJSON(): CollectorGlobalRegistryV1JSON;
+    toEncodable(): {
+        CollectorGlobalRegistryV1: {};
+    };
+}
+export interface CollectorArtistRegistryV1JSON {
+    kind: "CollectorArtistRegistryV1";
+}
+export declare class CollectorArtistRegistryV1 {
+    static readonly discriminator = 14;
+    static readonly kind = "CollectorArtistRegistryV1";
+    readonly discriminator = 14;
+    readonly kind = "CollectorArtistRegistryV1";
+    toJSON(): CollectorArtistRegistryV1JSON;
+    toEncodable(): {
+        CollectorArtistRegistryV1: {};
+    };
+}
+export interface PackTraitsV1JSON {
+    kind: "PackTraitsV1";
+}
+export declare class PackTraitsV1 {
+    static readonly discriminator = 15;
+    static readonly kind = "PackTraitsV1";
+    readonly discriminator = 15;
+    readonly kind = "PackTraitsV1";
+    toJSON(): PackTraitsV1JSON;
+    toEncodable(): {
+        PackTraitsV1: {};
+    };
+}
+export interface PackUploadsV1JSON {
+    kind: "PackUploadsV1";
+}
+export declare class PackUploadsV1 {
+    static readonly discriminator = 16;
+    static readonly kind = "PackUploadsV1";
+    readonly discriminator = 16;
+    readonly kind = "PackUploadsV1";
+    toJSON(): PackUploadsV1JSON;
+    toEncodable(): {
+        PackUploadsV1: {};
+    };
+}
+export interface ZeroOpenHolderV1JSON {
+    kind: "ZeroOpenHolderV1";
+}
+export declare class ZeroOpenHolderV1 {
+    static readonly discriminator = 17;
+    static readonly kind = "ZeroOpenHolderV1";
+    readonly discriminator = 17;
+    readonly kind = "ZeroOpenHolderV1";
+    toJSON(): ZeroOpenHolderV1JSON;
+    toEncodable(): {
+        ZeroOpenHolderV1: {};
+    };
+}
+export interface BurnDepositV1JSON {
+    kind: "BurnDepositV1";
+}
+export declare class BurnDepositV1 {
+    static readonly discriminator = 18;
+    static readonly kind = "BurnDepositV1";
+    readonly discriminator = 18;
+    readonly kind = "BurnDepositV1";
+    toJSON(): BurnDepositV1JSON;
+    toEncodable(): {
+        BurnDepositV1: {};
+    };
+}
+export interface GlobalBurnTrackV1JSON {
+    kind: "GlobalBurnTrackV1";
+}
+export declare class GlobalBurnTrackV1 {
+    static readonly discriminator = 19;
+    static readonly kind = "GlobalBurnTrackV1";
+    readonly discriminator = 19;
+    readonly kind = "GlobalBurnTrackV1";
+    toJSON(): GlobalBurnTrackV1JSON;
+    toEncodable(): {
+        GlobalBurnTrackV1: {};
+    };
+}
+export interface ArtistBurnTrackV1JSON {
+    kind: "ArtistBurnTrackV1";
+}
+export declare class ArtistBurnTrackV1 {
+    static readonly discriminator = 20;
+    static readonly kind = "ArtistBurnTrackV1";
+    readonly discriminator = 20;
+    readonly kind = "ArtistBurnTrackV1";
+    toJSON(): ArtistBurnTrackV1JSON;
+    toEncodable(): {
+        ArtistBurnTrackV1: {};
+    };
+}
+export interface SecureHolderV1JSON {
+    kind: "SecureHolderV1";
+}
+export declare class SecureHolderV1 {
+    static readonly discriminator = 21;
+    static readonly kind = "SecureHolderV1";
+    readonly discriminator = 21;
+    readonly kind = "SecureHolderV1";
+    toJSON(): SecureHolderV1JSON;
+    toEncodable(): {
+        SecureHolderV1: {};
+    };
+}
+export interface RevealerForMeV1JSON {
+    kind: "RevealerForMeV1";
+}
+export declare class RevealerForMeV1 {
+    static readonly discriminator = 22;
+    static readonly kind = "RevealerForMeV1";
+    readonly discriminator = 22;
+    readonly kind = "RevealerForMeV1";
+    toJSON(): RevealerForMeV1JSON;
+    toEncodable(): {
+        RevealerForMeV1: {};
+    };
+}
+export interface ThreeIdV1JSON {
+    kind: "ThreeIdV1";
+}
+export declare class ThreeIdV1 {
+    static readonly discriminator = 23;
+    static readonly kind = "ThreeIdV1";
+    readonly discriminator = 23;
+    readonly kind = "ThreeIdV1";
+    toJSON(): ThreeIdV1JSON;
+    toEncodable(): {
+        ThreeIdV1: {};
+    };
+}
+export interface DonationRegistryV1JSON {
+    kind: "DonationRegistryV1";
+}
+export declare class DonationRegistryV1 {
+    static readonly discriminator = 24;
+    static readonly kind = "DonationRegistryV1";
+    readonly discriminator = 24;
+    readonly kind = "DonationRegistryV1";
+    toJSON(): DonationRegistryV1JSON;
+    toEncodable(): {
+        DonationRegistryV1: {};
+    };
+}
+export interface PoolVaultV1JSON {
+    kind: "PoolVaultV1";
+}
+export declare class PoolVaultV1 {
+    static readonly discriminator = 25;
+    static readonly kind = "PoolVaultV1";
+    readonly discriminator = 25;
+    readonly kind = "PoolVaultV1";
+    toJSON(): PoolVaultV1JSON;
+    toEncodable(): {
+        PoolVaultV1: {};
+    };
+}
+export interface GenericUserV1JSON {
+    kind: "GenericUserV1";
+}
+export declare class GenericUserV1 {
+    static readonly discriminator = 26;
+    static readonly kind = "GenericUserV1";
+    readonly discriminator = 26;
+    readonly kind = "GenericUserV1";
+    toJSON(): GenericUserV1JSON;
+    toEncodable(): {
+        GenericUserV1: {};
+    };
+}
+export interface TokenManagerV1JSON {
+    kind: "TokenManagerV1";
+}
+export declare class TokenManagerV1 {
+    static readonly discriminator = 27;
+    static readonly kind = "TokenManagerV1";
+    readonly discriminator = 27;
+    readonly kind = "TokenManagerV1";
+    toJSON(): TokenManagerV1JSON;
+    toEncodable(): {
+        TokenManagerV1: {};
+    };
+}
+export declare function fromDecoded(obj: any): types.AccountClassKind;
+export declare function fromJSON(obj: types.AccountClassJSON): types.AccountClassKind;
+export declare function layout(property?: string): any;