declare const PipelineNotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "PipelineNotFoundError";
} & Readonly<A>;
/**
 * Error thrown when a pipeline is not found by ID.
 */
export declare class PipelineNotFoundError extends PipelineNotFoundError_base<{
    readonly id: string;
}> {
}
declare const PipelineAlreadyExistsError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "PipelineAlreadyExistsError";
} & Readonly<A>;
/**
 * Error thrown when attempting to create a pipeline with an ID that already exists.
 */
export declare class PipelineAlreadyExistsError extends PipelineAlreadyExistsError_base<{
    readonly id: string;
}> {
}
declare const PipelineExecutionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "PipelineExecutionError";
} & Readonly<A>;
/**
 * Error thrown when pipeline execution fails.
 */
export declare class PipelineExecutionError extends PipelineExecutionError_base<{
    readonly pipelineId: string;
    readonly step: number;
    readonly cause: unknown;
}> {
}
declare const PipelineStepError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "PipelineStepError";
} & Readonly<A>;
/**
 * Error thrown when a specific pipeline step fails.
 */
export declare class PipelineStepError extends PipelineStepError_base<{
    readonly pipelineId: string;
    readonly stepName: string;
    readonly cause: unknown;
}> {
}
declare const CheckpointNotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "CheckpointNotFoundError";
} & Readonly<A>;
/**
 * Error thrown when a checkpoint is not found.
 */
export declare class CheckpointNotFoundError extends CheckpointNotFoundError_base<{
    readonly runId: string;
    readonly step?: number;
}> {
}
declare const CheckpointExpiredError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "CheckpointExpiredError";
} & Readonly<A>;
/**
 * Error thrown when a checkpoint has expired.
 */
export declare class CheckpointExpiredError extends CheckpointExpiredError_base<{
    readonly runId: string;
}> {
}
declare const PauseNotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "PauseNotFoundError";
} & Readonly<A>;
/**
 * Error thrown when a pause state is not found.
 */
export declare class PauseNotFoundError extends PauseNotFoundError_base<{
    readonly runId: string;
}> {
}
declare const PauseExpiredError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "PauseExpiredError";
} & Readonly<A>;
/**
 * Error thrown when a pause state has expired.
 */
export declare class PauseExpiredError extends PauseExpiredError_base<{
    readonly runId: string;
    readonly expiresAt: Date;
}> {
}
declare const ConcurrencyError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "ConcurrencyError";
} & Readonly<A>;
/**
 * Error thrown when a concurrency issue occurs.
 */
export declare class ConcurrencyError extends ConcurrencyError_base<{
    readonly runId: string;
    readonly operation: string;
}> {
}
declare const GraphValidationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "GraphValidationError";
} & Readonly<A>;
/**
 * Error thrown when graph workflow validation fails.
 */
export declare class GraphValidationError extends GraphValidationError_base<{
    readonly workflowId: string;
    readonly message: string;
}> {
}
declare const ResumeCheckpointNotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "ResumeCheckpointNotFoundError";
} & Readonly<A>;
/**
 * Error thrown when resume fails due to checkpoint not found.
 * Includes checkpoint metadata for diagnostics.
 */
export declare class ResumeCheckpointNotFoundError extends ResumeCheckpointNotFoundError_base<{
    readonly runId: string;
    readonly pipelineId?: string;
}> {
}
declare const ResumeCheckpointExpiredError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "ResumeCheckpointExpiredError";
} & Readonly<A>;
/**
 * Error thrown when resume fails due to checkpoint being expired.
 * Includes checkpoint metadata for diagnostics.
 */
export declare class ResumeCheckpointExpiredError extends ResumeCheckpointExpiredError_base<{
    readonly runId: string;
    readonly pipelineId: string;
    readonly expiresAt: Date;
}> {
}
declare const ResumeInvalidStateError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "ResumeInvalidStateError";
} & Readonly<A>;
/**
 * Error thrown when resume fails due to checkpoint being in invalid state.
 * Includes checkpoint metadata for diagnostics.
 */
export declare class ResumeInvalidStateError extends ResumeInvalidStateError_base<{
    readonly runId: string;
    readonly pipelineId: string;
    readonly step: number;
    readonly status: string;
    readonly expectedStatus: string;
}> {
}
declare const ResumePipelineNotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "ResumePipelineNotFoundError";
} & Readonly<A>;
/**
 * Error thrown when resume fails due to pipeline not found.
 * Includes checkpoint metadata for diagnostics.
 */
export declare class ResumePipelineNotFoundError extends ResumePipelineNotFoundError_base<{
    readonly runId: string;
    readonly pipelineId: string;
}> {
}
declare const ResumeStepNotResolvableError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "ResumeStepNotResolvableError";
} & Readonly<A>;
/**
 * Error thrown when resume fails due to step no longer being resolvable.
 * Includes checkpoint metadata and best-effort recovery information.
 */
export declare class ResumeStepNotResolvableError extends ResumeStepNotResolvableError_base<{
    readonly runId: string;
    readonly pipelineId: string;
    readonly step: number;
    readonly stepName?: string;
    readonly availableSteps: string[];
}> {
}
declare const ResumeNotPausedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "ResumeNotPausedError";
} & Readonly<A>;
/**
 * Error thrown when resumeWithHumanInput fails because checkpoint is not paused.
 * Includes checkpoint metadata for diagnostics.
 */
export declare class ResumeNotPausedError extends ResumeNotPausedError_base<{
    readonly runId: string;
    readonly pipelineId: string;
    readonly step: number;
    readonly status: string;
}> {
}
/**
 * Union type for all pipeline errors, enabling exhaustive catchTag handling.
 */
export type PipelineError = PipelineNotFoundError | PipelineAlreadyExistsError | PipelineExecutionError | PipelineStepError | CheckpointNotFoundError | CheckpointExpiredError | PauseNotFoundError | PauseExpiredError | ConcurrencyError | GraphValidationError | ResumeCheckpointNotFoundError | ResumeCheckpointExpiredError | ResumeInvalidStateError | ResumePipelineNotFoundError | ResumeStepNotResolvableError | ResumeNotPausedError;
/**
 * Union type for resume-specific errors.
 */
export type ResumeError = ResumeCheckpointNotFoundError | ResumeCheckpointExpiredError | ResumeInvalidStateError | ResumePipelineNotFoundError | ResumeStepNotResolvableError | ResumeNotPausedError;
export {};
//# sourceMappingURL=errors.d.ts.map