import { UserInfo } from '@memberjunction/core';
import { Transform } from 'node:stream';
export type TransformCallback = Parameters<Transform['_flush']>[0];
export type WorkerData<TContext = Record<string, unknown>, TRecord = Record<string, unknown>> = {
    batch?: Array<TRecord>;
    context?: TContext;
};
export type BatchWorkerOptions<TContext = Record<string, unknown>> = {
    /**
     * The number of records to process in a batch
     */
    batchSize?: number;
    /**
     * The path to the worker file used to launch a worker thread
     */
    workerFile?: string;
    /**
     * An abitrary context to pass to the worker thread
     */
    workerContext?: TContext;
    /**
     * The maximum number of worker threads to run concurrently
     */
    concurrencyLimit?: number;
    /**
     * The user context to pass to the worker thread
     */
    contextUser?: UserInfo;
    /**
     * The time to delay between api calls
     **/
    delayTimeMS?: number;
};
/**
 * This class processes records in batches using a worker thread. It expects
 * a worker file that exports a function to process the batch of records.
 * The stream operates in object mode and emits processed records.
 */
export declare class BatchWorker<TRecord = Record<string, unknown>, TContext = Record<string, unknown>> extends Transform {
    _batchSize: number;
    _workerFile: string;
    _workerContext: TContext | Record<string, never>;
    _concurrencyLimit: number;
    _running: number;
    _buffer: Array<TRecord>;
    _queue: Array<() => Promise<void>>;
    _contextUser: UserInfo | undefined;
    /**
     * @param {BatchWorkerOptions} options - Options for the BatchWorker
     */
    constructor(options?: BatchWorkerOptions<TContext>);
    /**
     * Starts the next task in the queue
     */
    _next(): void;
    /**
     * Enqueues a task to be processed
     * @param task - The task to enqueue
     */
    _enqueue(task: () => Promise<void>): void;
    _transform(chunk: TRecord, encoding: BufferEncoding, callback: TransformCallback): Promise<void>;
    _flush(callback: TransformCallback): Promise<void>;
    _processBatchInWorker(batch: Array<TRecord>): Promise<void>;
}
//# sourceMappingURL=BatchWorker.d.ts.map