zenko 0.1.6 → 0.1.7

package/dist/cli.mjs

@@ -135,6 +135,14 @@ function formatPropertyName(name) {
   return isValidJSIdentifier(name) ? name : `"${name}"`;
 }
 
+// src/utils/string-utils.ts
+function toCamelCase(str) {
+  return str.replace(/-([a-zA-Z])/g, (_, letter) => letter.toUpperCase()).replace(/-+$/, "");
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
 // src/utils/http-status.ts
 var statusNameMap = {
   "400": "badRequest",
@@ -194,14 +202,6 @@ function mapStatusToIdentifier(status) {
   if (!candidate) return "unknownError";
   return /^[a-zA-Z_$]/.test(candidate) ? candidate : `status${candidate.charAt(0).toUpperCase()}${candidate.slice(1)}`;
 }
-function getStatusCategory(status) {
-  if (status === "default") return "default";
-  const code = Number(status);
-  if (!Number.isInteger(code)) return "unknown";
-  if (code >= 400 && code <= 499) return "client";
-  if (code >= 500 && code <= 599) return "server";
-  return "unknown";
-}
 function isErrorStatus(status) {
   if (status === "default") return true;
   const code = Number(status);
@@ -209,6 +209,169 @@ function isErrorStatus(status) {
   return code >= 400;
 }
 
+// src/utils/tree-shaking.ts
+function analyzeZenkoUsage(operations) {
+  const usage = {
+    usesHeaderFn: false,
+    usesOperationDefinition: false,
+    usesOperationErrors: false
+  };
+  if (operations.length > 0) {
+    usage.usesOperationDefinition = true;
+  }
+  for (const op of operations) {
+    if (op.requestHeaders && op.requestHeaders.length > 0) {
+      usage.usesHeaderFn = true;
+    }
+    if (op.errors && hasAnyErrors(op.errors)) {
+      usage.usesOperationErrors = true;
+    }
+  }
+  if (operations.length > 0 && !usage.usesOperationErrors) {
+    const hasDefaultErrors = operations.some(
+      (op) => !op.errors || !hasAnyErrors(op.errors)
+    );
+    if (hasDefaultErrors) {
+      usage.usesOperationErrors = true;
+    }
+  }
+  return usage;
+}
+function generateZenkoImport(usage, mode, helpersOutput) {
+  const types = [];
+  if (usage.usesHeaderFn) types.push("HeaderFn");
+  if (usage.usesOperationDefinition) types.push("OperationDefinition");
+  if (usage.usesOperationErrors) types.push("OperationErrors");
+  if (types.length === 0) {
+    return "";
+  }
+  const importSource = mode === "package" ? '"zenko"' : `"${helpersOutput}"`;
+  return `import type { ${types.join(", ")} } from ${importSource};`;
+}
+function hasAnyErrors(errors) {
+  return Boolean(errors && Object.keys(errors).length > 0);
+}
+
+// src/utils/collect-inline-types.ts
+function collectInlineRequestTypes(operations, spec) {
+  const requestTypesToGenerate = /* @__PURE__ */ new Map();
+  const operationLookup = /* @__PURE__ */ new Map();
+  for (const [, pathItem] of Object.entries(spec.paths || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const [, pathItem] of Object.entries(spec.webhooks || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const op of operations) {
+    const operation = operationLookup.get(op.operationId);
+    if (!operation) continue;
+    const requestBody = operation.requestBody;
+    if (requestBody && requestBody.content) {
+      const content = requestBody.content;
+      const jsonContent = content["application/json"];
+      if (jsonContent && jsonContent.schema) {
+        const schema = jsonContent.schema;
+        const typeName = `${capitalize(toCamelCase(op.operationId))}Request`;
+        if (!schema.$ref || schema.allOf || schema.oneOf || schema.anyOf) {
+          requestTypesToGenerate.set(typeName, schema);
+        }
+      }
+    }
+  }
+  return requestTypesToGenerate;
+}
+function collectInlineResponseTypes(operations, spec) {
+  const responseTypesToGenerate = /* @__PURE__ */ new Map();
+  const operationLookup = /* @__PURE__ */ new Map();
+  for (const [, pathItem] of Object.entries(spec.paths || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const [, pathItem] of Object.entries(spec.webhooks || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const op of operations) {
+    const operation = operationLookup.get(op.operationId);
+    if (!operation) continue;
+    const responses = operation.responses || {};
+    for (const [statusCode, response] of Object.entries(responses)) {
+      if (/^2\d\d$/.test(statusCode) && response.content) {
+        const content = response.content;
+        const jsonContent = content["application/json"];
+        if (jsonContent && jsonContent.schema) {
+          const schema = jsonContent.schema;
+          const typeName = `${capitalize(toCamelCase(op.operationId))}Response`;
+          if (!schema.$ref || schema.allOf || schema.oneOf || schema.anyOf) {
+            responseTypesToGenerate.set(typeName, schema);
+          }
+        }
+      }
+    }
+  }
+  return responseTypesToGenerate;
+}
+
+// src/utils/generate-helper-file.ts
+function generateHelperFile() {
+  const output = [];
+  output.push("// Generated helper types for Zenko");
+  output.push(
+    "// This file provides type definitions for operation objects and path functions"
+  );
+  output.push("");
+  output.push(
+    "export type PathFn<TArgs extends unknown[] = []> = (...args: TArgs) => string"
+  );
+  output.push("");
+  output.push(
+    'export type RequestMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace"'
+  );
+  output.push("");
+  output.push(
+    "export type HeaderFn<TArgs extends unknown[] = [], TResult = Record<string, unknown> | Record<string, never>> = (...args: TArgs) => TResult"
+  );
+  output.push("");
+  output.push(
+    "export type AnyHeaderFn = HeaderFn<any, unknown> | (() => unknown)"
+  );
+  output.push("");
+  output.push(
+    "export type OperationErrors<TError = unknown> = TError extends Record<string, unknown> ? TError : Record<string, TError>;"
+  );
+  output.push("");
+  output.push(
+    "export type OperationDefinition<TMethod extends RequestMethod, TPath extends (...args: any[]) => string, TRequest = undefined, TResponse = undefined, THeaders extends AnyHeaderFn | undefined = undefined, TErrors extends OperationErrors | undefined = undefined> = {"
+  );
+  output.push("  method: TMethod");
+  output.push("  path: TPath");
+  output.push("  request?: TRequest");
+  output.push("  response?: TResponse");
+  output.push("  headers?: THeaders");
+  output.push("  errors?: TErrors");
+  output.push("}");
+  output.push("");
+  return output.join("\n");
+}
+
 // src/zenko.ts
 function generateWithMetadata(spec, options = {}) {
   const output = [];
@@ -220,7 +383,14 @@ function generateWithMetadata(spec, options = {}) {
     strictNumeric
   };
   output.push('import { z } from "zod";');
-  appendHelperTypesImport(output, typesConfig);
+  const nameMap = /* @__PURE__ */ new Map();
+  if (spec.components?.schemas) {
+    for (const name of Object.keys(spec.components.schemas)) {
+      nameMap.set(name, toCamelCase(name));
+    }
+  }
+  const operations = parseOperations(spec, nameMap);
+  appendHelperTypesImport(output, typesConfig, operations);
   output.push("");
   if (spec.components?.schemas) {
     output.push("// Generated Zod Schemas");
@@ -228,15 +398,23 @@ function generateWithMetadata(spec, options = {}) {
     const sortedSchemas = topologicalSort(spec.components.schemas);
     for (const name of sortedSchemas) {
       const schema = spec.components.schemas[name];
+      const sanitizedName = nameMap.get(name);
       output.push(
-        generateZodSchema(name, schema, generatedTypes, schemaOptions)
+        generateZodSchema(
+          sanitizedName,
+          schema,
+          generatedTypes,
+          schemaOptions,
+          nameMap
+        )
       );
       output.push("");
-      output.push(`export type ${name} = z.infer<typeof ${name}>;`);
+      output.push(
+        `export type ${sanitizedName} = z.infer<typeof ${sanitizedName}>;`
+      );
       output.push("");
     }
   }
-  const operations = parseOperations(spec);
   output.push("// Path Functions");
   output.push("export const paths = {");
   for (const op of operations) {
@@ -250,24 +428,37 @@ function generateWithMetadata(spec, options = {}) {
       );
       continue;
     }
-    const allParamNames = [
-      ...pathParamNames,
-      ...op.queryParams.map((p) => p.name)
-    ];
-    const signaturePieces = [];
+    const alias = (n) => {
+      if (isValidJSIdentifier(n)) return n;
+      let aliased = toCamelCase(n);
+      if (!isValidJSIdentifier(aliased)) {
+        aliased = `_${aliased}`;
+      }
+      return aliased;
+    };
+    const destructPieces = [];
+    const typePieces = [];
     for (const param of op.pathParams) {
-      signaturePieces.push(`${param.name}: string`);
+      destructPieces.push(
+        isValidJSIdentifier(param.name) ? param.name : `${formatPropertyName(param.name)}: ${alias(param.name)}`
+      );
+      typePieces.push(`${formatPropertyName(param.name)}: string`);
     }
     for (const param of op.queryParams) {
-      signaturePieces.push(
-        `${param.name}${param.required ? "" : "?"}: ${mapQueryType(param)}`
+      destructPieces.push(
+        isValidJSIdentifier(param.name) ? param.name : `${formatPropertyName(param.name)}: ${alias(param.name)}`
+      );
+      typePieces.push(
+        `${formatPropertyName(param.name)}${param.required ? "" : "?"}: ${mapQueryType(param)}`
       );
     }
-    const signatureParams = signaturePieces.join(", ");
     const needsDefaultObject = !hasPathParams && hasQueryParams && op.queryParams.every((param) => !param.required);
-    const signatureArgs = allParamNames.length ? `{ ${allParamNames.join(", ")} }` : "{}";
-    const signature = `${signatureArgs}: { ${signatureParams} }${needsDefaultObject ? " = {}" : ""}`;
-    const pathWithParams = op.path.replace(/{([^}]+)}/g, "${$1}");
+    const signatureArgs = destructPieces.length ? `{ ${destructPieces.join(", ")} }` : "{}";
+    const signature = `${signatureArgs}: { ${typePieces.join(", ")} }${needsDefaultObject ? " = {}" : ""}`;
+    const pathWithParams = op.path.replace(
+      /{([^}]+)}/g,
+      (_m, n) => `\${${alias(n)}}`
+    );
     if (!hasQueryParams) {
       output.push(
         `  ${formatPropertyName(camelCaseOperationId)}: (${signature}) => \`${pathWithParams}\`,`
@@ -279,8 +470,7 @@ function generateWithMetadata(spec, options = {}) {
     );
     output.push("    const params = new URLSearchParams()");
     for (const param of op.queryParams) {
-      const propertyKey = formatPropertyName(param.name);
-      const accessor = isValidJSIdentifier(param.name) ? param.name : propertyKey;
+      const accessor = isValidJSIdentifier(param.name) ? param.name : alias(toCamelCase(param.name));
       const schema = param.schema ?? {};
       if (schema?.type === "array") {
         const itemValueExpression = convertQueryParamValue(
@@ -362,6 +552,8 @@ function generateWithMetadata(spec, options = {}) {
   }
   output.push("} as const;");
   output.push("");
+  generateRequestTypes(output, operations, spec, nameMap, schemaOptions);
+  generateResponseTypes(output, operations, spec, nameMap, schemaOptions);
   generateOperationTypes(output, operations, typesConfig);
   output.push("// Operation Objects");
   for (const op of operations) {
@@ -375,13 +567,8 @@ function generateWithMetadata(spec, options = {}) {
     if (op.requestHeaders && op.requestHeaders.length > 0) {
       output.push(`  headers: headers.${camelCaseOperationId},`);
     }
-    if (op.errors && hasAnyErrors(op.errors)) {
-      output.push("  errors: {");
-      appendErrorGroup(output, "clientErrors", op.errors.clientErrors);
-      appendErrorGroup(output, "serverErrors", op.errors.serverErrors);
-      appendErrorGroup(output, "defaultErrors", op.errors.defaultErrors);
-      appendErrorGroup(output, "otherErrors", op.errors.otherErrors);
-      output.push("  },");
+    if (op.errors && hasAnyErrors2(op.errors)) {
+      appendErrorGroup(output, "errors", op.errors);
     }
     output.push("} as const;");
     output.push("");
@@ -397,6 +584,46 @@ function generateWithMetadata(spec, options = {}) {
   }
   return result;
 }
+function generateRequestTypes(output, operations, spec, nameMap, schemaOptions) {
+  const requestTypesToGenerate = collectInlineRequestTypes(operations, spec);
+  if (requestTypesToGenerate.size > 0) {
+    output.push("// Generated Request Types");
+    output.push("");
+    for (const [typeName, schema] of requestTypesToGenerate) {
+      const generatedSchema = generateZodSchema(
+        typeName,
+        schema,
+        /* @__PURE__ */ new Set(),
+        schemaOptions,
+        nameMap
+      );
+      output.push(generatedSchema);
+      output.push("");
+      output.push(`export type ${typeName} = z.infer<typeof ${typeName}>;`);
+      output.push("");
+    }
+  }
+}
+function generateResponseTypes(output, operations, spec, nameMap, schemaOptions) {
+  const responseTypesToGenerate = collectInlineResponseTypes(operations, spec);
+  if (responseTypesToGenerate.size > 0) {
+    output.push("// Generated Response Types");
+    output.push("");
+    for (const [typeName, schema] of responseTypesToGenerate) {
+      const generatedSchema = generateZodSchema(
+        typeName,
+        schema,
+        /* @__PURE__ */ new Set(),
+        schemaOptions,
+        nameMap
+      );
+      output.push(generatedSchema);
+      output.push("");
+      output.push(`export type ${typeName} = z.infer<typeof ${typeName}>;`);
+      output.push("");
+    }
+  }
+}
 function appendOperationField(buffer, key, value) {
   if (!value) return;
   buffer.push(`  ${key}: ${value},`);
@@ -409,13 +636,8 @@ function appendErrorGroup(buffer, label, errors) {
   }
   buffer.push("    },");
 }
-function hasAnyErrors(group) {
-  return [
-    group.clientErrors,
-    group.serverErrors,
-    group.defaultErrors,
-    group.otherErrors
-  ].some((bucket) => bucket && Object.keys(bucket).length > 0);
+function hasAnyErrors2(group) {
+  return Boolean(group && Object.keys(group).length > 0);
 }
 function isRequestMethod(method) {
   switch (method) {
@@ -462,33 +684,70 @@ function inferResponseType(contentType, statusCode) {
   }
   return "unknown";
 }
-function parseOperations(spec) {
+function parseOperations(spec, nameMap) {
   const operations = [];
-  for (const [path2, pathItem] of Object.entries(spec.paths)) {
-    for (const [method, operation] of Object.entries(pathItem)) {
-      const normalizedMethod = method.toLowerCase();
-      if (!isRequestMethod(normalizedMethod)) continue;
-      if (!operation.operationId) continue;
-      const pathParams = extractPathParams(path2);
-      const requestType = getRequestType(operation);
-      const { successResponse, errors } = getResponseTypes(
-        operation,
-        operation.operationId
-      );
-      const resolvedParameters = collectParameters(pathItem, operation, spec);
-      const requestHeaders = getRequestHeaders(resolvedParameters);
-      const queryParams = getQueryParams(resolvedParameters);
-      operations.push({
-        operationId: operation.operationId,
-        path: path2,
-        method: normalizedMethod,
-        pathParams,
-        queryParams,
-        requestType,
-        responseType: successResponse,
-        requestHeaders,
-        errors
-      });
+  if (spec.paths) {
+    for (const [path2, pathItem] of Object.entries(spec.paths)) {
+      for (const [method, operation] of Object.entries(pathItem)) {
+        const normalizedMethod = method.toLowerCase();
+        if (!isRequestMethod(normalizedMethod)) continue;
+        if (!operation.operationId) continue;
+        const pathParams = extractPathParams(path2);
+        const requestType = getRequestType(operation);
+        const { successResponse, errors } = getResponseTypes(
+          operation,
+          operation.operationId,
+          nameMap
+        );
+        const resolvedParameters = collectParameters(pathItem, operation, spec);
+        const requestHeaders = getRequestHeaders(resolvedParameters);
+        const queryParams = getQueryParams(resolvedParameters);
+        operations.push({
+          operationId: operation.operationId,
+          path: path2,
+          method: normalizedMethod,
+          pathParams,
+          queryParams,
+          requestType,
+          responseType: successResponse,
+          requestHeaders,
+          errors
+        });
+      }
+    }
+  }
+  if (spec.webhooks) {
+    for (const [webhookName, webhookItem] of Object.entries(spec.webhooks)) {
+      for (const [method, operation] of Object.entries(webhookItem)) {
+        const normalizedMethod = method.toLowerCase();
+        if (!isRequestMethod(normalizedMethod)) continue;
+        if (!operation.operationId) continue;
+        const path2 = webhookName;
+        const pathParams = extractPathParams(path2);
+        const requestType = getRequestType(operation);
+        const { successResponse, errors } = getResponseTypes(
+          operation,
+          operation.operationId
+        );
+        const resolvedParameters = collectParameters(
+          webhookItem,
+          operation,
+          spec
+        );
+        const requestHeaders = getRequestHeaders(resolvedParameters);
+        const queryParams = getQueryParams(resolvedParameters);
+        operations.push({
+          operationId: operation.operationId,
+          path: path2,
+          method: normalizedMethod,
+          pathParams,
+          queryParams,
+          requestType,
+          responseType: successResponse,
+          requestHeaders,
+          errors
+        });
+      }
     }
   }
   return operations;
@@ -497,21 +756,42 @@ function normalizeTypesConfig(config) {
   return {
     emit: config?.emit ?? true,
     helpers: config?.helpers ?? "package",
-    helpersOutput: config?.helpersOutput ?? "./zenko-types"
+    helpersOutput: config?.helpersOutput ?? "./zenko-types",
+    treeShake: config?.treeShake ?? true
   };
 }
-function appendHelperTypesImport(buffer, config) {
+function appendHelperTypesImport(buffer, config, operations) {
   if (!config.emit) return;
   switch (config.helpers) {
     case "package":
-      buffer.push(
-        'import type { PathFn, HeaderFn, OperationDefinition, OperationErrors } from "zenko";'
-      );
+      if (config.treeShake) {
+        const usage = analyzeZenkoUsage(operations);
+        const importStatement = generateZenkoImport(usage, "package");
+        if (importStatement) {
+          buffer.push(importStatement);
+        }
+      } else {
+        buffer.push(
+          'import type { PathFn, HeaderFn, OperationDefinition, OperationErrors } from "zenko";'
+        );
+      }
       return;
     case "file":
-      buffer.push(
-        `import type { PathFn, HeaderFn, OperationDefinition, OperationErrors } from "${config.helpersOutput}";`
-      );
+      if (config.treeShake) {
+        const usage = analyzeZenkoUsage(operations);
+        const importStatement = generateZenkoImport(
+          usage,
+          "file",
+          config.helpersOutput
+        );
+        if (importStatement) {
+          buffer.push(importStatement);
+        }
+      } else {
+        buffer.push(
+          `import type { PathFn, HeaderFn, OperationDefinition, OperationErrors } from "${config.helpersOutput}";`
+        );
+      }
       return;
     case "inline":
       buffer.push(
@@ -527,24 +807,19 @@ function appendHelperTypesImport(buffer, config) {
         "type AnyHeaderFn = HeaderFn<any, unknown> | (() => unknown);"
       );
       buffer.push(
-        "type OperationErrors<TClient = unknown, TServer = unknown, TDefault = unknown, TOther = unknown> = {"
+        "type OperationErrors<TError = unknown> = TError extends Record<string, unknown> ? TError : Record<string, TError>;"
       );
-      buffer.push("  clientErrors?: TClient;");
-      buffer.push("  serverErrors?: TServer;");
-      buffer.push("  defaultErrors?: TDefault;");
-      buffer.push("  otherErrors?: TOther;");
-      buffer.push("};");
       buffer.push(
         "type OperationDefinition<TMethod extends RequestMethod, TPath extends (...args: any[]) => string, TRequest = undefined, TResponse = undefined, THeaders extends AnyHeaderFn | undefined = undefined, TErrors extends OperationErrors | undefined = undefined> = {"
       );
-      buffer.push("  method: TMethod;");
-      buffer.push("  path: TPath;");
-      buffer.push("  request?: TRequest;");
-      buffer.push("  response?: TResponse;");
-      buffer.push("  headers?: THeaders;");
-      buffer.push("  errors?: TErrors;");
-      buffer.push("};");
-      return;
+      buffer.push("  method: TMethod");
+      buffer.push("  path: TPath");
+      buffer.push("  request?: TRequest");
+      buffer.push("  response?: TResponse");
+      buffer.push("  headers?: THeaders");
+      buffer.push("  errors?: TErrors");
+      buffer.push("}");
+      buffer.push("");
   }
 }
 function generateOperationTypes(buffer, operations, config) {
@@ -572,14 +847,11 @@ function generateOperationTypes(buffer, operations, config) {
   }
 }
 function buildOperationErrorsType(errors) {
-  if (!errors || !hasAnyErrors(errors)) {
+  if (!errors || !hasAnyErrors2(errors)) {
     return "OperationErrors";
   }
-  const client = buildErrorBucket(errors.clientErrors);
-  const server = buildErrorBucket(errors.serverErrors);
-  const fallback = buildErrorBucket(errors.defaultErrors);
-  const other = buildErrorBucket(errors.otherErrors);
-  return `OperationErrors<${client}, ${server}, ${fallback}, ${other}>`;
+  const errorBucket = buildErrorBucket(errors);
+  return `OperationErrors<${errorBucket}>`;
 }
 function buildErrorBucket(bucket) {
   if (!bucket || Object.keys(bucket).length === 0) {
@@ -686,10 +958,10 @@ function getRequestType(operation) {
   if (requestBody.$ref) {
     return extractRefName(requestBody.$ref);
   }
-  const typeName = `${capitalize(operation.operationId)}Request`;
+  const typeName = `${capitalize(toCamelCase(operation.operationId))}Request`;
   return typeName;
 }
-function getResponseTypes(operation, operationId) {
+function getResponseTypes(operation, operationId, nameMap) {
   const responses = operation.responses ?? {};
   const successCodes = /* @__PURE__ */ new Map();
   const errorEntries = [];
@@ -730,11 +1002,15 @@ function getResponseTypes(operation, operationId) {
       successCodes.set(statusCode, resolvedSchema);
     }
   }
-  const successResponse = selectSuccessResponse(successCodes, operationId);
-  const errors = buildErrorGroups(errorEntries, operationId);
+  const successResponse = selectSuccessResponse(
+    successCodes,
+    operationId,
+    nameMap
+  );
+  const errors = buildErrorGroups(errorEntries, operationId, nameMap);
   return { successResponse, errors };
 }
-function selectSuccessResponse(responses, operationId) {
+function selectSuccessResponse(responses, operationId, nameMap) {
   if (responses.size === 0) return void 0;
   const preferredOrder = ["200", "201", "204"];
   for (const code of preferredOrder) {
@@ -745,61 +1021,51 @@ function selectSuccessResponse(responses, operationId) {
       }
       return resolveResponseType(
         schema,
-        `${capitalize(operationId)}Response${code}`
+        `${capitalize(toCamelCase(operationId))}Response`,
+        nameMap
       );
     }
   }
-  const [firstCode, firstSchema] = responses.entries().next().value ?? [];
+  const [, firstSchema] = responses.entries().next().value ?? [];
   if (!firstSchema) return void 0;
   if (typeof firstSchema === "string") {
     return firstSchema;
   }
   return resolveResponseType(
     firstSchema,
-    `${capitalize(operationId)}Response${firstCode ?? "Default"}`
+    `${capitalize(toCamelCase(operationId))}Response`,
+    nameMap
   );
 }
-function buildErrorGroups(errors = [], operationId) {
+function buildErrorGroups(errors = [], operationId, nameMap) {
   if (!errors.length) return void 0;
   const group = {};
   for (const { code, schema } of errors) {
-    const category = getStatusCategory(code);
     const identifier = mapStatusToIdentifier(code);
     const typeName = resolveResponseType(
       schema,
-      `${capitalize(operationId)}${capitalize(identifier)}`
+      `${capitalize(toCamelCase(operationId))}${capitalize(identifier)}`,
+      nameMap
     );
-    switch (category) {
-      case "client":
-        group.clientErrors ??= {};
-        group.clientErrors[identifier] = typeName;
-        break;
-      case "server":
-        group.serverErrors ??= {};
-        group.serverErrors[identifier] = typeName;
-        break;
-      case "default":
-        group.defaultErrors ??= {};
-        group.defaultErrors[identifier] = typeName;
-        break;
-      default:
-        group.otherErrors ??= {};
-        group.otherErrors[identifier] = typeName;
-        break;
-    }
+    group[identifier] = typeName;
   }
   return group;
 }
-function resolveResponseType(schema, fallbackName) {
+function resolveResponseType(schema, fallbackName, nameMap) {
   if (typeof schema === "string") {
     return schema;
   }
   if (schema.$ref) {
-    return extractRefName(schema.$ref);
+    const refName = extractRefName(schema.$ref);
+    return nameMap?.get(refName) || refName;
   }
   if (schema.type === "array" && schema.items?.$ref) {
     const itemRef = extractRefName(schema.items.$ref);
-    return `z.array(${itemRef})`;
+    const sanitizedItemRef = nameMap?.get(itemRef) || itemRef;
+    return `z.array(${sanitizedItemRef})`;
+  }
+  if (schema.allOf && Array.isArray(schema.allOf)) {
+    return fallbackName;
   }
   return fallbackName;
 }
@@ -882,19 +1148,30 @@ function convertQueryParamValue(schema, accessor) {
       return `String(${accessor})`;
   }
 }
-function generateZodSchema(name, schema, generatedTypes, options) {
+function generateZodSchema(name, schema, generatedTypes, options, nameMap) {
   if (generatedTypes.has(name)) return "";
   generatedTypes.add(name);
   if (schema.enum) {
     const enumValues = schema.enum.map((v) => `"${v}"`).join(", ");
     return `export const ${name} = z.enum([${enumValues}]);`;
   }
+  if (schema.allOf && Array.isArray(schema.allOf)) {
+    const allOfParts = schema.allOf.map(
+      (part) => getZodTypeFromSchema(part, options, nameMap)
+    );
+    if (allOfParts.length === 0) return `export const ${name} = z.object({});`;
+    if (allOfParts.length === 1)
+      return `export const ${name} = ${allOfParts[0]};`;
+    const first = allOfParts[0];
+    const rest = allOfParts.slice(1).map((part) => `.and(${part})`).join("");
+    return `export const ${name} = ${first}${rest};`;
+  }
   if (schema.type === "object" || schema.properties) {
-    return `export const ${name} = ${buildZodObject(schema, options)};`;
+    return `export const ${name} = ${buildZodObject(schema, options, nameMap)};`;
   }
   if (schema.type === "array") {
     const itemSchema = schema.items ?? { type: "unknown" };
-    const itemType = getZodTypeFromSchema(itemSchema, options);
+    const itemType = getZodTypeFromSchema(itemSchema, options, nameMap);
     const builder = applyStrictArrayBounds(
       schema,
       `z.array(${itemType})`,
@@ -903,18 +1180,29 @@ function generateZodSchema(name, schema, generatedTypes, options) {
     );
     return `export const ${name} = ${builder};`;
   }
-  return `export const ${name} = ${getZodTypeFromSchema(schema, options)};`;
+  return `export const ${name} = ${getZodTypeFromSchema(schema, options, nameMap)};`;
 }
-function getZodTypeFromSchema(schema, options) {
+function getZodTypeFromSchema(schema, options, nameMap) {
   if (schema.$ref) {
-    return extractRefName(schema.$ref);
+    const refName = extractRefName(schema.$ref);
+    return nameMap?.get(refName) || refName;
   }
   if (schema.enum) {
     const enumValues = schema.enum.map((v) => `"${v}"`).join(", ");
     return `z.enum([${enumValues}])`;
   }
-  if (schema.type === "object" || schema.properties) {
-    return buildZodObject(schema, options);
+  if (schema.allOf && Array.isArray(schema.allOf)) {
+    const allOfParts = schema.allOf.map(
+      (part) => getZodTypeFromSchema(part, options, nameMap)
+    );
+    if (allOfParts.length === 0) return "z.object({})";
+    if (allOfParts.length === 1) return allOfParts[0];
+    const first = allOfParts[0];
+    const rest = allOfParts.slice(1).map((part) => `.and(${part})`).join("");
+    return `${first}${rest}`;
+  }
+  if (schema.type === "object" || schema.properties || schema.allOf || schema.oneOf || schema.anyOf) {
+    return buildZodObject(schema, options, nameMap);
   }
   switch (schema.type) {
     case "string":
@@ -924,7 +1212,8 @@ function getZodTypeFromSchema(schema, options) {
     case "array":
       return `z.array(${getZodTypeFromSchema(
         schema.items ?? { type: "unknown" },
-        options
+        options,
+        nameMap
       )})`;
     case "null":
       return "z.null()";
@@ -936,13 +1225,13 @@ function getZodTypeFromSchema(schema, options) {
       return "z.unknown()";
   }
 }
-function buildZodObject(schema, options) {
+function buildZodObject(schema, options, nameMap) {
   const properties = [];
   for (const [propName, propSchema] of Object.entries(
     schema.properties || {}
   )) {
     const isRequired = schema.required?.includes(propName) ?? false;
-    const zodType = getZodTypeFromSchema(propSchema, options);
+    const zodType = getZodTypeFromSchema(propSchema, options, nameMap);
     const finalType = isRequired ? zodType : `${zodType}.optional()`;
     properties.push(`  ${formatPropertyName(propName)}: ${finalType},`);
   }
@@ -1050,57 +1339,6 @@ function applyNumericBounds(schema, builder) {
   }
   return builder;
 }
-function generateHelperFile() {
-  const output = [];
-  output.push("// Generated helper types for Zenko");
-  output.push(
-    "// This file provides type definitions for operation objects and path functions"
-  );
-  output.push("");
-  output.push(
-    "export type PathFn<TArgs extends unknown[] = []> = (...args: TArgs) => string"
-  );
-  output.push("");
-  output.push(
-    'export type RequestMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace"'
-  );
-  output.push("");
-  output.push(
-    "export type HeaderFn<TArgs extends unknown[] = [], TResult = Record<string, unknown> | Record<string, never>> = (...args: TArgs) => TResult"
-  );
-  output.push("");
-  output.push(
-    "export type AnyHeaderFn = HeaderFn<any, unknown> | (() => unknown)"
-  );
-  output.push("");
-  output.push(
-    "export type OperationErrors<TClient = unknown, TServer = unknown, TDefault = unknown, TOther = unknown> = {"
-  );
-  output.push("  clientErrors?: TClient");
-  output.push("  serverErrors?: TServer");
-  output.push("  defaultErrors?: TDefault");
-  output.push("  otherErrors?: TOther");
-  output.push("}");
-  output.push("");
-  output.push(
-    "export type OperationDefinition<TMethod extends RequestMethod, TPath extends (...args: any[]) => string, TRequest = undefined, TResponse = undefined, THeaders extends AnyHeaderFn | undefined = undefined, TErrors extends OperationErrors | undefined = undefined> = {"
-  );
-  output.push("  method: TMethod");
-  output.push("  path: TPath");
-  output.push("  request?: TRequest");
-  output.push("  response?: TResponse");
-  output.push("  headers?: THeaders");
-  output.push("  errors?: TErrors");
-  output.push("}");
-  output.push("");
-  return output.join("\n");
-}
-function toCamelCase(str) {
-  return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
-}
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
 
 // src/cli.ts
 async function main() {
@@ -1267,7 +1505,10 @@ async function generateSingle(options) {
   fs.mkdirSync(path.dirname(resolvedOutput), { recursive: true });
   fs.writeFileSync(resolvedOutput, result.output);
   console.log(`\u2705 Generated TypeScript types in ${resolvedOutput}`);
-  console.log(`\u{1F4C4} Processed ${Object.keys(spec.paths).length} paths`);
+  console.log(`\u{1F4C4} Processed ${Object.keys(spec.paths || {}).length} paths`);
+  if (spec.webhooks) {
+    console.log(`\u{1FA9D} Processed ${Object.keys(spec.webhooks).length} webhooks`);
+  }
   if (result.helperFile) {
     const helperPath = path.isAbsolute(result.helperFile.path) ? result.helperFile.path : path.resolve(path.dirname(resolvedOutput), result.helperFile.path);
     const absoluteResolvedOutput = path.resolve(resolvedOutput);