express-fast-json-stringify 1.2.8 → 1.3.0

package/build/main/lib/openapi.d.ts

@@ -0,0 +1,87 @@
+import type { NextFunction, Request, Response } from 'express';
+import { type Options } from 'fast-json-stringify';
+import { type OverrideErrorHandler } from './override';
+/**
+ * The parts of an OpenAPI 3.x or Swagger 2.0 document this package reads.
+ *
+ * It is deliberately a plain document rather than an integration with a
+ * specific library: every popular Express toolchain either consumes or produces
+ * one of these, so `swagger-jsdoc`, `swagger-ui-express`, `tsoa`,
+ * `express-openapi-validator` and a hand written file all work unchanged.
+ */
+export type OpenApiDocument = {
+    readonly openapi?: string;
+    readonly swagger?: string;
+    readonly paths?: Readonly<Record<string, unknown>>;
+    readonly components?: Readonly<Record<string, unknown>>;
+    readonly definitions?: Readonly<Record<string, unknown>>;
+};
+export type OpenApiOptions = Omit<Options, 'mode'> & {
+    /** Media type to read the schema from. Defaults to `application/json`. */
+    readonly contentType?: string;
+    /** Pin the OpenAPI path instead of deriving it from the matched route. */
+    readonly path?: string;
+    /** Pin the OpenAPI method instead of using the request method. */
+    readonly method?: string;
+    /**
+     * Throw when the document describes no schema for a response, instead of
+     * quietly falling back to `res.json()`. Only applies to explicit
+     * `res.fastJson()` calls — an overridden `res.json()` always falls back.
+     */
+    readonly strict?: boolean;
+    /**
+     * Also route `res.json()` — and therefore `res.send(object)`, which Express
+     * implements on top of it — through the compiled serializer whenever the
+     * document describes the response.
+     *
+     * Off by default. Turning it on lets an existing codebase benefit without
+     * rewriting a single call site: responses the document covers are serialized
+     * from the schema, everything else keeps the stock behavior.
+     */
+    readonly overrideJson?: boolean;
+    /**
+     * Called when an overridden `res.json()` could not use the fast path because
+     * the serializer threw. The response falls back to the stock `res.json()`
+     * either way; this is only so the mismatch is visible.
+     */
+    readonly onError?: OverrideErrorHandler;
+};
+/**
+ * Translate an Express route pattern into the OpenAPI equivalent:
+ * `/users/:id` becomes `/users/{id}`. Express parameter modifiers — a trailing
+ * `?` or an inline `(regex)` — are dropped, since OpenAPI has no notion of them.
+ */
+export declare const toOpenApiPath: (path: string) => string;
+/**
+ * Build a stringify middleware that takes its schemas from an OpenAPI or Swagger
+ * document, so the contract you already publish is the one used to serialize.
+ *
+ * The operation is resolved per request from the matched Express route, and the
+ * schema from the response status code, which means `res.status(201).fastJson()`
+ * serializes with the `201` schema. Routes the document does not describe fall
+ * back to `res.json()` unless `strict` is set.
+ *
+ * @param {OpenApiDocument} document The OpenAPI 3.x or Swagger 2.0 document
+ * @param {OpenApiOptions} options The options to use (optional)
+ *
+ * Examples:
+ * ```ts
+ * import express from 'express';
+ * import swaggerJsdoc from 'swagger-jsdoc';
+ * import { fastJsonOpenApi } from 'express-fast-json-stringify';
+ *
+ * const app = express();
+ * const document = swaggerJsdoc({ definition: { openapi: '3.1.0', info: { title: 'API', version: '1.0.0' } }, apis: ['./routes/*.ts'] });
+ *
+ * app.use(fastJsonOpenApi(document));
+ *
+ * app.get('/users/:id', (req, res, next) => {
+ *   try {
+ *     res.fastJson({ id: Number(req.params.id), firstName: 'Simone' });
+ *   } catch (error) {
+ *     next(error);
+ *   }
+ * });
+ * ```
+ */
+export declare const fastJsonOpenApi: (document: OpenApiDocument, options?: OpenApiOptions) => (req: Request, res: Response, next: NextFunction) => void;

package/build/main/lib/openapi.js

