@qvac/sdk 0.5.0 → 0.6.1

package/dist/schemas/load-model.js

@@ -1,16 +1,18 @@
 import { z } from "zod";
-import { llmConfigSchema, embedConfigSchema } from "./llamacpp-config.js";
+import { llmConfigBaseSchema, embedConfigBaseSchema, } from "./llamacpp-config.js";
 import { whisperConfigSchema } from "./whispercpp-config.js";
 import { delegateSchema } from "./delegate.js";
 import { nmtConfigSchema } from "./translation-config.js";
 import { ttsConfigSchema } from "./text-to-speech.js";
+import { ocrConfigSchema } from "./ocr.js";
 import { modelSrcInputSchema, modelInputToSrcSchema, modelInputToNameSchema, } from "./model-src-utils.js";
+import { llmModelTypeSchema, whisperModelTypeSchema, embeddingsModelTypeSchema, nmtModelTypeSchema, ttsModelTypeSchema, ocrModelTypeSchema, ModelType, } from "./model-types.js";
 import { reloadConfigRequestSchema } from "./reload-config.js";
 const loadModelOptionsBaseSchema = z.union([
     z.object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("llm"),
-        modelConfig: llmConfigSchema.partial().strict().optional(),
+        modelType: llmModelTypeSchema,
+        modelConfig: llmConfigBaseSchema.strict().optional(),
         seed: z.boolean().optional(),
         projectionModelSrc: modelSrcInputSchema.optional(),
         delegate: delegateSchema,
@@ -18,7 +20,7 @@ const loadModelOptionsBaseSchema = z.union([
     }),
     z.object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("whisper"),
+        modelType: whisperModelTypeSchema,
         modelConfig: whisperConfigSchema.partial().strict().optional(),
         seed: z.boolean().optional(),
         vadModelSrc: modelSrcInputSchema.optional(),
@@ -26,27 +28,37 @@ const loadModelOptionsBaseSchema = z.union([
     }),
     z.object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("embeddings"),
-        modelConfig: embedConfigSchema.partial().strict().optional(),
+        modelType: embeddingsModelTypeSchema,
+        modelConfig: embedConfigBaseSchema.strict().optional(),
         seed: z.boolean().optional(),
         delegate: delegateSchema,
     }),
     z.object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("nmt"),
+        modelType: nmtModelTypeSchema,
         modelConfig: nmtConfigSchema,
+        srcVocabSrc: modelSrcInputSchema.optional(),
+        dstVocabSrc: modelSrcInputSchema.optional(),
         seed: z.boolean().optional(),
         delegate: delegateSchema,
     }),
     z.object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("tts"),
+        modelType: ttsModelTypeSchema,
         modelConfig: ttsConfigSchema,
         configSrc: modelSrcInputSchema,
         eSpeakDataPath: z.string(),
         seed: z.boolean().optional(),
         delegate: delegateSchema,
     }),
