@orpc/openapi 1.14.5 → 2.0.0-beta.1

package/dist/shared/openapi.CcyUEuTs.mjs

@@ -0,0 +1,313 @@
+import { COMMON_ERROR_STATUS_MAP } from '@orpc/client';
+import { walkProcedureContractsSync, Procedure, unlazy, getRouter, createContractProcedure, DEFAULT_SUCCESS_STATUS, DEFAULT_ERROR_STATUS } from '@orpc/server';
+import { value, pathToHttpPath, mergeHttpPath, normalizeHttpPath, tryDecodeURIComponent, isPlainObject, stringifyJSON, parseEmptyableJSON, isTypescriptObject, NullProtoObj } from '@orpc/shared';
+import { parseStandardUrl, isStandardHeaders } from '@standardserver/core';
+import { D as DEFAULT_OPENAPI_METHOD, g as getDynamicPathParams, O as OpenAPISerializer, a as DEFAULT_OPENAPI_INPUT_STRUCTURE, b as DEFAULT_OPENAPI_OUTPUT_STRUCTURE } from './openapi.DmAa7YPO.mjs';
+import { g as getOpenAPIMeta } from './openapi.B9PQzqBn.mjs';
+import { createRouter, addRoute, findRoute, routeToRegExp } from 'rou3';
+
+class OpenAPIMatcher {
+  filter;
+  rootRouter;
+  tree = createRouter();
+  pendingLazyRouters = [];
+  constructor(router, options = {}) {
+    this.filter = options.filter ?? true;
+    this.rootRouter = router;
+    this.index(router);
+  }
+  index(router, path = []) {
+    const lazyResults = walkProcedureContractsSync(router, (contract, path2) => {
+      if (!value(this.filter, contract, path2)) {
+        return;
+      }
+      const meta = getOpenAPIMeta(contract);
+      const method = meta?.method ?? DEFAULT_OPENAPI_METHOD;
+      const postHttpPath = meta?.path ?? pathToHttpPath(path2);
+      const openapiPath = meta?.prefix ? mergeHttpPath(meta.prefix, postHttpPath) : postHttpPath;
+      const rou3Path = toRou3Pattern(openapiPath);
+      addRoute(this.tree, method, rou3Path, {
+        path: path2,
+        contract,
+        procedure: contract instanceof Procedure ? contract : void 0
+      });
+    }, path);
+    this.pendingLazyRouters.push(...lazyResults.map((result) => {
+      const prefix = getOpenAPIMeta(result.router)?.prefix;
+      return {
+        ...result,
+        matcher: prefix ? toRou3PrefixMatcher(prefix) : void 0
+      };
+    }));
+  }
+  async match(method, pathname, prefix) {
+    if (prefix) {
+      if (!pathname.startsWith(prefix)) {
+        return void 0;
+      }
+      const charAfterPrefix = pathname[prefix.length];
+      if (charAfterPrefix === "/") {
+        pathname = pathname.slice(prefix.length);
+      } else if (charAfterPrefix === void 0) {
+        pathname = "/";
+      } else if (prefix[prefix.length - 1] === "/") {
+        pathname = pathname.slice(prefix.length - 1);
+      } else {
+        return void 0;
+      }
+    }
+    const result = await this.matchPathname(method, pathname);
+    if (!result && pathname.includes("%")) {
+      return this.matchPathname(method, normalizeHttpPath(pathname));
+    }
+    return result;
+  }
+  async matchPathname(method, pathname) {
+    await this.resolvePendingLazyRouters(pathname);
+    const match = findRoute(this.tree, method, pathname);
+    if (!match) {
+      return void 0;
+    }
+    const procedure = await this.resolveProcedure(match.data);
+    return {
+      path: match.data.path,
+      procedure,
+      params: match.params ? decodeParams(match.params) : void 0
+    };
+  }
+  async resolvePendingLazyRouters(pathname) {
+    if (!this.pendingLazyRouters.length) {
+      return;
+    }
+    const stillPending = [];
+    for (const pending of this.pendingLazyRouters) {
+      if (!pending.matcher || pending.matcher.test(pathname)) {
+        const { default: router } = await unlazy(pending.router);
+        this.index(router, pending.path);
+      } else {
+        stillPending.push(pending);
+      }
+    }
+    this.pendingLazyRouters = stillPending;
+  }
+  async resolveProcedure(entry) {
+    if (entry.procedure) {
+      return entry.procedure;
+    }
+    const { default: maybeProcedure } = await unlazy(getRouter(this.rootRouter, entry.path));
+    if (!(maybeProcedure instanceof Procedure)) {
+      throw new TypeError(
+        `[Contract-First] Missing or invalid implementation for procedure at path: "${entry.path.join(".")}". Ensure the procedure is correctly implemented and matches its contract.`
+      );
+    }
+    entry.procedure = createContractProcedure(maybeProcedure, entry.contract);
+    return entry.procedure;
+  }
+}
+function toRou3Pattern(path) {
+  const params = getDynamicPathParams(path);
+  if (!params?.length) {
+    return path;
+  }
+  for (let i = params.length - 1; i >= 0; i--) {
+    const param = params[i];
+    const pattern = param.allowsSlash ? `**:${param.parameterName}` : `:${param.parameterName}`;
+    path = path.slice(0, param.startIndex) + pattern + path.slice(param.startIndex + param.segment.length);
+  }
+  return path;
+}
+function toRou3PrefixMatcher(path) {
+  const pattern = toRou3Pattern(path);
+  return routeToRegExp(pattern === "/" ? "/**" : `${pattern}/**`);
+}
+function decodeParams(params) {
+  return Object.fromEntries(Object.entries(params).map(([key, val]) => [key, tryDecodeURIComponent(val)]));
+}
+
+class OpenAPIHandlerCodecError extends TypeError {
+}
+class OpenAPIHandlerCodec {
+  matcher;
+  serializer;
+  errorStatusMap;
+  customErrorResponseBodySerializer;
+  constructor(router, options = {}) {
+    this.matcher = new OpenAPIMatcher(router, options);
+    this.serializer = options.serializer ?? new OpenAPISerializer();
+    this.errorStatusMap = options.errorStatusMap ?? COMMON_ERROR_STATUS_MAP;
+    this.customErrorResponseBodySerializer = options.customErrorResponseBodyEncoder;
+  }
+  async resolveProcedure(request, options) {
+    const [pathname, search] = parseStandardUrl(request.url);
+    const matched = await this.matcher.match(request.method, pathname, options.prefix);
+    if (!matched) {
+      return void 0;
+    }
+    return {
+      procedure: matched.procedure,
+      path: matched.path,
+      decodeInput: async () => {
+        const meta = getOpenAPIMeta(matched.procedure);
+        const inputStructure = meta?.inputStructure ?? DEFAULT_OPENAPI_INPUT_STRUCTURE;
+        const params = this.deserializeParams(matched.params, meta?.paramsStyles);
+        const query = this.deserializeQuery(search, meta?.queryStyles);
+        if (inputStructure === "compact") {
+          const data = request.method === "GET" ? query : this.serializer.deserialize(await request.resolveBody(meta?.requestBodyHint));
+          if (data === void 0) {
+            return params;
+          }
+          if (!params || Object.keys(params).length < 1) {
+            return data;
+          }
+          if (isPlainObject(data)) {
+            return {
+              ...params,
+              ...data
+            };
+          }
+          return data;
+        }
+        return {
+          params,
+          query,
+          headers: request.headers,
+          body: this.serializer.deserialize(await request.resolveBody(meta?.requestBodyHint))
+        };
+      }
+    };
+  }
+  /**
+   * @throws {Error} If `outputStructure` is "detailed" and the output doesn't match the expected structure.
+   */
+  encodeOutput(output, procedure, path, _options) {
+    const meta = getOpenAPIMeta(procedure);
+    const successStatus = meta?.successStatus ?? DEFAULT_SUCCESS_STATUS;
+    const outputStructure = meta?.outputStructure ?? DEFAULT_OPENAPI_OUTPUT_STRUCTURE;
+    if (outputStructure === "compact") {
+      return {
+        status: successStatus,
+        headers: {},
+        body: this.serializer.serialize(output)
+      };
+    }
+    if (!isValidDetailedOutput(output)) {
+      throw new OpenAPIHandlerCodecError(`
+        Invalid "detailed" output structure returned by procedure (${path.join(".")}):
+        \u2022 Expected an object with optional properties:
+          - status (number 200-399)
+          - headers (Record<string, string | string[] | undefined>)
+          - body (any)
+        \u2022 No extra keys allowed.
+
+        Actual value:
+          ${stringifyJSON(output)}
+      `);
+    }
+    return {
+      status: output.status ?? successStatus,
+      headers: output.headers ?? {},
+      body: this.serializer.serialize(output.body)
+    };
+  }
+  encodeError(error, _procedure, _path, _options) {
+    const status = this.errorStatusMap[error.code] ?? DEFAULT_ERROR_STATUS;
+    return {
+      status,
+      headers: {},
+      body: this.serializer.serialize(this.customErrorResponseBodySerializer?.(error) ?? error.toJSON())
+    };
+  }
+  deserializeQuery(search, styles) {
+    const searchParams = new URLSearchParams(search);
+    const parsed = this.serializer.deserialize(searchParams);
+    if (!styles || !isPlainObject(parsed)) {
+      return parsed;
+    }
+    Object.entries(styles).forEach(([key, hint]) => {
+      if (hint === void 0) {
+        return;
+      }
+      const values = searchParams.getAll(key);
+      let parsedValue;
+      if (hint === "primitive") {
+        parsedValue = values.at(-1);
+      } else if (hint === "array") {
+        parsedValue = values;
+      } else if (hint === "comma-delimited-array") {
+        parsedValue = decodeDelimitedArray(values.at(-1), ",");
+      } else if (hint === "comma-delimited-object") {
+        parsedValue = decodeDelimitedObject(values.at(-1), ",");
+      } else if (hint === "space-delimited-array") {
+        parsedValue = decodeDelimitedArray(values.at(-1), " ");
+      } else if (hint === "space-delimited-object") {
+        parsedValue = decodeDelimitedObject(values.at(-1), " ");
+      } else if (hint === "pipe-delimited-array") {
+        parsedValue = decodeDelimitedArray(values.at(-1), "|");
+      } else if (hint === "pipe-delimited-object") {
+        parsedValue = decodeDelimitedObject(values.at(-1), "|");
+      } else {
+        const last = values.at(-1);
+        try {
+          parsedValue = parseEmptyableJSON(last);
+        } catch {
+          parsedValue = last;
+        }
+      }
+      parsed[key] = this.serializer.deserialize(parsedValue);
+    });
+    return parsed;
+  }
+  deserializeParams(params, styles) {
+    if (!params || !styles) {
+      return params;
+    }
+    const parsed = { ...params };
+    Object.entries(styles).forEach(([key, hint]) => {
+      if (hint === void 0 || hint === "primitive") {
+        return;
+      }
+      const value = params[key];
+      if (hint === "comma-delimited-array") {
+        parsed[key] = decodeDelimitedArray(value, ",");
+      } else {
+        parsed[key] = decodeDelimitedObject(value, ",");
+      }
+    });
+    return parsed;
+  }
+}
+function isValidDetailedOutput(output) {
+  if (!isTypescriptObject(output)) {
+    return false;
+  }
+  if (Object.keys(output).some((key) => key !== "status" && key !== "headers" && key !== "body")) {
+    return false;
+  }
+  if (output.status !== void 0 && (typeof output.status !== "number" || !Number.isInteger(output.status) || output.status < 200 || output.status > 399)) {
+    return false;
+  }
+  if (output.headers !== void 0 && !isStandardHeaders(output.headers)) {
+    return false;
+  }
+  return true;
+}
+function decodeDelimitedArray(value, delimiter) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return value.split(delimiter);
+}
+function decodeDelimitedObject(value, delimiter) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const obj = new NullProtoObj();
+  const parts = value.split(delimiter);
+  for (let i = 0; i < parts.length; i += 2) {
+    const key = parts[i];
+    obj[key] = parts[i + 1];
+  }
+  return obj;
+}
+
+export { OpenAPIHandlerCodec as O, OpenAPIHandlerCodecError as a, OpenAPIMatcher as b };

