declare const MessageValidationError_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: "MessageValidationError";
} & Readonly<A>;
/**
 * Error types for MessageProcessor operations
 * All errors use Data.TaggedError for type-safe error handling with Effect.
 */
/**
 * Error when message validation fails (e.g., too long)
 */
export declare class MessageValidationError extends MessageValidationError_base<{
    readonly message: string;
    readonly details?: string;
}> {
}
declare const NoRouteFoundError_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: "NoRouteFoundError";
} & Readonly<A>;
/**
 * Error when no route is found for a message
 */
export declare class NoRouteFoundError extends NoRouteFoundError_base<{
    readonly message: string;
}> {
}
/**
 * Route context metadata included in RouteExecutionError for diagnostics
 */
export interface RouteContext {
    /** The agent ID if routing selected an agent */
    readonly agentId?: string;
    /** The intent ID if routing matched an intent */
    readonly intentId?: string;
    /** The pipeline ID if routing matched a pipeline */
    readonly pipelineId?: string;
    /** The method used for route selection */
    readonly selectionType?: 'agent.utterance' | 'intent.matching' | 'pipeline.utterance' | 'default.agent' | 'message.router.rule' | 'message.router.fallback' | 'unknown';
}
declare const RouteExecutionError_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: "RouteExecutionError";
} & Readonly<A>;
/**
 * Error when route execution fails
 * Includes route context metadata for diagnostics when routing has already
 * selected a target (agent, pipeline, or intent).
 */
export declare class RouteExecutionError extends RouteExecutionError_base<{
    /** The type of route that was being executed */
    readonly routeType: string;
    /** The underlying cause of the failure */
    readonly cause: unknown;
    /** Route context metadata - populated when routing selected a target */
    readonly routeContext?: RouteContext;
}> {
}
declare const HandoffError_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: "HandoffError";
} & Readonly<A>;
/**
 * Error when agent handoff fails
 */
export declare class HandoffError extends HandoffError_base<{
    readonly fromAgentId: string;
    readonly toAgentId: string;
    readonly cause: unknown;
}> {
}
declare const ConversationIdRequiredError_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: "ConversationIdRequiredError";
} & Readonly<A>;
/**
 * Error when conversation ID is required but not provided
 */
export declare class ConversationIdRequiredError extends ConversationIdRequiredError_base<{
    readonly reason?: string;
}> {
}
declare const AgentNotFoundError_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: "AgentNotFoundError";
} & Readonly<A>;
/**
 * Error when target agent is not found during routing or handoff
 */
export declare class AgentNotFoundError extends AgentNotFoundError_base<{
    readonly agentId: string;
}> {
}
declare const MaxHandoffDepthError_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: "MaxHandoffDepthError";
} & Readonly<A>;
/**
 * Error when maximum handoff depth is exceeded
 */
export declare class MaxHandoffDepthError extends MaxHandoffDepthError_base<{
    readonly depth: number;
    readonly maxDepth: number;
}> {
}
/**
 * Union type of all MessageProcessor errors
 */
export type MessageProcessorError = MessageValidationError | NoRouteFoundError | RouteExecutionError | HandoffError | ConversationIdRequiredError | AgentNotFoundError | MaxHandoffDepthError;
export {};
//# sourceMappingURL=errors.d.ts.map