@zenera/faker 1.1.0

package/dist/server.js

@@ -0,0 +1,256 @@
+import { createHash, randomInt } from 'node:crypto';
+import { createServer } from 'node:http';
+import { BuildFailed } from "./cache.js";
+import { reason } from "./generate.js";
+import { describeIssues, issues } from "./validate.js";
+// ---------------------------------------------------------------------------
+// The server
+//
+// `node:http` and a switch. A framework would earn its place if there were
+// middleware to compose, and there is not: one route table, one validation
+// step, one generator.
+//
+// The rules that are not obvious from the code are the ones about what does not
+// travel. Request headers are filtered before the envelope is written, because
+// that envelope becomes a file inside a container. Request bodies never reach a
+// prompt at all — the build loop uses probes it made up. And the listener binds
+// to loopback unless somebody says otherwise in as many words.
+// ---------------------------------------------------------------------------
+/** Headers that are none of a generator's business. */
+const REDACTED = /^(authorization|cookie|set-cookie|proxy-authorization)$/i;
+const SECRETISH = /key|token|secret|password|credential/i;
+const DEFAULT_MAX_BODY = 1024 * 1024;
+export function build(opts) {
+    return createServer((req, res) => {
+        handle(req, res, opts).catch((err) => {
+            // Nothing below is expected to throw; if it does, the client still
+            // gets an answer and the operator still gets the reason.
+            send(res, 500, { error: err instanceof Error ? err.message : String(err) });
+        });
+    });
+}
+export async function listen(opts, host, port) {
+    const server = build(opts);
+    await new Promise((settle, fail) => {
+        server.once('error', fail);
+        server.listen(port, host, () => {
+            server.off('error', fail);
+            settle();
+        });
+    });
+    return {
+        server,
+        port: server.address().port,
+        close: () => new Promise((settle) => {
+            server.close(() => settle());
+            server.closeIdleConnections();
+        }),
+    };
+}
+// ---------------------------------------------------------------------------
+// One request
+// ---------------------------------------------------------------------------
+async function handle(req, res, opts) {
+    const started = Date.now();
+    const url = new URL(req.url ?? '/', 'http://localhost');
+    const method = (req.method ?? 'GET').toLowerCase();
+    // The search string is part of the request: without it a 400 caused by a
+    // query parameter is unexplainable from the log.
+    const say = (status, what) => opts.onRequest?.(`${req.method} ${url.pathname}${url.search} ${status} ${Date.now() - started}ms ${what}`);
+    if (url.pathname.startsWith('/__faker/')) {
+        introspect(url.pathname, res, opts);
+        say(200, 'introspection');
+        return;
+    }
+    const match = opts.router.match(method, url.pathname);
+    if (!match) {
+        const allowed = opts.router.allowed(url.pathname);
+        if (allowed.length > 0) {
+            res.setHeader('allow', allowed.map((m) => m.toUpperCase()).join(', '));
+            send(res, 405, { error: `${req.method} is not defined for ${url.pathname}` });
+            say(405, 'no such method');
+            return;
+        }
+        send(res, 404, { error: `no operation matches ${req.method} ${url.pathname}` });
+        say(404, 'no route');
+        return;
+    }
+    const { operation, pathParams } = match;
+    res.setHeader('x-faker-operation', operation.operationId);
+    let body;
+    try {
+        body = await readBody(req, opts.maxBody ?? DEFAULT_MAX_BODY);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        send(res, message.includes('too large') ? 413 : 400, { error: message });
+        say(400, 'bad body');
+        return;
+    }
+    const problems = check(operation, opts.checks, pathParams, url.searchParams, body);
+    if (problems.length > 0) {
+        send(res, 400, { error: describeIssues(problems), issues: problems });
+        say(400, describeIssues(problems));
+        return;
+    }
+    if (!operation.success.schema) {
+        res.statusCode = operation.success.status;
+        res.end();
+        say(operation.success.status, 'no body declared');
+        return;
+    }
+    let generator;
+    try {
+        generator = await opts.cache.ensure(operation);
+    }
+    catch (err) {
+        const status = err instanceof BuildFailed ? 501 : 500;
+        const detail = reason(err);
+        send(res, status, {
+            error: `no generator for ${operation.operationId}`,
+            detail,
+            diagnostics: err instanceof BuildFailed ? err.diagnostics : undefined,
+        });
+        say(status, `no generator: ${detail}`);
+        return;
+    }
+    res.setHeader('x-faker-cache', generator.cached ? 'hit' : 'miss');
+    const input = {
+        operationId: operation.operationId,
+        method: operation.method,
+        path: operation.path,
+        pathParams,
+        query: Object.fromEntries(url.searchParams),
+        headers: safeHeaders(req),
+        body,
+        seed: seedFor(opts.seed, operation, pathParams, url.searchParams),
+    };
+    const outcome = await opts.box.run(operation.key, input);
+    if (!outcome.ok) {
+        send(res, 502, {
+            error: `the generator for ${operation.operationId} ${outcome.fault}`,
+            stderr: outcome.stderr || undefined,
+        });
+        say(502, 'generator faulted');
+        return;
+    }
+    send(res, operation.success.status, outcome.value);
+    say(operation.success.status, generator.cached ? 'hit' : 'miss');
+}
+function check(operation, checks, pathParams, query, body) {
+    const compiled = checks.for(operation);
+    const out = [];
+    // Coercion rewrites what it is given, so the copies are validated and the
+    // originals are what reach the generator.
+    if (!compiled.path({ ...pathParams })) {
+        out.push(...issues('path', compiled.path.errors));
+    }
+    if (!compiled.query(Object.fromEntries(query))) {
+        out.push(...issues('query', compiled.query.errors));
+    }
+    if (compiled.body) {
+        if (body === undefined) {
+            if (compiled.bodyRequired) {
+                out.push({ where: 'body', message: 'is required' });
+            }
+        }
+        else if (!compiled.body(body)) {
+            out.push(...issues('body', compiled.body.errors));
+        }
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Wire details
+// ---------------------------------------------------------------------------
+async function readBody(req, max) {
+    const claimed = Number(req.headers['content-length'] ?? '');
+    if (Number.isFinite(claimed) && claimed > max) {
+        throw new Error(`the body is too large (${claimed} bytes, limit ${max})`);
+    }
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        size += chunk.length;
+        if (size > max) {
+            req.destroy();
+            throw new Error(`the body is too large (limit ${max} bytes)`);
+        }
+        chunks.push(chunk);
+    }
+    if (size === 0) {
+        return undefined;
+    }
+    const text = Buffer.concat(chunks).toString('utf8');
+    const type = String(req.headers['content-type'] ?? '')
+        .split(';')[0]
+        .trim();
+    if (type && type !== 'application/json' && !type.endsWith('+json')) {
+        return text;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (err) {
+        throw new Error(`the body is not JSON: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/**
+ * Headers reach the generator so it can vary on things like `accept-language`.
+ * Credentials do not: the envelope is written to a file inside a container, and
+ * a mock is exactly what people point a real bearer token at by accident.
+ */
+function safeHeaders(req) {
+    const out = {};
+    for (const [name, value] of Object.entries(req.headers)) {
+        if (value === undefined || REDACTED.test(name) || SECRETISH.test(name)) {
+            continue;
+        }
+        out[name] = Array.isArray(value) ? value.join(', ') : value;
+    }
+    return out;
+}
+/**
+ * Without a base seed every call is a fresh roll, which is what a demo wants.
+ * With one, the seed is a function of the request, so polling the same URL
+ * returns the same body and a test can assert on it.
+ */
+function seedFor(base, operation, pathParams, query) {
+    if (base === undefined) {
+        return randomInt(1, 2 ** 31 - 1);
+    }
+    const shape = JSON.stringify([
+        base,
+        operation.key,
+        Object.entries(pathParams).sort(),
+        [...query.entries()].sort(),
+    ]);
+    return createHash('sha256').update(shape).digest().readUInt32BE(0) % 2 ** 31;
+}
+function introspect(pathname, res, opts) {
+    if (pathname === '/__faker/routes') {
+        send(res, 200, opts.router.operations.map((o) => ({
+            method: o.method.toUpperCase(),
+            path: o.path,
+            operationId: o.operationId,
+            status: o.success.status,
+            body: Boolean(o.success.schema),
+            key: o.key,
+            source: o.source,
+        })));
+        return;
+    }
+    if (pathname === '/__faker/health') {
+        send(res, 200, { ok: true, operations: opts.router.operations.length });
+        return;
+    }
+    send(res, 404, { error: `no such endpoint: ${pathname}` });
+}
+function send(res, status, value) {
+    const text = `${JSON.stringify(value, null, 2)}\n`;
+    res.statusCode = status;
+    res.setHeader('content-type', 'application/json; charset=utf-8');
+    res.setHeader('content-length', Buffer.byteLength(text));
+    res.end(text);
+}
+//# sourceMappingURL=server.js.map

package/dist/setup.d.ts

@@ -0,0 +1,35 @@
+import { type Model } from '@zenera/neo';
+import { Box } from './box.ts';
+import { Cache, type CacheOptions } from './cache.ts';
+import { Router } from './router.ts';
+import { SpecError } from './spec.ts';
+import { Checks } from './validate.ts';
+export interface SetupOptions {
+    specs: readonly string[];
+    cwd: string;
+    /** where generators and the container's workspace live */
+    cache?: string;
+    model?: string;
+    image?: string;
+    attempts?: number;
+    /** how many generators may be written at once */
+    concurrency?: number;
+    rebuild?: boolean;
+    ephemeral?: boolean;
+    timeout?: number;
+    onImageBuild?: (tag: string) => void;
+    events?: Pick<CacheOptions, 'onStart' | 'onAttempt' | 'onReady' | 'onFail'>;
+}
+export interface Setup {
+    router: Router;
+    checks: Checks;
+    cache: Cache;
+    box: Box;
+    model: Model;
+    image: string;
+    root: string;
+    close(): Promise<void>;
+}
+export declare function open(opts: SetupOptions): Promise<Setup>;
+export { SpecError };
+//# sourceMappingURL=setup.d.ts.map

package/dist/setup.js

@@ -0,0 +1,81 @@
+import { mkdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { credentialError, ensureHome, ensurePodmanReady, invalidError, KeyStore, paths, PROVIDERS, SHAPES, } from '@zenera/cli/lib';
+import { createModel } from '@zenera/neo';
+import { Box } from "./box.js";
+import { Cache } from "./cache.js";
+import { ensureImage } from "./image.js";
+import { Router } from "./router.js";
+import { loadSpecs, SpecError } from "./spec.js";
+import { Checks } from "./validate.js";
+// ---------------------------------------------------------------------------
+// Assembly
+//
+// The order here is the whole point and it is the same order `zen run` uses:
+// credentials before anything that needs one, the container engine before the
+// image, the image before the box, and the documents last — so the failure a
+// user sees is the first thing that was actually wrong rather than whatever
+// happened to be checked first.
+// ---------------------------------------------------------------------------
+/**
+ * The model each provider gets when none is named. Every ref names its
+ * provider: the shorthand reads the first segment as a *provider name*, so a
+ * bare `gemini-3.5-flash` would be asked of OpenAI.
+ */
+const DEFAULT_MODEL = {
+    openai: 'openai:gpt-5.4-mini',
+    anthropic: 'anthropic:claude-sonnet-4-5',
+    google: 'google:gemini-3.5-flash',
+    vertex: 'vertex:gemini-3.5-flash',
+    openrouter: 'openrouter:inclusionai/ling-3.0-flash-fin:free',
+};
+export async function open(opts) {
+    if (opts.specs.length === 0) {
+        throw invalidError('no specification given', 'name one or more openapi/swagger files');
+    }
+    // Real environment variables win, exactly as they do for `zen`.
+    ensureHome();
+    const keys = await KeyStore.open();
+    keys.materialize();
+    const model = createModel(opts.model ?? defaultRef(keys));
+    const root = resolve(opts.cwd, opts.cache ?? paths.faker());
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    // Podman is asked about before the image is built, so a machine without a
+    // container engine says so instead of failing halfway through a build.
+    await ensurePodmanReady({ image: opts.image, yes: true });
+    const image = opts.image ?? (await ensureImage({ root, onBuild: opts.onImageBuild }));
+    const operations = await loadSpecs(opts.specs.map((s) => resolve(opts.cwd, s)));
+    if (operations.length === 0) {
+        throw invalidError('the specification declares no operations');
+    }
+    const router = new Router(operations);
+    const checks = new Checks();
+    const box = new Box({ root, image, timeout: opts.timeout });
+    await box.fresh();
+    const cache = new Cache({
+        box,
+        checks,
+        model,
+        attempts: opts.attempts,
+        concurrency: opts.concurrency,
+        rebuild: opts.rebuild,
+        ephemeral: opts.ephemeral,
+        ...opts.events,
+    });
+    return { router, checks, cache, box, model, image, root, close: () => box.dispose() };
+}
+/**
+ * Presence, not liveness. `zen init` probes because it is writing a project
+ * that has to work later; this is about to make a call anyway, and the call
+ * itself is a better test than a round trip that costs the same.
+ */
+function defaultRef(keys) {
+    const provider = PROVIDERS.find((p) => process.env[SHAPES[p].env]) ??
+        PROVIDERS.find((p) => keys.active(p) !== undefined);
+    if (!provider) {
+        throw credentialError('no credentials for any provider', 'add one with: zen key add openai');
+    }
+    return DEFAULT_MODEL[provider];
+}
+export { SpecError };
+//# sourceMappingURL=setup.js.map

package/dist/spec.d.ts

@@ -0,0 +1,41 @@
+import { CliError } from '@zenera/cli/lib';
+import { type Schema } from './schema.ts';
+export declare const METHODS: readonly ["get", "put", "post", "delete", "patch", "head", "options"];
+export type Method = (typeof METHODS)[number];
+export type ParamIn = 'path' | 'query' | 'header' | 'cookie';
+export interface ParamSpec {
+    name: string;
+    in: ParamIn;
+    required: boolean;
+    schema: Schema;
+    description?: string;
+}
+export interface Operation {
+    /** cache identity — a pure function of the operation's shape, see `keyOf` */
+    key: string;
+    /** the document it came from, for error messages */
+    source: string;
+    method: Method;
+    /** the template, `/users/{user_id}` */
+    path: string;
+    operationId: string;
+    summary?: string;
+    description?: string;
+    params: ParamSpec[];
+    requestBody?: {
+        required: boolean;
+        schema: Schema;
+    };
+    /** the response a call is answered with; `schema` absent means no body */
+    success: {
+        status: number;
+        schema?: Schema;
+    };
+}
+/** A `CliError` so an unreadable document exits 3 wherever it is raised. */
+export declare class SpecError extends CliError {
+    constructor(message: string, hint?: string);
+}
+export declare function loadSpecs(files: readonly string[]): Promise<Operation[]>;
+export declare function loadSpec(file: string): Promise<Operation[]>;
+//# sourceMappingURL=spec.d.ts.map

package/dist/spec.js

@@ -0,0 +1,257 @@
+import SwaggerParser from '@apidevtools/swagger-parser';
+import { createHash } from 'node:crypto';
+import { CliError, EXIT } from '@zenera/cli/lib';
+import { normalize } from "./schema.js";
+// ---------------------------------------------------------------------------
+// Documents, flattened
+//
+// Everything below this file works on `Operation`, which is one method on one
+// path with its schemas already dereferenced and already 2020-12. Which
+// document it came from, and which of the three dialects that document was
+// written in, stops mattering here.
+//
+// `dereference` is used rather than `bundle` on purpose: the generator is asked
+// to produce a body for one operation, and it should see that operation's
+// shapes rather than a pointer into a components section it was never shown.
+// ---------------------------------------------------------------------------
+export const METHODS = ['get', 'put', 'post', 'delete', 'patch', 'head', 'options'];
+const isObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+/** A `CliError` so an unreadable document exits 3 wherever it is raised. */
+export class SpecError extends CliError {
+    constructor(message, hint) {
+        super(message, EXIT.invalid, hint);
+        this.name = 'SpecError';
+    }
+}
+// ---------------------------------------------------------------------------
+// Loading
+// ---------------------------------------------------------------------------
+export async function loadSpecs(files) {
+    const out = [];
+    for (const file of files) {
+        out.push(...(await loadSpec(file)));
+    }
+    return out;
+}
+export async function loadSpec(file) {
+    let doc;
+    try {
+        doc = (await SwaggerParser.dereference(file));
+    }
+    catch (err) {
+        throw new SpecError(`${file}: ${err instanceof Error ? err.message.split('\n')[0] : String(err)}`, 'the document must be a readable OpenAPI 3.x or Swagger 2.0 file');
+    }
+    const dialect = dialectOf(doc);
+    const prefix = dialect === 'swagger-2.0' ? (doc.basePath ?? '') : '';
+    const out = [];
+    for (const [template, item] of Object.entries(doc.paths ?? {})) {
+        if (!isObject(item)) {
+            continue;
+        }
+        // Path-level parameters apply to every method on it, and an operation
+        // may override one by repeating its name and location.
+        const shared = params(item.parameters, dialect);
+        for (const method of METHODS) {
+            const op = item[method];
+            if (!isObject(op)) {
+                continue;
+            }
+            const path = join(prefix, template);
+            const merged = override(shared, params(op.parameters, dialect));
+            out.push(build({
+                source: file,
+                dialect,
+                method,
+                path,
+                op,
+                params: merged,
+                body: requestBody(op, dialect),
+            }));
+        }
+    }
+    return out;
+}
+function dialectOf(doc) {
+    if (doc.swagger?.startsWith('2.')) {
+        return 'swagger-2.0';
+    }
+    if (doc.openapi?.startsWith('3.1')) {
+        return 'openapi-3.1';
+    }
+    if (doc.openapi?.startsWith('3.')) {
+        return 'openapi-3.0';
+    }
+    throw new SpecError('neither `swagger: 2.0` nor `openapi: 3.x` is declared');
+}
+function join(prefix, template) {
+    const base = prefix.replace(/\/+$/, '');
+    return `${base}${template.startsWith('/') ? '' : '/'}${template}` || '/';
+}
+function build(b) {
+    const success = successOf(b.op, b.dialect);
+    const operationId = typeof b.op.operationId === 'string' && b.op.operationId
+        ? b.op.operationId
+        : synthesizeId(b.method, b.path);
+    const operation = {
+        key: '',
+        source: b.source,
+        method: b.method,
+        path: b.path,
+        operationId,
+        summary: typeof b.op.summary === 'string' ? b.op.summary : undefined,
+        description: typeof b.op.description === 'string' ? b.op.description : undefined,
+        params: b.params,
+        requestBody: b.body,
+        success,
+    };
+    return { ...operation, key: keyOf(operation) };
+}
+/**
+ * Cache identity. Everything that changes what a generator must produce is in
+ * here and nothing else is — not the file it came from, not its summary, not
+ * the order of its keys. Editing a spec therefore yields a new key and the old
+ * artefact is simply never looked up again, so there is no invalidation step
+ * to get wrong.
+ */
+function keyOf(op) {
+    const shape = {
+        method: op.method,
+        path: op.path,
+        operationId: op.operationId,
+        params: [...op.params]
+            .sort((a, b) => `${a.in}:${a.name}`.localeCompare(`${b.in}:${b.name}`))
+            .map((p) => [p.in, p.name, p.required, canonical(p.schema)]),
+        body: op.requestBody ? [op.requestBody.required, canonical(op.requestBody.schema)] : null,
+        success: [op.success.status, op.success.schema ? canonical(op.success.schema) : null],
+    };
+    return createHash('sha256').update(JSON.stringify(shape)).digest('hex').slice(0, 16);
+}
+/** Key order is a formatting accident; it must not change a cache key. */
+function canonical(value) {
+    if (Array.isArray(value)) {
+        return value.map(canonical);
+    }
+    if (isObject(value)) {
+        return Object.keys(value)
+            .sort()
+            .map((k) => [k, canonical(value[k])]);
+    }
+    return value;
+}
+function synthesizeId(method, path) {
+    const words = path
+        .split('/')
+        .filter(Boolean)
+        .map((s) => s.replace(/[{}]/g, '').replace(/[^A-Za-z0-9]+/g, '_'));
+    return [method, ...words].join('_');
+}
+// ---------------------------------------------------------------------------
+// Parameters
+// ---------------------------------------------------------------------------
+function params(raw, dialect) {
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    const out = [];
+    for (const entry of raw) {
+        if (!isObject(entry) || typeof entry.name !== 'string') {
+            continue;
+        }
+        const where = entry.in;
+        if (where !== 'path' && where !== 'query' && where !== 'header' && where !== 'cookie') {
+            continue; // `body` and `formData` are handled as a request body
+        }
+        out.push({
+            name: entry.name,
+            in: where,
+            required: where === 'path' ? true : entry.required === true,
+            schema: normalize(paramSchema(entry, dialect), dialect),
+            description: typeof entry.description === 'string' ? entry.description : undefined,
+        });
+    }
+    return out;
+}
+/**
+ * Swagger 2.0 puts a non-body parameter's type keywords directly on the
+ * parameter object; OpenAPI 3 moved them under `schema`. Both end up as a
+ * schema, so the difference is confined to this function.
+ */
+function paramSchema(entry, dialect) {
+    if (dialect !== 'swagger-2.0') {
+        return isObject(entry.schema) ? entry.schema : {};
+    }
+    const { name: _name, in: _in, required: _required, description: _description, collectionFormat: _collectionFormat, allowEmptyValue: _allowEmptyValue, ...rest } = entry;
+    return rest;
+}
+/** Operation-level parameters win over path-level ones with the same identity. */
+function override(base, own) {
+    const merged = new Map(base.map((p) => [`${p.in}:${p.name}`, p]));
+    for (const p of own) {
+        merged.set(`${p.in}:${p.name}`, p);
+    }
+    return [...merged.values()];
+}
+function requestBody(op, dialect) {
+    if (dialect === 'swagger-2.0') {
+        const list = Array.isArray(op.parameters) ? op.parameters : [];
+        const body = list.find((p) => isObject(p) && p.in === 'body');
+        if (!body || !isObject(body.schema)) {
+            return undefined;
+        }
+        return { required: body.required === true, schema: normalize(body.schema, dialect) };
+    }
+    const rb = op.requestBody;
+    if (!isObject(rb)) {
+        return undefined;
+    }
+    const schema = jsonContent(rb.content);
+    return schema
+        ? { required: rb.required === true, schema: normalize(schema, dialect) }
+        : undefined;
+}
+// ---------------------------------------------------------------------------
+// Responses
+// ---------------------------------------------------------------------------
+/**
+ * The response a call gets answered with: the lowest 2xx that carries a JSON
+ * body, or the lowest 2xx at all when none of them do. An operation whose
+ * success response has no JSON schema is answered `204` and never gets a
+ * generator — there is nothing for one to produce.
+ */
+function successOf(op, dialect) {
+    const responses = isObject(op.responses) ? op.responses : {};
+    const codes = Object.keys(responses)
+        .map(Number)
+        .filter((n) => Number.isInteger(n) && n >= 200 && n < 300)
+        .sort((a, b) => a - b);
+    for (const status of codes) {
+        const schema = responseSchema(responses[String(status)], dialect);
+        if (schema) {
+            return { status, schema: normalize(schema, dialect) };
+        }
+    }
+    return { status: codes[0] ?? 204 };
+}
+function responseSchema(response, dialect) {
+    if (!isObject(response)) {
+        return undefined;
+    }
+    if (dialect === 'swagger-2.0') {
+        return isObject(response.schema) ? response.schema : undefined;
+    }
+    return jsonContent(response.content);
+}
+/** The first JSON media type a content map offers, `+json` suffixes included. */
+function jsonContent(content) {
+    if (!isObject(content)) {
+        return undefined;
+    }
+    for (const [type, entry] of Object.entries(content)) {
+        const base = type.split(';')[0].trim();
+        if ((base === 'application/json' || base.endsWith('+json')) && isObject(entry)) {
+            return isObject(entry.schema) ? entry.schema : undefined;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=spec.js.map

package/dist/validate.d.ts

@@ -0,0 +1,21 @@
+import { type ErrorObject, type ValidateFunction } from 'ajv/dist/2020.js';
+import type { Operation } from './spec.ts';
+export interface Issue {
+    where: string;
+    message: string;
+}
+export declare class Checks {
+    #private;
+    constructor();
+    for(operation: Operation): Compiled;
+}
+export interface Compiled {
+    path: ValidateFunction;
+    query: ValidateFunction;
+    body?: ValidateFunction;
+    bodyRequired: boolean;
+    response?: ValidateFunction;
+}
+export declare function issues(prefix: string, errors: ErrorObject[] | null | undefined): Issue[];
+export declare function describeIssues(list: readonly Issue[]): string;
+//# sourceMappingURL=validate.d.ts.map