@kaana.ai/contracts 0.0.0-stage → 4.3.0

package/dist/public/catalogue.d.ts

@@ -0,0 +1,914 @@
+/**
+ * The public catalogue: what `GET /v1/models` and `GET /v1/power-levels` say.
+ *
+ * Moved from `@oxy.so/contracts` 4.12.0 (`src/inference/catalogue.ts`) by Kaana ADR 0002.
+ */
+import { z } from 'zod';
+/** Input/request modalities; structured decisions are an output, never an input. */
+export declare const inferenceModalitySchema: z.ZodEnum<{
+    text: "text";
+    audio: "audio";
+    image: "image";
+    video: "video";
+    embedding: "embedding";
+}>;
+/** Declared model outputs, separate from request/input modalities. */
+export declare const inferenceOutputModalitySchema: z.ZodEnum<{
+    text: "text";
+    audio: "audio";
+    image: "image";
+    video: "video";
+    embedding: "embedding";
+    decisions: "decisions";
+}>;
+/**
+ * How hard a reasoning model is asked to think before it answers.
+ *
+ * A closed, provider-neutral vocabulary: Kaana translates each value into the
+ * serving provider's own control. A model advertises the subset it accepts in
+ * `modelCapabilitiesSchema.reasoningEfforts`, and Oxy refuses a request for an
+ * effort the resolved model does not advertise rather than dropping it.
+ */
+export declare const reasoningEffortSchema: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+}>;
+/**
+ * A POWER LEVEL: the public name of a product-preset routing profile that asks
+ * Oxy to choose a model by capability tier instead of naming one (contract set
+ * 3.4.0). Ordered cheapest first; `auto` asks Oxy to pick the cheapest level
+ * that suffices for the request.
+ *
+ * - `instant` — very cheap, fast small models; the least reasoning each model
+ *   accepts (`low` on a reasoning model, nothing on one without effort control)
+ * - `medium` — mid-size models, low reasoning effort
+ * - `high` — strong models, medium reasoning effort
+ * - `xhigh` — strong models, high reasoning effort
+ * - `pro` — frontier models, high reasoning effort
+ * - `ultra` — the heaviest frontier models, maximum reasoning effort
+ *
+ * A power level is a routing profile, never a model: its slug has no `/`, and
+ * the response always reports the concrete model that ran.
+ */
+export declare const powerLevelSchema: z.ZodEnum<{
+    medium: "medium";
+    high: "high";
+    auto: "auto";
+    instant: "instant";
+    xhigh: "xhigh";
+    pro: "pro";
+    ultra: "ultra";
+}>;
+/**
+ * The reviewed capability tier of one MODEL, which power levels choose from.
+ * `xhigh` and `auto` are not classes: `xhigh` runs `high`-class models at a
+ * higher effort, and `auto` chooses a level. Reviewed catalogue data with a
+ * cited public benchmark source — never inferred from a model's name.
+ */
+export declare const modelPowerClassSchema: z.ZodEnum<{
+    medium: "medium";
+    high: "high";
+    instant: "instant";
+    pro: "pro";
+    ultra: "ultra";
+}>;
+/**
+ * The public dialects a request can arrive in — `client.apiFormat` on the
+ * envelope, and the list a deployment declares it can execute.
+ *
+ * Named (contract set 3.2.0) rather than inline on the client metadata so the
+ * two uses cannot drift: a capability naming a dialect the envelope cannot
+ * carry, or the reverse, would authorize a request no route can serve.
+ */
+export declare const inferenceApiFormatSchema: z.ZodEnum<{
+    embeddings: "embeddings";
+    decisions: "decisions";
+    responses: "responses";
+    chat_completions: "chat_completions";
+    images_generations: "images_generations";
+    audio_transcriptions: "audio_transcriptions";
+    audio_speech: "audio_speech";
+    rerank: "rerank";
+    batches: "batches";
+}>;
+/**
+ * What a realtime session is FOR. The three are different upstream products
+ * with different event families and different metering, not options of one:
+ *
+ *  - `conversation` — a speech-to-speech (or text) model holding a dialogue,
+ *    with responses, tool calls and interruption.
+ *  - `transcription` — live speech-to-text; the model never responds, it only
+ *    transcribes committed input audio.
+ *  - `translation` — live speech-to-speech translation into one target language.
+ */
+export declare const realtimeSessionKindSchema: z.ZodEnum<{
+    conversation: "conversation";
+    transcription: "transcription";
+    translation: "translation";
+}>;
+/**
+ * How a realtime session is carried. One member today: a WebSocket, whose every
+ * frame is one JSON message (see `realtime.ts`). WebRTC and SIP are separate
+ * transports with separate media handling, and are added as members only when a
+ * deployment can actually execute them.
+ */
+export declare const realtimeSessionTransportSchema: z.ZodEnum<{
+    websocket: "websocket";
+}>;
+/**
+ * What a deployment can execute as a realtime session. Present only on a model
+ * that holds sessions; absent means it holds none, which is the state of every
+ * catalogue written before contract set 3.2.0.
+ *
+ * Two optional fields arrived in contract set 4.1.0 (Alia ADR 0017, Kaana
+ * phase 1), and ABSENT means undeclared — a catalogue from an older producer —
+ * never "every value":
+ *
+ * - `inputAudioTranscription` — the model transcribes the caller's speech
+ *   inside a `conversation` when the session asks for it
+ *   (`config.inputAudioTranscription`), and delivers each turn as a
+ *   `transcript.done` with `source: 'input_audio'`. Absent or `false`: a
+ *   session that asks is refused before anything is held.
+ * - `audioFormats` — the realtime encodings a session may name as
+ *   `config.inputAudioFormat` and `config.outputAudioFormat`. These are not the
+ *   media types of `audio.audioFormats`, which describe files.
+ */
+export declare const modelRealtimeCapabilitiesSchema: z.ZodObject<{
+    transports: z.ZodArray<z.ZodEnum<{
+        websocket: "websocket";
+    }>>;
+    sessionKinds: z.ZodArray<z.ZodEnum<{
+        conversation: "conversation";
+        transcription: "transcription";
+        translation: "translation";
+    }>>;
+    inputAudioTranscription: z.ZodOptional<z.ZodBoolean>;
+    audioFormats: z.ZodOptional<z.ZodObject<{
+        input: z.ZodArray<z.ZodEnum<{
+            pcm16_24khz: "pcm16_24khz";
+            g711_ulaw: "g711_ulaw";
+            g711_alaw: "g711_alaw";
+        }>>;
+        output: z.ZodArray<z.ZodEnum<{
+            pcm16_24khz: "pcm16_24khz";
+            g711_ulaw: "g711_ulaw";
+            g711_alaw: "g711_alaw";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * What a model can do, in the terms a caller has to decide against before
+ * sending a request: can it call tools, does it accept images, will it honour a
+ * JSON schema, how much context does it take, how much can it emit.
+ */
+export declare const modelCapabilitiesSchema: z.ZodObject<{
+    inputModalities: z.ZodArray<z.ZodEnum<{
+        text: "text";
+        audio: "audio";
+        image: "image";
+        video: "video";
+        embedding: "embedding";
+    }>>;
+    outputModalities: z.ZodArray<z.ZodEnum<{
+        text: "text";
+        audio: "audio";
+        image: "image";
+        video: "video";
+        embedding: "embedding";
+        decisions: "decisions";
+    }>>;
+    tools: z.ZodBoolean;
+    parallelToolCalls: z.ZodBoolean;
+    structuredOutput: z.ZodBoolean;
+    jsonMode: z.ZodBoolean;
+    reasoning: z.ZodBoolean;
+    reasoningEfforts: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>>;
+    streaming: z.ZodBoolean;
+    promptCaching: z.ZodBoolean;
+    maxContextTokens: z.ZodNumber;
+    maxOutputTokens: z.ZodNumber;
+    apiFormats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        embeddings: "embeddings";
+        decisions: "decisions";
+        responses: "responses";
+        chat_completions: "chat_completions";
+        images_generations: "images_generations";
+        audio_transcriptions: "audio_transcriptions";
+        audio_speech: "audio_speech";
+        rerank: "rerank";
+        batches: "batches";
+    }>>>;
+    realtime: z.ZodOptional<z.ZodObject<{
+        transports: z.ZodArray<z.ZodEnum<{
+            websocket: "websocket";
+        }>>;
+        sessionKinds: z.ZodArray<z.ZodEnum<{
+            conversation: "conversation";
+            transcription: "transcription";
+            translation: "translation";
+        }>>;
+        inputAudioTranscription: z.ZodOptional<z.ZodBoolean>;
+        audioFormats: z.ZodOptional<z.ZodObject<{
+            input: z.ZodArray<z.ZodEnum<{
+                pcm16_24khz: "pcm16_24khz";
+                g711_ulaw: "g711_ulaw";
+                g711_alaw: "g711_alaw";
+            }>>;
+            output: z.ZodArray<z.ZodEnum<{
+                pcm16_24khz: "pcm16_24khz";
+                g711_ulaw: "g711_ulaw";
+                g711_alaw: "g711_alaw";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * License terms, including the two questions that decide whether Oxy may serve
+ * a model to third parties at all: is commercial use permitted, and must the
+ * base model be attributed.
+ */
+export declare const modelLicenseSchema: z.ZodObject<{
+    licenseId: z.ZodString;
+    displayName: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+    commercialUseAllowed: z.ZodBoolean;
+    requiresAttribution: z.ZodBoolean;
+    acceptableUsePolicyUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * How a model came to exist.
+ *
+ * `releaseKind` is what stops `alia/*` from becoming a re-badging namespace:
+ * a first-party namespace may only carry models Alia actually trained or
+ * derived, never a third-party route wearing an Oxy name.
+ */
+export declare const modelProvenanceSchema: z.ZodObject<{
+    releaseKind: z.ZodEnum<{
+        first_party_original: "first_party_original";
+        first_party_derived: "first_party_derived";
+        open_weight: "open_weight";
+        third_party_hosted: "third_party_hosted";
+    }>;
+    baseModelId: z.ZodOptional<z.ZodString>;
+    trainingOrganization: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * What happens to the customer's prompts and responses on a given route.
+ *
+ * Every field here is enforceable by a routing policy, which is the reason they
+ * are structured rather than a prose paragraph on a docs page.
+ */
+export declare const inferenceDataPolicySchema: z.ZodObject<{
+    retainsPayloads: z.ZodBoolean;
+    retentionDays: z.ZodNumber;
+    trainsOnCustomerData: z.ZodBoolean;
+    zeroDataRetentionAvailable: z.ZodBoolean;
+    subprocessors: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    policyUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** Deprecation state, with the replacement a customer should migrate to. */
+export declare const modelDeprecationSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        active: "active";
+        deprecated: "deprecated";
+        retired: "retired";
+    }>;
+    replacementModelReference: z.ZodOptional<z.ZodString>;
+    announcedAt: z.ZodOptional<z.ZodString>;
+    sunsetAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** One published evaluation result for a revision. */
+export declare const modelEvaluationResultSchema: z.ZodObject<{
+    suite: z.ZodString;
+    metric: z.ZodString;
+    score: z.ZodString;
+    evaluatedAt: z.ZodOptional<z.ZodString>;
+    reportUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Safety metadata a downstream developer needs, and the EU AI Act / GPAI
+ * documentation trail expects to find beside a served model.
+ */
+export declare const modelSafetyMetadataSchema: z.ZodObject<{
+    safetyCardUrl: z.ZodOptional<z.ZodString>;
+    contentFilteringDefault: z.ZodEnum<{
+        none: "none";
+        provider_default: "provider_default";
+        strict: "strict";
+    }>;
+    knownLimitations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    provenanceMarking: z.ZodEnum<{
+        none: "none";
+        visible_watermark: "visible_watermark";
+        invisible_watermark: "invisible_watermark";
+        c2pa: "c2pa";
+    }>;
+}, z.core.$strict>;
+/** The publisher fields a customer sees beside a model. */
+export declare const cataloguePublisherSummarySchema: z.ZodObject<{
+    slug: z.ZodString;
+    displayName: z.ZodString;
+    websiteUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** One voice a speech or realtime model can speak in. */
+export declare const voiceSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    languages: z.ZodArray<z.ZodString>;
+    gender: z.ZodOptional<z.ZodEnum<{
+        female: "female";
+        male: "male";
+        neutral: "neutral";
+    }>>;
+}, z.core.$strict>;
+/**
+ * What an audio model accepts, published so a request that cannot be served
+ * is refused BEFORE a grant or a reservation (`invalid_request` with `param`),
+ * never by an adapter after money was held.
+ *
+ * When several providers serve one model line, the published value is the
+ * INTERSECTION — what every one of them accepts — so a request that passes
+ * here is servable by any route of the line.
+ *
+ * - `voices` — empty for a model that reads no text aloud (transcription).
+ * - `audioFormats.input` — the media types an upload may have (transcription).
+ * - `audioFormats.output` — the media types speech can be produced in.
+ * - `speed` — absent when the model accepts no speed control; a request that
+ *   names one is then refused.
+ * - `maxInputCharacters` — the longest text one speech request may carry,
+ *   counted in UTF-16 code units, as JavaScript's `length` counts.
+ *
+ * A REALTIME model publishes the same shape (contract set 4.1.0): `voices` are
+ * what a session's `config.voice` may name, `languages` what it converses in
+ * and what `config.inputAudioTranscription.language` may name, and
+ * `audioFormats` is empty in both directions because a session carries no
+ * files — its encodings are `capabilities.realtime.audioFormats`. An empty
+ * `languages` means the provider documents none, not that the model speaks
+ * none; a caller that needs a language then cannot choose the model.
+ * `gender` is published only where it has been reviewed against the
+ * provider's own catalogue; absent is unknown.
+ */
+export declare const modelAudioCapabilitiesSchema: z.ZodObject<{
+    voices: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        languages: z.ZodArray<z.ZodString>;
+        gender: z.ZodOptional<z.ZodEnum<{
+            female: "female";
+            male: "male";
+            neutral: "neutral";
+        }>>;
+    }, z.core.$strict>>;
+    languages: z.ZodArray<z.ZodString>;
+    audioFormats: z.ZodObject<{
+        input: z.ZodArray<z.ZodEnum<{
+            "audio/mpeg": "audio/mpeg";
+            "audio/wav": "audio/wav";
+            "audio/ogg": "audio/ogg";
+            "audio/aac": "audio/aac";
+            "audio/flac": "audio/flac";
+            "audio/pcm": "audio/pcm";
+            "audio/mp4": "audio/mp4";
+            "audio/webm": "audio/webm";
+        }>>;
+        output: z.ZodArray<z.ZodEnum<{
+            "audio/mpeg": "audio/mpeg";
+            "audio/wav": "audio/wav";
+            "audio/ogg": "audio/ogg";
+            "audio/aac": "audio/aac";
+            "audio/flac": "audio/flac";
+            "audio/pcm": "audio/pcm";
+        }>>;
+    }, z.core.$strict>;
+    speed: z.ZodOptional<z.ZodObject<{
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+    }, z.core.$strict>>;
+    maxInputCharacters: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * One model as `GET /v1/models` and `GET /v1/models/{publisher}/{model}`
+ * serve it: modalities, power class, limits, parameters, audio capabilities and
+ * the customer price.
+ *
+ * Derived from Oxy's `modelCatalogueEntrySchema` without what names who serves
+ * the model: no serving provider, no deployment, no availability scope and no
+ * commercial permission. Those are in the operational catalogue under
+ * `@kaana.ai/contracts/internal`.
+ */
+export declare const modelSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    modelId: z.ZodString;
+    publisher: z.ZodObject<{
+        slug: z.ZodString;
+        displayName: z.ZodString;
+        websiteUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    displayName: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    currentRevision: z.ZodString;
+    availableRevisions: z.ZodArray<z.ZodString>;
+    capabilities: z.ZodObject<{
+        inputModalities: z.ZodArray<z.ZodEnum<{
+            text: "text";
+            audio: "audio";
+            image: "image";
+            video: "video";
+            embedding: "embedding";
+        }>>;
+        outputModalities: z.ZodArray<z.ZodEnum<{
+            text: "text";
+            audio: "audio";
+            image: "image";
+            video: "video";
+            embedding: "embedding";
+            decisions: "decisions";
+        }>>;
+        tools: z.ZodBoolean;
+        parallelToolCalls: z.ZodBoolean;
+        structuredOutput: z.ZodBoolean;
+        jsonMode: z.ZodBoolean;
+        reasoning: z.ZodBoolean;
+        reasoningEfforts: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>>;
+        streaming: z.ZodBoolean;
+        promptCaching: z.ZodBoolean;
+        maxContextTokens: z.ZodNumber;
+        maxOutputTokens: z.ZodNumber;
+        apiFormats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            embeddings: "embeddings";
+            decisions: "decisions";
+            responses: "responses";
+            chat_completions: "chat_completions";
+            images_generations: "images_generations";
+            audio_transcriptions: "audio_transcriptions";
+            audio_speech: "audio_speech";
+            rerank: "rerank";
+            batches: "batches";
+        }>>>;
+        realtime: z.ZodOptional<z.ZodObject<{
+            transports: z.ZodArray<z.ZodEnum<{
+                websocket: "websocket";
+            }>>;
+            sessionKinds: z.ZodArray<z.ZodEnum<{
+                conversation: "conversation";
+                transcription: "transcription";
+                translation: "translation";
+            }>>;
+            inputAudioTranscription: z.ZodOptional<z.ZodBoolean>;
+            audioFormats: z.ZodOptional<z.ZodObject<{
+                input: z.ZodArray<z.ZodEnum<{
+                    pcm16_24khz: "pcm16_24khz";
+                    g711_ulaw: "g711_ulaw";
+                    g711_alaw: "g711_alaw";
+                }>>;
+                output: z.ZodArray<z.ZodEnum<{
+                    pcm16_24khz: "pcm16_24khz";
+                    g711_ulaw: "g711_ulaw";
+                    g711_alaw: "g711_alaw";
+                }>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    audio: z.ZodOptional<z.ZodObject<{
+        voices: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            languages: z.ZodArray<z.ZodString>;
+            gender: z.ZodOptional<z.ZodEnum<{
+                female: "female";
+                male: "male";
+                neutral: "neutral";
+            }>>;
+        }, z.core.$strict>>;
+        languages: z.ZodArray<z.ZodString>;
+        audioFormats: z.ZodObject<{
+            input: z.ZodArray<z.ZodEnum<{
+                "audio/mpeg": "audio/mpeg";
+                "audio/wav": "audio/wav";
+                "audio/ogg": "audio/ogg";
+                "audio/aac": "audio/aac";
+                "audio/flac": "audio/flac";
+                "audio/pcm": "audio/pcm";
+                "audio/mp4": "audio/mp4";
+                "audio/webm": "audio/webm";
+            }>>;
+            output: z.ZodArray<z.ZodEnum<{
+                "audio/mpeg": "audio/mpeg";
+                "audio/wav": "audio/wav";
+                "audio/ogg": "audio/ogg";
+                "audio/aac": "audio/aac";
+                "audio/flac": "audio/flac";
+                "audio/pcm": "audio/pcm";
+            }>>;
+        }, z.core.$strict>;
+        speed: z.ZodOptional<z.ZodObject<{
+            min: z.ZodNumber;
+            max: z.ZodNumber;
+        }, z.core.$strict>>;
+        maxInputCharacters: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    license: z.ZodObject<{
+        licenseId: z.ZodString;
+        displayName: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+        commercialUseAllowed: z.ZodBoolean;
+        requiresAttribution: z.ZodBoolean;
+        acceptableUsePolicyUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    provenance: z.ZodObject<{
+        releaseKind: z.ZodEnum<{
+            first_party_original: "first_party_original";
+            first_party_derived: "first_party_derived";
+            open_weight: "open_weight";
+            third_party_hosted: "third_party_hosted";
+        }>;
+        baseModelId: z.ZodOptional<z.ZodString>;
+        trainingOrganization: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    knowledgeCutoff: z.ZodOptional<z.ZodString>;
+    releasedOn: z.ZodOptional<z.ZodString>;
+    releasedAt: z.ZodOptional<z.ZodString>;
+    regions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    dataPolicy: z.ZodObject<{
+        retainsPayloads: z.ZodBoolean;
+        retentionDays: z.ZodNumber;
+        trainsOnCustomerData: z.ZodBoolean;
+        zeroDataRetentionAvailable: z.ZodBoolean;
+        subprocessors: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        policyUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    pricing: z.ZodOptional<z.ZodObject<{
+        priceVersionId: z.ZodString;
+        currency: z.ZodString;
+        unitPrices: z.ZodArray<z.ZodObject<{
+            unit: z.ZodEnum<{
+                input_tokens: "input_tokens";
+                cached_input_tokens: "cached_input_tokens";
+                output_tokens: "output_tokens";
+                reasoning_tokens: "reasoning_tokens";
+                requests: "requests";
+                images: "images";
+                audio_input_milliseconds: "audio_input_milliseconds";
+                audio_output_milliseconds: "audio_output_milliseconds";
+                video_milliseconds: "video_milliseconds";
+                characters: "characters";
+                embeddings: "embeddings";
+                audio_input_tokens: "audio_input_tokens";
+                cached_audio_input_tokens: "cached_audio_input_tokens";
+                audio_output_tokens: "audio_output_tokens";
+                session_milliseconds: "session_milliseconds";
+                input_transcription_milliseconds: "input_transcription_milliseconds";
+            }>;
+            amount: z.core.$ZodBranded<z.ZodString, "ExactDecimal", "out">;
+            per: z.ZodNumber;
+            currency: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    deprecation: z.ZodObject<{
+        status: z.ZodEnum<{
+            active: "active";
+            deprecated: "deprecated";
+            retired: "retired";
+        }>;
+        replacementModelReference: z.ZodOptional<z.ZodString>;
+        announcedAt: z.ZodOptional<z.ZodString>;
+        sunsetAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    evaluations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        suite: z.ZodString;
+        metric: z.ZodString;
+        score: z.ZodString;
+        evaluatedAt: z.ZodOptional<z.ZodString>;
+        reportUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    safety: z.ZodOptional<z.ZodObject<{
+        safetyCardUrl: z.ZodOptional<z.ZodString>;
+        contentFilteringDefault: z.ZodEnum<{
+            none: "none";
+            provider_default: "provider_default";
+            strict: "strict";
+        }>;
+        knownLimitations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        provenanceMarking: z.ZodEnum<{
+            none: "none";
+            visible_watermark: "visible_watermark";
+            invisible_watermark: "invisible_watermark";
+            c2pa: "c2pa";
+        }>;
+    }, z.core.$strict>>;
+    modelCardUrl: z.ZodOptional<z.ZodString>;
+    powerClass: z.ZodOptional<z.ZodEnum<{
+        medium: "medium";
+        high: "high";
+        instant: "instant";
+        pro: "pro";
+        ultra: "ultra";
+    }>>;
+}, z.core.$strip>;
+/** `GET /v1/models`. */
+export declare const modelListSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        modelId: z.ZodString;
+        publisher: z.ZodObject<{
+            slug: z.ZodString;
+            displayName: z.ZodString;
+            websiteUrl: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        displayName: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        currentRevision: z.ZodString;
+        availableRevisions: z.ZodArray<z.ZodString>;
+        capabilities: z.ZodObject<{
+            inputModalities: z.ZodArray<z.ZodEnum<{
+                text: "text";
+                audio: "audio";
+                image: "image";
+                video: "video";
+                embedding: "embedding";
+            }>>;
+            outputModalities: z.ZodArray<z.ZodEnum<{
+                text: "text";
+                audio: "audio";
+                image: "image";
+                video: "video";
+                embedding: "embedding";
+                decisions: "decisions";
+            }>>;
+            tools: z.ZodBoolean;
+            parallelToolCalls: z.ZodBoolean;
+            structuredOutput: z.ZodBoolean;
+            jsonMode: z.ZodBoolean;
+            reasoning: z.ZodBoolean;
+            reasoningEfforts: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>>>;
+            streaming: z.ZodBoolean;
+            promptCaching: z.ZodBoolean;
+            maxContextTokens: z.ZodNumber;
+            maxOutputTokens: z.ZodNumber;
+            apiFormats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                embeddings: "embeddings";
+                decisions: "decisions";
+                responses: "responses";
+                chat_completions: "chat_completions";
+                images_generations: "images_generations";
+                audio_transcriptions: "audio_transcriptions";
+                audio_speech: "audio_speech";
+                rerank: "rerank";
+                batches: "batches";
+            }>>>;
+            realtime: z.ZodOptional<z.ZodObject<{
+                transports: z.ZodArray<z.ZodEnum<{
+                    websocket: "websocket";
+                }>>;
+                sessionKinds: z.ZodArray<z.ZodEnum<{
+                    conversation: "conversation";
+                    transcription: "transcription";
+                    translation: "translation";
+                }>>;
+                inputAudioTranscription: z.ZodOptional<z.ZodBoolean>;
+                audioFormats: z.ZodOptional<z.ZodObject<{
+                    input: z.ZodArray<z.ZodEnum<{
+                        pcm16_24khz: "pcm16_24khz";
+                        g711_ulaw: "g711_ulaw";
+                        g711_alaw: "g711_alaw";
+                    }>>;
+                    output: z.ZodArray<z.ZodEnum<{
+                        pcm16_24khz: "pcm16_24khz";
+                        g711_ulaw: "g711_ulaw";
+                        g711_alaw: "g711_alaw";
+                    }>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        audio: z.ZodOptional<z.ZodObject<{
+            voices: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                languages: z.ZodArray<z.ZodString>;
+                gender: z.ZodOptional<z.ZodEnum<{
+                    female: "female";
+                    male: "male";
+                    neutral: "neutral";
+                }>>;
+            }, z.core.$strict>>;
+            languages: z.ZodArray<z.ZodString>;
+            audioFormats: z.ZodObject<{
+                input: z.ZodArray<z.ZodEnum<{
+                    "audio/mpeg": "audio/mpeg";
+                    "audio/wav": "audio/wav";
+                    "audio/ogg": "audio/ogg";
+                    "audio/aac": "audio/aac";
+                    "audio/flac": "audio/flac";
+                    "audio/pcm": "audio/pcm";
+                    "audio/mp4": "audio/mp4";
+                    "audio/webm": "audio/webm";
+                }>>;
+                output: z.ZodArray<z.ZodEnum<{
+                    "audio/mpeg": "audio/mpeg";
+                    "audio/wav": "audio/wav";
+                    "audio/ogg": "audio/ogg";
+                    "audio/aac": "audio/aac";
+                    "audio/flac": "audio/flac";
+                    "audio/pcm": "audio/pcm";
+                }>>;
+            }, z.core.$strict>;
+            speed: z.ZodOptional<z.ZodObject<{
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+            }, z.core.$strict>>;
+            maxInputCharacters: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        license: z.ZodObject<{
+            licenseId: z.ZodString;
+            displayName: z.ZodString;
+            url: z.ZodOptional<z.ZodString>;
+            commercialUseAllowed: z.ZodBoolean;
+            requiresAttribution: z.ZodBoolean;
+            acceptableUsePolicyUrl: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        provenance: z.ZodObject<{
+            releaseKind: z.ZodEnum<{
+                first_party_original: "first_party_original";
+                first_party_derived: "first_party_derived";
+                open_weight: "open_weight";
+                third_party_hosted: "third_party_hosted";
+            }>;
+            baseModelId: z.ZodOptional<z.ZodString>;
+            trainingOrganization: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        knowledgeCutoff: z.ZodOptional<z.ZodString>;
+        releasedOn: z.ZodOptional<z.ZodString>;
+        releasedAt: z.ZodOptional<z.ZodString>;
+        regions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        dataPolicy: z.ZodObject<{
+            retainsPayloads: z.ZodBoolean;
+            retentionDays: z.ZodNumber;
+            trainsOnCustomerData: z.ZodBoolean;
+            zeroDataRetentionAvailable: z.ZodBoolean;
+            subprocessors: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            policyUrl: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        pricing: z.ZodOptional<z.ZodObject<{
+            priceVersionId: z.ZodString;
+            currency: z.ZodString;
+            unitPrices: z.ZodArray<z.ZodObject<{
+                unit: z.ZodEnum<{
+                    input_tokens: "input_tokens";
+                    cached_input_tokens: "cached_input_tokens";
+                    output_tokens: "output_tokens";
+                    reasoning_tokens: "reasoning_tokens";
+                    requests: "requests";
+                    images: "images";
+                    audio_input_milliseconds: "audio_input_milliseconds";
+                    audio_output_milliseconds: "audio_output_milliseconds";
+                    video_milliseconds: "video_milliseconds";
+                    characters: "characters";
+                    embeddings: "embeddings";
+                    audio_input_tokens: "audio_input_tokens";
+                    cached_audio_input_tokens: "cached_audio_input_tokens";
+                    audio_output_tokens: "audio_output_tokens";
+                    session_milliseconds: "session_milliseconds";
+                    input_transcription_milliseconds: "input_transcription_milliseconds";
+                }>;
+                amount: z.core.$ZodBranded<z.ZodString, "ExactDecimal", "out">;
+                per: z.ZodNumber;
+                currency: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        deprecation: z.ZodObject<{
+            status: z.ZodEnum<{
+                active: "active";
+                deprecated: "deprecated";
+                retired: "retired";
+            }>;
+            replacementModelReference: z.ZodOptional<z.ZodString>;
+            announcedAt: z.ZodOptional<z.ZodString>;
+            sunsetAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        evaluations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            suite: z.ZodString;
+            metric: z.ZodString;
+            score: z.ZodString;
+            evaluatedAt: z.ZodOptional<z.ZodString>;
+            reportUrl: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        safety: z.ZodOptional<z.ZodObject<{
+            safetyCardUrl: z.ZodOptional<z.ZodString>;
+            contentFilteringDefault: z.ZodEnum<{
+                none: "none";
+                provider_default: "provider_default";
+                strict: "strict";
+            }>;
+            knownLimitations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            provenanceMarking: z.ZodEnum<{
+                none: "none";
+                visible_watermark: "visible_watermark";
+                invisible_watermark: "invisible_watermark";
+                c2pa: "c2pa";
+            }>;
+        }, z.core.$strict>>;
+        modelCardUrl: z.ZodOptional<z.ZodString>;
+        powerClass: z.ZodOptional<z.ZodEnum<{
+            medium: "medium";
+            high: "high";
+            instant: "instant";
+            pro: "pro";
+            ultra: "ultra";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+/**
+ * One power level as `GET /v1/power-levels` lists it for the calling
+ * credential: the level, the class it draws from, the effort it asks for, and
+ * the model lines it can currently choose among.
+ *
+ * `auto` draws from no single class (it chooses a level), so it carries no
+ * `powerClass` and lists every line of the levels it may climb to.
+ */
+export declare const powerLevelEntrySchema: z.ZodObject<{
+    level: z.ZodEnum<{
+        medium: "medium";
+        high: "high";
+        auto: "auto";
+        instant: "instant";
+        xhigh: "xhigh";
+        pro: "pro";
+        ultra: "ultra";
+    }>;
+    powerClass: z.ZodOptional<z.ZodEnum<{
+        medium: "medium";
+        high: "high";
+        instant: "instant";
+        pro: "pro";
+        ultra: "ultra";
+    }>>;
+    reasoningEffort: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+    modelLines: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/** `GET /v1/power-levels`. Replaces Oxy's `/v1/models/routing-profiles`. */
+export declare const powerLevelListSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        level: z.ZodEnum<{
+            medium: "medium";
+            high: "high";
+            auto: "auto";
+            instant: "instant";
+            xhigh: "xhigh";
+            pro: "pro";
+            ultra: "ultra";
+        }>;
+        powerClass: z.ZodOptional<z.ZodEnum<{
+            medium: "medium";
+            high: "high";
+            instant: "instant";
+            pro: "pro";
+            ultra: "ultra";
+        }>>;
+        reasoningEffort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>;
+        modelLines: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type InferenceOutputModality = z.infer<typeof inferenceOutputModalitySchema>;
+export type InferenceModality = z.infer<typeof inferenceModalitySchema>;
+export type ReasoningEffort = z.infer<typeof reasoningEffortSchema>;
+export type PowerLevel = z.infer<typeof powerLevelSchema>;
+export type ModelPowerClass = z.infer<typeof modelPowerClassSchema>;
+export type InferenceApiFormat = z.infer<typeof inferenceApiFormatSchema>;
+export type RealtimeSessionKind = z.infer<typeof realtimeSessionKindSchema>;
+export type RealtimeSessionTransport = z.infer<typeof realtimeSessionTransportSchema>;
+export type ModelRealtimeCapabilities = z.infer<typeof modelRealtimeCapabilitiesSchema>;
+export type ModelCapabilities = z.infer<typeof modelCapabilitiesSchema>;
+export type ModelLicense = z.infer<typeof modelLicenseSchema>;
+export type ModelProvenance = z.infer<typeof modelProvenanceSchema>;
+export type InferenceDataPolicy = z.infer<typeof inferenceDataPolicySchema>;
+export type ModelDeprecation = z.infer<typeof modelDeprecationSchema>;
+export type ModelEvaluationResult = z.infer<typeof modelEvaluationResultSchema>;
+export type ModelSafetyMetadata = z.infer<typeof modelSafetyMetadataSchema>;
+export type CataloguePublisherSummary = z.infer<typeof cataloguePublisherSummarySchema>;
+export type Voice = z.infer<typeof voiceSchema>;
+export type ModelAudioCapabilities = z.infer<typeof modelAudioCapabilitiesSchema>;
+export type Model = z.infer<typeof modelSchema>;
+export type ModelList = z.infer<typeof modelListSchema>;
+export type PowerLevelEntry = z.infer<typeof powerLevelEntrySchema>;
+export type PowerLevelList = z.infer<typeof powerLevelListSchema>;