@elysiajs/openapi 1.4.14 → 1.4.16

package/dist/cjs/openapi.d.ts

@@ -1,7 +1,7 @@
-import { type AnyElysia, type TSchema, type InputSchema } from 'elysia';
+import { type AnyElysia, type InputSchema } from 'elysia';
 import type { OpenAPIV3 } from 'openapi-types';
-import { TAnySchema, type TProperties } from '@sinclair/typebox';
-import type { AdditionalReferences, ElysiaOpenAPIConfig, MapJsonSchema } from './types';
+import { TAnySchema } from '@sinclair/typebox';
+import type { AdditionalReferences, ElysiaOpenAPIConfig, MapJsonSchema, OpenAPIVersion } from './types';
 export declare const capitalize: (word: string) => string;
 /**
  * Get all possible paths of a path with optional parameters
@@ -10,24 +10,27 @@ export declare const capitalize: (word: string) => string;
  */
 export declare const getPossiblePath: (path: string) => string[];
 export declare const getLoosePath: (path: string) => string;
-export declare const unwrapSchema: (schema: InputSchema["body"], mapJsonSchema?: MapJsonSchema, io?: "input" | "output") => OpenAPIV3.SchemaObject | undefined;
+export declare const unwrapSchema: (schema: InputSchema["body"], mapJsonSchema?: MapJsonSchema, io?: "input" | "output", openapiVersion?: OpenAPIVersion) => OpenAPIV3.SchemaObject | undefined;
 /**
  * Convert TypeBox enum-like Union schemas to OpenAPI enum schemas
  *
  * Otherwise, return the schema as is
  */
 export declare const enumToOpenApi: <T extends TAnySchema | OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject | undefined>(_schema: T) => T;
+export declare const nullToOpenApi: <T>(schema: T, openapiVersion: OpenAPIVersion) => T;
 /**
- * Converts Elysia routes to OpenAPI 3.0.3 paths schema
+ * Converts Elysia routes to OpenAPI paths schema
  * @param routes Array of Elysia route objects
  * @returns OpenAPI paths object
  */
