@kaana.ai/contracts 0.0.0-stage → 4.4.0

package/dist/public/generations.d.ts

@@ -0,0 +1,330 @@
+/**
+ * Generation records: the receipt a client reads back with
+ * `GET /v1/generations/{id}` or `GET /v1/generations?idempotency_key=`.
+ *
+ * Kaana serves the record and Oxy supplies the amount (Kaana ADR 0002,
+ * decision 7): Kaana measured the units, Oxy priced and settled them. Two
+ * kinds, discriminated on `kind`, because a commercial request and an
+ * internally metered one are different facts — one was charged, the other was
+ * deliberately not — and a single shape with optional money would let a
+ * reader mistake the second for a free request.
+ *
+ * Derived from the Oxy edge's `generationReceiptSchema` and
+ * `meteredGenerationSchema` (`@oxy.so/contracts` 4.12.0) without the serving
+ * provider: no public record names a provider, a key or a deployment.
+ */
+import { z } from 'zod';
+/**
+ * How a request ended.
+ *
+ * Moved from `@oxy.so/contracts` 4.12.0 (`src/inference/usage.ts`).
+ */
+export declare const inferenceRequestOutcomeSchema: z.ZodEnum<{
+    cancelled: "cancelled";
+    completed: "completed";
+    partial: "partial";
+    failed: "failed";
+}>;
+/**
+ * A commercial request: priced and charged.
+ *
+ * `priceSnapshot` is a COPY of the unit prices applied, so the arithmetic is
+ * checkable without the price version still existing. `platformFeeOnly` marks
+ * a BYOK request: the provider billed the customer's own account and
+ * `billedAmount` is Oxy's fee, not the cost of the tokens.
+ */
+export declare const chargedGenerationRecordSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"charge">;
+    receiptId: z.ZodString;
+    priceSnapshot: 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>;
+    billedAmount: z.core.$ZodBranded<z.ZodString, "ExactDecimal", "out">;
+    currency: z.ZodString;
+    platformFeeOnly: z.ZodBoolean;
+    schemaVersion: z.ZodLiteral<1>;
+    requestId: z.ZodString;
+    generationId: z.ZodOptional<z.ZodString>;
+    applicationId: z.ZodString;
+    credentialId: z.ZodString;
+    delegatedUserId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "DelegatedUserId", "out">>;
+    environment: z.ZodEnum<{
+        development: "development";
+        staging: "staging";
+        production: "production";
+    }>;
+    outcome: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        partial: "partial";
+        failed: "failed";
+    }>;
+    usageSource: z.ZodEnum<{
+        provider_reported: "provider_reported";
+        oxy_measured: "oxy_measured";
+        estimated: "estimated";
+    }>;
+    units: 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";
+        }>;
+        quantity: z.ZodNumber;
+    }, z.core.$strict>>;
+    model: z.ZodString;
+    labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    settledAt: z.ZodString;
+}, z.core.$strict>;
+/**
+ * An internally metered request: measured and recorded, never charged. The
+ * tariff is what the published price list WOULD have charged, which is not a
+ * cost and not a charge.
+ */
+export declare const meteredGenerationRecordSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"metered_usage">;
+    meteredUsageId: z.ZodString;
+    parentRequestId: z.ZodOptional<z.ZodString>;
+    tariff: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"quoted">;
+        amount: z.core.$ZodBranded<z.ZodString, "ExactDecimal", "out">;
+        currency: z.ZodString;
+        priceVersionId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"unpriced">;
+        priceVersionId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>], "status">;
+    customerCharge: z.ZodObject<{
+        status: z.ZodLiteral<"not_charged">;
+    }, z.core.$strict>;
+    schemaVersion: z.ZodLiteral<1>;
+    requestId: z.ZodString;
+    generationId: z.ZodOptional<z.ZodString>;
+    applicationId: z.ZodString;
+    credentialId: z.ZodString;
+    delegatedUserId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "DelegatedUserId", "out">>;
+    environment: z.ZodEnum<{
+        development: "development";
+        staging: "staging";
+        production: "production";
+    }>;
+    outcome: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        partial: "partial";
+        failed: "failed";
+    }>;
+    usageSource: z.ZodEnum<{
+        provider_reported: "provider_reported";
+        oxy_measured: "oxy_measured";
+        estimated: "estimated";
+    }>;
+    units: 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";
+        }>;
+        quantity: z.ZodNumber;
+    }, z.core.$strict>>;
+    model: z.ZodString;
+    labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    settledAt: z.ZodString;
+}, z.core.$strict>;
+/** `GET /v1/generations/{id}` and `GET /v1/generations?idempotency_key=`. */
+export declare const generationRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"charge">;
+    receiptId: z.ZodString;
+    priceSnapshot: 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>;
+    billedAmount: z.core.$ZodBranded<z.ZodString, "ExactDecimal", "out">;
+    currency: z.ZodString;
+    platformFeeOnly: z.ZodBoolean;
+    schemaVersion: z.ZodLiteral<1>;
+    requestId: z.ZodString;
+    generationId: z.ZodOptional<z.ZodString>;
+    applicationId: z.ZodString;
+    credentialId: z.ZodString;
+    delegatedUserId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "DelegatedUserId", "out">>;
+    environment: z.ZodEnum<{
+        development: "development";
+        staging: "staging";
+        production: "production";
+    }>;
+    outcome: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        partial: "partial";
+        failed: "failed";
+    }>;
+    usageSource: z.ZodEnum<{
+        provider_reported: "provider_reported";
+        oxy_measured: "oxy_measured";
+        estimated: "estimated";
+    }>;
+    units: 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";
+        }>;
+        quantity: z.ZodNumber;
+    }, z.core.$strict>>;
+    model: z.ZodString;
+    labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    settledAt: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"metered_usage">;
+    meteredUsageId: z.ZodString;
+    parentRequestId: z.ZodOptional<z.ZodString>;
+    tariff: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"quoted">;
+        amount: z.core.$ZodBranded<z.ZodString, "ExactDecimal", "out">;
+        currency: z.ZodString;
+        priceVersionId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"unpriced">;
+        priceVersionId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>], "status">;
+    customerCharge: z.ZodObject<{
+        status: z.ZodLiteral<"not_charged">;
+    }, z.core.$strict>;
+    schemaVersion: z.ZodLiteral<1>;
+    requestId: z.ZodString;
+    generationId: z.ZodOptional<z.ZodString>;
+    applicationId: z.ZodString;
+    credentialId: z.ZodString;
+    delegatedUserId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "DelegatedUserId", "out">>;
+    environment: z.ZodEnum<{
+        development: "development";
+        staging: "staging";
+        production: "production";
+    }>;
+    outcome: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        partial: "partial";
+        failed: "failed";
+    }>;
+    usageSource: z.ZodEnum<{
+        provider_reported: "provider_reported";
+        oxy_measured: "oxy_measured";
+        estimated: "estimated";
+    }>;
+    units: 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";
+        }>;
+        quantity: z.ZodNumber;
+    }, z.core.$strict>>;
+    model: z.ZodString;
+    labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    settledAt: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type InferenceRequestOutcome = z.infer<typeof inferenceRequestOutcomeSchema>;
+export type ChargedGenerationRecord = z.infer<typeof chargedGenerationRecordSchema>;
+export type MeteredGenerationRecord = z.infer<typeof meteredGenerationRecordSchema>;
+export type GenerationRecord = z.infer<typeof generationRecordSchema>;

