@skailar-ai/sdk 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,1254 @@
+/**
+ * Shared primitive types used across multiple Skailar API resources.
+ *
+ * @packageDocumentation
+ */
+/**
+ * A string union that keeps IDE autocomplete for known members while still
+ * accepting any arbitrary string.
+ *
+ * TypeScript collapses `"a" | "b" | string` down to `string`, which destroys
+ * editor suggestions. Intersecting the open end with `Record<never, never>`
+ * (spelled `string & {}`) prevents that collapse, so known literals are offered
+ * as completions yet any string remains assignable. Used for model identifiers,
+ * whose catalog evolves faster than this SDK is released.
+ *
+ * @typeParam Known - The union of literal strings to surface as autocomplete hints.
+ *
+ * @example
+ * ```ts
+ * type ModelId = LiteralUnion<"gpt-5" | "claude-opus-4-8">;
+ * const a: ModelId = "gpt-5";          // autocompleted
+ * const b: ModelId = "some-new-model"; // still allowed
+ * ```
+ */
+type LiteralUnion<Known extends string> = Known | (string & Record<never, never>);
+/**
+ * Token accounting returned with every completion, streamed or not.
+ *
+ * Mirrors the OpenAI `usage` object. On a stream each chunk carries the running
+ * totals observed so far rather than a per-chunk delta.
+ */
+interface Usage {
+    /** Tokens consumed by the prompt (input side). */
+    prompt_tokens: number;
+    /** Tokens produced by the model (output side). */
+    completion_tokens: number;
+    /** Sum of {@link Usage.prompt_tokens} and {@link Usage.completion_tokens}. */
+    total_tokens: number;
+}
+
+/**
+ * Types for the chat completions resource (`POST /v1/chat/completions`),
+ * modelled on the OpenAI wire format so the SDK is a drop-in replacement for
+ * `openai` for these calls.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Identifiers of models known to the gateway at the time this SDK was cut, used
+ * to power editor autocomplete.
+ *
+ * This is intentionally a {@link LiteralUnion}: the list is a convenience hint,
+ * not an enforced enum. The authoritative, always-current catalog is
+ * `GET /v1/models`; new models work immediately without an SDK upgrade.
+ */
+type KnownModelId = "epoch-mini" | "claude-opus-4-8" | "claude-opus-4-7" | "claude-sonnet-4-6" | "claude-opus-4-6" | "claude-haiku-4-5" | "claude-sonnet-4-5" | "o3" | "o4-mini" | "gpt-5" | "gpt-5-mini" | "gpt-5.1" | "gpt-5.4" | "gpt-5.4-nano" | "gpt-5.4-mini" | "gpt-5.5" | "gemini-2.5-flash" | "gemini-2.5-pro" | "gemini-2.5-flash-lite" | "gemini-3-flash-preview" | "gemini-3.1-pro-preview" | "gemini-3.5-flash" | "deepseek-v4-flash" | "deepseek-v4-pro" | "grok-4.20-non-reasoning" | "grok-4.20-reasoning" | "grok-4.3" | "grok-build-0.1" | "gpt-image-1";
+/** A model identifier: any known id (with autocomplete) or any other string. */
+type ModelId = LiteralUnion<KnownModelId>;
+/** The conversational role attached to a {@link ChatMessage}. */
+type ChatRole = "system" | "user" | "assistant" | "tool";
+/** A plain-text fragment of multi-part message content. */
+interface TextContentPart {
+    type: "text";
+    /** The literal text contributed by this part. */
+    text: string;
+}
+/**
+ * An image fragment of multi-part message content, used for vision input.
+ *
+ * The `url` may be an inline `data:` URI (base64) or an HTTPS URL, for instance
+ * one returned by `POST /v1/uploads/images`.
+ */
+interface ImageContentPart {
+    type: "image_url";
+    image_url: {
+        /** A `data:` URI or HTTPS URL pointing at the image. */
+        url: string;
+        /**
+         * Requested analysis fidelity: `low` is cheaper/faster, `high` preserves
+         * detail, `auto` lets the upstream provider decide.
+         */
+        detail?: "low" | "high" | "auto";
+    };
+}
+/** A single fragment of structured message content. */
+type ContentPart = TextContentPart | ImageContentPart;
+/**
+ * Message content: a simple string, an ordered array of parts (for mixed text +
+ * vision), or `null` (e.g. an assistant turn that only carries tool calls).
+ */
+type MessageContent = string | ContentPart[] | null;
+/**
+ * One message in a chat conversation.
+ *
+ * For `role: "tool"`, {@link ChatMessage.tool_call_id} is required and must
+ * reference the `id` of the assistant tool call being answered.
+ */
+interface ChatMessage {
+    role: ChatRole;
+    /** The message payload; optional for assistant tool-call-only turns. */
+    content?: MessageContent;
+    /** Tool calls requested by the assistant on this turn, if any. */
+    tool_calls?: ToolCall[];
+    /** Identifier of the tool call this message responds to; required when `role` is `"tool"`. */
+    tool_call_id?: string;
+}
+/**
+ * A function-calling tool definition, OpenAI-compatible.
+ *
+ * @remarks
+ * Tools use the OpenAI shape (`type: "function"`, `function.parameters` as JSON
+ * Schema). The gateway translates this into each provider's native format —
+ * e.g. Anthropic's `input_schema` — so provider-native tool shapes are not
+ * exposed by the SDK in this version.
+ */
+interface Tool {
+    type: "function";
+    function: {
+        /** Unique function name the model may invoke. */
+        name: string;
+        /** Natural-language description guiding when to call it. */
+        description?: string;
+        /**
+         * JSON Schema describing the function's arguments. Left as an open record
+         * because the SDK ships no runtime schema validator.
+         */
+        parameters?: Record<string, unknown>;
+    };
+}
+/**
+ * Controls whether and how the model may call tools: `"auto"` lets the model
+ * decide, `"none"` forbids tool use, `"required"` forces at least one call, and
+ * the object form pins a specific function by name.
+ */
+type ToolChoice = "auto" | "none" | "required" | {
+    type: "function";
+    function: {
+        /** Name of the function to force. */
+        name: string;
+    };
+};
+/** A tool invocation emitted by the assistant. */
+interface ToolCall {
+    /** Stable identifier correlating this call with its tool result. */
+    id: string;
+    type: "function";
+    function: {
+        /** Name of the invoked function. */
+        name: string;
+        /**
+         * JSON-encoded argument object, as a string. Per the OpenAI contract this is
+         * a string of JSON, not a parsed object — callers must `JSON.parse` it.
+         */
+        arguments: string;
+    };
+}
+/**
+ * Reasoning budget for reasoning-capable models (Claude extended thinking,
+ * OpenAI o-series, DeepSeek-R1, Gemini thinking). Ignored by other models.
+ */
+type ReasoningEffort = "low" | "medium" | "high";
+/**
+ * Requested output structure, OpenAI-compatible. Honored only when the selected
+ * upstream model supports it. Use `{ type: "json_object" }` for free-form JSON
+ * or `{ type: "json_schema", json_schema: {...} }` for constrained output.
+ */
+interface ResponseFormat {
+    type: "text" | "json_object" | "json_schema";
+    /** Schema descriptor, present when {@link ResponseFormat.type} is `"json_schema"`. */
+    json_schema?: Record<string, unknown>;
+}
+/**
+ * Request body for `POST /v1/chat/completions`. Field names and semantics match
+ * the OpenAI Chat Completions API. The `stream` field narrows the method's
+ * return type at compile time via overloads on the resource.
+ */
+interface ChatCompletionRequest {
+    /** Model identifier or alias to route the request to. */
+    model: ModelId;
+    /** The ordered conversation history. */
+    messages: ChatMessage[];
+    /** When `true`, responses arrive incrementally as SSE chunks. */
+    stream?: boolean;
+    /** Hard cap on tokens generated for the completion. */
+    max_tokens?: number;
+    /** Sampling temperature in `[0, 2]`; higher is more random. */
+    temperature?: number;
+    /** Nucleus sampling probability mass in `[0, 1]`. */
+    top_p?: number;
+    /** Reasoning budget for reasoning-capable models. */
+    reasoning_effort?: ReasoningEffort;
+    /** Tool definitions the model may call. */
+    tools?: Tool[];
+    /** Constraint on whether/which tools may be called. */
+    tool_choice?: ToolChoice;
+    /** Requested output structure. */
+    response_format?: ResponseFormat;
+    /** Number of independent completions to generate (default `1`). */
+    n?: number;
+    /** Penalty in `[-2, 2]` discouraging repeated topics. */
+    presence_penalty?: number;
+    /** Penalty in `[-2, 2]` discouraging repeated tokens. */
+    frequency_penalty?: number;
+    /** Per-token logit bias map keyed by token id. */
+    logit_bias?: Record<string, number>;
+    /** Opaque stable end-user identifier for abuse monitoring. */
+    user?: string;
+    /** Seed for best-effort deterministic sampling. */
+    seed?: number;
+    /** One or more stop sequences that halt generation. */
+    stop?: string | string[];
+}
+/**
+ * Reason the model stopped generating a choice: `"stop"` natural end,
+ * `"length"` hit the token cap, `"tool_calls"` paused to call tools,
+ * `"content_filter"` blocked by moderation.
+ */
+type FinishReason = "stop" | "length" | "tool_calls" | "content_filter";
+/** A single completed choice within a non-streamed {@link ChatCompletion}. */
+interface ChatCompletionChoice {
+    /** Zero-based position of this choice when `n > 1`. */
+    index: number;
+    message: {
+        role: "assistant";
+        /** The generated text; may be empty when only tool calls are present. */
+        content: string;
+        /** Reasoning trace for models that expose their thinking (e.g. DeepSeek). */
+        reasoning_content?: string;
+        /** Tool calls the assistant requested, if any. */
+        tool_calls?: ToolCall[];
+    };
+    /** Why generation stopped for this choice. */
+    finish_reason: FinishReason;
+}
+/** A complete, non-streamed chat completion (`object: "chat.completion"`). */
+interface ChatCompletion {
+    id: string;
+    object: "chat.completion";
+    /** Creation time as Unix epoch seconds. */
+    created: number;
+    /** The model that actually served the request. */
+    model: string;
+    /** One entry per requested choice. */
+    choices: ChatCompletionChoice[];
+    usage: Usage;
+}
+/**
+ * Incremental tool-call fragment carried by a streamed delta.
+ *
+ * Streaming assembles a tool call across chunks: the first chunk for a given
+ * `index` carries `id`/`name`, subsequent chunks append to `arguments`.
+ */
+interface ChatCompletionChunkToolCall {
+    /** Position of the tool call being assembled. */
+    index: number;
+    /** Tool call id, present on the opening fragment. */
+    id?: string;
+    type?: "function";
+    function?: {
+        /** Function name, present on the opening fragment. */
+        name?: string;
+        /** A slice of the JSON-encoded arguments string to append. */
+        arguments?: string;
+    };
+}
+/** A single choice slice within a streamed {@link ChatCompletionChunk}. */
+interface ChatCompletionChunkChoice {
+    /** Zero-based position of this choice when `n > 1`. */
+    index: number;
+    delta: {
+        /** Present only on the first delta of the choice. */
+        role?: "assistant";
+        /** The text fragment to append to the running content. */
+        content?: string;
+        /** The reasoning-trace fragment to append, if any. */
+        reasoning_content?: string;
+        /** Tool-call fragments to merge by index. */
+        tool_calls?: ChatCompletionChunkToolCall[];
+    };
+    /** Stop reason, present on the terminal slice; may be `null` on intermediate chunks. */
+    finish_reason?: FinishReason | null;
+}
+/** One streamed delta of a chat completion (`object: "chat.completion.chunk"`). */
+interface ChatCompletionChunk {
+    id: string;
+    object: "chat.completion.chunk";
+    /** Creation time as Unix epoch seconds. */
+    created: number;
+    model: string;
+    /** Incremental choice slices for this chunk. */
+    choices: ChatCompletionChunkChoice[];
+    /**
+     * Running token accounting. The Skailar gateway reports cumulative
+     * {@link Usage} on each chunk; treat it as the latest snapshot, not an increment.
+     */
+    usage?: Usage;
+}
+
+/**
+ * A dependency-free Server-Sent Events parser and the {@link ChatCompletionStream}
+ * wrapper that exposes a chat completion SSE response as an abortable async iterable.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Incrementally decode a byte stream into SSE `data:` payload strings, in
+ * arrival order, excluding the terminal `[DONE]` sentinel.
+ *
+ * Implements just the slice of the SSE grammar the gateway emits: UTF-8 `data:`
+ * lines separated by `\n`, events delimited by blank lines, terminated by a
+ * literal `data: [DONE]`. A partial line left in the buffer across reads is
+ * preserved and completed by the next chunk. Comment lines (`:` prefix) and
+ * non-`data:` fields are ignored. Yielding stops at `[DONE]`; reaching
+ * end-of-stream without `[DONE]` simply ends the generator.
+ *
+ * On any exit — normal completion, `[DONE]`, an error, or the consumer
+ * abandoning the `for await` early — the reader is cancelled before its lock is
+ * released, so the underlying fetch connection is torn down instead of leaving
+ * bytes streaming from the network.
+ *
+ * @param stream - The response body as a stream of UTF-8 encoded bytes.
+ * @param signal - Optional abort signal; aborting rejects the iteration.
+ * @returns An async generator yielding the raw string after each `data:` field.
+ * @throws {@link SkailarConnectionError} If the underlying read is aborted or fails.
+ */
+declare function parseSSE(stream: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncGenerator<string, void, unknown>;
+/**
+ * An abortable async iterable of {@link ChatCompletionChunk} values, returned by
+ * `chat.completions.create({ stream: true })`.
+ *
+ * Iterate it with `for await`; each iteration yields one decoded chunk. Mirrors
+ * the ergonomics of `openai-node`'s stream, including the {@link ChatCompletionStream.controller}
+ * for cancellation.
+ *
+ * @example
+ * ```ts
+ * const stream = await client.chat.completions.create({
+ *   model: "gemini-2.5-flash-lite",
+ *   messages: [{ role: "user", content: "hi" }],
+ *   stream: true,
+ * });
+ * for await (const chunk of stream) {
+ *   process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
+ * }
+ * ```
+ */
+declare class ChatCompletionStream implements AsyncIterable<ChatCompletionChunk> {
+    /**
+     * The {@link AbortController} governing the underlying HTTP request. Call
+     * `stream.controller.abort()` to cancel an in-flight stream; the active
+     * `for await` loop then terminates promptly.
+     */
+    readonly controller: AbortController;
+    /** The raw SSE byte stream backing this iterator. */
+    private readonly body;
+    /**
+     * @param body - The response body stream of SSE bytes.
+     * @param controller - The abort controller tied to the originating request.
+     */
+    constructor(body: ReadableStream<Uint8Array>, controller: AbortController);
+    /**
+     * Decode the SSE byte stream into typed chunks.
+     *
+     * Each `data:` payload is `JSON.parse`d. If a payload carries an `error` field
+     * (the gateway's in-band failure signal), iteration throws the corresponding
+     * {@link SkailarAPIError} instead of yielding. Malformed JSON payloads are
+     * skipped defensively.
+     *
+     * @returns An async generator over {@link ChatCompletionChunk} values.
+     * @throws {@link SkailarAPIError} When the stream delivers an in-band error event.
+     * @throws {@link SkailarConnectionError} When the stream is aborted or read fails.
+     */
+    private decode;
+    /**
+     * Iterate the decoded chunks. Abandoning the iteration early (a `break` or
+     * `return` inside a `for await`) invokes the returned iterator's `return()`,
+     * which aborts {@link ChatCompletionStream.controller} so the underlying fetch
+     * request is cancelled — not merely the body reader — and then runs the
+     * generator's own cleanup ({@link parseSSE}'s `finally`: reader cancel +
+     * lock release). Normal completion and thrown errors are unaffected.
+     *
+     * @returns An async iterator over {@link ChatCompletionChunk} values.
+     */
+    [Symbol.asyncIterator](): AsyncIterator<ChatCompletionChunk>;
+}
+
+/**
+ * The chat resource, exposing `client.chat.completions.create(...)` with the
+ * same call shape as `openai`'s chat completions.
+ *
+ * @packageDocumentation
+ */
+
+/** A chat completion request that explicitly opts into streaming. */
+interface StreamingRequest extends ChatCompletionRequest {
+    stream: true;
+}
+/** A chat completion request that does not stream. */
+interface NonStreamingRequest extends ChatCompletionRequest {
+    stream?: false;
+}
+/**
+ * The `completions` sub-namespace of the chat resource. Holds
+ * {@link ChatCompletions.create}, whose return type is narrowed by the `stream`
+ * field of the request via overloads.
+ */
+declare class ChatCompletions {
+    /** The owning client used to dispatch requests. */
+    private readonly client;
+    /** @param client - The owning {@link Skailar} client. */
+    constructor(client: Skailar);
+    /**
+     * Create a buffered (non-streamed) chat completion.
+     *
+     * @param body - The request with `stream` omitted or `false`.
+     * @param options - Optional per-call signal, timeout and headers.
+     * @returns The fully-formed {@link ChatCompletion}.
+     */
+    create(body: NonStreamingRequest, options?: RequestOptions): Promise<ChatCompletion>;
+    /**
+     * Create a streamed chat completion.
+     *
+     * @param body - The request with `stream: true`.
+     * @param options - Optional per-call signal, timeout and headers. The stream
+     * is also cancellable via its `.controller`.
+     * @returns A {@link ChatCompletionStream} async-iterable of chunks, exposing
+     * `.controller` for cancellation.
+     */
+    create(body: StreamingRequest, options?: RequestOptions): Promise<ChatCompletionStream>;
+    /**
+     * Create a chat completion whose mode is chosen at runtime. Use this form when
+     * `stream` is a non-literal `boolean` (e.g. `stream: shouldStream`), where the
+     * concrete return type cannot be known at compile time; narrow the result with
+     * `instanceof ChatCompletionStream` or by checking the `stream` flag yourself.
+     *
+     * @param body - The request with a dynamic `stream` boolean.
+     * @param options - Optional per-call signal, timeout and headers.
+     * @returns Either a {@link ChatCompletion} or a {@link ChatCompletionStream}.
+     */
+    create(body: ChatCompletionRequest & {
+        stream?: boolean;
+    }, options?: RequestOptions): Promise<ChatCompletion | ChatCompletionStream>;
+}
+/** The chat resource root, mirroring `openai`'s `client.chat`. */
+declare class ChatResource {
+    /** The chat completions namespace. */
+    readonly completions: ChatCompletions;
+    /** @param client - The owning {@link Skailar} client. */
+    constructor(client: Skailar);
+}
+
+/**
+ * Types for the models resource (`GET /v1/models` and `GET /v1/models/{id}`).
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * The provider that owns/serves a model. Kept as a {@link LiteralUnion} rather
+ * than a closed enum so the gateway may onboard new providers without an SDK release.
+ */
+type ModelOwner = LiteralUnion<"skailar" | "anthropic" | "openai" | "google" | "deepseek" | "xai">;
+/**
+ * Lifecycle status of a model. The live gateway returns values such as
+ * `"available"` and `"beta"`; modelled as a {@link LiteralUnion} so any
+ * server-side value parses without breaking the client.
+ */
+type ModelStatus = LiteralUnion<"available" | "beta" | "active" | "preview" | "deprecated">;
+/** Capability flags describing what a model can do. */
+interface ModelCapabilities {
+    /** Whether the model supports incremental SSE streaming. */
+    streaming: boolean;
+    /** Whether the model can emit function/tool calls. */
+    tool_calls: boolean;
+    /** Whether the model accepts image input (vision). */
+    vision: boolean;
+    /** Whether the model honors structured JSON output modes. */
+    json_mode: boolean;
+    /** Whether the model exposes a reasoning/thinking mode; `null` if unclassified. */
+    reasoning?: boolean | null;
+}
+/** Per-token pricing for a model. */
+interface ModelPricing {
+    /** Cost per one million input tokens, in {@link ModelPricing.currency}. */
+    input_per_mtok: number;
+    /** Cost per one million output tokens, in {@link ModelPricing.currency}. */
+    output_per_mtok: number;
+    /** ISO 4217 currency code (e.g. `"USD"`). */
+    currency: string;
+}
+/** Summary card for a model as returned by `GET /v1/models`. */
+interface ModelSummary {
+    id: string;
+    object: "model";
+    /** Creation/registration time as Unix epoch seconds. */
+    created: number;
+    owned_by: ModelOwner;
+    /** Human-friendly display name. */
+    display_name: string;
+    /** Maximum context window size in tokens. */
+    context_window: number;
+    /** Maximum tokens the model may generate in one response. */
+    max_output_tokens: number;
+    capabilities: ModelCapabilities;
+    pricing: ModelPricing;
+    status: ModelStatus;
+}
+/**
+ * Full detail card for a model as returned by `GET /v1/models/{id}`. Extends
+ * {@link ModelSummary} with descriptive and routing metadata; all extended
+ * fields are optional because availability varies by provider.
+ */
+interface Model extends ModelSummary {
+    /** Long-form description of the model. */
+    description?: string;
+    modalities?: {
+        /** Accepted input modalities (e.g. `["text", "image"]`). */
+        input?: string[];
+        /** Produced output modalities (e.g. `["text"]`). */
+        output?: string[];
+    };
+    /** Names of request parameters the model honors. */
+    supported_parameters?: string[];
+    /** Training knowledge cutoff, as a date-like string. */
+    knowledge_cutoff?: string;
+    /** Public release date, as a date-like string. */
+    released_at?: string;
+    /** URL of upstream provider documentation. */
+    documentation_url?: string;
+    /** Alternate identifiers that resolve to this model. */
+    aliases?: string[];
+}
+/** Envelope returned by `GET /v1/models`. */
+interface ModelList {
+    object: "list";
+    data: ModelSummary[];
+}
+
+/**
+ * The models resource, exposing `client.models.list()` and
+ * `client.models.retrieve(id)`.
+ *
+ * @packageDocumentation
+ */
+
+/** Model discovery operations. */
+declare class ModelsResource {
+    /** The owning client used to dispatch requests. */
+    private readonly client;
+    /** @param client - The owning {@link Skailar} client. */
+    constructor(client: Skailar);
+    /**
+     * List every model the gateway can route to. Unwraps the
+     * `{ object: "list", data }` envelope and returns just `data` as a plain array.
+     *
+     * @param options - Optional per-call signal, timeout and headers.
+     * @returns A promise resolving to the array of {@link ModelSummary} cards.
+     */
+    list(options?: RequestOptions): Promise<ModelSummary[]>;
+    /**
+     * Retrieve the full detail card for a single model.
+     *
+     * @param id - The model identifier; may contain slashes (e.g.
+     * `"google/gemini-2.5-pro"`), which are preserved in the path.
+     * @param options - Optional per-call signal, timeout and headers.
+     * @returns A promise resolving to the {@link Model} detail.
+     * @throws {@link SkailarNotFoundError} If no model matches the id.
+     */
+    retrieve(id: string, options?: RequestOptions): Promise<Model>;
+}
+
+/**
+ * Types for the image generation resource (`POST /v1/images/generations`).
+ *
+ * @packageDocumentation
+ */
+
+/** Request body for `POST /v1/images/generations`. */
+interface ImageGenerationRequest {
+    /** Image model identifier (e.g. `"gpt-image-1"`). */
+    model: ModelId;
+    /** Natural-language description of the desired image. */
+    prompt: string;
+    /** Number of images to generate, in `[1, 10]` (default `1`). */
+    n?: number;
+    /** Output resolution, e.g. `"1024x1024"`; accepted values depend on the provider. */
+    size?: string;
+    /** Provider-specific quality hint (e.g. `"standard"`, `"hd"`). */
+    quality?: string;
+    /** Provider-specific background hint (e.g. `"transparent"`). */
+    background?: string;
+}
+/**
+ * A single generated image. Exactly one of {@link GeneratedImage.url} or
+ * {@link GeneratedImage.b64_json} is populated, depending on the provider's
+ * delivery mode.
+ */
+interface GeneratedImage {
+    /** HTTPS URL of the generated image, when delivered by reference. */
+    url?: string;
+    /** Base64-encoded image bytes, when delivered inline. */
+    b64_json?: string;
+    /** The prompt after any provider-side rewriting, if applicable. */
+    revised_prompt?: string;
+}
+/** Response body for `POST /v1/images/generations`. */
+interface ImageGenerationResponse {
+    /** Creation time as Unix epoch seconds. */
+    created: number;
+    data: GeneratedImage[];
+}
+
+/**
+ * The images resource, exposing `client.images.generate(...)`.
+ *
+ * @packageDocumentation
+ */
+
+/** Image generation operations. */
+declare class ImagesResource {
+    /** The owning client used to dispatch requests. */
+    private readonly client;
+    /** @param client - The owning {@link Skailar} client. */
+    constructor(client: Skailar);
+    /**
+     * Generate one or more images from a text prompt. Named `generate` to match
+     * `openai`'s `images.generate(...)`.
+     *
+     * @param body - The generation request; see {@link ImageGenerationRequest}.
+     * @param options - Optional per-call signal, timeout and headers.
+     * @returns A promise resolving to the {@link ImageGenerationResponse}, whose
+     * `data` entries carry either a `url` or inline `b64_json`.
+     * @throws {@link SkailarBadRequestError} On HTTP 400.
+     * @throws {@link SkailarRateLimitError} On HTTP 429 (after exhausting retries).
+     */
+    generate(body: ImageGenerationRequest, options?: RequestOptions): Promise<ImageGenerationResponse>;
+}
+
+/**
+ * Types for the audio resource: transcription (`POST /v1/audio/transcriptions`)
+ * and speech synthesis (`POST /v1/audio/speech`).
+ *
+ * @packageDocumentation
+ */
+/**
+ * Binary payload accepted by SDK methods that upload bytes. The SDK normalizes
+ * any of these into the base64 string the gateway expects, so callers may pass
+ * whichever representation they already hold.
+ *
+ * A `string` is treated as **already-encoded** base64 (no `data:` prefix) and is
+ * forwarded without validation — pass a `Uint8Array`/`ArrayBuffer`/`Blob` for
+ * raw bytes, since raw text passed as a string decodes to corrupt data server-side.
+ */
+type BinaryInput = Uint8Array | ArrayBuffer | Blob | string;
+/** Audio MIME types accepted by the transcription endpoint. */
+type TranscriptionMime = "audio/wav" | "audio/webm" | "audio/mp4" | "audio/m4a" | "audio/mpeg" | "audio/mp3";
+/**
+ * Parameters for {@link AudioTranscriptions.create}. Callers pass the raw audio
+ * as `file`; the SDK base64-encodes it into the wire field.
+ */
+interface TranscriptionCreateParams {
+    /** The audio to transcribe, in any {@link BinaryInput} form. */
+    file: BinaryInput;
+    /**
+     * MIME type of the supplied audio (default `"audio/wav"`). If `file` is a
+     * {@link Blob} with a `type`, that type is used when this is omitted.
+     */
+    mime?: TranscriptionMime;
+}
+/** Wire request body for `POST /v1/audio/transcriptions`. */
+interface TranscriptionRequest {
+    /** Base64-encoded audio bytes with no `data:` prefix. */
+    base64: string;
+    mime?: TranscriptionMime;
+}
+/** Response body for `POST /v1/audio/transcriptions`. */
+interface TranscriptionResponse {
+    /** The transcribed text. */
+    text: string;
+}
+/** Voices available for speech synthesis. */
+type SpeechVoice = "alloy" | "ash" | "ballad" | "coral" | "echo" | "fable" | "nova" | "onyx" | "sage" | "shimmer";
+/** Parameters for {@link AudioSpeech.create}. */
+interface SpeechCreateParams {
+    /** Text to synthesize; limited to 4000 characters by the gateway. */
+    input: string;
+    /** Voice to speak with (default `"nova"`). */
+    voice?: SpeechVoice;
+}
+/** Wire request body for `POST /v1/audio/speech`. */
+interface SpeechRequest {
+    /** Text to synthesize (max 4000 characters). */
+    input: string;
+    voice?: SpeechVoice;
+}
+
+/**
+ * The audio resource, exposing `client.audio.transcriptions.create(...)` and
+ * `client.audio.speech.create(...)`.
+ *
+ * @packageDocumentation
+ */
+
+/** Audio transcription operations (speech-to-text, Whisper-backed). */
+declare class AudioTranscriptions {
+    /** The owning client used to dispatch requests. */
+    private readonly client;
+    /** @param client - The owning {@link Skailar} client. */
+    constructor(client: Skailar);
+    /**
+     * Transcribe an audio clip to text. The supplied bytes are base64-encoded
+     * client-side into the gateway's `base64` field. When `mime` is omitted and
+     * `file` is a {@link Blob} carrying a `type`, that type is used; otherwise the
+     * gateway default (`audio/wav`) applies.
+     *
+     * @param params - The audio and its MIME type; see {@link TranscriptionCreateParams}.
+     * `file` may be a {@link Uint8Array}, {@link ArrayBuffer}, {@link Blob} or a
+     * pre-encoded base64 string.
+     * @param options - Optional per-call signal, timeout and headers.
+     * @returns A promise resolving to the {@link TranscriptionResponse}.
+     */
+    create(params: TranscriptionCreateParams, options?: RequestOptions): Promise<TranscriptionResponse>;
+}
+/** Speech synthesis operations (text-to-speech). */
+declare class AudioSpeech {
+    /** The owning client used to dispatch requests. */
+    private readonly client;
+    /** @param client - The owning {@link Skailar} client. */
+    constructor(client: Skailar);
+    /**
+     * Synthesize speech and return the raw MP3 audio stream. Unlike the JSON
+     * endpoints, this returns the response body stream directly so large audio
+     * payloads need not be buffered in memory.
+     *
+     * Pass `options.signal` to cancel the request: aborting it before the response
+     * arrives rejects this call, and aborting it while the MP3 is still downloading
+     * tears down the underlying connection so the body stops mid-stream.
+     *
+     * @param params - The text and voice; see {@link SpeechCreateParams}.
+     * @param options - Optional per-call signal, timeout and headers.
+     * @returns A promise resolving to a `ReadableStream<Uint8Array>` of
+     * `audio/mpeg` bytes, suitable for piping to a file, an HTTP response, or an
+     * audio element.
+     * @throws {@link SkailarConnectionError} If the response unexpectedly lacks a body.
+     * @throws {@link SkailarBadRequestError} On HTTP 400 (e.g. text exceeding 4000 chars).
+     */
+    create(params: SpeechCreateParams, options?: RequestOptions): Promise<ReadableStream<Uint8Array>>;
+}
+/** The audio resource root, grouping transcription and speech. */
+declare class AudioResource {
+    /** Speech-to-text operations. */
+    readonly transcriptions: AudioTranscriptions;
+    /** Text-to-speech operations. */
+    readonly speech: AudioSpeech;
+    /** @param client - The owning {@link Skailar} client. */
+    constructor(client: Skailar);
+}
+
+/**
+ * Types for the uploads resource: image uploads (`POST /v1/uploads/images`) and
+ * file uploads (`POST /v1/uploads/files`).
+ *
+ * @packageDocumentation
+ */
+
+/** Content types accepted by `POST /v1/uploads/images`. */
+type ImageContentType = "image/png" | "image/jpeg" | "image/gif" | "image/webp";
+/** Content types accepted by `POST /v1/uploads/files`. */
+type FileContentType = "application/pdf" | "text/plain";
+/**
+ * Parameters for `client.uploads.images.create`. Callers pass raw bytes as
+ * `data`; the SDK base64-encodes them into the wire `base64` field.
+ */
+interface ImageUploadCreateParams {
+    /** The image bytes, in any {@link BinaryInput} form. */
+    data: BinaryInput;
+    /** MIME type of the image being uploaded. */
+    contentType: ImageContentType;
+}
+/** Parameters for `client.uploads.files.create`. */
+interface FileUploadCreateParams {
+    /** The document bytes, in any {@link BinaryInput} form. */
+    data: BinaryInput;
+    /** MIME type of the document being uploaded. */
+    contentType: FileContentType;
+}
+/** Wire request body shared by both upload endpoints. */
+interface UploadRequest {
+    /** Base64-encoded payload with no `data:` prefix. */
+    base64: string;
+    /** MIME type of the encoded payload. */
+    content_type: string;
+}
+/** Response body for the upload endpoints. */
+interface UploadResponse {
+    /**
+     * URL of the stored asset, ready to embed in subsequent calls — for example
+     * as the `url` of a vision {@link ImageContentPart}.
+     */
+    url: string;
+    /** MIME type the asset was stored as. */
+    content_type: string;
+}
+
+/**
+ * The uploads resource, exposing `client.uploads.images.create(...)` and
+ * `client.uploads.files.create(...)` for storing assets in Skailar storage and
+ * receiving an embeddable URL.
+ *
+ * @packageDocumentation
+ */
+
+/** Image upload operations (`POST /v1/uploads/images`). */
+declare class ImageUploads {
+    /** The owning client used to dispatch requests. */
+    private readonly client;
+    /** @param client - The owning {@link Skailar} client. */
+    constructor(client: Skailar);
+    /**
+     * Upload an image and obtain a URL usable as vision input. `data` may be a
+     * {@link Uint8Array}, {@link ArrayBuffer}, {@link Blob} or a pre-encoded base64
+     * string; it is base64-encoded client-side into the gateway's `base64` field.
+     *
+     * @param params - The image bytes and content type; see {@link ImageUploadCreateParams}.
+     * @returns A promise resolving to the {@link UploadResponse} whose `url` can be
+     * embedded in a chat completion as an `image_url` content part.
+     */
+    create(params: ImageUploadCreateParams): Promise<UploadResponse>;
+}
+/** File upload operations (`POST /v1/uploads/files`). */
+declare class FileUploads {
+    /** The owning client used to dispatch requests. */
+    private readonly client;
+    /** @param client - The owning {@link Skailar} client. */
+    constructor(client: Skailar);
+    /**
+     * Upload a document (`application/pdf` or `text/plain`). `data` accepts the
+     * same forms as image upload and is base64-encoded client-side.
+     *
+     * @param params - The document bytes and content type; see {@link FileUploadCreateParams}.
+     * @returns A promise resolving to the {@link UploadResponse} with the stored asset URL.
+     */
+    create(params: FileUploadCreateParams): Promise<UploadResponse>;
+}
+/** The uploads resource root, grouping image and file uploads. */
+declare class UploadsResource {
+    /** Image upload operations. */
+    readonly images: ImageUploads;
+    /** File/document upload operations. */
+    readonly files: FileUploads;
+    /** @param client - The owning {@link Skailar} client. */
+    constructor(client: Skailar);
+}
+
+/**
+ * Barrel re-exporting every public type of the Skailar SDK.
+ *
+ * @packageDocumentation
+ */
+
+/** Response body for `GET /v1/ping-key`. */
+interface PingKeyResponse {
+    /** Always `"ok"` when the key is valid. */
+    status: "ok";
+    /** UUID of the account that owns the validated key. */
+    user_id: string;
+}
+
+/**
+ * The {@link Skailar} client: configuration, the shared fetch dispatch pipeline
+ * (timeout, retry with backoff, error mapping) and the resource namespaces hung
+ * off it.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Configuration accepted by the {@link Skailar} constructor. Every field is
+ * optional; omitted fields fall back to environment variables or library
+ * defaults as documented per property.
+ */
+interface SkailarOptions {
+    /**
+     * Skailar API key of the form `skl_live_<43 url-safe base64 chars>`. Defaults
+     * to `process.env.SKAILAR_API_KEY`; if neither is provided the constructor throws.
+     *
+     * @remarks
+     * The format is **not** validated locally — only emptiness is checked. A
+     * malformed or wrong-provider key (e.g. an OpenAI `sk-...` key passed by
+     * mistake) is accepted here and rejected at the first request with a
+     * {@link SkailarAuthError} (HTTP 401).
+     */
+    apiKey?: string;
+    /**
+     * Base URL of the gateway, without a trailing `/v1` (default
+     * `"https://api.skailar.com"`). The `/v1/...` path is appended by the SDK.
+     * Point this at `http://localhost:8080` for a local gateway.
+     */
+    baseURL?: string;
+    /**
+     * Per-request timeout in milliseconds (default `60000`). Applies to each
+     * attempt independently; a timed-out attempt becomes a
+     * {@link SkailarConnectionError} and is eligible for retry.
+     */
+    timeout?: number;
+    /**
+     * Maximum automatic retries for transient failures (default `2`). Retries
+     * apply only to HTTP 429, HTTP 5xx, and connection errors; non-429 4xx
+     * responses are never retried.
+     */
+    maxRetries?: number;
+    /**
+     * Custom `fetch` implementation, primarily for testing (default global
+     * `fetch`). No binding is applied; pass an already-bound function if your
+     * implementation requires a specific receiver.
+     */
+    fetch?: typeof fetch;
+    /**
+     * Headers merged into every request. The SDK's own `Authorization`,
+     * `Content-Type` and `Accept`, plus explicit per-call headers, take precedence.
+     */
+    defaultHeaders?: Record<string, string>;
+}
+/**
+ * Per-call request options accepted as the trailing argument of every resource
+ * method (e.g. `chat.completions.create(body, options)`). Mirrors the
+ * `openai-node` convention so the wire body stays separate from transport
+ * concerns. Every field is optional and overrides the client-level default for
+ * this one call.
+ */
+interface RequestOptions {
+    /**
+     * Signal to cancel this call. Aborting before the response arrives rejects the
+     * call with a {@link SkailarConnectionError}; for streaming/audio bodies,
+     * aborting mid-transfer tears down the connection.
+     */
+    signal?: AbortSignal;
+    /**
+     * Per-call timeout in milliseconds, overriding {@link SkailarOptions.timeout}
+     * for this request only.
+     */
+    timeout?: number;
+    /** Extra headers merged into this request, overriding client defaults. */
+    headers?: Record<string, string>;
+}
+/** Internal description of a single HTTP request to dispatch. */
+interface InternalRequest {
+    method: "GET" | "POST";
+    /** Path beginning with `/v1/...`, relative to {@link SkailarOptions.baseURL}. */
+    path: string;
+    /** Optional JSON body; serialized with `JSON.stringify`. */
+    body?: unknown;
+    /** Extra headers for this request only. */
+    headers?: Record<string, string>;
+    /** Expected response handling: parsed JSON, raw `Response`, or SSE stream. */
+    expect: "json" | "response" | "stream";
+    /**
+     * External abort signal composed with the timeout. Used for streaming, where
+     * the caller-visible {@link ChatCompletionStream.controller} drives cancellation.
+     */
+    signal?: AbortSignal;
+    /** Per-call timeout override in ms; falls back to {@link Skailar.timeout}. */
+    timeout?: number;
+}
+/**
+ * The official Skailar API client. Construct once and reuse. Resource namespaces
+ * ({@link Skailar.chat}, {@link Skailar.models}, etc.) provide the
+ * OpenAI-compatible and Skailar-native operations. All network access flows
+ * through {@link Skailar.request}, which centralizes authentication, timeouts,
+ * retries and error mapping.
+ *
+ * @example
+ * ```ts
+ * import Skailar from "@skailar-ai/sdk";
+ * const client = new Skailar({ apiKey: "skl_live_..." });
+ * const res = await client.chat.completions.create({
+ *   model: "claude-sonnet-4-6",
+ *   messages: [{ role: "user", content: "Hello!" }],
+ * });
+ * console.log(res.choices[0]?.message.content);
+ * ```
+ */
+declare class Skailar {
+    /** Resolved API key sent as the bearer token. */
+    readonly apiKey: string;
+    /** Resolved base URL with any trailing slash removed. */
+    readonly baseURL: string;
+    /** Resolved per-attempt timeout in milliseconds. */
+    readonly timeout: number;
+    /** Resolved maximum retry count. */
+    readonly maxRetries: number;
+    /** Default headers merged into every request. */
+    readonly defaultHeaders: Record<string, string>;
+    /** The `fetch` implementation used for all requests. */
+    private readonly fetchImpl;
+    /** Chat completions (OpenAI-compatible). */
+    readonly chat: ChatResource;
+    /** Model discovery. */
+    readonly models: ModelsResource;
+    /** Image generation. */
+    readonly images: ImagesResource;
+    /** Speech synthesis and transcription. */
+    readonly audio: AudioResource;
+    /** Direct uploads to Skailar storage. */
+    readonly uploads: UploadsResource;
+    /**
+     * @param options - Client configuration; see {@link SkailarOptions}.
+     * @throws If no API key is resolvable (neither `options.apiKey` nor
+     * `SKAILAR_API_KEY`). A key that is present but malformed is **not** rejected
+     * here; it fails at the first request with a {@link SkailarAuthError}.
+     */
+    constructor(options?: SkailarOptions);
+    /**
+     * Verify the configured API key against `GET /v1/ping-key`.
+     *
+     * @param options - Optional per-call signal, timeout and headers.
+     * @returns The `{ status, user_id }` payload when the key is valid.
+     * @throws {@link SkailarAuthError} If the key is missing, invalid or revoked.
+     */
+    ping(options?: RequestOptions): Promise<PingKeyResponse>;
+    /**
+     * Dispatch a request expecting a JSON body, with retries.
+     *
+     * @typeParam T - The expected shape of the parsed JSON response.
+     * @param options - The request description.
+     * @returns The parsed JSON response body typed as `T`.
+     */
+    request<T>(options: InternalRequest & {
+        expect: "json";
+    }): Promise<T>;
+    /**
+     * Dispatch a request expecting the raw {@link Response}, with retries.
+     *
+     * @param options - The request description.
+     * @returns The successful `Response`, body unread (e.g. for audio streams).
+     */
+    request(options: InternalRequest & {
+        expect: "response";
+    }): Promise<Response>;
+    /**
+     * Dispatch a streaming request, returning a chat completion stream.
+     *
+     * @param options - The request description with `expect: "stream"`.
+     * @returns A {@link ChatCompletionStream} over the SSE response.
+     */
+    request(options: InternalRequest & {
+        expect: "stream";
+    }): Promise<ChatCompletionStream>;
+    /**
+     * Assemble the outgoing header set for a request, applying defaults, auth,
+     * content-type and accept in precedence order.
+     *
+     * @param options - The request description.
+     * @returns The header record to send.
+     */
+    private buildHeaders;
+    /**
+     * Convert a non-2xx {@link Response} into the most specific
+     * {@link SkailarAPIError} subclass. Reads the body once, attempting JSON first
+     * and falling back to raw text, then defers classification to
+     * {@link SkailarAPIError.from}.
+     *
+     * @param response - The failed HTTP response.
+     * @returns The mapped error.
+     */
+    private toApiError;
+    /**
+     * Whether a status code is eligible for automatic retry (429 and any 5xx).
+     *
+     * @param status - The HTTP status code.
+     * @returns `true` if retryable.
+     */
+    private isRetryableStatus;
+    /**
+     * Whether another attempt remains within the retry budget.
+     *
+     * @param attempt - The count of attempts already made (before increment).
+     * @returns `true` if a retry is permitted.
+     */
+    private shouldRetry;
+    /**
+     * Compute a full-jitter exponential backoff delay: a random value in
+     * `[0, min(cap, base * 2^attempt))`, capped at 8000ms. Jitter spreads retries
+     * from many clients to avoid synchronized thundering-herd load on the gateway.
+     *
+     * @param attempt - The retry number, starting at 1 for the first retry.
+     * @returns A randomized delay in milliseconds.
+     */
+    private backoff;
+}
+
+/**
+ * The typed error hierarchy thrown by the Skailar SDK.
+ *
+ * Every failure surfaces as a subclass of {@link SkailarError}, so a single
+ * `catch (err) { if (err instanceof SkailarError) ... }` covers the whole SDK.
+ * Transport/network failures become {@link SkailarConnectionError}; any non-2xx
+ * HTTP response becomes the most specific {@link SkailarAPIError} subclass for
+ * its status code.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Normalized shape extracted from a Skailar error response body.
+ *
+ * The gateway has been observed to return a flat body
+ * (`{ "error": "invalid_api_key", "message": "..." }`) and, inside streams, a
+ * nested body (`{ "error": { "type": "...", "message": "..." } }`).
+ * {@link parseErrorBody} collapses both into this structure.
+ */
+interface ParsedErrorBody {
+    /** Machine-readable error code, e.g. `"invalid_api_key"`. */
+    code: string | undefined;
+    /** Human-readable error message. */
+    message: string | undefined;
+}
+/** Fields shared by the constructors of every concrete SDK error. */
+interface SkailarErrorOptions {
+    /** Human-readable message; falls back to a per-class default. */
+    message?: string | undefined;
+    /** Machine-readable error code from the response body, if any. */
+    code?: string | undefined;
+    /** Value of the response `x-request-id` header, if present. */
+    requestId?: string | undefined;
+    /** The raw response body (parsed JSON or raw text) for diagnostics. */
+    raw?: unknown;
+    /** Underlying cause, e.g. the original network error. */
+    cause?: unknown;
+}
+/**
+ * Abstract base class for all errors thrown by the Skailar SDK.
+ *
+ * Not thrown directly; serves as the common `instanceof` target. The `abstract`
+ * marker forbids `new SkailarError()` while still allowing subclasses to call `super`.
+ */
+declare abstract class SkailarError extends Error {
+    /** HTTP status code, or `null` for non-HTTP failures (e.g. network). */
+    readonly status: number | null;
+    /** Machine-readable error code from the body, if any. */
+    readonly code: string | undefined;
+    /** Correlation id from the `x-request-id` response header, if any. */
+    readonly requestId: string | undefined;
+    /** The raw response body captured for debugging. */
+    readonly raw: unknown;
+    /**
+     * @param status - HTTP status, or `null` when not applicable.
+     * @param options - Message, code, request id, raw body and cause.
+     */
+    protected constructor(status: number | null, options?: SkailarErrorOptions);
+}
+/**
+ * Raised when the request never produced an HTTP response: DNS failures,
+ * connection resets, TLS errors, and client-side timeouts/aborts driven by the
+ * configured `timeout`. Its {@link SkailarError.status} is always `null`.
+ */
+declare class SkailarConnectionError extends SkailarError {
+    /** @param options - Message and originating cause. */
+    constructor(options?: {
+        message?: string;
+        cause?: unknown;
+    });
+}
+/**
+ * Base class for any non-2xx HTTP response from the gateway.
+ * {@link SkailarAPIError.from} is the factory that inspects the status code and
+ * returns the most specific subclass.
+ */
+declare class SkailarAPIError extends SkailarError {
+    /**
+     * @param status - The HTTP status code of the response.
+     * @param options - Message, code, request id and raw body.
+     */
+    constructor(status: number, options?: SkailarErrorOptions);
+    /**
+     * Build the most specific {@link SkailarAPIError} subclass for a status code.
+     *
+     * @param status - The HTTP status code returned by the gateway.
+     * @param parsed - The normalized `{ code, message }` from {@link parseErrorBody}.
+     * @param requestId - The `x-request-id` header value, if present.
+     * @param raw - The raw response body for diagnostics.
+     * @param retryAfter - Seconds from a `Retry-After` header, for 429 responses.
+     * @returns A {@link SkailarAuthError}, {@link SkailarBadRequestError},
+     * {@link SkailarNotFoundError}, {@link SkailarRateLimitError},
+     * {@link SkailarUpstreamError}, or a plain {@link SkailarAPIError}.
+     */
+    static from(status: number, parsed: ParsedErrorBody, requestId: string | undefined, raw: unknown, retryAfter?: number | undefined): SkailarAPIError;
+}
+/** HTTP 401 — the API key is missing, malformed, or revoked. */
+declare class SkailarAuthError extends SkailarAPIError {
+    /** @param options - Error details. */
+    constructor(options?: SkailarErrorOptions);
+}
+/** HTTP 400 — the request was malformed or failed validation. */
+declare class SkailarBadRequestError extends SkailarAPIError {
+    /** @param options - Error details. */
+    constructor(options?: SkailarErrorOptions);
+}
+/** HTTP 404 — the requested resource (e.g. a model id) does not exist. */
+declare class SkailarNotFoundError extends SkailarAPIError {
+    /** @param options - Error details. */
+    constructor(options?: SkailarErrorOptions);
+}
+/**
+ * HTTP 429 — the account exceeded its rate limit.
+ *
+ * When the gateway provides a `Retry-After` header, its value (in seconds) is
+ * exposed as {@link SkailarRateLimitError.retryAfter} and honored by the
+ * client's automatic retry logic.
+ */
+declare class SkailarRateLimitError extends SkailarAPIError {
+    /** Seconds to wait before retrying, parsed from `Retry-After`; `undefined` if absent/unparseable. */
+    readonly retryAfter: number | undefined;
+    /** @param options - Error details plus the optional `retryAfter` seconds. */
+    constructor(options?: SkailarErrorOptions & {
+        retryAfter?: number | undefined;
+    });
+}
+/**
+ * HTTP 5xx — the upstream model provider failed or timed out. The gateway
+ * propagates provider 5xx failures (502/503/504) with a structured body. These
+ * are transient and are retried automatically.
+ */
+declare class SkailarUpstreamError extends SkailarAPIError {
+    /**
+     * @param status - The specific 5xx status code.
+     * @param options - Error details.
+     */
+    constructor(status: number, options?: SkailarErrorOptions);
+}
+
+/**
+ * Public entry point of the Skailar TypeScript SDK.
+ *
+ * Exports {@link Skailar} as both the default and a named export, the full typed
+ * error hierarchy, the {@link ChatCompletionStream} helper, and every public
+ * request/response type.
+ *
+ * @example Default import
+ * ```ts
+ * import Skailar from "@skailar-ai/sdk";
+ * const client = new Skailar({ apiKey: "skl_live_..." });
+ * ```
+ *
+ * @example Named imports
+ * ```ts
+ * import { Skailar, SkailarError, SkailarRateLimitError } from "@skailar-ai/sdk";
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+export { type BinaryInput, type ChatCompletion, type ChatCompletionChoice, type ChatCompletionChunk, type ChatCompletionChunkChoice, type ChatCompletionChunkToolCall, type ChatCompletionRequest, ChatCompletionStream, type ChatMessage, type ChatRole, type ContentPart, type FileContentType, type FileUploadCreateParams, type FinishReason, type GeneratedImage, type ImageContentPart, type ImageContentType, type ImageGenerationRequest, type ImageGenerationResponse, type ImageUploadCreateParams, type KnownModelId, type LiteralUnion, type MessageContent, type Model, type ModelCapabilities, type ModelId, type ModelList, type ModelOwner, type ModelPricing, type ModelStatus, type ModelSummary, type ParsedErrorBody, type PingKeyResponse, type ReasoningEffort, type RequestOptions, type ResponseFormat, Skailar, SkailarAPIError, SkailarAuthError, SkailarBadRequestError, SkailarConnectionError, SkailarError, SkailarNotFoundError, type SkailarOptions, SkailarRateLimitError, SkailarUpstreamError, type SpeechCreateParams, type SpeechRequest, type SpeechVoice, type TextContentPart, type Tool, type ToolCall, type ToolChoice, type TranscriptionCreateParams, type TranscriptionMime, type TranscriptionRequest, type TranscriptionResponse, type UploadRequest, type UploadResponse, type Usage, Skailar as default, parseSSE };