/**
 * SDK Error Hierarchy
 *
 * Provides structured error types for different failure scenarios.
 * All errors extend SDKError for consistent handling.
 */
/**
 * Base error class for all SDK errors
 */
export declare class SDKError extends Error {
    readonly code: string;
    readonly recoverable: boolean;
    readonly timestamp: Date;
    constructor(message: string, code: string, recoverable?: boolean);
    toJSON(): Record<string, unknown>;
}
/**
 * Error from an LLM provider API call
 */
export declare class ProviderError extends SDKError {
    readonly provider: string;
    readonly statusCode?: number | undefined;
    readonly responseBody?: unknown | undefined;
    constructor(message: string, provider: string, statusCode?: number | undefined, responseBody?: unknown | undefined);
    static fromResponse(provider: string, statusCode: number, body: unknown): ProviderError;
}
/**
 * Rate limit exceeded error
 */
export declare class RateLimitError extends ProviderError {
    readonly retryAfterMs?: number | undefined;
    constructor(provider: string, retryAfterMs?: number | undefined);
}
/**
 * Provider authentication failed
 */
export declare class AuthenticationError extends ProviderError {
    constructor(provider: string, message?: string);
}
/**
 * Input validation failed
 */
export declare class ValidationError extends SDKError {
    readonly field: string;
    readonly value?: unknown | undefined;
    constructor(message: string, field: string, value?: unknown | undefined);
    static required(field: string): ValidationError;
    static invalidType(field: string, expected: string, actual: unknown): ValidationError;
}
/**
 * Token limit exceeded
 */
export declare class TokenLimitError extends SDKError {
    readonly requested: number;
    readonly available: number;
    readonly model?: string | undefined;
    constructor(requested: number, available: number, model?: string | undefined);
}
/**
 * Context window overflow
 */
export declare class ContextOverflowError extends SDKError {
    readonly totalTokens: number;
    readonly maxTokens: number;
    constructor(totalTokens: number, maxTokens: number);
}
/**
 * Model not found in registry
 */
export declare class ModelNotFoundError extends SDKError {
    readonly modelName: string;
    constructor(modelName: string);
}
/**
 * Prompt template not found
 */
export declare class PromptNotFoundError extends SDKError {
    readonly promptName: string;
    constructor(promptName: string);
}
/**
 * Configuration error
 */
export declare class ConfigurationError extends SDKError {
    constructor(message: string);
}
/**
 * Request was cancelled
 */
export declare class CancellationError extends SDKError {
    constructor(reason?: string);
}
/**
 * Request timeout
 */
export declare class TimeoutError extends SDKError {
    readonly timeoutMs: number;
    constructor(timeoutMs: number, operation?: string);
}
/**
 * Network connectivity error
 */
export declare class NetworkError extends SDKError {
    readonly originalError?: Error | undefined;
    constructor(message: string, originalError?: Error | undefined);
}
/**
 * Circuit breaker is open
 */
export declare class CircuitOpenError extends SDKError {
    readonly provider: string;
    readonly resetTime?: Date | undefined;
    constructor(provider: string, resetTime?: Date | undefined);
}
export declare function isSDKError(error: unknown): error is SDKError;
export declare function isProviderError(error: unknown): error is ProviderError;
export declare function isRecoverableError(error: unknown): boolean;
export declare const ErrorCode: {
    readonly PROVIDER_ERROR: "PROVIDER_ERROR";
    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
    readonly TOKEN_LIMIT_ERROR: "TOKEN_LIMIT_ERROR";
    readonly CONTEXT_OVERFLOW_ERROR: "CONTEXT_OVERFLOW_ERROR";
    readonly MODEL_NOT_FOUND: "MODEL_NOT_FOUND";
    readonly PROMPT_NOT_FOUND: "PROMPT_NOT_FOUND";
    readonly CONFIGURATION_ERROR: "CONFIGURATION_ERROR";
    readonly CANCELLED: "CANCELLED";
    readonly TIMEOUT: "TIMEOUT";
    readonly NETWORK_ERROR: "NETWORK_ERROR";
    readonly CIRCUIT_OPEN: "CIRCUIT_OPEN";
};
export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
//# sourceMappingURL=index.d.ts.map