import TinyInventory from './TinyInventory.mjs';
export type InventoryMetadata = import('./TinyInventory.mjs').InventoryMetadata;
export type AddItemResult = import('./TinyInventory.mjs').AddItemResult;
export type TransferItemCfg = {
    /**
     * - Sender slot index.
     */
    slotIndex?: number;
    /**
     * - Receiver slot index (optional).
     */
    receiverSlotIndex?: number;
    /**
     * - Sender special slot ID.
     */
    specialSlot?: string;
    /**
     * - Quantity to transfer.
     */
    quantity?: number;
    /**
     * - Whether to force addition even if space is limited.
     */
    forceSpace?: boolean;
    /**
     * - If true, transfer will throw if not all items can fit.
     */
    strict?: boolean;
};
/** @typedef {import('./TinyInventory.mjs').InventoryMetadata} InventoryMetadata */
/** @typedef {import('./TinyInventory.mjs').AddItemResult} AddItemResult */
/**
 * @typedef {Object} TransferItemCfg - Transfer configuration.
 * @property {number} [slotIndex] - Sender slot index.
 * @property {number} [receiverSlotIndex] - Receiver slot index (optional).
 * @property {string} [specialSlot] - Sender special slot ID.
 * @property {number} [quantity=1] - Quantity to transfer.
 * @property {boolean} [forceSpace=false] - Whether to force addition even if space is limited.
   @property {boolean} [strict=false] - If true, transfer will throw if not all items can fit.
 */
/**
 * Class responsible for managing item transfers between two TinyInventory instances.
 */
declare class TinyInventoryTrader {
    #private;
    /** @returns {TinyInventory|null} The currently connected sender inventory. */
    get sender(): TinyInventory | null;
    /** @returns {TinyInventory|null} The currently connected receiver inventory. */
    get receiver(): TinyInventory | null;
    /** @param {TinyInventory} value Sets the sender inventory. */
    set sender(value: TinyInventory);
    /** @param {TinyInventory} value Sets the receiver inventory. */
    set receiver(value: TinyInventory);
    /**
     * Manages item transfers between two TinyInventory instances.
     * @param {TinyInventory} [sender] - Inventory to remove items from.
     * @param {TinyInventory} [receiver] - Inventory to add items to.
     */
    constructor(sender?: TinyInventory, receiver?: TinyInventory);
    /**
     * Connects the sender and receiver inventories for trading.
     * @param {TinyInventory} sender - Inventory to remove items from.
     * @param {TinyInventory} receiver - Inventory to add items to.
     */
    connect(sender: TinyInventory, receiver: TinyInventory): void;
    /**
     * Disconnects the sender and receiver inventories, preventing further transfers.
     */
    disconnect(): void;
    /**
     * Inverts the sender and receiver roles.
     * Useful when performing bidirectional transfers.
     */
    invert(): void;
    /**
     * Transfers an item from sender to receiver.
     *
     * @param {TransferItemCfg} options - Transfer configuration.
     * @returns {Partial<AddItemResult>} Remaining quantity that could NOT be transferred.
     * @throws {Error} If sender or receiver is not connected, item does not exist in sender,
     * or if strict mode is enabled and receiver has no space for full transfer.
     */
    transferItem({ slotIndex, specialSlot, quantity, receiverSlotIndex, forceSpace, strict, }: TransferItemCfg): Partial<AddItemResult>;
    /**
     * Transfers multiple items at once.
     * @param {TransferItemCfg[]} items - Array of transfer configs (see transferItem options).
     * @returns {Partial<AddItemResult>[]} Array of remaining quantities for each item.
     */
    transferMultiple(items: TransferItemCfg[]): Partial<AddItemResult>[];
}
export default TinyInventoryTrader;
//# sourceMappingURL=TinyInventoryTrader.d.mts.map