mobx-tanstack-query-api 0.40.1 → 0.41.1

package/cli.cjs

@@ -219,6 +219,15 @@ const createShortModelType = (shortModelType) => {
     description: shortModelType.description || ""
   };
 };
+const DEFAULT_DATA_CONTRACT_TYPE_SUFFIX = "DC";
+const DEFAULT_ZOD_CONTRACT_SUFFIX = "";
+const DEFAULT_ENDPOINT_ZOD_CONTRACT_SUFFIX = "Contract";
+function getZodContractSuffix(zodContracts) {
+  return (typeof zodContracts === "object" && zodContracts !== null && typeof zodContracts.suffix === "string" ? zodContracts.suffix : void 0) ?? DEFAULT_ZOD_CONTRACT_SUFFIX;
+}
+function getEndpointZodContractSuffix(zodContracts) {
+  return (typeof zodContracts === "object" && zodContracts !== null && typeof zodContracts.suffix === "string" ? zodContracts.suffix : void 0) ?? DEFAULT_ENDPOINT_ZOD_CONTRACT_SUFFIX;
+}
 const REF_PREFIX = "#/components/schemas/";
 const REF_PREFIX_PARAMS = "#/components/parameters/";
 function parseRef(ref) {
@@ -247,7 +256,7 @@ function getResponseSchemaKeyFromOperation(rawOperation) {
   if (typeof ref !== "string") return null;
   return parseRef(ref);
 }
-function typeNameToSchemaKey(typeName, typeSuffix = "DC") {
+function typeNameToSchemaKey(typeName, typeSuffix = DEFAULT_DATA_CONTRACT_TYPE_SUFFIX) {
   const t = typeName.trim();
   if (typeSuffix && t.endsWith(typeSuffix))
     return t.slice(0, -typeSuffix.length);
@@ -270,14 +279,14 @@ function schemaToNumber(schema) {
   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()";
+function schemaToArray(schema, schemas, schemaKeyToVarName, visited) {
+  const items = schema.items ? schemaToZodExpr(schema.items, schemas, schemaKeyToVarName, 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) {
+function schemaToObject(schema, schemas, schemaKeyToVarName, visited) {
   if (schema.properties && Object.keys(schema.properties).length > 0) {
     const required = new Set(schema.required ?? []);
     const entries = Object.entries(schema.properties).map(
@@ -285,7 +294,7 @@ function schemaToObject(schema, schemas, schemaKeyToVarName2, visited) {
         const expr = schemaToZodExpr(
           propSchema,
           schemas,
-          schemaKeyToVarName2,
+          schemaKeyToVarName,
           visited
         );
         const optional = !required.has(propName);
@@ -303,26 +312,26 @@ ${entries.join(",\n")}
     const value = schemaToZodExpr(
       schema.additionalProperties,
       schemas,
-      schemaKeyToVarName2,
+      schemaKeyToVarName,
       visited
     );
     return `z.record(z.string(), ${value})`;
   }
   return "z.record(z.string(), z.any())";
 }
-function schemaToZodExpr(schema, schemas, schemaKeyToVarName2, visited) {
+function schemaToZodExpr(schema, schemas, schemaKeyToVarName, 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 isCycle ? `z.lazy((): z.ZodTypeAny => ${schemaKeyToVarName(key)})` : `z.lazy(() => ${schemaKeyToVarName(key)})`;
     }
     return "z.any()";
   }
   if (schema.allOf && schema.allOf.length > 0) {
     const parts = schema.allOf.map(
-      (part) => schemaToZodExpr(part, schemas, schemaKeyToVarName2, visited)
+      (part) => schemaToZodExpr(part, schemas, schemaKeyToVarName, visited)
     );
     const base2 = parts.length === 1 ? parts[0] : parts.reduce((acc, p) => `z.intersection(${acc}, ${p})`);
     return schema.nullable === true ? `${base2}.nullable()` : base2;
@@ -341,10 +350,10 @@ function schemaToZodExpr(schema, schemas, schemaKeyToVarName2, visited) {
       base = "z.boolean()";
       break;
     case "array":
-      base = schemaToArray(schema, schemas, schemaKeyToVarName2, visited);
+      base = schemaToArray(schema, schemas, schemaKeyToVarName, visited);
       break;
     case "object":
-      base = schemaToObject(schema, schemas, schemaKeyToVarName2, visited);
+      base = schemaToObject(schema, schemas, schemaKeyToVarName, visited);
       break;
     default:
       base = "z.any()";
@@ -374,9 +383,16 @@ function collectRefs(schema, schemas, out) {
     collectRefs(schema.additionalProperties, schemas, out);
   }
 }
-function schemaKeyToVarName(key, utils) {
+function dataContractTypeNameToZodVarName(typeName, utils, contractSuffix = DEFAULT_ZOD_CONTRACT_SUFFIX) {
   const _ = utils._;
-  return `${_.camelCase(key)}Schema`;
+  return `${_.camelCase(typeName)}${contractSuffix}`;
+}
+function schemaKeyToContractVarName(key, utils, contractSuffix = DEFAULT_ZOD_CONTRACT_SUFFIX, typeSuffix = DEFAULT_DATA_CONTRACT_TYPE_SUFFIX) {
+  return dataContractTypeNameToZodVarName(
+    `${key}${typeSuffix}`,
+    utils,
+    contractSuffix
+  );
 }
 function resolveQueryParameters(operation, componentsParameters) {
   const list = [];
@@ -405,13 +421,13 @@ function resolveQueryParameters(operation, componentsParameters) {
   }
   return list;
 }
-function queryParamsToZodObject(queryParams, schemas, schemaKeyToVarName2) {
+function queryParamsToZodObject(queryParams, schemas, schemaKeyToContractVarName2) {
   if (queryParams.length === 0) return "z.object({})";
   const entries = queryParams.map(({ name, required, schema }) => {
     const expr = schemaToZodExpr(
       schema,
       schemas,
-      schemaKeyToVarName2,
+      schemaKeyToContractVarName2,
       /* @__PURE__ */ new Set()
     );
     const field = required ? expr : `${expr}.optional()`;
@@ -421,32 +437,37 @@ function queryParamsToZodObject(queryParams, schemas, schemaKeyToVarName2) {
 ${entries.join(",\n")}
 })`;
 }
-function generateAuxiliarySchemas(schemaKeys, schemas, schemaKeyToVarNameFn, visited) {
+function generateAuxiliarySchemas(schemaKeys, schemas, schemaKeyToContractVarNameFn, 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 varName = schemaKeyToContractVarNameFn(key);
     const cyclePath = /* @__PURE__ */ new Set([key]);
     const expr = schemaToZodExpr(
       schema,
       schemas,
-      schemaKeyToVarNameFn,
+      schemaKeyToContractVarNameFn,
       cyclePath
     );
     lines.push(`export const ${varName} = ${expr};`);
   }
   return lines;
 }
-function buildCentralZodSchemasFile(params) {
-  const { componentsSchemas, utils } = params;
-  const schemaKeyToVarNameFn = (key) => schemaKeyToVarName(key, utils);
+function buildCentralZodContractsFile(params) {
+  const {
+    componentsSchemas,
+    utils,
+    contractSuffix = DEFAULT_ZOD_CONTRACT_SUFFIX,
+    typeSuffix = DEFAULT_DATA_CONTRACT_TYPE_SUFFIX
+  } = params;
+  const schemaKeyToContractVarNameFn = (key) => schemaKeyToContractVarName(key, utils, contractSuffix, typeSuffix);
   const lines = generateAuxiliarySchemas(
     Object.keys(componentsSchemas),
     componentsSchemas,
-    schemaKeyToVarNameFn,
+    schemaKeyToContractVarNameFn,
     /* @__PURE__ */ new Set()
   );
   return `import * as z from "zod";
@@ -468,7 +489,7 @@ function typeToZodSchemaFallback(typeStr) {
   if (t === "unknown") return "z.unknown()";
   return "z.any()";
 }
-function typeToZodSchemaWithSchema(typeStr, schemas, utils, typeSuffix) {
+function typeToZodSchemaWithSchema(typeStr, schemas, utils, typeSuffix = DEFAULT_DATA_CONTRACT_TYPE_SUFFIX, contractSuffix = DEFAULT_ZOD_CONTRACT_SUFFIX) {
   const t = typeStr.trim();
   if (!schemas || Object.keys(schemas).length === 0) {
     return { expr: typeToZodSchemaFallback(t), refs: [] };
@@ -481,51 +502,49 @@ function typeToZodSchemaWithSchema(typeStr, schemas, utils, typeSuffix) {
   }
   const refs = /* @__PURE__ */ new Set();
   collectRefs(schema, schemas, refs);
-  const schemaKeyToVarNameFn = (key) => schemaKeyToVarName(key, utils);
+  const schemaKeyToContractVarNameFn = (key) => schemaKeyToContractVarName(key, utils, contractSuffix, typeSuffix);
   const expr = schemaToZodExpr(
     schema,
     schemas,
-    schemaKeyToVarNameFn,
+    schemaKeyToContractVarNameFn,
     /* @__PURE__ */ new Set()
   );
   return { expr, refs: [...refs] };
 }
-function schemaKeyToZod(schemaKey, schemas, utils) {
+function schemaKeyToZod(schemaKey, schemas, utils, typeSuffix = DEFAULT_DATA_CONTRACT_TYPE_SUFFIX, contractSuffix = DEFAULT_ZOD_CONTRACT_SUFFIX) {
   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 schemaKeyToContractVarNameFn = (key) => schemaKeyToContractVarName(key, utils, contractSuffix, typeSuffix);
   const expr = schemaToZodExpr(
     schema,
     schemas,
-    schemaKeyToVarNameFn,
+    schemaKeyToContractVarNameFn,
     /* @__PURE__ */ new Set()
   );
   return { expr, refs: [...refs] };
 }
 function buildEndpointZodContractsCode(params) {
   const {
-    routeNameUsage,
     inputParams,
     responseDataTypeName,
-    contractsVarName,
+    contractVarName,
     utils,
+    contractSuffix = DEFAULT_ZOD_CONTRACT_SUFFIX,
     componentsSchemas = null,
-    typeSuffix = "DC",
+    typeSuffix = DEFAULT_DATA_CONTRACT_TYPE_SUFFIX,
     responseSchemaKey,
     useExternalZodSchemas = false,
     openApiOperation = null,
     openApiComponentsParameters = null,
     queryParamName = "query"
   } = params;
-  const _ = utils._;
-  const paramsSchemaName = `${_.camelCase(routeNameUsage)}ParamsSchema`;
-  const dataSchemaName = `${_.camelCase(routeNameUsage)}DataSchema`;
+  utils._;
   const allAuxiliaryKeys = /* @__PURE__ */ new Set();
   const paramParts = [];
   const resolvedQueryParams = openApiOperation && (openApiComponentsParameters || openApiOperation.parameters?.length) ? resolveQueryParameters(openApiOperation, openApiComponentsParameters) : [];
-  const schemaKeyToVarNameFn = (key) => schemaKeyToVarName(key, utils);
+  const schemaKeyToContractVarNameFn = (key) => schemaKeyToContractVarName(key, utils, contractSuffix, typeSuffix);
   for (const p of inputParams) {
     let expr;
     let refKeys = [];
@@ -533,14 +552,15 @@ function buildEndpointZodContractsCode(params) {
       expr = queryParamsToZodObject(
         resolvedQueryParams,
         componentsSchemas,
-        schemaKeyToVarNameFn
+        schemaKeyToContractVarNameFn
       );
     } else {
       const result = typeToZodSchemaWithSchema(
         p.type,
         componentsSchemas,
         utils,
-        typeSuffix
+        typeSuffix,
+        contractSuffix
       );
       expr = result.expr;
       refKeys = result.refs;
@@ -549,11 +569,18 @@ function buildEndpointZodContractsCode(params) {
     const schemaWithOptional = p.optional ? `${expr}.optional()` : expr;
     paramParts.push(`${p.name}: ${schemaWithOptional}`);
   }
-  const responseResult = responseSchemaKey && componentsSchemas && responseSchemaKey in componentsSchemas ? schemaKeyToZod(responseSchemaKey, componentsSchemas, utils) : typeToZodSchemaWithSchema(
+  const responseResult = responseSchemaKey && componentsSchemas && responseSchemaKey in componentsSchemas ? schemaKeyToZod(
+    responseSchemaKey,
+    componentsSchemas,
+    utils,
+    typeSuffix,
+    contractSuffix
+  ) : typeToZodSchemaWithSchema(
     responseDataTypeName,
     componentsSchemas,
     utils,
-    typeSuffix
+    typeSuffix,
+    contractSuffix
   );
   const useDataSchemaFromCentral = useExternalZodSchemas && responseSchemaKey && componentsSchemas && responseSchemaKey in componentsSchemas;
   if (useDataSchemaFromCentral) {
@@ -561,31 +588,27 @@ function buildEndpointZodContractsCode(params) {
   } else {
     for (const k of responseResult.refs) allAuxiliaryKeys.add(k);
   }
-  const zodSchemaImportNames = useExternalZodSchemas && allAuxiliaryKeys.size > 0 ? [...allAuxiliaryKeys].map(schemaKeyToVarNameFn) : [];
+  const zodContractImportNames = useExternalZodSchemas && allAuxiliaryKeys.size > 0 ? [...allAuxiliaryKeys].map(schemaKeyToContractVarNameFn) : [];
   const allAuxiliary = useExternalZodSchemas ? [] : generateAuxiliarySchemas(
     [...allAuxiliaryKeys],
     componentsSchemas ?? {},
-    schemaKeyToVarNameFn,
+    schemaKeyToContractVarNameFn,
     /* @__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 paramsFields = paramParts.join(",\n    ");
+  const paramsSchemaExpr = `z.object({
+    ${paramsFields},
+  })`;
+  const dataSchemaExpr = useDataSchemaFromCentral ? schemaKeyToContractVarNameFn(responseSchemaKey) : responseResult.expr;
+  const contractsCode = `export const ${contractVarName} = {
+  params: ${paramsSchemaExpr},
+  data: ${dataSchemaExpr},
 };`;
   const auxiliaryBlock = allAuxiliary.length > 0 ? `${allAuxiliary.join("\n\n")}
 
 ` : "";
-  const content = `${auxiliaryBlock}${paramsSchemaCode}
-
-${dataSchemaCode}
-
-${contractsCode}`;
-  return { content, zodSchemaImportNames };
+  const content = `${auxiliaryBlock}${contractsCode}`;
+  return { content, zodContractImportNames };
 }
 const formatGroupNameEnumKey = (groupName, { _ }) => _.upperFirst(_.camelCase(groupName));
 const formatTagNameEnumKey = (tagName, utils) => formatGroupNameEnumKey(tagName, utils);
@@ -745,10 +768,8 @@ const newEndpointTmpl = ({
 }) => {
   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 sharedContractSuffix = getZodContractSuffix(zodContracts);
+  const endpointContractSuffix = getEndpointZodContractSuffix(zodContracts);
   const { _ } = utils;
   const positiveResponseTypes = route.raw.responsesTypes?.filter(
     (it) => +it.status >= 200 && +it.status < 300 && (!it.typeData || filterTypes(it.typeData))
@@ -862,7 +883,24 @@ const newEndpointTmpl = ({
   });
   const isAllowedInputType = filterTypes(requestInputTypeDc);
   const defaultOkResponseType = positiveResponseTypes?.[0]?.type ?? "unknown";
-  const contractsVarName = hasZodContracts ? `${_.camelCase(route.routeName.usage)}Contracts` : null;
+  const contractVarName = hasZodContracts ? `${_.camelCase(route.routeName.usage)}${endpointContractSuffix}` : null;
+  const routeInfoForContracts = contractVarName != null ? {
+    operationId: raw.operationId ?? "",
+    path: path2,
+    method,
+    contractName: contractVarName
+  } : null;
+  const resolveZodContractsMaybeFn = (value) => {
+    if (typeof value === "function" && routeInfoForContracts != null) {
+      return value(routeInfoForContracts.contractName, routeInfoForContracts);
+    }
+    return value;
+  };
+  const validateOpt = zodContractsIsObject ? resolveZodContractsMaybeFn(zodContracts.validate) : zodContracts === true ? true : void 0;
+  const throwOpt = zodContractsIsObject ? resolveZodContractsMaybeFn(zodContracts.throw) : void 0;
+  const isRuntimeContractsRuleObject = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+  const validateOptObj = isRuntimeContractsRuleObject(validateOpt) ? validateOpt : null;
+  const throwOptObj = isRuntimeContractsRuleObject(throwOpt) ? throwOpt : null;
   const swaggerSchema = configuration.config?.swaggerSchema ?? configuration?.swaggerSchema;
   const componentsSchemas = swaggerSchema?.components?.schemas;
   let operationFromSpec = null;
@@ -888,7 +926,10 @@ const newEndpointTmpl = ({
       (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");
+      const resolved = typeNameToSchemaKey(
+        aliasType.content.trim(),
+        DEFAULT_DATA_CONTRACT_TYPE_SUFFIX
+      );
       if (resolved in componentsSchemas) responseSchemaKey = resolved;
     }
   }
@@ -899,46 +940,36 @@ const newEndpointTmpl = ({
       if (candidate in componentsSchemas) responseSchemaKey = candidate;
     }
   }
-  const contractsCode = hasZodContracts && contractsVarName ? buildEndpointZodContractsCode({
+  const contractsCode = hasZodContracts && contractVarName ? buildEndpointZodContractsCode({
     routeNameUsage: route.routeName.usage,
     inputParams,
     responseDataTypeName: defaultOkResponseType,
-    contractsVarName,
+    contractVarName,
     utils,
     componentsSchemas: componentsSchemas ?? void 0,
-    typeSuffix: "DC",
+    typeSuffix: DEFAULT_DATA_CONTRACT_TYPE_SUFFIX,
     responseSchemaKey: responseSchemaKey ?? void 0,
     useExternalZodSchemas: Boolean(relativePathZodSchemas),
+    contractSuffix: sharedContractSuffix,
     openApiOperation: operationFromSpec ?? void 0,
     openApiComponentsParameters: swaggerSchema?.components?.parameters ?? void 0,
     queryParamName: queryName
   }) : null;
-  const appendRuleOpt = zodContractsIsObject && zodContracts.appendRule != null ? zodContracts.appendRule : null;
-  const routeInfoForAppend = contractsVarName != null ? {
-    operationId: raw.operationId ?? "",
-    path: path2,
-    method,
-    contractName: contractsVarName
-  } : null;
-  const contractsLine = (() => {
-    if (contractsVarName == null) return "";
+  const appendRuleOpt = zodContractsIsObject && zodContracts.appendRule != null ? resolveZodContractsMaybeFn(zodContracts.appendRule) : null;
+  const contractLine = (() => {
+    if (contractVarName == null) return "";
     if (typeof appendRuleOpt === "string")
-      return `contracts: ${appendRuleOpt} ? ${contractsVarName} : undefined,`;
-    if (typeof appendRuleOpt === "function" && routeInfoForAppend) {
-      const include = appendRuleOpt(
-        routeInfoForAppend.contractName,
-        routeInfoForAppend
-      );
-      return include ? `contracts: ${contractsVarName},` : "contracts: undefined,";
-    }
-    return `contracts: ${contractsVarName},`;
+      return `contract: ${appendRuleOpt} ? ${contractVarName} : undefined,`;
+    if (appendRuleOpt === false) return "contract: undefined,";
+    if (appendRuleOpt === true) return `contract: ${contractVarName},`;
+    return `contract: ${contractVarName},`;
   })();
-  const validateContractsLine = (() => {
+  const validateContractLine = (() => {
     if (validateOpt === void 0) return "";
     if (typeof validateOpt === "string")
-      return `validateContracts: ${validateOpt},`;
+      return `validateContract: ${validateOpt},`;
     if (typeof validateOpt === "boolean")
-      return `validateContracts: ${validateOpt},`;
+      return `validateContract: ${validateOpt},`;
     if (validateOptObj !== null) {
       const parts = [];
       if (validateOptObj.params !== void 0)
@@ -949,7 +980,7 @@ const newEndpointTmpl = ({
         parts.push(
           `data: ${typeof validateOptObj.data === "string" ? validateOptObj.data : validateOptObj.data}`
         );
-      return parts.length > 0 ? `validateContracts: { ${parts.join(", ")} },` : "";
+      return parts.length > 0 ? `validateContract: { ${parts.join(", ")} },` : "";
     }
     return "";
   })();
@@ -971,7 +1002,7 @@ const newEndpointTmpl = ({
     reservedDataContractNames,
     localModelTypes: isAllowedInputType ? [requestInputTypeDc] : [],
     contractsCode: contractsCode ?? void 0,
-    contractsVarName: contractsVarName ?? void 0,
+    contractVarName: contractVarName ?? void 0,
     content: `
 new ${importFileParams.endpoint.exportName}<
   ${getHttpRequestGenerics()},
@@ -1004,8 +1035,8 @@ new ${importFileParams.endpoint.exportName}<
         ${groupName ? `group: ${metaInfo ? `Group.${formatGroupNameEnumKey(groupName, utils)}` : `"${groupName}"`},` : ""}
         ${metaInfo?.namespace ? `namespace,` : ""}
         meta: ${requestInfoMeta?.tmplData ?? "{} as any"},
-        ${contractsLine}
-        ${validateContractsLine}
+        ${contractLine}
+        ${validateContractLine}
         ${throwContractsLine}
     },
     ${importFileParams.queryClient.exportName},
@@ -1055,17 +1086,17 @@ const allEndpointPerFileTmpl = async (params) => {
   const hasAnyZodContracts = newEndpointTemplates.some(
     (t) => t.contractsCode != null
   );
-  const allZodSchemaImportNames = /* @__PURE__ */ new Set();
+  const allZodContractImportNames = /* @__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);
+    if (c != null && typeof c === "object" && c.zodContractImportNames?.length) {
+      for (const n of c.zodContractImportNames) {
+        allZodContractImportNames.add(n);
       }
     }
   });
   const zodImportLine = hasAnyZodContracts ? 'import * as z from "zod";' : "";
-  const zodSchemasImportLine = allZodSchemaImportNames.size && relativePathZodSchemas ? `import { ${[...allZodSchemaImportNames].sort().join(", ")} } from "${relativePathZodSchemas}";` : "";
+  const zodSchemasImportLine = allZodContractImportNames.size && relativePathZodSchemas ? `import { ${[...allZodContractImportNames].sort().join(", ")} } from "${relativePathZodSchemas}";` : "";
   const endpointTemplates = await Promise.all(
     newEndpointTemplates.map(
       async ({
@@ -1169,7 +1200,7 @@ const allExportsTmpl = async ({
 }) => {
   return await formatTSContent(`${LINTERS_IGNORE}
   export * from './data-contracts';
-  ${exportSchemas ? "  export * from './schemas';\n  " : ""}${collectedExportFiles.map((fileName) => `export * from './${fileName}';`).join("\n")}
+  ${exportSchemas ? "  export * from './contracts';\n  " : ""}${collectedExportFiles.map((fileName) => `export * from './${fileName}';`).join("\n")}
   ${metaInfo ? 'export * from "./meta-info";' : ""}
     `);
 };
@@ -1251,7 +1282,7 @@ 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 zodSchemasImportLine = contractsResult?.zodContractImportNames?.length && relativePathZodSchemas ? `import { ${contractsResult.zodContractImportNames.join(", ")} } from "${relativePathZodSchemas}";` : "";
   const contractsBlock = contractsResult != null ? `
 
 ${contractsResult.content}
@@ -1496,7 +1527,7 @@ const generateApi = async (params) => {
     cleanOutput: params.cleanOutput ?? true,
     modular: true,
     patch: true,
-    typeSuffix: "DC",
+    typeSuffix: DEFAULT_DATA_CONTRACT_TYPE_SUFFIX,
     disableStrictSSL: false,
     singleHttpClient: true,
     extractRequestBody: true,
@@ -1661,7 +1692,8 @@ const generateApi = async (params) => {
   };
   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 zodContractSuffix = getZodContractSuffix(params.zodContracts);
+  const hasZodContractsFile = (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();
@@ -1684,7 +1716,7 @@ const generateApi = async (params) => {
             groupNames: [],
             namespace
           },
-          relativePathZodSchemas: hasZodSchemasFile ? "../schemas" : null
+          relativePathZodSchemas: hasZodContractsFile ? "../contracts" : null
         });
         if (Array.isArray(route.raw.tags)) {
           route.raw.tags.forEach((tag) => {
@@ -1729,7 +1761,7 @@ const generateApi = async (params) => {
           namespace,
           groupNames: []
         },
-        relativePathZodSchemas: hasZodSchemasFile ? "./schemas" : null
+        relativePathZodSchemas: hasZodContractsFile ? "./contracts" : null
       });
       reservedDataContractNames.forEach((name) => {
         reservedDataContractNamesMap.set(
@@ -1802,6 +1834,7 @@ const generateApi = async (params) => {
             ...baseTmplParams,
             route,
             relativePathDataContracts: "../../data-contracts",
+            relativePathZodSchemas: hasZodContractsFile ? "../../contracts" : null,
             groupName,
             metaInfo: params.noMetaInfo ? null : {
               namespace,
@@ -1844,6 +1877,7 @@ const generateApi = async (params) => {
           ...baseTmplParams,
           routes,
           relativePathDataContracts: "../data-contracts",
+          relativePathZodSchemas: hasZodContractsFile ? "../contracts" : null,
           groupName,
           metaInfo: params.noMetaInfo ? null : {
             namespace,
@@ -1925,20 +1959,21 @@ export * as ${exportGroupName} from './endpoints';
     withPrefix: false,
     content: dataContractsContent
   });
-  if (hasZodSchemasFile && componentsSchemasForZod) {
-    const schemasTsContent = buildCentralZodSchemasFile({
+  if (hasZodContractsFile && componentsSchemasForZod) {
+    const contractsTsContent = buildCentralZodContractsFile({
       componentsSchemas: componentsSchemasForZod,
-      utils
+      utils,
+      contractSuffix: zodContractSuffix
     });
-    const formattedSchemasContent = await generated.formatTSContent(
+    const formattedContractsContent = await generated.formatTSContent(
       `${LINTERS_IGNORE}
-${schemasTsContent}`
+${contractsTsContent}`
     );
     codegenFs.createFile({
       path: paths.outputDir,
-      fileName: "schemas.ts",
+      fileName: "contracts.ts",
       withPrefix: false,
-      content: formattedSchemasContent
+      content: formattedContractsContent
     });
   }
   if (metaInfo) {
@@ -1961,7 +1996,7 @@ ${schemasTsContent}`
         ...baseTmplParams,
         collectedExportFiles: collectedExportFilesFromIndexFile,
         metaInfo,
-        exportSchemas: hasZodSchemasFile
+        exportSchemas: hasZodContractsFile
       })
     });
     if (shouldGenerateBarrelFiles) {
@@ -1984,7 +2019,7 @@ export * as ${namespace} from './__exports';
           ...baseTmplParams,
           collectedExportFiles: collectedExportFilesFromIndexFile,
           metaInfo,
-          exportSchemas: hasZodSchemasFile
+          exportSchemas: hasZodContractsFile
         })
       });
     }