import { Transaction } from '../transactions.cjs';
/**
 * Base strategy interface that all strategy implementations must conform to
 */
export interface BaseStrategy<TName extends string = string> {
    /** Type discriminator for strategy identification */
    _type: TName;
    /**
     * Execute a function according to the strategy's timing rules
     * @param fn - The function to execute
     * @returns The result of the function execution (if applicable)
     */
    execute: <T extends object = Record<string, unknown>>(fn: () => Transaction<T>) => void | Promise<void>;
    /**
     * Clean up any resources held by the strategy
     * Should be called when the strategy is no longer needed
     */
    cleanup: () => void;
}
/**
 * Options for debounce strategy
 * Delays execution until after a period of inactivity
 */
export interface DebounceStrategyOptions {
    /** Wait time in milliseconds before execution */
    wait: number;
    /** Execute immediately on the first call */
    leading?: boolean;
    /** Execute after the wait period on the last call */
    trailing?: boolean;
}
/**
 * Debounce strategy that delays execution until activity stops
 */
export interface DebounceStrategy extends BaseStrategy<`debounce`> {
    options: DebounceStrategyOptions;
}
/**
 * Options for queue strategy
 * Processes all executions in order (FIFO/LIFO)
 */
export interface QueueStrategyOptions {
    /** Wait time between processing queue items (milliseconds) */
    wait?: number;
    /** Maximum queue size (items are dropped if exceeded) */
    maxSize?: number;
    /** Where to add new items in the queue */
    addItemsTo?: `front` | `back`;
    /** Where to get items from when processing */
    getItemsFrom?: `front` | `back`;
}
/**
 * Queue strategy that processes all executions in order
 * FIFO: { addItemsTo: 'back', getItemsFrom: 'front' }
 * LIFO: { addItemsTo: 'back', getItemsFrom: 'back' }
 */
export interface QueueStrategy extends BaseStrategy<`queue`> {
    options?: QueueStrategyOptions;
}
/**
 * Options for throttle strategy
 * Ensures executions are evenly spaced over time
 */
export interface ThrottleStrategyOptions {
    /** Minimum wait time between executions (milliseconds) */
    wait: number;
    /** Execute immediately on the first call */
    leading?: boolean;
    /** Execute on the last call after wait period */
    trailing?: boolean;
}
/**
 * Throttle strategy that spaces executions evenly over time
 */
export interface ThrottleStrategy extends BaseStrategy<`throttle`> {
    options: ThrottleStrategyOptions;
}
/**
 * Options for batch strategy
 * Groups multiple executions together
 */
export interface BatchStrategyOptions {
    /** Maximum items per batch */
    maxSize?: number;
    /** Maximum wait time before processing batch (milliseconds) */
    wait?: number;
    /** Custom logic to determine when to execute batch */
    getShouldExecute?: (items: Array<any>) => boolean;
}
/**
 * Batch strategy that groups multiple executions together
 */
export interface BatchStrategy extends BaseStrategy<`batch`> {
    options?: BatchStrategyOptions;
}
/**
 * Union type of all available strategies
 */
export type Strategy = DebounceStrategy | QueueStrategy | ThrottleStrategy | BatchStrategy;
/**
 * Extract the options type from a strategy
 */
export type StrategyOptions<T extends Strategy> = T extends DebounceStrategy ? DebounceStrategyOptions : T extends QueueStrategy ? QueueStrategyOptions : T extends ThrottleStrategy ? ThrottleStrategyOptions : T extends BatchStrategy ? BatchStrategyOptions : never;