-export declare function toOpenAPISchema(app: AnyElysia, exclude?: ElysiaOpenAPIConfig['exclude'], references?: AdditionalReferences, vendors?: MapJsonSchema): {
+export declare function toOpenAPISchema(app: AnyElysia, exclude?: ElysiaOpenAPIConfig['exclude'], references?: AdditionalReferences, vendors?: MapJsonSchema, openapiVersion?: OpenAPIVersion): {
     components: {
         schemas: any;
     };
     paths: OpenAPIV3.PathsObject<{}, {}>;
 };
-export declare const withHeaders: (schema: TSchema, headers: TProperties) => TSchema & {
-    headers: TProperties;
+type ResponseHeaderSchemas = Record<string, Exclude<InputSchema['headers'], undefined>>;
+export declare const withHeaders: <S extends Exclude<InputSchema["body"], string | undefined>, H extends ResponseHeaderSchemas>(schema: S, headers: H) => S & {
+    headers: H;
 };
+export {};

package/dist/cjs/openapi.js

@@ -24,21 +24,16 @@ __export(openapi_exports, {
   enumToOpenApi: () => enumToOpenApi,
   getLoosePath: () => getLoosePath,
   getPossiblePath: () => getPossiblePath,
+  nullToOpenApi: () => nullToOpenApi,
   toOpenAPISchema: () => toOpenAPISchema,
   unwrapSchema: () => unwrapSchema,
   withHeaders: () => withHeaders
 });
 module.exports = __toCommonJS(openapi_exports);
 var import_elysia = require("elysia");
-
-// node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.mjs
-var Kind = /* @__PURE__ */ Symbol.for("TypeBox.Kind");
-
-// src/openapi.ts
+var import_typebox = require("@sinclair/typebox");
 var capitalize = (word) => word.charAt(0).toUpperCase() + word.slice(1);
-var toRef = (name) => import_elysia.t.Ref(
-  name.startsWith("#/") ? name : `#/components/schemas/${name}`
-);
+var toRef = (name) => import_elysia.t.Ref(name.startsWith("#/") ? name : `#/components/schemas/${name}`);
 var toOperationId = (method, paths) => {
   let operationId = method.toLowerCase();
   if (!paths || paths === "/") return operationId + "Index";
@@ -59,7 +54,7 @@ var getPossiblePath = (path) => {
   }
   return paths;
 };
-var isValidSchema = (schema) => schema && typeof schema === "object" && (Kind in schema && schema[Kind] !== "Unknown" || schema.type || schema.properties || schema.items);
+var isValidSchema = (schema) => schema && typeof schema === "object" && (import_typebox.Kind in schema && schema[import_typebox.Kind] !== "Unknown" || schema.type || schema.properties || schema.items);
 var getLoosePath = (path) => {
   if (path.charCodeAt(path.length - 1) === 47)
     return path.slice(0, path.length - 1);
@@ -160,7 +155,7 @@ var mergeObjectSchemas = (schemas) => {
 };
 var isTSchema = (value) => {
   if (!value || typeof value !== "object") return false;
-  if (Kind in value) return true;
+  if (import_typebox.Kind in value) return true;
   const keys = Object.keys(value);
   if (keys.length > 0 && keys.every((k) => !isNaN(Number(k)))) {
     return false;
@@ -172,7 +167,7 @@ var normalizeSchemaReference = (schema) => {
   if (typeof schema !== "string") return schema;
   return toRef(schema);
 };
-var mergeSchemaProperty = (existing, incoming, vendors) => {
+var mergeSchemaProperty = (existing, incoming, vendors, openapiVersion = "3.1.2") => {
   if (!existing) return incoming;
   if (!incoming) return existing;
   let existingSchema = normalizeSchemaReference(existing);
@@ -180,9 +175,19 @@ var mergeSchemaProperty = (existing, incoming, vendors) => {
   if (!existingSchema) return incoming;
   if (!incomingSchema) return existing;
   if (!isTSchema(incomingSchema) && incomingSchema["~standard"])
-    incomingSchema = unwrapSchema(incomingSchema, vendors);
+    incomingSchema = unwrapSchema(
+      incomingSchema,
+      vendors,
+      "input",
+      openapiVersion
+    );
   if (!isTSchema(existingSchema) && existingSchema["~standard"])
-    existingSchema = unwrapSchema(existingSchema, vendors);
+    existingSchema = unwrapSchema(
+      existingSchema,
+      vendors,
+      "input",
+      openapiVersion
+    );
   if (!incomingSchema) return existingSchema;
   if (!existingSchema) return incomingSchema;
   const { schema: mergedSchema, notObjects } = mergeObjectSchemas([
@@ -195,24 +200,30 @@ var mergeSchemaProperty = (existing, incoming, vendors) => {
   }
   return mergedSchema;
 };
-var unwrapResponseSchema = (schema, vendors) => typeof schema === "string" ? normalizeSchemaReference(schema) : !schema ? void 0 : isTSchema(schema) ? schema : (
+var unwrapResponseSchema = (schema, vendors, openapiVersion = "3.1.2") => typeof schema === "string" ? normalizeSchemaReference(schema) : !schema ? void 0 : isTSchema(schema) ? schema : (
   // @ts-ignore
-  schema["~standard"] ? unwrapSchema(schema, vendors, "output") : Object.fromEntries(
+  schema["~standard"] ? unwrapSchema(
+    schema,
+    vendors,
+    "output",
+    openapiVersion
+  ) : Object.fromEntries(
     Object.entries(schema).map(([status, schema2]) => [
       status,
       typeof schema2 === "string" ? normalizeSchemaReference(schema2) : isTSchema(schema2) ? schema2 : unwrapSchema(
         schema2,
         vendors,
-        "output"
+        "output",
+        openapiVersion
       )
     ])
   )
 );
-var mergeResponseSchema = (_existing, _incoming, vendors) => {
+var mergeResponseSchema = (_existing, _incoming, vendors, openapiVersion = "3.1.2") => {
   if (!_existing) return _incoming;
   if (!_incoming) return _existing;
-  let existing = unwrapResponseSchema(_existing, vendors);
-  let incoming = unwrapResponseSchema(_incoming, vendors);
+  let existing = unwrapResponseSchema(_existing, vendors, openapiVersion);
+  let incoming = unwrapResponseSchema(_incoming, vendors, openapiVersion);
   if (!existing && !incoming) return void 0;
   if (incoming && !existing) return incoming;
   if (existing && !incoming) return existing;
@@ -234,14 +245,15 @@ var mergeResponseSchema = (_existing, _incoming, vendors) => {
       schema[status] = mergeSchemaProperty(
         existingSchema,
         incomingSchema,
-        vendors
+        vendors,
+        openapiVersion
       );
     else if (existingSchema) schema[status] = existingSchema;
     else if (incomingSchema) schema[status] = incomingSchema;
   }
   return schema;
 };
-var mergeStandaloneValidators = (hooks, vendors) => {
+var mergeStandaloneValidators = (hooks, vendors, openapiVersion = "3.1.2") => {
   const merged = { ...hooks };
   if (!hooks.standaloneValidator?.length) return merged;
   for (const validator of hooks.standaloneValidator) {
@@ -249,37 +261,43 @@ var mergeStandaloneValidators = (hooks, vendors) => {
       merged.body = mergeSchemaProperty(
         merged.body,
         validator.body,
-        vendors
+        vendors,
+        openapiVersion
       );
     if (validator.headers)
       merged.headers = mergeSchemaProperty(
         merged.headers,
         validator.headers,
-        vendors
+        vendors,
+        openapiVersion
       );
     if (validator.query)
       merged.query = mergeSchemaProperty(
         merged.query,
         validator.query,
-        vendors
+        vendors,
+        openapiVersion
       );
     if (validator.params)
       merged.params = mergeSchemaProperty(
         merged.params,
         validator.params,
-        vendors
+        vendors,
+        openapiVersion
       );
     if (validator.cookie)
       merged.cookie = mergeSchemaProperty(
         merged.cookie,
         validator.cookie,
-        vendors
+        vendors,
+        openapiVersion
       );
     if (validator.response)
       merged.response = mergeResponseSchema(
         merged.response,
         validator.response,
-        vendors
+        vendors,
+        openapiVersion
       );
   }
   if (typeof merged.body === "string")
@@ -305,36 +323,51 @@ var mergeStandaloneValidators = (hooks, vendors) => {
   }
   return merged;
 };
-var flattenRoutes = (routes, vendors) => routes.map((route) => {
+var flattenRoutes = (routes, vendors, openapiVersion = "3.1.2") => routes.map((route) => {
   if (!route.hooks?.standaloneValidator?.length) return route;
   return {
     ...route,
-    hooks: mergeStandaloneValidators(route.hooks, vendors)
+    hooks: mergeStandaloneValidators(
+      route.hooks,
+      vendors,
+      openapiVersion
+    )
   };
 });
-var unwrapReference = (schema, definitions) => {
+var unwrapReference = (schema, definitions, openapiVersion = "3.1.2") => {
   const ref = schema?.$ref;
   if (!ref) return schema;
   const name = ref.slice(ref.lastIndexOf("/") + 1);
   if (ref && definitions[name]) schema = definitions[name];
-  return enumToOpenApi(schema);
+  return nullToOpenApi(enumToOpenApi(schema), openapiVersion);
 };
-var unwrapSchema = (schema, mapJsonSchema, io = "input") => {
+var unwrapSchema = (schema, mapJsonSchema, io = "input", openapiVersion = "3.1.2") => {
   if (!schema) return;
   if (typeof schema === "string") schema = toRef(schema);
-  if (Kind in schema) return enumToOpenApi(schema);
+  if (import_typebox.Kind in schema)
+    return nullToOpenApi(enumToOpenApi(schema), openapiVersion);
   if (!schema?.["~standard"] && // @ts-ignore
   (schema.$schema || schema.type || schema.properties || schema.items))
-    return schema;
+    return nullToOpenApi(schema, openapiVersion);
   if (!schema?.["~standard"]) return;
-  const vendor = schema["~standard"].vendor;
+  const standard = schema["~standard"];
+  const vendor = standard.vendor;
   try {
+    const jsonSchemaTarget = openapiVersion.startsWith("3.0.") ? "draft-07" : "draft-2020-12";
     if (mapJsonSchema?.[vendor] && typeof mapJsonSchema[vendor] === "function")
-      return enumToOpenApi(mapJsonSchema[vendor](schema));
-    if (schema["~standard"]?.jsonSchema?.[io])
-      return enumToOpenApi(schema["~standard"].jsonSchema[io]({
-        target: "draft-2020-12"
-      }));
+      return nullToOpenApi(
+        enumToOpenApi(mapJsonSchema[vendor](schema)),
+        openapiVersion
+      );
+    if (standard.jsonSchema?.[io])
+      return nullToOpenApi(
+        enumToOpenApi(
+          standard.jsonSchema[io]({
+            target: jsonSchemaTarget
+          })
+        ),
+        openapiVersion
+      );
     switch (vendor) {
       case "zod":
         if (warned.zod4 || warned.zod3) break;
@@ -379,10 +412,16 @@ var unwrapSchema = (schema, mapJsonSchema, io = "input") => {
         break;
     }
     if (vendor === "arktype")
-      return enumToOpenApi(schema?.toJsonSchema?.());
-    return enumToOpenApi(
-      // @ts-ignore
-      schema.toJSONSchema?.() ?? schema?.toJsonSchema?.()
+      return nullToOpenApi(
+        enumToOpenApi(schema.toJsonSchema?.()),
+        openapiVersion
+      );
+    return nullToOpenApi(
+      enumToOpenApi(
+        // @ts-ignore
+        schema.toJSONSchema?.() ?? schema?.toJsonSchema?.()
+      ),
+      openapiVersion
     );
   } catch (error) {
     console.warn(error);
@@ -390,9 +429,9 @@ var unwrapSchema = (schema, mapJsonSchema, io = "input") => {
 };
 var enumToOpenApi = (_schema) => {
   if (!_schema || typeof _schema !== "object") return _schema;
-  if (Kind in _schema) {
+  if (import_typebox.Kind in _schema) {
     const schema2 = _schema;
-    if (schema2[Kind] === "Union" && schema2.anyOf && Array.isArray(schema2.anyOf) && schema2.anyOf.length > 0 && schema2.anyOf.every(
+    if (schema2[import_typebox.Kind] === "Union" && schema2.anyOf && Array.isArray(schema2.anyOf) && schema2.anyOf.length > 0 && schema2.anyOf.every(
       (item) => item && typeof item === "object" && item.const !== void 0
     ))
       return {
@@ -415,9 +454,154 @@ var enumToOpenApi = (_schema) => {
       ...schema,
       items: enumToOpenApi(schema.items)
     };
+  if (schema.anyOf && Array.isArray(schema.anyOf)) {
+    const mapped = schema.anyOf.map(
+      (item) => item && typeof item === "object" && item.type === "Date" ? { type: "string", format: "date-time" } : enumToOpenApi(item)
+    );
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = mapped.filter((item) => {
+      if (!item || typeof item !== "object") return true;
+      const key = JSON.stringify(
+        Object.fromEntries(
+          Object.entries(item).sort(
+            ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+          )
+        )
+      );
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+    if (deduped.length === 1) return deduped[0];
+    return { ...schema, anyOf: deduped };
+  }
   return schema;
 };
-function toOpenAPISchema(app, exclude, references, vendors) {
+var SCHEMA_MAP_KEYS = /* @__PURE__ */ new Set([
+  "properties",
+  "patternProperties",
+  "$defs",
+  "definitions",
+  "dependentSchemas"
+]);
+var SCHEMA_ARRAY_KEYS = /* @__PURE__ */ new Set(["allOf", "anyOf", "oneOf", "prefixItems"]);
+var SCHEMA_VALUE_KEYS = /* @__PURE__ */ new Set([
+  "items",
+  "additionalProperties",
+  "unevaluatedProperties",
+  "contains",
+  "not",
+  "if",
+  "then",
+  "else",
+  "propertyNames"
+]);
+var isSchemaObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var nullToOpenApi = (schema, openapiVersion) => {
+  const normalize = (value) => {
+    if (Array.isArray(value)) return value.map(normalize);
+    if (!isSchemaObject(value)) return value;
+    const normalized = { ...value };
+    const isOpenAPI30 = openapiVersion.startsWith("3.0.");
+    for (const unionKey of ["anyOf", "oneOf"]) {
+      const union = normalized[unionKey];
+      if (!Array.isArray(union)) continue;
+      const nonNull = union.filter(
+        (item) => !isSchemaObject(item) || item.type !== "null"
+      );
+      if (nonNull.length === union.length) continue;
+      const normalizedNonNull = nonNull.map(normalize);
+      if (isOpenAPI30) {
+        delete normalized[unionKey];
+        if (normalizedNonNull.length === 1 && isSchemaObject(normalizedNonNull[0]))
+          Object.assign(normalized, normalizedNonNull[0]);
+        else if (normalizedNonNull.length)
+          normalized[unionKey] = normalizedNonNull;
+        normalized.nullable = true;
+      } else if (normalizedNonNull.length === 1 && isSchemaObject(normalizedNonNull[0]) && typeof normalizedNonNull[0].type === "string") {
+        delete normalized[unionKey];
+        Object.assign(normalized, normalizedNonNull[0]);
+        normalized.type = [normalizedNonNull[0].type, "null"];
+      } else normalized[unionKey] = union.map(normalize);
+    }
+    if (isOpenAPI30 && normalized.type === "null") {
+      delete normalized.type;
+      normalized.nullable = true;
+    } else if (isOpenAPI30 && Array.isArray(normalized.type) && normalized.type.includes("null")) {
+      const types = normalized.type.filter((type) => type !== "null");
+      normalized.nullable = true;
+      if (types.length === 1) normalized.type = types[0];
+      else if (types.length) normalized.type = types;
+      else delete normalized.type;
+    }
+    for (const [key, nested] of Object.entries(normalized)) {
+      if (SCHEMA_MAP_KEYS.has(key) && isSchemaObject(nested))
+        normalized[key] = Object.fromEntries(
+          Object.entries(nested).map(([name, child]) => [
+            name,
+            normalize(child)
+          ])
+        );
+      else if (SCHEMA_ARRAY_KEYS.has(key) && Array.isArray(nested))
+        normalized[key] = nested.map(normalize);
+      else if (SCHEMA_VALUE_KEYS.has(key) && isSchemaObject(nested))
+        normalized[key] = normalize(nested);
+      else if (key === "dependencies" && isSchemaObject(nested))
+        normalized[key] = Object.fromEntries(
+          Object.entries(nested).map(([name, child]) => [
+            name,
+            isSchemaObject(child) ? normalize(child) : child
+          ])
+        );
+    }
+    return normalized;
+  };
+  return normalize(schema);
+};
+var toResponseHeaders = (schema, vendors, openapiVersion = "3.1.2") => {
+  if (!schema || typeof schema === "string" || !("headers" in schema) || !schema.headers)
+    return;
+  const entries = Object.entries(
+    schema.headers
+  ).map(
+    ([name, hs]) => [
+      name,
+      {
+        schema: unwrapSchema(
+          hs,
+          vendors,
+          "output",
+          openapiVersion
+        )
+      }
+    ]
+  ).filter(([, v]) => v.schema);
+  return entries.length ? Object.fromEntries(entries) : void 0;
+};
+var stripHeaders = (schema) => {
+  const { headers, ...rest } = schema;
+  return rest;
+};
+var VOID_TYPES = /* @__PURE__ */ new Set(["void", "null", "undefined"]);
+var PLAIN_TYPES = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean"]);
+var toResponseContent = (schema, type, description) => VOID_TYPES.has(type) ? { type, description } : PLAIN_TYPES.has(type) ? { "text/plain": { schema } } : { "application/json": { schema } };
+var toResponseObject = (schema, status, definitions, vendors, openapiVersion = "3.1.2") => {
+  const response = unwrapSchema(schema, vendors, "output", openapiVersion);
+  if (!response) return;
+  const responseSchema = stripHeaders(response);
+  const { type, description } = unwrapReference(
+    responseSchema,
+    definitions,
+    openapiVersion
+  );
+  const headers = toResponseHeaders(schema, vendors, openapiVersion);
+  return {
+    description: description ?? `Response for status ${status}`,
+    ...headers ? { headers } : {},
+    content: toResponseContent(responseSchema, type, description)
+  };
+};
+function toOpenAPISchema(app, exclude, references, vendors, openapiVersion = "3.1.2") {
   let {
     methods: excludeMethods = ["options"],
     staticFile: excludeStaticFile = true,
@@ -434,11 +618,19 @@ function toOpenAPISchema(app, exclude, references, vendors) {
       if (typeof reference === "function") references[i] = reference();
     }
   }
-  const routes = flattenRoutes(app.getGlobalRoutes(), vendors);
+  const routes = flattenRoutes(app.getGlobalRoutes(), vendors, openapiVersion);
   for (const route of routes) {
     if (route.hooks?.detail?.hide) continue;
     const method = route.method.toLowerCase();
-    if (excludeStaticFile && route.path.includes(".") || excludePaths.includes(route.path) || excludeMethods.includes(method))
+    if (excludeStaticFile && route.path.includes(".") || excludePaths.some((exclusion) => {
+      if (exclusion instanceof RegExp) {
+        exclusion.lastIndex = 0;
+        return exclusion.test(route.path);
+      }
+      if (typeof exclusion === "string")
+        return exclusion === route.path;
+      return false;
+    }) || excludeMethods.includes(method))
       continue;
     const hooks = route.hooks ?? {};
     if (references?.length)
@@ -484,8 +676,9 @@ function toOpenAPISchema(app, exclude, references, vendors) {
     const parameters = [];
     if (hooks.params) {
       const params = unwrapReference(
-        unwrapSchema(hooks.params, vendors),
-        definitions
+        unwrapSchema(hooks.params, vendors, "input", openapiVersion),
+        definitions,
+        openapiVersion
       );
       if (params && params.type === "object" && params.properties)
         for (const [name, schema] of Object.entries(params.properties))
@@ -509,8 +702,9 @@ function toOpenAPISchema(app, exclude, references, vendors) {
     }
     if (hooks.query) {
       const query = unwrapReference(
-        unwrapSchema(hooks.query, vendors),
-        definitions
+        unwrapSchema(hooks.query, vendors, "input", openapiVersion),
+        definitions,
+        openapiVersion
       );
       if (query && query.type === "object" && query.properties) {
         const required = query.required || [];
@@ -525,8 +719,9 @@ function toOpenAPISchema(app, exclude, references, vendors) {
     }
     if (hooks.headers) {
       const headers = unwrapReference(
-        unwrapSchema(hooks.headers, vendors),
-        definitions
+        unwrapSchema(hooks.headers, vendors, "input", openapiVersion),
+        definitions,
+        openapiVersion
       );
       if (headers && headers.type === "object" && headers.properties) {
         const required = headers.required || [];
@@ -541,8 +736,9 @@ function toOpenAPISchema(app, exclude, references, vendors) {
     }
     if (hooks.cookie) {
       const cookie = unwrapReference(
-        unwrapSchema(hooks.cookie, vendors),
-        definitions
+        unwrapSchema(hooks.cookie, vendors, "input", openapiVersion),
+        definitions,
+        openapiVersion
       );
       if (cookie && cookie.type === "object" && cookie.properties) {
         const required = cookie.required || [];
@@ -557,11 +753,17 @@ function toOpenAPISchema(app, exclude, references, vendors) {
     }
     if (parameters.length > 0) operation.parameters = parameters;
     if (hooks.body && method !== "get" && method !== "head") {
-      const body = unwrapSchema(hooks.body, vendors);
+      const body = unwrapSchema(
+        hooks.body,
+        vendors,
+        "input",
+        openapiVersion
+      );
       if (body) {
         const { type, description, $ref, ...options } = unwrapReference(
           body,
-          definitions
+          definitions,
+          openapiVersion
         );
         if (hooks.parse) {
           const content = {};
@@ -589,6 +791,12 @@ function toOpenAPISchema(app, exclude, references, vendors) {
                   schema: body
                 };
                 continue;
+              case "arrayBuffer":
+              case "application/octet-stream":
+                content["application/octet-stream"] = {
+                  schema: body
+                };
+                continue;
             }
           }
           operation.requestBody = {
@@ -622,50 +830,26 @@ function toOpenAPISchema(app, exclude, references, vendors) {
     if (hooks.response) {
       operation.responses = {};
       if (typeof hooks.response === "object" && // TypeBox
-      !hooks.response.type && !hooks.response.$ref && !hooks.response["~standard"]) {
+      !(import_typebox.Kind in hooks.response) && !hooks.response.type && !hooks.response.$ref && !hooks.response["~standard"]) {
         for (let [status, schema] of Object.entries(hooks.response)) {
-          const response = unwrapSchema(schema, vendors, "output");
-          if (!response) continue;
-          const { type, description, $ref, ..._options } = unwrapReference(response, definitions);
-          operation.responses[status] = {
-            description: description ?? `Response for status ${status}`,
-            content: type === "void" || type === "null" || type === "undefined" ? { type, description } : type === "string" || type === "number" || type === "integer" || type === "boolean" ? {
-              "text/plain": {
-                schema: response
-              }
-            } : {
-              "application/json": {
-                schema: response
-              }
-            }
-          };
+          const response = toResponseObject(
+            schema,
+            status,
+            definitions,
+            vendors,
+            openapiVersion
+          );
+          if (response) operation.responses[status] = response;
         }
       } else {
-        const response = unwrapSchema(
+        const response = toResponseObject(
           hooks.response,
+          "200",
+          definitions,
           vendors,
-          "output"
+          openapiVersion
         );
-        if (response) {
-          const {
-            type: _type,
-            description,
-            ...options
-          } = unwrapReference(response, definitions);
-          const type = _type;
-          operation.responses["200"] = {
-            description: description ?? `Response for status 200`,
-            content: type === "void" || type === "null" || type === "undefined" ? { type, description } : type === "string" || type === "number" || type === "integer" || type === "boolean" ? {
-              "text/plain": {
-                schema: response
-              }
-            } : {
-              "application/json": {
-                schema: response
-              }
-            }
-          };
-        }
+        if (response) operation.responses["200"] = response;
       }
     }
     for (let path of getPossiblePath(route.path)) {
@@ -699,7 +883,12 @@ function toOpenAPISchema(app, exclude, references, vendors) {
   const schemas = /* @__PURE__ */ Object.create(null);
   if (definitions)
     for (const [name, schema] of Object.entries(definitions)) {
-      const jsonSchema = unwrapSchema(schema, vendors);
+      const jsonSchema = unwrapSchema(
+        schema,
+        vendors,
+        "input",
+        openapiVersion
+      );
       if (jsonSchema) schemas[name] = jsonSchema;
     }
   return {
@@ -709,15 +898,26 @@ function toOpenAPISchema(app, exclude, references, vendors) {
     paths
   };
 }
-var withHeaders = (schema, headers) => Object.assign(schema, {
-  headers
-});
+var withHeaders = (schema, headers) => {
+  const clone = Object.create(
+    Object.getPrototypeOf(schema),
+    Object.getOwnPropertyDescriptors(schema)
+  );
+  Object.defineProperty(clone, "headers", {
+    value: headers,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+  return clone;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   capitalize,
   enumToOpenApi,
   getLoosePath,
   getPossiblePath,
+  nullToOpenApi,
   toOpenAPISchema,
   unwrapSchema,
   withHeaders