open-classify 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Taylor Bayouth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,290 @@
+<p align="center">
+  <img src="open-classify-logo.png" alt="Open Classify" width="220">
+</p>
+
+<p align="center">
+  Decide what should happen to a user message <em>before</em> it reaches your downstream model.
+</p>
+
+Open Classify is a pre-routing layer for AI products. It runs a small set of fast classifiers in parallel against the latest user message, then tells your app one of four things: **route** it, **answer** it immediately, **block** it, or flag it for **review**.
+
+Use it when your frontier model should not be the first thing every request touches. Open Classify can handle tiny terminal replies before they hit an expensive model, recommend the right downstream model for the actual task, suggest what tools or context the downstream model should receive, and add a safety pass for prompt injection and permission-boundary risk.
+
+The result is a small, auditable decision envelope your app can act on before spending the big tokens.
+
+```
+message
+  │
+  ▼
+normalize + trim classifier context
+  │
+  ├─► preflight ─────────────► final_reply? / ack_reply?
+  ├─► routing ───────────────► model_tier?
+  ├─► model_specialization ──► specialization?
+  ├─► tools ─────────────────► tools?
+  ├─► security ──────────────► safety verdict
+  └─► custom classifiers ────► JSON-Schema output
+        (run in parallel)
+  │
+  ▼
+aggregator + model catalog
+  │
+  ▼
+route / answer / block / needs_review
+```
+
+Stock classifiers have fixed typed signals. Custom classifiers carry their own JSON-Schema-validated payload. The aggregator merges everything, resolves a concrete model from your catalog, and short-circuits when preflight has a final answer or security flags risk.
+
+## Why Open Classify
+
+- **Spend frontier tokens only when they matter.** Simple greetings, thanks, spelling checks, and small arithmetic can return `action: "answer"` with a `final_reply` and skip downstream work entirely.
+- **Keep the user interface responsive.** For complex work, preflight can return an `ack_reply` while your app routes the request to the real worker.
+- **Pick the right model per message.** Classifiers emit soft constraints like tier and specialization; your catalog turns those into a concrete model optimized for cost, capability, and fit.
+- **Shape downstream context intentionally.** Built-in and custom classifiers can recommend tools, retrieval queries, summaries, or other context hints without passing the full conversation history back to the caller.
+- **Add another defensive layer.** The security classifier can block or require review for prompt injection, secret exposure risk, unsafe tool use, and related boundary violations.
+
+## Install
+
+```sh
+npm install open-classify
+```
+
+Node 18+. The packaged runner is local Ollama and ships with `gemma4:e4b-it-q4_K_M` as the zero-config classifier model. That runner is configurable through `open-classify.config.json`; arbitrary backends are supported in code by implementing `RunClassifier`.
+
+## Hello World
+
+```ts
+import { classifyWithOllama, loadCatalog } from "open-classify";
+
+const result = await classifyWithOllama(
+  {
+    messages: [
+      { role: "user", text: "Can you review the attached contract?" },
+    ],
+  },
+  { catalog: loadCatalog("downstream-models.json") },
+);
+
+if (result.action === "route") {
+  // result.downstream.model_id is a concrete model from your catalog.
+  // result.downstream.tools is the recommended tool exposure.
+  // result.classifier_outputs holds any custom classifier payloads.
+}
+```
+
+## What you get back
+
+Every call returns a `PipelineResult` with one of four `action` values:
+
+| `action` | When | Key fields |
+|---|---|---|
+| `route` | Default — downstream work should continue | `downstream.{model_id, target_message, tools}`, `audit.ack_reply?` |
+| `answer` | Preflight had a tiny terminal reply | `final_reply` |
+| `block` | Security flagged `decision: "block"` (with `high_risk`) | `reason.{risk_level, signals}` |
+| `needs_review` | Security flagged `decision: "needs_review"` | `reason.{risk_level, signals}` |
+
+All four also carry `message_id`, `classifier_outputs` (custom classifier payloads, keyed by name), and an `audit` block. Route results include the downstream target message, not the caller's message history. Short-circuit results include the firing classifier's audit context.
+
+For complex requests, look for `audit.ack_reply` on `route` results. It is the immediate acknowledgement your UI can show while the downstream model works. For trivial requests, `result.final_reply.reply` is the complete response and no downstream model is needed.
+
+Example `route` result:
+
+```json
+{
+  "action": "route",
+  "message_id": "b11d5268",
+  "downstream": {
+    "model_id": "gpt-5.5",
+    "tools": { "tools": ["workspace"] },
+    "target_message": { "role": "user", "text": "...", "hash": "b11d5268" }
+  },
+  "classifier_outputs": {
+    "memory_retrieval_queries": { "queries": ["user code review preferences"] }
+  },
+  "audit": {
+    "ack_reply": { "reply": "Let me check." },
+    "routing": { "model_tier": "frontier_strong" },
+    "model_specialization": { "specialization": "coding" },
+    "tools": { "tools": ["workspace"] },
+    "model_recommendation": {
+      "id": "gpt-5.5",
+      "context_window": 1050000,
+      "input_tokens_cpm": 5,
+      "cached_tokens_cpm": 0.5,
+      "output_tokens_cpm": 30,
+      "resolution": { "...": "..." }
+    },
+    "meta": { "classifiers": { "...": "..." } }
+  }
+}
+```
+
+## Stock classifiers
+
+Stock classifiers are built in and have fixed, typed output shapes. Each one owns exactly one signal. Its manifest lives in `src/classifiers/stock/<name>/manifest.json`; the shared stock prompt building blocks live in `src/classifiers/stock/prompts/`.
+
+Every classifier prompt includes a shared header with its `Classifier` name, `Purpose`, and an instruction to treat that purpose as a hard scope boundary. In practice:
+
+- `routing` chooses only `model_tier`
+- `model_specialization` chooses only `specialization`
+- `security` is only for safety and permission-boundary risk, not contradiction, feasibility, or freshness checks
+
+| Name | Signal | Short-circuits? |
+|---|---|---|
+| `preflight` | `final_reply?` / `ack_reply?` | `final_reply` → `answer` |
+| `routing` | `model_tier?` | no |
+| `model_specialization` | `specialization?` | no |
+| `tools` | `{ tools[] }` | no |
+| `security` | `{ decision?, risk_level, signals[] }` | `decision: "block"` → `block`, `"needs_review"` → `needs_review` |
+
+Each output may also carry optional `reason` (≤120 chars) and `confidence` (0–1). Below-threshold signals are dropped from aggregation; the default threshold is `0.6`.
+
+## Custom classifiers
+
+A custom classifier is two files in `src/classifiers/custom/<name>/`:
+
+`manifest.json`:
+
+```json
+{
+  "kind": "custom",
+  "name": "memory_retrieval_queries",
+  "version": "1.0.0",
+  "purpose": "Generate retrieval queries likely to surface helpful user-specific context for the downstream model.",
+  "order": 60,
+  "fallback": { "output": { "queries": [] } },
+  "output_schema": {
+    "type": "object",
+    "additionalProperties": false,
+    "required": ["queries"],
+    "properties": {
+      "queries": {
+        "type": "array", "maxItems": 5,
+        "items": { "type": "string", "minLength": 1, "maxLength": 120 }
+      }
+    }
+  }
+}
+```
+
+`prompt.md`: your classifier-specific instructions.
+
+Custom classifiers receive the same shared `Classifier` + `Purpose` header and the same scope-boundary instruction, so keep the manifest `purpose` specific and operational.
+
+The runtime auto-discovers it, validates outputs against your schema, and surfaces them on `result.classifier_outputs.<name>`. No TypeScript edits required.
+
+See [docs/adding-a-classifier.md](docs/adding-a-classifier.md) for a full walkthrough.
+
+## Model catalog
+
+Classifiers never emit model ids. They emit constraints; your catalog maps constraints to concrete models.
+
+```json
+{
+  "models": [
+    {
+      "id": "gpt-5.5",
+      "provider": "openai",
+      "runtime": "api",
+      "specializations": [
+        "chat",
+        "writing",
+        "reasoning",
+        "planning",
+        "coding",
+        "instruction_following",
+        "agentic_workflows"
+      ],
+      "tier": "frontier_strong",
+      "params_in_billions": null,
+      "context_window": 1050000,
+      "max_output_tokens": 128000,
+      "input_tokens_cpm": 5,
+      "cached_tokens_cpm": 0.5,
+      "output_tokens_cpm": 30
+    }
+  ],
+  "default": "gpt-5.5",
+  "pricing_unit": "USD per 1M tokens"
+}
+```
+
+OpenAI's GPT-5.5 model page lists text and image input, text output, a 1,050,000-token context window, 128,000 max output tokens, and text-token pricing of $5.00 input, $0.50 cached input, and $30.00 output per 1M tokens. OpenAI does not publish parameter counts, so use `null` for `params_in_billions`. See the [GPT-5.5 model details](https://developers.openai.com/api/docs/models/gpt-5.5) for current pricing and capability details.
+
+The resolver picks the cheapest model matching `specialization` and `tier`, relaxing constraints in order when nothing fits, and reports what it dropped on `audit.model_recommendation.resolution`. See [docs/resolver.md](docs/resolver.md) for ranking details.
+
+## Input contract
+
+`classifyWithOllama({ messages })` — that's the whole input.
+
+- `messages` is chronological, oldest to newest, and must end with the user message you want classified.
+- Open Classify keeps whole messages only, drops oldest first to fit a 5,000-char budget, and caps history at 20 messages.
+- Unknown fields are rejected, not passed through.
+
+## Local workbench
+
+```sh
+npm run setup
+npm run start
+```
+
+UI opens at `http://127.0.0.1:4317/`. Classifier cards use classifier names from the runtime, displayed with underscores as spaces; result rendering remains generic.
+
+Optional Ollama runtime config:
+
+```sh
+cp open-classify.config.example.json open-classify.config.json
+```
+
+```json
+{
+  "runner": {
+    "provider": "ollama",
+    "defaultModel": "gemma4:e4b-it-q4_K_M",
+    "models": {
+      "stock": {
+        "routing": "qwen2.5:7b-instruct-q4_K_M",
+        "security": "llama-guard3:8b"
+      },
+      "custom": {
+        "memory_retrieval_queries": "qwen2.5:7b-instruct-q4_K_M"
+      }
+    }
+  },
+  "catalog": "downstream-models.json"
+}
+```
+
+`runner.provider` currently supports `"ollama"` only. `runner.defaultModel` applies to any classifier without an explicit entry. `runner.models.stock` configures built-in classifiers; `runner.models.custom` configures custom classifiers by manifest name. The setup and start scripts read `open-classify.config.json`, or `OPEN_CLASSIFY_CONFIG` when you want a different path.
+
+## Bring your own backend
+
+The Ollama runner is one implementation of a single function:
+
+```ts
+type RunClassifier = (
+  name: string,
+  input: ClassifierInput,
+  signal: AbortSignal,
+) => Promise<ClassifierOutput>;
+```
+
+Pass any `RunClassifier` to `classifyOpenClassifyInput(input, { runClassifier, catalog })` to back classifiers with OpenAI, Anthropic, a remote service, or anything else. This is a code-level extension point, separate from the Ollama-only config file runner.
+
+## Further reading
+
+- [docs/signals.md](docs/signals.md) — full signal contracts and validation rules
+- [docs/manifests.md](docs/manifests.md) — manifest reference (stock and custom)
+- [docs/resolver.md](docs/resolver.md) — aggregation and model resolution
+- [docs/adding-a-classifier.md](docs/adding-a-classifier.md) — author guide
+
+## Development
+
+```sh
+npm test      # build + run the Node test runner suite
+npm run ui    # build + serve the local workbench
+```
+
+## Screenshot
+
+![Open Classify local workbench](open-classify-screenshot.png)