@@ -0,0 +1,166 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fastJsonOpenApi = exports.toOpenApiPath = void 0;
+const fast_json_stringify_1 = __importDefault(require("fast-json-stringify"));
+const override_1 = require("./override");
+const send_1 = require("./send");
+/**
+ * Translate an Express route pattern into the OpenAPI equivalent:
+ * `/users/:id` becomes `/users/{id}`. Express parameter modifiers — a trailing
+ * `?` or an inline `(regex)` — are dropped, since OpenAPI has no notion of them.
+ */
+const toOpenApiPath = (path) => path.replace(/:([A-Za-z0-9_]+)(\([^)]*\))?\??/g, '{$1}');
+exports.toOpenApiPath = toOpenApiPath;
+/**
+ * Express answers a HEAD request with the GET handler, and documents rarely
+ * describe a `head` operation, so fall back to `get`.
+ */
+const methodCandidates = (method) => (method === 'head' ? ['head', 'get'] : [method]);
+/**
+ * Response keys to try, most specific first. OpenAPI allows a wildcard range
+ * (`2XX`) and a catch all (`default`) next to explicit codes.
+ */
+const statusCandidates = (status) => {
+    const range = Math.floor(status / 100);
+    return [String(status), `${range}XX`, `${range}xx`, 'default'];
+};
+const findResponseSchema = (document, path, method, status, contentType) => {
+    var _a, _b, _c, _d;
+    const operations = (_a = document.paths) === null || _a === void 0 ? void 0 : _a[path];
+    if (!operations) {
+        return undefined;
+    }
+    for (const candidate of methodCandidates(method)) {
+        const operation = operations[candidate];
+        const responses = operation === null || operation === void 0 ? void 0 : operation.responses;
+        if (!responses) {
+            continue;
+        }
+        for (const key of statusCandidates(status)) {
+            const response = responses[key];
+            if (!response) {
+                continue;
+            }
+            // OpenAPI 3.x keys the schema by media type; Swagger 2.0 does not.
+            const schema = (_d = (_c = (_b = response.content) === null || _b === void 0 ? void 0 : _b[contentType]) === null || _c === void 0 ? void 0 : _c.schema) !== null && _d !== void 0 ? _d : response.schema;
+            if (schema) {
+                return schema;
+            }
+        }
+    }
+    return undefined;
+};
+/**
+ * fast-json-stringify resolves `$ref` as a JSON pointer against the root of the
+ * schema it is given, so the document's shared schemas only have to be reachable
+ * under the key the references already use — `components` for OpenAPI 3.x,
+ * `definitions` for Swagger 2.0. No rewriting needed, and recursive references
+ * keep working.
+ */
+const withSharedSchemas = (document, schema) => {
+    const result = Object.assign({}, schema);
+    if (document.components && result.components === undefined) {
+        result.components = document.components;
+    }
+    if (document.definitions && result.definitions === undefined) {
+        result.definitions = document.definitions;
+    }
+    return result;
+};
+/**
+ * Build a stringify middleware that takes its schemas from an OpenAPI or Swagger
+ * document, so the contract you already publish is the one used to serialize.
+ *
+ * The operation is resolved per request from the matched Express route, and the
+ * schema from the response status code, which means `res.status(201).fastJson()`
+ * serializes with the `201` schema. Routes the document does not describe fall
+ * back to `res.json()` unless `strict` is set.
+ *
+ * @param {OpenApiDocument} document The OpenAPI 3.x or Swagger 2.0 document
+ * @param {OpenApiOptions} options The options to use (optional)
+ *
+ * Examples:
+ * ```ts
+ * import express from 'express';
+ * import swaggerJsdoc from 'swagger-jsdoc';
+ * import { fastJsonOpenApi } from 'express-fast-json-stringify';
+ *
+ * const app = express();
+ * const document = swaggerJsdoc({ definition: { openapi: '3.1.0', info: { title: 'API', version: '1.0.0' } }, apis: ['./routes/*.ts'] });
+ *
+ * app.use(fastJsonOpenApi(document));
+ *
+ * app.get('/users/:id', (req, res, next) => {
+ *   try {
+ *     res.fastJson({ id: Number(req.params.id), firstName: 'Simone' });
+ *   } catch (error) {
+ *     next(error);
+ *   }
+ * });
+ * ```
+ */
+const fastJsonOpenApi = (document, options = {}) => {
+    if (!document || typeof document !== 'object' || typeof document.paths !== 'object' || document.paths === null) {
+        throw new TypeError(`express-fast-json-stringify: invalid OpenAPI document`);
+    }
+    const { contentType = 'application/json', path: pinnedPath, method: pinnedMethod, strict = false, overrideJson = false, onError } = options, fastJsonOptions = __rest(options, ["contentType", "path", "method", "strict", "overrideJson", "onError"]);
+    // One compiled serializer per operation and status code. Misses are cached as
+    // `null` so an undocumented route costs a single lookup.
+    const serializers = new Map();
+    const routePath = (req) => { var _a, _b; return pinnedPath !== null && pinnedPath !== void 0 ? pinnedPath : (0, exports.toOpenApiPath)(`${req.baseUrl}${(_b = (_a = req.route) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : req.path}`); };
+    const serializerFor = (req, status) => {
+        const path = routePath(req);
+        const method = (pinnedMethod !== null && pinnedMethod !== void 0 ? pinnedMethod : req.method).toLowerCase();
+        const key = `${method} ${path} ${status}`;
+        const cached = serializers.get(key);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const schema = findResponseSchema(document, path, method, status, contentType);
+        const serializer = schema ? (0, fast_json_stringify_1.default)(withSharedSchemas(document, schema), fastJsonOptions) : null;
+        serializers.set(key, serializer);
+        return serializer;
+    };
+    return (req, res, next) => {
+        /**
+         * Send JSON response, serialized with the schema the document declares for
+         * this route and status code.
+         *
+         * Examples:
+         * ```ts
+         * res.fastJson({ user: 'Simone Nigro' });
+         * res.status(201).fastJson({ user: 'Simone Nigro' });
+         * ```
+         */
+        res.fastJson = (body) => {
+            const serializer = serializerFor(req, res.statusCode);
+            if (!serializer) {
+                if (strict) {
+                    throw new Error(`express-fast-json-stringify: no ${contentType} schema for ${req.method} ${routePath(req)} with status ${res.statusCode}`);
+                }
+                return res.json(body);
+            }
+            return (0, send_1.sendJson)(req, res, serializer(body));
+        };
+        if (overrideJson) {
+            (0, override_1.overrideResJson)(req, res, (status) => serializerFor(req, status), onError);
+        }
+        next();
+    };
+};
+exports.fastJsonOpenApi = fastJsonOpenApi;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3BlbmFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvb3BlbmFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUNBLDhFQUEwRTtBQUUxRSx5Q0FBd0U7QUFDeEUsaUNBQWtDO0FBaURsQzs7OztHQUlHO0FBQ0ksTUFBTSxhQUFhLEdBQUcsQ0FBQyxJQUFZLEVBQVUsRUFBRSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsa0NBQWtDLEVBQUUsTUFBTSxDQUFDLENBQUM7QUFBbkcsUUFBQSxhQUFhLGlCQUFzRjtBQUVoSDs7O0dBR0c7QUFDSCxNQUFNLGdCQUFnQixHQUFHLENBQUMsTUFBYyxFQUFxQixFQUFFLENBQUMsQ0FBQyxNQUFNLEtBQUssTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLE1BQU0sRUFBRSxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDO0FBRWpIOzs7R0FHRztBQUNILE1BQU0sZ0JBQWdCLEdBQUcsQ0FBQyxNQUFjLEVBQXFCLEVBQUU7SUFDN0QsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLEdBQUcsR0FBRyxDQUFDLENBQUM7SUFDdkMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFBRSxHQUFHLEtBQUssSUFBSSxFQUFFLEdBQUcsS0FBSyxJQUFJLEVBQUUsU0FBUyxDQUFDLENBQUM7QUFDakUsQ0FBQyxDQUFDO0FBUUYsTUFBTSxrQkFBa0IsR0FBRyxDQUFDLFFBQXlCLEVBQUUsSUFBWSxFQUFFLE1BQWMsRUFBRSxNQUFjLEVBQUUsV0FBbUIsRUFBVyxFQUFFOztJQUNuSSxNQUFNLFVBQVUsR0FBRyxNQUFBLFFBQVEsQ0FBQyxLQUFLLDBDQUFHLElBQUksQ0FBa0QsQ0FBQztJQUMzRixJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7UUFDaEIsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQztJQUVELEtBQUssTUFBTSxTQUFTLElBQUksZ0JBQWdCLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztRQUNqRCxNQUFNLFNBQVMsR0FBRyxVQUFVLENBQUMsU0FBUyxDQUE4RixDQUFDO1FBQ3JJLE1BQU0sU0FBUyxHQUFHLFNBQVMsYUFBVCxTQUFTLHVCQUFULFNBQVMsQ0FBRSxTQUFTLENBQUM7UUFDdkMsSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ2YsU0FBUztRQUNYLENBQUM7UUFDRCxLQUFLLE1BQU0sR0FBRyxJQUFJLGdCQUFnQixDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUM7WUFDM0MsTUFBTSxRQUFRLEdBQUcsU0FBUyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQ2hDLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztnQkFDZCxTQUFTO1lBQ1gsQ0FBQztZQUNELG1FQUFtRTtZQUNuRSxNQUFNLE1BQU0sR0FBRyxNQUFBLE1BQUEsTUFBQSxRQUFRLENBQUMsT0FBTywwQ0FBRyxXQUFXLENBQUMsMENBQUUsTUFBTSxtQ0FBSSxRQUFRLENBQUMsTUFBTSxDQUFDO1lBQzFFLElBQUksTUFBTSxFQUFFLENBQUM7Z0JBQ1gsT0FBTyxNQUFNLENBQUM7WUFDaEIsQ0FBQztRQUNILENBQUM7SUFDSCxDQUFDO0lBQ0QsT0FBTyxTQUFTLENBQUM7QUFDbkIsQ0FBQyxDQUFDO0FBRUY7Ozs7OztHQU1HO0FBQ0gsTUFBTSxpQkFBaUIsR0FBRyxDQUFDLFFBQXlCLEVBQUUsTUFBZSxFQUFVLEVBQUU7SUFDL0UsTUFBTSxNQUFNLHFCQUFTLE1BQTRDLENBQUUsQ0FBQztJQUNwRSxJQUFJLFFBQVEsQ0FBQyxVQUFVLElBQUksTUFBTSxDQUFDLFVBQVUsS0FBSyxTQUFTLEVBQUUsQ0FBQztRQUMzRCxNQUFNLENBQUMsVUFBVSxHQUFHLFFBQVEsQ0FBQyxVQUFVLENBQUM7SUFDMUMsQ0FBQztJQUNELElBQUksUUFBUSxDQUFDLFdBQVcsSUFBSSxNQUFNLENBQUMsV0FBVyxLQUFLLFNBQVMsRUFBRSxDQUFDO1FBQzdELE1BQU0sQ0FBQyxXQUFXLEdBQUcsUUFBUSxDQUFDLFdBQVcsQ0FBQztJQUM1QyxDQUFDO0lBQ0QsT0FBTyxNQUEyQixDQUFDO0FBQ3JDLENBQUMsQ0FBQztBQUVGOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBK0JHO0FBQ0ksTUFBTSxlQUFlLEdBQUcsQ0FBQyxRQUF5QixFQUFFLFVBQTBCLEVBQUUsRUFBRSxFQUFFO0lBQ3pGLElBQUksQ0FBQyxRQUFRLElBQUksT0FBTyxRQUFRLEtBQUssUUFBUSxJQUFJLE9BQU8sUUFBUSxDQUFDLEtBQUssS0FBSyxRQUFRLElBQUksUUFBUSxDQUFDLEtBQUssS0FBSyxJQUFJLEVBQUUsQ0FBQztRQUMvRyxNQUFNLElBQUksU0FBUyxDQUFDLHVEQUF1RCxDQUFDLENBQUM7SUFDL0UsQ0FBQztJQUVELE1BQU0sRUFBRSxXQUFXLEdBQUcsa0JBQWtCLEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsWUFBWSxFQUFFLE1BQU0sR0FBRyxLQUFLLEVBQUUsWUFBWSxHQUFHLEtBQUssRUFBRSxPQUFPLEtBQXlCLE9BQU8sRUFBM0IsZUFBZSxVQUFLLE9BQU8sRUFBekosc0VBQStJLENBQVUsQ0FBQztJQUVoSyw4RUFBOEU7SUFDOUUseURBQXlEO0lBQ3pELE1BQU0sV0FBVyxHQUFHLElBQUksR0FBRyxFQUEwQyxDQUFDO0lBRXRFLE1BQU0sU0FBUyxHQUFHLENBQUMsR0FBWSxFQUFVLEVBQUUsZUFBQyxPQUFBLFVBQVUsYUFBVixVQUFVLGNBQVYsVUFBVSxHQUFJLElBQUEscUJBQWEsRUFBQyxHQUFHLEdBQUcsQ0FBQyxPQUFPLEdBQUcsTUFBQSxNQUFBLEdBQUcsQ0FBQyxLQUFLLDBDQUFFLElBQUksbUNBQUksR0FBRyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUEsRUFBQSxDQUFDO0lBRXhILE1BQU0sYUFBYSxHQUFHLENBQUMsR0FBWSxFQUFFLE1BQWMsRUFBa0MsRUFBRTtRQUNyRixNQUFNLElBQUksR0FBRyxTQUFTLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDNUIsTUFBTSxNQUFNLEdBQUcsQ0FBQyxZQUFZLGFBQVosWUFBWSxjQUFaLFlBQVksR0FBSSxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUMsV0FBVyxFQUFFLENBQUM7UUFDMUQsTUFBTSxHQUFHLEdBQUcsR0FBRyxNQUFNLElBQUksSUFBSSxJQUFJLE1BQU0sRUFBRSxDQUFDO1FBRTFDLE1BQU0sTUFBTSxHQUFHLFdBQVcsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDcEMsSUFBSSxNQUFNLEtBQUssU0FBUyxFQUFFLENBQUM7WUFDekIsT0FBTyxNQUFNLENBQUM7UUFDaEIsQ0FBQztRQUVELE1BQU0sTUFBTSxHQUFHLGtCQUFrQixDQUFDLFFBQVEsRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxXQUFXLENBQUMsQ0FBQztRQUMvRSxNQUFNLFVBQVUsR0FBRyxNQUFNLENBQUMsQ0FBQyxDQUFDLElBQUEsNkJBQVEsRUFBQyxpQkFBaUIsQ0FBQyxRQUFRLEVBQUUsTUFBTSxDQUFDLEVBQUUsZUFBZSxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQztRQUNsRyxXQUFXLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUNqQyxPQUFPLFVBQVUsQ0FBQztJQUNwQixDQUFDLENBQUM7SUFFRixPQUFPLENBQUMsR0FBWSxFQUFFLEdBQWEsRUFBRSxJQUFrQixFQUFFLEVBQUU7UUFDekQ7Ozs7Ozs7OztXQVNHO1FBQ0gsR0FBRyxDQUFDLFFBQVEsR0FBRyxDQUFDLElBQVMsRUFBWSxFQUFFO1lBQ3JDLE1BQU0sVUFBVSxHQUFHLGFBQWEsQ0FBQyxHQUFHLEVBQUUsR0FBRyxDQUFDLFVBQVUsQ0FBQyxDQUFDO1lBQ3RELElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztnQkFDaEIsSUFBSSxNQUFNLEVBQUUsQ0FBQztvQkFDWCxNQUFNLElBQUksS0FBSyxDQUFDLG1DQUFtQyxXQUFXLGVBQWUsR0FBRyxDQUFDLE1BQU0sSUFBSSxTQUFTLENBQUMsR0FBRyxDQUFDLGdCQUFnQixHQUFHLENBQUMsVUFBVSxFQUFFLENBQUMsQ0FBQztnQkFDN0ksQ0FBQztnQkFDRCxPQUFPLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDeEIsQ0FBQztZQUNELE9BQU8sSUFBQSxlQUFRLEVBQUMsR0FBRyxFQUFFLEdBQUcsRUFBRSxVQUFVLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztRQUM5QyxDQUFDLENBQUM7UUFFRixJQUFJLFlBQVksRUFBRSxDQUFDO1lBQ2pCLElBQUEsMEJBQWUsRUFBQyxHQUFHLEVBQUUsR0FBRyxFQUFFLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQyxhQUFhLENBQUMsR0FBRyxFQUFFLE1BQU0sQ0FBQyxFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQzdFLENBQUM7UUFFRCxJQUFJLEVBQUUsQ0FBQztJQUNULENBQUMsQ0FBQztBQUNKLENBQUMsQ0FBQztBQXpEVyxRQUFBLGVBQWUsbUJBeUQxQiJ9

