/**
 * ThreadTS Universal - Core Types
 * Universal TypeScript library for effortless parallel computing
 */
export interface ThreadOptions {
    timeout?: number;
    priority?: 'low' | 'normal' | 'high';
    signal?: AbortSignal;
    transferable?: Transferable[];
    maxRetries?: number;
    poolSize?: number;
    resourceLimits?: {
        maxOldGenerationSizeMb?: number;
        maxYoungGenerationSizeMb?: number;
        codeRangeSizeMb?: number;
        stackSizeMb?: number;
    };
    denoPermissions?: {
        net?: boolean | string[];
        read?: boolean | string[];
        write?: boolean | string[];
        env?: boolean | string[];
        run?: boolean | string[];
        ffi?: boolean | string[];
        hrtime?: boolean;
        sys?: boolean | string[];
    };
    bunOptions?: {
        name?: string;
        credentials?: 'omit' | 'same-origin' | 'include';
        highPrecisionTiming?: boolean;
        forceGC?: boolean;
    };
    workerName?: string;
    isolateContext?: boolean;
    trackResources?: boolean;
}
export interface ThreadTask<TData = SerializableData> {
    fn: SerializableFunction;
    data?: TData;
    options?: ThreadOptions;
}
export interface MapOptions extends ThreadOptions {
    batchSize?: number;
}
export interface ProgressEvent {
    progress: number;
    message?: string;
    data?: unknown;
}
export interface ThreadResult<T = unknown> {
    result: T;
    executionTime: number;
    workerId?: string;
    error?: Error;
}
export interface PoolConfig {
    minWorkers?: number;
    maxWorkers?: number;
    idleTimeout?: number;
    queueSize?: number;
    strategy?: 'round-robin' | 'least-busy' | 'random';
}
export type Platform = 'browser' | 'node' | 'deno' | 'bun' | 'unknown';
export type SerializableFunction = (...args: any[]) => any;
export type SerializableData = string | number | boolean | null | undefined | ArrayBuffer | {
    [key: string]: unknown;
} | unknown[];
export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
export interface WorkerAdapter {
    readonly platform: Platform;
    createWorker(script: string): Promise<WorkerInstance>;
    terminateWorker(worker: WorkerInstance): Promise<void>;
    isSupported(): boolean;
}
export interface WorkerInstance {
    id: string;
    execute<T = unknown>(fn: SerializableFunction, data: SerializableData, options?: ThreadOptions): Promise<ThreadResult<T>>;
    terminate(): Promise<void>;
    isIdle(): boolean;
}
export interface PoolManager {
    execute<T = unknown>(fn: SerializableFunction, data: SerializableData, options?: ThreadOptions): Promise<ThreadResult<T>>;
    resize(size: number): Promise<void>;
    terminate(): Promise<void>;
    getStats(): PoolStats;
}
export interface PoolStats {
    activeWorkers: number;
    idleWorkers: number;
    queuedTasks: number;
    completedTasks: number;
    averageExecutionTime: number;
}
export declare class ThreadError extends Error {
    readonly code: string;
    readonly cause?: Error | undefined;
    constructor(message: string, code: string, cause?: Error | undefined);
}
export declare class TimeoutError extends ThreadError {
    constructor(timeout: number);
}
export declare class WorkerError extends ThreadError {
    constructor(message: string, cause?: Error);
}
export declare class SerializationError extends ThreadError {
    constructor(message: string, cause?: Error);
}
export interface ParallelMethodOptions extends ThreadOptions {
    poolSize?: number;
    cacheResults?: boolean;
}
export interface ProgressTracker {
    on(event: 'progress', handler: (event: ProgressEvent) => void): void;
    off(event: 'progress', handler: (event: ProgressEvent) => void): void;
    emit(event: 'progress', data: ProgressEvent): void;
}
export interface ThreadConfig {
    poolSize: number;
    timeout: number;
    retries: number;
    autoResize: boolean;
    debug: boolean;
    serializationStrategy: 'auto' | 'json' | 'custom';
    enableDecorators: boolean;
    enableMetrics: boolean;
    maxQueueSize: number;
    workerIdleTimeout: number;
    taskPriority: 'low' | 'normal' | 'high';
}
export interface TaskResult {
    success: boolean;
    result: SerializableData | null;
    error: string | null;
}
//# sourceMappingURL=types.d.ts.map