package/dist/shared/openapi.DmAa7YPO.mjs

@@ -0,0 +1,275 @@
+import { wrapEventIteratorPreservingMeta, toORPCError, isORPCErrorJson, createORPCErrorFromJson } from '@orpc/client';
+import { isPlainObject, isAsyncIteratorObject } from '@orpc/shared';
+import { ErrorEvent } from '@standardserver/core';
+import { B as BracketNotationSerializer } from './openapi.Bt87OzTt.mjs';
+
+const DEFAULT_OPENAPI_METHOD = "POST";
+const DEFAULT_OPENAPI_SUCCESS_DESCRIPTION = "OK";
+const DEFAULT_OPENAPI_INPUT_STRUCTURE = "compact";
+const DEFAULT_OPENAPI_OUTPUT_STRUCTURE = "compact";
+
+const DEFAULT_OPEN_API_JSON_SERIALIZER_HANDLERS = {
+  undefined: {
+    condition(data) {
+      return data === void 0;
+    },
+    serialize() {
+      return null;
+    },
+    isTerminal: true
+  },
+  bigint: {
+    condition(data) {
+      return typeof data === "bigint";
+    },
+    serialize(data) {
+      return data.toString();
+    },
+    isTerminal: true
+  },
+  date: {
+    condition(data) {
+      return data instanceof Date;
+    },
+    serialize(data) {
+      if (Number.isNaN(data.getTime())) {
+        return null;
+      }
+      return data.toISOString();
+    },
+    isTerminal: true
+  },
+  nan: {
+    condition(data) {
+      return typeof data === "number" && Number.isNaN(data);
+    },
+    serialize() {
+      return null;
+    },
+    isTerminal: true
+  },
+  url: {
+    condition(data) {
+      return data instanceof URL;
+    },
+    serialize(data) {
+      return data.toString();
+    },
+    isTerminal: true
+  },
+  regexp: {
+    condition(data) {
+      return data instanceof RegExp;
+    },
+    serialize(data) {
+      return data.toString();
+    },
+    isTerminal: true
+  },
+  set: {
+    condition(data) {
+      return data instanceof Set;
+    },
+    serialize(data) {
+      return Array.from(data);
+    }
+  },
+  map: {
+    condition(data) {
+      return data instanceof Map;
+    },
+    serialize(data) {
+      return Array.from(data.entries());
+    }
+  }
+};
+class OpenAPIJsonSerializer {
+  handlers;
+  omitUndefinedProperties;
+  constructor(options = {}) {
+    this.handlers = {
+      ...DEFAULT_OPEN_API_JSON_SERIALIZER_HANDLERS,
+      ...options.handlers
+    };
+    this.omitUndefinedProperties = options.omitUndefinedProperties !== false;
+  }
+  serialize(data) {
+    const [json, maps, blobs] = this.serializeValue(data, [], [], []);
+    return { json, maps, blobs };
+  }
+  serializeValue(data, segments, maps, blobs) {
+    for (const key in this.handlers) {
+      const handler = this.handlers[key];
+      if (handler && handler.condition(data)) {
+        const serialized = handler.serialize(data);
+        if (handler.isTerminal) {
+          return [serialized, maps, blobs];
+        }
+        const result = this.serializeValue(serialized, segments, maps, blobs);
+        return result;
+      }
+    }
+    if (data instanceof Blob) {
+      maps.push(segments);
+      blobs.push(data);
+      return [data, maps, blobs];
+    }
+    if (Array.isArray(data)) {
+      const json = data.map((v, i) => {
+        return this.serializeValue(v, [...segments, i], maps, blobs)[0];
+      });
+      return [json, maps, blobs];
+    }
+    if (isPlainObject(data)) {
+      const json = {};
+      for (const k in data) {
+        const v = data[k];
+        if (k === "toJSON" && typeof v === "function") {
+          continue;
+        }
+        if (v === void 0 && this.omitUndefinedProperties) {
+          continue;
+        }
+        json[k] = this.serializeValue(v, [...segments, k], maps, blobs)[0];
+      }
+      return [json, maps, blobs];
+    }
+    return [data, maps, blobs];
+  }
+  deserialize(serialized) {
+    const ref = { data: serialized.json };
+    if (serialized.blobs?.length) {
+      serialized.maps.forEach((segments, i) => {
+        let currentRef = ref;
+        let preSegment = "data";
+        segments.forEach((segment) => {
+          currentRef = currentRef[preSegment];
+          preSegment = segment;
+          if (!Object.hasOwn(currentRef, preSegment)) {
+            throw new Error(`Security error: Invalid serialized data. Segment "${preSegment}" does not exist.`);
+          }
+        });
+        currentRef[preSegment] = serialized.blobs[i];
+      });
+    }
+    return ref.data;
+  }
+}
+
+class OpenAPISerializer {
+  jsonSerializer;
+  bracketNotation;
+  defaultSerializeOptions;
+  constructor({ bracketNotation, serialize, ...options } = {}) {
+    this.jsonSerializer = new OpenAPIJsonSerializer(options);
+    this.bracketNotation = new BracketNotationSerializer(bracketNotation);
+    this.defaultSerializeOptions = serialize;
+  }
+  serialize(data, options = {}) {
+    const useFormDataForBlobFields = options.useFormDataForBlobFields ?? this.defaultSerializeOptions?.useFormDataForBlobFields ?? true;
+    const asFormData = options.asFormData ?? this.defaultSerializeOptions?.asFormData ?? false;
+    if (!options.asFormData) {
+      if (data === void 0 || data instanceof ReadableStream || data instanceof Blob) {
+        return data;
+      }
+      if (isAsyncIteratorObject(data)) {
+        return wrapEventIteratorPreservingMeta(data, {
+          mapResult: (result) => {
+            if (result.value === void 0) {
+              return result;
+            }
+            return { done: result.done, value: this.serializeValue(result.value, { asFormData: false, useFormDataForBlobFields: false }) };
+          },
+          mapError: (e) => {
+            return new ErrorEvent({
+              data: this.serializeValue(toORPCError(e).toJSON(), { asFormData: false, useFormDataForBlobFields: false }),
+              cause: e
+            });
+          }
+        });
+      }
+    }
+    return this.serializeValue(data, { useFormDataForBlobFields, asFormData });
+  }
+  serializeValue(value, options) {
+    const { json, blobs } = this.jsonSerializer.serialize(value);
+    if (!options.asFormData && (json instanceof Blob || json === void 0 || !blobs?.length || !options.useFormDataForBlobFields)) {
+      return json;
+    }
+    const form = new FormData();
+    for (const [path, value2] of this.bracketNotation.serialize(json)) {
+      if (value2 instanceof Blob) {
+        form.append(path, value2);
+      } else if (value2 !== void 0 && value2 !== null) {
+        form.append(path, String(value2));
+      }
+    }
+    return form;
+  }
+  deserialize(data) {
+    if (data === void 0 || data instanceof ReadableStream || data instanceof Blob) {
+      return data;
+    }
+    if (isAsyncIteratorObject(data)) {
+      return wrapEventIteratorPreservingMeta(data, {
+        mapResult: (result) => {
+          if (result.value === void 0) {
+            return result;
+          }
+          return { done: result.done, value: this.jsonSerializer.deserialize({ json: result.value }) };
+        },
+        mapError: (e) => {
+          if (e instanceof ErrorEvent) {
+            const deserialized = this.jsonSerializer.deserialize({ json: e.data });
+            if (isORPCErrorJson(deserialized)) {
+              return createORPCErrorFromJson(deserialized, { cause: e });
+            }
+          }
+          return e;
+        }
+      });
+    }
+    if (data instanceof URLSearchParams || data instanceof FormData) {
+      data = this.bracketNotation.deserialize(Array.from(data.entries()));
+    }
+    return this.jsonSerializer.deserialize({ json: data });
+  }
+}
+
+const PARAMETER_NAME_REGEX = /^[\w-]+$/;
+function getDynamicPathParams(path) {
+  if (!path.includes("{")) {
+    return void 0;
+  }
+  const len = path.length;
+  let params;
+  let index = 1;
+  while (index < len) {
+    const segmentStart = index;
+    const slashPos = path.indexOf("/", index);
+    const segmentEnd = slashPos === -1 ? len : slashPos;
+    if (segmentEnd > segmentStart && path.charCodeAt(segmentStart) === 123 && path.charCodeAt(segmentEnd - 1) === 125) {
+      let parameterStart = segmentStart + 1;
+      let allowsSlash = false;
+      const operator = path.charCodeAt(parameterStart);
+      if (operator === 43) {
+        allowsSlash = true;
+        parameterStart++;
+      }
+      const parameterName = path.slice(parameterStart, segmentEnd - 1);
+      if (PARAMETER_NAME_REGEX.test(parameterName)) {
+        params ??= [];
+        params.push({
+          segment: path.slice(segmentStart, segmentEnd),
+          startIndex: segmentStart,
+          parameterName,
+          allowsSlash
+        });
+      }
+    }
+    index = segmentEnd + 1;
+  }
+  return params;
+}
+
+export { DEFAULT_OPENAPI_METHOD as D, OpenAPISerializer as O, DEFAULT_OPENAPI_INPUT_STRUCTURE as a, DEFAULT_OPENAPI_OUTPUT_STRUCTURE as b, DEFAULT_OPENAPI_SUCCESS_DESCRIPTION as c, OpenAPIJsonSerializer as d, getDynamicPathParams as g };

