import { ItemId, ItemReference, ItemValue, KioskOwnerCap, Price, PurchaseOptions } from "../types/kiosk.mjs";
import { KioskClient } from "./kiosk-client.mjs";
import { ObjectArgument } from "../types/index.mjs";
import { Transaction, TransactionArgument, TransactionObjectArgument } from "@mysten/sui/transactions";

//#region src/client/kiosk-transaction.d.ts
type KioskTransactionParams = {
  /** The Transaction for this run */transaction: Transaction;
  /**
   * You can create a new KioskClient by calling `new KioskClient()`
   */
  kioskClient: KioskClient;
  /**
   * You can optionally pass in the `cap` as returned
   * from `kioskClient.getOwnedKiosks` when initializing the client
   * Otherwise, you can set it by calling `kioskTransaction.setCap()`
   */
  cap?: KioskOwnerCap;
};
/**
 * A helper for building transactions that involve kiosk.
 */
declare class KioskTransaction {
  #private;
  transaction: Transaction;
  kioskClient: KioskClient;
  kiosk?: TransactionObjectArgument;
  kioskCap?: TransactionObjectArgument;
  constructor({
    transaction,
    kioskClient,
    cap
  }: KioskTransactionParams);
  /**
   * Creates a kiosk and saves `kiosk` and `kioskOwnerCap` in state.
   * Helpful if we want to chain some actions before sharing + transferring the cap to the specified address.
   * @param borrow If true, the `kioskOwnerCap` is borrowed from the `PersonalKioskCap` to be used in next transactions.
   */
  create(): this;
  /**
   * Creates a personal kiosk & shares it.
   * The `PersonalKioskCap` is transferred to the signer.
   * @param borrow If true, the `kioskOwnerCap` is borrowed from the `PersonalKioskCap` to be used in next transactions.
   */
  createPersonal(borrow?: boolean): this;
  /**
   * Converts a kiosk to a Personal (Soulbound) Kiosk.
   * Requires initialization by either calling `ktxb.create()` or `ktxb.setCap()`.
   */
  convertToPersonal(borrow?: boolean): this;
  /**
   * Single function way to create a kiosk, share it and transfer the cap to the specified address.
   */
  createAndShare(address: string): this;
  /**
   * Shares the kiosk.
   */
  share(): this;
  /**
   * Should be called only after `create` is called.
   * It shares the kiosk & transfers the cap to the specified address.
   */
  shareAndTransferCap(address: string): this;
  /**
   * A function to borrow an item from a kiosk & execute any function with it.
   * Example: You could borrow a Fren out of a kiosk, attach an accessory (or mix), and return it.
   */
  borrowTx({
    itemType,
    itemId
  }: ItemId, callback: (item: TransactionArgument) => void): this;
  /**
   * Borrows an item from the kiosk.
   * This will fail if the item is listed for sale.
   *
   * Requires calling `return`.
   */
  borrow({
    itemType,
    itemId
  }: ItemId): [TransactionArgument, TransactionArgument];
  /**
   * Returns the item back to the kiosk.
   * Accepts the parameters returned from the `borrow` function.
   */
  return({
    itemType,
    item,
    promise
  }: ItemValue & {
    promise: TransactionArgument;
  }): this;
  /**
   * A function to withdraw from kiosk
   * @param address Where to transfer the coin.
   * @param amount The amount we aim to withdraw.
   */
  withdraw(address: string, amount?: string | bigint | number): this;
  /**
   * A function to place an item in the kiosk.
   * @param itemType The type `T` of the item
   * @param item The ID or Transaction Argument of the item
   */
  place({
    itemType,
    item
  }: ItemReference): this;
  /**
   * A function to place an item in the kiosk and list it for sale in one transaction.
   * @param itemType The type `T` of the item
   * @param item The ID or Transaction Argument of the item
   * @param price The price in MIST
   */
  placeAndList({
    itemType,
    item,
    price
  }: ItemReference & Price): this;
  /**
   * A function to list an item in the kiosk.
   * @param itemType The type `T` of the item
   * @param itemId The ID of the item
   * @param price The price in MIST
   */
  list({
    itemType,
    itemId,
    price
  }: ItemId & {
    price: string | bigint;
  }): this;
  /**
   * A function to delist an item from the kiosk.
   * @param itemType The type `T` of the item
   * @param itemId The ID of the item
   */
  delist({
    itemType,
    itemId
  }: ItemId): this;
  /**
   * A function to take an item from the kiosk. The transaction won't succeed if the item is listed or locked.
    * @param itemType The type `T` of the item
   * @param itemId The ID of the item
   */
  take({
    itemType,
    itemId
  }: ItemId): TransactionObjectArgument;
  /**
   * Transfer a non-locked/non-listed item to an address.
   *
   * @param itemType The type `T` of the item
   * @param itemId The ID of the item
   * @param address The destination address
   */
  transfer({
    itemType,
    itemId,
    address
  }: ItemId & {
    address: string;
  }): this;
  /**
   * A function to take lock an item in the kiosk.
    * @param itemType The type `T` of the item
   * @param item The ID or Transaction Argument of the item
   * @param itemId The ID of the item - Deprecated: Use `item` instead.
   * @param policy The Policy ID or Transaction Argument for item T
   */
  lock({
    itemType,
    item,
    itemId,
    policy
  }: ItemReference & {
    policy: ObjectArgument;
    itemId?: string;
  }): this;
  /**
   * Purchase an item from a seller's kiosk.
   * Returns [item, transferRequest]
   * Can be called like: `const [item, transferRequest] = kioskTx.purchase({...})`
   * @param itemType The type `T` of the item
   * @param itemId The ID of the item
   * @param price The price in MIST
   * @param sellerKiosk The kiosk which is selling the item. Can be an id or an object argument.
   */
  purchase({
    itemType,
    itemId,
    price,
    sellerKiosk
  }: ItemId & Price & {
    sellerKiosk: ObjectArgument;
  }): [TransactionObjectArgument, TransactionObjectArgument];
  /**
   * A function to purchase and resolve a transfer policy.
   * If the transfer policy has the `lock` rule, the item is locked in the kiosk.
   * Otherwise, the item is placed in the kiosk.
   * @param itemType The type of the item
   * @param itemId The id of the item
   * @param price The price of the specified item
   * @param sellerKiosk The kiosk which is selling the item. Can be an id or an object argument.
   * @param extraArgs Used to pass arguments for custom rule resolvers.
   */
  purchaseAndResolve({
    itemType,
    itemId,
    price,
    sellerKiosk,
    extraArgs
  }: ItemId & Price & {
    sellerKiosk: ObjectArgument;
  } & PurchaseOptions): Promise<this>;
  /**
   * A function to setup the client using an existing `ownerCap`,
   * as return from the `kioskClient.getOwnedKiosks` function.
   * @param cap `KioskOwnerCap` object as returned from `getOwnedKiosks` SDK call.
   */
  setCap(cap: KioskOwnerCap): this | undefined;
  /**
   *	A function that ends up the kiosk building tx & returns the `kioskOwnerCap` back to the
   *  `PersonalKioskCap`, in case we are operating on a personal kiosk.
   * 	It will also share the `kiosk` if it's not shared, and finalize the transfer of the personal cap if it's pending.
   */
  finalize(): void;
  setKioskCap(cap: TransactionObjectArgument): this;
  setKiosk(kiosk: TransactionObjectArgument): this;
  getKiosk(): TransactionObjectArgument;
  getKioskCap(): TransactionObjectArgument;
}
//#endregion
export { KioskTransaction, KioskTransactionParams };
//# sourceMappingURL=kiosk-transaction.d.mts.map