+    z.object({
+        modelSrc: modelSrcInputSchema,
+        modelType: ocrModelTypeSchema,
+        modelConfig: ocrConfigSchema.partial().strict().optional(),
+        detectorModelSrc: modelSrcInputSchema.optional(),
+        seed: z.boolean().optional(),
+        delegate: delegateSchema,
+    }),
 ]);
 export const loadModelOptionsSchema = loadModelOptionsBaseSchema.transform((data) => ({
     ...data,
@@ -56,8 +68,8 @@ export const loadModelOptionsToRequestSchema = z.union([
     z
         .object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("llm"),
-        modelConfig: llmConfigSchema.partial().strict().optional(),
+        modelType: llmModelTypeSchema,
+        modelConfig: llmConfigBaseSchema.strict().optional(),
         seed: z.boolean().optional(),
         projectionModelSrc: modelSrcInputSchema.optional(),
         delegate: delegateSchema,
@@ -67,7 +79,7 @@ export const loadModelOptionsToRequestSchema = z.union([
     })
         .transform((data) => ({
         type: "loadModel",
-        modelType: "llm",
+        modelType: ModelType.llamacppCompletion,
         modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
         modelName: modelInputToNameSchema.parse(data.modelSrc),
         modelConfig: (data.modelConfig ?? {}),
@@ -81,7 +93,7 @@ export const loadModelOptionsToRequestSchema = z.union([
     z
         .object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("whisper"),
+        modelType: whisperModelTypeSchema,
         modelConfig: whisperConfigSchema.partial().strict().optional(),
         seed: z.boolean().optional(),
         vadModelSrc: modelSrcInputSchema.optional(),
@@ -91,7 +103,7 @@ export const loadModelOptionsToRequestSchema = z.union([
     })
         .transform((data) => ({
         type: "loadModel",
-        modelType: "whisper",
+        modelType: ModelType.whispercppTranscription,
         modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
         modelName: modelInputToNameSchema.parse(data.modelSrc),
         modelConfig: (data.modelConfig ?? {}),
@@ -105,8 +117,8 @@ export const loadModelOptionsToRequestSchema = z.union([
     z
         .object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("embeddings"),
-        modelConfig: embedConfigSchema.partial().strict().optional(),
+        modelType: embeddingsModelTypeSchema,
+        modelConfig: embedConfigBaseSchema.strict().optional(),
         seed: z.boolean().optional(),
         delegate: delegateSchema,
         onProgress: z.unknown().optional(),
@@ -114,7 +126,7 @@ export const loadModelOptionsToRequestSchema = z.union([
     })
         .transform((data) => ({
         type: "loadModel",
-        modelType: "embeddings",
+        modelType: ModelType.llamacppEmbedding,
         modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
         modelName: modelInputToNameSchema.parse(data.modelSrc),
         modelConfig: (data.modelConfig ?? {}),
@@ -125,8 +137,10 @@ export const loadModelOptionsToRequestSchema = z.union([
     z
         .object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("nmt"),
+        modelType: nmtModelTypeSchema,
         modelConfig: nmtConfigSchema,
+        srcVocabSrc: modelSrcInputSchema.optional(),
+        dstVocabSrc: modelSrcInputSchema.optional(),
         seed: z.boolean().optional(),
         delegate: delegateSchema,
         onProgress: z.unknown().optional(),
@@ -134,10 +148,16 @@ export const loadModelOptionsToRequestSchema = z.union([
     })
         .transform((data) => ({
         type: "loadModel",
-        modelType: "nmt",
+        modelType: ModelType.nmtcppTranslation,
         modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
         modelName: modelInputToNameSchema.parse(data.modelSrc),
         modelConfig: data.modelConfig,
+        srcVocabSrc: data.srcVocabSrc
+            ? modelInputToSrcSchema.parse(data.srcVocabSrc)
+            : undefined,
+        dstVocabSrc: data.dstVocabSrc
+            ? modelInputToSrcSchema.parse(data.dstVocabSrc)
+            : undefined,
         seed: data.seed ?? false,
         withProgress: data.withProgress ?? !!data.onProgress,
         delegate: data.delegate,
@@ -145,7 +165,7 @@ export const loadModelOptionsToRequestSchema = z.union([
     z
         .object({
         modelSrc: modelSrcInputSchema,
-        modelType: z.literal("tts"),
+        modelType: ttsModelTypeSchema,
         modelConfig: ttsConfigSchema,
         configSrc: modelSrcInputSchema,
         eSpeakDataPath: z.string(),
@@ -156,7 +176,7 @@ export const loadModelOptionsToRequestSchema = z.union([
     })
         .transform((data) => ({
         type: "loadModel",
-        modelType: "tts",
+        modelType: ModelType.onnxTts,
         modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
         modelName: modelInputToNameSchema.parse(data.modelSrc),
         modelConfig: data.modelConfig,
@@ -166,6 +186,30 @@ export const loadModelOptionsToRequestSchema = z.union([
         configSrc: modelInputToSrcSchema.parse(data.configSrc),
         eSpeakDataPath: data.eSpeakDataPath,
     })),
+    z
+        .object({
+        modelSrc: modelSrcInputSchema,
+        modelType: ocrModelTypeSchema,
+        modelConfig: ocrConfigSchema.partial().strict().optional(),
+        detectorModelSrc: modelSrcInputSchema.optional(),
+        seed: z.boolean().optional(),
+        delegate: delegateSchema,
+        onProgress: z.unknown().optional(),
+        withProgress: z.boolean().optional(),
+    })
+        .transform((data) => ({
+        type: "loadModel",
+        modelType: ModelType.onnxOcr,
+        modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
+        modelName: modelInputToNameSchema.parse(data.modelSrc),
+        modelConfig: (data.modelConfig ?? {}),
+        seed: data.seed ?? false,
+        withProgress: data.withProgress ?? !!data.onProgress,
+        delegate: data.delegate,
+        detectorModelSrc: data.detectorModelSrc
+            ? modelInputToSrcSchema.parse(data.detectorModelSrc)
+            : undefined,
+    })),
 ]);
 const commonModelConfigSchema = z.object({
     type: z.literal("loadModel"),
@@ -174,41 +218,51 @@ const commonModelConfigSchema = z.object({
     projectionModelSrc: z.string().optional(),
     vadModelSrc: z.string().optional(),
     configSrc: z.string().optional(),
+    detectorModelSrc: z.string().optional(),
     withProgress: z.boolean().optional(),
     seed: z.boolean().optional(),
     delegate: delegateSchema,
 });
-// Request schemas for each model type
+// Request schemas for each model type (use canonical types since transforms normalize)
+// Use base schemas (no defaults) for client-side validation.
+// Server applies device defaults, then full schema defaults.
 export const loadLlmModelRequestSchema = commonModelConfigSchema.extend({
-    modelType: z.literal("llm"),
-    modelConfig: llmConfigSchema,
+    modelType: z.literal(ModelType.llamacppCompletion),
+    modelConfig: llmConfigBaseSchema,
 });
 export const loadWhisperModelRequestSchema = commonModelConfigSchema.extend({
-    modelType: z.literal("whisper"),
-    modelConfig: whisperConfigSchema,
+    modelType: z.literal(ModelType.whispercppTranscription),
+    modelConfig: whisperConfigSchema, // whisper has no defaults
 });
 export const loadEmbeddingsModelRequestSchema = commonModelConfigSchema.extend({
-    modelType: z.literal("embeddings"),
-    modelConfig: embedConfigSchema,
+    modelType: z.literal(ModelType.llamacppEmbedding),
+    modelConfig: embedConfigBaseSchema,
 });
 export const loadNmtModelRequestSchema = commonModelConfigSchema.extend({
-    modelType: z.literal("nmt"),
-    modelConfig: nmtConfigSchema,
+    modelType: z.literal(ModelType.nmtcppTranslation),
+    modelConfig: nmtConfigSchema, // nmt has no defaults
+    srcVocabSrc: z.string().optional(),
+    dstVocabSrc: z.string().optional(),
 });
 export const loadTtsModelRequestSchema = commonModelConfigSchema.extend({
-    modelType: z.literal("tts"),
-    modelConfig: ttsConfigSchema,
+    modelType: z.literal(ModelType.onnxTts),
+    modelConfig: ttsConfigSchema, // tts has no defaults
     configSrc: z.string(),
     eSpeakDataPath: z.string(),
 });
-// Union of all load model request types
+export const loadOcrModelRequestSchema = commonModelConfigSchema.extend({
+    modelType: z.literal(ModelType.onnxOcr),
+    modelConfig: ocrConfigSchema, // ocr has no defaults
+});
+// Union of all load model request types (using z.union since each modelType accepts multiple values)
 export const loadModelSrcRequestSchema = z
-    .discriminatedUnion("modelType", [
+    .union([
     loadLlmModelRequestSchema,
     loadWhisperModelRequestSchema,
     loadEmbeddingsModelRequestSchema,
     loadNmtModelRequestSchema,
     loadTtsModelRequestSchema,
+    loadOcrModelRequestSchema,
 ])
     .transform((data) => ({
     ...data,
@@ -257,5 +311,6 @@ export const loadModelServerParamsSchema = z.object({
     vadModelPath: z.string().optional(),
     ttsConfigModelPath: z.string().optional(),
     eSpeakDataPath: z.string().optional(),
+    detectorModelPath: z.string().optional(),
     modelName: z.string().optional(),
 });

package/dist/schemas/logging-stream.d.ts

@@ -1,10 +1,10 @@
 import { z } from "zod";
 export declare const logLevelSchema: z.ZodEnum<{
     error: "error";
+    off: "off";
     warn: "warn";
     info: "info";
     debug: "debug";
-    off: "off";
 }>;
 declare const loggingParamsSchema: z.ZodObject<{
     id: z.ZodString;
@@ -18,10 +18,10 @@ export declare const loggingStreamResponseSchema: z.ZodObject<{
     id: z.ZodString;
     level: z.ZodEnum<{
         error: "error";
+        off: "off";
         warn: "warn";
         info: "info";
         debug: "debug";
-        off: "off";
     }>;
     namespace: z.ZodString;
     message: z.ZodString;

package/dist/schemas/model-src-utils.d.ts

@@ -1,6 +1,4 @@
 import { z } from "zod";
-export declare const MODEL_TYPES: readonly ["llm", "whisper", "embeddings", "nmt", "tts"];
-export type ModelType = (typeof MODEL_TYPES)[number];
 export declare const modelDescriptorSchema: z.ZodObject<{
     src: z.ZodString;
     name: z.ZodOptional<z.ZodString>;
@@ -9,14 +7,20 @@ export declare const modelDescriptorSchema: z.ZodObject<{
     hyperbeeKey: z.ZodOptional<z.ZodString>;
     expectedSize: z.ZodOptional<z.ZodNumber>;
     sha256Checksum: z.ZodOptional<z.ZodString>;
-    addon: z.ZodOptional<z.ZodEnum<{
+    addon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        "llamacpp-completion": "llamacpp-completion";
+        "whispercpp-transcription": "whispercpp-transcription";
+        "llamacpp-embedding": "llamacpp-embedding";
+        "nmtcpp-translation": "nmtcpp-translation";
+        "onnx-tts": "onnx-tts";
+        "onnx-ocr": "onnx-ocr";
         llm: "llm";
         whisper: "whisper";
         embeddings: "embeddings";
         nmt: "nmt";
         tts: "tts";
-        vad: "vad";
-    }>>;
+        ocr: "ocr";
+    }>, z.ZodLiteral<"vad">]>>;
 }, z.core.$strip>;
 export declare const modelSrcInputSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
     src: z.ZodString;
@@ -26,14 +30,20 @@ export declare const modelSrcInputSchema: z.ZodUnion<readonly [z.ZodString, z.Zo
     hyperbeeKey: z.ZodOptional<z.ZodString>;
     expectedSize: z.ZodOptional<z.ZodNumber>;
     sha256Checksum: z.ZodOptional<z.ZodString>;
-    addon: z.ZodOptional<z.ZodEnum<{
+    addon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        "llamacpp-completion": "llamacpp-completion";
+        "whispercpp-transcription": "whispercpp-transcription";
+        "llamacpp-embedding": "llamacpp-embedding";
+        "nmtcpp-translation": "nmtcpp-translation";
+        "onnx-tts": "onnx-tts";
+        "onnx-ocr": "onnx-ocr";
         llm: "llm";
         whisper: "whisper";
         embeddings: "embeddings";
         nmt: "nmt";
         tts: "tts";
-        vad: "vad";
-    }>>;
+        ocr: "ocr";
+    }>, z.ZodLiteral<"vad">]>>;
 }, z.core.$strip>]>;
 export type ModelDescriptor = z.infer<typeof modelDescriptorSchema>;
 export type ModelSrcInput = z.infer<typeof modelSrcInputSchema>;
@@ -49,14 +59,20 @@ export declare const modelInputToSrcSchema: z.ZodPipe<z.ZodUnion<readonly [z.Zod
     hyperbeeKey: z.ZodOptional<z.ZodString>;
     expectedSize: z.ZodOptional<z.ZodNumber>;
     sha256Checksum: z.ZodOptional<z.ZodString>;
-    addon: z.ZodOptional<z.ZodEnum<{
+    addon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        "llamacpp-completion": "llamacpp-completion";
+        "whispercpp-transcription": "whispercpp-transcription";
+        "llamacpp-embedding": "llamacpp-embedding";
+        "nmtcpp-translation": "nmtcpp-translation";
+        "onnx-tts": "onnx-tts";
+        "onnx-ocr": "onnx-ocr";
         llm: "llm";
         whisper: "whisper";
         embeddings: "embeddings";
         nmt: "nmt";
         tts: "tts";
-        vad: "vad";
-    }>>;
+        ocr: "ocr";
+    }>, z.ZodLiteral<"vad">]>>;
 }, z.core.$strip>]>, z.ZodTransform<string, string | {
     src: string;
     name?: string | undefined;
@@ -65,7 +81,7 @@ export declare const modelInputToSrcSchema: z.ZodPipe<z.ZodUnion<readonly [z.Zod
     hyperbeeKey?: string | undefined;
     expectedSize?: number | undefined;
     sha256Checksum?: string | undefined;
-    addon?: "llm" | "whisper" | "embeddings" | "nmt" | "tts" | "vad" | undefined;
+    addon?: "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "onnx-ocr" | "llm" | "whisper" | "embeddings" | "nmt" | "tts" | "ocr" | "vad" | undefined;
 }>>;
 /**
  * Schema that transforms ModelSrc to its optional name
@@ -79,14 +95,20 @@ export declare const modelInputToNameSchema: z.ZodPipe<z.ZodUnion<readonly [z.Zo
     hyperbeeKey: z.ZodOptional<z.ZodString>;
     expectedSize: z.ZodOptional<z.ZodNumber>;
     sha256Checksum: z.ZodOptional<z.ZodString>;
-    addon: z.ZodOptional<z.ZodEnum<{
+    addon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        "llamacpp-completion": "llamacpp-completion";
+        "whispercpp-transcription": "whispercpp-transcription";
+        "llamacpp-embedding": "llamacpp-embedding";
+        "nmtcpp-translation": "nmtcpp-translation";
+        "onnx-tts": "onnx-tts";
+        "onnx-ocr": "onnx-ocr";
         llm: "llm";
         whisper: "whisper";
         embeddings: "embeddings";
         nmt: "nmt";
         tts: "tts";
-        vad: "vad";
-    }>>;
+        ocr: "ocr";
+    }>, z.ZodLiteral<"vad">]>>;
 }, z.core.$strip>]>, z.ZodTransform<string | undefined, string | {
     src: string;
     name?: string | undefined;
@@ -95,6 +117,6 @@ export declare const modelInputToNameSchema: z.ZodPipe<z.ZodUnion<readonly [z.Zo
     hyperbeeKey?: string | undefined;
     expectedSize?: number | undefined;
     sha256Checksum?: string | undefined;
-    addon?: "llm" | "whisper" | "embeddings" | "nmt" | "tts" | "vad" | undefined;
+    addon?: "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "onnx-ocr" | "llm" | "whisper" | "embeddings" | "nmt" | "tts" | "ocr" | "vad" | undefined;
 }>>;
 //# sourceMappingURL=model-src-utils.d.ts.map

package/dist/schemas/model-src-utils.js

@@ -1,11 +1,7 @@
 import { z } from "zod";
-export const MODEL_TYPES = [
-    "llm",
-    "whisper",
-    "embeddings",
-    "nmt",
-    "tts",
-];
+import { modelTypeInputSchema } from "./model-types.js";
+// Addon field accepts model type inputs plus "vad"
+const addonSchema = z.union([modelTypeInputSchema, z.literal("vad")]);
 export const modelDescriptorSchema = z.object({
     src: z.string(),
     name: z.string().optional(),
@@ -14,7 +10,7 @@ export const modelDescriptorSchema = z.object({
     hyperbeeKey: z.string().optional(),
     expectedSize: z.number().optional(),
     sha256Checksum: z.string().optional(),
-    addon: z.enum([...MODEL_TYPES, "vad"]).optional(),
+    addon: addonSchema.optional(),
 });
 export const modelSrcInputSchema = z.union([z.string(), modelDescriptorSchema]);
 /**

package/dist/schemas/model-types.d.ts

@@ -0,0 +1,154 @@
+import { z } from "zod";
+/**
+ * Canonical model type values for internal SDK use.
+ * Format: `engine-usecase` (e.g., "llamacpp-completion")
+ * Use dot-accessor syntax: `ModelType.llamacppCompletion`
+ */
+export declare const ModelType: {
+    readonly llamacppCompletion: "llamacpp-completion";
+    readonly whispercppTranscription: "whispercpp-transcription";
+    readonly llamacppEmbedding: "llamacpp-embedding";
+    readonly nmtcppTranslation: "nmtcpp-translation";
+    readonly onnxTts: "onnx-tts";
+    readonly onnxOcr: "onnx-ocr";
+};
+/**
+ * Alias mappings for backward compatibility.
+ * Maps old names to canonical values.
+ */
+export declare const ModelTypeAliases: {
+    readonly llm: "llamacpp-completion";
+    readonly whisper: "whispercpp-transcription";
+    readonly embeddings: "llamacpp-embedding";
+    readonly nmt: "nmtcpp-translation";
+    readonly tts: "onnx-tts";
+    readonly ocr: "onnx-ocr";
+};
+export type CanonicalModelType = (typeof ModelType)[keyof typeof ModelType];
+export type AliasKey = keyof typeof ModelTypeAliases;
+export type ModelTypeInput = CanonicalModelType | AliasKey;
+/**
+ * All valid model types: canonical names + aliases.
+ *
+ * Canonical names follow `engine-usecase` format (e.g., "llamacpp-completion").
+ * Aliases resolve to canonical names for backward compatibility.
+ *
+ * @example
+ * ```typescript
+ * // Using alias (backward compatible)
+ * loadModel({ modelSrc: "...", modelType: MODEL_TYPES.nmt });
+ * // MODEL_TYPES.nmt resolves to "nmtcpp-translation"
+ *
+ * // Using canonical name directly
+ * loadModel({ modelSrc: "...", modelType: MODEL_TYPES.nmtcppTranslation });
+ * ```
+ */
+export declare const PUBLIC_MODEL_TYPES: {
+    readonly llm: "llamacpp-completion";
+    readonly whisper: "whispercpp-transcription";
+    readonly embeddings: "llamacpp-embedding";
+    readonly nmt: "nmtcpp-translation";
+    readonly tts: "onnx-tts";
+    readonly ocr: "onnx-ocr";
+    readonly llamacppCompletion: "llamacpp-completion";
+    readonly whispercppTranscription: "whispercpp-transcription";
+    readonly llamacppEmbedding: "llamacpp-embedding";
+    readonly nmtcppTranslation: "nmtcpp-translation";
+    readonly onnxTts: "onnx-tts";
+    readonly onnxOcr: "onnx-ocr";
+};
+/** Schema accepting both canonical and alias model type inputs */
+export declare const modelTypeInputSchema: z.ZodEnum<{
+    "llamacpp-completion": "llamacpp-completion";
+    "whispercpp-transcription": "whispercpp-transcription";
+    "llamacpp-embedding": "llamacpp-embedding";
+    "nmtcpp-translation": "nmtcpp-translation";
+    "onnx-tts": "onnx-tts";
+    "onnx-ocr": "onnx-ocr";
+    llm: "llm";
+    whisper: "whisper";
+    embeddings: "embeddings";
+    nmt: "nmt";
+    tts: "tts";
+    ocr: "ocr";
+}>;
+/** Schema that transforms input to canonical model type */
+export declare const modelTypeSchema: z.ZodPipe<z.ZodEnum<{
+    "llamacpp-completion": "llamacpp-completion";
+    "whispercpp-transcription": "whispercpp-transcription";
+    "llamacpp-embedding": "llamacpp-embedding";
+    "nmtcpp-translation": "nmtcpp-translation";
+    "onnx-tts": "onnx-tts";
+    "onnx-ocr": "onnx-ocr";
+    llm: "llm";
+    whisper: "whisper";
+    embeddings: "embeddings";
+    nmt: "nmt";
+    tts: "tts";
+    ocr: "ocr";
+}>, z.ZodTransform<"llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "onnx-ocr", "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "onnx-ocr" | "llm" | "whisper" | "embeddings" | "nmt" | "tts" | "ocr">>;
+/** Normalize model type input to canonical form */
+export declare function normalizeModelType(input: ModelTypeInput): CanonicalModelType;
+/** Check if input is an alias (not canonical) */
+export declare function isModelTypeAlias(input: ModelTypeInput): boolean;
+/**
+ * LLM/Completion model type schema.
+ * - Alias: `"llm"` → resolves to `"llamacpp-completion"`
+ * - Canonical: `"llamacpp-completion"`
+ */
+export declare const llmModelTypeSchema: z.ZodEnum<{
+    "llamacpp-completion": "llamacpp-completion";
+    llm: "llm";
+}>;
+export type LlmModelTypeInput = z.infer<typeof llmModelTypeSchema>;
+/**
+ * Whisper/Transcription model type schema.
+ * - Alias: `"whisper"` → resolves to `"whispercpp-transcription"`
+ * - Canonical: `"whispercpp-transcription"`
+ */
+export declare const whisperModelTypeSchema: z.ZodEnum<{
+    "whispercpp-transcription": "whispercpp-transcription";
+    whisper: "whisper";
+}>;
+export type WhisperModelTypeInput = z.infer<typeof whisperModelTypeSchema>;
+/**
+ * Embeddings model type schema.
+ * - Alias: `"embeddings"` → resolves to `"llamacpp-embedding"`
+ * - Canonical: `"llamacpp-embedding"`
+ */
+export declare const embeddingsModelTypeSchema: z.ZodEnum<{
+    "llamacpp-embedding": "llamacpp-embedding";
+    embeddings: "embeddings";
+}>;
+export type EmbeddingsModelTypeInput = z.infer<typeof embeddingsModelTypeSchema>;
+/**
+ * NMT/Translation model type schema.
+ * - Alias: `"nmt"` → resolves to `"nmtcpp-translation"`
+ * - Canonical: `"nmtcpp-translation"`
+ */
+export declare const nmtModelTypeSchema: z.ZodEnum<{
+    "nmtcpp-translation": "nmtcpp-translation";
+    nmt: "nmt";
+}>;
+export type NmtModelTypeInput = z.infer<typeof nmtModelTypeSchema>;
+/**
+ * TTS model type schema.
+ * - Alias: `"tts"` → resolves to `"onnx-tts"`
+ * - Canonical: `"onnx-tts"`
+ */
+export declare const ttsModelTypeSchema: z.ZodEnum<{
+    "onnx-tts": "onnx-tts";
+    tts: "tts";
+}>;
+export type TtsModelTypeInput = z.infer<typeof ttsModelTypeSchema>;
+/**
+ * OCR model type schema.
+ * - Alias: `"ocr"` → resolves to `"onnx-ocr"`
+ * - Canonical: `"onnx-ocr"`
+ */
+export declare const ocrModelTypeSchema: z.ZodEnum<{
+    "onnx-ocr": "onnx-ocr";
+    ocr: "ocr";
+}>;
+export type OcrModelTypeInput = z.infer<typeof ocrModelTypeSchema>;
+//# sourceMappingURL=model-types.d.ts.map