@xgamesfun/solana 0.0.0-stage → 0.20.1

package/types/client/ix.d.ts

@@ -0,0 +1,1687 @@
+import { ASSOCIATED_TOKEN_PROGRAM } from '../chain/pda.js';
+import IDL from './idl/loot.js';
+export { IDL, ASSOCIATED_TOKEN_PROGRAM };
+/** Token Metadata: a legacy NFT's or a pNFT's metadata lives at an address of its (`METAPLEX_METADATA_PROGRAM`). */
+export declare const TOKEN_METADATA_PROGRAM = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
+/** 32 bytes a project names a call by (a match id, a payout's reason). Zeros when not given. */
+export declare function reference(value: any): Uint8Array<ArrayBuffer>;
+/**
+ * Any loot instruction. `accounts` names accounts by their IDL leaf name; `null` for an optional one passes "None".
+ * Options: `remaining` (metas after the instruction's own), `writable` and `signer` (leaf names whose flag is set
+ * on, beyond the IDL's), `readonly` (leaf names whose writable flag is set off).
+ */
+export declare function lootIx(name: any, args?: {}, accounts?: {}, { remaining, writable, signer, readonly }?: {
+    readonly?: never[] | undefined;
+    remaining?: never[] | undefined;
+    signer?: never[] | undefined;
+    writable?: never[] | undefined;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * The accounts one destination needs, in the order the program reads them: a pool, a named token account, a wallet
+ * and its associated token account of `mint` (the project's `treasury` wallet for `Treasury`), or whoever holds a
+ * collectible (its asset, then the holder and their associated token account). The program opens a wallet's account
+ * or a pool when it is not there, paid by whoever sends the instruction. `holders` maps an asset to its holder now;
+ * for one nobody holds, the default address fills the holder's two places. A buyer's choice (`Chosen`) is written as
+ * what was chosen first (`chosenShares`).
+ */
+export declare function destinationAccounts(project: any, to: any, mint: any, { holders, programs, treasury }?: Readonly<Record<string, any>>): {
+    pubkey: any;
+    isSigner: any;
+    isWritable: any;
+}[];
+/** A split's destinations, in order. */
+export declare const shareAccounts: (project: any, shares: any, mint: any, options: any) => any;
+/**
+ * A split with the buyer's choice written in, as the program does at `open_box` and `buy_tickets`: a wallet, the
+ * holder of the collectible chosen (a share with an item, which needs one), or the treasury with no choice. A
+ * contest's decision names its wallet the same way (`decideIx`).
+ */
+export declare const chosenShares: (shares: any, choice: any) => any;
+/** Whether a split burns, so the mint is written: it has a burn share. */
+export declare const sharesBurn: (shares: any) => any;
+/**
+ * The account each prize of a box's entries comes with at the roll, in entry order and each entry's prizes in order:
+ * its item for an item, its pool for tokens from one, its stash for an NFT of one (a named one, or one at random). All
+ * written: the roll takes from them. Tokens minted and rolls take none here.
+ */
+export declare function entryAccounts(project: any, entries: any): any;
+/**
+ * For each mint a box's tokens are in, in the order their prizes first name them, the mint (written when the roll
+ * mints from it) and the project's vault for it, where tokens won wait. `poolMints` maps a pool index to its mint (a
+ * pool not opened yet has none and is left out).
+ */
+export declare function prizeAccounts(project: any, entries: any, poolMints: {} | undefined, programs: any): {
+    pubkey: any;
+    isSigner: any;
+    isWritable: any;
+}[];
+/** Whether a box leaves its outcome to the oracle: more than one entry, or an entry gives a stash's NFT at random. */
+export declare const boxRolls: (entries: any) => any;
+/** What an order of `box` holds for the collectibles its roll may mint: a collectible's rent for each item the entry
+ * with the most of them gives. */
+export declare const orderEscrow: (box: any) => bigint;
+/**
+ * The nonce the `k`th roll an order won is named by when it settles: the first 8 bytes, little
+ * endian, of sha256("roll" | order | its requested slot (u64 LE) | k (u8)). Like every prize's roll, its order is at
+ * `prizeRollNonce` of it.
+ */
+export declare function rollNonce(order: any, requestedSlot: any, k: any): bigint;
+/**
+ * The nonce of a roll on an NFT whose box moves its numbers, burns it or gives it away: the first
+ * 8 bytes, little endian, of its address. Its player has one such roll open on it at a time: the order's address is
+ * taken until it settles or is refunded. `openBoxIx` makes a box's roll on one there; a mission's roll (`unstakeNftIx`)
+ * and a recipe's (`craftIx`) take it as their `nonce`.
+ */
+export declare const nonceOn: (asset: any) => bigint;
+/** Whether a box's roll holds the NFT it rolls on, or moves its numbers: an entry burns it, gives it
+ * away or moves its numbers. Its order is at the NFT's nonce (`nonceOn`). */
+export declare const boxHolds: (box: any) => any;
+/**
+ * The accounts of an NFT the player shows, for a gate or for odds: right after the instruction's other accounts.
+ * `shown` is a Core asset the project has authority over (its address), one it has no authority over (`{ asset }`: then
+ * its Sheet's address), a Token Metadata NFT (`{ mint, owner }`: its mint, its metadata, the owner's token account of
+ * it, its Sheet's address), or a compressed NFT (`{ compressed: assetId, tree }`: its asset id, its record, which a
+ * `proveLeafIx` earlier in the same transaction writes, its tree, and its Sheet's address).
+ */
+export declare function shownAccounts(project: any, shown: any): {
+    pubkey: any;
+    isSigner: any;
+    isWritable: any;
+}[];
+/**
+ * What a player passes a gate with, right after an instruction's own accounts: a list's proof (`Gate::List`: its
+ * nodes as accounts, from `merkleProof` of `gateListLeaf`s), then an NFT shown (`shownAccounts`) for a gate that reads
+ * one, or for a box's odds.
+ */
+export declare const gateAccounts: (project: any, { gate, wallet, shown, listProof }?: Readonly<Record<string, any>>) => any[];
+/**
+ * A nonce a prize route names (its `nonce` argument), from what names the prize: a grant and its round, a lottery's
+ * contribution, a contest's entry, an auction and its last bid. Any nonce works (the sender picks it); the roll's order
+ * is then at `prizeRollNonce` of it (plus the place where the route says so), which no roll on an NFT is at.
+ */
+export declare const prizeNonce: (...parts: any[]) => bigint;
+/**
+ * The nonce a roll given as a prize is made at: the first 8 bytes, little endian, of
+ * sha256("prize" | n (u64 LE)), `n` the nonce the route names (its argument, plus the place or `k` where it says so).
+ * Every roll given as a prize (a grant's, a lottery place's, a contest's, an auction's roll lot, a mission's chest, a
+ * recipe's `Prize::Roll`, a box's prize roll) is at `["order", project, winner, prizeRollNonce(n)]`. A roll an order
+ * won is made at settle at `rollNonce(order, slot, k)` as it is (hashed under "roll", so no named nonce reaches it). A roll on an NFT (`nonceOn`, a recipe's `RollOn`, a mission's
+ * `roll`) and a box's own order are not. Not `prizeNonce`, which makes the `n` a route names from its parts.
+ */
+export declare const prizeRollNonce: (n: any) => bigint;
+/**
+ * The accounts a prize takes after a route's own, given to `winner`:
+ *   Tokens  the mint (written when minted), the pool when they come from one, the winner's account of the mint;
+ *   Item    the item; for a collectible, its collection (the Item's), its address at the item's next serial, Metaplex Core;
+ *   Nft     the stash, the NFT as `piece` takes it, then a compressed NFT's proof;
+ *   Roll    the box, then the order its roll is made in, at `prizeRollNonce(nonce)`; on a route the player pays or
+ *           asks for (`strict`: a buy, a craft, a grant's claim), then the box's prize mints (`rollMints`);
+ *   Held    the lottery's own stash (`lottery`: the lottery's address), the NFT as `piece` takes it, then its proof.
+ * `poolMints` maps a pool's index to its mint (null for a pool never opened, which gives nothing: `projectMint` stands in
+ * for its mint); `items` an item's id to its decoded Item (for its next serial; `made`
+ * collectibles of the same item already made earlier in the instruction); `nft` the NFT's kind, as `piece` takes it
+ * ({ collection, tokenMetadata, compressed }). A strict roll's `boxes` maps the box's id to its decoded LootBox (null
+ * for one never written), and `rollPools` each pool its prizes name to its mint (null for one never opened;
+ * `poolMints` when not given).
+ */
+export declare function prizeMetas({ project, collection, prize, winner, nonce, poolMints, items, nft, made, projectMint, programs, lottery, strict, boxes, rollPools }: {
+    boxes?: {} | undefined;
+    collection: any;
+    items?: {} | undefined;
+    lottery: any;
+    made?: number | undefined;
+    nft?: {} | undefined;
+    nonce?: bigint | undefined;
+    poolMints?: {} | undefined;
+    prize: any;
+    programs: any;
+    project: any;
+    projectMint: any;
+    rollPools?: any;
+    strict?: boolean | undefined;
+    winner: any;
+}): any[];
+/**
+ * The accounts the program reads after a roll's box and order, to check the roll can be asked for, on a route the
+ * player pays or asks for (a craft's `Prize::Roll` or `RollOn`, a buy's roll, a grant's claim of one): for each of the
+ * box's token prizes, in order, its pool and then, for a pool opened, the pool's mint; for tokens minted, their mint. The program refuses the whole
+ * transaction (PrizeHasHook) when any of those mints has a transfer hook, so the player keeps what the route takes.
+ * `box` is the decoded LootBox (null for one never written: no roll is made, and nothing follows); `pools` maps each
+ * pool its prizes name to its mint, or null for a pool never opened (its address alone).
+ */
+export declare function rollMints(project: any, box: any, pools?: {}): any;
+/** Bubblegum's signer for its calls to Core, `["mpl_core_cpi_signer"]`. */
+export declare const BUBBLEGUM_CORE_SIGNER = "CbNY3JiXdXNE9tPNEk1aRZVEkWdj2v7kfJLNQwZZgpXk";
+/**
+ * The project's owner or authority (`signer`) makes a Bubblegum v2 tree the project alone mints compressed prizes into
+ * (`Prize::Compressed`). `tree` is a new account of mpl-account-compression of `treeSize(maxDepth, maxBufferSize,
+ * canopy)` bytes, made empty first in the same transaction (a System `createAccount` owned by mpl-account-compression, the tree's keypair signing).
+ */
+export declare const openTreeIx: ({ signer, project, tree, maxDepth, maxBufferSize }: {
+    maxBufferSize: any;
+    maxDepth: any;
+    project: any;
+    signer: any;
+    tree: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/** The bytes an mpl-account-compression tree of this shape takes (its header, changelog, rightmost path and canopy). */
+export declare function treeSize(maxDepth: any, maxBufferSize: any, canopy: any): number;
+/** The ticket that names what an oracle request is for: sha256("ticket" | order or lottery | the slot of its first ask).
+ * Every request of one roll, or of one round's draw, names it. Nothing lives there. */
+export declare const ticketOf: (requester: any, slot: any) => string;
+/** Signed by the program's upgrade authority, once. `fees`: { player, project } lamports. */
+export declare const initPlatformIx: ({ admin, fees }: {
+    admin: any;
+    fees: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/** `nextAdmin` signs too when it is another key. */
+export declare const setPlatformIx: ({ admin, fees, nextAdmin }: {
+    admin: any;
+    fees: any;
+    nextAdmin?: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/** The platform collects the fees waiting in each project's fee box, into `to`. */
+export declare const collectFeesIx: ({ admin, to, projects }: {
+    admin: any;
+    projects: any;
+    to: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+export declare const setSuspendedIx: ({ admin, project, suspended }: {
+    admin: any;
+    project: any;
+    suspended: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * Opens project `id` (any number of `owner`'s own) at `pda.project(owner, id)`. `authority` signs payouts and makes,
+ * `treasury` is the wallet the remainder of every split goes to (its associated token account of each mint, which the
+ * program opens when it is not there). `collections`: the Metaplex Core collections it has authority over (none at
+ * all is fine; at most 8), each one whose update authority is the owner or the project, passed after the
+ * instruction's own accounts. A project names no token: each mechanic names the mint it takes or pays. Only the owner
+ * signs; the authority's and the treasury's accounts are passed too, and the program refuses a key nobody can sign
+ * for that it can tell (an account of loot or of a token program, a program: `BadKey`).
+ */
+export declare const createProjectIx: ({ owner, id, authority, treasury, collections }: {
+    authority: any;
+    collections?: never[] | undefined;
+    id?: number | undefined;
+    owner: any;
+    treasury: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * `update`: { authority?, treasury?, paused?, collections? }. `collections` replaces the project's list; every one in
+ * it is passed after the instruction's own accounts (the program reads the new ones). The owner pays for the project
+ * growing with its collections, and gets back what it shrinks by. A new owner (who signs too) is optional. A new
+ * authority or treasury comes with the account at its key (`new_authority`, `new_treasury`), which the program checks
+ * as `createProjectIx`'s.
+ */
+export declare const updateProjectIx: ({ owner, project, authority, paused, treasury, collections, newOwner }: {
+    authority?: null | undefined;
+    collections?: null | undefined;
+    newOwner?: null | undefined;
+    owner: any;
+    paused?: null | undefined;
+    project: any;
+    treasury?: null | undefined;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+export declare const openPoolIx: ({ owner, project, index, mint }: {
+    index: any;
+    mint: any;
+    owner: any;
+    project: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/** Where a record of the owner's lives: its kind's seed, the project and its id. */
+export declare function recordAddress(project: any, def: any): any;
+/**
+ * `def` with optional fields filled in (no window, no limit for each wallet, no key root, a fall on its own clock).
+ */
+export declare function withDefaults(def: any): {
+    [x: string]: any;
+};
+/**
+ * The owner writes one record (`def`: { Item: { id, args } }, { Box: … }, …), at its own address. A lottery names
+ * its pot's mint, its pot (which its first write opens), its ticket mint, its
+ * funds and both token programs.
+ */
+export declare function upsertIx({ owner, project, def: given, lottery }: {
+    def: any;
+    lottery?: null | undefined;
+    owner: any;
+    project: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * The owner closes the record at `target`, and its rent comes back: a grant's with the funds it held. A lottery
+ * (`lottery`: its decoded record) sends what its pot holds to `to`, a token account of the pot's mint (the owner's own
+ * by default), and closes the pot.
+ */
+export declare function closeRecordIx({ owner, project, target, lottery, schedule, programs, to, paymentTo, extra }: {
+    extra?: never[] | undefined;
+    lottery: any;
+    owner: any;
+    paymentTo: any;
+    programs: any;
+    project: any;
+    schedule: any;
+    target: any;
+    to: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * `player` (or a sponsor, or the project's own keys funding a pool) pays `amount` of `mint`, split at once by `shares`.
+ * The rest goes to the project's `treasury` wallet. The player opens any account this pays into that is not there.
+ */
+export declare function payIx({ player, project, mint, treasury, amount, shares, reference: ref, playerToken, holders, programs, extra }: {
+    amount: any;
+    extra?: never[] | undefined;
+    holders: any;
+    mint: any;
+    player: any;
+    playerToken: any;
+    programs: any;
+    project: any;
+    reference: any;
+    shares?: never[] | undefined;
+    treasury: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * Opens a loot box (`box` the decoded LootBox at `boxAddress`), in an order at `nonce` (a box whose roll moves the
+ * numbers of the NFT it rolls on: at that NFT's, `nonceOn`, whatever `nonce` says). `poolMints` maps each pool its
+ * prizes take tokens from to its mint (a pool's tokens won wait in the project's vault for that mint); one not given
+ * is taken to be in the box's currency, one given as null is closed. `shown`: an NFT the player shows for the box's
+ * gate or odds; `listProof`: for a list gate, the proof's nodes. `chosenRecipient`: the wallet (or, for a share with an
+ * item, the collectible, `chosen`) the buyer names for a share the box lets them choose. A box of one entry with
+ * nothing random is rolled at once and takes no oracle accounts (a box that needs no roll at all sells with `buyIx`).
+ * The player opens the project's vault for the price's mint, and for each prize's, when it is not there. A box that
+ * limits each wallet counts the purchase in the player's receipt (its rent theirs).
+ */
+export declare function openBoxIx({ player, project, box, boxAddress, nonce, maxPrice, shown, listProof, subject, chosenRecipient, chosen, poolMints, playerToken, programs, extra }: {
+    box: any;
+    boxAddress: any;
+    chosen?: null | undefined;
+    chosenRecipient?: null | undefined;
+    extra?: never[] | undefined;
+    listProof: any;
+    maxPrice: any;
+    nonce: any;
+    player: any;
+    playerToken: any;
+    poolMints: any;
+    programs: any;
+    project: any;
+    shown: any;
+    subject: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * Buys a box that needs no roll (one entry, nothing random, no NFT to roll on: `boxRolls` false and no subject) in one
+ * instruction: the price is split at once (or burned, for an entry that burns) and the entry's prizes are given to
+ * the player (`prizeMetas`: `items` maps an item's id to its decoded Item, `poolMints` a pool's index to its mint,
+ * `nfts` an NFT a prize names to its kind; a roll's `boxes` and `rollPools`, for the rolled box's prize mints). No
+ * order. A prize that can't be given refuses the purchase. `treasury` is
+ * the project's treasury wallet; `holders` maps a collectible a share pays to its holder; a roll the entry gives is
+ * made at `nonce` (the next one for each roll after). `shown`/`listProof` pass the box's gate.
+ */
+export declare function buyIx({ player, project, box, boxAddress, maxPrice, treasury, chosenRecipient, chosen, nonce, shown, listProof, items, poolMints, nfts, boxes, rollPools, holders, playerToken, programs, extra }: {
+    box: any;
+    boxAddress: any;
+    boxes?: {} | undefined;
+    chosen?: null | undefined;
+    chosenRecipient?: null | undefined;
+    extra?: never[] | undefined;
+    holders: any;
+    items?: {} | undefined;
+    listProof: any;
+    maxPrice: any;
+    nfts?: {} | undefined;
+    nonce?: bigint | undefined;
+    player: any;
+    playerToken: any;
+    poolMints?: {} | undefined;
+    programs: any;
+    project: any;
+    rollPools?: any;
+    shown: any;
+    treasury: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * The oracle's answer to a box order (for a local simulation: on chain MagicBlock's oracle sends it). The accounts
+ * are the ones `open_box` handed the oracle: the order, the box, the roll's ticket (named by its first ask,
+ * `asked_first`, which a stale re-ask keeps), every prize's account (written); for a
+ * box with tokens the two token programs, the project, and each mint with its vault (a mint it mints from written);
+ * for a prize in a mint with a transfer hook, the hook's accounts (`extra`). The buyer's odds boosts were fixed at
+ * purchase.
+ */
+export declare function callbackRollIx({ order, orderState, box, boxAddress, randomness, project, poolMints, programs, extra }: {
+    box: any;
+    boxAddress: any;
+    extra?: never[] | undefined;
+    order: any;
+    orderState: any;
+    poolMints: any;
+    programs: any;
+    project: any;
+    randomness: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * The accounts of what an order won (`order.won`), in order, as `settle` hands each over:
+ *   Item    the item; for a collectible (`items[id]` its decoded Item), its collection, its address, Metaplex Core
+ *   Tokens  the mint, the project's vault for it, the player's account of it (`prizeTo`, when given)
+ *   Nft     the NFT as `piece` takes it (`nfts[nft]` its kind), going to the player, then a compressed NFT's proof
+ *   Roll    the box, then the order its roll is made in (`rollNonce`)
+ */
+export declare function wonAccounts({ orderAddress, order, items, nfts, prizeTo, putBack, programs }: {
+    items?: {} | undefined;
+    nfts?: {} | undefined;
+    order: any;
+    orderAddress: any;
+    prizeTo: any;
+    programs: any;
+    putBack?: never[] | undefined;
+}): any;
+/** The heap a settle that moves three or more NFTs asks for (`settleHeapFrame`): all a transaction may have, 256 KiB. */
+export declare const LARGE_SETTLE_HEAP: number;
+/**
+ * The heap a settle of `order` asks for with Compute Budget's `RequestHeapFrame` (`requestHeapFrame`), in bytes; 0 for
+ * none (the 32 KiB every transaction has). A settle hands every account to each NFT's move, so one that moves three or
+ * more NFTs (the prizes and the NFT rolled on) can outgrow 32 KiB, for good once a payee turns on required memos
+ * (a known limit of the program).
+ *
+ * loot's own allocator uses the frame a transaction asks for, up to
+ * 256 KiB, so such a settle asks for all of it (`LARGE_SETTLE_HEAP`, about 1,000 compute units more). Every settle
+ * `js/play` sends for such an order asks for it, and so does the keeper's sweep: put `requestHeapFrame(heap)` before
+ * the settle when `settleHeapFrame(order)` is not 0. A prize step of a lottery gives one place a call and needs none.
+ */
+export declare function settleHeapFrame(order: any): number;
+/** All the compute units a transaction may have: what a settle that moves an NFT asks for (`settleComputeUnits`). */
+export declare const MAX_COMPUTE_UNITS = 1400000;
+/**
+ * The compute limit a settle of `order` asks for. A settle that moves an NFT asks for all a transaction may have
+ * (1,400,000 units): up to 986,000 were measured for three pNFTs of stashes, the NFT rolled on and
+ * four holders' shares. Any other asks for 800,000 (tokens to the player and up to four payees, accounts opened for
+ * them). A limit costs nothing more when no priority fee is set.
+ */
+export declare function settleComputeUnits(order: any): 800000 | 1400000;
+/**
+ * Carries out a rolled order: hands over what its roll set aside (`wonAccounts`: a collectible minted, the project's
+ * backend delivering a normal item from the receipt; tokens from the project's vault; an NFT taken out of its stash;
+ * a roll made for the player), then splits the payment, or burns it for an entry that burns. Anyone sends it, for the
+ * order at `orderAddress`; `signer` opens any account it pays into that is not there, and pays a roll's order. `order`
+ * is the decoded Order; `projectState` the decoded Project; `items` and `nfts` as `wonAccounts` takes them. `putBack`:
+ * NFTs won that the player, signing, puts back into their stash in place of taking them (one its collection won't let move).
+ * `handBack`: the wallet the box's fate gives the NFT rolled on to (`receiverOf`) is an account of the loot program
+ * (`handsBack` of it as read), so the program gives it back to the player, and a Token Metadata NFT's `token` is the
+ * player's. `extra`: a hook's or a memo's accounts.
+ */
+export declare function settleIx({ signer, orderAddress, order, projectState, items, nfts, prizeTo, putBack, subject, handBack, holders, programs, extra }: {
+    extra?: never[] | undefined;
+    handBack?: boolean | undefined;
+    holders: any;
+    items: any;
+    nfts: any;
+    order: any;
+    orderAddress: any;
+    prizeTo: any;
+    programs: any;
+    projectState: any;
+    putBack: any;
+    signer: any;
+    subject: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * Where a held NFT a roll was on goes, when not back to its player: the wallet its fate names, the stash it goes into,
+ * or the incinerator.
+ */
+export declare function receiverOf(order: any): any;
+/**
+ * Whether an NFT the project holds, given to the wallet whose account is `account` (as read: `{ owner }`, or null for
+ * none), goes back to its player instead: when that account is the loot program's (the project's
+ * own address, a record, a stash, a fee box), where nothing could move it again. A settle's fate and an NFT lottery
+ * ticket's price take it as `handBack`.
+ */
+export declare const handsBack: (account: any) => boolean;
+/** Where an NFT that is burned but can't be (any kind but Core) is sent: an address nobody holds the key to. */
+export declare const INCINERATOR = "1nc1nerator11111111111111111111111111111111";
+/**
+ * Gives an order's payment back to its player, into their account of the mint (`signer`, anyone, opens it when it is
+ * not there): an order whose roll failed or never came. A rolled order is settled, never refunded
+ * (`orderRefundSlot`). A purchase counted against a box's limit for each
+ * wallet is given back. `extra`: a hook's or a memo's accounts.
+ */
+export declare function refundIx({ signer, orderAddress, order, subject, programs, extra }: {
+    extra?: never[] | undefined;
+    order: any;
+    orderAddress: any;
+    programs: any;
+    signer: any;
+    subject: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * Anyone (`payer`, who pays the oracle) asks for the roll a mission's return, a recipe or a prize made (`order.status`
+ * Waiting): the box's prizes' accounts, as `openBoxIx` passes them. It lands in `callback_roll`. Returns a list of
+ * instructions: first `payer` opens the project's vault for each prize mint when it is not there (idempotent; the
+ * program refuses the ask without them, since tokens won wait there), then the ask.
+ */
+export declare function askRollIx({ payer, orderAddress, order, box, poolMints, programs }: {
+    box: any;
+    order: any;
+    orderAddress: any;
+    payer: any;
+    poolMints: any;
+    programs: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+}[];
+/** The SOL a box order holds for each collectible its roll may mint (`orderEscrow`): its rent, given back unspent. The
+ * IDL's `ESCROW_LAMPORTS`. */
+export declare const ESCROW_LAMPORTS: bigint;
+/**
+ * The authority moves the project's tokens: `from` { Pool: [i] } or { Mint: [mint] } (newly minted), `to` a pool, a
+ * wallet, an account, the treasury (`treasury`, the project's wallet), a collectible's holder or 'Burn', `amount`
+ * { Fixed: [n] } or { Bps: [bps] } of a pool. The authority opens the account it pays into when it is not there; a
+ * collectible nobody holds gets nothing.
+ */
+export declare function moveTokensIx({ authority, project, mint, from, to, amount, reference: ref, holders, programs, treasury, extra }: {
+    amount: any;
+    authority: any;
+    extra?: never[] | undefined;
+    from: any;
+    holders: any;
+    mint: any;
+    programs: any;
+    project: any;
+    reference: any;
+    to: any;
+    treasury: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * The authority makes, rewrites or burns a collectible. `change`: { Make: { attributes } } (then `item` is the item id
+ * it makes one of, `asset` is a new key that signs, and `owner` receives it), { Set: [attributes] } or 'Burn'. `collection`: the project's for a Make
+ * or a Burn; for a Set, the asset's own (`MPL_CORE_PROGRAM` for one in none). `hasAuthority` false for a `Set` on an
+ * NFT the project has no authority over (a Core asset of another collection, or a Token Metadata NFT's mint): what it
+ * writes goes in the NFT's Sheet, or on the NFT itself when its Attributes plugin names the project.
+ */
+export declare function collectibleIx({ authority, project, collection, asset, change, item, owner, hasAuthority, reference: ref }: {
+    asset: any;
+    authority: any;
+    change: any;
+    collection: any;
+    hasAuthority?: boolean | undefined;
+    item?: null | undefined;
+    owner?: null | undefined;
+    project: any;
+    reference: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * A held NFT goes to `to`: the authority's choice while the hold runs, home to its player (anyone) after; a repaid
+ * loan's home (anyone, whenever), an unpaid one's to its lender once due. `hold` is the
+ * decoded Hold: its address names its end (`pda.hold(asset, free_at)`), so a release sent late never lands on a later
+ * hold. The NFT is any kind
+ * (`piece`): `asset` and `collection` for a Core asset, with `tokenMetadata` for a Token Metadata NFT, or `compressed`
+ * (after a `proveLeafIx`).
+ */
+export declare function releaseIx({ signer, project, collection, asset, tokenMetadata: tm, compressed, hold, to, reference: ref }: {
+    asset: any;
+    collection: any;
+    compressed: any;
+    hold: any;
+    project: any;
+    reference: any;
+    signer: any;
+    to: any;
+    tokenMetadata: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * The authority opens contest `id` in `mint`. `args`: { sides, closes_at, result_by, shares, gate, deciders,
+ * min_pot, stake, prize, nft, prize_split }: `prize`, what each winning entry gets when it is claimed (`prizeMetas`);
+ * `nft`, a rule an NFT each entry stakes passes, in place of tokens (no shares then, no stake: the NFTs are the pot).
+ * With `args.prize_split`, its token prize is set aside whole when it is
+ * decided, in the contest's own vault (`pda.prizeVault`, opened now at the authority's rent), and each winning entry
+ * takes its part by what it put in: `prizeMint` names the prize's mint when it comes from a pool.
+ */
+export declare const openContestIx: ({ authority, project, id, mint, args, prizeMint }: {
+    args: any;
+    authority: any;
+    id: any;
+    mint: any;
+    prizeMint: any;
+    project: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/** The prefix of a contest's verdict (`verdictBytes`). */
+export declare const VERDICT_DOMAIN = "loot-verdict-v3";
+/**
+ * The bytes a contest's decider key signs: "loot-verdict-v3" | program (32) | contest (32) | incarnation (u64 LE) |
+ * side (1; 255 calls it off) | expires (i64 LE), then | recipient (32) when the verdict names the wallet the
+ * contest's chosen share pays. `incarnation` is the contest's (the decoded Contest's), so a verdict decides only the
+ * contest it was signed for, never one opened later at the same id. `decide` rebuilds them from its own accounts and
+ * arguments.
+ */
+export declare function verdictBytes({ program, contest, incarnation, side, expires, recipient }: {
+    contest: any;
+    expires: any;
+    incarnation: any;
+    program?: string | undefined;
+    recipient?: null | undefined;
+    side: any;
+}): Uint8Array<any>;
+/**
+ * Names the side that won (`side`), or calls the contest off (`side: null`). `signer` is the authority; or anyone
+ * sending a decider's verdict (`verdict: { expires }`, taken once entries have closed): then this instruction goes
+ * right after the Ed25519 check of the decider's signature over `verdictBytes` (`ed25519Ix` in grant.js), and
+ * `signer` pays the fee. Anyone writes down a contest that is off by itself. The contest's incarnation names it, so a
+ * decision sent late never decides a contest opened later at the same id. A call-off takes no share accounts. A
+ * contest with a chosen share is decided naming its `recipient`, a wallet (a bounty's worker); a decider's verdict
+ * signs it too (`verdictBytes`).
+ */
+export declare function decideIx({ signer, project, projectState, contestAddress, contest, side, recipient, verdict, reference: ref, holders, prizeMint, programs, extra }: {
+    contest: any;
+    contestAddress: any;
+    extra?: never[] | undefined;
+    holders: any;
+    prizeMint: any;
+    programs: any;
+    project: any;
+    projectState: any;
+    recipient?: null | undefined;
+    reference: any;
+    side: any;
+    signer: any;
+    verdict: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/** The authority asks the oracle for a random number, for a rule of the project's own. */
+export declare const rollIx: ({ authority, project, reference: ref }: {
+    authority: any;
+    project: any;
+    reference: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/** The oracle's answer to a `roll` (for a local simulation). */
+export declare const callbackRandomIx: ({ project, reference: ref, randomness }: {
+    project: any;
+    randomness: any;
+    reference: any;
+}) => {
+    programId: string;
+    keys: {
+        pubkey: any;
+        isSigner: any;
+        isWritable: any;
+    }[];
+    data: Uint8Array<any>;
+};
+/**
+ * Anyone (`payer`) runs a schedule that is due, and opens the account it pays into when that is not there.
+ * `poolMint`: the mint of the pool it moves from (when it moves from one). `extra`: a hook's or a memo's accounts.
+ */
+export declare function runScheduleIx({ payer, project, id, schedule, poolMint, holders, programs, treasury, extra }: {
+    extra?: never[] | undefined;
+    holders: any;
+    id: any;
+    payer: any;
+    poolMint: any;
+    programs: any;
+    project: any;
+    schedule: any;
+    treasury: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+export declare const lotteryPaymentMint: (lottery: any) => any;
+/**
+ * `player` buys `count` tickets: a contribution of their own at `nonce` (any number they have no contribution at in
+ * this lottery), whose rent they pay and get back once it is finished. The ticket money waits in the lottery's
+ * escrow until the draw. Whoever holds a collectible a fixed share pays is fixed now, from that collectible. It buys
+ * only at the `lottery`'s incarnation and revision (`TermsChanged` once the owner edits or recreates it). A lottery
+ * whose ticket costs an NFT (`lottery.nft_ticket`) sells one at a time, for `nft` ({ asset, collection, tokenMetadata,
+ * compressed }, as `piece` takes it), which the project holds until the round is drawn (then it goes where its `then`
+ * says, `spentTo`) or cancelled (then back to its buyer).
+ */
+export declare function buyTicketsIx({ player, project, id, lottery, mint, count, nonce, shown, listProof, chosenRecipient, chosen, nft, playerToken, programs, extra }: {
+    chosen?: null | undefined;
+    chosenRecipient?: null | undefined;
+    count: any;
+    extra?: never[] | undefined;
+    id: any;
+    listProof: any;
+    lottery: any;
+    mint: any;
+    nft: any;
+    nonce: any;
+    player: any;
+    playerToken: any;
+    programs: any;
+    project: any;
+    shown: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/** Anyone asks for a lottery's draw once it is due. */
+export declare const drawLotteryIx: ({ payer, project, id }: {
+    id: any;
+    payer: any;
+    project: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/** The oracle's answer to a draw (for a local simulation). Every request of a round names the round's ticket, fixed
+ * at its first ask (`asked_first`): a re-ask keeps it, so the first answer to land draws the round. */
+export declare function callbackLotteryIx({ project, id, lottery, askedFirst, randomness }: {
+    askedFirst?: any;
+    id: any;
+    lottery: any;
+    project: any;
+    randomness: any;
+}): {
+    programId: string;
+    keys: {
+        pubkey: any;
+        isSigner: any;
+        isWritable: any;
+    }[];
+    data: Uint8Array<any>;
+};
+export declare const cancelLotteryIx: ({ project, id }: {
+    id: any;
+    project: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/** Where a decoded contribution's shares go: as fixed when it was bought. */
+export declare function lotteryContributionShares(lottery: any, contribution: any): any;
+/**
+ * Anyone (`payer`) sends a contribution's next step (`lotteryStep`; `contributionAddress`, decoded `contribution`):
+ *   - a drawn round gives every place's prize first: the step of a contribution that won a place with a prize gives
+ *     the first such prize not given yet to its buyer, one place a call (`prizeMetas`: `collection`, `poolMints`, `items`, `nfts` as it takes them; a roll's
+ *     order at `nonce` plus the place, `prizeNonce(contributionAddress)` by default), and nothing else moves;
+ *   - once every prize is given, it is routed through its shares into the pot (or its tickets burned, or its NFT ticket
+ *     spent); a cancelled round's, or a lottery's that returns its tickets, goes back to its buyer, never waiting;
+ *   - one that holds a winning ticket stays (`done`): once every contribution is finished, it pays its buyer every
+ *     place's share of the pot it won, into their account of the pot's mint.
+ * `payer` opens any account it pays into that is not there. `treasury`: the project's treasury wallet, for a share
+ * that names it. A ticket an NFT paid for passes that NFT (`ticket`: its kind, as `piece` takes it); `handBack` when the
+ * wallet its price gives it to is an account of the loot program (`handsBack`), where it goes back to its buyer (a
+ * Token Metadata NFT into the buyer's token account).
+ */
+export declare function finishLotteryContributionIx({ payer, project, id, lottery, contributionAddress, contribution, treasury, nonce, collection, poolMints, items, nfts, ticket, handBack, programs, extra }: {
+    collection: any;
+    contribution: any;
+    contributionAddress: any;
+    extra?: never[] | undefined;
+    handBack?: boolean | undefined;
+    id: any;
+    items: any;
+    lottery: any;
+    nfts?: {} | undefined;
+    nonce: any;
+    payer: any;
+    poolMints: any;
+    programs: any;
+    project: any;
+    ticket?: {} | undefined;
+    treasury: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * The owner opens farm `id`: of `stakedMint`'s tokens, or of collectibles when it is null. Its rewards come from pool
+ * `args.rewards_pool`, whose mint is `rewardsMint`: all it receives, shared, or with `args.rate` ({ per_day, mints })
+ * a fixed rate, minted or from that pool (a rate of 0 pays nothing: a farm that only grows or gives prizes).
+ * `args.gates`: the rules an NFT must all pass. `args.growth`: up to 4 of { key, per_day, level, steps, streak }, each
+ * writing points (and a level) on what is staked; tiers' `prize` is paid from `args.prize` ({ Mint: [mint] } or
+ * { Pool: [index] }), whose mint is `prizeMint`. `args.ends_at`: when it ends (0: never). For a farm of collectibles,
+ * `args.lock_key`: the attribute a staked NFT's lock is written under, as the time it ends, so recipes and rolls can
+ * move it; `args.upkeep_key`: the attribute that says until when it earns and grows (fuel). Empty: none.
+ */
+export declare const openFarmIx: ({ owner, project, id, args, rewardsMint, stakedMint }: {
+    args: any;
+    id: any;
+    owner: any;
+    project: any;
+    rewardsMint: any;
+    stakedMint?: null | undefined;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * `player` stakes `amount` at lock tier `tier`. `farm` is decoded; `extra` carries token hook/memo accounts. A new tier
+ * on a seat with a booster, in a farm with growth, needs the booster's growth written first: put a `refreshSeatIx` of
+ * the seat before it, in the same transaction.
+ */
+export declare const stakeTokensIx: ({ player, project, id, farm, amount, tier, programs, shown, extra }: {
+    amount: any;
+    extra?: never[] | undefined;
+    farm: any;
+    id: any;
+    player: any;
+    programs: any;
+    project: any;
+    shown: any;
+    tier?: number | undefined;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * `player` takes `amount` out (0: only collects what is owed, and takes out tokens whose unbonding wait is over);
+ * `forfeit` gives up rewards that can't move. Before the tier's lock has run, a tier with an early-exit fee
+ * (`exit_bps`) lets it leave, leaving that share of `amount` to the farm's `exit_to`. In a farm that unbonds
+ * (`unbond`), what is taken out waits that long first, earning nothing (`withdrawable`).
+ */
+export declare const unstakeTokensIx: ({ player, project, id, farm, amount, forfeit, programs, extra }: {
+    amount: any;
+    extra?: never[] | undefined;
+    farm: any;
+    forfeit?: boolean | undefined;
+    id: any;
+    player: any;
+    programs: any;
+    project: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/** What a token seat may take out now (Unix seconds `now`): its unbonded tokens once their wait is over, else 0. */
+export declare const withdrawable: (seat: any, now: any) => bigint;
+/**
+ * Whether a farm (decoded) takes a stake at lock tier `tier` at `now` (Unix seconds, the chain's clock), as the program
+ * judges it: a farm with an end (`ends_at`, 0 for never) takes none at its end or after it, nor one whose lock
+ * would run past it (`FarmOver`). A stake of tokens, a booster, a new tier and a watched NFT's takeover all ask it.
+ */
+export declare function farmOpenFor(farm: any, tier: any, now: any): boolean;
+export declare const AUTH_RULES_PROGRAM = "auth9SigNpDKz4sJJ1DfCTuZrZNSAgh9sFD3rboVmgg";
+/**
+ * Any NFT's accounts on a route (a farm, a hold, an auction's lot): `{ accounts, proof, writable }`, the proof going
+ * first among the instruction's remaining accounts, `writable` the accounts to pass writable (`lootIx`'s option). The
+ * NFT is one of:
+ *   a Core asset (`asset`; `collection` its collection now; `hasAuthority` false for one the project has no authority
+ *     over, whose Sheet is passed);
+ *   a Token Metadata NFT (`asset` its mint, `tokenMetadata` { programmable, ruleSet } from `decodeTokenMetadata`): the
+ *     token account of `wallet` (its holder, or whoever the project sends it to) and the project's own;
+ *   a compressed NFT (`compressed`, from `compressedFromDas`), proven by a `proveLeafIx` earlier in the transaction.
+ * A Token Metadata or compressed NFT passes its Sheet: the project writes nothing on it.
+ * What the route does with it, so only the accounts it takes are passed (each true when left out):
+ *   `moves`: hands it to the project or sends it on; `locks`: locks or unlocks it in its wallet; `writes`: writes on it;
+ *   `burns`: burns a Core asset (false when left out); `reads`: reads its Sheet; `held`: reads it in the project's token
+ *   account (an escrow farm).
+ */
+export declare function piece({ project, asset, wallet, collection, hasAuthority, tokenMetadata: tm, compressed: c, moves, locks, writes, burns, reads, held }: {
+    asset: any;
+    burns?: boolean | undefined;
+    collection: any;
+    compressed: any;
+    hasAuthority?: boolean | undefined;
+    held?: any;
+    locks?: boolean | undefined;
+    moves?: boolean | undefined;
+    project: any;
+    reads?: boolean | undefined;
+    tokenMetadata: any;
+    wallet: any;
+    writes?: boolean | undefined;
+}): {
+    accounts: {
+        mpl_core_program: null;
+        metadata: null;
+        edition: null;
+        token: null;
+        token_record: null;
+        project_token: null;
+        project_record: null;
+        rule_set: null;
+        rules_program: null;
+        token_metadata_program: null;
+        instructions: null;
+        spl_token_program: null;
+        spl_ata_program: null;
+        collection: any;
+        tree_config: any;
+        leaf_delegate: any;
+        bubblegum_program: string;
+        compression_program: string;
+        log_wrapper: string;
+        asset: any;
+        sheet: any;
+        leaf: any;
+        tree: any;
+    } | {
+        collection: null;
+        mpl_core_program: null;
+        metadata: null;
+        edition: null;
+        token: null;
+        token_record: null;
+        project_token: null;
+        project_record: null;
+        rule_set: null;
+        rules_program: null;
+        token_metadata_program: null;
+        instructions: null;
+        spl_token_program: null;
+        spl_ata_program: null;
+        tree_config: null;
+        leaf_delegate: null;
+        bubblegum_program: null;
+        compression_program: null;
+        log_wrapper: null;
+        asset: any;
+        sheet: any;
+        leaf: any;
+        tree: any;
+    };
+    proof: any;
+    writable: string[];
+} | {
+    accounts: {
+        collection: null;
+        mpl_core_program: null;
+        leaf: null;
+        tree: null;
+        tree_config: null;
+        leaf_delegate: null;
+        bubblegum_program: null;
+        compression_program: null;
+        log_wrapper: null;
+        asset: any;
+        sheet: any;
+        metadata: any;
+        token: any;
+        edition: any;
+        token_record: any;
+        project_token: any;
+        project_record: any;
+        rule_set: any;
+        rules_program: string | null;
+        token_metadata_program: string | null;
+        instructions: string | null;
+        spl_token_program: string | null;
+        spl_ata_program: string | null;
+    };
+    proof: never[];
+    writable: never[];
+} | {
+    accounts: {
+        metadata: null;
+        edition: null;
+        token: null;
+        token_record: null;
+        project_token: null;
+        project_record: null;
+        rule_set: null;
+        rules_program: null;
+        token_metadata_program: null;
+        instructions: null;
+        spl_token_program: null;
+        spl_ata_program: null;
+        leaf: null;
+        tree: null;
+        tree_config: null;
+        leaf_delegate: null;
+        bubblegum_program: null;
+        compression_program: null;
+        log_wrapper: null;
+        asset: any;
+        sheet: any;
+        collection: any;
+        mpl_core_program: string | null;
+    };
+    proof: never[];
+    writable: string[];
+};
+/** The account an NFT paid goes to: the wallet it is given to, the stash it goes into, or the
+ * incinerator for a burn (any account stands in for a Core asset, which Core burns). `then`: 'Burn', { Give: [wallet] }
+ * or { Stash: [id] }. */
+export declare function spentTo(project: any, then: any): any;
+/**
+ * The accounts of an NFT `owner` pays with, after a route's own: the NFT as `piece` takes it, its proof,
+ * then where it goes (`spentTo`). Given on or burned it moves straight from its owner: a Token Metadata NFT's
+ * receiver's token account (and a pNFT's record of it) take the project's places; stashed, it is handed to the
+ * project first. A Core asset burned writes its collection.
+ */
+export declare function nftPaid({ project, owner, then, asset, collection, hasAuthority, tokenMetadata: tm, compressed }: {
+    asset: any;
+    collection: any;
+    compressed: any;
+    hasAuthority: any;
+    owner: any;
+    project: any;
+    then: any;
+    tokenMetadata: any;
+}): any[];
+/**
+ * `player` pays with an NFT, any kind (as `piece` takes it): burned (`to` null: the incinerator's address goes in its
+ * place), or given to the wallet `to` (the treasury, a partner). The receipt (`PaidNft`) is the record: an app admits the player when the NFT, where it went (`to`: a payment to the player's own wallet pays nothing) and the reference
+ * are the ones it asked for. `extra`: Core's transfer adapters.
+ */
+export declare function payNftIx({ player, project, asset, to, collection, hasAuthority, tokenMetadata: tm, compressed, reference: ref, extra }: {
+    asset: any;
+    collection: any;
+    compressed: any;
+    extra?: never[] | undefined;
+    hasAuthority: any;
+    player: any;
+    project: any;
+    reference: any;
+    to?: null | undefined;
+    tokenMetadata: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * Whether a classic token account (its `{ owner, data }` as read) takes a Token Metadata NFT `mint` for `holder`: an
+ * account of the Token program, of that mint, that `holder` owns, not frozen. Token Metadata refuses one another key
+ * owns (a holder can hand their own associated account to another key) and a frozen one, so a route that hands the
+ * NFT into it fails: then the NFT goes into a fresh account of the holder's (`freshNftAccount`).
+ */
+export declare function takesNft(account: any, holder: any, mint: any): boolean;
+/**
+ * A fresh token account of `mint` that `holder` holds, which `payer` opens (and pays the rent of, the fixed
+ * `TOKEN_ACCOUNT_RENT`, never an RPC's figure) at an address of its key and a seed (`addressWithSeed`): no new key
+ * signs. Pass it as the NFT's `tokenMetadata.into` when the holder's associated account can't take it (`takesNft`).
+ *
+ * The seed names the holder and the mint (a hash of both), so each holder has their own 8 addresses (`index` 0 to 7) of
+ * a payer's. `there` is the account at the address now, as read (null: nothing there): nothing there is opened with
+ * `CreateAccountWithSeed`; an address that holds only lamports someone sent it (System's, no data), which
+ * `CreateAccountWithSeed` refuses, is topped up to the rent (never more than `TOKEN_ACCOUNT_RENT`, whatever the RPC says
+ * it holds) and allocated as the payer's seed account instead; a token account there that takes the NFT
+ * needs nothing (`instructions` []). Anything else at the address (an account of the holder's that no longer takes it,
+ * or lamports no account can hold: negative, or not a whole number) answers null: try the next `index`.
+ */
+export declare function freshNftAccount({ payer, holder, mint, index, there }: {
+    holder: any;
+    index?: number | undefined;
+    mint: any;
+    payer: any;
+    there?: null | undefined;
+}): {
+    address: string;
+    instructions: {
+        programId: string;
+        keys: {
+            pubkey: any;
+            isSigner: any;
+            isWritable: any;
+        }[];
+        data: Uint8Array<any>;
+    }[];
+} | null;
+/** How many fresh accounts a payer may open for one holder and mint (`freshNftAccount`'s `index`). */
+export declare const FRESH_NFT_ACCOUNTS = 8;
+/** A token account's rent on every cluster (165 bytes). */
+export declare const TOKEN_ACCOUNT_RENT = 2039280n;
+/** Anyone closes a compressed NFT's record (`pda.leaf`) that no longer matches its tree; its rent goes to `payer`, who paid it. */
+export declare const closeLeafIx: ({ asset, tree, payer }: {
+    asset: any;
+    payer: any;
+    tree: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * Anyone proves a compressed NFT's leaf (`compressed` from `compressedFromDas`): put it before the instruction that
+ * uses the NFT, in the same transaction. The proof must be against the tree's current root (`StaleProof` otherwise:
+ * fetch it again). Its record is read only while the tree is as it was then. Bubblegum's config of the tree comes
+ * with it: only a tree Bubblegum made has one.
+ */
+export declare const proveLeafIx: ({ signer, compressed: c }: {
+    compressed: any;
+    signer: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/** The project's owner or authority vouches for NFTs' off-chain traits: `root` of a `traitsTree`, under `key`. */
+export declare const setTraitsIx: ({ signer, project, key, root }: {
+    key: any;
+    project: any;
+    root: any;
+    signer: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/** Anyone writes `nft`'s traits ([{ key, value }]) into its Sheet in `project`, by its `proof` in the tree under `key`. */
+export declare const proveTraitsIx: ({ signer, project, key, nft, attributes, proof }: {
+    attributes: any;
+    key: any;
+    nft: any;
+    project: any;
+    proof: any;
+    signer: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * `player` stakes an NFT: on a seat of its own in a farm of collectibles, or as the booster of the player's token seat
+ * in a farm of tokens. Any kind (`piece`): a Core asset, a Token Metadata NFT's mint with `tokenMetadata`, or
+ * `compressed` (after a `proveLeafIx` in the same transaction). `previous`: in a farm that watches, the last staker of
+ * an NFT that changed hands, whose seat this takes over. `extra` carries reward token hooks/memos and Core transfer
+ * adapter accounts.
+ */
+export declare const stakeNftIx: ({ player, project, id, farm, asset, collection, hasAuthority, tokenMetadata: tm, compressed, previous, tier, programs, extra }: {
+    asset: any;
+    collection: any;
+    compressed: any;
+    extra?: never[] | undefined;
+    farm: any;
+    hasAuthority?: boolean | undefined;
+    id: any;
+    player: any;
+    previous?: null | undefined;
+    programs: any;
+    project: any;
+    tier?: number | undefined;
+    tokenMetadata: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * `player` takes an NFT out once its lock has run: it grows on its way out (a farm with growth writes on it, or on its
+ * Sheet), and from its own seat takes its tier's prize. `forfeit` gives up the rewards and the prize. Leaving a tier
+ * that rolls (`roll`: its box id), the NFT is rolled on that box, in an order at `nonce` (anyone then asks the oracle,
+ * `askRollIx`, and settles); a box that can burn it or give it away keeps it in the project's hands until then.
+ */
+export declare const unstakeNftIx: ({ player, project, id, farm, asset, collection, hasAuthority, tokenMetadata: tm, compressed, forfeit, roll, nonce, tier, projectCollection, poolMints, items, nft, programs, extra }: {
+    asset: any;
+    collection: any;
+    compressed: any;
+    extra?: never[] | undefined;
+    farm: any;
+    forfeit?: boolean | undefined;
+    hasAuthority?: boolean | undefined;
+    id: any;
+    items: any;
+    nft: any;
+    nonce?: bigint | undefined;
+    player: any;
+    poolMints: any;
+    programs: any;
+    project: any;
+    projectCollection: any;
+    roll?: null | undefined;
+    tier: any;
+    tokenMetadata: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * `player` collects what the seat of `by` owes (their own address for tokens, a collectible's asset). `held`: in a farm
+ * that watches, what shows the player still holds the seat's NFT (the Core asset, their token account of a Token
+ * Metadata NFT, or a compressed NFT's record, `pda.leaf`, with its `tree`), which such a farm refuses to go without.
+ */
+export declare const harvestIx: ({ player, project, id, farm, by, held, tree, compound, programs, extra }: {
+    by?: any;
+    compound?: boolean | undefined;
+    extra?: never[] | undefined;
+    farm: any;
+    held?: null | undefined;
+    id: any;
+    player: any;
+    programs: any;
+    project: any;
+    tree?: null | undefined;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * Anyone (`signer`) writes what a seat's NFT grew (a farm with growth), then reads its boosts again. `seat` is the
+ * decoded Seat of `by`. Its NFT is any kind (`piece`): a Core asset (`collection` its collection now, the project's when
+ * left out; `hasAuthority` false for one the project has no authority over), a Token Metadata NFT (`tokenMetadata`), or
+ * `compressed` (after a `proveLeafIx`). What shows where it is must come: a compressed NFT's proof, and a Token Metadata
+ * NFT's token account that holds it, `holder`'s (its staker's, or a watched NFT's buyer's). `signer` pays for what the
+ * write adds. `extra`: the reward mint's hook accounts.
+ */
+export declare const refreshSeatIx: ({ signer, project, id, farm, by, seat, collection, hasAuthority, tokenMetadata: tm, compressed, holder, extra }: {
+    by: any;
+    collection: any;
+    compressed: any;
+    extra?: never[] | undefined;
+    farm: any;
+    hasAuthority?: boolean | undefined;
+    holder?: any;
+    id: any;
+    project: any;
+    seat: any;
+    signer: any;
+    tokenMetadata: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * `player` crafts recipe `id` (`recipe` decoded, the version shown to them), `times` over. `assets`: the
+ * collectibles handed in, in the recipe's order (the burned, the used, and for a `Show` line the NFT shown: its address
+ * when it is the project's, `{ asset, collection }` for a Core NFT of another collection, `{ mint, owner }` for a Token
+ * Metadata one; for a `Trade` line the NFT traded in, as `piece` takes it: `{ asset, collection, tokenMetadata,
+ * compressed }`). A collectible used or renewed that is staked in a farm holding it for the player (escrow) is
+ * `{ asset, farm }`, `farm` that farm's id: its seat and farm follow it. A `Staked` line names the farm its collectible
+ * is staked in (`Input::Staked { item, farm }`, escrowed or frozen there): its address, or `{ asset, farm }` with that
+ * farm, and its seat and that farm follow it. Each item line passes its item's collection
+ * (`items[id].collection`, the decoded Items; `collection` when not given), written for a burn: Core writes it as it
+ * burns a collectible. A recipe's `raises` write on the kept ones, in their Sheet when the project has no
+ * authority over them. The player opens any account a line pays into that is not there. A roll it makes (a
+ * `Prize::Roll` or a `RollOn`) passes its box's prize mints (`rollMints`): `boxes` maps the box's id to its decoded
+ * LootBox, `rollPools` each pool its prizes name to its mint (null for one never opened; `poolMints` when not given).
+ * A craft makes several Core calls: raise the compute limit. `extra`: a token's hook accounts.
+ */
+export declare function craftIx({ player, project, collection, id, recipe, assets, times, nonce, holders, programs, treasury, poolMints, items, nfts, boxes, rollPools, extra }: {
+    assets?: never[] | undefined;
+    boxes?: {} | undefined;
+    collection: any;
+    extra?: never[] | undefined;
+    holders: any;
+    id: any;
+    items?: {} | undefined;
+    nfts?: {} | undefined;
+    nonce?: bigint | undefined;
+    player: any;
+    poolMints: any;
+    programs: any;
+    project: any;
+    recipe: any;
+    rollPools?: any;
+    times?: number | undefined;
+    treasury: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/** The collectibles a craft of `recipe` makes: one per `Item` prize among its outputs. */
+export declare const craftNewAssets: (recipe: any) => any;
+/**
+ * `player` hands an NFT to the project until `freeAt` (Unix seconds; the hold's address names it, `pda.hold`): a Core
+ * asset (`collection` its own, Core's address for none), a Token Metadata NFT (`tokenMetadata`), or `compressed` (after
+ * a `proveLeafIx`).
+ */
+export declare function holdIx({ player, project, collection, asset, tokenMetadata: tm, compressed, freeAt, reference: ref }: {
+    asset: any;
+    collection: any;
+    compressed: any;
+    freeAt: any;
+    player: any;
+    project: any;
+    reference: any;
+    tokenMetadata: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * The project's owner or authority (`signer`) puts an NFT it holds into stash `id`, or (`out`: a wallet) takes one the
+ * stash holds out to that wallet. The NFT is any kind, as `piece` takes it: `collection` a Core asset's own,
+ * `tokenMetadata`, or `compressed` after a `proveLeafIx` in the same transaction. The signer pays what the stash grows
+ * by, and gets back the rent it no longer needs. Taken out with `out` the project's own address, the entry is only dropped
+ * from the stash and the NFT stays where it is. `out` is never another account of the program (`ToTheProject`).
+ */
+export declare function stashIx({ signer, project, id, lottery, asset, out, collection, tokenMetadata: tm, compressed }: {
+    asset: any;
+    collection: any;
+    compressed: any;
+    id: any;
+    lottery?: null | undefined;
+    out?: null | undefined;
+    project: any;
+    signer: any;
+    tokenMetadata: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * `player` backs `side` with `amount`, naming the contest's incarnation (which fixes its terms). `contest` is the
+ * decoded Contest. A contest of NFTs (`contest.nft`) takes one NFT instead (`nft`: { asset, collection, tokenMetadata,
+ * compressed }, as `piece` takes it), which the contest holds until it is claimed. `shown`/`listProof` pass its gate.
+ * `extra`: a hook's accounts.
+ */
+export declare function enterIx({ player, project, id, contest, side, amount, shown, listProof, nft, playerToken, programs, extra }: {
+    amount: any;
+    contest: any;
+    extra?: never[] | undefined;
+    id: any;
+    listProof: any;
+    nft: any;
+    player: any;
+    playerToken: any;
+    programs: any;
+    project: any;
+    shown: any;
+    side: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * Anyone (`payer`) claims `player`'s entry on `side`, into the player's account of the mint, which `payer` opens when
+ * it is not there (the last entry's claim closes the pot and writes the mint). A winning entry of a contest with a
+ * prize (`contest.prize`) also gets it (`prizeMetas`: `collection`, `poolMints`, `items`, `nft`; a roll's order at
+ * `nonce`, `prizeNonce(entry)` by default), `payer` paying what it opens. For a contest of NFTs, `entry` is the decoded
+ * Entry: its own NFT (`own`, its kind as `piece` takes it) goes back to its player, or to the opener for a loser's NFT
+ * no winner took; a winner, while losers' NFTs are left, also takes one (`taking`: { player, side } of a losing entry
+ * that still holds one, and `kind`, its NFT's kind). While losers' NFTs are left only the winner sends their claim, and
+ * picks which (`payer` the player; `WinnerPicks` otherwise). `extra`: a hook's accounts.
+ */
+export declare function claimIx({ payer, project, id, contest, player, side, entry, own, taking, nonce, collection, poolMints, items, nft, prizeMint, forgo, programs, extra }: {
+    collection: any;
+    contest: any;
+    entry: any;
+    extra?: never[] | undefined;
+    forgo?: boolean | undefined;
+    id: any;
+    items: any;
+    nft: any;
+    nonce: any;
+    own?: {} | undefined;
+    payer: any;
+    player: any;
+    poolMints: any;
+    prizeMint: any;
+    programs: any;
+    project: any;
+    side: any;
+    taking: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/** What a bid signs: sha256(mint | Borsh(AuctionArgs)). */
+export declare function auctionTerms(mint: any, args: any): Uint8Array<ArrayBuffer>;
+/** An auction's AuctionArgs from its decoded account (what `open_auction` fixed). */
+export declare const auctionArgsOf: (auction: any) => {
+    lot: any;
+    reserve: any;
+    min_raise_bps: any;
+    starts_at: any;
+    ends_at: any;
+    extend: any;
+    shares: any;
+    gate: any;
+    nft_bids: any;
+};
+/** When bids close, as the program reckons it: `ends_at`, or `extend` seconds after the last bid when that is later. */
+export declare const auctionEnds: (auction: any) => bigint;
+/** The least next bid the program takes, or null when no u64 amount can top it. */
+export declare function leastBid(auction: any): bigint | null;
+/**
+ * `seller` opens its auction `id` of `args.lot` ({ Item: [id] }, { Asset: [address] } or { Roll: [box id] }), alone,
+ * and pays its rent: a player for an NFT of the project's own collection they hold; the project's owner or authority for an
+ * NFT of any kind it holds (`piece`: `collection` a Core asset's own, `tokenMetadata`, or `compressed` after a
+ * `proveLeafIx`), a new unit of its item, or a roll of one of its boxes (a mystery lot). Its address names the seller, so an
+ * id is the seller's own.
+ */
+export declare function openAuctionIx({ seller, project, collection, tokenMetadata: tm, compressed, id, mint, args }: {
+    args: any;
+    collection: any;
+    compressed: any;
+    id: any;
+    mint: any;
+    project: any;
+    seller: any;
+    tokenMetadata: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * `bidder` bids `amount` on auction `id`, signing its terms; the bid it tops goes back to the high bidder's account
+ * of the mint, which `bidder` opens when it is not there. `auction` is the decoded Auction. `shown`/`listProof`: what
+ * passes the auction's gate. An auction of NFT bids (`auction.nft_bids`) takes `nfts` instead ([{ asset, collection,
+ * tokenMetadata }], as `piece` takes each; never a compressed NFT: `CompressedBid`), handed to the project, and gives the high bid's NFTs
+ * (`held`, the kinds of `auction.held`, in order) back to its bidder. `extra`: a hook's accounts.
+ */
+export declare function bidIx({ bidder, project, id, auction, amount, shown, listProof, nfts, held, bidderToken, programs, extra }: {
+    amount: any;
+    auction: any;
+    bidder: any;
+    bidderToken: any;
+    extra?: never[] | undefined;
+    held?: never[] | undefined;
+    id: any;
+    listProof: any;
+    nfts?: never[] | undefined;
+    programs: any;
+    project: any;
+    shown: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * Anyone ends auction `id` once it is over (its seller calls off one with no bid). Sold: the lot goes to the high
+ * bidder (an item that is a collectible is minted to them at `pda.itemAsset(item, serial)`; a roll of a box is made
+ * for them in an order at `prizeRollNonce(nonce)`, `nonce` being `prizeNonce(auction, last_bid_at)` by default, which `signer` pays for), the price
+ * through the shares, the rest to whoever owned the lot (the seller of an NFT, the treasury for the project's item or
+ * roll), however long after the end it is sent. With no bid, the lot goes home. `signer` opens any account the end pays into that is
+ * not there. `item` is the decoded Item of an item lot; for an NFT lot, `collection` its Core collection now (the
+ * project's when left out), `tokenMetadata` for a Token Metadata NFT, or `compressed` (after a `proveLeafIx`).
+ */
+export declare function endAuctionIx({ signer, project, projectState, id, auction, item, collection, tokenMetadata: tm, compressed, held, reference: ref, nonce, holders, programs, extra }: {
+    auction: any;
+    collection: any;
+    compressed: any;
+    extra?: never[] | undefined;
+    held?: never[] | undefined;
+    holders: any;
+    id: any;
+    item?: null | undefined;
+    nonce: any;
+    programs: any;
+    project: any;
+    projectState: any;
+    reference: any;
+    signer: any;
+    tokenMetadata: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/** The hash a taker signs, as the program rebuilds it: sha256(mint | rule | deal | shares), Borsh. `offer` is the decoded Offer. */
+export declare function offerTerms(offer: any): Uint8Array<ArrayBuffer>;
+/** What one take of a deal pays out of its offer's money: a bid's price, a loan's amount. */
+export declare const dealUnit: (deal: any) => bigint;
+/**
+ * `maker` (any wallet, signing alone) opens offer `id` in `mint`, and puts all of its money (`left` times the deal's
+ * price or amount) into the project's vault now. `args`: { rule, deal: { Buy: { price } } or { Lend: { amount, repay,
+ * lasts } }, left, shares } (shares only on a price). Its address names the maker, so an id is the maker's own.
+ */
+export declare function openOfferIx({ maker, project, id, mint, args, makerToken, programs, extra }: {
+    args: any;
+    extra?: never[] | undefined;
+    id: any;
+    maker: any;
+    makerToken: any;
+    mint: any;
+    programs: any;
+    project: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/** Its maker calls offer `id` off (`offer` the decoded Offer): what is left of its money goes back to them. Free. */
+export declare function closeOfferIx({ maker, project, id, offer, programs, extra }: {
+    extra?: never[] | undefined;
+    id: any;
+    maker: any;
+    offer: any;
+    programs: any;
+    project: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * `seller` sells an NFT that passes the bid's rule into offer `id` (`offer` the decoded Offer, its deal a `Buy`),
+ * signing its terms: the NFT goes straight to the maker, the price through the shares, the rest to the seller. The NFT is
+ * any kind, as `piece` takes it (`collection`, `hasAuthority` false for a Core asset of another collection,
+ * `tokenMetadata`, or `compressed` after a `proveLeafIx`).
+ */
+export declare function sellToOfferIx({ seller, project, projectState, id, offer, asset, collection, hasAuthority, tokenMetadata: tm, compressed, holders, programs, extra }: {
+    asset: any;
+    collection: any;
+    compressed: any;
+    extra?: never[] | undefined;
+    hasAuthority: any;
+    holders: any;
+    id: any;
+    offer: any;
+    programs: any;
+    project: any;
+    projectState: any;
+    seller: any;
+    tokenMetadata: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * `borrower` borrows against an NFT that passes the offer's rule (`offer` the decoded Offer, its deal a `Lend`), due at
+ * `due` (Unix seconds: after now, at most the deal's `lasts` from now), signing its terms. The NFT is held at
+ * `pda.hold(asset, due)` until it is repaid (`repayIx`, then `releaseIx` sends it home) or, once due, sent to the
+ * lender (`releaseIx` with `to` the lender); the loan goes to the borrower. The NFT is any kind, as `sellToOfferIx` takes it.
+ */
+export declare function borrowIx({ borrower, project, id, offer, due, asset, collection, hasAuthority, tokenMetadata: tm, compressed, programs, extra }: {
+    asset: any;
+    borrower: any;
+    collection: any;
+    compressed: any;
+    due: any;
+    extra?: never[] | undefined;
+    hasAuthority: any;
+    id: any;
+    offer: any;
+    programs: any;
+    project: any;
+    tokenMetadata: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * Anyone (`payer`: the borrower, a friend) repays a loan before it is due (`hold` the decoded Hold, with its debt): the
+ * debt's `repay` goes to the lender, and the NFT is the borrower's again. Only money moves: anyone then sends the NFT
+ * home with `releaseIx` (in the same transaction, or later: a repaid loan's release has no deadline). Free. `extra`: a
+ * transfer hook's accounts.
+ */
+export declare function repayIx({ payer, project, hold, payerToken, programs, extra }: {
+    extra?: never[] | undefined;
+    hold: any;
+    payer: any;
+    payerToken: any;
+    programs: any;
+    project: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/** What a taker signs: sha256(maker | asset | mint | Borsh(ListingDeal) | Borsh(shares)). */
+export declare function listingTerms(listing: any): Uint8Array<ArrayBuffer>;
+/**
+ * `maker` (any wallet, signing alone) lists an NFT they hold, of any kind (as `piece` takes it), for sale
+ * (`deal: { Sell: { price } }`) or for rent (`{ Rent: { price, lasts, max_periods } }`: `price` a period of `lasts`
+ * seconds, a renter taking 1 to `max_periods` at once), paid in `mint`, `shares` taken before the maker's part. The NFT
+ * goes to the project until it is sold or the listing is closed. The listing's address names the NFT
+ * (`pda.listing(project, asset)`), so a game finds it, and its renter, with one account read.
+ */
+export declare function openListingIx({ maker, project, asset, mint, deal, shares, collection, hasAuthority, tokenMetadata: tm, compressed, extra }: {
+    asset: any;
+    collection: any;
+    compressed: any;
+    deal: any;
+    extra?: never[] | undefined;
+    hasAuthority: any;
+    maker: any;
+    mint: any;
+    project: any;
+    shares?: never[] | undefined;
+    tokenMetadata: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * `taker` takes a listing (`listing`: the decoded Listing), signing its terms: a sale pays its price through the shares
+ * to the maker and hands the NFT over; a rental of `periods` periods (1 to its `max_periods`) pays `price` each and
+ * makes the taker its user until `periods × lasts` from now, refused while another runs. A rental moves no NFT, so it
+ * takes none of the NFT's accounts but its address. `holders`, `programs`, `treasury` as for any split. After the
+ * take's own accounts come a sale's compressed NFT's proof, then the shares' accounts, then (in `extra`) Core's
+ * transfer adapters and any transfer hook's accounts, which the program finds by address after the shares'.
+ */
+export declare function takeListingIx({ taker, project, projectState, listing, periods, collection, hasAuthority, tokenMetadata: tm, compressed, holders, programs, takerToken, extra }: {
+    collection: any;
+    compressed: any;
+    extra?: never[] | undefined;
+    hasAuthority: any;
+    holders: any;
+    listing: any;
+    periods?: number | undefined;
+    programs: any;
+    project: any;
+    projectState: any;
+    taker: any;
+    takerToken: any;
+    tokenMetadata: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * Its maker closes a listing (`listing` the decoded Listing): the NFT goes home. While a rental runs it only stops (no
+ * renter takes it again), and the same call once the rental is over takes it home. Free.
+ */
+export declare function closeListingIx({ maker, project, listing, collection, hasAuthority, tokenMetadata: tm, compressed, extra }: {
+    collection: any;
+    compressed: any;
+    extra?: never[] | undefined;
+    hasAuthority: any;
+    listing: any;
+    maker: any;
+    project: any;
+    tokenMetadata: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * Whether a classic mint's account data (`data`, 82 bytes) is an NFT's, as the program takes one:
+ * exactly one token, no decimals, initialized, and no mint authority or only its edition's. A semi-fungible item's
+ * mint (several units, or one that can still mint) is refused when handed in (`NotAnNft`).
+ */
+export declare function isNftMint(mint: any, data: any): boolean;
+/** A Token Metadata NFT's own addresses: its metadata, its edition, and a pNFT's record of a token account. */
+export declare const tokenMetadata: {
+    metadata: (mint: any) => any;
+    edition: (mint: any) => any;
+    record: (mint: any, token: any) => any;
+};