3land_sdk 1.0.1 → 1.0.2

package/dist/types/accounts/TokenManager.js

@@ -0,0 +1,150 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.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 class TokenManager {
+    constructor(fields) {
+        this.class = fields.class;
+        this.storeHash = fields.storeHash;
+        this.tokenType = fields.tokenType;
+        this.state = fields.state;
+        this.currency = fields.currency;
+        this.creator = fields.creator;
+        this.communityShare = fields.communityShare;
+        this.name = fields.name;
+        this.base = fields.base;
+        this.price = fields.price;
+        this.supply = fields.supply;
+        this.created = fields.created;
+        this.pool = fields.pool;
+        this.pending = fields.pending;
+        this.taxes = fields.taxes;
+        this.options = fields.options;
+        this.extra = fields.extra;
+    }
+    static fetch(c_1, address_1) {
+        return __awaiter(this, arguments, void 0, function* (c, address, programId = PROGRAM_ID) {
+            const info = yield c.getAccountInfo(address);
+            if (info === null) {
+                return null;
+            }
+            if (!info.owner.equals(programId)) {
+                throw new Error("account doesn't belong to this program");
+            }
+            return this.decode(info.data);
+        });
+    }
+    static fetchMultiple(c_1, addresses_1) {
+        return __awaiter(this, arguments, void 0, function* (c, addresses, programId = PROGRAM_ID) {
+            const infos = yield c.getMultipleAccountsInfo(addresses);
+            return infos.map((info) => {
+                if (info === null) {
+                    return null;
+                }
+                if (!info.owner.equals(programId)) {
+                    throw new Error("account doesn't belong to this program");
+                }
+                return this.decode(info.data);
+            });
+        });
+    }
+    static decode(data) {
+        if (!data.slice(0, 8).equals(TokenManager.discriminator)) {
+            throw new Error("invalid account discriminator");
+        }
+        const dec = TokenManager.layout.decode(data.slice(8));
+        return new TokenManager({
+            class: types.AccountClass.fromDecoded(dec.class),
+            storeHash: dec.storeHash,
+            tokenType: types.TokenType.fromDecoded(dec.tokenType),
+            state: types.TokenState.fromDecoded(dec.state),
+            currency: dec.currency,
+            creator: dec.creator,
+            communityShare: dec.communityShare,
+            name: dec.name,
+            base: dec.base,
+            price: dec.price,
+            supply: dec.supply,
+            created: dec.created,
+            pool: dec.pool,
+            pending: dec.pending,
+            taxes: dec.taxes,
+            options: dec.options,
+            extra: dec.extra,
+        });
+    }
+    toJSON() {
+        return {
+            class: this.class.toJSON(),
+            storeHash: this.storeHash.toString(),
+            tokenType: this.tokenType.toJSON(),
+            state: this.state.toJSON(),
+            currency: this.currency.toString(),
+            creator: this.creator.toString(),
+            communityShare: this.communityShare,
+            name: this.name,
+            base: this.base.toString(),
+            price: this.price.toString(),
+            supply: this.supply.toString(),
+            created: this.created.toString(),
+            pool: this.pool.toString(),
+            pending: this.pending.toString(),
+            taxes: this.taxes,
+            options: this.options,
+            extra: this.extra,
+        };
+    }
+    static fromJSON(obj) {
+        return new TokenManager({
+            class: types.AccountClass.fromJSON(obj.class),
+            storeHash: new BN(obj.storeHash),
+            tokenType: types.TokenType.fromJSON(obj.tokenType),
+            state: types.TokenState.fromJSON(obj.state),
+            currency: new PublicKey(obj.currency),
+            creator: new PublicKey(obj.creator),
+            communityShare: obj.communityShare,
+            name: obj.name,
+            base: new BN(obj.base),
+            price: new BN(obj.price),
+            supply: new BN(obj.supply),
+            created: new BN(obj.created),
+            pool: new BN(obj.pool),
+            pending: new BN(obj.pending),
+            taxes: obj.taxes,
+            options: obj.options,
+            extra: obj.extra,
+        });
+    }
+}
+TokenManager.discriminator = Buffer.from([
+    185, 97, 124, 231, 70, 75, 228, 47,
+]);
+TokenManager.layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    borsh.u64("storeHash"),
+    types.TokenType.layout("tokenType"),
+    types.TokenState.layout("state"),
+    borsh.publicKey("currency"),
+    borsh.publicKey("creator"),
+    borsh.u16("communityShare"),
+    borsh.str("name"),
+    borsh.u64("base"),
+    borsh.u64("price"),
+    borsh.u64("supply"),
+    borsh.u64("created"),
+    borsh.u64("pool"),
+    borsh.u64("pending"),
+    borsh.array(borsh.u16(), 4, "taxes"),
+    borsh.array(borsh.u8(), 8, "options"),
+    borsh.array(borsh.u8(), 64, "extra"),
+]);