package/dist/public/generations.js

@@ -0,0 +1,121 @@
+/**
+ * Generation records: the receipt a client reads back with
+ * `GET /v1/generations/{id}` or `GET /v1/generations?idempotency_key=`.
+ *
+ * Kaana serves the record and Oxy supplies the amount (Kaana ADR 0002,
+ * decision 7): Kaana measured the units, Oxy priced and settled them. Two
+ * kinds, discriminated on `kind`, because a commercial request and an
+ * internally metered one are different facts — one was charged, the other was
+ * deliberately not — and a single shape with optional money would let a
+ * reader mistake the second for a free request.
+ *
+ * Derived from the Oxy edge's `generationReceiptSchema` and
+ * `meteredGenerationSchema` (`@oxy.so/contracts` 4.12.0) without the serving
+ * provider: no public record names a provider, a key or a deployment.
+ */
+import { z } from 'zod';
+import { delegatedUserIdSchema, generationIdSchema, inferenceEnvironmentSchema, inferenceTimestampSchema, modelReferenceSchema, oxyApplicationIdSchema, oxyCredentialIdSchema, requestIdSchema, } from './identifiers.js';
+import { requestLabelsSchema } from './messages.js';
+import { currencyCodeSchema, exactDecimalSchema, priceSnapshotSchema, usageQuantitySchema, usageSourceSchema, } from './money.js';
+/**
+ * How a request ended.
+ *
+ * Moved from `@oxy.so/contracts` 4.12.0 (`src/inference/usage.ts`).
+ */
+export const inferenceRequestOutcomeSchema = z.enum([
+    'completed',
+    'partial',
+    'cancelled',
+    'failed',
+]);
+const recordFields = {
+    /** A whole message on the wire, so it is versioned. */
+    schemaVersion: z.literal(1),
+    requestId: requestIdSchema,
+    generationId: generationIdSchema.optional(),
+    applicationId: oxyApplicationIdSchema,
+    credentialId: oxyCredentialIdSchema,
+    /** Attribution only. Never the billing identity. */
+    delegatedUserId: delegatedUserIdSchema.optional(),
+    environment: inferenceEnvironmentSchema,
+    outcome: inferenceRequestOutcomeSchema,
+    usageSource: usageSourceSchema,
+    units: z.array(usageQuantitySchema),
+    /** The revision that actually served the request. */
+    model: modelReferenceSchema,
+    /** The caller's cost-attribution labels, echoed back. */
+    labels: requestLabelsSchema.optional(),
+    settledAt: inferenceTimestampSchema,
+};
+const uniqueUnits = (units, ctx) => {
+    const names = units.map((quantity) => quantity.unit);
+    if (new Set(names).size !== names.length) {
+        ctx.addIssue({ code: 'custom', path: ['units'], message: 'each unit is settled once' });
+    }
+};
+/**
+ * A commercial request: priced and charged.
+ *
+ * `priceSnapshot` is a COPY of the unit prices applied, so the arithmetic is
+ * checkable without the price version still existing. `platformFeeOnly` marks
+ * a BYOK request: the provider billed the customer's own account and
+ * `billedAmount` is Oxy's fee, not the cost of the tokens.
+ */
+export const chargedGenerationRecordSchema = z
+    .object({
+    ...recordFields,
+    kind: z.literal('charge'),
+    receiptId: z.string().min(1).max(128),
+    priceSnapshot: priceSnapshotSchema,
+    billedAmount: exactDecimalSchema,
+    currency: currencyCodeSchema,
+    platformFeeOnly: z.boolean(),
+})
+    .strict()
+    .superRefine((record, ctx) => {
+    uniqueUnits(record.units, ctx);
+    if (record.currency !== record.priceSnapshot.currency) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['priceSnapshot', 'currency'],
+            message: 'a record is settled in the currency it was priced in',
+        });
+    }
+});
+/**
+ * An internally metered request: measured and recorded, never charged. The
+ * tariff is what the published price list WOULD have charged, which is not a
+ * cost and not a charge.
+ */
+export const meteredGenerationRecordSchema = z
+    .object({
+    ...recordFields,
+    kind: z.literal('metered_usage'),
+    meteredUsageId: z.string().min(1).max(128),
+    /** The request this one ran inside, for a child such as an Auto classification. */
+    parentRequestId: requestIdSchema.optional(),
+    tariff: z.discriminatedUnion('status', [
+        z
+            .object({
+            status: z.literal('quoted'),
+            amount: exactDecimalSchema,
+            currency: currencyCodeSchema,
+            priceVersionId: z.string().min(1).max(128),
+        })
+            .strict(),
+        z
+            .object({
+            status: z.literal('unpriced'),
+            priceVersionId: z.string().min(1).max(128).nullable(),
+        })
+            .strict(),
+    ]),
+    customerCharge: z.object({ status: z.literal('not_charged') }).strict(),
+})
+    .strict()
+    .superRefine((record, ctx) => uniqueUnits(record.units, ctx));
+/** `GET /v1/generations/{id}` and `GET /v1/generations?idempotency_key=`. */
+export const generationRecordSchema = z.discriminatedUnion('kind', [
+    chargedGenerationRecordSchema,
+    meteredGenerationRecordSchema,
+]);

