@alt-stack/zod-openapi 1.1.2 → 1.2.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @alt-stack/zod-openapi@1.1.2 build /home/runner/work/alt-stack/alt-stack/packages/zod-openapi
+> @alt-stack/zod-openapi@1.2.0 build /home/runner/work/alt-stack/alt-stack/packages/zod-openapi
 > tsup
 
 CLI Building entry: src/index.ts
@@ -10,13 +10,13 @@
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs     26.95 KB
-CJS dist/index.cjs.map 55.60 KB
-CJS ⚡️ Build success in 31ms
-ESM dist/index.js     25.41 KB
-ESM dist/index.js.map 54.74 KB
-ESM ⚡️ Build success in 31ms
+ESM dist/index.js     38.35 KB
+ESM dist/index.js.map 84.13 KB
+ESM ⚡️ Build success in 32ms
+CJS dist/index.cjs     39.98 KB
+CJS dist/index.cjs.map 85.09 KB
+CJS ⚡️ Build success in 33ms
 DTS Build start
-DTS ⚡️ Build success in 1417ms
-DTS dist/index.d.ts  4.83 KB
-DTS dist/index.d.cts 4.83 KB
+DTS ⚡️ Build success in 1497ms
+DTS dist/index.d.ts  5.68 KB
+DTS dist/index.d.cts 5.68 KB

package/dist/index.cjs

