mobx-tanstack-query-api 0.37.1 → 0.38.1

package/cli.js

@@ -216,6 +216,373 @@ const createShortModelType = (shortModelType) => {
     description: shortModelType.description || ""
   };
 };
+const REF_PREFIX = "#/components/schemas/";
+const REF_PREFIX_PARAMS = "#/components/parameters/";
+function parseRef(ref) {
+  if (typeof ref !== "string" || !ref.startsWith(REF_PREFIX)) return null;
+  return ref.slice(REF_PREFIX.length);
+}
+function parseParamRef(ref) {
+  if (typeof ref !== "string" || !ref.startsWith(REF_PREFIX_PARAMS))
+    return null;
+  return ref.slice(REF_PREFIX_PARAMS.length);
+}
+function getResponseSchemaKeyFromOperation(rawOperation) {
+  const op = rawOperation;
+  const responses = op?.responses;
+  if (!responses || typeof responses !== "object") return null;
+  const successStatus = Object.keys(responses).find((s) => {
+    const code = Number.parseInt(s, 10);
+    return code >= 200 && code < 300;
+  });
+  if (!successStatus) return null;
+  const successResponse = responses[successStatus];
+  const content = successResponse?.content;
+  if (!content || typeof content !== "object") return null;
+  const jsonContent = content["application/json"] ?? Object.values(content)[0];
+  const ref = jsonContent?.schema?.$ref;
+  if (typeof ref !== "string") return null;
+  return parseRef(ref);
+}
+function typeNameToSchemaKey(typeName, typeSuffix = "DC") {
+  const t = typeName.trim();
+  if (typeSuffix && t.endsWith(typeSuffix))
+    return t.slice(0, -typeSuffix.length);
+  return t;
+}
+function schemaToString(schema) {
+  let s = "z.string()";
+  if (schema.minLength != null) s += `.min(${schema.minLength})`;
+  if (schema.maxLength != null) s += `.max(${schema.maxLength})`;
+  if (schema.pattern != null)
+    s += `.regex(new RegExp(${JSON.stringify(schema.pattern)}))`;
+  if (schema.enum != null)
+    s = `z.enum([${schema.enum.map((e) => JSON.stringify(e)).join(", ")}])`;
+  return s;
+}
+function schemaToNumber(schema) {
+  let n = "z.number()";
+  if (schema.type === "integer") n += ".int()";
+  if (schema.minimum != null) n += `.min(${schema.minimum})`;
+  if (schema.maximum != null) n += `.max(${schema.maximum})`;
+  return n;
+}
+function schemaToArray(schema, schemas, schemaKeyToVarName2, visited) {
+  const items = schema.items ? schemaToZodExpr(schema.items, schemas, schemaKeyToVarName2, visited) : "z.any()";
+  let a = `z.array(${items})`;
+  if (schema.minItems != null) a += `.min(${schema.minItems})`;
+  if (schema.maxItems != null) a += `.max(${schema.maxItems})`;
+  return a;
+}
+function schemaToObject(schema, schemas, schemaKeyToVarName2, visited) {
+  if (schema.properties && Object.keys(schema.properties).length > 0) {
+    const required = new Set(schema.required ?? []);
+    const entries = Object.entries(schema.properties).map(
+      ([propName, propSchema]) => {
+        const expr = schemaToZodExpr(
+          propSchema,
+          schemas,
+          schemaKeyToVarName2,
+          visited
+        );
+        const optional = !required.has(propName);
+        const field = optional ? `${expr}.optional()` : expr;
+        return `  ${JSON.stringify(propName)}: ${field}`;
+      }
+    );
+    return `z.object({
+${entries.join(",\n")}
+})`;
+  }
+  if (schema.additionalProperties === true)
+    return "z.record(z.string(), z.any())";
+  if (typeof schema.additionalProperties === "object") {
+    const value = schemaToZodExpr(
+      schema.additionalProperties,
+      schemas,
+      schemaKeyToVarName2,
+      visited
+    );
+    return `z.record(z.string(), ${value})`;
+  }
+  return "z.record(z.string(), z.any())";
+}
+function schemaToZodExpr(schema, schemas, schemaKeyToVarName2, visited) {
+  if (!schema) return "z.any()";
+  if (schema.$ref) {
+    const key = parseRef(schema.$ref);
+    if (key && key in schemas) {
+      const isCycle = visited.has(key);
+      return isCycle ? `z.lazy((): z.ZodTypeAny => ${schemaKeyToVarName2(key)})` : `z.lazy(() => ${schemaKeyToVarName2(key)})`;
+    }
+    return "z.any()";
+  }
+  if (schema.allOf && schema.allOf.length > 0) {
+    const parts = schema.allOf.map(
+      (part) => schemaToZodExpr(part, schemas, schemaKeyToVarName2, visited)
+    );
+    const base2 = parts.length === 1 ? parts[0] : parts.reduce((acc, p) => `z.intersection(${acc}, ${p})`);
+    return schema.nullable === true ? `${base2}.nullable()` : base2;
+  }
+  const nullable = schema.nullable === true;
+  let base;
+  switch (schema.type) {
+    case "string":
+      base = schemaToString(schema);
+      break;
+    case "integer":
+    case "number":
+      base = schemaToNumber(schema);
+      break;
+    case "boolean":
+      base = "z.boolean()";
+      break;
+    case "array":
+      base = schemaToArray(schema, schemas, schemaKeyToVarName2, visited);
+      break;
+    case "object":
+      base = schemaToObject(schema, schemas, schemaKeyToVarName2, visited);
+      break;
+    default:
+      base = "z.any()";
+  }
+  return nullable ? `${base}.nullable()` : base;
+}
+function collectRefs(schema, schemas, out) {
+  if (!schema) return;
+  if (schema.$ref) {
+    const key = parseRef(schema.$ref);
+    if (key && key in schemas && !out.has(key)) {
+      out.add(key);
+      collectRefs(schemas[key], schemas, out);
+    }
+    return;
+  }
+  if (schema.allOf) {
+    for (const part of schema.allOf) collectRefs(part, schemas, out);
+  }
+  if (schema.properties) {
+    for (const v of Object.values(schema.properties)) {
+      collectRefs(v, schemas, out);
+    }
+  }
+  if (schema.items) collectRefs(schema.items, schemas, out);
+  if (typeof schema.additionalProperties === "object") {
+    collectRefs(schema.additionalProperties, schemas, out);
+  }
+}
+function schemaKeyToVarName(key, utils) {
+  const _ = utils._;
+  return `${_.camelCase(key)}Schema`;
+}
+function resolveQueryParameters(operation, componentsParameters) {
+  const list = [];
+  const params = operation?.parameters;
+  if (!Array.isArray(params) || !params.length) return list;
+  for (const p of params) {
+    let param = p;
+    if (p.$ref && componentsParameters) {
+      const key = parseParamRef(p.$ref);
+      if (key && key in componentsParameters)
+        param = componentsParameters[key];
+    }
+    if (param.in !== "query") continue;
+    const name = param.name;
+    if (!name) continue;
+    const schema = param.schema ?? {
+      type: param.type ?? "string",
+      format: param.format,
+      items: param.items
+    };
+    list.push({
+      name,
+      required: param.required === true,
+      schema
+    });
+  }
+  return list;
+}
+function queryParamsToZodObject(queryParams, schemas, schemaKeyToVarName2) {
+  if (queryParams.length === 0) return "z.object({})";
+  const entries = queryParams.map(({ name, required, schema }) => {
+    const expr = schemaToZodExpr(
+      schema,
+      schemas,
+      schemaKeyToVarName2,
+      /* @__PURE__ */ new Set()
+    );
+    const field = required ? expr : `${expr}.optional()`;
+    return `  ${JSON.stringify(name)}: ${field}`;
+  });
+  return `z.object({
+${entries.join(",\n")}
+})`;
+}
+function generateAuxiliarySchemas(schemaKeys, schemas, schemaKeyToVarNameFn, visited) {
+  const lines = [];
+  for (const key of schemaKeys) {
+    if (visited.has(key)) continue;
+    visited.add(key);
+    const schema = schemas[key];
+    if (!schema) continue;
+    const varName = schemaKeyToVarNameFn(key);
+    const expr = schemaToZodExpr(
+      schema,
+      schemas,
+      schemaKeyToVarNameFn,
+      visited
+    );
+    lines.push(`export const ${varName} = ${expr};`);
+  }
+  return lines;
+}
+function buildCentralZodSchemasFile(params) {
+  const { componentsSchemas, utils } = params;
+  const schemaKeyToVarNameFn = (key) => schemaKeyToVarName(key, utils);
+  const lines = generateAuxiliarySchemas(
+    Object.keys(componentsSchemas),
+    componentsSchemas,
+    schemaKeyToVarNameFn,
+    /* @__PURE__ */ new Set()
+  );
+  return `import * as z from "zod";
+
+${lines.join("\n\n")}
+`;
+}
+function typeToZodSchemaFallback(typeStr) {
+  const t = typeStr.trim();
+  if (t === "RequestParams") return "z.any()";
+  if (t === "Record<string, any>" || t === "Record<string, unknown>")
+    return "z.record(z.string(), z.any())";
+  if (/^Record\s*<\s*string\s*,/i.test(t))
+    return "z.record(z.string(), z.any())";
+  if (t === "string") return "z.string()";
+  if (t === "number") return "z.number()";
+  if (t === "boolean") return "z.boolean()";
+  if (t === "any") return "z.any()";
+  if (t === "unknown") return "z.unknown()";
+  return "z.any()";
+}
+function typeToZodSchemaWithSchema(typeStr, schemas, utils, typeSuffix) {
+  const t = typeStr.trim();
+  if (!schemas || Object.keys(schemas).length === 0) {
+    return { expr: typeToZodSchemaFallback(t), refs: [] };
+  }
+  if (t === "RequestParams") return { expr: "z.any()", refs: [] };
+  const schemaKey = typeNameToSchemaKey(t, typeSuffix);
+  const schema = schemas[schemaKey];
+  if (!schema) {
+    return { expr: typeToZodSchemaFallback(t), refs: [] };
+  }
+  const refs = /* @__PURE__ */ new Set();
+  collectRefs(schema, schemas, refs);
+  const schemaKeyToVarNameFn = (key) => schemaKeyToVarName(key, utils);
+  const expr = schemaToZodExpr(
+    schema,
+    schemas,
+    schemaKeyToVarNameFn,
+    /* @__PURE__ */ new Set()
+  );
+  return { expr, refs: [...refs] };
+}
+function schemaKeyToZod(schemaKey, schemas, utils) {
+  const schema = schemas[schemaKey];
+  if (!schema) return { expr: "z.any()", refs: [] };
+  const refs = /* @__PURE__ */ new Set();
+  collectRefs(schema, schemas, refs);
+  const schemaKeyToVarNameFn = (key) => schemaKeyToVarName(key, utils);
+  const expr = schemaToZodExpr(
+    schema,
+    schemas,
+    schemaKeyToVarNameFn,
+    /* @__PURE__ */ new Set()
+  );
+  return { expr, refs: [...refs] };
+}
+function buildEndpointZodContractsCode(params) {
+  const {
+    routeNameUsage,
+    inputParams,
+    responseDataTypeName,
+    contractsVarName,
+    utils,
+    componentsSchemas = null,
+    typeSuffix = "DC",
+    responseSchemaKey,
+    useExternalZodSchemas = false,
+    openApiOperation = null,
+    openApiComponentsParameters = null,
+    queryParamName = "query"
+  } = params;
+  const _ = utils._;
+  const paramsSchemaName = `${_.camelCase(routeNameUsage)}ParamsSchema`;
+  const dataSchemaName = `${_.camelCase(routeNameUsage)}DataSchema`;
+  const allAuxiliaryKeys = /* @__PURE__ */ new Set();
+  const paramParts = [];
+  const resolvedQueryParams = openApiOperation && (openApiComponentsParameters || openApiOperation.parameters?.length) ? resolveQueryParameters(openApiOperation, openApiComponentsParameters) : [];
+  const schemaKeyToVarNameFn = (key) => schemaKeyToVarName(key, utils);
+  for (const p of inputParams) {
+    let expr;
+    let refKeys = [];
+    if (p.name === queryParamName && resolvedQueryParams.length > 0 && componentsSchemas) {
+      expr = queryParamsToZodObject(
+        resolvedQueryParams,
+        componentsSchemas,
+        schemaKeyToVarNameFn
+      );
+    } else {
+      const result = typeToZodSchemaWithSchema(
+        p.type,
+        componentsSchemas,
+        utils,
+        typeSuffix
+      );
+      expr = result.expr;
+      refKeys = result.refs;
+    }
+    for (const k of refKeys) allAuxiliaryKeys.add(k);
+    const schemaWithOptional = p.optional ? `${expr}.optional()` : expr;
+    paramParts.push(`${p.name}: ${schemaWithOptional}`);
+  }
+  const responseResult = responseSchemaKey && componentsSchemas && responseSchemaKey in componentsSchemas ? schemaKeyToZod(responseSchemaKey, componentsSchemas, utils) : typeToZodSchemaWithSchema(
+    responseDataTypeName,
+    componentsSchemas,
+    utils,
+    typeSuffix
+  );
+  const useDataSchemaFromCentral = useExternalZodSchemas && responseSchemaKey && componentsSchemas && responseSchemaKey in componentsSchemas;
+  if (useDataSchemaFromCentral) {
+    allAuxiliaryKeys.add(responseSchemaKey);
+  } else {
+    for (const k of responseResult.refs) allAuxiliaryKeys.add(k);
+  }
+  const zodSchemaImportNames = useExternalZodSchemas && allAuxiliaryKeys.size > 0 ? [...allAuxiliaryKeys].map(schemaKeyToVarNameFn) : [];
+  const allAuxiliary = useExternalZodSchemas ? [] : generateAuxiliarySchemas(
+    [...allAuxiliaryKeys],
+    componentsSchemas ?? {},
+    schemaKeyToVarNameFn,
+    /* @__PURE__ */ new Set()
+  );
+  const paramsFields = paramParts.join(",\n  ");
+  const paramsSchemaCode = `export const ${paramsSchemaName} = z.object({
+  ${paramsFields},
+});`;
+  const dataSchemaCode = useDataSchemaFromCentral ? `export const ${dataSchemaName} = ${schemaKeyToVarNameFn(responseSchemaKey)};` : `export const ${dataSchemaName} = ${responseResult.expr};`;
+  const contractsCode = `export const ${contractsVarName} = {
+  params: ${paramsSchemaName},
+  data: ${dataSchemaName},
+};`;
+  const auxiliaryBlock = allAuxiliary.length > 0 ? `${allAuxiliary.join("\n\n")}
+
+` : "";
+  const content = `${auxiliaryBlock}${paramsSchemaCode}
+
+${dataSchemaCode}
+
+${contractsCode}`;
+  return { content, zodSchemaImportNames };
+}
 const formatGroupNameEnumKey = (groupName, { _ }) => _.upperFirst(_.camelCase(groupName));
 const formatTagNameEnumKey = (tagName, utils) => formatGroupNameEnumKey(tagName, utils);
 const metaInfoTmpl = async ({
@@ -367,8 +734,17 @@ const newEndpointTmpl = ({
   groupName,
   metaInfo,
   filterTypes,
-  configuration
+  configuration,
+  zodContracts,
+  relativePathZodSchemas
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: codegen template, many branches by design
 }) => {
+  const zodContractsIsObject = typeof zodContracts === "object" && zodContracts !== null;
+  const hasZodContracts = zodContracts === true || zodContractsIsObject;
+  const validateOpt = zodContractsIsObject ? zodContracts.validate : zodContracts === true ? true : void 0;
+  const throwOpt = zodContractsIsObject ? zodContracts.throw : void 0;
+  const validateOptObj = validateOpt != null && typeof validateOpt === "object" && !Array.isArray(validateOpt) ? validateOpt : null;
+  const throwOptObj = throwOpt != null && typeof throwOpt === "object" && !Array.isArray(throwOpt) ? throwOpt : null;
   const { _ } = utils;
   const positiveResponseTypes = route.raw.responsesTypes?.filter(
     (it) => +it.status >= 200 && +it.status < 300 && (!it.typeData || filterTypes(it.typeData))
@@ -481,9 +857,98 @@ const newEndpointTmpl = ({
   }`
   });
   const isAllowedInputType = filterTypes(requestInputTypeDc);
+  const defaultOkResponseType = positiveResponseTypes?.[0]?.type ?? "unknown";
+  const contractsVarName = hasZodContracts ? `${_.camelCase(route.routeName.usage)}Contracts` : null;
+  const swaggerSchema = configuration.config?.swaggerSchema ?? configuration?.swaggerSchema;
+  const componentsSchemas = swaggerSchema?.components?.schemas;
+  let operationFromSpec = null;
+  const pathKeyForSpec = path2?.startsWith("/") ? path2 : `/${path2 || ""}`;
+  const methodKey = method?.toLowerCase?.() ?? method;
+  if (pathKeyForSpec && methodKey && swaggerSchema?.paths?.[pathKeyForSpec]) {
+    operationFromSpec = swaggerSchema.paths[pathKeyForSpec][methodKey] ?? null;
+  }
+  if (!operationFromSpec && swaggerSchema?.paths && raw?.operationId) {
+    for (const pathItem of Object.values(swaggerSchema.paths)) {
+      const op = pathItem?.[methodKey];
+      if (op?.operationId === raw.operationId) {
+        operationFromSpec = op;
+        break;
+      }
+    }
+  }
+  let responseSchemaKey = getResponseSchemaKeyFromOperation(
+    operationFromSpec ?? raw
+  );
+  if (!responseSchemaKey && componentsSchemas && configuration.modelTypes) {
+    const aliasType = configuration.modelTypes.find(
+      (m) => m.name === defaultOkResponseType
+    );
+    if (aliasType?.typeIdentifier === "type" && typeof aliasType.content === "string" && /^[A-Za-z0-9_]+$/.test(aliasType.content.trim())) {
+      const resolved = typeNameToSchemaKey(aliasType.content.trim(), "DC");
+      if (resolved in componentsSchemas) responseSchemaKey = resolved;
+    }
+  }
+  if (!responseSchemaKey && componentsSchemas) {
+    const match = defaultOkResponseType.match(/^Get(.+)DataDC$/);
+    if (match) {
+      const candidate = match[1];
+      if (candidate in componentsSchemas) responseSchemaKey = candidate;
+    }
+  }
+  const contractsCode = hasZodContracts && contractsVarName ? buildEndpointZodContractsCode({
+    routeNameUsage: route.routeName.usage,
+    inputParams,
+    responseDataTypeName: defaultOkResponseType,
+    contractsVarName,
+    utils,
+    componentsSchemas: componentsSchemas ?? void 0,
+    typeSuffix: "DC",
+    responseSchemaKey: responseSchemaKey ?? void 0,
+    useExternalZodSchemas: Boolean(relativePathZodSchemas),
+    openApiOperation: operationFromSpec ?? void 0,
+    openApiComponentsParameters: swaggerSchema?.components?.parameters ?? void 0,
+    queryParamName: queryName
+  }) : null;
+  const contractsLine = contractsVarName != null ? `contracts: ${contractsVarName},` : "";
+  const validateContractsLine = (() => {
+    if (validateOpt === void 0) return "";
+    if (typeof validateOpt === "string")
+      return `validateContracts: ${validateOpt},`;
+    if (typeof validateOpt === "boolean")
+      return `validateContracts: ${validateOpt},`;
+    if (validateOptObj !== null) {
+      const parts = [];
+      if (validateOptObj.params !== void 0)
+        parts.push(
+          `params: ${typeof validateOptObj.params === "string" ? validateOptObj.params : validateOptObj.params}`
+        );
+      if (validateOptObj.data !== void 0)
+        parts.push(
+          `data: ${typeof validateOptObj.data === "string" ? validateOptObj.data : validateOptObj.data}`
+        );
+      return parts.length > 0 ? `validateContracts: { ${parts.join(", ")} },` : "";
+    }
+    return "";
+  })();
+  const throwContractsLine = (() => {
+    if (throwOpt === void 0) return "";
+    if (typeof throwOpt === "string") return `throwContracts: ${throwOpt},`;
+    if (typeof throwOpt === "boolean") return `throwContracts: ${throwOpt},`;
+    if (throwOptObj !== null) {
+      const parts = [];
+      if (throwOptObj.params !== void 0)
+        parts.push(`params: ${throwOptObj.params}`);
+      if (throwOptObj.data !== void 0)
+        parts.push(`data: ${throwOptObj.data}`);
+      return parts.length > 0 ? `throwContracts: { ${parts.join(", ")} },` : "";
+    }
+    return "";
+  })();
   return {
     reservedDataContractNames,
     localModelTypes: isAllowedInputType ? [requestInputTypeDc] : [],
+    contractsCode: contractsCode ?? void 0,
+    contractsVarName: contractsVarName ?? void 0,
     content: `
 new ${importFileParams.endpoint.exportName}<
   ${getHttpRequestGenerics()},
@@ -516,6 +981,9 @@ new ${importFileParams.endpoint.exportName}<
         ${groupName ? `group: ${metaInfo ? `Group.${formatGroupNameEnumKey(groupName, utils)}` : `"${groupName}"`},` : ""}
         ${metaInfo?.namespace ? `namespace,` : ""}
         meta: ${requestInfoMeta?.tmplData ?? "{} as any"},
+        ${contractsLine}
+        ${validateContractsLine}
+        ${throwContractsLine}
     },
     ${importFileParams.queryClient.exportName},
     ${importFileParams.httpClient.exportName},
@@ -533,7 +1001,8 @@ const allEndpointPerFileTmpl = async (params) => {
     utils,
     relativePathDataContracts,
     groupName,
-    metaInfo
+    metaInfo,
+    relativePathZodSchemas
   } = params;
   const { _ } = utils;
   const dataContractNamesInThisFile = [];
@@ -545,7 +1014,11 @@ const allEndpointPerFileTmpl = async (params) => {
   const newEndpointTemplates = routes.map((route) => {
     const newEndpointTemplateData = newEndpointTmpl({
       ...params,
-      route
+      route,
+      groupName,
+      metaInfo,
+      zodContracts: codegenParams.zodContracts,
+      relativePathZodSchemas: relativePathZodSchemas ?? void 0
     });
     const { reservedDataContractNames } = newEndpointTemplateData;
     reservedDataContractNames.forEach((reservedDataContractName) => {
@@ -556,12 +1029,27 @@ const allEndpointPerFileTmpl = async (params) => {
     return { ...newEndpointTemplateData, route };
   });
   const extraImportLines = [];
+  const hasAnyZodContracts = newEndpointTemplates.some(
+    (t) => t.contractsCode != null
+  );
+  const allZodSchemaImportNames = /* @__PURE__ */ new Set();
+  newEndpointTemplates.forEach((t) => {
+    const c = t.contractsCode;
+    if (c != null && typeof c === "object" && c.zodSchemaImportNames?.length) {
+      for (const n of c.zodSchemaImportNames) {
+        allZodSchemaImportNames.add(n);
+      }
+    }
+  });
+  const zodImportLine = hasAnyZodContracts ? 'import * as z from "zod";' : "";
+  const zodSchemasImportLine = allZodSchemaImportNames.size && relativePathZodSchemas ? `import { ${[...allZodSchemaImportNames].sort().join(", ")} } from "${relativePathZodSchemas}";` : "";
   const endpointTemplates = await Promise.all(
     newEndpointTemplates.map(
       async ({
         content: requestInfoInstanceContent,
         localModelTypes,
-        route
+        route,
+        contractsCode
       }) => {
         const requestInfoMeta = codegenParams.getEndpointMeta?.(route, utils);
         if (requestInfoMeta?.typeNameImportPath && requestInfoMeta.typeName) {
@@ -569,6 +1057,12 @@ const allEndpointPerFileTmpl = async (params) => {
             `import { ${requestInfoMeta.typeName} } from "${requestInfoMeta.typeNameImportPath}";`
           );
         }
+        const contractsResult = contractsCode != null && typeof contractsCode === "object" ? contractsCode : null;
+        const contractsBlock = contractsResult != null ? `
+
+${contractsResult.content}
+
+` : "";
         return `
       ${(await Promise.all(
           localModelTypes.map(async (modelType) => {
@@ -580,7 +1074,7 @@ const allEndpointPerFileTmpl = async (params) => {
             return contractType;
           })
         )).filter(Boolean).join("\n\n")}
-      
+      ${contractsBlock}
       ${endpointJSDocTmpl({
           ...params,
           route
@@ -607,6 +1101,7 @@ const allEndpointPerFileTmpl = async (params) => {
       import { ${importFileParams.httpClient.exportName} } from "${importFileParams.httpClient.path}";
       import { ${importFileParams.queryClient.exportName} } from "${importFileParams.queryClient.path}";
       ${extraImportLines.join("\n")}
+      ${[zodImportLine, zodSchemasImportLine].filter(Boolean).join("\n")}
       ${dataContractImportToken}
 
       ${(await Promise.all(
@@ -646,11 +1141,12 @@ const allEndpointPerFileTmpl = async (params) => {
 const allExportsTmpl = async ({
   collectedExportFiles,
   metaInfo,
-  formatTSContent
+  formatTSContent,
+  exportSchemas
 }) => {
   return await formatTSContent(`${LINTERS_IGNORE}
   export * from './data-contracts';
-  ${collectedExportFiles.map((fileName) => `export * from './${fileName}';`).join("\n")}
+  ${exportSchemas ? "  export * from './schemas';\n  " : ""}${collectedExportFiles.map((fileName) => `export * from './${fileName}';`).join("\n")}
   ${metaInfo ? 'export * from "./meta-info";' : ""}
     `);
 };
@@ -689,18 +1185,22 @@ const endpointPerFileTmpl = async (params) => {
     utils,
     relativePathDataContracts,
     groupName,
-    metaInfo
+    metaInfo,
+    relativePathZodSchemas
   } = params;
   const { _ } = utils;
   const {
     content: requestInfoInstanceContent,
     reservedDataContractNames,
-    localModelTypes
+    localModelTypes,
+    contractsCode
   } = newEndpointTmpl({
     ...params,
     route,
     groupName,
-    metaInfo
+    metaInfo,
+    zodContracts: codegenParams.zodContracts,
+    relativePathZodSchemas: relativePathZodSchemas ?? void 0
   });
   const dataContactNames = new Set(
     Object.keys(
@@ -726,6 +1226,15 @@ const endpointPerFileTmpl = async (params) => {
     );
   }
   const dataContractImportToken = "/*__DATA_CONTRACT_IMPORTS__*/";
+  const contractsResult = contractsCode != null && typeof contractsCode === "object" ? contractsCode : null;
+  const zodImportLine = contractsResult != null ? 'import * as z from "zod";' : "";
+  const zodSchemasImportLine = contractsResult?.zodSchemaImportNames?.length && relativePathZodSchemas ? `import { ${contractsResult.zodSchemaImportNames.join(", ")} } from "${relativePathZodSchemas}";` : "";
+  const contractsBlock = contractsResult != null ? `
+
+${contractsResult.content}
+
+` : "";
+  const zodImportsBlock = [zodImportLine, zodSchemasImportLine].filter(Boolean).join("\n");
   const contentWithImportToken = await formatTSContent(`${LINTERS_IGNORE}
       import {
         RequestParams,
@@ -736,6 +1245,7 @@ const endpointPerFileTmpl = async (params) => {
       import { ${importFileParams.httpClient.exportName} } from "${importFileParams.httpClient.path}";
       import { ${importFileParams.queryClient.exportName} } from "${importFileParams.queryClient.path}";
       ${extraImportLines.join("\n")}
+      ${zodImportsBlock}
       ${dataContractImportToken}
 
       ${(await Promise.all(
@@ -765,7 +1275,7 @@ const endpointPerFileTmpl = async (params) => {
       return contractType;
     })
   )).filter(Boolean).join("\n\n")}
-      
+      ${contractsBlock}
       ${endpointJSDocTmpl({
     ...params,
     route
@@ -813,7 +1323,7 @@ const unpackFilterOption = (option, argsToString, defaultReturnValue = true) =>
 const removeUnusedTypesItteration = async ({
   directory,
   keepTypes
-  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <explanation>
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: iterative AST traversal
 }) => {
   const project = new Project();
   project.addSourceFilesAtPaths([
@@ -1131,6 +1641,8 @@ const generateApi = async (params) => {
     filterTypes
   };
   const reservedDataContractNamesMap = /* @__PURE__ */ new Map();
+  const componentsSchemasForZod = generated.configuration.config?.swaggerSchema?.components?.schemas ?? generated.configuration.swaggerSchema?.components?.schemas;
+  const hasZodSchemasFile = (params.zodContracts === true || typeof params.zodContracts === "object" && params.zodContracts != null) && componentsSchemasForZod && typeof componentsSchemasForZod === "object" && Object.keys(componentsSchemasForZod).length > 0;
   const collectedExportFilesFromIndexFile = [];
   const groupsMap = /* @__PURE__ */ new Map();
   const nonEmptyGroups = /* @__PURE__ */ new Set();
@@ -1152,7 +1664,8 @@ const generateApi = async (params) => {
           metaInfo: params.noMetaInfo ? null : {
             groupNames: [],
             namespace
-          }
+          },
+          relativePathZodSchemas: hasZodSchemasFile ? "../schemas" : null
         });
         if (Array.isArray(route.raw.tags)) {
           route.raw.tags.forEach((tag) => {
@@ -1196,7 +1709,8 @@ const generateApi = async (params) => {
         metaInfo: params.noMetaInfo ? null : {
           namespace,
           groupNames: []
-        }
+        },
+        relativePathZodSchemas: hasZodSchemasFile ? "./schemas" : null
       });
       reservedDataContractNames.forEach((name) => {
         reservedDataContractNamesMap.set(
@@ -1392,6 +1906,22 @@ export * as ${exportGroupName} from './endpoints';
     withPrefix: false,
     content: dataContractsContent
   });
+  if (hasZodSchemasFile && componentsSchemasForZod) {
+    const schemasTsContent = buildCentralZodSchemasFile({
+      componentsSchemas: componentsSchemasForZod,
+      utils
+    });
+    const formattedSchemasContent = await generated.formatTSContent(
+      `${LINTERS_IGNORE}
+${schemasTsContent}`
+    );
+    codegenFs.createFile({
+      path: paths.outputDir,
+      fileName: "schemas.ts",
+      withPrefix: false,
+      content: formattedSchemasContent
+    });
+  }
   if (metaInfo) {
     codegenFs.createFile({
       path: paths.outputDir,
@@ -1411,7 +1941,8 @@ export * as ${exportGroupName} from './endpoints';
       content: await allExportsTmpl({
         ...baseTmplParams,
         collectedExportFiles: collectedExportFilesFromIndexFile,
-        metaInfo
+        metaInfo,
+        exportSchemas: hasZodSchemasFile
       })
     });
     if (shouldGenerateBarrelFiles) {
@@ -1433,7 +1964,8 @@ export * as ${namespace} from './__exports';
         content: await allExportsTmpl({
           ...baseTmplParams,
           collectedExportFiles: collectedExportFilesFromIndexFile,
-          metaInfo
+          metaInfo,
+          exportSchemas: hasZodSchemasFile
         })
       });
     }