package/dist/shared/openapi.Drd1OtzG.d.mts

@@ -0,0 +1,75 @@
+import { AnyORPCError } from '@orpc/client';
+import { AnyProcedure, AnyRouter, Context } from '@orpc/server';
+import { StandardHandlerCodec, StandardHandlerHandleOptions, StandardHandlerCodecResolvedProcedure } from '@orpc/server/standard';
+import { Value, Promisable } from '@orpc/shared';
+import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
+import { AnyProcedureContract } from '@orpc/contract';
+import { O as OpenAPISerializer } from './openapi.C7m7NAmH.mjs';
+
+interface OpenAPIMatcherOptions {
+    /**
+     * Filter which procedures are exposed for matching. Return `false` to exclude.
+     *
+     * @default true
+     */
+    filter?: Value<boolean, [contract: AnyProcedureContract | AnyProcedure, path: string[]]>;
+}
+declare class OpenAPIMatcher {
+    private readonly filter;
+    private readonly rootRouter;
+    private readonly tree;
+    private pendingLazyRouters;
+    constructor(router: AnyRouter, options?: OpenAPIMatcherOptions);
+    private index;
+    match(method: string, pathname: `/${string}`, prefix: `/${string}` | undefined): Promise<{
+        path: string[];
+        procedure: AnyProcedure;
+        params?: Record<string, string> | undefined;
+    } | undefined>;
+    private matchPathname;
+    private resolvePendingLazyRouters;
+    private resolveProcedure;
+}
+
+declare class OpenAPIHandlerCodecError extends TypeError {
+}
+interface OpenAPIHandlerCodecOptions<_T extends Context> extends OpenAPIMatcherOptions {
+    /**
+     * Override the default OpenAPI serializer.
+     */
+    serializer?: Pick<OpenAPISerializer, keyof OpenAPISerializer>;
+    /**
+     * Mapping ORPCError Code -> HTTP Status Code
+     *
+     * @default COMMON_ERROR_STATUS_MAP, DEFAULT_ERROR_STATUS
+     */
+    errorStatusMap?: Record<string, number> | undefined;
+    /**
+     * Customize how an ORPC error is serialized into a response body.
+     * Use this if your API needs a different error output structure.
+     *
+     * @remarks
+     * - Return `null | undefined` to fallback to default behavior
+     *
+     * @default ((e) => e.toJSON())
+     */
+    customErrorResponseBodyEncoder?: (error: AnyORPCError) => unknown;
+}
+declare class OpenAPIHandlerCodec<T extends Context> implements StandardHandlerCodec<T> {
+    private readonly matcher;
+    private readonly serializer;
+    private readonly errorStatusMap;
+    private readonly customErrorResponseBodySerializer;
+    constructor(router: AnyRouter, options?: OpenAPIHandlerCodecOptions<T>);
+    resolveProcedure(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerCodecResolvedProcedure | undefined>;
+    /**
+     * @throws {Error} If `outputStructure` is "detailed" and the output doesn't match the expected structure.
+     */
+    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], _options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    encodeError(error: AnyORPCError, _procedure: AnyProcedure, _path: string[], _options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    private deserializeQuery;
+    private deserializeParams;
+}
+
+export { OpenAPIHandlerCodec as a, OpenAPIHandlerCodecError as b, OpenAPIMatcher as c };
+export type { OpenAPIHandlerCodecOptions as O, OpenAPIMatcherOptions as d };