import Emittery from "emittery";
import type { Config } from "../../config";
import { Disposition, Job, JobFunction } from "../../job";
export interface ItemResult {
    id: string;
    isSuccessful: boolean;
    category: string;
    duration: number;
    error?: Error;
}
export interface CategoryResult {
    isSuccessful: boolean;
    category: string;
    count: number;
}
export interface FunctionResult {
    name: JobFunction;
    duration: number;
    error?: Error;
}
export declare enum ExecutionState {
    NotStarted = "Not Started",
    Initializing = "Initializing",
    GettingItems = "Getting Items",
    Processing = "Processing",
    Finalizing = "Finalizing",
    Complete = "Complete"
}
declare type EventDataMap = {
    started: {
        startedAt: Date;
    };
    stateChanged: {
        state: ExecutionState;
    };
    itemsCounted: {
        count: number;
    };
    itemCompleted: {
        result: ItemResult;
    };
    functionCompleted: {
        result: FunctionResult;
    };
    completed: {
        disposition: Disposition;
        completedAt: Date;
    };
};
export declare enum Events {
    Started = "started",
    StateChanged = "stateChanged",
    ItemsCounted = "itemsCounted",
    ItemCompleted = "itemCompleted",
    FunctionCompleted = "functionCompleted",
    Completed = "completed"
}
export interface Run {
    state: ExecutionState;
    progress: RunProgress;
    results: ItemResult[];
    categories: {
        [id: string]: CategoryResult;
    };
    startedAt: Date;
    completedAt: Date;
    cancelledAt: Date;
    failedAt: Date;
    failedIn: JobFunction;
    failedBecauseOf: Error;
    readonly isRunning: boolean;
    readonly isComplete: boolean;
    readonly isCancelled: boolean;
    readonly isFailed: boolean;
    readonly disposition: Disposition;
}
export interface RunProgress {
    total?: number;
    success: number;
    failed: number;
}
export default class Execution extends Emittery.Typed<EventDataMap, undefined> implements Run {
    constructor(job: Job<Config, unknown>, cfg: Config);
    job: Job<Config, unknown>;
    cfg: Config;
    state: ExecutionState;
    items: unknown[] | Promise<unknown[]> | AsyncIterator<unknown, void, unknown> | Iterator<Promise<unknown> | unknown, void, unknown>;
    totalItemCount?: number;
    successfulItemCount: number;
    failedItemCount: number;
    get progress(): RunProgress;
    results: ItemResult[];
    categories: {
        [id: string]: CategoryResult;
    };
    startedAt: Date;
    completedAt: Date;
    cancelledAt: Date;
    failedAt: Date;
    failedIn: JobFunction;
    failedBecauseOf: Error;
    get isRunning(): boolean;
    get isComplete(): boolean;
    get isCancelled(): boolean;
    get isFailed(): boolean;
    get disposition(): Disposition;
    setState(state: ExecutionState): Promise<void>;
    itemCompleted(result: ItemResult): Promise<void>;
    functionCompleted(handlers: Promise<void>[], func: JobFunction, duration: number, error: Error, throwOnError?: boolean): void;
    cancel(): void;
    itemsIsArray(): boolean;
    start(): Promise<void>;
    processInParallel(iterator: AsyncIterator<unknown, void, unknown>, handlers: Promise<void>[]): Promise<void>;
    processItem(item: unknown, handlers: Promise<void>[]): Promise<void>;
}
export {};