package/dist/types/accounts/ZeroCard.d.ts

@@ -0,0 +1,15 @@
+import { PublicKey, Connection } from "@solana/web3.js";
+export interface ZeroCardFields {
+}
+export interface ZeroCardJSON {
+}
+export declare class ZeroCard {
+    static readonly discriminator: Buffer;
+    static readonly layout: any;
+    constructor(fields: ZeroCardFields);
+    static fetch(c: Connection, address: PublicKey, programId?: PublicKey): Promise<ZeroCard | null>;
+    static fetchMultiple(c: Connection, addresses: PublicKey[], programId?: PublicKey): Promise<Array<ZeroCard | null>>;
+    static decode(data: Buffer): ZeroCard;
+    toJSON(): ZeroCardJSON;
+    static fromJSON(obj: ZeroCardJSON): ZeroCard;
+}

package/dist/types/accounts/ZeroCard.js

@@ -0,0 +1,57 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as borsh from "@coral-xyz/borsh"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export class ZeroCard {
+    constructor(fields) { }
+    static fetch(c_1, address_1) {
+        return __awaiter(this, arguments, void 0, function* (c, address, programId = PROGRAM_ID) {
+            const info = yield c.getAccountInfo(address);
+            if (info === null) {
+                return null;
+            }
+            if (!info.owner.equals(programId)) {
+                throw new Error("account doesn't belong to this program");
+            }
+            return this.decode(info.data);
+        });
+    }
+    static fetchMultiple(c_1, addresses_1) {
+        return __awaiter(this, arguments, void 0, function* (c, addresses, programId = PROGRAM_ID) {
+            const infos = yield c.getMultipleAccountsInfo(addresses);
+            return infos.map((info) => {
+                if (info === null) {
+                    return null;
+                }
+                if (!info.owner.equals(programId)) {
+                    throw new Error("account doesn't belong to this program");
+                }
+                return this.decode(info.data);
+            });
+        });
+    }
+    static decode(data) {
+        if (!data.slice(0, 8).equals(ZeroCard.discriminator)) {
+            throw new Error("invalid account discriminator");
+        }
+        const dec = ZeroCard.layout.decode(data.slice(8));
+        return new ZeroCard({});
+    }
+    toJSON() {
+        return {};
+    }
+    static fromJSON(obj) {
+        return new ZeroCard({});
+    }
+}
+ZeroCard.discriminator = Buffer.from([
+    31, 109, 105, 105, 213, 228, 142, 232,
+]);
+ZeroCard.layout = borsh.struct([]);

package/dist/types/accounts/ZeroContent.d.ts

@@ -0,0 +1,18 @@
+import { PublicKey, Connection } from "@solana/web3.js";
+export interface ZeroContentFields {
+    cards: Array<number>;
+}
+export interface ZeroContentJSON {
+    cards: Array<number>;
+}
+export declare class ZeroContent {
+    readonly cards: Array<number>;
+    static readonly discriminator: Buffer;
+    static readonly layout: any;
+    constructor(fields: ZeroContentFields);
+    static fetch(c: Connection, address: PublicKey, programId?: PublicKey): Promise<ZeroContent | null>;
+    static fetchMultiple(c: Connection, addresses: PublicKey[], programId?: PublicKey): Promise<Array<ZeroContent | null>>;
+    static decode(data: Buffer): ZeroContent;
+    toJSON(): ZeroContentJSON;
+    static fromJSON(obj: ZeroContentJSON): ZeroContent;
+}