package/build/main/lib/override.d.ts

@@ -0,0 +1,17 @@
+import type { Request, Response } from 'express';
+/** Resolves the serializer to use for a response status, or `null` for none. */
+export type SerializerResolver = (status: number) => ((body: any) => string) | null;
+/** Notified when an overridden `res.json()` could not use the fast path. */
+export type OverrideErrorHandler = (error: unknown, req: Request) => void;
+/**
+ * Route `res.json()` through a compiled serializer when one is available.
+ *
+ * Only `res.json` is replaced: Express implements `res.send(object)` by calling
+ * `res.json(object)`, so both entry points are covered by the single hook.
+ *
+ * The override is deliberately incapable of breaking a route. Whenever the fast
+ * path does not apply — no schema for this response, custom JSON settings, or a
+ * serializer that throws on the given body — the original `res.json()` runs and
+ * the response is exactly what it was before.
+ */
+export declare const overrideResJson: (req: Request, res: Response, resolve: SerializerResolver, onError?: OverrideErrorHandler) => void;

package/build/main/lib/override.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overrideResJson = void 0;
+const send_1 = require("./send");
+/**
+ * Settings that change the bytes `res.json()` writes. A compiled serializer
+ * cannot reproduce any of them, so the fast path has to step aside when one is
+ * configured rather than silently change the output.
+ */
+const hasCustomJsonSettings = (res) => {
+    var _a, _b;
+    const app = res.app;
+    if (!app) {
+        return false;
+    }
+    return Boolean((_b = (_a = app.get('json replacer')) !== null && _a !== void 0 ? _a : app.get('json spaces')) !== null && _b !== void 0 ? _b : app.get('json escape'));
+};
+/**
+ * Route `res.json()` through a compiled serializer when one is available.
+ *
+ * Only `res.json` is replaced: Express implements `res.send(object)` by calling
+ * `res.json(object)`, so both entry points are covered by the single hook.
+ *
+ * The override is deliberately incapable of breaking a route. Whenever the fast
+ * path does not apply — no schema for this response, custom JSON settings, or a
+ * serializer that throws on the given body — the original `res.json()` runs and
+ * the response is exactly what it was before.
+ */
+const overrideResJson = (req, res, resolve, onError) => {
+    const original = res.json.bind(res);
+    res.json = (body) => {
+        if (!hasCustomJsonSettings(res)) {
+            const serialize = resolve(res.statusCode);
+            if (serialize) {
+                try {
+                    return (0, send_1.sendJson)(req, res, serialize(body));
+                }
+                catch (error) {
+                    // A body that does not fit the schema must not turn into a failed
+                    // request: report it, then fall through to the stock res.json().
+                    onError === null || onError === void 0 ? void 0 : onError(error, req);
+                }
+            }
+        }
+        return original(body);
+    };
+};
+exports.overrideResJson = overrideResJson;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcnJpZGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL292ZXJyaWRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUVBLGlDQUFrQztBQVFsQzs7OztHQUlHO0FBQ0gsTUFBTSxxQkFBcUIsR0FBRyxDQUFDLEdBQWEsRUFBVyxFQUFFOztJQUN2RCxNQUFNLEdBQUcsR0FBRyxHQUFHLENBQUMsR0FBRyxDQUFDO0lBQ3BCLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUNULE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztJQUNELE9BQU8sT0FBTyxDQUFDLE1BQUEsTUFBQSxHQUFHLENBQUMsR0FBRyxDQUFDLGVBQWUsQ0FBQyxtQ0FBSSxHQUFHLENBQUMsR0FBRyxDQUFDLGFBQWEsQ0FBQyxtQ0FBSSxHQUFHLENBQUMsR0FBRyxDQUFDLGFBQWEsQ0FBQyxDQUFDLENBQUM7QUFDL0YsQ0FBQyxDQUFDO0FBRUY7Ozs7Ozs7Ozs7R0FVRztBQUNJLE1BQU0sZUFBZSxHQUFHLENBQUMsR0FBWSxFQUFFLEdBQWEsRUFBRSxPQUEyQixFQUFFLE9BQThCLEVBQVEsRUFBRTtJQUNoSSxNQUFNLFFBQVEsR0FBRyxHQUFHLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUVwQyxHQUFHLENBQUMsSUFBSSxHQUFHLENBQUMsSUFBUyxFQUFZLEVBQUU7UUFDakMsSUFBSSxDQUFDLHFCQUFxQixDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDaEMsTUFBTSxTQUFTLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsQ0FBQztZQUMxQyxJQUFJLFNBQVMsRUFBRSxDQUFDO2dCQUNkLElBQUksQ0FBQztvQkFDSCxPQUFPLElBQUEsZUFBUSxFQUFDLEdBQUcsRUFBRSxHQUFHLEVBQUUsU0FBUyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7Z0JBQzdDLENBQUM7Z0JBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztvQkFDZixrRUFBa0U7b0JBQ2xFLGlFQUFpRTtvQkFDakUsT0FBTyxhQUFQLE9BQU8sdUJBQVAsT0FBTyxDQUFHLEtBQUssRUFBRSxHQUFHLENBQUMsQ0FBQztnQkFDeEIsQ0FBQztZQUNILENBQUM7UUFDSCxDQUFDO1FBQ0QsT0FBTyxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDeEIsQ0FBQyxDQUFDO0FBQ0osQ0FBQyxDQUFDO0FBbEJXLFFBQUEsZUFBZSxtQkFrQjFCIn0=

