@alt-stack/zod-openapi 1.0.1

package/dist/index.js

@@ -0,0 +1,860 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SUPPORTED_STRING_FORMATS: () => SUPPORTED_STRING_FORMATS,
+  clearZodSchemaToOpenApiSchemaRegistry: () => clearZodSchemaToOpenApiSchemaRegistry,
+  convertSchemaToZodString: () => convertSchemaToZodString,
+  generateRouteSchemaNames: () => generateRouteSchemaNames,
+  getSchemaExportedVariableNameForStringFormat: () => getSchemaExportedVariableNameForStringFormat,
+  openApiToZodTsCode: () => openApiToZodTsCode,
+  parseOpenApiPaths: () => parseOpenApiPaths,
+  registerZodSchemaToOpenApiSchema: () => registerZodSchemaToOpenApiSchema,
+  schemaRegistry: () => schemaRegistry
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/dependencies.ts
+function extractSchemaDependencies(schema) {
+  const dependencies = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new WeakSet();
+  function traverse(obj) {
+    if (!obj || typeof obj !== "object") return;
+    if (visited.has(obj)) return;
+    visited.add(obj);
+    if (obj["$ref"] && typeof obj["$ref"] === "string") {
+      const match = obj["$ref"].match(
+        /#\/components\/schemas\/(.+)/
+      );
+      if (match && match[1]) {
+        dependencies.add(decodeURIComponent(match[1]));
+      }
+      return;
+    }
+    if (Array.isArray(obj)) {
+      obj.forEach(traverse);
+      return;
+    }
+    if (obj.properties && typeof obj.properties === "object") {
+      for (const propValue of Object.values(obj.properties)) {
+        traverse(propValue);
+      }
+    }
+    const schemaKeys = [
+      "items",
+      "oneOf",
+      "allOf",
+      "anyOf",
+      "not",
+      "if",
+      "then",
+      "else",
+      "prefixItems",
+      "contains",
+      "propertyNames",
+      "dependentSchemas"
+    ];
+    for (const key of schemaKeys) {
+      if (obj[key]) {
+        traverse(obj[key]);
+      }
+    }
+    if (obj.additionalProperties && typeof obj.additionalProperties === "object") {
+      traverse(obj.additionalProperties);
+    }
+    if (obj.discriminator?.mapping) {
+      Object.values(obj.discriminator.mapping).forEach(traverse);
+    }
+  }
+  traverse(schema);
+  return Array.from(dependencies);
+}
+function topologicalSortSchemas(schemas) {
+  const schemaNames = Object.keys(schemas);
+  const dependencies = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  const sorted = [];
+  const queue = [];
+  const dependents = /* @__PURE__ */ new Map();
+  for (const name of schemaNames) {
+    dependencies.set(name, []);
+    dependents.set(name, []);
+    inDegree.set(name, 0);
+  }
+  for (const name of schemaNames) {
+    const schemaValue = schemas[name];
+    if (schemaValue) {
+      const deps = extractSchemaDependencies(schemaValue);
+      const validDeps = deps.filter((dep) => schemaNames.includes(dep));
+      dependencies.set(name, validDeps);
+      for (const dep of validDeps) {
+        const currentDependents = dependents.get(dep) || [];
+        currentDependents.push(name);
+        dependents.set(dep, currentDependents);
+      }
+    }
+  }
+  for (const [name, deps] of dependencies.entries()) {
+    inDegree.set(name, deps.length);
+  }
+  for (const [name, degree] of inDegree.entries()) {
+    if (degree === 0) {
+      queue.push(name);
+    }
+  }
+  while (queue.length > 0) {
+    const current = queue.shift();
+    sorted.push(current);
+    const currentDependents = dependents.get(current) || [];
+    for (const dependent of currentDependents) {
+      const newDegree = (inDegree.get(dependent) || 0) - 1;
+      inDegree.set(dependent, newDegree);
+      if (newDegree === 0) {
+        queue.push(dependent);
+      }
+    }
+  }
+  if (sorted.length !== schemaNames.length) {
+    for (const name of schemaNames) {
+      if (!sorted.includes(name)) {
+        sorted.push(name);
+      }
+    }
+  }
+  return sorted;
+}
+
+// src/types/boolean.ts
+function convertOpenAPIBooleanToZod(_) {
+  return "z.boolean()";
+}
+
+// src/types/number.ts
+function convertOpenAPINumberToZod(schema) {
+  let result = "z.number()";
+  if (schema.type === "integer") {
+    result += ".int()";
+  }
+  if (typeof schema.minimum === "number") {
+    result += `.min(${schema.minimum})`;
+  }
+  if (typeof schema.maximum === "number") {
+    result += `.max(${schema.maximum})`;
+  }
+  return result;
+}
+
+// src/registry.ts
+var SUPPORTED_STRING_FORMATS_MAP = {
+  "color-hex": 1,
+  date: 1,
+  "date-time": 1,
+  email: 1,
+  "iso-date": 1,
+  "iso-date-time": 1,
+  objectid: 1,
+  uri: 1,
+  url: 1,
+  uuid: 1
+};
+var SUPPORTED_STRING_FORMATS = Object.keys(
+  SUPPORTED_STRING_FORMATS_MAP
+);
+function isStringRegistration(reg) {
+  return reg.type === "string" && "format" in reg;
+}
+function isStringsRegistration(reg) {
+  return reg.type === "string" && "formats" in reg;
+}
+function getTypeFormatPairs(reg) {
+  if (isStringRegistration(reg)) {
+    return [{ type: "string", format: reg.format }];
+  }
+  if (isStringsRegistration(reg)) {
+    return reg.formats.map((f) => ({ type: "string", format: f }));
+  }
+  return [];
+}
+var ZodSchemaRegistry = class {
+  map = /* @__PURE__ */ new Map();
+  register(schema, registration) {
+    const newPairs = getTypeFormatPairs(registration);
+    if (newPairs.length > 0) {
+      for (const [existingSchema, existingRegistration] of this.map.entries()) {
+        if (existingSchema === schema) continue;
+        const existingPairs = getTypeFormatPairs(existingRegistration);
+        for (const { type, format } of newPairs) {
+          if (existingPairs.some((p) => p.type === type && p.format === format)) {
+            throw new Error(
+              `duplicate Zod OpenAPI registration for (type, format)=('${type}', '${format}')`
+            );
+          }
+        }
+      }
+    }
+    this.map.set(schema, registration);
+  }
+  /**
+   * Get the OpenAPI schema for a given Zod schema
+   */
+  getOpenApiSchema(schema) {
+    return this.map.get(schema);
+  }
+  /**
+   * Check if a Zod schema is registered
+   */
+  isRegistered(schema) {
+    return this.map.has(schema);
+  }
+  /**
+   * Clear all registered schemas
+   */
+  clear() {
+    this.map.clear();
+  }
+  /**
+   * Reverse-lookup helper: given a string format, return the registered schema's exported variable name
+   */
+  getSchemaExportedVariableNameForStringFormat(format) {
+    for (const registration of this.map.values()) {
+      if (registration.type !== "string") continue;
+      if (isStringRegistration(registration) && registration.format === format) {
+        return registration.schemaExportedVariableName;
+      }
+      if (isStringsRegistration(registration) && registration.formats.includes(format)) {
+        return registration.schemaExportedVariableName;
+      }
+    }
+    return void 0;
+  }
+};
+var schemaRegistry = new ZodSchemaRegistry();
+function registerZodSchemaToOpenApiSchema(schema, openApiSchema) {
+  schemaRegistry.register(schema, openApiSchema);
+}
+function getSchemaExportedVariableNameForStringFormat(format) {
+  return schemaRegistry.getSchemaExportedVariableNameForStringFormat(format);
+}
+function clearZodSchemaToOpenApiSchemaRegistry() {
+  schemaRegistry.clear();
+}
+
+// src/types/string.ts
+function convertOpenAPIStringToZod(schema) {
+  if (schema.enum) {
+    return `z.enum([${schema.enum.map((value) => `'${value}'`).join(", ")}])`;
+  }
+  if (schema.format && SUPPORTED_STRING_FORMATS.includes(schema.format)) {
+    const customSchemaName = getSchemaExportedVariableNameForStringFormat(
+      schema.format
+    );
+    if (customSchemaName) {
+      return customSchemaName;
+    }
+  }
+  let zodSchema = "z.string()";
+  if (schema.format) {
+    zodSchema += getFormatModifier(schema.format);
+  }
+  if (typeof schema.minLength === "number") {
+    zodSchema += `.min(${schema.minLength})`;
+  }
+  if (typeof schema.maxLength === "number") {
+    zodSchema += `.max(${schema.maxLength})`;
+  }
+  if (typeof schema.pattern === "string") {
+    zodSchema += `.regex(/${schema.pattern}/)`;
+  }
+  return zodSchema;
+}
+function getFormatModifier(format) {
+  switch (format) {
+    case "email":
+      return ".email()";
+    case "url":
+    case "uri":
+      return ".url()";
+    case "uuid":
+      return ".uuid()";
+    case "color-hex":
+      return ".regex(/^[a-fA-F0-9]{6}$/)";
+    default:
+      return "";
+  }
+}
+
+// src/types/array.ts
+function convertOpenAPIArrayToZod(schema, convertSchema) {
+  const item = schema.items;
+  let itemZodString = "z.unknown()";
+  if (item && typeof item === "object") {
+    itemZodString = convertSchema(item);
+  }
+  let result = `z.array(${itemZodString})`;
+  if (typeof schema.minItems === "number") {
+    result += `.min(${schema.minItems})`;
+  }
+  if (typeof schema.maxItems === "number") {
+    result += `.max(${schema.maxItems})`;
+  }
+  return result;
+}
+
+// src/types/object.ts
+function convertOpenAPIObjectToZod(schema, convertSchema) {
+  const properties = schema.properties || {};
+  const propertyNames = Object.keys(properties);
+  if (propertyNames.length === 0) {
+    if (schema.additionalProperties === false) {
+      return "z.object({}).strict()";
+    }
+    return "z.record(z.string(), z.unknown())";
+  }
+  const requiredSet = new Set(schema.required || []);
+  const entries = [];
+  for (const [propName, propSchema] of Object.entries(properties)) {
+    let zodProp = "z.unknown()";
+    if (propSchema && typeof propSchema === "object") {
+      zodProp = convertSchema(propSchema);
+    }
+    if (!requiredSet.has(propName)) {
+      zodProp += ".optional()";
+    }
+    entries.push(`${propName}: ${zodProp}`);
+  }
+  let result = `z.object({ ${entries.join(", ")} })`;
+  if (schema.additionalProperties === false) {
+    result += ".strict()";
+  }
+  return result;
+}
+
+// src/types/union.ts
+function convertOpenAPIUnionToZod(schema, convertSchema) {
+  const items = schema.oneOf.map((item) => convertSchema(item));
+  return `z.union([${items.join(", ")}])`;
+}
+
+// src/types/intersection.ts
+function convertOpenAPIIntersectionToZod(schema, convertSchema) {
+  const items = schema.allOf.map((item) => convertSchema(item));
+  if (schema.allOf.length === 0) return "z.unknown()";
+  if (schema.allOf.length === 1) return convertSchema(schema.allOf[0]);
+  return `z.intersection(${items.join(", ")})`;
+}
+
+// src/to-zod.ts
+function convertSchemaToZodString(schema) {
+  if (!schema || typeof schema !== "object") return "z.unknown()";
+  if (schema["$ref"] && typeof schema["$ref"] === "string") {
+    const match = schema["$ref"].match(
+      /#\/components\/schemas\/(.+)/
+    );
+    let result2 = "z.unknown()";
+    if (match && match[1]) {
+      result2 = `${match[1]}Schema`;
+    }
+    if (schema["nullable"] === true) {
+      result2 = `z.union([${result2}, z.null()])`;
+    }
+    return result2;
+  }
+  let result = "z.unknown()";
+  if ("oneOf" in schema && Array.isArray(schema["oneOf"])) {
+    result = convertOpenAPIUnionToZod(
+      schema,
+      convertSchemaToZodString
+    );
+  } else if ("allOf" in schema && Array.isArray(schema["allOf"])) {
+    result = convertOpenAPIIntersectionToZod(
+      schema,
+      convertSchemaToZodString
+    );
+  } else {
+    switch (schema["type"]) {
+      case "string":
+        result = convertOpenAPIStringToZod({
+          enum: schema["enum"],
+          format: schema["format"],
+          maxLength: schema["maxLength"],
+          minLength: schema["minLength"],
+          pattern: schema["pattern"],
+          type: "string"
+        });
+        break;
+      case "number":
+        result = convertOpenAPINumberToZod({
+          maximum: schema["maximum"],
+          minimum: schema["minimum"],
+          type: "number"
+        });
+        break;
+      case "integer":
+        result = convertOpenAPINumberToZod({
+          maximum: schema["maximum"],
+          minimum: schema["minimum"],
+          type: "integer"
+        });
+        break;
+      case "boolean":
+        result = convertOpenAPIBooleanToZod({ type: "boolean" });
+        break;
+      case "array":
+        result = convertOpenAPIArrayToZod(
+          {
+            items: schema["items"],
+            maxItems: schema["maxItems"],
+            minItems: schema["minItems"],
+            type: "array"
+          },
+          convertSchemaToZodString
+        );
+        break;
+      case "object":
+        result = convertOpenAPIObjectToZod(
+          {
+            additionalProperties: schema["additionalProperties"],
+            properties: schema["properties"],
+            required: schema["required"],
+            type: "object"
+          },
+          convertSchemaToZodString
+        );
+        break;
+      default:
+        if (schema["properties"]) {
+          result = convertOpenAPIObjectToZod(
+            {
+              additionalProperties: schema["additionalProperties"],
+              properties: schema["properties"],
+              required: schema["required"],
+              type: "object"
+            },
+            convertSchemaToZodString
+          );
+        } else {
+          result = "z.unknown()";
+        }
+        break;
+    }
+  }
+  if (schema["nullable"] === true) {
+    result = `z.union([${result}, z.null()])`;
+  }
+  return result;
+}
+
+// src/routes.ts
+function toUpperCaseMethod(method) {
+  const upper = method.toUpperCase();
+  if (upper === "GET" || upper === "POST" || upper === "PUT" || upper === "PATCH" || upper === "DELETE" || upper === "HEAD" || upper === "OPTIONS") {
+    return upper;
+  }
+  return "GET";
+}
+function toPascalCase(str) {
+  return str.replace(/[^a-zA-Z0-9]/g, " ").split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function generateRouteSchemaName(path, method, suffix) {
+  const pathParts = path.split("/").filter((p) => p).map((p) => {
+    if (p.startsWith("{") && p.endsWith("}")) {
+      return p.slice(1, -1);
+    }
+    return p;
+  }).map(toPascalCase);
+  const methodPrefix = method.charAt(0) + method.slice(1).toLowerCase();
+  const parts = [methodPrefix, ...pathParts, suffix];
+  return parts.join("");
+}
+function parseOpenApiPaths(openapi) {
+  const paths = openapi["paths"];
+  if (!paths) {
+    return [];
+  }
+  const routes = [];
+  for (const [path, pathItem] of Object.entries(paths)) {
+    if (!pathItem || typeof pathItem !== "object") continue;
+    const methods = [
+      "get",
+      "post",
+      "put",
+      "patch",
+      "delete",
+      "head",
+      "options"
+    ];
+    for (const method of methods) {
+      const operation = pathItem[method];
+      if (!operation) continue;
+      const parameters = [];
+      const responses = {};
+      if (Array.isArray(pathItem["parameters"])) {
+        for (const param of pathItem["parameters"]) {
+          if (param && typeof param === "object") {
+            parameters.push({
+              name: String(param["name"] || ""),
+              in: param["in"] || "query",
+              required: Boolean(param["required"]),
+              schema: param["schema"] || {}
+            });
+          }
+        }
+      }
+      if (Array.isArray(operation["parameters"])) {
+        for (const param of operation["parameters"]) {
+          if (param && typeof param === "object") {
+            parameters.push({
+              name: String(param["name"] || ""),
+              in: param["in"] || "query",
+              required: Boolean(param["required"]),
+              schema: param["schema"] || {}
+            });
+          }
+        }
+      }
+      let requestBody;
+      if (operation["requestBody"]) {
+        const rb = operation["requestBody"];
+        if (rb && typeof rb === "object") {
+          const content = rb["content"];
+          if (content && typeof content === "object") {
+            const jsonContent = content["application/json"];
+            if (jsonContent && typeof jsonContent === "object") {
+              requestBody = jsonContent["schema"] || {};
+            }
+          }
+        }
+      }
+      if (operation["responses"] && typeof operation["responses"] === "object") {
+        for (const [statusCode, response] of Object.entries(
+          operation["responses"]
+        )) {
+          if (response && typeof response === "object") {
+            const responseSchema = response;
+            const content = responseSchema["content"];
+            if (content && typeof content === "object") {
+              const jsonContent = content["application/json"];
+              if (jsonContent && typeof jsonContent === "object") {
+                const schema = jsonContent["schema"];
+                if (schema) {
+                  responses[statusCode] = schema;
+                }
+              }
+            }
+          }
+        }
+      }
+      routes.push({
+        path,
+        method: toUpperCaseMethod(method),
+        parameters,
+        requestBody,
+        responses
+      });
+    }
+  }
+  return routes;
+}
+function generateRouteSchemaNames(route) {
+  const pathParams = route.parameters.filter((p) => p.in === "path");
+  const queryParams = route.parameters.filter((p) => p.in === "query");
+  const headerParams = route.parameters.filter((p) => p.in === "header");
+  const successStatuses = Object.keys(route.responses).filter(
+    (s) => s.startsWith("2")
+  );
+  const result = {
+    responseSchemaName: successStatuses.length > 0 ? generateRouteSchemaName(
+      route.path,
+      route.method,
+      "Response"
+    ) : void 0
+  };
+  if (pathParams.length > 0) {
+    result.paramsSchemaName = generateRouteSchemaName(
+      route.path,
+      route.method,
+      "Params"
+    );
+  }
+  if (queryParams.length > 0) {
+    result.querySchemaName = generateRouteSchemaName(
+      route.path,
+      route.method,
+      "Query"
+    );
+  }
+  if (headerParams.length > 0) {
+    result.headersSchemaName = generateRouteSchemaName(
+      route.path,
+      route.method,
+      "Headers"
+    );
+  }
+  if (route.requestBody) {
+    result.bodySchemaName = generateRouteSchemaName(
+      route.path,
+      route.method,
+      "Body"
+    );
+  }
+  return result;
+}
+
+// src/to-typescript.ts
+function generateRouteSchemaName2(path, method, suffix) {
+  const pathParts = path.split("/").filter((p) => p).map((p) => {
+    if (p.startsWith("{") && p.endsWith("}")) {
+      return p.slice(1, -1);
+    }
+    return p;
+  }).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());
+  const methodPrefix = method.charAt(0) + method.slice(1).toLowerCase();
+  const parts = [methodPrefix, ...pathParts, suffix];
+  return parts.join("");
+}
+function generateRouteSchemas(routes, convertSchema) {
+  const lines = [];
+  const schemaNames = /* @__PURE__ */ new Set();
+  for (const route of routes) {
+    const names = generateRouteSchemaNames(route);
+    const pathParams = route.parameters.filter((p) => p.in === "path");
+    const queryParams = route.parameters.filter((p) => p.in === "query");
+    const headerParams = route.parameters.filter((p) => p.in === "header");
+    if (names.paramsSchemaName && pathParams.length > 0) {
+      if (!schemaNames.has(names.paramsSchemaName)) {
+        schemaNames.add(names.paramsSchemaName);
+        const properties = [];
+        const required = [];
+        for (const param of pathParams) {
+          const zodExpr = convertSchema(param.schema);
+          properties.push(`${param.name}: ${zodExpr}`);
+          if (param.required) {
+            required.push(param.name);
+          }
+        }
+        lines.push(
+          `export const ${names.paramsSchemaName} = z.object({ ${properties.join(", ")} });`
+        );
+      }
+    }
+    if (names.querySchemaName && queryParams.length > 0) {
+      if (!schemaNames.has(names.querySchemaName)) {
+        schemaNames.add(names.querySchemaName);
+        const properties = [];
+        for (const param of queryParams) {
+          let zodExpr = convertSchema(param.schema);
+          if (!param.required) {
+            zodExpr += ".optional()";
+          }
+          properties.push(`${param.name}: ${zodExpr}`);
+        }
+        lines.push(
+          `export const ${names.querySchemaName} = z.object({ ${properties.join(", ")} });`
+        );
+      }
+    }
+    if (names.headersSchemaName && headerParams.length > 0) {
+      if (!schemaNames.has(names.headersSchemaName)) {
+        schemaNames.add(names.headersSchemaName);
+        const properties = [];
+        for (const param of headerParams) {
+          let zodExpr = convertSchema(param.schema);
+          if (!param.required) {
+            zodExpr += ".optional()";
+          }
+          properties.push(`${param.name}: ${zodExpr}`);
+        }
+        lines.push(
+          `export const ${names.headersSchemaName} = z.object({ ${properties.join(", ")} });`
+        );
+      }
+    }
+    if (names.bodySchemaName && route.requestBody) {
+      if (!schemaNames.has(names.bodySchemaName)) {
+        schemaNames.add(names.bodySchemaName);
+        const zodExpr = convertSchema(route.requestBody);
+        lines.push(`export const ${names.bodySchemaName} = ${zodExpr};`);
+      }
+    }
+    for (const [statusCode, responseSchema] of Object.entries(
+      route.responses
+    )) {
+      if (!responseSchema) continue;
+      const isSuccess = statusCode.startsWith("2");
+      const suffix = isSuccess ? `${statusCode}Response` : `${statusCode}ErrorResponse`;
+      const responseSchemaName = generateRouteSchemaName2(
+        route.path,
+        route.method,
+        suffix
+      );
+      if (!schemaNames.has(responseSchemaName)) {
+        schemaNames.add(responseSchemaName);
+        const zodExpr = convertSchema(responseSchema);
+        lines.push(`export const ${responseSchemaName} = ${zodExpr};`);
+      }
+    }
+  }
+  return lines;
+}
+function generateRequestResponseObjects(routes) {
+  const lines = [];
+  const requestPaths = {};
+  const responsePaths = {};
+  for (const route of routes) {
+    const names = generateRouteSchemaNames(route);
+    const pathParams = route.parameters.filter((p) => p.in === "path");
+    const queryParams = route.parameters.filter((p) => p.in === "query");
+    const headerParams = route.parameters.filter((p) => p.in === "header");
+    if (!requestPaths[route.path]) {
+      requestPaths[route.path] = {};
+    }
+    const requestMethodObj = requestPaths[route.path];
+    if (!requestMethodObj[route.method]) {
+      requestMethodObj[route.method] = [];
+    }
+    const requestParts = [];
+    if (names.paramsSchemaName && pathParams.length > 0) {
+      requestParts.push(`params: ${names.paramsSchemaName}`);
+    }
+    if (names.querySchemaName && queryParams.length > 0) {
+      requestParts.push(`query: ${names.querySchemaName}`);
+    }
+    if (names.headersSchemaName && headerParams.length > 0) {
+      requestParts.push(`headers: ${names.headersSchemaName}`);
+    }
+    if (names.bodySchemaName && route.requestBody) {
+      requestParts.push(`body: ${names.bodySchemaName}`);
+    }
+    if (requestParts.length > 0) {
+      requestMethodObj[route.method] = requestParts;
+    }
+    if (!responsePaths[route.path]) {
+      responsePaths[route.path] = {};
+    }
+    const responseMethodObj = responsePaths[route.path];
+    if (!responseMethodObj[route.method]) {
+      responseMethodObj[route.method] = {};
+    }
+    for (const [statusCode, responseSchema] of Object.entries(
+      route.responses
+    )) {
+      if (!responseSchema) continue;
+      const isSuccess = statusCode.startsWith("2");
+      const suffix = isSuccess ? `${statusCode}Response` : `${statusCode}ErrorResponse`;
+      const responseSchemaName = generateRouteSchemaName2(
+        route.path,
+        route.method,
+        suffix
+      );
+      responseMethodObj[route.method][statusCode] = responseSchemaName;
+    }
+  }
+  lines.push("export const Request = {");
+  for (const [path, methods] of Object.entries(requestPaths)) {
+    const methodEntries = Object.entries(methods).filter(
+      ([, parts]) => parts.length > 0
+    );
+    if (methodEntries.length > 0) {
+      lines.push(`  '${path}': {`);
+      for (const [method, parts] of methodEntries) {
+        lines.push(`    ${method}: {`);
+        for (const part of parts) {
+          lines.push(`      ${part},`);
+        }
+        lines.push(`    },`);
+      }
+      lines.push(`  },`);
+    }
+  }
+  lines.push("} as const;");
+  lines.push("");
+  lines.push("export const Response = {");
+  for (const [path, methods] of Object.entries(responsePaths)) {
+    const methodEntries = Object.entries(methods);
+    if (methodEntries.length > 0) {
+      lines.push(`  '${path}': {`);
+      for (const [method, statusCodes] of methodEntries) {
+        lines.push(`    ${method}: {`);
+        for (const [statusCode, schemaName] of Object.entries(statusCodes)) {
+          lines.push(`      '${statusCode}': ${schemaName},`);
+        }
+        lines.push(`    },`);
+      }
+      lines.push(`  },`);
+    }
+  }
+  lines.push("} as const;");
+  return lines;
+}
+var openApiToZodTsCode = (openapi, customImportLines, options) => {
+  const components = openapi["components"];
+  const schemas = components?.["schemas"] ?? {};
+  const lines = [];
+  lines.push("/**");
+  lines.push(" * This file was automatically generated from OpenAPI schema");
+  lines.push(" * Do not manually edit this file");
+  lines.push(" */");
+  lines.push("");
+  lines.push("import { z } from 'zod';");
+  lines.push(...customImportLines ?? []);
+  lines.push("");
+  const sortedSchemaNames = topologicalSortSchemas(schemas);
+  for (const name of sortedSchemaNames) {
+    const schema = schemas[name];
+    if (schema) {
+      const zodExpr = convertSchemaToZodString(schema);
+      const schemaName = `${name}Schema`;
+      const typeName = name;
+      lines.push(`export const ${schemaName} = ${zodExpr};`);
+      lines.push(`export type ${typeName} = z.infer<typeof ${schemaName}>;`);
+      lines.push("");
+    }
+  }
+  if (options?.includeRoutes) {
+    const routes = parseOpenApiPaths(openapi);
+    if (routes.length > 0) {
+      const routeSchemas = generateRouteSchemas(
+        routes,
+        convertSchemaToZodString
+      );
+      if (routeSchemas.length > 0) {
+        lines.push(...routeSchemas);
+        lines.push("");
+        const requestResponseObjs = generateRequestResponseObjects(routes);
+        lines.push(...requestResponseObjs);
+      }
+    }
+  }
+  return lines.join("\n");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SUPPORTED_STRING_FORMATS,
+  clearZodSchemaToOpenApiSchemaRegistry,
+  convertSchemaToZodString,
+  generateRouteSchemaNames,
+  getSchemaExportedVariableNameForStringFormat,
+  openApiToZodTsCode,
+  parseOpenApiPaths,
+  registerZodSchemaToOpenApiSchema,
+  schemaRegistry
+});
+//# sourceMappingURL=index.js.map