package/dist/types/accounts/ZeroContent.js

@@ -0,0 +1,67 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as borsh from "@coral-xyz/borsh"; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId";
+export class ZeroContent {
+    constructor(fields) {
+        this.cards = fields.cards;
+    }
+    static fetch(c_1, address_1) {
+        return __awaiter(this, arguments, void 0, function* (c, address, programId = PROGRAM_ID) {
+            const info = yield c.getAccountInfo(address);
+            if (info === null) {
+                return null;
+            }
+            if (!info.owner.equals(programId)) {
+                throw new Error("account doesn't belong to this program");
+            }
+            return this.decode(info.data);
+        });
+    }
+    static fetchMultiple(c_1, addresses_1) {
+        return __awaiter(this, arguments, void 0, function* (c, addresses, programId = PROGRAM_ID) {
+            const infos = yield c.getMultipleAccountsInfo(addresses);
+            return infos.map((info) => {
+                if (info === null) {
+                    return null;
+                }
+                if (!info.owner.equals(programId)) {
+                    throw new Error("account doesn't belong to this program");
+                }
+                return this.decode(info.data);
+            });
+        });
+    }
+    static decode(data) {
+        if (!data.slice(0, 8).equals(ZeroContent.discriminator)) {
+            throw new Error("invalid account discriminator");
+        }
+        const dec = ZeroContent.layout.decode(data.slice(8));
+        return new ZeroContent({
+            cards: dec.cards,
+        });
+    }
+    toJSON() {
+        return {
+            cards: this.cards,
+        };
+    }
+    static fromJSON(obj) {
+        return new ZeroContent({
+            cards: obj.cards,
+        });
+    }
+}
+ZeroContent.discriminator = Buffer.from([
+    60, 71, 181, 209, 154, 77, 4, 225,
+]);
+ZeroContent.layout = borsh.struct([
+    borsh.array(borsh.u8(), 10000000, "cards"),
+]);

package/dist/types/accounts/ZeroOpenHolder.d.ts

@@ -0,0 +1,50 @@
+import { PublicKey, Connection } from "@solana/web3.js";
+import BN from "bn.js";
+import * as types from "../types";
+export interface ZeroOpenHolderFields {
+    class: types.AccountClassKind;
+    storeHalfHash: Array<number>;
+    state: types.PackOpenHolderStateKind;
+    paidFee: number;
+    pack: PublicKey;
+    creator: PublicKey;
+    claimer: PublicKey;
+    randomBase: BN;
+    packType: types.PackTypeKind;
+    sendToVault: types.MemeVaultProofFields | null;
+    items: Array<types.SelectedZeroCardFields>;
+}
+export interface ZeroOpenHolderJSON {
+    class: types.AccountClassJSON;
+    storeHalfHash: Array<number>;
+    state: types.PackOpenHolderStateJSON;
+    paidFee: number;
+    pack: string;
+    creator: string;
+    claimer: string;
+    randomBase: string;
+    packType: types.PackTypeJSON;
+    sendToVault: types.MemeVaultProofJSON | null;
+    items: Array<types.SelectedZeroCardJSON>;
+}
+export declare class ZeroOpenHolder {
+    readonly class: types.AccountClassKind;
+    readonly storeHalfHash: Array<number>;
+    readonly state: types.PackOpenHolderStateKind;
+    readonly paidFee: number;
+    readonly pack: PublicKey;
+    readonly creator: PublicKey;
+    readonly claimer: PublicKey;
+    readonly randomBase: BN;
+    readonly packType: types.PackTypeKind;
+    readonly sendToVault: types.MemeVaultProof | null;
+    readonly items: Array<types.SelectedZeroCard>;
+    static readonly discriminator: Buffer;
+    static readonly layout: any;
+    constructor(fields: ZeroOpenHolderFields);
+    static fetch(c: Connection, address: PublicKey, programId?: PublicKey): Promise<ZeroOpenHolder | null>;
+    static fetchMultiple(c: Connection, addresses: PublicKey[], programId?: PublicKey): Promise<Array<ZeroOpenHolder | null>>;
+    static decode(data: Buffer): ZeroOpenHolder;
+    toJSON(): ZeroOpenHolderJSON;
+    static fromJSON(obj: ZeroOpenHolderJSON): ZeroOpenHolder;
+}