@@ -23,12 +23,14 @@ __export(index_exports, {
   SUPPORTED_STRING_FORMATS: () => SUPPORTED_STRING_FORMATS,
   clearZodSchemaToOpenApiSchemaRegistry: () => clearZodSchemaToOpenApiSchemaRegistry,
   convertSchemaToZodString: () => convertSchemaToZodString,
+  generateInterface: () => generateInterface,
   generateRouteSchemaNames: () => generateRouteSchemaNames,
   getSchemaExportedVariableNameForStringFormat: () => getSchemaExportedVariableNameForStringFormat,
   openApiToZodTsCode: () => openApiToZodTsCode,
   parseOpenApiPaths: () => parseOpenApiPaths,
   registerZodSchemaToOpenApiSchema: () => registerZodSchemaToOpenApiSchema,
-  schemaRegistry: () => schemaRegistry
+  schemaRegistry: () => schemaRegistry,
+  schemaToTypeString: () => schemaToTypeString
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -142,6 +144,87 @@ function topologicalSortSchemas(schemas) {
   return sorted;
 }
 
+// src/schema-dedup.ts
+function sortObjectDeep(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(sortObjectDeep);
+  const sorted = {};
+  const keys = Object.keys(obj).sort();
+  for (const key of keys) {
+    sorted[key] = sortObjectDeep(obj[key]);
+  }
+  return sorted;
+}
+function getSchemaFingerprint(schema) {
+  return JSON.stringify(sortObjectDeep(schema));
+}
+function createSchemaRegistry() {
+  return {
+    fingerprintToName: /* @__PURE__ */ new Map(),
+    nameToFingerprint: /* @__PURE__ */ new Map()
+  };
+}
+function registerSchema(registry, name, schema) {
+  const fingerprint = getSchemaFingerprint(schema);
+  const existing = registry.fingerprintToName.get(fingerprint);
+  if (existing) {
+    return { isNew: false, canonicalName: existing };
+  }
+  registry.fingerprintToName.set(fingerprint, name);
+  registry.nameToFingerprint.set(name, fingerprint);
+  return { isNew: true, canonicalName: name };
+}
+function preRegisterSchema(registry, name, fingerprint) {
+  registry.fingerprintToName.set(fingerprint, name);
+  registry.nameToFingerprint.set(name, fingerprint);
+}
+function extractErrorCode(schema) {
+  const properties = schema?.["properties"];
+  const errorObj = properties?.["error"];
+  const errorProps = errorObj?.["properties"];
+  const codeSchema = errorProps?.["code"];
+  const codeEnum = codeSchema?.["enum"];
+  if (Array.isArray(codeEnum) && codeEnum.length === 1) {
+    return codeEnum[0];
+  }
+  return null;
+}
+function errorCodeToPascalCase(code) {
+  return code.split("_").map((part) => part.charAt(0) + part.slice(1).toLowerCase()).join("");
+}
+function generateCommonErrorSchemaName(errorCode) {
+  return `${errorCodeToPascalCase(errorCode)}ErrorSchema`;
+}
+function findCommonSchemas(schemas, minCount = 2) {
+  const fingerprints = /* @__PURE__ */ new Map();
+  for (const { name, schema } of schemas) {
+    const fingerprint = getSchemaFingerprint(schema);
+    const existing = fingerprints.get(fingerprint);
+    if (existing) {
+      existing.names.push(name);
+    } else {
+      fingerprints.set(fingerprint, {
+        schema,
+        names: [name],
+        errorCode: extractErrorCode(schema)
+      });
+    }
+  }
+  const commonSchemas = [];
+  for (const [fingerprint, data] of fingerprints) {
+    if (data.names.length >= minCount) {
+      const name = data.errorCode ? generateCommonErrorSchemaName(data.errorCode) : data.names[0];
+      commonSchemas.push({
+        name,
+        schema: data.schema,
+        fingerprint,
+        count: data.names.length
+      });
+    }
+  }
+  return commonSchemas.sort((a, b) => b.count - a.count);
+}
+
 // src/types/boolean.ts
 function convertOpenAPIBooleanToZod(_) {
   return "z.boolean()";
@@ -622,11 +705,150 @@ function generateRouteSchemaNames(route) {
   return result;
 }
 
-// src/to-typescript.ts
+// src/interface-generator.ts
 var validIdentifierRegex2 = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
 function quotePropertyName2(name) {
   return validIdentifierRegex2.test(name) ? name : `'${name}'`;
 }
+function schemaToTypeString(schema) {
+  if (!schema || typeof schema !== "object") return "unknown";
+  if (schema["$ref"] && typeof schema["$ref"] === "string") {
+    const match = schema["$ref"].match(
+      /#\/components\/schemas\/(.+)/
+    );
+    let result2 = "unknown";
+    if (match && match[1]) {
+      result2 = decodeURIComponent(match[1]);
+    }
+    if (schema["nullable"] === true) {
+      result2 = `(${result2} | null)`;
+    }
+    return result2;
+  }
+  let result = "unknown";
+  if ("oneOf" in schema && Array.isArray(schema["oneOf"])) {
+    const unionMembers = schema["oneOf"].map(
+      (s) => schemaToTypeString(s)
+    );
+    result = unionMembers.length > 1 ? `(${unionMembers.join(" | ")})` : unionMembers[0] ?? "unknown";
+  } else if ("allOf" in schema && Array.isArray(schema["allOf"])) {
+    const intersectionMembers = schema["allOf"].map(
+      (s) => schemaToTypeString(s)
+    );
+    result = intersectionMembers.length > 1 ? `(${intersectionMembers.join(" & ")})` : intersectionMembers[0] ?? "unknown";
+  } else if ("anyOf" in schema && Array.isArray(schema["anyOf"])) {
+    const unionMembers = schema["anyOf"].map(
+      (s) => schemaToTypeString(s)
+    );
+    result = unionMembers.length > 1 ? `(${unionMembers.join(" | ")})` : unionMembers[0] ?? "unknown";
+  } else {
+    switch (schema["type"]) {
+      case "string":
+        if (schema["enum"] && Array.isArray(schema["enum"])) {
+          result = schema["enum"].map((v) => JSON.stringify(v)).join(" | ");
+        } else {
+          result = "string";
+        }
+        break;
+      case "number":
+      case "integer":
+        if (schema["enum"] && Array.isArray(schema["enum"])) {
+          result = schema["enum"].map((v) => String(v)).join(" | ");
+        } else {
+          result = "number";
+        }
+        break;
+      case "boolean":
+        result = "boolean";
+        break;
+      case "null":
+        result = "null";
+        break;
+      case "array":
+        if (schema["items"]) {
+          const itemType = schemaToTypeString(schema["items"]);
+          result = `Array<${itemType}>`;
+        } else {
+          result = "unknown[]";
+        }
+        break;
+      case "object":
+        result = objectSchemaToTypeString(schema);
+        break;
+      default:
+        if (schema["properties"]) {
+          result = objectSchemaToTypeString(schema);
+        } else if (schema["enum"] && Array.isArray(schema["enum"])) {
+          result = schema["enum"].map((v) => JSON.stringify(v)).join(" | ");
+        } else {
+          result = "unknown";
+        }
+        break;
+    }
+  }
+  if (schema["nullable"] === true) {
+    result = `(${result} | null)`;
+  }
+  return result;
+}
+function objectSchemaToTypeString(schema) {
+  const properties = schema["properties"];
+  const required = new Set(schema["required"] ?? []);
+  const additionalProperties = schema["additionalProperties"];
+  if (!properties && !additionalProperties) {
+    return "Record<string, unknown>";
+  }
+  const propertyStrings = [];
+  if (properties) {
+    for (const [propName, propSchema] of Object.entries(properties)) {
+      const isRequired = required.has(propName);
+      const propType = schemaToTypeString(propSchema);
+      const quotedName = quotePropertyName2(propName);
+      propertyStrings.push(
+        `${quotedName}${isRequired ? "" : "?"}: ${propType}`
+      );
+    }
+  }
+  if (additionalProperties === true) {
+    propertyStrings.push("[key: string]: unknown");
+  } else if (typeof additionalProperties === "object" && additionalProperties !== null) {
+    const additionalType = schemaToTypeString(additionalProperties);
+    propertyStrings.push(`[key: string]: ${additionalType}`);
+  }
+  return `{ ${propertyStrings.join("; ")} }`;
+}
+function generateInterface(name, schema) {
+  const properties = schema["properties"];
+  const required = new Set(schema["required"] ?? []);
+  if (schema["type"] !== "object" && !properties) {
+    return `export type ${name} = ${schemaToTypeString(schema)};`;
+  }
+  const lines = [];
+  lines.push(`export interface ${name} {`);
+  if (properties) {
+    for (const [propName, propSchema] of Object.entries(properties)) {
+      const isRequired = required.has(propName);
+      const propType = schemaToTypeString(propSchema);
+      const quotedName = quotePropertyName2(propName);
+      lines.push(`  ${quotedName}${isRequired ? "" : "?"}: ${propType};`);
+    }
+  }
+  const additionalProperties = schema["additionalProperties"];
+  if (additionalProperties === true) {
+    lines.push("  [key: string]: unknown;");
+  } else if (typeof additionalProperties === "object" && additionalProperties !== null) {
+    const additionalType = schemaToTypeString(additionalProperties);
+    lines.push(`  [key: string]: ${additionalType};`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+
+// src/to-typescript.ts
+var validIdentifierRegex3 = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+function quotePropertyName3(name) {
+  return validIdentifierRegex3.test(name) ? name : `'${name}'`;
+}
 function generateRouteSchemaName2(path, method, suffix) {
   const pathParts = path.split("/").filter((p) => p).map((p) => {
     if (p.startsWith("{") && p.endsWith("}")) {
@@ -640,68 +862,138 @@ function generateRouteSchemaName2(path, method, suffix) {
   const parts = [methodPrefix, ...pathParts, suffix];
   return parts.join("");
 }
-function generateRouteSchemas(routes, convertSchema) {
-  const lines = [];
-  const schemaNames = /* @__PURE__ */ new Set();
+function generateRouteSchemas(routes, convertSchema, registry) {
+  const declarations = [];
+  const schemaNameToCanonical = /* @__PURE__ */ new Map();
+  const generatedNames = /* @__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 paramsSchema = {
+        type: "object",
+        properties: Object.fromEntries(
+          pathParams.map((p) => [p.name, p.schema])
+        ),
+        required: pathParams.filter((p) => p.required).map((p) => p.name)
+      };
+      const { isNew, canonicalName } = registerSchema(
+        registry,
+        names.paramsSchemaName,
+        paramsSchema
+      );
+      schemaNameToCanonical.set(names.paramsSchemaName, canonicalName);
+      if (isNew && !generatedNames.has(names.paramsSchemaName)) {
+        generatedNames.add(names.paramsSchemaName);
         const properties = [];
-        const required = [];
         for (const param of pathParams) {
           const zodExpr = convertSchema(param.schema);
-          properties.push(`${quotePropertyName2(param.name)}: ${zodExpr}`);
-          if (param.required) {
-            required.push(param.name);
-          }
+          properties.push(`${quotePropertyName3(param.name)}: ${zodExpr}`);
         }
-        lines.push(
+        declarations.push(
           `export const ${names.paramsSchemaName} = z.object({ ${properties.join(", ")} });`
         );
+      } else if (!isNew && names.paramsSchemaName !== canonicalName) {
+        if (!generatedNames.has(names.paramsSchemaName)) {
+          generatedNames.add(names.paramsSchemaName);
+          declarations.push(
+            `export const ${names.paramsSchemaName} = ${canonicalName};`
+          );
+        }
       }
     }
     if (names.querySchemaName && queryParams.length > 0) {
-      if (!schemaNames.has(names.querySchemaName)) {
-        schemaNames.add(names.querySchemaName);
+      const querySchema = {
+        type: "object",
+        properties: Object.fromEntries(
+          queryParams.map((p) => [p.name, p.schema])
+        ),
+        required: queryParams.filter((p) => p.required).map((p) => p.name)
+      };
+      const { isNew, canonicalName } = registerSchema(
+        registry,
+        names.querySchemaName,
+        querySchema
+      );
+      schemaNameToCanonical.set(names.querySchemaName, canonicalName);
+      if (isNew && !generatedNames.has(names.querySchemaName)) {
+        generatedNames.add(names.querySchemaName);
         const properties = [];
         for (const param of queryParams) {
           let zodExpr = convertSchema(param.schema);
           if (!param.required) {
             zodExpr += ".optional()";
           }
-          properties.push(`${quotePropertyName2(param.name)}: ${zodExpr}`);
+          properties.push(`${quotePropertyName3(param.name)}: ${zodExpr}`);
         }
-        lines.push(
+        declarations.push(
           `export const ${names.querySchemaName} = z.object({ ${properties.join(", ")} });`
         );
+      } else if (!isNew && names.querySchemaName !== canonicalName) {
+        if (!generatedNames.has(names.querySchemaName)) {
+          generatedNames.add(names.querySchemaName);
+          declarations.push(
+            `export const ${names.querySchemaName} = ${canonicalName};`
+          );
+        }
       }
     }
     if (names.headersSchemaName && headerParams.length > 0) {
-      if (!schemaNames.has(names.headersSchemaName)) {
-        schemaNames.add(names.headersSchemaName);
+      const headersSchema = {
+        type: "object",
+        properties: Object.fromEntries(
+          headerParams.map((p) => [p.name, p.schema])
+        ),
+        required: headerParams.filter((p) => p.required).map((p) => p.name)
+      };
+      const { isNew, canonicalName } = registerSchema(
+        registry,
+        names.headersSchemaName,
+        headersSchema
+      );
+      schemaNameToCanonical.set(names.headersSchemaName, canonicalName);
+      if (isNew && !generatedNames.has(names.headersSchemaName)) {
+        generatedNames.add(names.headersSchemaName);
         const properties = [];
         for (const param of headerParams) {
           let zodExpr = convertSchema(param.schema);
           if (!param.required) {
             zodExpr += ".optional()";
           }
-          properties.push(`${quotePropertyName2(param.name)}: ${zodExpr}`);
+          properties.push(`${quotePropertyName3(param.name)}: ${zodExpr}`);
         }
-        lines.push(
+        declarations.push(
           `export const ${names.headersSchemaName} = z.object({ ${properties.join(", ")} });`
         );
+      } else if (!isNew && names.headersSchemaName !== canonicalName) {
+        if (!generatedNames.has(names.headersSchemaName)) {
+          generatedNames.add(names.headersSchemaName);
+          declarations.push(
+            `export const ${names.headersSchemaName} = ${canonicalName};`
+          );
+        }
       }
     }
     if (names.bodySchemaName && route.requestBody) {
-      if (!schemaNames.has(names.bodySchemaName)) {
-        schemaNames.add(names.bodySchemaName);
+      const { isNew, canonicalName } = registerSchema(
+        registry,
+        names.bodySchemaName,
+        route.requestBody
+      );
+      schemaNameToCanonical.set(names.bodySchemaName, canonicalName);
+      if (isNew && !generatedNames.has(names.bodySchemaName)) {
+        generatedNames.add(names.bodySchemaName);
         const zodExpr = convertSchema(route.requestBody);
-        lines.push(`export const ${names.bodySchemaName} = ${zodExpr};`);
+        declarations.push(`export const ${names.bodySchemaName} = ${zodExpr};`);
+      } else if (!isNew && names.bodySchemaName !== canonicalName) {
+        if (!generatedNames.has(names.bodySchemaName)) {
+          generatedNames.add(names.bodySchemaName);
+          declarations.push(
+            `export const ${names.bodySchemaName} = ${canonicalName};`
+          );
+        }
       }
     }
     for (const [statusCode, responseSchema] of Object.entries(
@@ -715,19 +1007,35 @@ function generateRouteSchemas(routes, convertSchema) {
         route.method,
         suffix
       );
-      if (!schemaNames.has(responseSchemaName)) {
-        schemaNames.add(responseSchemaName);
+      const { isNew, canonicalName } = registerSchema(
+        registry,
+        responseSchemaName,
+        responseSchema
+      );
+      schemaNameToCanonical.set(responseSchemaName, canonicalName);
+      if (isNew && !generatedNames.has(responseSchemaName)) {
+        generatedNames.add(responseSchemaName);
         const zodExpr = convertSchema(responseSchema);
-        lines.push(`export const ${responseSchemaName} = ${zodExpr};`);
+        declarations.push(`export const ${responseSchemaName} = ${zodExpr};`);
+      } else if (!isNew && responseSchemaName !== canonicalName) {
+        if (!generatedNames.has(responseSchemaName)) {
+          generatedNames.add(responseSchemaName);
+          declarations.push(
+            `export const ${responseSchemaName} = ${canonicalName};`
+          );
+        }
       }
     }
   }
-  return lines;
+  return { declarations, schemaNameToCanonical };
 }
-function generateRequestResponseObjects(routes) {
+function generateRequestResponseObjects(routes, schemaNameToCanonical) {
   const lines = [];
   const requestPaths = {};
   const responsePaths = {};
+  const resolveSchemaName = (name) => {
+    return schemaNameToCanonical.get(name) ?? name;
+  };
   for (const route of routes) {
     const names = generateRouteSchemaNames(route);
     const pathParams = route.parameters.filter((p) => p.in === "path");
@@ -742,16 +1050,20 @@ function generateRequestResponseObjects(routes) {
     }
     const requestParts = [];
     if (names.paramsSchemaName && pathParams.length > 0) {
-      requestParts.push(`params: ${names.paramsSchemaName}`);
+      requestParts.push(
+        `params: ${resolveSchemaName(names.paramsSchemaName)}`
+      );
     }
     if (names.querySchemaName && queryParams.length > 0) {
-      requestParts.push(`query: ${names.querySchemaName}`);
+      requestParts.push(`query: ${resolveSchemaName(names.querySchemaName)}`);
     }
     if (names.headersSchemaName && headerParams.length > 0) {
-      requestParts.push(`headers: ${names.headersSchemaName}`);
+      requestParts.push(
+        `headers: ${resolveSchemaName(names.headersSchemaName)}`
+      );
     }
     if (names.bodySchemaName && route.requestBody) {
-      requestParts.push(`body: ${names.bodySchemaName}`);
+      requestParts.push(`body: ${resolveSchemaName(names.bodySchemaName)}`);
     }
     if (requestParts.length > 0) {
       requestMethodObj[route.method] = requestParts;
@@ -774,7 +1086,7 @@ function generateRequestResponseObjects(routes) {
         route.method,
         suffix
       );
-      responseMethodObj[route.method][statusCode] = responseSchemaName;
+      responseMethodObj[route.method][statusCode] = resolveSchemaName(responseSchemaName);
     }
   }
   lines.push("export const Request = {");
@@ -814,6 +1126,25 @@ function generateRequestResponseObjects(routes) {
   lines.push("} as const;");
   return lines;
 }
+function collectRouteSchemas(routes) {
+  const collected = [];
+  for (const route of routes) {
+    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
+      );
+      collected.push({ name: responseSchemaName, schema: responseSchema });
+    }
+  }
+  return collected;
+}
 var openApiToZodTsCode = (openapi, customImportLines, options) => {
   const components = openapi["components"];
   const schemas = components?.["schemas"] ?? {};
@@ -826,29 +1157,58 @@ var openApiToZodTsCode = (openapi, customImportLines, options) => {
   lines.push("import { z } from 'zod';");
   lines.push(...customImportLines ?? []);
   lines.push("");
+  lines.push("// Type assertion helper - verifies interface matches schema at compile time");
+  lines.push("type _AssertEqual<T, U> = [T] extends [U] ? ([U] extends [T] ? true : never) : never;");
+  lines.push("");
+  const registry = createSchemaRegistry();
   const sortedSchemaNames = topologicalSortSchemas(schemas);
+  const typeAssertions = [];
   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(generateInterface(typeName, schema));
+      lines.push(`export const ${schemaName}: z.ZodType<${typeName}> = ${zodExpr};`);
       lines.push("");
+      typeAssertions.push(`type _Assert${typeName} = _AssertEqual<${typeName}, z.infer<typeof ${schemaName}>>;`);
+      const fingerprint = getSchemaFingerprint(schema);
+      preRegisterSchema(registry, schemaName, fingerprint);
     }
   }
+  if (typeAssertions.length > 0) {
+    lines.push("// Compile-time type assertions - ensure interfaces match schemas");
+    lines.push(typeAssertions.join("\n"));
+    lines.push("");
+  }
   if (options?.includeRoutes) {
     const routes = parseOpenApiPaths(openapi);
     if (routes.length > 0) {
-      const routeSchemas = generateRouteSchemas(
+      const routeSchemaList = collectRouteSchemas(routes);
+      const commonSchemas = findCommonSchemas(routeSchemaList, 2);
+      if (commonSchemas.length > 0) {
+        lines.push("// Common Error Schemas (deduplicated)");
+        for (const common of commonSchemas) {
+          const zodExpr = convertSchemaToZodString(common.schema);
+          lines.push(`export const ${common.name} = ${zodExpr};`);
+          preRegisterSchema(registry, common.name, common.fingerprint);
+        }
+        lines.push("");
+      }
+      const { declarations, schemaNameToCanonical } = generateRouteSchemas(
         routes,
-        convertSchemaToZodString
+        convertSchemaToZodString,
+        registry
       );
-      if (routeSchemas.length > 0) {
-        lines.push(...routeSchemas);
+      if (declarations.length > 0) {
+        lines.push("// Route Schemas");
+        lines.push(...declarations);
         lines.push("");
-        const requestResponseObjs = generateRequestResponseObjects(routes);
+        const requestResponseObjs = generateRequestResponseObjects(
+          routes,
+          schemaNameToCanonical
+        );
         lines.push(...requestResponseObjs);
       }
     }
@@ -860,11 +1220,13 @@ var openApiToZodTsCode = (openapi, customImportLines, options) => {
   SUPPORTED_STRING_FORMATS,
   clearZodSchemaToOpenApiSchemaRegistry,
   convertSchemaToZodString,
+  generateInterface,
   generateRouteSchemaNames,
   getSchemaExportedVariableNameForStringFormat,
   openApiToZodTsCode,
   parseOpenApiPaths,
   registerZodSchemaToOpenApiSchema,
-  schemaRegistry
+  schemaRegistry,
+  schemaToTypeString
 });
 //# sourceMappingURL=index.cjs.map