package/build/main/lib/send.d.ts

@@ -0,0 +1,10 @@
+import type { Request, Response } from 'express';
+/**
+ * Write an already serialized JSON payload with the same HTTP semantics as
+ * `res.json()`: charset, `Content-Length`, `ETag`, conditional requests and the
+ * empty body rules for `204`/`304`.
+ *
+ * Every middleware in this package goes through here, so they cannot drift
+ * apart from each other or from Express.
+ */
+export declare const sendJson: (req: Request, res: Response, serialized: string) => Response;

package/build/main/lib/send.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendJson = void 0;
+/**
+ * Write an already serialized JSON payload with the same HTTP semantics as
+ * `res.json()`: charset, `Content-Length`, `ETag`, conditional requests and the
+ * empty body rules for `204`/`304`.
+ *
+ * Every middleware in this package goes through here, so they cannot drift
+ * apart from each other or from Express.
+ */
+const sendJson = (req, res, serialized) => {
+    var _a;
+    let payload = serialized;
+    // Do not clobber a content type the route set on purpose (eg. res.type('application/vnd.api+json')).
+    if (!res.getHeader('Content-Type')) {
+        res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    }
+    // Mirror res.send(): honour the app `etag` setting so that swapping
+    // res.json() for res.fastJson() keeps conditional requests working.
+    const etagFn = (_a = res.app) === null || _a === void 0 ? void 0 : _a.get('etag fn');
+    if (typeof etagFn === 'function' && !res.getHeader('ETag')) {
+        const etag = etagFn(payload, 'utf-8');
+        if (etag) {
+            res.setHeader('ETag', etag);
+        }
+    }
+    if (req.fresh) {
+        res.statusCode = 304;
+    }
+    // 204 No Content and 304 Not Modified must not carry a body, nor describe one.
+    if (res.statusCode === 204 || res.statusCode === 304) {
+        res.removeHeader('Content-Type');
+        res.removeHeader('Content-Length');
+        res.removeHeader('Transfer-Encoding');
+        payload = '';
+    }
+    else {
+        // Without this the response falls back to chunked encoding, and HEAD
+        // requests answer with no length at all.
+        res.setHeader('Content-Length', Buffer.byteLength(payload));
+    }
+    return res.end(payload);
+};
+exports.sendJson = sendJson;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VuZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvc2VuZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFQTs7Ozs7OztHQU9HO0FBQ0ksTUFBTSxRQUFRLEdBQUcsQ0FBQyxHQUFZLEVBQUUsR0FBYSxFQUFFLFVBQWtCLEVBQVksRUFBRTs7SUFDcEYsSUFBSSxPQUFPLEdBQUcsVUFBVSxDQUFDO0lBRXpCLHFHQUFxRztJQUNyRyxJQUFJLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxjQUFjLENBQUMsRUFBRSxDQUFDO1FBQ25DLEdBQUcsQ0FBQyxTQUFTLENBQUMsY0FBYyxFQUFFLGlDQUFpQyxDQUFDLENBQUM7SUFDbkUsQ0FBQztJQUVELG9FQUFvRTtJQUNwRSxvRUFBb0U7SUFDcEUsTUFBTSxNQUFNLEdBQUcsTUFBQSxHQUFHLENBQUMsR0FBRywwQ0FBRSxHQUFHLENBQUMsU0FBUyxDQUE0RSxDQUFDO0lBQ2xILElBQUksT0FBTyxNQUFNLEtBQUssVUFBVSxJQUFJLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDO1FBQzNELE1BQU0sSUFBSSxHQUFHLE1BQU0sQ0FBQyxPQUFPLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDdEMsSUFBSSxJQUFJLEVBQUUsQ0FBQztZQUNULEdBQUcsQ0FBQyxTQUFTLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxDQUFDO1FBQzlCLENBQUM7SUFDSCxDQUFDO0lBRUQsSUFBSSxHQUFHLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDZCxHQUFHLENBQUMsVUFBVSxHQUFHLEdBQUcsQ0FBQztJQUN2QixDQUFDO0lBRUQsK0VBQStFO0lBQy9FLElBQUksR0FBRyxDQUFDLFVBQVUsS0FBSyxHQUFHLElBQUksR0FBRyxDQUFDLFVBQVUsS0FBSyxHQUFHLEVBQUUsQ0FBQztRQUNyRCxHQUFHLENBQUMsWUFBWSxDQUFDLGNBQWMsQ0FBQyxDQUFDO1FBQ2pDLEdBQUcsQ0FBQyxZQUFZLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztRQUNuQyxHQUFHLENBQUMsWUFBWSxDQUFDLG1CQUFtQixDQUFDLENBQUM7UUFDdEMsT0FBTyxHQUFHLEVBQUUsQ0FBQztJQUNmLENBQUM7U0FBTSxDQUFDO1FBQ04scUVBQXFFO1FBQ3JFLHlDQUF5QztRQUN6QyxHQUFHLENBQUMsU0FBUyxDQUFDLGdCQUFnQixFQUFFLE1BQU0sQ0FBQyxVQUFVLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQztJQUM5RCxDQUFDO0lBRUQsT0FBTyxHQUFHLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0FBQzFCLENBQUMsQ0FBQztBQW5DVyxRQUFBLFFBQVEsWUFtQ25CIn0=