package/dist/types/accounts/ZeroOpenHolder.js

@@ -0,0 +1,126 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.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 class ZeroOpenHolder {
+    constructor(fields) {
+        this.class = fields.class;
+        this.storeHalfHash = fields.storeHalfHash;
+        this.state = fields.state;
+        this.paidFee = fields.paidFee;
+        this.pack = fields.pack;
+        this.creator = fields.creator;
+        this.claimer = fields.claimer;
+        this.randomBase = fields.randomBase;
+        this.packType = fields.packType;
+        this.sendToVault =
+            (fields.sendToVault &&
+                new types.MemeVaultProof(Object.assign({}, fields.sendToVault))) ||
+                null;
+        this.items = fields.items.map((item) => new types.SelectedZeroCard(Object.assign({}, item)));
+    }
+    static fetch(c_1, address_1) {
+        return __awaiter(this, arguments, void 0, function* (c, address, programId = PROGRAM_ID) {
+            const info = yield c.getAccountInfo(address);
+            if (info === null) {
+                return null;
+            }
+            if (!info.owner.equals(programId)) {
+                throw new Error("account doesn't belong to this program");
+            }
+            return this.decode(info.data);
+        });
+    }
+    static fetchMultiple(c_1, addresses_1) {
+        return __awaiter(this, arguments, void 0, function* (c, addresses, programId = PROGRAM_ID) {
+            const infos = yield c.getMultipleAccountsInfo(addresses);
+            return infos.map((info) => {
+                if (info === null) {
+                    return null;
+                }
+                if (!info.owner.equals(programId)) {
+                    throw new Error("account doesn't belong to this program");
+                }
+                return this.decode(info.data);
+            });
+        });
+    }
+    static decode(data) {
+        if (!data.slice(0, 8).equals(ZeroOpenHolder.discriminator)) {
+            throw new Error("invalid account discriminator");
+        }
+        const dec = ZeroOpenHolder.layout.decode(data.slice(8));
+        return new ZeroOpenHolder({
+            class: types.AccountClass.fromDecoded(dec.class),
+            storeHalfHash: dec.storeHalfHash,
+            state: types.PackOpenHolderState.fromDecoded(dec.state),
+            paidFee: dec.paidFee,
+            pack: dec.pack,
+            creator: dec.creator,
+            claimer: dec.claimer,
+            randomBase: dec.randomBase,
+            packType: types.PackType.fromDecoded(dec.packType),
+            sendToVault: (dec.sendToVault &&
+                types.MemeVaultProof.fromDecoded(dec.sendToVault)) ||
+                null,
+            items: dec.items.map((item /* eslint-disable-line @typescript-eslint/no-explicit-any */) => types.SelectedZeroCard.fromDecoded(item)),
+        });
+    }
+    toJSON() {
+        return {
+            class: this.class.toJSON(),
+            storeHalfHash: this.storeHalfHash,
+            state: this.state.toJSON(),
+            paidFee: this.paidFee,
+            pack: this.pack.toString(),
+            creator: this.creator.toString(),
+            claimer: this.claimer.toString(),
+            randomBase: this.randomBase.toString(),
+            packType: this.packType.toJSON(),
+            sendToVault: (this.sendToVault && this.sendToVault.toJSON()) || null,
+            items: this.items.map((item) => item.toJSON()),
+        };
+    }
+    static fromJSON(obj) {
+        return new ZeroOpenHolder({
+            class: types.AccountClass.fromJSON(obj.class),
+            storeHalfHash: obj.storeHalfHash,
+            state: types.PackOpenHolderState.fromJSON(obj.state),
+            paidFee: obj.paidFee,
+            pack: new PublicKey(obj.pack),
+            creator: new PublicKey(obj.creator),
+            claimer: new PublicKey(obj.claimer),
+            randomBase: new BN(obj.randomBase),
+            packType: types.PackType.fromJSON(obj.packType),
+            sendToVault: (obj.sendToVault && types.MemeVaultProof.fromJSON(obj.sendToVault)) ||
+                null,
+            items: obj.items.map((item) => types.SelectedZeroCard.fromJSON(item)),
+        });
+    }
+}
+ZeroOpenHolder.discriminator = Buffer.from([
+    106, 194, 12, 193, 165, 210, 56, 2,
+]);
+ZeroOpenHolder.layout = borsh.struct([
+    types.AccountClass.layout("class"),
+    borsh.array(borsh.u8(), 4, "storeHalfHash"),
+    types.PackOpenHolderState.layout("state"),
+    borsh.u8("paidFee"),
+    borsh.publicKey("pack"),
+    borsh.publicKey("creator"),
+    borsh.publicKey("claimer"),
+    borsh.u64("randomBase"),
+    types.PackType.layout("packType"),
+    borsh.option(types.MemeVaultProof.layout(), "sendToVault"),
+    borsh.vec(types.SelectedZeroCard.layout(), "items"),
+]);

