import { EventEmitter } from "node:events";
export interface TaskState {
    result?: 'completed' | 'timeout' | 'stopped' | 'error' | 'paused';
    error?: Error;
    tsStart?: number;
    tsTimeout?: number;
    promise?: Promise<any>;
}
export interface TaskProps<T, P> {
    timeout?: number;
    state?: any;
    name?: string;
    errorOnTimeout?: boolean;
    log?: (event: any) => void;
    onDone?: (state: T) => P;
    onCancel?: () => void;
}
interface InternalTaskState<P> {
    tsStart?: number;
    tsTimeout?: number;
    timeoutDuration?: number;
    isRunning: boolean;
    timeout?: NodeJS.Timeout;
    promise?: Promise<P>;
    onDone?: (result: P) => void;
    onError?: (error: Error) => void;
    onTimeout?: () => void;
}
export declare class InteruptableTask<T extends TaskState, P> {
    protected state: T;
    protected internalState: InternalTaskState<P>;
    protected props?: TaskProps<T, P>;
    protected internalEvents: EventEmitter<any>;
    protected promise?: Promise<P>;
    protected onStopNotifiers: Array<() => void>;
    protected cancelNotified: boolean;
    constructor(promise: Promise<any>, props?: TaskProps<T, P>);
    getPromise(): Promise<P>;
    getUnderlyingPromise(): Promise<any> | undefined;
    getState(): T;
    run(): Promise<P>;
    notifyOnStop(cb: () => void): void;
    start(): void;
    stop(): Promise<boolean>;
    isRunning(): boolean;
    protected clearTimeout(): void;
    protected onTimeout(): void;
    protected notifyCancel(): void;
    protected sendStopNotification(): void;
    protected logEvent(event: any): void;
}
export {};