package/build/module/index.d.ts

@@ -1 +1,3 @@
 export * from './lib/middleware';
+export * from './lib/openapi';
+export type { OverrideErrorHandler } from './lib/override';

package/build/module/index.js

@@ -1,2 +1,3 @@
 export * from './lib/middleware';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQkFBa0IsQ0FBQyJ9
+export * from './lib/openapi';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGVBQWUsQ0FBQyJ9

package/build/module/lib/middleware.d.ts

@@ -1,8 +1,26 @@
 import type { NextFunction, Request, Response } from 'express';
 import { type Options, type Schema } from 'fast-json-stringify';
+import { type OverrideErrorHandler } from './override';
 export type { Schema, Options } from 'fast-json-stringify';
+export type FastJsonSchemaOptions = Omit<Options, 'mode'> & {
+    /**
+     * Also route `res.json()` — and therefore `res.send(object)`, which Express
+     * implements on top of it — through the compiled serializer.
+     *
+     * Off by default. Because a single schema describes the successful payload,
+     * only `2xx` responses take the fast path: an error body would otherwise be
+     * rewritten into the shape of the success schema.
+     */
+    readonly overrideJson?: boolean;
+    /**
+     * Called when an overridden `res.json()` could not use the fast path because
+     * the serializer threw. The response falls back to the stock `res.json()`
+     * either way; this is only so the mismatch is visible.
+     */
+    readonly onError?: OverrideErrorHandler;
+};
 /**
- * Set the schema
+ * Build a stringify function using a schema of the documents that should be stringified
  * @param {Schema} schema The schema used to stringify values
  * @param {Options} options The options to use (optional)
  * @see https://www.npmjs.com/package/fast-json-stringify
@@ -10,7 +28,7 @@ export type { Schema, Options } from 'fast-json-stringify';
  * Examples:
  * ```ts
  * import express from 'express';
- * import { fastJsonSchemas, Schema } from 'express-fast-json-stringify';
+ * import { fastJsonSchema, Schema } from 'express-fast-json-stringify';
  *
  * const app = express();
  *
@@ -44,7 +62,7 @@ export type { Schema, Options } from 'fast-json-stringify';
  * });
  * ```
  */