package/dist/types/accounts/index.d.ts

@@ -0,0 +1,66 @@
+export { BuyTrack } from "./BuyTrack";
+export type { BuyTrackFields, BuyTrackJSON } from "./BuyTrack";
+export { BuyHistory } from "./BuyHistory";
+export type { BuyHistoryFields, BuyHistoryJSON } from "./BuyHistory";
+export { ZeroOpenHolder } from "./ZeroOpenHolder";
+export type { ZeroOpenHolderFields, ZeroOpenHolderJSON } from "./ZeroOpenHolder";
+export { PackOpenHolder } from "./PackOpenHolder";
+export type { PackOpenHolderFields, PackOpenHolderJSON } from "./PackOpenHolder";
+export { ArchiveDeposit } from "./ArchiveDeposit";
+export type { ArchiveDepositFields, ArchiveDepositJSON } from "./ArchiveDeposit";
+export { CollectorRegistry } from "./CollectorRegistry";
+export type { CollectorRegistryFields, CollectorRegistryJSON, } from "./CollectorRegistry";
+export { LutVault } from "./LutVault";
+export type { LutVaultFields, LutVaultJSON } from "./LutVault";
+export { TokenManager } from "./TokenManager";
+export type { TokenManagerFields, TokenManagerJSON } from "./TokenManager";
+export { CreatorRegistry } from "./CreatorRegistry";
+export type { CreatorRegistryFields, CreatorRegistryJSON, } from "./CreatorRegistry";
+export { CollectionRegistry } from "./CollectionRegistry";
+export type { CollectionRegistryFields, CollectionRegistryJSON, } from "./CollectionRegistry";
+export { PoolVault } from "./PoolVault";
+export type { PoolVaultFields, PoolVaultJSON } from "./PoolVault";
+export { Store } from "./Store";
+export type { StoreFields, StoreJSON } from "./Store";
+export { CurrencyArtistProof } from "./CurrencyArtistProof";
+export type { CurrencyArtistProofFields, CurrencyArtistProofJSON, } from "./CurrencyArtistProof";
+export { Payment } from "./Payment";
+export type { PaymentFields, PaymentJSON } from "./Payment";
+export { RevealForMe } from "./RevealForMe";
+export type { RevealForMeFields, RevealForMeJSON } from "./RevealForMe";
+export { BurnDeposit } from "./BurnDeposit";
+export type { BurnDepositFields, BurnDepositJSON } from "./BurnDeposit";
+export { BurnProgress } from "./BurnProgress";
+export type { BurnProgressFields, BurnProgressJSON } from "./BurnProgress";
+export { ItemReserveList } from "./ItemReserveList";
+export type { ItemReserveListFields, ItemReserveListJSON, } from "./ItemReserveList";
+export { ItemReserveList2 } from "./ItemReserveList2";
+export type { ItemReserveList2Fields, ItemReserveList2JSON, } from "./ItemReserveList2";
+export { PackTraits } from "./PackTraits";
+export type { PackTraitsFields, PackTraitsJSON } from "./PackTraits";
+export { PackReceipt } from "./PackReceipt";
+export type { PackReceiptFields, PackReceiptJSON } from "./PackReceipt";
+export { ZeroContent } from "./ZeroContent";
+export type { ZeroContentFields, ZeroContentJSON } from "./ZeroContent";
+export { PackContent } from "./PackContent";
+export type { PackContentFields, PackContentJSON } from "./PackContent";
+export { ZeroCard } from "./ZeroCard";
+export type { ZeroCardFields, ZeroCardJSON } from "./ZeroCard";
+export { Authority } from "./Authority";
+export type { AuthorityFields, AuthorityJSON } from "./Authority";
+export { Card } from "./Card";
+export type { CardFields, CardJSON } from "./Card";
+export { ItemArchive } from "./ItemArchive";
+export type { ItemArchiveFields, ItemArchiveJSON } from "./ItemArchive";
+export { SecureHolder } from "./SecureHolder";
+export type { SecureHolderFields, SecureHolderJSON } from "./SecureHolder";
+export { Single } from "./Single";
+export type { SingleFields, SingleJSON } from "./Single";
+export { Pack } from "./Pack";
+export type { PackFields, PackJSON } from "./Pack";
+export { GenericUser } from "./GenericUser";
+export type { GenericUserFields, GenericUserJSON } from "./GenericUser";
+export { ThreeId } from "./ThreeId";
+export type { ThreeIdFields, ThreeIdJSON } from "./ThreeId";
+export { StoresHolder } from "./StoresHolder";
+export type { StoresHolderFields, StoresHolderJSON } from "./StoresHolder";