package/dist/src/aggregator.d.ts

@@ -0,0 +1,18 @@
+import type { AggregatorConfig, Catalog, ClassifierRegistry, ClassifierResults, Envelope, ModelRecommendation, ModelRecommendationResolution } from "./manifest.js";
+import type { AckReplySignal, ModelSpecializationClassifierOutput, FinalReplySignal, RoutingClassifierOutput, RoutingSignal } from "./stock.js";
+import type { ClassifierInput } from "./types.js";
+export declare const DEFAULT_CONFIDENCE_THRESHOLD = 0.6;
+export interface ComposeEnvelopeArgs {
+    readonly registry: ClassifierRegistry;
+    readonly results: ClassifierResults;
+    readonly catalog: Catalog;
+    readonly input: ClassifierInput;
+    readonly config?: AggregatorConfig;
+}
+export declare function composeEnvelope(args: ComposeEnvelopeArgs): Envelope;
+export declare function resolveModelFromRouting(routing: RoutingSignal | undefined, catalog: Catalog, confidence: number | undefined, ignoredConstraints?: ModelRecommendationResolution["constraints_dropped"]): ModelRecommendation;
+export declare function resolveModel(results: Readonly<{
+    routing?: RoutingClassifierOutput;
+    model_specialization?: ModelSpecializationClassifierOutput;
+}>, catalog: Catalog, threshold: number): ModelRecommendation;
+export type { FinalReplySignal, AckReplySignal };

