import { Context } from './context';
export interface Logger {
    info: (message: string, ...args: any[]) => void;
    debug: (message: string, ...args: any[]) => void;
}
export declare class WorkflowError extends Error {
    readonly code: string;
    constructor(message: string, code?: string);
}
export declare class ProcessError extends WorkflowError {
    readonly processId: string;
    readonly originalError: Error;
    readonly strategy: ErrorStrategy;
    constructor(processId: string, originalError: Error, strategy: ErrorStrategy);
}
export type ErrorStrategy = 'silent' | 'throw';
export type ProcessStatus = 'pending' | 'running' | 'completed' | 'skipped' | 'failed';
export type ProcessFunction<T = any> = (context: Context) => Promise<T>;
export type ConditionFunction = (context: Context) => boolean;
export interface Process {
    id: string;
    dependencies: string[];
    execute: ProcessFunction;
    condition?: ConditionFunction;
    errorStrategy: ErrorStrategy;
}
export interface WorkflowConfig {
    processes: Process[];
    initialContext?: Record<string, any>;
    logger?: Logger;
    concurrency?: number;
}
export interface ProcessState {
    id: string;
    status: ProcessStatus;
    dependencies: string[];
    dependents: string[];
    error?: ProcessError | Error;
}
export interface WorkflowResult {
    data: Record<string, any>;
    metadata: {
        states: Record<string, ProcessStatus>;
        errors: Record<string, Error>;
    };
}
//# sourceMappingURL=types.d.ts.map