auto-api-hooks 1.0.0

package/dist/cli.js

@@ -0,0 +1,3308 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import pc2 from 'picocolors';
+import { mkdir, writeFile, readFile } from 'fs/promises';
+import { join, dirname, extname } from 'path';
+import { parse } from 'yaml';
+import SwaggerParser from '@apidevtools/swagger-parser';
+import { buildClientSchema, buildSchema, isNonNullType, isScalarType, isObjectType, isInputObjectType, isEnumType, isUnionType, isListType } from 'graphql';
+
+var _verbose = false;
+function setVerbose(v) {
+  _verbose = v;
+}
+var logger = {
+  info(message) {
+    console.log(pc2.cyan("\u2139"), message);
+  },
+  success(message) {
+    console.log(pc2.green("\u2714"), message);
+  },
+  warn(message) {
+    console.log(pc2.yellow("\u26A0"), message);
+  },
+  error(message) {
+    console.error(pc2.red("\u2716"), message);
+  },
+  verbose(message) {
+    if (_verbose) {
+      console.log(pc2.gray("  \u25B8"), pc2.gray(message));
+    }
+  }
+};
+
+// src/ir/helpers.ts
+var CURSOR_PARAM_NAMES = /* @__PURE__ */ new Set([
+  "cursor",
+  "after",
+  "before",
+  "page_token",
+  "pageToken",
+  "next_token",
+  "nextToken",
+  "starting_after",
+  "startingAfter",
+  "ending_before",
+  "endingBefore"
+]);
+var OFFSET_PARAM_NAMES = /* @__PURE__ */ new Set([
+  "offset",
+  "skip"
+]);
+var LIMIT_PARAM_NAMES = /* @__PURE__ */ new Set([
+  "limit",
+  "count",
+  "size",
+  "per_page",
+  "perPage",
+  "page_size",
+  "pageSize"
+]);
+var PAGE_NUMBER_PARAM_NAMES = /* @__PURE__ */ new Set([
+  "page",
+  "page_number",
+  "pageNumber",
+  "p"
+]);
+var CURSOR_RESPONSE_FIELDS = /* @__PURE__ */ new Set([
+  "next_cursor",
+  "nextCursor",
+  "cursor",
+  "next_page_token",
+  "nextPageToken",
+  "next_token",
+  "nextToken",
+  "endCursor",
+  "end_cursor",
+  "has_more",
+  "hasMore"
+]);
+var ITEMS_FIELDS = /* @__PURE__ */ new Set([
+  "items",
+  "data",
+  "results",
+  "records",
+  "edges",
+  "nodes",
+  "entries",
+  "list",
+  "rows",
+  "content",
+  "hits"
+]);
+function findItemsPath(type) {
+  if (type.kind !== "object") return void 0;
+  for (const prop of type.properties) {
+    if (ITEMS_FIELDS.has(prop.name) && prop.type.kind === "array") {
+      return [prop.name];
+    }
+  }
+  return void 0;
+}
+function findNextPagePath(type) {
+  if (type.kind !== "object") return void 0;
+  for (const prop of type.properties) {
+    if (CURSOR_RESPONSE_FIELDS.has(prop.name)) {
+      return [prop.name];
+    }
+    if ((prop.name === "pagination" || prop.name === "meta" || prop.name === "page_info" || prop.name === "pageInfo") && prop.type.kind === "object") {
+      for (const nested of prop.type.properties) {
+        if (CURSOR_RESPONSE_FIELDS.has(nested.name)) {
+          return [prop.name, nested.name];
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function findPageCountPath(type) {
+  if (type.kind !== "object") return void 0;
+  const PAGE_COUNT_FIELDS = /* @__PURE__ */ new Set([
+    "total_pages",
+    "totalPages",
+    "total_count",
+    "totalCount",
+    "total",
+    "page_count",
+    "pageCount",
+    "last_page",
+    "lastPage"
+  ]);
+  for (const prop of type.properties) {
+    if (PAGE_COUNT_FIELDS.has(prop.name)) {
+      return [prop.name];
+    }
+    if ((prop.name === "pagination" || prop.name === "meta") && prop.type.kind === "object") {
+      for (const nested of prop.type.properties) {
+        if (PAGE_COUNT_FIELDS.has(nested.name)) {
+          return [prop.name, nested.name];
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function detectPagination(op) {
+  const queryParamNames = new Set(op.queryParams.map((p) => p.name));
+  const responseType = op.response.type;
+  for (const name of CURSOR_PARAM_NAMES) {
+    if (queryParamNames.has(name)) {
+      const nextPagePath = findNextPagePath(responseType) ?? [name];
+      const itemsPath = findItemsPath(responseType) ?? [];
+      return {
+        strategy: "cursor",
+        pageParam: name,
+        nextPagePath,
+        itemsPath
+      };
+    }
+  }
+  for (const offsetName of OFFSET_PARAM_NAMES) {
+    if (queryParamNames.has(offsetName)) {
+      const hasLimit = [...LIMIT_PARAM_NAMES].some((n) => queryParamNames.has(n));
+      if (hasLimit) {
+        const itemsPath = findItemsPath(responseType) ?? [];
+        return {
+          strategy: "offset-limit",
+          pageParam: offsetName,
+          nextPagePath: [offsetName],
+          itemsPath
+        };
+      }
+    }
+  }
+  for (const pageName of PAGE_NUMBER_PARAM_NAMES) {
+    if (queryParamNames.has(pageName)) {
+      const itemsPath = findItemsPath(responseType) ?? [];
+      const nextPagePath = findPageCountPath(responseType) ?? [pageName];
+      return {
+        strategy: "page-number",
+        pageParam: pageName,
+        nextPagePath,
+        itemsPath
+      };
+    }
+  }
+  if (responseType.kind === "object") {
+    const cursorPath = findNextPagePath(responseType);
+    const items = findItemsPath(responseType);
+    if (cursorPath && items) {
+      const likelyCursorParam = [...CURSOR_PARAM_NAMES].find((n) => queryParamNames.has(n)) ?? [...PAGE_NUMBER_PARAM_NAMES].find((n) => queryParamNames.has(n));
+      if (likelyCursorParam) {
+        return {
+          strategy: "cursor",
+          pageParam: likelyCursorParam,
+          nextPagePath: cursorPath,
+          itemsPath: items
+        };
+      }
+    }
+  }
+  return void 0;
+}
+function applyPaginationDetection(spec) {
+  const operations = spec.operations.map((op) => {
+    if (op.method !== "GET" && op.method !== "QUERY") {
+      return op;
+    }
+    if (op.pagination) {
+      return op;
+    }
+    const pagination = detectPagination(op);
+    if (pagination) {
+      return { ...op, pagination };
+    }
+    return op;
+  });
+  return { ...spec, operations };
+}
+function isRef(obj) {
+  return typeof obj === "object" && obj !== null && "$ref" in obj;
+}
+var HTTP_METHODS = /* @__PURE__ */ new Set([
+  "get",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "head",
+  "options"
+]);
+function convertSchema(schema) {
+  if (!schema) {
+    return { kind: "primitive", type: "unknown" };
+  }
+  if (schema.oneOf && schema.oneOf.length > 0) {
+    const variants = schema.oneOf.filter((s) => !isRef(s)).map((s) => convertSchema(s));
+    return { kind: "union", variants, description: schema.description };
+  }
+  if (schema.anyOf && schema.anyOf.length > 0) {
+    const variants = schema.anyOf.filter((s) => !isRef(s)).map((s) => convertSchema(s));
+    return { kind: "union", variants, description: schema.description };
+  }
+  if (schema.allOf && schema.allOf.length > 0) {
+    const merged = mergeAllOf(schema.allOf.filter((s) => !isRef(s)));
+    const result = convertSchema(merged);
+    if (schema.description && result.kind === "object") {
+      return { ...result, description: schema.description };
+    }
+    return result;
+  }
+  if (schema.enum && schema.enum.length > 0) {
+    return {
+      kind: "enum",
+      values: schema.enum,
+      name: schema.title,
+      description: schema.description
+    };
+  }
+  if (schema.type === "array") {
+    const arraySchema = schema;
+    const items = isRef(arraySchema.items) ? { kind: "primitive", type: "unknown" } : convertSchema(arraySchema.items);
+    return { kind: "array", items, description: schema.description };
+  }
+  if (schema.type === "object" || schema.properties || !schema.type && hasObjectShape(schema)) {
+    return convertObjectSchema(schema);
+  }
+  if (schema.type === "string" || schema.type === "number" || schema.type === "integer" || schema.type === "boolean") {
+    const result = {
+      kind: "primitive",
+      type: schema.type,
+      description: schema.description
+    };
+    if (schema.format) {
+      result.format = schema.format;
+    }
+    return result;
+  }
+  if (schema.nullable && schema.type) {
+    const inner = convertSchema({ ...schema, nullable: void 0 });
+    return {
+      kind: "union",
+      variants: [inner, { kind: "primitive", type: "null" }],
+      description: schema.description
+    };
+  }
+  return { kind: "primitive", type: "unknown", description: schema.description };
+}
+function hasObjectShape(schema) {
+  return !!(schema.properties || schema.additionalProperties);
+}
+function convertObjectSchema(schema) {
+  const requiredSet = new Set(schema.required ?? []);
+  const properties = [];
+  if (schema.properties) {
+    for (const [name, propSchema] of Object.entries(schema.properties)) {
+      if (isRef(propSchema)) continue;
+      properties.push({
+        name,
+        type: convertSchema(propSchema),
+        required: requiredSet.has(name),
+        description: propSchema.description
+      });
+    }
+  }
+  const result = {
+    kind: "object",
+    properties,
+    description: schema.description
+  };
+  if (schema.title) {
+    result.name = schema.title;
+  }
+  if (schema.additionalProperties !== void 0) {
+    if (typeof schema.additionalProperties === "boolean") {
+      result.additionalProperties = schema.additionalProperties;
+    } else if (!isRef(schema.additionalProperties)) {
+      result.additionalProperties = convertSchema(schema.additionalProperties);
+    }
+  }
+  return result;
+}
+function mergeAllOf(schemas) {
+  const merged = {
+    type: "object",
+    properties: {},
+    required: []
+  };
+  for (const schema of schemas) {
+    if (schema.properties) {
+      Object.assign(merged.properties, schema.properties);
+    }
+    if (schema.required) {
+      merged.required.push(...schema.required);
+    }
+    if (schema.description && !merged.description) {
+      merged.description = schema.description;
+    }
+  }
+  return merged;
+}
+function convertParameter(param) {
+  const schema = param.schema && !isRef(param.schema) ? param.schema : void 0;
+  return {
+    name: param.name,
+    required: param.required ?? param.in === "path",
+    type: convertSchema(schema),
+    description: param.description,
+    in: param.in
+  };
+}
+function convertRequestBody(body) {
+  const jsonContent = body.content["application/json"] ?? body.content["*/*"];
+  if (!jsonContent) {
+    const firstKey = Object.keys(body.content)[0];
+    if (!firstKey) return void 0;
+    const mediaType = body.content[firstKey];
+    return convertMediaTypeToBody(mediaType, firstKey, body);
+  }
+  return convertMediaTypeToBody(jsonContent, "application/json", body);
+}
+function convertMediaTypeToBody(media, contentType, body) {
+  const schema = media.schema && !isRef(media.schema) ? media.schema : void 0;
+  return {
+    required: body.required ?? false,
+    contentType,
+    type: convertSchema(schema),
+    description: body.description
+  };
+}
+function convertResponse(responses) {
+  const successCodes = ["200", "201"];
+  let responseObj;
+  let statusCode = 200;
+  for (const code of successCodes) {
+    const candidate = responses[code];
+    if (candidate && !isRef(candidate)) {
+      responseObj = candidate;
+      statusCode = parseInt(code, 10);
+      break;
+    }
+  }
+  if (!responseObj) {
+    for (const [code, value] of Object.entries(responses)) {
+      if (code.startsWith("2") && !isRef(value)) {
+        responseObj = value;
+        statusCode = parseInt(code, 10);
+        break;
+      }
+    }
+  }
+  if (!responseObj) {
+    const defaultResp = responses["default"];
+    if (defaultResp && !isRef(defaultResp)) {
+      responseObj = defaultResp;
+      statusCode = "default";
+    }
+  }
+  if (!responseObj) {
+    return {
+      statusCode: 200,
+      contentType: "application/json",
+      type: { kind: "primitive", type: "unknown" }
+    };
+  }
+  const content = responseObj.content;
+  if (!content) {
+    return {
+      statusCode,
+      contentType: "application/json",
+      type: { kind: "primitive", type: "unknown" },
+      description: responseObj.description
+    };
+  }
+  const jsonMedia = content["application/json"] ?? content["*/*"];
+  if (jsonMedia) {
+    const schema = jsonMedia.schema && !isRef(jsonMedia.schema) ? jsonMedia.schema : void 0;
+    return {
+      statusCode,
+      contentType: "application/json",
+      type: convertSchema(schema),
+      description: responseObj.description
+    };
+  }
+  const firstKey = Object.keys(content)[0];
+  if (firstKey) {
+    const media = content[firstKey];
+    const schema = media.schema && !isRef(media.schema) ? media.schema : void 0;
+    return {
+      statusCode,
+      contentType: firstKey,
+      type: convertSchema(schema),
+      description: responseObj.description
+    };
+  }
+  return {
+    statusCode,
+    contentType: "application/json",
+    type: { kind: "primitive", type: "unknown" },
+    description: responseObj.description
+  };
+}
+function generateOperationId(method, path) {
+  const segments = path.split("/").filter(Boolean).map((seg) => {
+    const clean = seg.replace(/[{}]/g, "");
+    return clean.charAt(0).toUpperCase() + clean.slice(1);
+  });
+  return method.toLowerCase() + segments.join("");
+}
+var openApiParser = {
+  canParse(input) {
+    if (typeof input !== "object" || input === null) return false;
+    const doc = input;
+    return typeof doc.openapi === "string" && doc.openapi.startsWith("3");
+  },
+  async parse(input, options) {
+    const derefed = await SwaggerParser.dereference(
+      input,
+      { dereference: { circular: "ignore" } }
+    );
+    const doc = derefed;
+    const types = /* @__PURE__ */ new Map();
+    if (doc.components?.schemas) {
+      for (const [name, schema] of Object.entries(doc.components.schemas)) {
+        if (!isRef(schema)) {
+          const converted = convertSchema(schema);
+          if (converted.kind === "object" && !converted.name) {
+            converted.name = name;
+          } else if (converted.kind === "enum" && !converted.name) {
+            converted.name = name;
+          }
+          types.set(name, converted);
+        }
+      }
+    }
+    const baseUrl = options?.baseUrl ?? (doc.servers && doc.servers.length > 0 ? doc.servers[0].url : "");
+    const operations = [];
+    if (doc.paths) {
+      for (const [path, pathItem] of Object.entries(doc.paths)) {
+        if (!pathItem) continue;
+        const pathLevelParams = (pathItem.parameters ?? []).filter((p) => !isRef(p));
+        for (const method of HTTP_METHODS) {
+          const operationObj = pathItem[method];
+          if (!operationObj) continue;
+          const opParams = (operationObj.parameters ?? []).filter((p) => !isRef(p));
+          const mergedParams = mergeParameters(pathLevelParams, opParams);
+          const pathParams = [];
+          const queryParams = [];
+          const headerParams = [];
+          for (const param of mergedParams) {
+            const converted = convertParameter(param);
+            switch (param.in) {
+              case "path":
+                pathParams.push(converted);
+                break;
+              case "query":
+                queryParams.push(converted);
+                break;
+              case "header":
+                headerParams.push(converted);
+                break;
+            }
+          }
+          let requestBody;
+          if (operationObj.requestBody && !isRef(operationObj.requestBody)) {
+            requestBody = convertRequestBody(operationObj.requestBody);
+          }
+          const response = convertResponse(
+            operationObj.responses
+          );
+          const tags = operationObj.tags && operationObj.tags.length > 0 ? operationObj.tags : ["default"];
+          const operationId = operationObj.operationId ?? generateOperationId(method, path);
+          operations.push({
+            operationId,
+            summary: operationObj.summary,
+            method: method.toUpperCase(),
+            path,
+            tags,
+            pathParams,
+            queryParams,
+            headerParams,
+            requestBody,
+            response,
+            deprecated: operationObj.deprecated ?? false
+          });
+        }
+      }
+    }
+    return {
+      title: doc.info?.title ?? "Untitled API",
+      baseUrl,
+      version: doc.info?.version ?? "0.0.0",
+      operations,
+      types
+    };
+  }
+};
+function mergeParameters(pathParams, opParams) {
+  const opParamKeys = new Set(opParams.map((p) => `${p.in}:${p.name}`));
+  const filtered = pathParams.filter((p) => !opParamKeys.has(`${p.in}:${p.name}`));
+  return [...filtered, ...opParams];
+}
+function isRef2(obj) {
+  return typeof obj === "object" && obj !== null && "$ref" in obj;
+}
+function isBodyParam(param) {
+  return param.in === "body";
+}
+var HTTP_METHODS2 = /* @__PURE__ */ new Set([
+  "get",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "head",
+  "options"
+]);
+function convertSchema2(schema) {
+  if (!schema) {
+    return { kind: "primitive", type: "unknown" };
+  }
+  if (schema.oneOf && schema.oneOf.length > 0) {
+    const variants = schema.oneOf.filter((s) => !isRef2(s)).map((s) => convertSchema2(s));
+    return { kind: "union", variants, description: schema.description };
+  }
+  if (schema.anyOf && schema.anyOf.length > 0) {
+    const variants = schema.anyOf.filter((s) => !isRef2(s)).map((s) => convertSchema2(s));
+    return { kind: "union", variants, description: schema.description };
+  }
+  if (schema.allOf && schema.allOf.length > 0) {
+    const merged = mergeAllOf2(
+      schema.allOf.filter((s) => !isRef2(s))
+    );
+    const result = convertSchema2(merged);
+    if (schema.description && result.kind === "object") {
+      return { ...result, description: schema.description };
+    }
+    return result;
+  }
+  if (schema.enum && schema.enum.length > 0) {
+    return {
+      kind: "enum",
+      values: schema.enum,
+      name: schema.title,
+      description: schema.description
+    };
+  }
+  const schemaType = typeof schema.type === "string" ? schema.type : void 0;
+  if (schemaType === "array") {
+    let items = { kind: "primitive", type: "unknown" };
+    if (schema.items && !isRef2(schema.items)) {
+      items = convertSchema2(schema.items);
+    }
+    return { kind: "array", items, description: schema.description };
+  }
+  if (schemaType === "object" || schema.properties || !schemaType && hasObjectShape2(schema)) {
+    return convertObjectSchema2(schema);
+  }
+  if (schemaType === "string" || schemaType === "number" || schemaType === "integer" || schemaType === "boolean") {
+    const result = {
+      kind: "primitive",
+      type: schemaType,
+      description: schema.description
+    };
+    if (schema.format) {
+      result.format = schema.format;
+    }
+    return result;
+  }
+  return { kind: "primitive", type: "unknown", description: schema.description };
+}
+function hasObjectShape2(schema) {
+  return !!(schema.properties || schema.additionalProperties);
+}
+function convertObjectSchema2(schema) {
+  const requiredSet = new Set(schema.required ?? []);
+  const properties = [];
+  if (schema.properties) {
+    for (const [name, propSchema] of Object.entries(schema.properties)) {
+      if (isRef2(propSchema)) continue;
+      properties.push({
+        name,
+        type: convertSchema2(propSchema),
+        required: requiredSet.has(name),
+        description: propSchema.description
+      });
+    }
+  }
+  const result = {
+    kind: "object",
+    properties,
+    description: schema.description
+  };
+  if (schema.title) {
+    result.name = schema.title;
+  }
+  if (schema.additionalProperties !== void 0) {
+    if (typeof schema.additionalProperties === "boolean") {
+      result.additionalProperties = schema.additionalProperties;
+    } else if (!isRef2(schema.additionalProperties)) {
+      result.additionalProperties = convertSchema2(schema.additionalProperties);
+    }
+  }
+  return result;
+}
+function mergeAllOf2(schemas) {
+  const merged = {
+    type: "object",
+    properties: {},
+    required: []
+  };
+  for (const schema of schemas) {
+    if (schema.properties) {
+      Object.assign(merged.properties, schema.properties);
+    }
+    if (schema.required) {
+      merged.required.push(...schema.required);
+    }
+    if (schema.description && !merged.description) {
+      merged.description = schema.description;
+    }
+  }
+  return merged;
+}
+function convertGeneralParam(param) {
+  const paramType = param.type;
+  let type;
+  if (param.enum && param.enum.length > 0) {
+    type = {
+      kind: "enum",
+      values: param.enum
+    };
+  } else if (paramType === "array" && param.items) {
+    const itemSchema = isRef2(param.items) ? { kind: "primitive", type: "unknown" } : convertItemsToType(param.items);
+    type = { kind: "array", items: itemSchema };
+  } else {
+    type = {
+      kind: "primitive",
+      type: mapSwagger2Type(paramType),
+      format: param.format
+    };
+  }
+  return {
+    name: param.name,
+    required: param.required ?? param.in === "path",
+    type,
+    description: param.description,
+    in: param.in
+  };
+}
+function convertItemsToType(items) {
+  if (items.enum && items.enum.length > 0) {
+    return { kind: "enum", values: items.enum };
+  }
+  if (items.type === "array" && items.items && !isRef2(items.items)) {
+    return {
+      kind: "array",
+      items: convertItemsToType(items.items)
+    };
+  }
+  return {
+    kind: "primitive",
+    type: mapSwagger2Type(items.type),
+    format: items.format
+  };
+}
+function mapSwagger2Type(t) {
+  switch (t) {
+    case "string":
+      return "string";
+    case "number":
+    case "float":
+    case "double":
+      return "number";
+    case "integer":
+    case "long":
+      return "integer";
+    case "boolean":
+      return "boolean";
+    default:
+      return "unknown";
+  }
+}
+function convertBodyParam(param, produces) {
+  const schema = isRef2(param.schema) ? void 0 : param.schema;
+  return {
+    required: param.required ?? false,
+    contentType: produces.includes("application/json") ? "application/json" : produces[0] ?? "application/json",
+    type: convertSchema2(schema),
+    description: param.description
+  };
+}
+function convertResponse2(responses, produces) {
+  const successCodes = ["200", "201"];
+  let responseObj;
+  let statusCode = 200;
+  for (const code of successCodes) {
+    const candidate = responses[code];
+    if (candidate && !isRef2(candidate)) {
+      responseObj = candidate;
+      statusCode = parseInt(code, 10);
+      break;
+    }
+  }
+  if (!responseObj) {
+    for (const [code, value] of Object.entries(responses)) {
+      if (code.startsWith("2") && value && !isRef2(value)) {
+        responseObj = value;
+        statusCode = parseInt(code, 10);
+        break;
+      }
+    }
+  }
+  if (!responseObj) {
+    const defaultResp = responses["default"];
+    if (defaultResp && !isRef2(defaultResp)) {
+      responseObj = defaultResp;
+      statusCode = "default";
+    }
+  }
+  if (!responseObj || !responseObj.schema) {
+    return {
+      statusCode,
+      contentType: produces[0] ?? "application/json",
+      type: { kind: "primitive", type: "unknown" },
+      description: responseObj?.description
+    };
+  }
+  const schema = isRef2(responseObj.schema) ? void 0 : responseObj.schema;
+  const contentType = produces.includes("application/json") ? "application/json" : produces[0] ?? "application/json";
+  return {
+    statusCode,
+    contentType,
+    type: convertSchema2(schema),
+    description: responseObj.description
+  };
+}
+function generateOperationId2(method, path) {
+  const segments = path.split("/").filter(Boolean).map((seg) => {
+    const clean = seg.replace(/[{}]/g, "");
+    return clean.charAt(0).toUpperCase() + clean.slice(1);
+  });
+  return method.toLowerCase() + segments.join("");
+}
+var swaggerParser = {
+  canParse(input) {
+    if (typeof input !== "object" || input === null) return false;
+    const doc = input;
+    return doc.swagger === "2.0";
+  },
+  async parse(input, options) {
+    const derefed = await SwaggerParser.dereference(
+      input,
+      { dereference: { circular: "ignore" } }
+    );
+    const doc = derefed;
+    const types = /* @__PURE__ */ new Map();
+    if (doc.definitions) {
+      for (const [name, schema] of Object.entries(doc.definitions)) {
+        if (!isRef2(schema)) {
+          const converted = convertSchema2(schema);
+          if (converted.kind === "object" && !converted.name) {
+            converted.name = name;
+          } else if (converted.kind === "enum" && !converted.name) {
+            converted.name = name;
+          }
+          types.set(name, converted);
+        }
+      }
+    }
+    let baseUrl = options?.baseUrl ?? "";
+    if (!baseUrl) {
+      const scheme = doc.schemes && doc.schemes.length > 0 ? doc.schemes[0] : "https";
+      const host = doc.host ?? "";
+      const basePath = doc.basePath ?? "";
+      if (host) {
+        baseUrl = `${scheme}://${host}${basePath}`;
+      } else {
+        baseUrl = basePath;
+      }
+    }
+    const globalProduces = doc.produces ?? ["application/json"];
+    const operations = [];
+    for (const [path, pathItem] of Object.entries(doc.paths)) {
+      if (!pathItem) continue;
+      const pathLevelParams = (pathItem.parameters ?? []).filter((p) => !isRef2(p));
+      for (const method of HTTP_METHODS2) {
+        const operationObj = pathItem[method];
+        if (!operationObj) continue;
+        const opRawParams = (operationObj.parameters ?? []).filter((p) => !isRef2(p));
+        const mergedParams = mergeParameters2(pathLevelParams, opRawParams);
+        const produces = operationObj.produces ?? globalProduces;
+        const pathParams = [];
+        const queryParams = [];
+        const headerParams = [];
+        let requestBody;
+        for (const param of mergedParams) {
+          if (isBodyParam(param)) {
+            requestBody = convertBodyParam(param, produces);
+          } else {
+            const generalParam = param;
+            const converted = convertGeneralParam(generalParam);
+            switch (param.in) {
+              case "path":
+                pathParams.push(converted);
+                break;
+              case "query":
+                queryParams.push(converted);
+                break;
+              case "header":
+                headerParams.push(converted);
+                break;
+            }
+          }
+        }
+        const response = convertResponse2(operationObj.responses, produces);
+        const tags = operationObj.tags && operationObj.tags.length > 0 ? operationObj.tags : ["default"];
+        const operationId = operationObj.operationId ?? generateOperationId2(method, path);
+        operations.push({
+          operationId,
+          summary: operationObj.summary,
+          method: method.toUpperCase(),
+          path,
+          tags,
+          pathParams,
+          queryParams,
+          headerParams,
+          requestBody,
+          response,
+          deprecated: operationObj.deprecated ?? false
+        });
+      }
+    }
+    return {
+      title: doc.info?.title ?? "Untitled API",
+      baseUrl,
+      version: doc.info?.version ?? "0.0.0",
+      operations,
+      types
+    };
+  }
+};
+function mergeParameters2(pathParams, opParams) {
+  const opParamKeys = new Set(opParams.map((p) => `${p.in}:${p.name}`));
+  const filtered = pathParams.filter((p) => !opParamKeys.has(`${p.in}:${p.name}`));
+  return [...filtered, ...opParams];
+}
+function isIntrospectionResult(input) {
+  return typeof input === "object" && input !== null && "__schema" in input;
+}
+function isIntrospectionWrapper(input) {
+  return typeof input === "object" && input !== null && "data" in input && typeof input.data === "object" && input.data !== null && "__schema" in input.data;
+}
+var SDL_KEYWORDS = /^\s*(type |schema |input |enum |union |interface |scalar |directive |extend )/;
+function isSDLString(input) {
+  return typeof input === "string" && SDL_KEYWORDS.test(input);
+}
+function mapScalarType(name) {
+  switch (name) {
+    case "String":
+      return { type: "string" };
+    case "Int":
+      return { type: "number", format: "int32" };
+    case "Float":
+      return { type: "number", format: "float" };
+    case "Boolean":
+      return { type: "boolean" };
+    case "ID":
+      return { type: "string", format: "id" };
+    case "DateTime":
+      return { type: "string", format: "date-time" };
+    case "Date":
+      return { type: "string", format: "date" };
+    case "JSON":
+    case "JSONObject":
+      return { type: "unknown" };
+    default:
+      return { type: "string" };
+  }
+}
+var visitedTypes = /* @__PURE__ */ new Set();
+function convertGraphQLType(graphqlType) {
+  let required = false;
+  let unwrapped = graphqlType;
+  if (isNonNullType(unwrapped)) {
+    required = true;
+    unwrapped = unwrapped.ofType;
+  }
+  const apiType = convertInnerType(unwrapped);
+  return { type: apiType, required };
+}
+function convertInnerType(graphqlType) {
+  if (isListType(graphqlType)) {
+    const inner = isNonNullType(graphqlType.ofType) ? convertInnerType(graphqlType.ofType.ofType) : convertInnerType(graphqlType.ofType);
+    return { kind: "array", items: inner };
+  }
+  if (isScalarType(graphqlType)) {
+    const mapped = mapScalarType(graphqlType.name);
+    return {
+      kind: "primitive",
+      type: mapped.type,
+      format: mapped.format,
+      description: graphqlType.description ?? void 0
+    };
+  }
+  if (isEnumType(graphqlType)) {
+    return {
+      kind: "enum",
+      name: graphqlType.name,
+      values: graphqlType.getValues().map((v) => v.value),
+      description: graphqlType.description ?? void 0
+    };
+  }
+  if (isUnionType(graphqlType)) {
+    const variants = graphqlType.getTypes().map((t) => convertInnerType(t));
+    return {
+      kind: "union",
+      variants,
+      description: graphqlType.description ?? void 0
+    };
+  }
+  if (isObjectType(graphqlType)) {
+    return convertObjectType(graphqlType);
+  }
+  if (isInputObjectType(graphqlType)) {
+    return convertInputObjectType(graphqlType);
+  }
+  return { kind: "primitive", type: "unknown" };
+}
+function convertObjectType(objType) {
+  const name = objType.name;
+  if (visitedTypes.has(name)) {
+    return { kind: "ref", name };
+  }
+  visitedTypes.add(name);
+  try {
+    const fields = objType.getFields();
+    const properties = [];
+    for (const [fieldName, field] of Object.entries(fields)) {
+      const { type, required } = convertGraphQLType(field.type);
+      properties.push({
+        name: fieldName,
+        type,
+        required,
+        description: field.description ?? void 0
+      });
+    }
+    return {
+      kind: "object",
+      name,
+      properties,
+      description: objType.description ?? void 0
+    };
+  } finally {
+    visitedTypes.delete(name);
+  }
+}
+function convertInputObjectType(inputType) {
+  const name = inputType.name;
+  if (visitedTypes.has(name)) {
+    return { kind: "ref", name };
+  }
+  visitedTypes.add(name);
+  try {
+    const fields = inputType.getFields();
+    const properties = [];
+    for (const [fieldName, field] of Object.entries(fields)) {
+      const { type, required } = convertGraphQLType(field.type);
+      properties.push({
+        name: fieldName,
+        type,
+        required,
+        description: field.description ?? void 0
+      });
+    }
+    return {
+      kind: "object",
+      name,
+      properties,
+      description: inputType.description ?? void 0
+    };
+  } finally {
+    visitedTypes.delete(name);
+  }
+}
+function convertArgument(arg) {
+  const { type, required } = convertGraphQLType(arg.type);
+  return {
+    name: arg.name,
+    required,
+    type,
+    description: arg.description ?? void 0,
+    in: "query"
+    // GraphQL args are conceptually similar to query params
+  };
+}
+function buildOperationsFromType(rootType, method, tag) {
+  if (!rootType) return [];
+  const fields = rootType.getFields();
+  const operations = [];
+  for (const [fieldName, field] of Object.entries(fields)) {
+    const args = field.args ?? [];
+    const queryParams = args.map(convertArgument);
+    let requestBody;
+    if (args.length > 0) {
+      const argProperties = args.map((arg) => {
+        const { type, required } = convertGraphQLType(arg.type);
+        return {
+          name: arg.name,
+          type,
+          required,
+          description: arg.description ?? void 0
+        };
+      });
+      requestBody = {
+        required: args.some((arg) => isNonNullType(arg.type)),
+        contentType: "application/json",
+        type: {
+          kind: "object",
+          properties: argProperties
+        }
+      };
+    }
+    const { type: responseType } = convertGraphQLType(field.type);
+    const response = {
+      statusCode: 200,
+      contentType: "application/json",
+      type: responseType,
+      description: field.description ?? void 0
+    };
+    operations.push({
+      operationId: fieldName,
+      summary: field.description ?? void 0,
+      method,
+      path: fieldName,
+      tags: [tag],
+      pathParams: [],
+      queryParams,
+      headerParams: [],
+      requestBody,
+      response,
+      deprecated: field.deprecationReason != null
+    });
+  }
+  return operations;
+}
+function extractNamedTypes(schema) {
+  const types = /* @__PURE__ */ new Map();
+  const typeMap = schema.getTypeMap();
+  for (const [name, graphqlType] of Object.entries(typeMap)) {
+    if (name.startsWith("__")) continue;
+    if (isScalarType(graphqlType)) {
+      const builtins = /* @__PURE__ */ new Set(["String", "Int", "Float", "Boolean", "ID"]);
+      if (builtins.has(name)) continue;
+    }
+    if (isObjectType(graphqlType)) {
+      const queryType = schema.getQueryType();
+      const mutationType = schema.getMutationType();
+      const subscriptionType = schema.getSubscriptionType();
+      if (graphqlType === queryType || graphqlType === mutationType || graphqlType === subscriptionType) {
+        continue;
+      }
+      types.set(name, convertObjectType(graphqlType));
+    } else if (isInputObjectType(graphqlType)) {
+      types.set(name, convertInputObjectType(graphqlType));
+    } else if (isEnumType(graphqlType)) {
+      types.set(name, {
+        kind: "enum",
+        name,
+        values: graphqlType.getValues().map((v) => v.value),
+        description: graphqlType.description ?? void 0
+      });
+    } else if (isUnionType(graphqlType)) {
+      types.set(name, {
+        kind: "union",
+        variants: graphqlType.getTypes().map((t) => convertInnerType(t)),
+        description: graphqlType.description ?? void 0
+      });
+    }
+  }
+  return types;
+}
+var graphqlParser = {
+  canParse(input) {
+    if (isIntrospectionResult(input)) return true;
+    if (isIntrospectionWrapper(input)) return true;
+    if (isSDLString(input)) return true;
+    return false;
+  },
+  async parse(input, options) {
+    let schema;
+    if (isIntrospectionWrapper(input)) {
+      schema = buildClientSchema(input.data);
+    } else if (isIntrospectionResult(input)) {
+      schema = buildClientSchema(input);
+    } else if (typeof input === "string") {
+      schema = buildSchema(input);
+    } else {
+      throw new Error("GraphQL parser: unsupported input format");
+    }
+    visitedTypes.clear();
+    const operations = [
+      ...buildOperationsFromType(schema.getQueryType(), "QUERY", "queries"),
+      ...buildOperationsFromType(schema.getMutationType(), "MUTATION", "mutations"),
+      ...buildOperationsFromType(schema.getSubscriptionType(), "SUBSCRIPTION", "subscriptions")
+    ];
+    const types = extractNamedTypes(schema);
+    visitedTypes.clear();
+    return {
+      title: "GraphQL API",
+      baseUrl: options?.baseUrl ?? "/graphql",
+      version: "0.0.0",
+      operations,
+      types
+    };
+  }
+};
+
+// src/parsers/index.ts
+var ParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ParseError";
+  }
+};
+var parsers = [openApiParser, swaggerParser, graphqlParser];
+var YAML_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml"]);
+var JSON_EXTENSIONS = /* @__PURE__ */ new Set([".json"]);
+var GRAPHQL_EXTENSIONS = /* @__PURE__ */ new Set([".graphql", ".gql"]);
+async function loadFile(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  const ext = extname(filePath).toLowerCase();
+  if (YAML_EXTENSIONS.has(ext)) {
+    return parse(content);
+  }
+  if (JSON_EXTENSIONS.has(ext)) {
+    return JSON.parse(content);
+  }
+  if (GRAPHQL_EXTENSIONS.has(ext)) {
+    return content;
+  }
+  try {
+    return JSON.parse(content);
+  } catch {
+    try {
+      return parse(content);
+    } catch {
+      return content;
+    }
+  }
+}
+async function parseSpec(input, options) {
+  let resolved;
+  if (typeof input === "string") {
+    const looksLikeFile = /\.[a-z]{2,10}$/i.test(input) && !input.includes("\n");
+    if (looksLikeFile) {
+      try {
+        resolved = await loadFile(input);
+      } catch (err) {
+        throw new ParseError(
+          `Failed to read spec file "${input}": ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    } else {
+      try {
+        resolved = JSON.parse(input);
+      } catch {
+        try {
+          const parsed = parse(input);
+          resolved = typeof parsed === "string" ? input : parsed;
+        } catch {
+          resolved = input;
+        }
+      }
+    }
+  } else {
+    resolved = input;
+  }
+  for (const parser of parsers) {
+    if (parser.canParse(resolved)) {
+      const spec = await parser.parse(resolved, options);
+      return applyPaginationDetection(spec);
+    }
+  }
+  const inputType = typeof resolved;
+  let hint = "";
+  if (inputType === "object" && resolved !== null) {
+    const keys = Object.keys(resolved).slice(0, 5);
+    hint = ` Object keys: [${keys.join(", ")}].`;
+  } else if (inputType === "string") {
+    const preview = resolved.slice(0, 80);
+    hint = ` String starts with: "${preview}...".`;
+  }
+  throw new ParseError(
+    `Unable to detect API specification format.${hint} Expected an OpenAPI 3.x document (with "openapi" field starting with "3"), a Swagger 2.0 document (with "swagger": "2.0"), or a GraphQL schema (introspection JSON with "__schema", or SDL string).`
+  );
+}
+
+// src/utils/naming.ts
+var IRREGULAR_PLURALS = {
+  person: "people",
+  child: "children",
+  man: "men",
+  woman: "women",
+  mouse: "mice",
+  goose: "geese",
+  tooth: "teeth",
+  foot: "feet",
+  datum: "data",
+  medium: "media",
+  criterion: "criteria",
+  analysis: "analyses",
+  status: "statuses"
+};
+var IRREGULAR_SINGULARS = Object.fromEntries(
+  Object.entries(IRREGULAR_PLURALS).map(([s, p]) => [p, s])
+);
+function singularize(word) {
+  const lower = word.toLowerCase();
+  if (IRREGULAR_SINGULARS[lower]) {
+    return preserveCase(word, IRREGULAR_SINGULARS[lower]);
+  }
+  if (lower.endsWith("ies") && lower.length > 4) {
+    return word.slice(0, -3) + "y";
+  }
+  if (lower.endsWith("ses") || lower.endsWith("xes") || lower.endsWith("zes") || lower.endsWith("ches") || lower.endsWith("shes")) {
+    return word.slice(0, -2);
+  }
+  if (lower.endsWith("s") && !lower.endsWith("ss") && !lower.endsWith("us") && lower.length > 2) {
+    return word.slice(0, -1);
+  }
+  return word;
+}
+function preserveCase(original, replacement) {
+  if (original[0] === original[0].toUpperCase()) {
+    return replacement[0].toUpperCase() + replacement.slice(1);
+  }
+  return replacement;
+}
+function toPascalCase(str) {
+  return str.replace(/[^a-zA-Z0-9]+(.)/g, (_, char) => char.toUpperCase()).replace(/^[a-z]/, (char) => char.toUpperCase()).replace(/[^a-zA-Z0-9]/g, "");
+}
+function toCamelCase(str) {
+  const pascal = toPascalCase(str);
+  return pascal[0].toLowerCase() + pascal.slice(1);
+}
+function extractResource(path) {
+  const segments = path.split("/").filter((s) => s && !s.startsWith("{"));
+  const meaningful = segments.filter((s) => !/^(api|v\d+)$/i.test(s));
+  return meaningful[meaningful.length - 1] || segments[segments.length - 1] || "unknown";
+}
+function isDetailEndpoint(path) {
+  const segments = path.split("/").filter(Boolean);
+  const last = segments[segments.length - 1];
+  return !!last && last.startsWith("{");
+}
+function getHookName(operationId, method, path) {
+  if (operationId) {
+    const name = toPascalCase(operationId);
+    return `use${name}`;
+  }
+  const resource = extractResource(path);
+  const isDetail = isDetailEndpoint(path);
+  const resourceName = isDetail ? singularize(resource) : resource;
+  const methodMap = {
+    GET: isDetail ? "Get" : "Get",
+    POST: "Create",
+    PUT: "Update",
+    PATCH: "Patch",
+    DELETE: "Delete",
+    QUERY: "Get",
+    MUTATION: "",
+    SUBSCRIPTION: "Subscribe"
+  };
+  const prefix = methodMap[method.toUpperCase()] || method;
+  return `use${prefix}${toPascalCase(resourceName)}`;
+}
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+}
+
+// src/type-gen/typescript-emitter.ts
+function emitTypeScriptTypes(spec) {
+  const chunks = [];
+  chunks.push(fileHeader(spec));
+  for (const [name, type] of spec.types) {
+    chunks.push(emitNamedType(name, type));
+  }
+  for (const op of spec.operations) {
+    const params = emitParamsInterface(op);
+    if (params) {
+      chunks.push(params);
+    }
+    const body = emitRequestBodyType(op);
+    if (body) {
+      chunks.push(body);
+    }
+    chunks.push(emitResponseType(op));
+  }
+  return chunks.join("\n");
+}
+function emitTypeString(type) {
+  switch (type.kind) {
+    case "primitive":
+      return emitPrimitive(type);
+    case "object":
+      return emitObjectInline(type);
+    case "array":
+      return emitArray(type);
+    case "enum":
+      return emitEnum(type);
+    case "union":
+      return emitUnion(type);
+    case "ref":
+      return emitRef(type);
+  }
+}
+function emitParamsInterface(op) {
+  const allParams = [
+    ...op.pathParams,
+    ...op.queryParams,
+    ...op.headerParams
+  ];
+  if (allParams.length === 0) {
+    return null;
+  }
+  const name = `${toPascalCase(op.operationId)}Params`;
+  const lines = [];
+  if (op.summary) {
+    lines.push(jsdoc(op.summary));
+  }
+  lines.push(`export interface ${name} {`);
+  for (const param of allParams) {
+    if (param.description) {
+      lines.push(indent(jsdoc(param.description)));
+    }
+    const optional = param.required ? "" : "?";
+    lines.push(indent(`${safePropName(param.name)}${optional}: ${emitTypeString(param.type)}`));
+  }
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function emitRequestBodyType(op) {
+  if (!op.requestBody) {
+    return null;
+  }
+  const name = `${toPascalCase(op.operationId)}Body`;
+  const lines = [];
+  if (op.requestBody.description) {
+    lines.push(jsdoc(op.requestBody.description));
+  }
+  lines.push(`export type ${name} = ${emitTypeString(op.requestBody.type)}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function emitResponseType(op) {
+  const name = `${toPascalCase(op.operationId)}Response`;
+  const lines = [];
+  if (op.response.description) {
+    lines.push(jsdoc(op.response.description));
+  }
+  lines.push(`export type ${name} = ${emitTypeString(op.response.type)}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function fileHeader(spec) {
+  const lines = [
+    "/* eslint-disable */",
+    "/* tslint:disable */",
+    `/**`,
+    ` * Auto-generated TypeScript types for ${spec.title} (v${spec.version}).`,
+    ` * DO NOT EDIT \u2014 this file is regenerated on every run.`,
+    ` */`,
+    ""
+  ];
+  return lines.join("\n");
+}
+function emitPrimitive(type) {
+  switch (type.type) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    case "unknown":
+      return "unknown";
+  }
+}
+function emitObjectInline(type) {
+  if (type.properties.length === 0 && !type.additionalProperties) {
+    return "Record<string, unknown>";
+  }
+  const members = [];
+  for (const prop of type.properties) {
+    const optional = prop.required ? "" : "?";
+    const comment = prop.description ? ` ${inlineComment(prop.description)}` : "";
+    members.push(
+      `${safePropName(prop.name)}${optional}: ${emitTypeString(prop.type)}${comment}`
+    );
+  }
+  if (type.additionalProperties !== void 0) {
+    if (type.additionalProperties === true) {
+      members.push("[key: string]: unknown");
+    } else if (type.additionalProperties !== false) {
+      members.push(`[key: string]: ${emitTypeString(type.additionalProperties)}`);
+    }
+  }
+  return `{
+${members.map((m) => indent(m)).join("\n")}
+}`;
+}
+function emitArray(type) {
+  const inner = emitTypeString(type.items);
+  if (inner.includes("|") || inner.includes("{")) {
+    return `Array<${inner}>`;
+  }
+  return `${inner}[]`;
+}
+function emitEnum(type) {
+  if (type.values.length === 0) {
+    return "never";
+  }
+  return type.values.map((v) => typeof v === "string" ? `'${escapeString(v)}'` : String(v)).join(" | ");
+}
+function emitUnion(type) {
+  if (type.variants.length === 0) {
+    return "never";
+  }
+  if (type.variants.length === 1) {
+    return emitTypeString(type.variants[0]);
+  }
+  return type.variants.map((v) => emitTypeString(v)).join(" | ");
+}
+function emitRef(type) {
+  return toPascalCase(type.name);
+}
+function emitNamedType(name, type) {
+  const tsName = toPascalCase(name);
+  const lines = [];
+  if (type.kind !== "ref" && type.description) {
+    lines.push(jsdoc(type.description));
+  }
+  if (type.kind === "object") {
+    lines.push(...emitInterface(tsName, type));
+  } else {
+    lines.push(`export type ${tsName} = ${emitTypeString(type)}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function emitInterface(name, type) {
+  const lines = [];
+  lines.push(`export interface ${name} {`);
+  for (const prop of type.properties) {
+    if (prop.description) {
+      lines.push(indent(jsdoc(prop.description)));
+    }
+    const optional = prop.required ? "" : "?";
+    lines.push(indent(`${safePropName(prop.name)}${optional}: ${emitTypeString(prop.type)}`));
+  }
+  if (type.additionalProperties !== void 0) {
+    if (type.additionalProperties === true) {
+      lines.push(indent("[key: string]: unknown"));
+    } else if (type.additionalProperties !== false) {
+      lines.push(indent(`[key: string]: ${emitTypeString(type.additionalProperties)}`));
+    }
+  }
+  lines.push("}");
+  return lines;
+}
+function jsdoc(text) {
+  const trimmed = text.trim();
+  if (!trimmed.includes("\n")) {
+    return `/** ${trimmed} */`;
+  }
+  const lines = trimmed.split("\n");
+  return ["/**", ...lines.map((l) => ` * ${l.trimEnd()}`), " */"].join("\n");
+}
+function inlineComment(text) {
+  const single = text.replace(/\n/g, " ").trim();
+  return `/** ${single} */`;
+}
+function indent(str) {
+  return str.split("\n").map((line) => `  ${line}`).join("\n");
+}
+function safePropName(name) {
+  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)) {
+    return name;
+  }
+  return `'${escapeString(name)}'`;
+}
+function escapeString(value) {
+  return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+
+// src/type-gen/zod-emitter.ts
+function emitZodSchemas(spec) {
+  const chunks = [];
+  chunks.push(fileHeader2(spec));
+  chunks.push("import { z } from 'zod'");
+  chunks.push("");
+  for (const [name, type] of spec.types) {
+    chunks.push(emitNamedSchema(name, type));
+  }
+  for (const op of spec.operations) {
+    chunks.push(emitOperationResponseSchema(op));
+  }
+  return chunks.join("\n");
+}
+function emitZodType(type) {
+  switch (type.kind) {
+    case "primitive":
+      return emitZodPrimitive(type);
+    case "object":
+      return emitZodObject(type);
+    case "array":
+      return emitZodArray(type);
+    case "enum":
+      return emitZodEnum(type);
+    case "union":
+      return emitZodUnion(type);
+    case "ref":
+      return emitZodRef(type);
+  }
+}
+function emitZodPrimitive(type) {
+  switch (type.type) {
+    case "string":
+      return applyStringFormat("z.string()", type.format);
+    case "number":
+      return "z.number()";
+    case "integer":
+      return "z.number().int()";
+    case "boolean":
+      return "z.boolean()";
+    case "null":
+      return "z.null()";
+    case "unknown":
+      return "z.unknown()";
+  }
+}
+function applyStringFormat(base, format) {
+  if (!format) {
+    return base;
+  }
+  switch (format) {
+    case "date-time":
+      return `${base}.datetime()`;
+    case "email":
+      return `${base}.email()`;
+    case "uuid":
+      return `${base}.uuid()`;
+    case "uri":
+    case "url":
+      return `${base}.url()`;
+    default:
+      return base;
+  }
+}
+function emitZodObject(type) {
+  if (type.properties.length === 0 && !type.additionalProperties) {
+    return "z.record(z.string(), z.unknown())";
+  }
+  const members = type.properties.map((prop) => emitZodProperty(prop));
+  let suffix = "";
+  if (type.additionalProperties !== void 0) {
+    if (type.additionalProperties === true) {
+      suffix = ".catchall(z.unknown())";
+    } else if (type.additionalProperties !== false) {
+      suffix = `.catchall(${emitZodType(type.additionalProperties)})`;
+    }
+  }
+  if (members.length === 0) {
+    return `z.object({})${suffix}`;
+  }
+  const body = members.map((m) => indent2(m)).join("\n");
+  return `z.object({
+${body}
+})${suffix}`;
+}
+function emitZodProperty(prop) {
+  const schema = emitZodType(prop.type);
+  const optionalSuffix = prop.required ? "" : ".optional()";
+  const comment = prop.description ? ` ${inlineComment2(prop.description)}` : "";
+  return `${safePropName2(prop.name)}: ${schema}${optionalSuffix},${comment}`;
+}
+function emitZodArray(type) {
+  return `z.array(${emitZodType(type.items)})`;
+}
+function emitZodEnum(type) {
+  if (type.values.length === 0) {
+    return "z.never()";
+  }
+  const allStrings = type.values.every((v) => typeof v === "string");
+  if (allStrings) {
+    const items = type.values.map((v) => `'${escapeString2(String(v))}'`).join(", ");
+    return `z.enum([${items}])`;
+  }
+  const literals = type.values.map(
+    (v) => typeof v === "string" ? `z.literal('${escapeString2(v)}')` : `z.literal(${v})`
+  ).join(", ");
+  return `z.union([${literals}])`;
+}
+function emitZodUnion(type) {
+  if (type.variants.length === 0) {
+    return "z.never()";
+  }
+  if (type.variants.length === 1) {
+    return emitZodType(type.variants[0]);
+  }
+  const members = type.variants.map((v) => emitZodType(v)).join(", ");
+  return `z.union([${members}])`;
+}
+function emitZodRef(type) {
+  return schemaVarName(type.name);
+}
+function emitNamedSchema(name, type) {
+  const varName = schemaVarName(name);
+  const lines = [];
+  if (type.kind !== "ref" && type.description) {
+    lines.push(jsdoc2(type.description));
+  }
+  lines.push(`export const ${varName} = ${emitZodType(type)}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function emitOperationResponseSchema(op) {
+  const varName = `${toCamelCase(op.operationId)}ResponseSchema`;
+  const lines = [];
+  if (op.response.description) {
+    lines.push(jsdoc2(op.response.description));
+  }
+  lines.push(`export const ${varName} = ${emitZodType(op.response.type)}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function schemaVarName(name) {
+  return `${toCamelCase(name)}Schema`;
+}
+function fileHeader2(spec) {
+  const lines = [
+    "/* eslint-disable */",
+    "/* tslint:disable */",
+    `/**`,
+    ` * Auto-generated Zod schemas for ${spec.title} (v${spec.version}).`,
+    ` * DO NOT EDIT \u2014 this file is regenerated on every run.`,
+    ` */`,
+    ""
+  ];
+  return lines.join("\n");
+}
+function jsdoc2(text) {
+  const trimmed = text.trim();
+  if (!trimmed.includes("\n")) {
+    return `/** ${trimmed} */`;
+  }
+  const lines = trimmed.split("\n");
+  return ["/**", ...lines.map((l) => ` * ${l.trimEnd()}`), " */"].join("\n");
+}
+function inlineComment2(text) {
+  const single = text.replace(/\n/g, " ").trim();
+  return `/** ${single} */`;
+}
+function indent2(str) {
+  return str.split("\n").map((line) => `  ${line}`).join("\n");
+}
+function safePropName2(name) {
+  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)) {
+    return name;
+  }
+  return `'${escapeString2(name)}'`;
+}
+function escapeString2(value) {
+  return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+
+// src/generators/base-generator.ts
+var BaseHookGenerator = class {
+  /**
+   * Generate all files for the given spec.
+   */
+  generate(spec, options) {
+    const files = [];
+    files.push({
+      path: "types.ts",
+      content: emitTypeScriptTypes(spec)
+    });
+    if (options.zod) {
+      files.push({
+        path: "schemas.ts",
+        content: emitZodSchemas(spec)
+      });
+    }
+    files.push(this.generateClientConfig(spec, options));
+    const groups = this.groupByTag(spec.operations);
+    const hookExports = [];
+    for (const [tag, operations] of groups) {
+      const groupFiles = this.generateHookGroup(tag, operations, spec, options);
+      files.push(...groupFiles);
+      hookExports.push(tag);
+    }
+    files.push(this.generateBarrelIndex(hookExports, options));
+    return files;
+  }
+  /**
+   * Generate hooks for a single tag group.
+   * Subclasses implement generateHookFile for each operation.
+   */
+  generateHookGroup(tag, operations, spec, options) {
+    const files = [];
+    const tagDir = toKebabCase(tag);
+    const exportNames = [];
+    for (const op of operations) {
+      const hookName = getHookName(op.operationId, op.method, op.path);
+      const fileName = toKebabCase(hookName.replace(/^use/, ""));
+      const hookFile = this.generateHookFile(op, hookName, spec, options);
+      files.push({
+        path: `${tagDir}/${fileName}.ts`,
+        content: hookFile
+      });
+      exportNames.push(hookName);
+      if (options.infiniteQueries && op.pagination && this.supportsInfiniteQueries()) {
+        const infiniteName = `${hookName}Infinite`;
+        const infiniteFile = this.generateInfiniteHookFile(op, infiniteName, spec, options);
+        if (infiniteFile) {
+          files.push({
+            path: `${tagDir}/${fileName}-infinite.ts`,
+            content: infiniteFile
+          });
+          exportNames.push(infiniteName);
+        }
+      }
+    }
+    const groupExports = exportNames.map((name) => {
+      const fileName = toKebabCase(name.replace(/^use/, ""));
+      return `export { ${name} } from './${fileName}'`;
+    }).join("\n");
+    files.push({
+      path: `${tagDir}/index.ts`,
+      content: `${groupExports}
+`
+    });
+    return files;
+  }
+  /**
+   * Generate the base API client configuration file.
+   */
+  generateClientConfig(spec, options) {
+    const baseUrl = options.baseUrl || spec.baseUrl || "";
+    return {
+      path: "client.ts",
+      content: [
+        `/**`,
+        ` * API client configuration.`,
+        ` * Generated by auto-api-hooks \u2014 do not edit manually.`,
+        ` */`,
+        ``,
+        `export const API_BASE_URL = '${baseUrl}'`,
+        ``,
+        `export interface ClientConfig {`,
+        `  baseUrl: string`,
+        `  headers?: Record<string, string>`,
+        `}`,
+        ``,
+        `let _config: ClientConfig = {`,
+        `  baseUrl: API_BASE_URL,`,
+        `}`,
+        ``,
+        `/**`,
+        ` * Configure the API client.`,
+        ` */`,
+        `export function configureClient(config: Partial<ClientConfig>): void {`,
+        `  _config = { ..._config, ...config }`,
+        `}`,
+        ``,
+        `/**`,
+        ` * Get the current client configuration.`,
+        ` */`,
+        `export function getClientConfig(): ClientConfig {`,
+        `  return _config`,
+        `}`,
+        ``
+      ].join("\n")
+    };
+  }
+  /**
+   * Generate the barrel index file.
+   */
+  generateBarrelIndex(tagGroups, options) {
+    const lines = [
+      `/**`,
+      ` * Auto-generated API hooks.`,
+      ` * Generated by auto-api-hooks \u2014 do not edit manually.`,
+      ` */`,
+      ``,
+      `export * from './types'`,
+      `export * from './client'`
+    ];
+    if (options.zod) {
+      lines.push(`export * from './schemas'`);
+    }
+    for (const tag of tagGroups) {
+      lines.push(`export * from './${toKebabCase(tag)}'`);
+    }
+    lines.push(``);
+    return {
+      path: "index.ts",
+      content: lines.join("\n")
+    };
+  }
+  /**
+   * Group operations by their first tag.
+   */
+  groupByTag(operations) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const op of operations) {
+      const tag = op.tags[0] || "default";
+      const group = groups.get(tag) || [];
+      group.push(op);
+      groups.set(tag, group);
+    }
+    return groups;
+  }
+  /**
+   * Get the params type name for an operation.
+   */
+  getParamsTypeName(operationId) {
+    return `${toPascalCase(operationId)}Params`;
+  }
+  /**
+   * Get the request body type name for an operation.
+   */
+  getBodyTypeName(operationId) {
+    return `${toPascalCase(operationId)}Body`;
+  }
+  /**
+   * Get the response type name for an operation.
+   */
+  getResponseTypeName(operationId) {
+    return `${toPascalCase(operationId)}Response`;
+  }
+  /**
+   * Check if an operation is a "read" operation (GET or QUERY).
+   */
+  isReadOperation(op) {
+    return op.method === "GET" || op.method === "QUERY";
+  }
+  /**
+   * Check if an operation is a "write" operation (POST, PUT, PATCH, DELETE, MUTATION).
+   */
+  isWriteOperation(op) {
+    return !this.isReadOperation(op);
+  }
+  /**
+   * Whether this generator supports infinite queries.
+   * Override in subclasses that support them (react-query, swr).
+   */
+  supportsInfiniteQueries() {
+    return false;
+  }
+  /**
+   * Generate an infinite query hook file for a paginated operation.
+   * Override in subclasses that support infinite queries.
+   */
+  generateInfiniteHookFile(_op, _hookName, _spec, _options) {
+    return null;
+  }
+};
+
+// src/generators/fetch-generator.ts
+var FetchGenerator = class extends BaseHookGenerator {
+  generateHookFile(op, hookName, _spec, options) {
+    const paramsType = this.getParamsTypeName(op.operationId);
+    const responseType = this.getResponseTypeName(op.operationId);
+    const bodyType = op.requestBody ? this.getBodyTypeName(op.operationId) : null;
+    const hasParams = op.pathParams.length > 0 || op.queryParams.length > 0;
+    const isRead = this.isReadOperation(op);
+    const lines = [
+      `/**`,
+      ` * ${op.summary || `${op.method} ${op.path}`}`,
+      ` *`,
+      ` * \`${op.method} ${op.path}\``,
+      op.deprecated ? ` * @deprecated` : "",
+      ` * Generated by auto-api-hooks \u2014 do not edit manually.`,
+      ` */`,
+      `import { useState, useEffect, useCallback, useRef } from 'react'`,
+      `import { getClientConfig } from '../client'`,
+      `import type { ${[paramsType, responseType, bodyType].filter(Boolean).join(", ")} } from '../types'`
+    ].filter(Boolean);
+    if (options.zod) {
+      const schemaName = `${toPascalCase(op.operationId)}ResponseSchema`;
+      lines.push(`import { ${schemaName.charAt(0).toLowerCase() + schemaName.slice(1)} } from '../schemas'`);
+    }
+    lines.push(``);
+    if (isRead) {
+      lines.push(...this.generateReadHook(op, hookName, paramsType, responseType, hasParams, options));
+    } else {
+      lines.push(...this.generateWriteHook(op, hookName, paramsType, responseType, bodyType, hasParams, options));
+    }
+    return lines.join("\n") + "\n";
+  }
+  generateReadHook(op, hookName, paramsType, responseType, hasParams, options) {
+    const paramArg = hasParams ? `params: ${paramsType}` : "";
+    const enabledArg = `options?: { enabled?: boolean }`;
+    const args = [paramArg, enabledArg].filter(Boolean).join(", ");
+    return [
+      `export interface ${hookName}Result {`,
+      `  data: ${responseType} | null`,
+      `  error: Error | null`,
+      `  isLoading: boolean`,
+      `  refetch: () => void`,
+      `}`,
+      ``,
+      `export function ${hookName}(${args}): ${hookName}Result {`,
+      `  const [data, setData] = useState<${responseType} | null>(null)`,
+      `  const [error, setError] = useState<Error | null>(null)`,
+      `  const [isLoading, setIsLoading] = useState(false)`,
+      `  const abortRef = useRef<AbortController | null>(null)`,
+      ``,
+      `  const fetchData = useCallback(async () => {`,
+      `    if (options?.enabled === false) return`,
+      `    abortRef.current?.abort()`,
+      `    const controller = new AbortController()`,
+      `    abortRef.current = controller`,
+      ``,
+      `    setIsLoading(true)`,
+      `    setError(null)`,
+      ``,
+      `    try {`,
+      `      const config = getClientConfig()`,
+      `      const url = buildUrl(config.baseUrl, ${hasParams ? "params" : "undefined"})`,
+      `      const res = await fetch(url, {`,
+      `        method: '${op.method}',`,
+      `        headers: { 'Content-Type': 'application/json', ...config.headers },`,
+      `        signal: controller.signal,`,
+      `      })`,
+      ``,
+      `      if (!res.ok) throw new Error(\`HTTP \${res.status}: \${res.statusText}\`)`,
+      ``,
+      options.zod ? `      const json = await res.json()
+      const parsed = ${toPascalCase(op.operationId).charAt(0).toLowerCase() + toPascalCase(op.operationId).slice(1)}ResponseSchema.parse(json)
+      setData(parsed as ${responseType})` : `      const json = await res.json()
+      setData(json as ${responseType})`,
+      `    } catch (err) {`,
+      `      if (err instanceof Error && err.name !== 'AbortError') {`,
+      `        setError(err)`,
+      `      }`,
+      `    } finally {`,
+      `      setIsLoading(false)`,
+      `    }`,
+      `  // eslint-disable-next-line react-hooks/exhaustive-deps`,
+      `  }, [${hasParams ? "JSON.stringify(params)" : ""}])`,
+      ``,
+      `  useEffect(() => {`,
+      `    fetchData()`,
+      `    return () => { abortRef.current?.abort() }`,
+      `  }, [fetchData])`,
+      ``,
+      `  return { data, error, isLoading, refetch: fetchData }`,
+      `}`,
+      ``,
+      ...this.generateBuildUrl(op)
+    ];
+  }
+  generateWriteHook(op, hookName, paramsType, responseType, bodyType, hasParams, options) {
+    const mutateArgs = [];
+    if (hasParams) mutateArgs.push(`params: ${paramsType}`);
+    if (bodyType) mutateArgs.push(`body: ${bodyType}`);
+    const mutateArgStr = mutateArgs.join(", ");
+    return [
+      `export interface ${hookName}Result {`,
+      `  data: ${responseType} | null`,
+      `  error: Error | null`,
+      `  isLoading: boolean`,
+      `  mutate: (${mutateArgStr}) => Promise<${responseType}>`,
+      `  reset: () => void`,
+      `}`,
+      ``,
+      `export function ${hookName}(): ${hookName}Result {`,
+      `  const [data, setData] = useState<${responseType} | null>(null)`,
+      `  const [error, setError] = useState<Error | null>(null)`,
+      `  const [isLoading, setIsLoading] = useState(false)`,
+      ``,
+      `  const mutate = useCallback(async (${mutateArgStr}): Promise<${responseType}> => {`,
+      `    setIsLoading(true)`,
+      `    setError(null)`,
+      ``,
+      `    try {`,
+      `      const config = getClientConfig()`,
+      `      const url = buildUrl(config.baseUrl, ${hasParams ? "params" : "undefined"})`,
+      `      const res = await fetch(url, {`,
+      `        method: '${op.method}',`,
+      `        headers: { 'Content-Type': 'application/json', ...config.headers },`,
+      bodyType ? `        body: JSON.stringify(body),` : "",
+      `      })`,
+      ``,
+      `      if (!res.ok) throw new Error(\`HTTP \${res.status}: \${res.statusText}\`)`,
+      ``,
+      options.zod ? `      const json = await res.json()
+      const parsed = ${toPascalCase(op.operationId).charAt(0).toLowerCase() + toPascalCase(op.operationId).slice(1)}ResponseSchema.parse(json)
+      setData(parsed as ${responseType})
+      return parsed as ${responseType}` : `      const json = await res.json()
+      setData(json as ${responseType})
+      return json as ${responseType}`,
+      `    } catch (err) {`,
+      `      const error = err instanceof Error ? err : new Error(String(err))`,
+      `      setError(error)`,
+      `      throw error`,
+      `    } finally {`,
+      `      setIsLoading(false)`,
+      `    }`,
+      `  }, [])`,
+      ``,
+      `  const reset = useCallback(() => {`,
+      `    setData(null)`,
+      `    setError(null)`,
+      `    setIsLoading(false)`,
+      `  }, [])`,
+      ``,
+      `  return { data, error, isLoading, mutate, reset }`,
+      `}`,
+      ``,
+      ...this.generateBuildUrl(op)
+    ].filter(Boolean);
+  }
+  generateBuildUrl(op) {
+    const hasPathParams = op.pathParams.length > 0;
+    const hasQueryParams = op.queryParams.length > 0;
+    const paramsType = this.getParamsTypeName(op.operationId);
+    const hasAnyParams = hasPathParams || hasQueryParams;
+    if (!hasAnyParams) {
+      return [
+        `function buildUrl(baseUrl: string, _params: undefined): string {`,
+        `  return \`\${baseUrl}${op.path}\``,
+        `}`
+      ];
+    }
+    let pathTemplate = op.path;
+    for (const p of op.pathParams) {
+      pathTemplate = pathTemplate.replace(`{${p.name}}`, `\${params.${p.name}}`);
+    }
+    const lines = [
+      `function buildUrl(baseUrl: string, params: ${paramsType}): string {`,
+      `  let url = \`\${baseUrl}${pathTemplate}\``
+    ];
+    if (hasQueryParams) {
+      lines.push(
+        `  const query = new URLSearchParams()`
+      );
+      for (const p of op.queryParams) {
+        lines.push(
+          `  if (params.${p.name} !== undefined) query.set('${p.name}', String(params.${p.name}))`
+        );
+      }
+      lines.push(
+        `  const qs = query.toString()`,
+        `  if (qs) url += \`?\${qs}\``
+      );
+    }
+    lines.push(
+      `  return url`,
+      `}`
+    );
+    return lines;
+  }
+};
+
+// src/generators/axios-generator.ts
+var AxiosGenerator = class extends BaseHookGenerator {
+  generateClientConfig(spec, options) {
+    const baseUrl = options.baseUrl || spec.baseUrl || "";
+    return {
+      path: "client.ts",
+      content: [
+        `/**`,
+        ` * Axios API client configuration.`,
+        ` * Generated by auto-api-hooks \u2014 do not edit manually.`,
+        ` */`,
+        `import axios from 'axios'`,
+        ``,
+        `export const API_BASE_URL = '${baseUrl}'`,
+        ``,
+        `export const apiClient = axios.create({`,
+        `  baseURL: API_BASE_URL,`,
+        `  headers: { 'Content-Type': 'application/json' },`,
+        `})`,
+        ``,
+        `/**`,
+        ` * Configure the API client.`,
+        ` */`,
+        `export function configureClient(config: { baseUrl?: string; headers?: Record<string, string> }): void {`,
+        `  if (config.baseUrl) apiClient.defaults.baseURL = config.baseUrl`,
+        `  if (config.headers) Object.assign(apiClient.defaults.headers.common, config.headers)`,
+        `}`,
+        ``
+      ].join("\n")
+    };
+  }
+  generateHookFile(op, hookName, _spec, options) {
+    const paramsType = this.getParamsTypeName(op.operationId);
+    const responseType = this.getResponseTypeName(op.operationId);
+    const bodyType = op.requestBody ? this.getBodyTypeName(op.operationId) : null;
+    const hasParams = op.pathParams.length > 0 || op.queryParams.length > 0;
+    const isRead = this.isReadOperation(op);
+    const imports = [
+      `import type { ${[paramsType, responseType, bodyType].filter(Boolean).join(", ")} } from '../types'`,
+      `import { apiClient } from '../client'`
+    ];
+    if (isRead) {
+      imports.unshift(`import { useState, useEffect, useCallback, useRef } from 'react'`);
+    } else {
+      imports.unshift(`import { useState, useCallback } from 'react'`);
+    }
+    if (options.zod) {
+      const schemaVar = `${toPascalCase(op.operationId).charAt(0).toLowerCase() + toPascalCase(op.operationId).slice(1)}ResponseSchema`;
+      imports.push(`import { ${schemaVar} } from '../schemas'`);
+    }
+    const lines = [
+      `/**`,
+      ` * ${op.summary || `${op.method} ${op.path}`}`,
+      ` *`,
+      ` * \`${op.method} ${op.path}\``,
+      op.deprecated ? ` * @deprecated` : "",
+      ` * Generated by auto-api-hooks \u2014 do not edit manually.`,
+      ` */`,
+      ...imports,
+      ``
+    ].filter(Boolean);
+    if (isRead) {
+      lines.push(...this.generateReadHook(op, hookName, paramsType, responseType, hasParams, options));
+    } else {
+      lines.push(...this.generateWriteHook(op, hookName, paramsType, responseType, bodyType, hasParams, options));
+    }
+    return lines.join("\n") + "\n";
+  }
+  generateReadHook(op, hookName, paramsType, responseType, hasParams, options) {
+    const paramArg = hasParams ? `params: ${paramsType}` : "";
+    const args = [paramArg, `options?: { enabled?: boolean }`].filter(Boolean).join(", ");
+    const schemaVar = `${toPascalCase(op.operationId).charAt(0).toLowerCase() + toPascalCase(op.operationId).slice(1)}ResponseSchema`;
+    let pathExpr = `'${op.path}'`;
+    if (op.pathParams.length > 0) {
+      let tmpl = op.path;
+      for (const p of op.pathParams) {
+        tmpl = tmpl.replace(`{${p.name}}`, `\${params.${p.name}}`);
+      }
+      pathExpr = `\`${tmpl}\``;
+    }
+    const queryParams = op.queryParams.length > 0 ? `params: { ${op.queryParams.map((p) => `${p.name}: params.${p.name}`).join(", ")} },` : "";
+    return [
+      `export interface ${hookName}Result {`,
+      `  data: ${responseType} | null`,
+      `  error: Error | null`,
+      `  isLoading: boolean`,
+      `  refetch: () => void`,
+      `}`,
+      ``,
+      `export function ${hookName}(${args}): ${hookName}Result {`,
+      `  const [data, setData] = useState<${responseType} | null>(null)`,
+      `  const [error, setError] = useState<Error | null>(null)`,
+      `  const [isLoading, setIsLoading] = useState(false)`,
+      `  const cancelRef = useRef<(() => void) | null>(null)`,
+      ``,
+      `  const fetchData = useCallback(async () => {`,
+      `    if (options?.enabled === false) return`,
+      `    cancelRef.current?.()`,
+      `    const source = new AbortController()`,
+      `    cancelRef.current = () => source.abort()`,
+      ``,
+      `    setIsLoading(true)`,
+      `    setError(null)`,
+      ``,
+      `    try {`,
+      `      const res = await apiClient.get<${responseType}>(${pathExpr}, {`,
+      queryParams ? `        ${queryParams}` : "",
+      `        signal: source.signal,`,
+      `      })`,
+      options.zod ? `      const parsed = ${schemaVar}.parse(res.data)
+      setData(parsed as ${responseType})` : `      setData(res.data)`,
+      `    } catch (err) {`,
+      `      if (!source.signal.aborted) {`,
+      `        setError(err instanceof Error ? err : new Error(String(err)))`,
+      `      }`,
+      `    } finally {`,
+      `      setIsLoading(false)`,
+      `    }`,
+      `  // eslint-disable-next-line react-hooks/exhaustive-deps`,
+      `  }, [${hasParams ? "JSON.stringify(params)" : ""}])`,
+      ``,
+      `  useEffect(() => {`,
+      `    fetchData()`,
+      `    return () => { cancelRef.current?.() }`,
+      `  }, [fetchData])`,
+      ``,
+      `  return { data, error, isLoading, refetch: fetchData }`,
+      `}`
+    ].filter(Boolean);
+  }
+  generateWriteHook(op, hookName, paramsType, responseType, bodyType, hasParams, options) {
+    const mutateArgs = [];
+    if (hasParams) mutateArgs.push(`params: ${paramsType}`);
+    if (bodyType) mutateArgs.push(`body: ${bodyType}`);
+    const mutateArgStr = mutateArgs.join(", ");
+    const schemaVar = `${toPascalCase(op.operationId).charAt(0).toLowerCase() + toPascalCase(op.operationId).slice(1)}ResponseSchema`;
+    let pathExpr = `'${op.path}'`;
+    if (op.pathParams.length > 0) {
+      let tmpl = op.path;
+      for (const p of op.pathParams) {
+        tmpl = tmpl.replace(`{${p.name}}`, `\${params.${p.name}}`);
+      }
+      pathExpr = `\`${tmpl}\``;
+    }
+    const methodLower = op.method.toLowerCase();
+    const axiosCall = bodyType ? `apiClient.${methodLower}<${responseType}>(${pathExpr}, body)` : `apiClient.${methodLower}<${responseType}>(${pathExpr})`;
+    return [
+      `export interface ${hookName}Result {`,
+      `  data: ${responseType} | null`,
+      `  error: Error | null`,
+      `  isLoading: boolean`,
+      `  mutate: (${mutateArgStr}) => Promise<${responseType}>`,
+      `  reset: () => void`,
+      `}`,
+      ``,
+      `export function ${hookName}(): ${hookName}Result {`,
+      `  const [data, setData] = useState<${responseType} | null>(null)`,
+      `  const [error, setError] = useState<Error | null>(null)`,
+      `  const [isLoading, setIsLoading] = useState(false)`,
+      ``,
+      `  const mutate = useCallback(async (${mutateArgStr}): Promise<${responseType}> => {`,
+      `    setIsLoading(true)`,
+      `    setError(null)`,
+      ``,
+      `    try {`,
+      `      const res = await ${axiosCall}`,
+      options.zod ? `      const parsed = ${schemaVar}.parse(res.data)
+      setData(parsed as ${responseType})
+      return parsed as ${responseType}` : `      setData(res.data)
+      return res.data`,
+      `    } catch (err) {`,
+      `      const error = err instanceof Error ? err : new Error(String(err))`,
+      `      setError(error)`,
+      `      throw error`,
+      `    } finally {`,
+      `      setIsLoading(false)`,
+      `    }`,
+      `  }, [])`,
+      ``,
+      `  const reset = useCallback(() => {`,
+      `    setData(null)`,
+      `    setError(null)`,
+      `    setIsLoading(false)`,
+      `  }, [])`,
+      ``,
+      `  return { data, error, isLoading, mutate, reset }`,
+      `}`
+    ];
+  }
+};
+
+// src/utils/cache-keys.ts
+function deriveCacheKeyFactories(operations) {
+  const resourceMap = /* @__PURE__ */ new Map();
+  for (const op of operations) {
+    if (op.method !== "GET" && op.method !== "QUERY") continue;
+    const resource = extractResource(op.path);
+    const existing = resourceMap.get(resource) || { hasList: false, hasDetail: false };
+    if (isDetailEndpoint(op.path)) {
+      existing.hasDetail = true;
+    } else {
+      existing.hasList = true;
+    }
+    resourceMap.set(resource, existing);
+  }
+  const factories = [];
+  for (const [resource, info] of resourceMap) {
+    const singular = toCamelCase(resource);
+    factories.push({
+      resource: singular,
+      variableName: `${singular}Keys`,
+      rootKey: [resource],
+      hasList: info.hasList,
+      hasDetail: info.hasDetail
+    });
+  }
+  return factories;
+}
+function getSwrKey(op) {
+  const pathParams = op.pathParams.map((p) => p.name);
+  let key = op.path;
+  for (const param of pathParams) {
+    key = key.replace(`{${param}}`, `\${${param}}`);
+  }
+  if (op.queryParams.length > 0) {
+    return `\`${key}?\${new URLSearchParams(params as Record<string, string>).toString()}\``;
+  }
+  if (pathParams.length > 0) {
+    return `\`${key}\``;
+  }
+  return `'${op.path}'`;
+}
+function getQueryKey(op) {
+  const resource = extractResource(op.path);
+  const parts = [`'${resource}'`];
+  if (isDetailEndpoint(op.path)) {
+    parts.push(`'detail'`);
+    for (const p of op.pathParams) {
+      parts.push(p.name);
+    }
+  } else {
+    parts.push(`'list'`);
+    if (op.queryParams.length > 0) {
+      parts.push("params");
+    }
+  }
+  return `[${parts.join(", ")}] as const`;
+}
+
+// src/generators/react-query-generator.ts
+var ReactQueryGenerator = class extends BaseHookGenerator {
+  supportsInfiniteQueries() {
+    return true;
+  }
+  generate(spec, options) {
+    const files = super.generate(spec, options);
+    files.push(this.generateQueryKeysFile(spec));
+    return files;
+  }
+  /**
+   * Generate the query-keys.ts file with cache key factories.
+   */
+  generateQueryKeysFile(spec) {
+    const factories = deriveCacheKeyFactories(spec.operations);
+    const lines = [
+      `/**`,
+      ` * Query key factories for TanStack React Query.`,
+      ` * Generated by auto-api-hooks \u2014 do not edit manually.`,
+      ` */`,
+      ``
+    ];
+    for (const factory of factories) {
+      lines.push(
+        `export const ${factory.variableName} = {`,
+        `  all: [${factory.rootKey.map((k) => `'${k}'`).join(", ")}] as const,`
+      );
+      if (factory.hasList) {
+        lines.push(
+          `  lists: () => [...${factory.variableName}.all, 'list'] as const,`,
+          `  list: (params?: Record<string, unknown>) => [...${factory.variableName}.lists(), params] as const,`
+        );
+      }
+      if (factory.hasDetail) {
+        lines.push(
+          `  details: () => [...${factory.variableName}.all, 'detail'] as const,`,
+          `  detail: (id: string | number) => [...${factory.variableName}.details(), id] as const,`
+        );
+      }
+      lines.push(`} as const`, ``);
+    }
+    return {
+      path: "query-keys.ts",
+      content: lines.join("\n")
+    };
+  }
+  generateBarrelIndex(tagGroups, options) {
+    const base = super.generateBarrelIndex(tagGroups, options);
+    const content = base.content.replace(
+      `export * from './client'`,
+      `export * from './client'
+export * from './query-keys'`
+    );
+    return { ...base, content };
+  }
+  generateHookFile(op, hookName, _spec, options) {
+    const isRead = this.isReadOperation(op);
+    return isRead ? this.generateQueryHook(op, hookName, options) : this.generateMutationHook(op, hookName, options);
+  }
+  generateInfiniteHookFile(op, hookName, _spec, options) {
+    if (!op.pagination) return null;
+    return this.generateInfiniteQueryHook(op, hookName, op.pagination, options);
+  }
+  // ---------------------------------------------------------------------------
+  // useQuery
+  // ---------------------------------------------------------------------------
+  generateQueryHook(op, hookName, options) {
+    const paramsType = this.getParamsTypeName(op.operationId);
+    const responseType = this.getResponseTypeName(op.operationId);
+    const hasParams = op.pathParams.length > 0 || op.queryParams.length > 0;
+    const queryKey = getQueryKey(op);
+    const schemaVar = `${toPascalCase(op.operationId).charAt(0).toLowerCase() + toPascalCase(op.operationId).slice(1)}ResponseSchema`;
+    const paramArg = hasParams ? `params: ${paramsType}` : "";
+    const optionsArg = `options?: Partial<UseQueryOptions<${responseType}, Error>>`;
+    const args = [paramArg, optionsArg].filter(Boolean).join(", ");
+    const fetcherBody = this.generateFetcherBody(op, options);
+    const lines = [
+      `/**`,
+      ` * ${op.summary || `${op.method} ${op.path}`}`,
+      ` *`,
+      ` * \`${op.method} ${op.path}\``,
+      op.deprecated ? ` * @deprecated` : "",
+      ` * Generated by auto-api-hooks \u2014 do not edit manually.`,
+      ` */`,
+      `import { useQuery } from '@tanstack/react-query'`,
+      `import type { UseQueryOptions } from '@tanstack/react-query'`,
+      `import { getClientConfig } from '../client'`,
+      `import type { ${[paramsType, responseType].filter(Boolean).join(", ")} } from '../types'`
+    ].filter(Boolean);
+    if (options.zod) {
+      lines.push(`import { ${schemaVar} } from '../schemas'`);
+    }
+    lines.push(
+      ``,
+      `export function ${hookName}(${args}) {`,
+      `  return useQuery<${responseType}, Error>({`,
+      `    queryKey: ${queryKey},`,
+      `    queryFn: async () => {`,
+      ...fetcherBody.map((l) => `      ${l}`),
+      `    },`,
+      `    ...options,`,
+      `  })`,
+      `}`,
+      ``
+    );
+    return lines.join("\n");
+  }
+  // ---------------------------------------------------------------------------
+  // useMutation
+  // ---------------------------------------------------------------------------
+  generateMutationHook(op, hookName, options) {
+    const paramsType = this.getParamsTypeName(op.operationId);
+    const responseType = this.getResponseTypeName(op.operationId);
+    const bodyType = op.requestBody ? this.getBodyTypeName(op.operationId) : null;
+    const hasParams = op.pathParams.length > 0 || op.queryParams.length > 0;
+    const schemaVar = `${toPascalCase(op.operationId).charAt(0).toLowerCase() + toPascalCase(op.operationId).slice(1)}ResponseSchema`;
+    const varFields = [];
+    if (hasParams) varFields.push(`params: ${paramsType}`);
+    if (bodyType) varFields.push(`body: ${bodyType}`);
+    const varsType = varFields.length > 0 ? `{ ${varFields.join("; ")} }` : "void";
+    const fetcherBody = this.generateMutationFetcherBody(op, options);
+    const typeImports = [paramsType, responseType, bodyType].filter(Boolean).join(", ");
+    const lines = [
+      `/**`,
+      ` * ${op.summary || `${op.method} ${op.path}`}`,
+      ` *`,
+      ` * \`${op.method} ${op.path}\``,
+      op.deprecated ? ` * @deprecated` : "",
+      ` * Generated by auto-api-hooks \u2014 do not edit manually.`,
+      ` */`,
+      `import { useMutation } from '@tanstack/react-query'`,
+      `import type { UseMutationOptions } from '@tanstack/react-query'`,
+      `import { getClientConfig } from '../client'`,
+      `import type { ${typeImports} } from '../types'`
+    ].filter(Boolean);
+    if (options.zod) {
+      lines.push(`import { ${schemaVar} } from '../schemas'`);
+    }
+    lines.push(
+      ``,
+      `export function ${hookName}(options?: UseMutationOptions<${responseType}, Error, ${varsType}>) {`,
+      `  return useMutation<${responseType}, Error, ${varsType}>({`,
+      `    mutationFn: async (${varFields.length > 0 ? "vars" : ""}) => {`,
+      ...fetcherBody.map((l) => `      ${l}`),
+      `    },`,
+      `    ...options,`,
+      `  })`,
+      `}`,
+      ``
+    );
+    return lines.join("\n");
+  }
+  // ---------------------------------------------------------------------------
+  // useInfiniteQuery
+  // ---------------------------------------------------------------------------
+  generateInfiniteQueryHook(op, hookName, pagination, options) {
+    const paramsType = this.getParamsTypeName(op.operationId);
+    const responseType = this.getResponseTypeName(op.operationId);
+    const hasParams = op.queryParams.length > 1 || op.pathParams.length > 0;
+    const queryKey = getQueryKey(op);
+    const schemaVar = `${toPascalCase(op.operationId).charAt(0).toLowerCase() + toPascalCase(op.operationId).slice(1)}ResponseSchema`;
+    const pageParamType = pagination.strategy === "cursor" ? "string | undefined" : "number";
+    const initialPageParam = pagination.strategy === "cursor" ? "undefined" : pagination.strategy === "offset-limit" ? "0" : "1";
+    const nextPagePath = pagination.nextPagePath.join("?.");
+    const paramArg = hasParams ? `params: Omit<${paramsType}, '${pagination.pageParam}'>` : "";
+    const optionsArg = `options?: Partial<UseInfiniteQueryOptions<${responseType}, Error>>`;
+    const args = [paramArg, optionsArg].filter(Boolean).join(", ");
+    const lines = [
+      `/**`,
+      ` * ${op.summary || `${op.method} ${op.path}`} (infinite)`,
+      ` *`,
+      ` * \`${op.method} ${op.path}\``,
+      op.deprecated ? ` * @deprecated` : "",
+      ` * Generated by auto-api-hooks \u2014 do not edit manually.`,
+      ` */`,
+      `import { useInfiniteQuery } from '@tanstack/react-query'`,
+      `import type { UseInfiniteQueryOptions } from '@tanstack/react-query'`,
+      `import { getClientConfig } from '../client'`,
+      `import type { ${[paramsType, responseType].filter(Boolean).join(", ")} } from '../types'`
+    ].filter(Boolean);
+    if (options.zod) {
+      lines.push(`import { ${schemaVar} } from '../schemas'`);
+    }
+    let pathExpr = `'${op.path}'`;
+    if (op.pathParams.length > 0) {
+      let tmpl = op.path;
+      for (const p of op.pathParams) {
+        tmpl = tmpl.replace(`{${p.name}}`, `\${params.${p.name}}`);
+      }
+      pathExpr = `\`${tmpl}\``;
+    }
+    lines.push(
+      ``,
+      `export function ${hookName}(${args}) {`,
+      `  return useInfiniteQuery<${responseType}, Error>({`,
+      `    queryKey: ${queryKey},`,
+      `    queryFn: async ({ pageParam }) => {`,
+      `      const config = getClientConfig()`,
+      `      const url = new URL(${pathExpr}, config.baseUrl)`
+    );
+    for (const p of op.queryParams) {
+      if (p.name === pagination.pageParam) {
+        lines.push(`      if (pageParam !== undefined) url.searchParams.set('${p.name}', String(pageParam))`);
+      } else {
+        lines.push(`      if (${hasParams ? `params.${p.name}` : "undefined"} !== undefined) url.searchParams.set('${p.name}', String(${hasParams ? `params.${p.name}` : ""}))`);
+      }
+    }
+    lines.push(
+      `      const res = await fetch(url.toString(), {`,
+      `        headers: { 'Content-Type': 'application/json', ...config.headers },`,
+      `      })`,
+      `      if (!res.ok) throw new Error(\`HTTP \${res.status}: \${res.statusText}\`)`
+    );
+    if (options.zod) {
+      lines.push(
+        `      const json = await res.json()`,
+        `      return ${schemaVar}.parse(json) as ${responseType}`
+      );
+    } else {
+      lines.push(`      return (await res.json()) as ${responseType}`);
+    }
+    lines.push(
+      `    },`,
+      `    initialPageParam: ${initialPageParam} as ${pageParamType},`,
+      `    getNextPageParam: (lastPage) => (lastPage as Record<string, unknown>)?.${nextPagePath} as ${pageParamType},`,
+      `    ...options,`,
+      `  })`,
+      `}`,
+      ``
+    );
+    return lines.join("\n");
+  }
+  // ---------------------------------------------------------------------------
+  // Shared fetcher body generators
+  // ---------------------------------------------------------------------------
+  generateFetcherBody(op, options) {
+    const responseType = this.getResponseTypeName(op.operationId);
+    const schemaVar = `${toPascalCase(op.operationId).charAt(0).toLowerCase() + toPascalCase(op.operationId).slice(1)}ResponseSchema`;
+    let pathExpr = `'${op.path}'`;
+    if (op.pathParams.length > 0) {
+      let tmpl = op.path;
+      for (const p of op.pathParams) {
+        tmpl = tmpl.replace(`{${p.name}}`, `\${params.${p.name}}`);
+      }
+      pathExpr = `\`${tmpl}\``;
+    }
+    const lines = [
+      `const config = getClientConfig()`,
+      `const url = new URL(${pathExpr}, config.baseUrl)`
+    ];
+    for (const p of op.queryParams) {
+      lines.push(`if (params.${p.name} !== undefined) url.searchParams.set('${p.name}', String(params.${p.name}))`);
+    }
+    lines.push(
+      `const res = await fetch(url.toString(), {`,
+      `  headers: { 'Content-Type': 'application/json', ...config.headers },`,
+      `})`,
+      `if (!res.ok) throw new Error(\`HTTP \${res.status}: \${res.statusText}\`)`
+    );
+    if (options.zod) {
+      lines.push(
+        `const json = await res.json()`,
+        `return ${schemaVar}.parse(json) as ${responseType}`
+      );
+    } else {
+      lines.push(`return (await res.json()) as ${responseType}`);
+    }
+    return lines;
+  }
+  generateMutationFetcherBody(op, options) {
+    const responseType = this.getResponseTypeName(op.operationId);
+    const hasParams = op.pathParams.length > 0 || op.queryParams.length > 0;
+    const hasBody = !!op.requestBody;
+    const schemaVar = `${toPascalCase(op.operationId).charAt(0).toLowerCase() + toPascalCase(op.operationId).slice(1)}ResponseSchema`;
+    let pathExpr = `'${op.path}'`;
+    if (op.pathParams.length > 0) {
+      let tmpl = op.path;
+      for (const p of op.pathParams) {
+        tmpl = tmpl.replace(`{${p.name}}`, `\${vars.params.${p.name}}`);
+      }
+      pathExpr = `\`${tmpl}\``;
+    }
+    const lines = [
+      `const config = getClientConfig()`,
+      `const url = new URL(${pathExpr}, config.baseUrl)`
+    ];
+    if (hasParams) {
+      for (const p of op.queryParams) {
+        lines.push(`if (vars.params.${p.name} !== undefined) url.searchParams.set('${p.name}', String(vars.params.${p.name}))`);
+      }
+    }
+    lines.push(
+      `const res = await fetch(url.toString(), {`,
+      `  method: '${op.method}',`,
+      `  headers: { 'Content-Type': 'application/json', ...config.headers },`
+    );
+    if (hasBody) {
+      lines.push(`  body: JSON.stringify(vars.body),`);
+    }
+    lines.push(
+      `})`,
+      `if (!res.ok) throw new Error(\`HTTP \${res.status}: \${res.statusText}\`)`
+    );
+    if (options.zod) {
+      lines.push(
+        `const json = await res.json()`,
+        `return ${schemaVar}.parse(json) as ${responseType}`
+      );
+    } else {
+      lines.push(`return (await res.json()) as ${responseType}`);
+    }
+    return lines;
+  }
+};
+
+// src/generators/swr-generator.ts
+var SwrGenerator = class extends BaseHookGenerator {
+  supportsInfiniteQueries() {
+    return true;
+  }
+  generateHookFile(op, hookName, _spec, options) {
+    const isRead = this.isReadOperation(op);
+    return isRead ? this.generateSwrHook(op, hookName, options) : this.generateSwrMutationHook(op, hookName, options);
+  }
+  generateInfiniteHookFile(op, hookName, _spec, options) {
+    if (!op.pagination) return null;
+    return this.generateSwrInfiniteHook(op, hookName, op.pagination, options);
+  }
+  // ---------------------------------------------------------------------------
+  // useSWR
+  // ---------------------------------------------------------------------------
+  generateSwrHook(op, hookName, options) {
+    const paramsType = this.getParamsTypeName(op.operationId);
+    const responseType = this.getResponseTypeName(op.operationId);
+    const hasParams = op.pathParams.length > 0 || op.queryParams.length > 0;
+    const swrKey = getSwrKey(op);
+    const schemaVar = `${toPascalCase(op.operationId).charAt(0).toLowerCase() + toPascalCase(op.operationId).slice(1)}ResponseSchema`;
+    const paramArg = hasParams ? `params: ${paramsType}` : "";
+    const optionsArg = `options?: { enabled?: boolean }`;
+    const args = [paramArg, optionsArg].filter(Boolean).join(", ");
+    const fetcherBody = this.generateFetcherBody(op, options);
+    const lines = [
+      `/**`,
+      ` * ${op.summary || `${op.method} ${op.path}`}`,
+      ` *`,
+      ` * \`${op.method} ${op.path}\``,
+      op.deprecated ? ` * @deprecated` : "",
+      ` * Generated by auto-api-hooks \u2014 do not edit manually.`,
+      ` */`,
+      `import useSWR from 'swr'`,
+      `import type { SWRConfiguration } from 'swr'`,
+      `import { getClientConfig } from '../client'`,
+      `import type { ${[paramsType, responseType].filter(Boolean).join(", ")} } from '../types'`
+    ].filter(Boolean);
+    if (options.zod) {
+      lines.push(`import { ${schemaVar} } from '../schemas'`);
+    }
+    lines.push(
+      ``,
+      `export function ${hookName}(${args}) {`,
+      `  const key = options?.enabled === false ? null : ${swrKey}`,
+      ``,
+      `  return useSWR<${responseType}, Error>(key, async () => {`,
+      ...fetcherBody.map((l) => `    ${l}`),
+      `  })`,
+      `}`,
+      ``
+    );
+    return lines.join("\n");
+  }
+  // ---------------------------------------------------------------------------
+  // useSWRMutation
+  // ---------------------------------------------------------------------------
+  generateSwrMutationHook(op, hookName, options) {
+    const paramsType = this.getParamsTypeName(op.operationId);
+    const responseType = this.getResponseTypeName(op.operationId);
+    const bodyType = op.requestBody ? this.getBodyTypeName(op.operationId) : null;
+    const hasParams = op.pathParams.length > 0 || op.queryParams.length > 0;
+    const schemaVar = `${toPascalCase(op.operationId).charAt(0).toLowerCase() + toPascalCase(op.operationId).slice(1)}ResponseSchema`;
+    const argFields = [];
+    if (hasParams) argFields.push(`params: ${paramsType}`);
+    if (bodyType) argFields.push(`body: ${bodyType}`);
+    const argType = argFields.length > 0 ? `{ ${argFields.join("; ")} }` : "void";
+    const typeImports = [paramsType, responseType, bodyType].filter(Boolean).join(", ");
+    const fetcherBody = this.generateMutationFetcherBody(op, options);
+    const lines = [
+      `/**`,
+      ` * ${op.summary || `${op.method} ${op.path}`}`,
+      ` *`,
+      ` * \`${op.method} ${op.path}\``,
+      op.deprecated ? ` * @deprecated` : "",
+      ` * Generated by auto-api-hooks \u2014 do not edit manually.`,
+      ` */`,
+      `import useSWRMutation from 'swr/mutation'`,
+      `import { getClientConfig } from '../client'`,
+      `import type { ${typeImports} } from '../types'`
+    ].filter(Boolean);
+    if (options.zod) {
+      lines.push(`import { ${schemaVar} } from '../schemas'`);
+    }
+    lines.push(
+      ``,
+      `export function ${hookName}() {`,
+      `  return useSWRMutation<${responseType}, Error, string, ${argType}>(`,
+      `    '${op.method} ${op.path}',`,
+      `    async (_key: string, { arg }: { arg: ${argType} }) => {`,
+      ...fetcherBody.map((l) => `      ${l}`),
+      `    },`,
+      `  )`,
+      `}`,
+      ``
+    );
+    return lines.join("\n");
+  }
+  // ---------------------------------------------------------------------------
+  // useSWRInfinite
+  // ---------------------------------------------------------------------------
+  generateSwrInfiniteHook(op, hookName, pagination, options) {
+    const paramsType = this.getParamsTypeName(op.operationId);
+    const responseType = this.getResponseTypeName(op.operationId);
+    const hasParams = op.queryParams.length > 1 || op.pathParams.length > 0;
+    const schemaVar = `${toPascalCase(op.operationId).charAt(0).toLowerCase() + toPascalCase(op.operationId).slice(1)}ResponseSchema`;
+    const nextPagePath = pagination.nextPagePath.join("?.");
+    const paramArg = hasParams ? `params: Omit<${paramsType}, '${pagination.pageParam}'>` : "";
+    const args = [paramArg].filter(Boolean).join(", ");
+    let pathExpr = `'${op.path}'`;
+    if (op.pathParams.length > 0) {
+      let tmpl = op.path;
+      for (const p of op.pathParams) {
+        tmpl = tmpl.replace(`{${p.name}}`, `\${params.${p.name}}`);
+      }
+      pathExpr = `\`${tmpl}\``;
+    }
+    const lines = [
+      `/**`,
+      ` * ${op.summary || `${op.method} ${op.path}`} (infinite)`,
+      ` *`,
+      ` * \`${op.method} ${op.path}\``,
+      op.deprecated ? ` * @deprecated` : "",
+      ` * Generated by auto-api-hooks \u2014 do not edit manually.`,
+      ` */`,
+      `import useSWRInfinite from 'swr/infinite'`,
+      `import { getClientConfig } from '../client'`,
+      `import type { ${[paramsType, responseType].filter(Boolean).join(", ")} } from '../types'`
+    ].filter(Boolean);
+    if (options.zod) {
+      lines.push(`import { ${schemaVar} } from '../schemas'`);
+    }
+    lines.push(
+      ``,
+      `export function ${hookName}(${args}) {`,
+      `  const getKey = (pageIndex: number, previousPageData: ${responseType} | null) => {`,
+      `    if (previousPageData && !(previousPageData as Record<string, unknown>)?.${nextPagePath}) return null`,
+      `    const pageParam = pageIndex === 0`,
+      `      ? undefined`,
+      `      : (previousPageData as Record<string, unknown>)?.${nextPagePath}`,
+      `    return [${pathExpr}, pageParam${hasParams ? ", params" : ""}] as const`,
+      `  }`,
+      ``,
+      `  return useSWRInfinite<${responseType}, Error>(getKey, async ([_path, pageParam]) => {`,
+      `    const config = getClientConfig()`,
+      `    const url = new URL(${pathExpr}, config.baseUrl)`
+    );
+    for (const p of op.queryParams) {
+      if (p.name === pagination.pageParam) {
+        lines.push(`    if (pageParam !== undefined) url.searchParams.set('${p.name}', String(pageParam))`);
+      } else {
+        lines.push(`    if (${hasParams ? `params.${p.name}` : "undefined"} !== undefined) url.searchParams.set('${p.name}', String(${hasParams ? `params.${p.name}` : ""}))`);
+      }
+    }
+    lines.push(
+      `    const res = await fetch(url.toString(), {`,
+      `      headers: { 'Content-Type': 'application/json', ...config.headers },`,
+      `    })`,
+      `    if (!res.ok) throw new Error(\`HTTP \${res.status}: \${res.statusText}\`)`
+    );
+    if (options.zod) {
+      lines.push(
+        `    const json = await res.json()`,
+        `    return ${schemaVar}.parse(json) as ${responseType}`
+      );
+    } else {
+      lines.push(`    return (await res.json()) as ${responseType}`);
+    }
+    lines.push(
+      `  })`,
+      `}`,
+      ``
+    );
+    return lines.join("\n");
+  }
+  // ---------------------------------------------------------------------------
+  // Shared fetcher body generators
+  // ---------------------------------------------------------------------------
+  generateFetcherBody(op, options) {
+    const responseType = this.getResponseTypeName(op.operationId);
+    const schemaVar = `${toPascalCase(op.operationId).charAt(0).toLowerCase() + toPascalCase(op.operationId).slice(1)}ResponseSchema`;
+    let pathExpr = `'${op.path}'`;
+    if (op.pathParams.length > 0) {
+      let tmpl = op.path;
+      for (const p of op.pathParams) {
+        tmpl = tmpl.replace(`{${p.name}}`, `\${params.${p.name}}`);
+      }
+      pathExpr = `\`${tmpl}\``;
+    }
+    const lines = [
+      `const config = getClientConfig()`,
+      `const url = new URL(${pathExpr}, config.baseUrl)`
+    ];
+    for (const p of op.queryParams) {
+      lines.push(`if (params.${p.name} !== undefined) url.searchParams.set('${p.name}', String(params.${p.name}))`);
+    }
+    lines.push(
+      `const res = await fetch(url.toString(), {`,
+      `  headers: { 'Content-Type': 'application/json', ...config.headers },`,
+      `})`,
+      `if (!res.ok) throw new Error(\`HTTP \${res.status}: \${res.statusText}\`)`
+    );
+    if (options.zod) {
+      lines.push(
+        `const json = await res.json()`,
+        `return ${schemaVar}.parse(json) as ${responseType}`
+      );
+    } else {
+      lines.push(`return (await res.json()) as ${responseType}`);
+    }
+    return lines;
+  }
+  generateMutationFetcherBody(op, options) {
+    const responseType = this.getResponseTypeName(op.operationId);
+    const hasParams = op.pathParams.length > 0 || op.queryParams.length > 0;
+    const hasBody = !!op.requestBody;
+    const schemaVar = `${toPascalCase(op.operationId).charAt(0).toLowerCase() + toPascalCase(op.operationId).slice(1)}ResponseSchema`;
+    let pathExpr = `'${op.path}'`;
+    if (op.pathParams.length > 0) {
+      let tmpl = op.path;
+      for (const p of op.pathParams) {
+        tmpl = tmpl.replace(`{${p.name}}`, `\${arg.params.${p.name}}`);
+      }
+      pathExpr = `\`${tmpl}\``;
+    }
+    const lines = [
+      `const config = getClientConfig()`,
+      `const url = new URL(${pathExpr}, config.baseUrl)`
+    ];
+    if (hasParams) {
+      for (const p of op.queryParams) {
+        lines.push(`if (arg.params.${p.name} !== undefined) url.searchParams.set('${p.name}', String(arg.params.${p.name}))`);
+      }
+    }
+    lines.push(
+      `const res = await fetch(url.toString(), {`,
+      `  method: '${op.method}',`,
+      `  headers: { 'Content-Type': 'application/json', ...config.headers },`
+    );
+    if (hasBody) {
+      lines.push(`  body: JSON.stringify(arg.body),`);
+    }
+    lines.push(
+      `})`,
+      `if (!res.ok) throw new Error(\`HTTP \${res.status}: \${res.statusText}\`)`
+    );
+    if (options.zod) {
+      lines.push(
+        `const json = await res.json()`,
+        `return ${schemaVar}.parse(json) as ${responseType}`
+      );
+    } else {
+      lines.push(`return (await res.json()) as ${responseType}`);
+    }
+    return lines;
+  }
+};
+
+// src/utils/errors.ts
+var AutoApiHooksError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AutoApiHooksError";
+  }
+};
+var GeneratorError = class extends AutoApiHooksError {
+  constructor(message) {
+    super(message);
+    this.name = "GeneratorError";
+  }
+};
+var FileWriteError = class extends AutoApiHooksError {
+  constructor(message) {
+    super(message);
+    this.name = "FileWriteError";
+  }
+};
+
+// src/generators/index.ts
+function createGenerator(strategy) {
+  switch (strategy) {
+    case "fetch":
+      return new FetchGenerator();
+    case "axios":
+      return new AxiosGenerator();
+    case "react-query":
+      return new ReactQueryGenerator();
+    case "swr":
+      return new SwrGenerator();
+    default:
+      throw new GeneratorError(`Unknown fetcher strategy: ${strategy}`);
+  }
+}
+function generateHooks(spec, options) {
+  const generator = createGenerator(options.fetcher);
+  return generator.generate(spec, options);
+}
+
+// src/mock-gen/faker-helpers.ts
+var counter = 0;
+function resetCounter() {
+  counter = 0;
+}
+function emitMockValue(type, spec, depth = 0) {
+  if (depth > 5) return `null`;
+  switch (type.kind) {
+    case "primitive":
+      return emitPrimitiveMock(type.type, type.format);
+    case "object":
+      return emitObjectMock(type, spec, depth);
+    case "array":
+      return `[${emitMockValue(type.items, spec, depth + 1)}]`;
+    case "enum":
+      if (type.values.length === 0) return `null`;
+      const val = type.values[0];
+      return typeof val === "string" ? `'${val}'` : String(val);
+    case "union":
+      if (type.variants.length === 0) return `null`;
+      return emitMockValue(type.variants[0], spec, depth + 1);
+    case "ref": {
+      const resolved = spec.types.get(type.name);
+      if (resolved) return emitMockValue(resolved, spec, depth + 1);
+      return `{}`;
+    }
+    default:
+      return `null`;
+  }
+}
+function emitPrimitiveMock(type, format) {
+  switch (type) {
+    case "string":
+      return emitStringMock(format);
+    case "number":
+    case "integer":
+      return String(counter++);
+    case "boolean":
+      return "true";
+    case "null":
+      return "null";
+    default:
+      return `'unknown'`;
+  }
+}
+function emitStringMock(format) {
+  switch (format) {
+    case "date-time":
+      return `'2024-01-01T00:00:00Z'`;
+    case "date":
+      return `'2024-01-01'`;
+    case "email":
+      return `'user@example.com'`;
+    case "uuid":
+      return `'00000000-0000-0000-0000-000000000001'`;
+    case "uri":
+    case "url":
+      return `'https://example.com'`;
+    case "hostname":
+      return `'example.com'`;
+    case "ipv4":
+      return `'127.0.0.1'`;
+    case "ipv6":
+      return `'::1'`;
+    default:
+      return `'string-value-${counter++}'`;
+  }
+}
+function emitObjectMock(type, spec, depth) {
+  if (type.properties.length === 0) {
+    return `{}`;
+  }
+  const props = type.properties.map((p) => `  ${safeKey(p.name)}: ${emitMockValue(p.type, spec, depth + 1)}`).join(",\n");
+  return `{
+${props}
+}`;
+}
+function safeKey(name) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `'${name}'`;
+}
+function emitMockDataFunction(op, spec) {
+  resetCounter();
+  const fnName = `generate${op.operationId.charAt(0).toUpperCase() + op.operationId.slice(1)}Mock`;
+  const mockValue = emitMockValue(op.response.type, spec);
+  return [
+    `export function ${fnName}() {`,
+    `  return ${mockValue}`,
+    `}`
+  ].join("\n");
+}
+function emitMockDataFile(spec) {
+  const lines = [
+    `/**`,
+    ` * Mock data generators.`,
+    ` * Generated by auto-api-hooks \u2014 do not edit manually.`,
+    ` */`,
+    ``
+  ];
+  for (const op of spec.operations) {
+    resetCounter();
+    lines.push(emitMockDataFunction(op, spec));
+    lines.push(``);
+  }
+  return lines.join("\n");
+}
+
+// src/mock-gen/handler-emitter.ts
+function emitMswHandlers(spec) {
+  const lines = [
+    `/**`,
+    ` * MSW request handlers.`,
+    ` * Generated by auto-api-hooks \u2014 do not edit manually.`,
+    ` */`,
+    `import { http, HttpResponse } from 'msw'`,
+    `import * as mocks from './data'`,
+    ``,
+    `export const handlers = [`
+  ];
+  for (const op of spec.operations) {
+    if (!isHttpMethod(op.method)) continue;
+    const mswMethod = op.method.toLowerCase();
+    const mswPath = convertPathToMsw(op.path, spec.baseUrl);
+    const mockFnName = `generate${op.operationId.charAt(0).toUpperCase() + op.operationId.slice(1)}Mock`;
+    const statusCode = getStatusCode(op);
+    lines.push(
+      `  http.${mswMethod}('${mswPath}', () => {`,
+      `    return HttpResponse.json(mocks.${mockFnName}(), { status: ${statusCode} })`,
+      `  }),`
+    );
+  }
+  lines.push(
+    `]`,
+    ``
+  );
+  return lines.join("\n");
+}
+function emitMswServerSetup() {
+  return [
+    `/**`,
+    ` * MSW server setup for Node.js (tests, SSR).`,
+    ` * Generated by auto-api-hooks \u2014 do not edit manually.`,
+    ` */`,
+    `import { setupServer } from 'msw/node'`,
+    `import { handlers } from './handlers'`,
+    ``,
+    `export const server = setupServer(...handlers)`,
+    ``
+  ].join("\n");
+}
+function emitMswBrowserSetup() {
+  return [
+    `/**`,
+    ` * MSW browser setup for development.`,
+    ` * Generated by auto-api-hooks \u2014 do not edit manually.`,
+    ` */`,
+    `import { setupWorker } from 'msw/browser'`,
+    `import { handlers } from './handlers'`,
+    ``,
+    `export const worker = setupWorker(...handlers)`,
+    ``
+  ].join("\n");
+}
+function emitMockIndex() {
+  return [
+    `export { handlers } from './handlers'`,
+    `export * from './data'`,
+    ``
+  ].join("\n");
+}
+function convertPathToMsw(path, baseUrl) {
+  const mswPath = path.replace(/\{(\w+)\}/g, ":$1");
+  if (baseUrl) {
+    return `${baseUrl}${mswPath}`;
+  }
+  return mswPath;
+}
+function isHttpMethod(method) {
+  return ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"].includes(method);
+}
+function getStatusCode(op) {
+  if (op.response.statusCode !== "default" && typeof op.response.statusCode === "number") {
+    return op.response.statusCode;
+  }
+  switch (op.method) {
+    case "POST":
+      return 201;
+    case "DELETE":
+      return 204;
+    default:
+      return 200;
+  }
+}
+
+// src/mock-gen/index.ts
+function generateMockFiles(spec) {
+  return [
+    { path: "mocks/data.ts", content: emitMockDataFile(spec) },
+    { path: "mocks/handlers.ts", content: emitMswHandlers(spec) },
+    { path: "mocks/server.ts", content: emitMswServerSetup() },
+    { path: "mocks/browser.ts", content: emitMswBrowserSetup() },
+    { path: "mocks/index.ts", content: emitMockIndex() }
+  ];
+}
+async function writeFiles(outputDir, files) {
+  for (const file of files) {
+    const fullPath = join(outputDir, file.path);
+    const dir = dirname(fullPath);
+    try {
+      await mkdir(dir, { recursive: true });
+      await writeFile(fullPath, file.content, "utf-8");
+      logger.verbose(`Wrote ${file.path}`);
+    } catch (err) {
+      throw new FileWriteError(
+        `Failed to write ${fullPath}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("auto-api-hooks").description("Auto-generate type-safe React hooks from OpenAPI, Swagger, or GraphQL specs.").version("1.0.0");
+program.command("generate").description("Generate React hooks from an API specification").requiredOption("--spec <path>", "Path to API spec file (OpenAPI, Swagger, or GraphQL)").option("--fetcher <strategy>", "Fetching strategy: fetch | axios | react-query | swr", "fetch").option("--output <dir>", "Output directory", "./src/hooks").option("--base-url <url>", "Override base URL from spec").option("--zod", "Generate Zod validation schemas", false).option("--mock", "Generate MSW mock server", false).option("--watch", "Watch spec file and regenerate on change", false).option("--no-infinite", "Disable infinite query generation for paginated endpoints").option("--tag <tags...>", "Only generate hooks for specific tags").option("--verbose", "Enable verbose logging", false).action(async (opts) => {
+  const {
+    spec: specPath,
+    fetcher,
+    output,
+    baseUrl,
+    zod,
+    mock,
+    watch,
+    infinite,
+    tag: tags,
+    verbose
+  } = opts;
+  if (verbose) setVerbose(true);
+  const validStrategies = ["fetch", "axios", "react-query", "swr"];
+  if (!validStrategies.includes(fetcher)) {
+    logger.error(`Invalid fetcher strategy: ${pc2.bold(fetcher)}`);
+    logger.info(`Valid options: ${validStrategies.join(", ")}`);
+    process.exit(1);
+  }
+  try {
+    await runGenerate({
+      specPath,
+      fetcher,
+      outputDir: output,
+      baseUrl,
+      zod: !!zod,
+      mock: !!mock,
+      infiniteQueries: infinite !== false,
+      tags
+    });
+    if (watch) {
+      await startWatchMode(specPath, {
+        specPath,
+        fetcher,
+        outputDir: output,
+        baseUrl,
+        zod: !!zod,
+        mock: !!mock,
+        infiniteQueries: infinite !== false,
+        tags
+      });
+    }
+  } catch (err) {
+    logger.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+async function runGenerate(config) {
+  const startTime = Date.now();
+  logger.info(`Parsing ${pc2.bold(config.specPath)}...`);
+  const spec = await parseSpec(config.specPath, { baseUrl: config.baseUrl });
+  if (config.tags && config.tags.length > 0) {
+    const tagSet = new Set(config.tags);
+    spec.operations = spec.operations.filter(
+      (op) => op.tags.some((t) => tagSet.has(t))
+    );
+  }
+  logger.verbose(`Found ${spec.operations.length} operations, ${spec.types.size} types`);
+  logger.info(`Generating ${pc2.bold(config.fetcher)} hooks...`);
+  const hookFiles = generateHooks(spec, {
+    fetcher: config.fetcher,
+    zod: config.zod,
+    mock: false,
+    // Mock files are generated separately
+    outputDir: config.outputDir,
+    baseUrl: config.baseUrl,
+    infiniteQueries: config.infiniteQueries
+  });
+  let mockFiles = [];
+  if (config.mock) {
+    logger.info("Generating MSW mock server...");
+    mockFiles = generateMockFiles(spec);
+  }
+  const allFiles = [...hookFiles, ...mockFiles];
+  await writeFiles(config.outputDir, allFiles);
+  const duration = Date.now() - startTime;
+  logger.success(
+    `Generated ${pc2.bold(String(allFiles.length))} files in ${pc2.bold(config.outputDir)} (${duration}ms)`
+  );
+  const hookCount = hookFiles.filter((f) => f.path.includes("use")).length;
+  logger.info(
+    `  ${pc2.cyan("Hooks:")} ${hookCount} | ${pc2.cyan("Types:")} ${spec.types.size} | ${pc2.cyan("Strategy:")} ${config.fetcher}${config.zod ? ` | ${pc2.cyan("Zod:")} \u2714` : ""}${config.mock ? ` | ${pc2.cyan("Mocks:")} \u2714` : ""}`
+  );
+}
+async function startWatchMode(specPath, config) {
+  const { watch } = await import('chokidar');
+  logger.info(`
+${pc2.yellow("\u{1F440} Watching")} ${pc2.bold(specPath)} for changes...
+`);
+  const watcher = watch(specPath, {
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 300, pollInterval: 100 }
+  });
+  watcher.on("change", async () => {
+    logger.info(`
+${pc2.yellow("\u21BB")} Spec changed, regenerating...`);
+    try {
+      await runGenerate(config);
+    } catch (err) {
+      logger.error(err instanceof Error ? err.message : String(err));
+    }
+  });
+  process.on("SIGINT", () => {
+    logger.info("\nStopping watch mode...");
+    watcher.close();
+    process.exit(0);
+  });
+}
+program.parse();
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map