package/dist/src/aggregator.js

@@ -0,0 +1,267 @@
+import { isCustomManifest, isStockManifest } from "./stock.js";
+export const DEFAULT_CONFIDENCE_THRESHOLD = 0.6;
+export function composeEnvelope(args) {
+    const { registry, results, catalog, config } = args;
+    const threshold = config?.confidenceThreshold ?? DEFAULT_CONFIDENCE_THRESHOLD;
+    const stockByName = stockResultsByName(registry, results);
+    const preflight = stockByName.preflight;
+    const routing = stockByName.routing;
+    const modelSpec = stockByName.model_specialization;
+    const tools = stockByName.tools;
+    const security = stockByName.security;
+    const preflightConfident = isConfident(preflight, threshold);
+    const finalReply = preflightConfident ? preflight?.final_reply : undefined;
+    const ackReply = preflightConfident ? preflight?.ack_reply : undefined;
+    const mergedRouting = mergeRouting(routing, modelSpec, threshold);
+    const lowConfidenceDrops = lowConfidenceRoutingDrops(routing, modelSpec, mergedRouting, threshold);
+    const toolsSignal = isConfident(tools, threshold) ? extractToolsSignal(tools) : undefined;
+    const safety = isConfident(security, threshold) ? extractSafetySignal(security) : undefined;
+    const envelope = {
+        ...optional("final_reply", finalReply),
+        ...optional("ack_reply", ackReply),
+        ...optional("routing", mergedRouting),
+        ...optional("tools", toolsSignal),
+        ...optional("safety", safety),
+        custom_outputs: customOutputs(registry, results),
+        model_recommendation: resolveModelFromRouting(mergedRouting, catalog, routingMaxConfidence(routing, modelSpec), lowConfidenceDrops),
+    };
+    return envelope;
+}
+function optional(key, value) {
+    return value === undefined ? {} : { [key]: value };
+}
+function stockResultsByName(registry, results) {
+    const map = {};
+    for (const manifest of registry) {
+        if (!isStockManifest(manifest))
+            continue;
+        const result = results[manifest.name];
+        if (result !== undefined) {
+            map[manifest.name] = result;
+        }
+    }
+    return map;
+}
+function isConfident(result, threshold) {
+    if (!result)
+        return false;
+    return (result.confidence ?? 0) >= threshold;
+}
+function mergeRouting(routing, modelSpec, threshold) {
+    const tier = pickConfidentAxis([
+        ["routing", routing, routing?.model_tier],
+    ], threshold);
+    const specialization = pickConfidentAxis([
+        ["model_specialization", modelSpec, modelSpec?.specialization],
+    ], threshold);
+    if (tier === undefined && specialization === undefined)
+        return undefined;
+    return {
+        ...(tier === undefined ? {} : { model_tier: tier }),
+        ...(specialization === undefined ? {} : { specialization }),
+    };
+}
+function pickConfidentAxis(candidates, threshold) {
+    let best;
+    for (const [, source, value] of candidates) {
+        if (value === undefined)
+            continue;
+        if (!isConfident(source, threshold))
+            continue;
+        const confidence = source.confidence ?? 0;
+        if (best === undefined || confidence > best.confidence) {
+            best = { value, confidence };
+        }
+    }
+    return best?.value;
+}
+function routingMaxConfidence(routing, modelSpec) {
+    const values = [routing?.confidence, modelSpec?.confidence].filter((v) => typeof v === "number");
+    if (values.length === 0)
+        return undefined;
+    return Math.max(...values);
+}
+function extractToolsSignal(result) {
+    return { tools: result.tools };
+}
+function extractSafetySignal(result) {
+    return {
+        ...(result.decision === undefined ? {} : { decision: result.decision }),
+        risk_level: result.risk_level,
+        signals: result.signals,
+    };
+}
+function customOutputs(registry, results) {
+    const out = [];
+    for (const manifest of registry) {
+        if (!isCustomManifest(manifest))
+            continue;
+        const result = results[manifest.name];
+        if (result === undefined)
+            continue;
+        out.push({
+            classifier: manifest.name,
+            ...(result.reason === undefined ? {} : { reason: result.reason }),
+            ...(result.confidence === undefined ? {} : { confidence: result.confidence }),
+            output: result.output,
+        });
+    }
+    return out;
+}
+// ─── Model recommendation ───────────────────────────────────────────────────
+function lowConfidenceRoutingDrops(routing, modelSpec, merged, threshold) {
+    const dropped = [];
+    if (merged?.specialization === undefined) {
+        if (hasLowConfidenceAxis(routing, "specialization", threshold) ||
+            hasLowConfidenceAxis(modelSpec, "specialization", threshold)) {
+            dropped.push({ axis: "specialization", reason: "low_confidence" });
+        }
+    }
+    if (merged?.model_tier === undefined) {
+        if (hasLowConfidenceAxis(routing, "model_tier", threshold) ||
+            hasLowConfidenceAxis(modelSpec, "model_tier", threshold)) {
+            dropped.push({ axis: "tier", reason: "low_confidence" });
+        }
+    }
+    return dropped;
+}
+function hasLowConfidenceAxis(result, field, threshold) {
+    if (!result)
+        return false;
+    if (result[field] === undefined)
+        return false;
+    return (result.confidence ?? 0) < threshold;
+}
+export function resolveModelFromRouting(routing, catalog, confidence, ignoredConstraints = []) {
+    const requested = {};
+    const confidences = {};
+    if (confidence !== undefined) {
+        confidences.routing = confidence;
+    }
+    if (routing?.specialization !== undefined)
+        requested.specialization = routing.specialization;
+    if (routing?.model_tier !== undefined)
+        requested.tier = routing.model_tier;
+    const passes = [
+        { useSpecialization: true, useTier: true },
+        { useSpecialization: true, useTier: false },
+        { useSpecialization: false, useTier: true },
+        { useSpecialization: false, useTier: false },
+    ];
+    for (const pass of passes) {
+        const constraints_used = constraintsForPass(requested, pass);
+        const matching = catalog.models.filter((model) => matchesConstraints(model, constraints_used));
+        if (matching.length === 0)
+            continue;
+        const winner = pickBestModel(matching, catalog.models);
+        return {
+            ...modelRecommendationFields(winner),
+            resolution: {
+                constraints_used,
+                constraints_dropped: [
+                    ...ignoredConstraints,
+                    ...relaxedConstraints(requested, constraints_used),
+                ],
+                confidences,
+                fell_back_to_default: false,
+            },
+        };
+    }
+    const fallback = catalog.models.find((model) => model.id === catalog.default);
+    if (!fallback) {
+        throw new Error(`catalog default "${catalog.default}" not found in models — catalog skipped validation`);
+    }
+    return {
+        ...modelRecommendationFields(fallback),
+        resolution: {
+            constraints_used: {},
+            constraints_dropped: [
+                ...ignoredConstraints,
+                ...defaultFallbackConstraints(requested),
+            ],
+            confidences,
+            fell_back_to_default: true,
+        },
+    };
+}
+// Test-friendly convenience wrapper: builds a routing signal from a typed
+// results map and resolves a model. Mirrors `composeEnvelope` for callers
+// that want just the model recommendation without the rest of the envelope.
+export function resolveModel(results, catalog, threshold) {
+    const routing = mergeRouting(results.routing, results.model_specialization, threshold);
+    return resolveModelFromRouting(routing, catalog, routingMaxConfidence(results.routing, results.model_specialization), lowConfidenceRoutingDrops(results.routing, results.model_specialization, routing, threshold));
+}
+function constraintsForPass(requested, pass) {
+    return {
+        ...(pass.useSpecialization && requested.specialization !== undefined
+            ? { specialization: requested.specialization }
+            : {}),
+        ...(pass.useTier && requested.tier !== undefined ? { tier: requested.tier } : {}),
+    };
+}
+function matchesConstraints(model, constraints) {
+    return ((constraints.specialization === undefined ||
+        model.specializations.includes(constraints.specialization)) &&
+        (constraints.tier === undefined || model.tier === constraints.tier));
+}
+function relaxedConstraints(requested, used) {
+    const dropped = [];
+    if (requested.specialization !== undefined && used.specialization === undefined) {
+        dropped.push({ axis: "specialization", reason: "no_match_relaxed" });
+    }
+    if (requested.tier !== undefined && used.tier === undefined) {
+        dropped.push({ axis: "tier", reason: "no_match_relaxed" });
+    }
+    return dropped;
+}
+function defaultFallbackConstraints(requested) {
+    const dropped = [];
+    if (requested.specialization !== undefined) {
+        dropped.push({ axis: "specialization", reason: "default_fallback" });
+    }
+    if (requested.tier !== undefined) {
+        dropped.push({ axis: "tier", reason: "default_fallback" });
+    }
+    return dropped;
+}
+function pickBestModel(candidates, catalogOrder) {
+    let winner = candidates[0];
+    for (let i = 1; i < candidates.length; i++) {
+        const candidate = candidates[i];
+        if (compareModels(candidate, winner, catalogOrder) < 0) {
+            winner = candidate;
+        }
+    }
+    return winner;
+}
+function compareModels(a, b, catalogOrder) {
+    const costDiff = priceIndex(a) - priceIndex(b);
+    if (Math.abs(costDiff) > Number.EPSILON)
+        return costDiff;
+    if (a.params_in_billions !== b.params_in_billions) {
+        return comparableParams(b) - comparableParams(a);
+    }
+    if (a.context_window !== b.context_window) {
+        return b.context_window - a.context_window;
+    }
+    return catalogOrder.indexOf(a) - catalogOrder.indexOf(b);
+}
+function priceIndex(model) {
+    if (model.input_tokens_cpm === undefined || model.output_tokens_cpm === undefined) {
+        return 0;
+    }
+    return model.input_tokens_cpm + model.output_tokens_cpm;
+}
+function comparableParams(model) {
+    return model.params_in_billions ?? 0;
+}
+function modelRecommendationFields(winner) {
+    return {
+        id: winner.id,
+        params_in_billions: winner.params_in_billions,
+        context_window: winner.context_window,
+        ...(winner.input_tokens_cpm === undefined ? {} : { input_tokens_cpm: winner.input_tokens_cpm }),
+        ...(winner.cached_tokens_cpm === undefined ? {} : { cached_tokens_cpm: winner.cached_tokens_cpm }),
+        ...(winner.output_tokens_cpm === undefined ? {} : { output_tokens_cpm: winner.output_tokens_cpm }),
+    };
+}

package/dist/src/catalog.d.ts

@@ -0,0 +1,7 @@
+import type { Catalog } from "./manifest.js";
+export declare class CatalogError extends Error {
+    readonly path?: string;
+    constructor(message: string, path?: string);
+}
+export declare function loadCatalog(configPath: string): Catalog;
+export declare function validateCatalog(value: unknown, path?: string): Catalog;