package/dist/types/accounts/index.js

@@ -0,0 +1,33 @@
+export { BuyTrack } from "./BuyTrack";
+export { BuyHistory } from "./BuyHistory";
+export { ZeroOpenHolder } from "./ZeroOpenHolder";
+export { PackOpenHolder } from "./PackOpenHolder";
+export { ArchiveDeposit } from "./ArchiveDeposit";
+export { CollectorRegistry } from "./CollectorRegistry";
+export { LutVault } from "./LutVault";
+export { TokenManager } from "./TokenManager";
+export { CreatorRegistry } from "./CreatorRegistry";
+export { CollectionRegistry } from "./CollectionRegistry";
+export { PoolVault } from "./PoolVault";
+export { Store } from "./Store";
+export { CurrencyArtistProof } from "./CurrencyArtistProof";
+export { Payment } from "./Payment";
+export { RevealForMe } from "./RevealForMe";
+export { BurnDeposit } from "./BurnDeposit";
+export { BurnProgress } from "./BurnProgress";
+export { ItemReserveList } from "./ItemReserveList";
+export { ItemReserveList2 } from "./ItemReserveList2";
+export { PackTraits } from "./PackTraits";
+export { PackReceipt } from "./PackReceipt";
+export { ZeroContent } from "./ZeroContent";
+export { PackContent } from "./PackContent";
+export { ZeroCard } from "./ZeroCard";
+export { Authority } from "./Authority";
+export { Card } from "./Card";
+export { ItemArchive } from "./ItemArchive";
+export { SecureHolder } from "./SecureHolder";
+export { Single } from "./Single";
+export { Pack } from "./Pack";
+export { GenericUser } from "./GenericUser";
+export { ThreeId } from "./ThreeId";
+export { StoresHolder } from "./StoresHolder";