package/dist/public/identifiers.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Identifiers and wire primitives of the public API (`https://kaana.ai/v1`).
+ *
+ * Every regex is plain ASCII: the package runs on Hermes (React Native), which
+ * rejects Unicode property escapes at runtime.
+ *
+ * Moved from `@oxy.so/contracts` 4.12.0 (`src/inference/identifiers.ts`) by Kaana ADR 0002.
+ */
+import { z } from 'zod';
+/**
+ * A delegated end-user identity (Alia's `X-Oxy-User-Id`), branded with a
+ * DIFFERENT brand from {@link oxyAccountIdSchema} so the two cannot be
+ * substituted for one another in either direction, in any consumer, without a
+ * cast that review would catch.
+ *
+ * It exists for attribution and product-side personalisation only. It is never
+ * a billing principal, never an access-control principal, and its presence
+ * never changes which account is charged.
+ */
+export declare const delegatedUserIdSchema: z.core.$ZodBranded<z.ZodString, "DelegatedUserId", "out">;
+/**
+ * An Oxy `Application._id`. Not branded: no invariant in this contract turns on
+ * confusing it with another id, and brand inflation costs every producer a
+ * parse call for no safety. The two ids above are branded because ADR 0007's
+ * rule is exactly that they must not be interchangeable.
+ */
+export declare const oxyApplicationIdSchema: z.ZodString;
+/** An Oxy `ApplicationCredential._id` — the credential used for this request. */
+export declare const oxyCredentialIdSchema: z.ZodString;
+/**
+ * A request id allocated by the Oxy EDGE, at admission and BEFORE
+ * authentication, so that a request rejected for a bad credential is as
+ * traceable as one that was served (ADR 0007, and step 1 of ADR 0010's edge
+ * order). It is required on the inbound envelope, which is what makes the data
+ * plane a consumer of this id rather than its source: the data plane echoes it
+ * on every stream event, on the usage report, in its response header and on
+ * anything it can be asked about later. It never mints one for a request it
+ * received.
+ *
+ * The one case that is NOT an exception to that: an envelope the data plane
+ * cannot read or authenticate carries no id to echo, so its rejection is
+ * labelled with an id of the data plane's own — visibly local, and never
+ * correlated with an Oxy request, because there is no Oxy request it belongs to.
+ * Saying so is what stops "consumer, not source" from being read as forbidding
+ * the only id such a rejection could have.
+ *
+ * Correlates the Oxy edge, the data plane, the financial ledger and the
+ * customer-visible receipt, so it appears on every stream event and every
+ * ledger record.
+ */
+export declare const requestIdSchema: z.ZodString;
+/**
+ * A generation id generated by the data plane, present when a request produced
+ * a generation that can be looked up later (`GET /v1/generations/:id`).
+ */
+export declare const generationIdSchema: z.ZodString;
+/**
+ * A caller-supplied idempotency key. Every reserve/settle/refund call is keyed
+ * on one so a retry, a redelivered event or a duplicated webhook can never
+ * charge twice.
+ */
+export declare const idempotencyKeySchema: z.ZodString;
+/** Credential environments. A credential is issued into exactly one of them. */
+export declare const inferenceEnvironmentSchema: z.ZodEnum<{
+    development: "development";
+    staging: "staging";
+    production: "production";
+}>;
+/**
+ * An instant, as an ISO 8601 string in UTC (`2026-08-15T09:41:00.000Z`).
+ *
+ * Validated rather than left free-form — unlike the session contracts, which
+ * carry legacy expiry strings no consumer interprets, every instant here is
+ * read: a reservation expires, a price version starts applying, a receipt is
+ * settled. One canonical spelling (UTC, `Z`) so two records that describe the
+ * same moment compare and sort as equal, which a mix of offsets would not.
+ */
+export declare const inferenceTimestampSchema: z.ZodString;
+/**
+ * A calendar DATE with no instant attached (`2026-05-01`) — a knowledge cutoff
+ * or a release date, which are published as days and become wrong when a
+ * timezone is invented for them.
+ */
+export declare const inferenceDateSchema: z.ZodString;
+/** An absolute https URL, for model cards, licenses and provider documentation. */
+export declare const inferenceHttpsUrlSchema: z.ZodString;
+/**
+ * A content digest, `sha256:<64 lowercase hex>`.
+ *
+ * ONE spelling, because a digest is compared for equality and nothing else: an
+ * uppercase or unprefixed variant of the same hash is a different string, so two
+ * records describing the same bytes would not match. Lowercase hex with the
+ * algorithm prefix is what the `inference_model_revisions` CHECK stores and what
+ * every artifact registry emits.
+ */
+export declare const sha256DigestSchema: z.ZodString;
+/** Standard base64 in whole, padded 4-character groups. */
+export declare const PADDED_BASE64_PATTERN: RegExp;
+/** A publisher slug, e.g. `openai`, `anthropic`, `meta`, `alia`. */
+export declare const publisherSlugSchema: z.ZodString;
+/** A model slug within its publisher's namespace, e.g. `gpt-5`, `llama-3.1-70b`. */
+export declare const modelSlugSchema: z.ZodString;
+/**
+ * A canonical model id, `<publisher>/<model>`. This names a MODEL — a
+ * long-lived product identity whose behaviour changes as revisions ship. It
+ * does not name a revision, a deployment or a provider.
+ */
+export declare const modelIdSchema: z.ZodString;
+/** An immutable revision label, unique within its model, e.g. `2026-05-01`. */
+export declare const modelRevisionLabelSchema: z.ZodString;
+/**
+ * A model reference as a customer writes it: `<publisher>/<model>` (the model's
+ * current revision, chosen by Oxy) or `<publisher>/<model>@<revision>` (an
+ * immutable revision the customer pinned).
+ *
+ * Both forms name a CONCRETE MODEL. Neither can name a routing profile — see
+ * {@link routingProfileSlugSchema} — which is what makes "a request for a
+ * concrete model is never silently replaced with a different model" a
+ * distinction the type system can carry rather than a convention.
+ */
+export declare const modelReferenceSchema: z.ZodString;
+/**
+ * A region identifier, e.g. `us-west-2`, `eu-central-1`. Free-form rather than
+ * a closed enum because the set is provider-defined and grows without any
+ * contract change; residency policies match on exact strings.
+ */
+export declare const inferenceRegionSchema: z.ZodString;
+/**
+ * The publisher namespace reserved for models Alia actually owns or derives.
+ *
+ * `alia/*` is never a re-badged third-party route and never a prompt preset —
+ * enforcing that is the job of `modelSchema`'s provenance refinement, which
+ * this constant exists to be checked against.
+ */
+export declare const RESERVED_ALIA_PUBLISHER = "alia";
+export type DelegatedUserId = z.infer<typeof delegatedUserIdSchema>;
+export type InferenceEnvironment = z.infer<typeof inferenceEnvironmentSchema>;
+export type ModelReference = z.infer<typeof modelReferenceSchema>;
+export type ModelId = z.infer<typeof modelIdSchema>;