-export declare const fastJsonSchema: (schema: Schema, options?: Options) => (_req: Request, res: Response, next: NextFunction) => void;
+export declare const fastJsonSchema: (schema: Schema, options?: FastJsonSchemaOptions) => (req: Request, res: Response, next: NextFunction) => void;
 declare global {
     namespace Express {
         interface Response {
@@ -53,11 +71,11 @@ declare global {
              *
              * Examples:
              * ```ts
-             * res.fastJson({ user: 'tj' });
-             * res.status(200).fastJson({ user: 'tj' });
+             * res.fastJson({ user: 'Simone Nigro' });
+             * res.status(200).fastJson({ user: 'Simone Nigro' });
              * ```
              */
-            fastJson: (data: any) => Response;
+            fastJson: (body: any) => Response;
         }
     }
 }

package/build/module/lib/middleware.js

@@ -1,6 +1,8 @@
 import fastJson from 'fast-json-stringify';
+import { overrideResJson } from './override';
+import { sendJson } from './send';
 /**
- * Set the schema
+ * Build a stringify function using a schema of the documents that should be stringified
  * @param {Schema} schema The schema used to stringify values
  * @param {Options} options The options to use (optional)
  * @see https://www.npmjs.com/package/fast-json-stringify
@@ -8,7 +10,7 @@ import fastJson from 'fast-json-stringify';
  * Examples:
  * ```ts
  * import express from 'express';
- * import { fastJsonSchemas, Schema } from 'express-fast-json-stringify';
+ * import { fastJsonSchema, Schema } from 'express-fast-json-stringify';
  *
  * const app = express();
  *
@@ -43,27 +45,29 @@ import fastJson from 'fast-json-stringify';
  * ```
  */
 export const fastJsonSchema = (schema, options) => {
-    if (!schema) {
+    if (!schema || (typeof schema !== 'object' && typeof schema !== 'boolean')) {
         throw new TypeError(`express-fast-json-stringify: invalid schema`);
     }
-    const fjs = fastJson(schema, options);
-    return (_req, res, next) => {
+    const { overrideJson = false, onError, ...fastJsonOptions } = options ?? {};
+    const fjs = fastJson(schema, fastJsonOptions);
+    return (req, res, next) => {
         /**
          * Send JSON response.
          *
          * Examples:
          * ```ts
-         * res.fastJson({ user: 'tj' });
-         * res.status(200).fastJson({ user: 'tj' });
+         * res.fastJson({ user: 'Simone Nigro' });
+         * res.status(200).fastJson({ user: 'Simone Nigro' });
          * ```
          */
-        res.fastJson = (data) => {
-            if (!res.getHeader('Content-Type')) {
-                res.setHeader('Content-Type', 'application/json');
-            }
-            return res.send(fjs(data));
-        };
+        res.fastJson = (body) => sendJson(req, res, fjs(body));
+        if (overrideJson) {
+            // A single schema describes the successful payload, so applying it to an
+            // error body would rewrite it into the wrong shape. Only 2xx responses
+            // take the fast path; everything else keeps the stock res.json().
+            overrideResJson(req, res, (status) => (status >= 200 && status < 300 ? fjs : null), onError);
+        }
         next();
     };
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlkZGxld2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvbWlkZGxld2FyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLFFBQXVDLE1BQU0scUJBQXFCLENBQUM7QUFJMUU7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQTBDRztBQUNILE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxDQUFDLE1BQWMsRUFBRSxPQUFpQixFQUFFLEVBQUU7SUFDbEUsSUFBSSxDQUFDLE1BQU0sRUFBRTtRQUNYLE1BQU0sSUFBSSxTQUFTLENBQUMsNkNBQTZDLENBQUMsQ0FBQztLQUNwRTtJQUNELE1BQU0sR0FBRyxHQUFHLFFBQVEsQ0FBQyxNQUFNLEVBQUUsT0FBTyxDQUFDLENBQUM7SUFDdEMsT0FBTyxDQUFDLElBQWEsRUFBRSxHQUFhLEVBQUUsSUFBa0IsRUFBRSxFQUFFO1FBQzFEOzs7Ozs7OztXQVFHO1FBQ0gsR0FBRyxDQUFDLFFBQVEsR0FBRyxDQUFDLElBQVMsRUFBWSxFQUFFO1lBQ3JDLElBQUksQ0FBQyxHQUFHLENBQUMsU0FBUyxDQUFDLGNBQWMsQ0FBQyxFQUFFO2dCQUNsQyxHQUFHLENBQUMsU0FBUyxDQUFDLGNBQWMsRUFBRSxrQkFBa0IsQ0FBQyxDQUFDO2FBQ25EO1lBQ0QsT0FBTyxHQUFHLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO1FBQzdCLENBQUMsQ0FBQztRQUNGLElBQUksRUFBRSxDQUFDO0lBQ1QsQ0FBQyxDQUFDO0FBQ0osQ0FBQyxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlkZGxld2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvbWlkZGxld2FyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLFFBQXVDLE1BQU0scUJBQXFCLENBQUM7QUFFMUUsT0FBTyxFQUE2QixlQUFlLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFDeEUsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLFFBQVEsQ0FBQztBQXNCbEM7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQTBDRztBQUNILE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxDQUFDLE1BQWMsRUFBRSxPQUErQixFQUFFLEVBQUU7SUFDaEYsSUFBSSxDQUFDLE1BQU0sSUFBSSxDQUFDLE9BQU8sTUFBTSxLQUFLLFFBQVEsSUFBSSxPQUFPLE1BQU0sS0FBSyxTQUFTLENBQUMsRUFBRSxDQUFDO1FBQzNFLE1BQU0sSUFBSSxTQUFTLENBQUMsNkNBQTZDLENBQUMsQ0FBQztJQUNyRSxDQUFDO0lBQ0QsTUFBTSxFQUFFLFlBQVksR0FBRyxLQUFLLEVBQUUsT0FBTyxFQUFFLEdBQUcsZUFBZSxFQUFFLEdBQUcsT0FBTyxJQUFJLEVBQUUsQ0FBQztJQUM1RSxNQUFNLEdBQUcsR0FBRyxRQUFRLENBQUMsTUFBTSxFQUFFLGVBQWUsQ0FBQyxDQUFDO0lBQzlDLE9BQU8sQ0FBQyxHQUFZLEVBQUUsR0FBYSxFQUFFLElBQWtCLEVBQUUsRUFBRTtRQUN6RDs7Ozs7Ozs7V0FRRztRQUNILEdBQUcsQ0FBQyxRQUFRLEdBQUcsQ0FBQyxJQUFTLEVBQVksRUFBRSxDQUFDLFFBQVEsQ0FBQyxHQUFHLEVBQUUsR0FBRyxFQUFFLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO1FBRXRFLElBQUksWUFBWSxFQUFFLENBQUM7WUFDakIseUVBQXlFO1lBQ3pFLHVFQUF1RTtZQUN2RSxrRUFBa0U7WUFDbEUsZUFBZSxDQUFDLEdBQUcsRUFBRSxHQUFHLEVBQUUsQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDLENBQUMsTUFBTSxJQUFJLEdBQUcsSUFBSSxNQUFNLEdBQUcsR0FBRyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQy9GLENBQUM7UUFFRCxJQUFJLEVBQUUsQ0FBQztJQUNULENBQUMsQ0FBQztBQUNKLENBQUMsQ0FBQyJ9

package/build/module/lib/openapi.d.ts

@@ -0,0 +1,87 @@
+import type { NextFunction, Request, Response } from 'express';
+import { type Options } from 'fast-json-stringify';
+import { type OverrideErrorHandler } from './override';
+/**
+ * The parts of an OpenAPI 3.x or Swagger 2.0 document this package reads.
+ *
+ * It is deliberately a plain document rather than an integration with a
+ * specific library: every popular Express toolchain either consumes or produces
+ * one of these, so `swagger-jsdoc`, `swagger-ui-express`, `tsoa`,
+ * `express-openapi-validator` and a hand written file all work unchanged.
+ */
+export type OpenApiDocument = {
+    readonly openapi?: string;
+    readonly swagger?: string;
+    readonly paths?: Readonly<Record<string, unknown>>;
+    readonly components?: Readonly<Record<string, unknown>>;
+    readonly definitions?: Readonly<Record<string, unknown>>;
+};
+export type OpenApiOptions = Omit<Options, 'mode'> & {
+    /** Media type to read the schema from. Defaults to `application/json`. */
+    readonly contentType?: string;
+    /** Pin the OpenAPI path instead of deriving it from the matched route. */
+    readonly path?: string;
+    /** Pin the OpenAPI method instead of using the request method. */
+    readonly method?: string;
+    /**
+     * Throw when the document describes no schema for a response, instead of
+     * quietly falling back to `res.json()`. Only applies to explicit
+     * `res.fastJson()` calls — an overridden `res.json()` always falls back.
+     */
+    readonly strict?: boolean;
+    /**
+     * Also route `res.json()` — and therefore `res.send(object)`, which Express
+     * implements on top of it — through the compiled serializer whenever the
+     * document describes the response.
+     *
+     * Off by default. Turning it on lets an existing codebase benefit without
+     * rewriting a single call site: responses the document covers are serialized
+     * from the schema, everything else keeps the stock behavior.
+     */
+    readonly overrideJson?: boolean;
+    /**
+     * Called when an overridden `res.json()` could not use the fast path because
+     * the serializer threw. The response falls back to the stock `res.json()`
+     * either way; this is only so the mismatch is visible.
+     */
+    readonly onError?: OverrideErrorHandler;
+};
+/**
+ * Translate an Express route pattern into the OpenAPI equivalent:
+ * `/users/:id` becomes `/users/{id}`. Express parameter modifiers — a trailing
+ * `?` or an inline `(regex)` — are dropped, since OpenAPI has no notion of them.
+ */
+export declare const toOpenApiPath: (path: string) => string;
+/**
+ * Build a stringify middleware that takes its schemas from an OpenAPI or Swagger
+ * document, so the contract you already publish is the one used to serialize.
+ *
+ * The operation is resolved per request from the matched Express route, and the
+ * schema from the response status code, which means `res.status(201).fastJson()`
+ * serializes with the `201` schema. Routes the document does not describe fall
+ * back to `res.json()` unless `strict` is set.
+ *
+ * @param {OpenApiDocument} document The OpenAPI 3.x or Swagger 2.0 document
+ * @param {OpenApiOptions} options The options to use (optional)
+ *
+ * Examples:
+ * ```ts
+ * import express from 'express';
+ * import swaggerJsdoc from 'swagger-jsdoc';
+ * import { fastJsonOpenApi } from 'express-fast-json-stringify';
+ *
+ * const app = express();
+ * const document = swaggerJsdoc({ definition: { openapi: '3.1.0', info: { title: 'API', version: '1.0.0' } }, apis: ['./routes/*.ts'] });
+ *
+ * app.use(fastJsonOpenApi(document));
+ *
+ * app.get('/users/:id', (req, res, next) => {
+ *   try {
+ *     res.fastJson({ id: Number(req.params.id), firstName: 'Simone' });
+ *   } catch (error) {
+ *     next(error);
+ *   }
+ * });
+ * ```
+ */
+export declare const fastJsonOpenApi: (document: OpenApiDocument, options?: OpenApiOptions) => (req: Request, res: Response, next: NextFunction) => void;