import type { CapturedHttpErrorResponse } from "../utils/http-inspector";
/** Prefix on errors raised when an Anthropic SSE stream envelope is malformed. */
export declare const STREAM_ENVELOPE_ERROR_PREFIX = "Anthropic stream envelope error:";
/** Structured HTTP errors thrown by provider clients. */
export interface ProviderHttpErrorOptions {
    /** Response headers; enables `retry-after`/rate-limit extraction downstream. */
    headers?: Headers;
    /** Machine-readable error code from the response body (`error.code` / `error.type`). */
    code?: string;
    cause?: unknown;
}
/** Non-2xx HTTP response from a provider. */
export declare class ProviderHttpError extends Error {
    readonly status: number;
    readonly headers: Headers | undefined;
    readonly code: string | undefined;
    constructor(message: string, status: number, options?: ProviderHttpErrorOptions);
}
/** Non-2xx response from an OpenAI-wire endpoint, with the decoded body attached. */
export declare class OpenAIHttpError extends ProviderHttpError {
    readonly captured: CapturedHttpErrorResponse;
    constructor(message: string, captured: CapturedHttpErrorResponse, code?: string, cause?: unknown);
    /**
     * Pull a human-readable message and machine code out of an OpenAI-style error
     * envelope (`{ error: { message, code, type } }`), tolerating the flat shapes
     * compat hosts return (`{ error: "..." }`, `{ message: "..." }`) and falling
     * back to the raw body text.
     */
    static parseEnvelope(bodyJson: unknown, bodyText: string | undefined): {
        detail: string | undefined;
        code: string | undefined;
    };
}
/** Non-2xx response from the Anthropic API. */
export declare class AnthropicApiError extends ProviderHttpError {
    readonly headers: Headers;
    readonly requestId: string | null;
    constructor(status: number, message: string, headers: Headers);
    static fromResponse(response: Response): Promise<AnthropicApiError>;
}
/** Network-level failure (DNS, TLS, socket reset) after retries were exhausted. */
export declare class AnthropicConnectionError extends Error {
    constructor(cause: unknown);
}
/** No response headers arrived within the configured request timeout. */
export declare class AnthropicConnectionTimeoutError extends Error {
    constructor();
}
/**
 * A malformed Anthropic SSE stream envelope — events arriving out of order
 * (before `message_start`) or otherwise violating the message-event grammar.
 * The message is prefixed with {@link STREAM_ENVELOPE_ERROR_PREFIX} so the
 * shared envelope predicates classify it.
 */
export declare class AnthropicStreamEnvelopeError extends Error {
    constructor(detail: string);
}
/** Non-2xx response (or in-stream exception event) from the Bedrock runtime API. */
export declare class BedrockApiError extends ProviderHttpError {
    readonly name = "BedrockApiError";
}
/** Non-2xx response (or in-stream error chunk) from the Cloud Code Assist API. */
export declare class GeminiCliApiError extends ProviderHttpError {
    readonly name = "GeminiCliApiError";
}
/** Non-2xx response (or in-stream error chunk) from the Google Generative Language / Vertex API. */
export declare class GoogleApiError extends ProviderHttpError {
    readonly name = "GoogleApiError";
}
/** Non-2xx response from the Ollama `/api/chat` endpoint. */
export declare class OllamaApiError extends ProviderHttpError {
    readonly name = "OllamaApiError";
}
/** Auth gateway HTTP failure. */
export declare class AuthGatewayError extends ProviderHttpError {
    constructor(message: string, status: number, headers?: Headers, code?: string);
}
export declare class CodexWebSocketTransportError extends Error {
    constructor(detail: string);
}
export declare class CodexWhitespaceToolCallLoopError extends Error {
    constructor(message: string);
}
export declare class CodexProviderStreamError extends Error {
    readonly retryable: boolean;
    constructor(message: string, options?: {
        retryable?: boolean;
        cause?: unknown;
    });
}
export declare class AuthBrokerError extends Error {
    readonly status: number | undefined;
    readonly body: string | undefined;
    constructor(message: string, opts?: {
        status?: number;
        body?: string;
        cause?: unknown;
    });
}
export declare class AuthBrokerStreamUnsupportedError extends AuthBrokerError {
    constructor(message?: string);
}