@moinax/orc 0.1.0

package/dist/cli.js

@@ -0,0 +1,1491 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import path5 from "path";
+import fs5 from "fs";
+import { createJiti } from "jiti";
+
+// src/generator/client-generator.ts
+import fs3 from "fs";
+import path3 from "path";
+
+// src/generator/enum-registry.ts
+import pluralizeLib2 from "pluralize";
+
+// src/generator/utils.ts
+import pluralizeLib from "pluralize";
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function camelCase(str) {
+  const result = str.replace(/[-_]+/g, "_").replace(/_([a-zA-Z])/g, (_, char) => char.toUpperCase()).replace(/_+/g, "");
+  return result.charAt(0).toLowerCase() + result.slice(1);
+}
+function pascalCase(str) {
+  return capitalize(camelCase(str));
+}
+function schemaConstToTypeName(schemaConstName) {
+  const withoutSuffix = schemaConstName.replace(/Schema$/, "");
+  return pascalCase(withoutSuffix);
+}
+function singularize(str) {
+  const match = str.match(/^(.*)([A-Z][a-z]+s)$/);
+  if (match) {
+    const prefix = match[1];
+    const lastWord = match[2];
+    return prefix + pluralizeLib.singular(lastWord);
+  }
+  return pluralizeLib.singular(str);
+}
+function isBooleanLikeEnum(values) {
+  if (!Array.isArray(values) || values.length !== 2) return false;
+  const sorted = [...values].sort();
+  return sorted[0] === "false" && sorted[1] === "true";
+}
+function getResourcePrefixedParamNames(methodName, resourceClassName) {
+  const singularResource = singularize(resourceClassName);
+  if (methodName.startsWith("get")) {
+    const rest = methodName.slice(3);
+    return {
+      schemaConstName: `get${singularResource}${rest}ParamsSchema`,
+      typeName: `Get${singularResource}${rest}Params`
+    };
+  }
+  return {
+    schemaConstName: `${camelCase(methodName)}${singularResource}ParamsSchema`,
+    typeName: `${pascalCase(methodName)}${singularResource}Params`
+  };
+}
+function validateFileName(name, context) {
+  if (!name || typeof name !== "string") {
+    throw new Error(`Invalid ${context}: must be a non-empty string`);
+  }
+  if (name.includes("..") || name.includes("/") || name.includes("\\")) {
+    throw new Error(`Invalid ${context}: contains path traversal characters`);
+  }
+  if (!/^[a-zA-Z][a-zA-Z0-9]*$/.test(name)) {
+    throw new Error(`Invalid ${context}: must be alphanumeric starting with a letter`);
+  }
+}
+function validateOutputPath(outputPath) {
+  if (!outputPath || typeof outputPath !== "string") {
+    throw new Error("Invalid output path: must be a non-empty string");
+  }
+  if (outputPath.includes("..")) {
+    throw new Error("Invalid output path: contains path traversal characters");
+  }
+}
+function isListResponse(responseSchema) {
+  if (!responseSchema) return false;
+  if (responseSchema.type === "object" && responseSchema.properties?.pagination) {
+    return true;
+  }
+  if (responseSchema.type === "array") {
+    return true;
+  }
+  if (responseSchema.type === "object" && responseSchema.properties) {
+    for (const arrayProp of ["data", "items", "results"]) {
+      const prop = responseSchema.properties[arrayProp];
+      if (prop?.type === "array") return true;
+    }
+  }
+  if (responseSchema.$ref) {
+    const refName = responseSchema.$ref.split("/").pop();
+    if (refName.includes("Paginated") || refName.includes("List")) {
+      return true;
+    }
+  }
+  return false;
+}
+function operationIdToMethodName(operationId, httpMethod, pathPattern, resourceName, responseSchema) {
+  const isList = isListResponse(responseSchema);
+  switch (httpMethod) {
+    case "get":
+      return isList ? "getList" : "getDetail";
+    case "post":
+      return "create";
+    case "put":
+      return "replace";
+    case "patch":
+      return "update";
+    case "delete":
+      return "delete";
+    default:
+      return operationId ? camelCase(operationId) : httpMethod;
+  }
+}
+function parsePathSegments(pathPattern) {
+  return pathPattern.split("/").filter((seg) => seg).map((seg) => ({
+    name: seg.startsWith("{") ? seg.slice(1, -1) : seg,
+    isParam: seg.startsWith("{"),
+    raw: seg
+  }));
+}
+function getResourcePath(pathPattern) {
+  const segments = parsePathSegments(pathPattern);
+  const resourcePath = [];
+  for (const seg of segments) {
+    if (!seg.isParam) {
+      resourcePath.push(seg.name);
+    }
+  }
+  return resourcePath;
+}
+function buildPathTree(paths) {
+  const tree = {
+    name: "root",
+    children: /* @__PURE__ */ new Map(),
+    operations: []
+  };
+  for (const [pathPattern, methods] of Object.entries(paths)) {
+    for (const [httpMethod, operation] of Object.entries(methods)) {
+      if (httpMethod === "parameters") continue;
+      const resourcePath = getResourcePath(pathPattern);
+      let current = tree;
+      for (const segment of resourcePath) {
+        if (!current.children.has(segment)) {
+          current.children.set(segment, {
+            name: segment,
+            children: /* @__PURE__ */ new Map(),
+            operations: []
+          });
+        }
+        current = current.children.get(segment);
+      }
+      current.operations.push({
+        pathPattern,
+        httpMethod,
+        operation
+      });
+    }
+  }
+  return tree;
+}
+function cleanSchemaName(name) {
+  if (name.endsWith("SchemaInput")) {
+    name = name.replace("SchemaInput", "Input");
+  } else if (name.endsWith("Schema")) {
+    name = name.replace("Schema", "");
+  }
+  if (name.includes("__")) {
+    const parts = name.split("__");
+    name = parts[parts.length - 1];
+  }
+  name = name.replace(/_+$/, "");
+  name = name.replace(/_([A-Za-z])/g, (_, char) => char.toUpperCase());
+  return name;
+}
+
+// src/generator/enum-registry.ts
+var EnumRegistry = class _EnumRegistry {
+  enums = /* @__PURE__ */ new Map();
+  enumContexts = /* @__PURE__ */ new Map();
+  usedNames = /* @__PURE__ */ new Set();
+  static fingerprint(values) {
+    return JSON.stringify([...values].sort());
+  }
+  generateEnumNames(values, context) {
+    const { source, schemaName, propertyPath, paramName, resourceName } = context;
+    let baseName;
+    if (source === "schema" && schemaName && propertyPath) {
+      const cleanSchemaName2 = schemaName.replace(/Schema$/, "").replace(/SchemaInput$/, "").replace(/Input$/, "");
+      const pathParts = propertyPath.split(".");
+      const contextFromPath = pathParts.map((p) => pascalCase(singularize(p))).join("");
+      baseName = camelCase(cleanSchemaName2) + contextFromPath;
+    } else if (source === "queryParam" && resourceName && paramName) {
+      const singularResource = singularize(resourceName);
+      baseName = camelCase(singularResource) + pascalCase(paramName);
+    } else {
+      baseName = camelCase(values[0].toLowerCase());
+    }
+    const valuesConstName = pluralizeLib2.isPlural(baseName) ? baseName : pluralizeLib2.plural(baseName);
+    return {
+      valuesConstName,
+      schemaConstName: `${singularize(baseName)}Schema`,
+      typeName: pascalCase(singularize(baseName)),
+      values
+    };
+  }
+  register(values, context) {
+    const fingerprint = _EnumRegistry.fingerprint(values);
+    if (!this.enumContexts.has(fingerprint)) {
+      this.enumContexts.set(fingerprint, []);
+    }
+    this.enumContexts.get(fingerprint).push(context);
+    if (this.enums.has(fingerprint)) {
+      return this.enums.get(fingerprint);
+    }
+    let enumInfo = this.generateEnumNames(values, context);
+    let counter = 1;
+    const hasCollision = () => this.usedNames.has(enumInfo.valuesConstName) || this.usedNames.has(enumInfo.schemaConstName) || this.usedNames.has(enumInfo.typeName);
+    while (hasCollision()) {
+      const baseInfo = this.generateEnumNames(values, context);
+      enumInfo = {
+        valuesConstName: `${baseInfo.valuesConstName}${counter}`,
+        schemaConstName: `${baseInfo.schemaConstName.replace(/Schema$/, "")}${counter}Schema`,
+        typeName: `${baseInfo.typeName}${counter}`,
+        values: baseInfo.values
+      };
+      counter++;
+    }
+    this.usedNames.add(enumInfo.valuesConstName);
+    this.usedNames.add(enumInfo.schemaConstName);
+    this.usedNames.add(enumInfo.typeName);
+    this.enums.set(fingerprint, enumInfo);
+    return enumInfo;
+  }
+  has(values) {
+    return this.enums.has(_EnumRegistry.fingerprint(values));
+  }
+  get(values) {
+    return this.enums.get(_EnumRegistry.fingerprint(values));
+  }
+  getAll() {
+    return Array.from(this.enums.values());
+  }
+  generateEnumExports() {
+    const lines = [];
+    if (this.enums.size === 0) {
+      return "";
+    }
+    lines.push("// ============================================================================");
+    lines.push("// Extracted Enums");
+    lines.push("// ============================================================================");
+    lines.push("");
+    for (const enumInfo of this.enums.values()) {
+      const { valuesConstName, schemaConstName, typeName, values } = enumInfo;
+      const valuesStr = values.map((v) => `'${v}'`).join(", ");
+      lines.push(`export const ${valuesConstName} = [${valuesStr}] as const;`);
+      lines.push(`export const ${schemaConstName} = z.enum(${valuesConstName});`);
+      lines.push(`export type ${typeName} = z.output<typeof ${schemaConstName}>;`);
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/generator/resource-generator.ts
+var ResourceGenerator = class {
+  schemas;
+  clientClassName;
+  stripPathPrefix;
+  enumRegistry;
+  paths;
+  pathTree;
+  generatedResources = /* @__PURE__ */ new Map();
+  collectedInlineSchemas = /* @__PURE__ */ new Map();
+  currentResourceName = null;
+  runtimePackage;
+  constructor(paths, schemas, clientClassName, options = {}) {
+    this.schemas = schemas || {};
+    this.clientClassName = clientClassName;
+    this.stripPathPrefix = options.stripPathPrefix || null;
+    this.enumRegistry = options.enumRegistry || new EnumRegistry();
+    this.runtimePackage = options.runtimePackage || "@moinax/orc";
+    this.paths = this.stripPathPrefix ? this.stripPrefixFromPaths(paths || {}) : paths || {};
+    this.pathTree = buildPathTree(this.paths);
+  }
+  collectAllInlineSchemas() {
+    this._collectInlineSchemasFromNode(this.pathTree, []);
+    return this.collectedInlineSchemas;
+  }
+  _collectInlineSchemasFromNode(node, parentPath) {
+    const nodeName = node.name === "root" ? "" : node.name;
+    const currentPath = [...parentPath, nodeName].filter(Boolean);
+    const operationMethodNames = /* @__PURE__ */ new Map();
+    for (const { pathPattern, httpMethod, operation } of node.operations) {
+      const responseSchemaObj = (operation.responses?.["200"] || operation.responses?.["201"])?.content?.["application/json"]?.schema;
+      const methodName = operationIdToMethodName(
+        operation.operationId,
+        httpMethod,
+        pathPattern,
+        node.name,
+        responseSchemaObj
+      );
+      const opKey = this.getOperationKey(pathPattern, httpMethod);
+      operationMethodNames.set(opKey, methodName);
+    }
+    const resourceClassName = this.getResourceClassName(currentPath);
+    for (const { pathPattern, httpMethod, operation } of node.operations) {
+      if (this.hasInlineRequestBody(operation)) {
+        const requestSchema = this.getRequestSchemaName(operation, pathPattern);
+        if (!requestSchema) {
+          const opKey = this.getOperationKey(pathPattern, httpMethod);
+          const methodName = operationMethodNames.get(opKey);
+          const schemaConstName = this.generateInlineSchemaName(resourceClassName, methodName, "body");
+          const bodySchema = operation.requestBody.content["application/json"].schema;
+          this.collectedInlineSchemas.set(schemaConstName, {
+            schema: bodySchema,
+            isInput: true,
+            typeName: `${pascalCase(resourceClassName)}${pascalCase(methodName)}Body`
+          });
+        }
+      }
+    }
+    for (const { pathPattern, httpMethod, operation } of node.operations) {
+      if (this.hasInlineResponseSchema(operation)) {
+        const responseSchema = this.getResponseSchemaName(operation, pathPattern);
+        if (!responseSchema) {
+          const opKey = this.getOperationKey(pathPattern, httpMethod);
+          const methodName = operationMethodNames.get(opKey);
+          const schemaConstName = this.generateInlineSchemaName(resourceClassName, methodName, "response");
+          const successResponse = operation.responses?.["200"] || operation.responses?.["201"];
+          const inlineSchema = successResponse.content["application/json"].schema;
+          this.collectedInlineSchemas.set(schemaConstName, {
+            schema: inlineSchema,
+            isInput: false,
+            typeName: `${pascalCase(resourceClassName)}${pascalCase(methodName)}Response`
+          });
+        }
+      }
+    }
+    for (const [, childNode] of node.children) {
+      this._collectInlineSchemasFromNode(childNode, currentPath);
+    }
+  }
+  stripPrefixFromPaths(paths) {
+    const result = {};
+    for (const [pathPattern, methods] of Object.entries(paths)) {
+      let newPath = pathPattern;
+      if (this.stripPathPrefix && pathPattern.startsWith(this.stripPathPrefix)) {
+        newPath = pathPattern.slice(this.stripPathPrefix.length) || "/";
+      }
+      result[newPath] = methods;
+    }
+    return result;
+  }
+  getResponseSchemaName(operation, pathPattern = null) {
+    const successResponse = operation.responses?.["200"] || operation.responses?.["201"];
+    if (!successResponse) return null;
+    const content = successResponse.content?.["application/json"];
+    if (!content?.schema) return null;
+    const schema = content.schema;
+    if (schema.$ref) {
+      const rawName = schema.$ref.split("/").pop();
+      return cleanSchemaName(rawName);
+    }
+    if (schema.type === "object") {
+      if (operation.operationId) {
+        const opId = operation.operationId;
+        const patterns = [
+          /^create[_-]?(.+)$/i,
+          /^update[_-]?(.+)$/i,
+          /^get[_-]?(.+)$/i,
+          /^(.+)[_-]?create$/i,
+          /^(.+)[_-]?update$/i,
+          /^(.+)[_-]?get$/i
+        ];
+        for (const pattern of patterns) {
+          const match = opId.match(pattern);
+          if (match) {
+            const entityName = pascalCase(match[1].replace(/[_-]/g, " "));
+            const schemaSchemaName = `${entityName}Schema`;
+            if (this.schemas[entityName] || this.schemas[schemaSchemaName]) {
+              return entityName;
+            }
+          }
+        }
+      }
+      if (pathPattern) {
+        const resourcePath = getResourcePath(pathPattern);
+        if (resourcePath.length > 0) {
+          const lastSegment = resourcePath[resourcePath.length - 1];
+          const entityName = pascalCase(singularize(lastSegment));
+          const schemaSchemaName = `${entityName}Schema`;
+          if (this.schemas[entityName] || this.schemas[schemaSchemaName]) {
+            return entityName;
+          }
+        }
+      }
+    }
+    if (schema.type === "object" && schema.properties) {
+      return null;
+    }
+    return null;
+  }
+  getRequestSchemaName(operation, pathPattern = null) {
+    const content = operation.requestBody?.content?.["application/json"];
+    if (!content?.schema) return null;
+    const schema = content.schema;
+    if (schema.$ref) {
+      const rawName = schema.$ref.split("/").pop();
+      return cleanSchemaName(rawName);
+    }
+    return null;
+  }
+  hasInlineRequestBody(operation) {
+    const content = operation.requestBody?.content?.["application/json"];
+    if (!content?.schema) return false;
+    return !content.schema.$ref && content.schema.type === "object";
+  }
+  hasInlineResponseSchema(operation) {
+    const successResponse = operation.responses?.["200"] || operation.responses?.["201"];
+    if (!successResponse) return false;
+    const content = successResponse.content?.["application/json"];
+    if (!content?.schema) return false;
+    const schema = content.schema;
+    if (schema.$ref) return false;
+    if (schema.type === "object" && schema.properties?.pagination) return false;
+    return schema.type === "object" && !!schema.properties;
+  }
+  generateInlineSchemaName(resourceName, methodName, purpose) {
+    const baseName = `${camelCase(resourceName)}${capitalize(methodName)}${capitalize(purpose)}Schema`;
+    return camelCase(baseName);
+  }
+  getPathParams(operation) {
+    return (operation.parameters || []).filter((p) => "in" in p && p.in === "path").map((p) => ({
+      name: p.name,
+      type: this.paramTypeToTs(p.schema),
+      required: p.required !== false
+    }));
+  }
+  getQueryParams(operation) {
+    return (operation.parameters || []).filter((p) => "in" in p && p.in === "query").map((p) => ({
+      name: p.name,
+      type: this.paramTypeToTs(p.schema),
+      required: p.required === true,
+      schema: p.schema
+    }));
+  }
+  paramTypeToTs(schema) {
+    if (!schema) return "string";
+    if (schema.enum) return schema.enum.map((v) => `'${v}'`).join(" | ");
+    switch (schema.type) {
+      case "integer":
+      case "number":
+        return "number";
+      case "boolean":
+        return "boolean";
+      default:
+        return "string";
+    }
+  }
+  paramToZod(param, resourceName) {
+    const { schema, name: paramName } = param;
+    if (!schema) return "z.string()";
+    let zodType;
+    if (schema.enum) {
+      if (isBooleanLikeEnum(schema.enum)) {
+        zodType = "z.boolean()";
+      } else {
+        const context = {
+          source: "queryParam",
+          resourceName: resourceName || this.currentResourceName || void 0,
+          paramName
+        };
+        const enumInfo = this.enumRegistry.register(schema.enum, context);
+        zodType = enumInfo.schemaConstName;
+      }
+    } else {
+      switch (schema.type) {
+        case "integer":
+          zodType = "z.number().int()";
+          break;
+        case "number":
+          zodType = "z.number()";
+          break;
+        case "boolean":
+          zodType = "z.boolean()";
+          break;
+        default:
+          zodType = "z.string()";
+      }
+    }
+    if (!param.required) {
+      zodType = `${zodType}.optional()`;
+    }
+    return zodType;
+  }
+  isPaginationParam(paramName) {
+    return ["page", "limit", "orderBy", "ordering"].includes(paramName);
+  }
+  getUniqueMethodName(operationId, httpMethod, pathPattern, usedNames, responseSchema) {
+    let methodName = operationIdToMethodName(operationId, httpMethod, pathPattern, "", responseSchema);
+    if (usedNames.has(methodName) && operationId) {
+      methodName = camelCase(operationId);
+    }
+    let finalName = methodName;
+    let counter = 1;
+    while (usedNames.has(finalName)) {
+      finalName = `${methodName}${counter}`;
+      counter++;
+    }
+    usedNames.add(finalName);
+    return finalName;
+  }
+  getOperationKey(pathPattern, httpMethod) {
+    return `${httpMethod}:${pathPattern}`;
+  }
+  getResourceClassName(pathSegments) {
+    return pathSegments.map((seg) => pascalCase(seg)).join("");
+  }
+  generateResourceNode(node, pathSegments) {
+    const parentImportPath = "../";
+    const resourceClassName = this.getResourceClassName(pathSegments);
+    this.currentResourceName = resourceClassName;
+    const lines = [];
+    const usedMethodNames = /* @__PURE__ */ new Set();
+    const schemaImports = /* @__PURE__ */ new Set();
+    let hasQueryParams = false;
+    let hasPaginatedResponse = false;
+    const childResources = [];
+    for (const [childName, childNode] of node.children) {
+      const childPath = [...pathSegments, childName];
+      const childClassName = this.getResourceClassName(childPath);
+      childResources.push({
+        propertyName: singularize(camelCase(childName)),
+        className: childClassName,
+        fileName: `${childClassName}.resource`
+      });
+    }
+    const operationMethodNames = /* @__PURE__ */ new Map();
+    let usesInlineZod = false;
+    for (const { pathPattern, httpMethod, operation } of node.operations) {
+      const successResponse = operation.responses?.["200"] || operation.responses?.["201"];
+      const responseContent = successResponse?.content?.["application/json"];
+      const responseSchemaObj = responseContent?.schema;
+      const methodName = this.getUniqueMethodName(
+        operation.operationId,
+        httpMethod,
+        pathPattern,
+        usedMethodNames,
+        responseSchemaObj
+      );
+      const opKey = this.getOperationKey(pathPattern, httpMethod);
+      operationMethodNames.set(opKey, methodName);
+      const queryParams = this.getQueryParams(operation);
+      if (queryParams.length > 0) {
+        hasQueryParams = true;
+      }
+      if (responseSchemaObj?.type === "object" && responseSchemaObj?.properties?.pagination) {
+        hasPaginatedResponse = true;
+      }
+      if (responseSchemaObj?.type === "object" && responseSchemaObj?.properties?.pagination && !responseSchemaObj?.properties?.data?.items?.$ref) {
+        usesInlineZod = true;
+      }
+    }
+    const typeImports = /* @__PURE__ */ new Map();
+    if (hasQueryParams) {
+      schemaImports.add("paginationParamsSchema");
+    }
+    if (hasPaginatedResponse) {
+      schemaImports.add("paginationResponseSchema");
+      typeImports.set("paginationResponseSchema", "PaginationResponse");
+    }
+    for (const { pathPattern, operation } of node.operations) {
+      const responseSchema = this.getResponseSchemaName(operation, pathPattern);
+      if (responseSchema) {
+        const schemaConst = `${camelCase(responseSchema)}Schema`;
+        schemaImports.add(schemaConst);
+        typeImports.set(schemaConst, pascalCase(responseSchema));
+      }
+      const requestSchema = this.getRequestSchemaName(operation, pathPattern);
+      if (requestSchema) {
+        const schemaConst = `${camelCase(requestSchema)}Schema`;
+        schemaImports.add(schemaConst);
+        typeImports.set(schemaConst, pascalCase(requestSchema));
+      }
+    }
+    const inlineBodySchemas = /* @__PURE__ */ new Map();
+    for (const { pathPattern, httpMethod, operation } of node.operations) {
+      if (this.hasInlineRequestBody(operation)) {
+        const requestSchema = this.getRequestSchemaName(operation, pathPattern);
+        if (!requestSchema) {
+          const opKey = this.getOperationKey(pathPattern, httpMethod);
+          const methodName = operationMethodNames.get(opKey);
+          const schemaConstName = this.generateInlineSchemaName(resourceClassName, methodName, "body");
+          const typeName = schemaConstToTypeName(schemaConstName);
+          inlineBodySchemas.set(opKey, { schemaConst: schemaConstName, typeName });
+          schemaImports.add(schemaConstName);
+          typeImports.set(schemaConstName, typeName);
+        }
+      }
+    }
+    const inlineResponseSchemas = /* @__PURE__ */ new Map();
+    for (const { pathPattern, httpMethod, operation } of node.operations) {
+      if (this.hasInlineResponseSchema(operation)) {
+        const responseSchema = this.getResponseSchemaName(operation, pathPattern);
+        if (!responseSchema) {
+          const opKey = this.getOperationKey(pathPattern, httpMethod);
+          const methodName = operationMethodNames.get(opKey);
+          const schemaConstName = this.generateInlineSchemaName(resourceClassName, methodName, "response");
+          const typeName = schemaConstToTypeName(schemaConstName);
+          inlineResponseSchemas.set(opKey, { schemaConst: schemaConstName, typeName });
+          schemaImports.add(schemaConstName);
+          typeImports.set(schemaConstName, typeName);
+        }
+      }
+    }
+    const needsZod = hasQueryParams || usesInlineZod;
+    if (needsZod) {
+      lines.push("import { z } from 'zod';");
+      lines.push("");
+    }
+    const hasParsing = node.operations.some(({ httpMethod, operation }) => {
+      const successResponse = operation.responses?.["200"] || operation.responses?.["201"];
+      const hasResponseParsing = !!successResponse?.content?.["application/json"]?.schema;
+      const hasBodyParsing = ["post", "put", "patch"].includes(httpMethod) && !!operation.requestBody;
+      const hasParamsParsing = this.getQueryParams(operation).length > 0;
+      return hasResponseParsing || hasBodyParsing || hasParamsParsing;
+    });
+    if (hasParsing) {
+      lines.push(`import { parseSchema } from '${this.runtimePackage}';`);
+    }
+    lines.push(`import { Resource } from '${parentImportPath}Resource';`);
+    const schemaImportPlaceholderIndex = lines.length;
+    lines.push("__SCHEMA_IMPORTS_PLACEHOLDER__");
+    for (const child of childResources) {
+      lines.push(`import { ${child.className}Resource } from './${child.fileName}';`);
+    }
+    lines.push("");
+    const queryParamsSchemas = [];
+    for (const { pathPattern, httpMethod, operation } of node.operations) {
+      const queryParams = this.getQueryParams(operation);
+      if (queryParams.length > 0) {
+        const opKey = this.getOperationKey(pathPattern, httpMethod);
+        const methodName = operationMethodNames.get(opKey);
+        const { schemaConstName, typeName } = getResourcePrefixedParamNames(methodName, resourceClassName);
+        const specificParams = queryParams.filter((p) => !this.isPaginationParam(p.name));
+        if (specificParams.length > 0) {
+          const props = specificParams.map((p) => {
+            const zodCode = this.paramToZod(p, resourceClassName);
+            if (p.schema?.enum) {
+              const enumInfo = this.enumRegistry.get(p.schema.enum);
+              if (enumInfo) {
+                schemaImports.add(enumInfo.schemaConstName);
+              }
+            }
+            return `  ${p.name}: ${zodCode}`;
+          });
+          queryParamsSchemas.push(
+            `export const ${schemaConstName} = paginationParamsSchema.extend({
+${props.join(",\n")},
+});`
+          );
+        } else {
+          queryParamsSchemas.push(`export const ${schemaConstName} = paginationParamsSchema;`);
+        }
+        queryParamsSchemas.push(`export type ${typeName} = z.input<typeof ${schemaConstName}>;`);
+        queryParamsSchemas.push("");
+      }
+    }
+    if (queryParamsSchemas.length > 0) {
+      lines.push("// Query parameter schemas");
+      lines.push(queryParamsSchemas.join("\n"));
+    }
+    lines.push(`export class ${resourceClassName}Resource extends Resource {`);
+    for (const child of childResources) {
+      lines.push(`  public ${child.propertyName}: ${child.className}Resource;`);
+    }
+    if (childResources.length > 0) {
+      lines.push("");
+      lines.push(
+        `  constructor(client: InstanceType<typeof import('${parentImportPath}${this.clientClassName}').default>) {`
+      );
+      lines.push("    super(client);");
+      for (const child of childResources) {
+        lines.push(`    this.${child.propertyName} = new ${child.className}Resource(client);`);
+      }
+      lines.push("  }");
+    }
+    for (const { pathPattern, httpMethod, operation } of node.operations) {
+      const opKey = this.getOperationKey(pathPattern, httpMethod);
+      const methodName = operationMethodNames.get(opKey);
+      const pathParams = this.getPathParams(operation);
+      const queryParams = this.getQueryParams(operation);
+      const responseSchema = this.getResponseSchemaName(operation, pathPattern);
+      const requestSchema = this.getRequestSchemaName(operation, pathPattern);
+      const params = [];
+      for (const p of pathParams) {
+        params.push(`${p.name}: ${p.type}`);
+      }
+      if (queryParams.length > 0) {
+        const { typeName } = getResourcePrefixedParamNames(methodName, resourceClassName);
+        const hasRequired = queryParams.some((p) => p.required);
+        params.push(`params${hasRequired ? "" : "?"}: ${typeName}`);
+      }
+      const inlineBodySchema = inlineBodySchemas.get(opKey);
+      if (["post", "put", "patch"].includes(httpMethod) && operation.requestBody) {
+        if (requestSchema) {
+          const schemaConst = `${camelCase(requestSchema)}Schema`;
+          const typeName = typeImports.get(schemaConst);
+          params.push(`body: ${typeName}`);
+        } else if (inlineBodySchema) {
+          params.push(`body: ${inlineBodySchema.typeName}`);
+        } else {
+          params.push("body: Record<string, unknown>");
+        }
+      }
+      const fullPath = this.stripPathPrefix ? this.stripPathPrefix + pathPattern : pathPattern;
+      let pathTemplate = fullPath.replace(/\{(\w+)\}/g, "${$1}");
+      pathTemplate = "`" + pathTemplate + "`";
+      const successResponse = operation.responses?.["200"] || operation.responses?.["201"];
+      const responseContent = successResponse?.content?.["application/json"];
+      const responseSchemaObj = responseContent?.schema;
+      let returnType = "void";
+      let parseLogic = "";
+      if (responseSchemaObj) {
+        if (responseSchemaObj.type === "object" && responseSchemaObj.properties?.pagination) {
+          const dataRef = responseSchemaObj.properties.data?.items?.$ref;
+          if (dataRef) {
+            const rawItemSchema = dataRef.split("/").pop();
+            const itemSchema = cleanSchemaName(rawItemSchema);
+            const itemSchemaConst = `${camelCase(itemSchema)}Schema`;
+            const itemTypeName = pascalCase(itemSchema);
+            schemaImports.add(itemSchemaConst);
+            typeImports.set(itemSchemaConst, itemTypeName);
+            returnType = `{ pagination: PaginationResponse; data: ${itemTypeName}[] }`;
+            parseLogic = `const schema = z.object({ pagination: paginationResponseSchema, data: z.array(${itemSchemaConst}) }).describe('Paginated${itemTypeName}List');
+    return parseSchema(schema, response);`;
+          } else {
+            if (responseSchema) {
+              const itemSchemaConst = `${camelCase(responseSchema)}Schema`;
+              const itemTypeName = pascalCase(responseSchema);
+              schemaImports.add(itemSchemaConst);
+              typeImports.set(itemSchemaConst, itemTypeName);
+              returnType = `{ pagination: PaginationResponse; data: ${itemTypeName}[] }`;
+              parseLogic = `const schema = z.object({ pagination: paginationResponseSchema, data: z.array(${itemSchemaConst}) }).describe('Paginated${itemTypeName}List');
+    return parseSchema(schema, response);`;
+            } else {
+              returnType = `{ pagination: PaginationResponse; data: unknown[] }`;
+              parseLogic = `const schema = z.object({ pagination: paginationResponseSchema, data: z.array(z.unknown()) }).describe('PaginatedList');
+    return parseSchema(schema, response);`;
+            }
+          }
+        } else if (responseSchema) {
+          const schemaConstName = `${camelCase(responseSchema)}Schema`;
+          const typeName = pascalCase(responseSchema);
+          returnType = typeName;
+          parseLogic = `return parseSchema(${schemaConstName}, response);`;
+          schemaImports.add(schemaConstName);
+          typeImports.set(schemaConstName, typeName);
+        } else if (inlineResponseSchemas.get(opKey)) {
+          const inlineSchema = inlineResponseSchemas.get(opKey);
+          returnType = inlineSchema.typeName;
+          parseLogic = `return parseSchema(${inlineSchema.schemaConst}, response);`;
+        } else {
+          returnType = "unknown";
+          parseLogic = "return response;";
+        }
+      }
+      lines.push("");
+      lines.push(`  async ${methodName}(${params.join(", ")}): Promise<${returnType}> {`);
+      if (queryParams.length > 0) {
+        const { schemaConstName } = getResourcePrefixedParamNames(methodName, resourceClassName);
+        lines.push(`    const searchParams = new URLSearchParams();`);
+        lines.push(`    if (params) {`);
+        lines.push(`      const validated = parseSchema(${schemaConstName}, params);`);
+        lines.push(`      Object.entries(validated).forEach(([key, value]) => {`);
+        lines.push(`        if (value !== undefined) searchParams.set(key, String(value));`);
+        lines.push(`      });`);
+        lines.push(`    }`);
+        lines.push(`    const query = searchParams.toString();`);
+        lines.push(`    const url = query ? \`\${${pathTemplate}}?\${query}\` : ${pathTemplate};`);
+      }
+      const urlVar = queryParams.length > 0 ? "url" : pathTemplate;
+      const needsResponse = returnType !== "void";
+      const responsePrefix = needsResponse ? "const response = " : "";
+      const hasBodySchema = requestSchema || inlineBodySchema;
+      const hasBodyValidation = ["post", "put", "patch"].includes(httpMethod) && hasBodySchema;
+      const bodyVar = hasBodyValidation ? "validatedBody" : "body";
+      if (hasBodyValidation) {
+        const bodySchemaConst = requestSchema ? `${camelCase(requestSchema)}Schema` : inlineBodySchema.schemaConst;
+        lines.push(`    const validatedBody = parseSchema(${bodySchemaConst}, body);`);
+      }
+      switch (httpMethod) {
+        case "get":
+          lines.push(`    ${responsePrefix}await this.client.get(${urlVar});`);
+          break;
+        case "post":
+          lines.push(`    ${responsePrefix}await this.client.post(${urlVar}, ${bodyVar});`);
+          break;
+        case "put":
+          lines.push(`    ${responsePrefix}await this.client.put(${urlVar}, ${bodyVar});`);
+          break;
+        case "patch":
+          lines.push(`    ${responsePrefix}await this.client.patch(${urlVar}, ${bodyVar});`);
+          break;
+        case "delete":
+          lines.push(`    ${responsePrefix}await this.client.delete(${urlVar});`);
+          break;
+      }
+      if (parseLogic) {
+        lines.push(`    ${parseLogic}`);
+      }
+      lines.push("  }");
+    }
+    lines.push("}");
+    const placeholderIndex = lines.findIndex((l) => l === "__SCHEMA_IMPORTS_PLACEHOLDER__");
+    if (placeholderIndex >= 0) {
+      if (schemaImports.size > 0 || typeImports.size > 0) {
+        const allImports = /* @__PURE__ */ new Set([...schemaImports, ...typeImports.values()]);
+        lines[placeholderIndex] = `import { ${Array.from(allImports).join(", ")} } from '${parentImportPath}schemas';`;
+      } else {
+        lines.splice(placeholderIndex, 1);
+      }
+    }
+    return {
+      className: resourceClassName,
+      code: lines.join("\n"),
+      children: childResources
+    };
+  }
+  generateFromTree(node, pathSegments = [], depth = 0) {
+    const resources = [];
+    for (const [childName, childNode] of node.children) {
+      const childPath = [...pathSegments, childName];
+      const childResources = this.generateFromTree(childNode, childPath, depth + 1);
+      resources.push(...childResources);
+    }
+    if (pathSegments.length > 0 && (node.operations.length > 0 || node.children.size > 0)) {
+      const resource = this.generateResourceNode(node, pathSegments);
+      resources.push({
+        pathSegments,
+        ...resource
+      });
+    }
+    return resources;
+  }
+  generateAll() {
+    this.collectAllInlineSchemas();
+    const resources = this.generateFromTree(this.pathTree);
+    const result = {};
+    for (const resource of resources) {
+      result[resource.className] = resource.code;
+    }
+    return {
+      resources: result,
+      tree: this.pathTree,
+      inlineSchemas: this.collectedInlineSchemas
+    };
+  }
+};
+
+// src/generator/zod-generator.ts
+var ZodGenerator = class {
+  schemas;
+  generatedSchemas = /* @__PURE__ */ new Map();
+  schemaOrder = [];
+  inlineSchemas = /* @__PURE__ */ new Map();
+  enumRegistry;
+  usedDateSchemas = {
+    stringToDateSchema: false,
+    stringToDaySchema: false,
+    dateToStringSchema: false,
+    dayToStringSchema: false
+  };
+  currentSchemaName = null;
+  currentPropertyPath = null;
+  constructor(schemas, enumRegistry) {
+    this.schemas = schemas || {};
+    this.enumRegistry = enumRegistry || new EnumRegistry();
+  }
+  addInlineSchemas(inlineSchemas) {
+    this.inlineSchemas = inlineSchemas;
+  }
+  convertSchema(schema, schemaName = null, isTopLevel = false) {
+    if (!schema) return "z.unknown()";
+    if (schema.$ref) {
+      const refName = schema.$ref.split("/").pop();
+      const cleanedName = cleanSchemaName(refName);
+      return `${camelCase(cleanedName)}Schema`;
+    }
+    if (schema.anyOf) {
+      const options = schema.anyOf.map((s) => this.convertSchema(s, schemaName));
+      if (options.length === 2 && options.includes("z.null()")) {
+        const nonNull = options.find((o) => o !== "z.null()");
+        const isInputSchema = schemaName && (schemaName.includes("Input") || schemaName.includes("Create") || schemaName.includes("Update"));
+        return isInputSchema ? `${nonNull}.nullish()` : `${nonNull}.nullable()`;
+      }
+      return `z.union([${options.join(", ")}])`;
+    }
+    if (schema.oneOf) {
+      const options = schema.oneOf.map((s) => this.convertSchema(s, schemaName));
+      return `z.union([${options.join(", ")}])`;
+    }
+    if (schema.allOf) {
+      const schemas = schema.allOf.map((s) => this.convertSchema(s, schemaName));
+      if (schemas.length === 1) return schemas[0];
+      return schemas.reduce((acc, s) => `${acc}.merge(${s})`);
+    }
+    if (schema.const !== void 0) {
+      if (typeof schema.const === "string") {
+        return `z.literal('${schema.const}')`;
+      }
+      return `z.literal(${JSON.stringify(schema.const)})`;
+    }
+    const isNullable = schema.nullable === true;
+    let zodSchema;
+    switch (schema.type) {
+      case "string":
+        zodSchema = this.convertStringSchema(schema, schemaName);
+        break;
+      case "number":
+      case "integer":
+        zodSchema = this.convertNumberSchema(schema, schemaName);
+        break;
+      case "boolean":
+        zodSchema = "z.boolean()";
+        break;
+      case "array":
+        zodSchema = this.convertArraySchema(schema, schemaName);
+        break;
+      case "object":
+        zodSchema = this.convertObjectSchema(schema, schemaName);
+        break;
+      case "null":
+        return "z.null()";
+      default:
+        if (schema.enum) {
+          zodSchema = this.convertEnumSchema(schema, schemaName);
+        } else if (schema.properties) {
+          zodSchema = this.convertObjectSchema(schema, schemaName);
+        } else {
+          zodSchema = "z.unknown()";
+        }
+    }
+    if (isNullable) {
+      const isInputSchema = schemaName && (schemaName.includes("Input") || schemaName.includes("Create") || schemaName.includes("Update"));
+      zodSchema = isInputSchema ? `${zodSchema}.nullish()` : `${zodSchema}.nullable()`;
+    }
+    return zodSchema;
+  }
+  convertStringSchema(schema, schemaName = null) {
+    if (schema.enum) {
+      return this.convertEnumSchema(schema, schemaName);
+    }
+    if (schema.format === "date-time" || schema.format === "date") {
+      const isInputSchema = schemaName && (schemaName.includes("Input") || schemaName.includes("Create") || schemaName.includes("Update"));
+      const isDateTime = schema.format === "date-time";
+      if (isInputSchema) {
+        if (isDateTime) {
+          this.usedDateSchemas.dateToStringSchema = true;
+          return "dateToStringSchema";
+        } else {
+          this.usedDateSchemas.dayToStringSchema = true;
+          return "dayToStringSchema";
+        }
+      }
+      if (isDateTime) {
+        this.usedDateSchemas.stringToDateSchema = true;
+        return "stringToDateSchema";
+      } else {
+        this.usedDateSchemas.stringToDaySchema = true;
+        return "stringToDaySchema";
+      }
+    }
+    let zod = "z.string()";
+    if (schema.format === "uuid") {
+      zod = "z.string().uuid()";
+    } else if (schema.format === "email") {
+      zod = "z.string().email()";
+    } else if (schema.format === "uri") {
+      zod = "z.string().url()";
+    }
+    if (schema.minLength !== void 0) {
+      zod = `${zod}.min(${schema.minLength})`;
+    }
+    if (schema.maxLength !== void 0) {
+      zod = `${zod}.max(${schema.maxLength})`;
+    }
+    if (schema.pattern && !schema.format) {
+      zod = `${zod}.regex(/${schema.pattern}/)`;
+    }
+    return zod;
+  }
+  convertNumberSchema(schema, schemaName = null) {
+    const isInputSchema = schemaName && (schemaName.includes("Input") || schemaName.includes("Body") || schemaName.includes("Params") || schemaName === "InlineInput");
+    const baseType = isInputSchema ? "z.coerce.number()" : "z.number()";
+    let zod = schema.type === "integer" ? `${baseType}.int()` : baseType;
+    if (schema.minimum !== void 0) {
+      zod = `${zod}.min(${schema.minimum})`;
+    }
+    if (schema.maximum !== void 0) {
+      zod = `${zod}.max(${schema.maximum})`;
+    }
+    return zod;
+  }
+  convertArraySchema(schema, schemaName = null) {
+    const itemSchema = schema.items ? this.convertSchema(schema.items, schemaName) : "z.unknown()";
+    let zod = `z.array(${itemSchema})`;
+    if (schema.minItems !== void 0) {
+      zod = `${zod}.min(${schema.minItems})`;
+    }
+    if (schema.maxItems !== void 0) {
+      zod = `${zod}.max(${schema.maxItems})`;
+    }
+    return zod;
+  }
+  convertObjectSchema(schema, schemaName = null) {
+    if (!schema.properties || Object.keys(schema.properties).length === 0) {
+      if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+        const valueSchema = this.convertSchema(schema.additionalProperties, schemaName);
+        return `z.record(z.string(), ${valueSchema})`;
+      }
+      return "z.object({})";
+    }
+    const required = new Set(schema.required || []);
+    const properties = [];
+    for (const [propName, propSchema] of Object.entries(schema.properties)) {
+      const previousPropertyPath = this.currentPropertyPath;
+      this.currentPropertyPath = previousPropertyPath ? `${previousPropertyPath}.${propName}` : propName;
+      const propZod = this.convertSchema(propSchema, schemaName);
+      const isRequired = required.has(propName);
+      const finalProp = isRequired ? propZod : `${propZod}.optional()`;
+      properties.push(`  ${propName}: ${finalProp}`);
+      this.currentPropertyPath = previousPropertyPath;
+    }
+    let zod = `z.object({
+${properties.join(",\n")}
+})`;
+    if (schema.additionalProperties === false) {
+      zod = `${zod}.strict()`;
+    }
+    return zod;
+  }
+  convertEnumSchema(schema, schemaName = null) {
+    const values = schema.enum;
+    if (isBooleanLikeEnum(values)) {
+      return "z.boolean()";
+    }
+    const context = {
+      source: "schema",
+      schemaName: this.currentSchemaName || schemaName || void 0,
+      propertyPath: this.currentPropertyPath || void 0
+    };
+    const enumInfo = this.enumRegistry.register(values, context);
+    return enumInfo.schemaConstName;
+  }
+  extractDependencies(schema) {
+    const deps = /* @__PURE__ */ new Set();
+    if (!schema) return deps;
+    if (schema.$ref) {
+      const refName = schema.$ref.split("/").pop();
+      deps.add(refName);
+      return deps;
+    }
+    if (schema.anyOf) {
+      for (const s of schema.anyOf) {
+        for (const dep of this.extractDependencies(s)) {
+          deps.add(dep);
+        }
+      }
+    }
+    if (schema.oneOf) {
+      for (const s of schema.oneOf) {
+        for (const dep of this.extractDependencies(s)) {
+          deps.add(dep);
+        }
+      }
+    }
+    if (schema.allOf) {
+      for (const s of schema.allOf) {
+        for (const dep of this.extractDependencies(s)) {
+          deps.add(dep);
+        }
+      }
+    }
+    if (schema.items) {
+      for (const dep of this.extractDependencies(schema.items)) {
+        deps.add(dep);
+      }
+    }
+    if (schema.properties) {
+      for (const propSchema of Object.values(schema.properties)) {
+        for (const dep of this.extractDependencies(propSchema)) {
+          deps.add(dep);
+        }
+      }
+    }
+    if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+      for (const dep of this.extractDependencies(schema.additionalProperties)) {
+        deps.add(dep);
+      }
+    }
+    return deps;
+  }
+  topologicalSort(schemaNames) {
+    const visited = /* @__PURE__ */ new Set();
+    const result = [];
+    const visiting = /* @__PURE__ */ new Set();
+    const visit = (name) => {
+      if (visited.has(name)) return;
+      if (visiting.has(name)) return;
+      visiting.add(name);
+      const schema = this.schemas[name];
+      if (schema) {
+        const deps = this.extractDependencies(schema);
+        for (const dep of deps) {
+          if (schemaNames.includes(dep)) {
+            visit(dep);
+          }
+        }
+      }
+      visiting.delete(name);
+      visited.add(name);
+      result.push(name);
+    };
+    for (const name of schemaNames) {
+      visit(name);
+    }
+    return result;
+  }
+  generateSchemas(runtimePackage) {
+    const schemaOutput = [];
+    for (const name of Object.keys(this.schemas)) {
+      this.schemaOrder.push(name);
+    }
+    this.schemaOrder = this.topologicalSort(this.schemaOrder);
+    const usedNames = /* @__PURE__ */ new Set();
+    for (const name of this.schemaOrder) {
+      const schema = this.schemas[name];
+      this.currentSchemaName = name;
+      this.currentPropertyPath = null;
+      const zodSchema = this.convertSchema(schema, name, true);
+      this.currentSchemaName = null;
+      let cleanName = name;
+      if (cleanName.endsWith("SchemaInput")) {
+        cleanName = cleanName.replace("SchemaInput", "Input");
+      } else if (cleanName.endsWith("Schema")) {
+        cleanName = cleanName.replace("Schema", "");
+      }
+      const schemaConstName = camelCase(cleanName) + "Schema";
+      const typeName = pascalCase(cleanName);
+      if (usedNames.has(schemaConstName) || usedNames.has(typeName)) {
+        continue;
+      }
+      usedNames.add(schemaConstName);
+      usedNames.add(typeName);
+      schemaOutput.push(`export const ${schemaConstName} = ${zodSchema}.describe('${typeName}');`);
+      const isInputType = /(?:Body|Input|Params)$/.test(cleanName);
+      const inferType = isInputType ? "z.input" : "z.output";
+      schemaOutput.push(`export type ${typeName} = ${inferType}<typeof ${schemaConstName}>;`);
+      schemaOutput.push("");
+    }
+    this.enumRegistry.register(["desc", "asc"], {
+      source: "schema",
+      schemaName: "PaginationParams",
+      propertyPath: "ordering"
+    });
+    const orderingEnumInfo = this.enumRegistry.get(["desc", "asc"]);
+    schemaOutput.push("// Common pagination schemas");
+    schemaOutput.push(`export const paginationParamsSchema = z.object({
+  page: z.number().optional(),
+  limit: z.number().optional(),
+  orderBy: z.string().optional(),
+  ordering: ${orderingEnumInfo.schemaConstName}.optional(),
+}).describe('PaginationParams');`);
+    schemaOutput.push("export type PaginationParams = z.input<typeof paginationParamsSchema>;");
+    schemaOutput.push("");
+    schemaOutput.push(`export const paginationResponseSchema = z.object({
+  page: z.number(),
+  pages: z.number(),
+  limit: z.number(),
+  total: z.number(),
+}).describe('PaginationResponse');`);
+    schemaOutput.push("export type PaginationResponse = z.output<typeof paginationResponseSchema>;");
+    schemaOutput.push("");
+    if (this.inlineSchemas.size > 0) {
+      schemaOutput.push("// Inline request/response schemas");
+      for (const [schemaName, schemaInfo] of this.inlineSchemas) {
+        const { schema, isInput, typeName } = schemaInfo;
+        const contextName = isInput ? "InlineInput" : "InlineOutput";
+        const zodSchema = this.convertSchema(schema, contextName, true);
+        schemaOutput.push(`export const ${schemaName} = ${zodSchema}.describe('${typeName}');`);
+        const inferType = isInput ? "z.input" : "z.output";
+        schemaOutput.push(`export type ${typeName} = ${inferType}<typeof ${schemaName}>;`);
+        schemaOutput.push("");
+      }
+    }
+    const output = [];
+    output.push("import { z } from 'zod';");
+    const usedDateSchemasList = Object.entries(this.usedDateSchemas).filter(([_, used]) => used).map(([name]) => name);
+    if (usedDateSchemasList.length > 0) {
+      output.push(`import { ${usedDateSchemasList.join(", ")} } from '${runtimePackage}';`);
+    }
+    output.push("");
+    const enumExports = this.enumRegistry.generateEnumExports();
+    if (enumExports) {
+      output.push(enumExports);
+    }
+    output.push(...schemaOutput);
+    return output.join("\n");
+  }
+};
+
+// src/generator/file-writer.ts
+import fs from "fs";
+import path from "path";
+import prettier from "prettier";
+async function formatCode(code, filepath) {
+  try {
+    const options = await prettier.resolveConfig(filepath);
+    return prettier.format(code, { ...options, parser: "typescript" });
+  } catch (error) {
+    console.warn(`Warning: Could not format ${filepath}:`, error.message);
+    return code;
+  }
+}
+async function writeFile(filepath, content) {
+  const dir = path.dirname(filepath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const formatted = await formatCode(content, filepath);
+  fs.writeFileSync(filepath, formatted);
+  console.log(`Generated: ${filepath}`);
+}
+
+// src/generator/spec-loader.ts
+import fs2 from "fs";
+import path2 from "path";
+async function loadSpec(specPath) {
+  if (specPath.startsWith("http://") || specPath.startsWith("https://")) {
+    console.log(`Fetching OpenAPI spec from ${specPath}...`);
+    const response = await fetch(specPath);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch OpenAPI spec: ${response.statusText}`);
+    }
+    const spec2 = await response.json();
+    console.log(`OpenAPI spec version: ${spec2.openapi}`);
+    console.log(`API title: ${spec2.info.title}`);
+    return spec2;
+  }
+  const resolvedPath = path2.resolve(specPath);
+  console.log(`Reading OpenAPI spec from ${resolvedPath}...`);
+  if (!fs2.existsSync(resolvedPath)) {
+    throw new Error(`OpenAPI spec file not found: ${resolvedPath}`);
+  }
+  const content = fs2.readFileSync(resolvedPath, "utf-8");
+  let spec;
+  if (resolvedPath.endsWith(".yaml") || resolvedPath.endsWith(".yml")) {
+    throw new Error("YAML specs are not supported yet. Please use JSON format.");
+  } else {
+    spec = JSON.parse(content);
+  }
+  console.log(`OpenAPI spec version: ${spec.openapi}`);
+  console.log(`API title: ${spec.info.title}`);
+  return spec;
+}
+
+// src/generator/client-generator.ts
+async function generateClient(config, options = {}) {
+  const { name, output } = config;
+  const specUrl = options.specOverride || config.spec;
+  const shouldWrite = options.write !== false;
+  const runtimePackage = options.runtimePackage || "@moinax/orc";
+  validateOutputPath(output);
+  const outputDir = path3.join(output, "generated");
+  const clientClassName = `${name}Client`;
+  validateFileName(clientClassName, "client class name");
+  console.log(`
+${"=".repeat(60)}`);
+  console.log(`Generating ${clientClassName}...`);
+  console.log(`${"=".repeat(60)}`);
+  if (shouldWrite && fs3.existsSync(outputDir)) {
+    fs3.rmSync(outputDir, { recursive: true });
+    console.log(`
+Cleaned up ${outputDir}`);
+  }
+  const spec = await loadSpec(specUrl);
+  const enumRegistry = new EnumRegistry();
+  const resourceGenerator = new ResourceGenerator(spec.paths, spec.components?.schemas, clientClassName, {
+    stripPathPrefix: config.stripPathPrefix,
+    enumRegistry,
+    runtimePackage
+  });
+  console.log("\nGenerating resource classes...");
+  const { resources, tree, inlineSchemas } = resourceGenerator.generateAll();
+  console.log("\nGenerating Zod schemas...");
+  const zodGenerator = new ZodGenerator(spec.components?.schemas, enumRegistry);
+  zodGenerator.addInlineSchemas(inlineSchemas);
+  const schemasCode = zodGenerator.generateSchemas(runtimePackage);
+  const generatedFiles = [];
+  generatedFiles.push({
+    path: path3.join(outputDir, "schemas.ts"),
+    content: schemasCode
+  });
+  const resourceNames = [];
+  for (const [resourceName, code] of Object.entries(resources)) {
+    validateFileName(resourceName, "resource name");
+    generatedFiles.push({
+      path: path3.join(outputDir, "resources", `${resourceName}.resource.ts`),
+      content: code
+    });
+    resourceNames.push(resourceName);
+  }
+  const resourceIndexCode = resourceNames.map((resourceName) => `export { ${resourceName}Resource } from './${resourceName}.resource';`).join("\n");
+  generatedFiles.push({
+    path: path3.join(outputDir, "resources", "index.ts"),
+    content: resourceIndexCode
+  });
+  const resourceBaseCode = `import type ${clientClassName} from './${clientClassName}';
+import { Resource as BaseResource } from '${runtimePackage}';
+
+export class Resource extends BaseResource {
+  protected declare client: ${clientClassName};
+
+  constructor(client: ${clientClassName}) {
+    super(client);
+  }
+}
+`;
+  generatedFiles.push({
+    path: path3.join(outputDir, "Resource.ts"),
+    content: resourceBaseCode
+  });
+  const topLevelResources = [];
+  for (const [childName] of tree.children) {
+    const className = pascalCase(childName);
+    topLevelResources.push({
+      propertyName: singularize(camelCase(childName)),
+      className
+    });
+  }
+  console.log(`
+Generating ${clientClassName}...`);
+  const resourceImports = topLevelResources.map((r) => `${r.className}Resource`).join(",\n  ");
+  const resourceProperties = topLevelResources.map((r) => `public ${r.propertyName}: ${r.className}Resource;`).join("\n  ");
+  const resourceInstantiations = topLevelResources.map((r) => `this.${r.propertyName} = new ${r.className}Resource(this);`).join("\n    ");
+  const clientCode = `import { Client, ClientOptions } from '${runtimePackage}';
+
+import {
+  ${resourceImports},
+} from './resources';
+
+export default class ${clientClassName} extends Client {
+  ${resourceProperties}
+
+  constructor(baseUrl: string, options: ClientOptions = {}) {
+    super(baseUrl, options);
+    ${resourceInstantiations}
+  }
+}
+`;
+  generatedFiles.push({
+    path: path3.join(outputDir, `${clientClassName}.ts`),
+    content: clientCode
+  });
+  const mainIndexCode = `export { default as ${clientClassName} } from './${clientClassName}';
+export * from './schemas';
+export * from './resources';
+`;
+  generatedFiles.push({
+    path: path3.join(outputDir, "index.ts"),
+    content: mainIndexCode
+  });
+  if (shouldWrite) {
+    for (const file of generatedFiles) {
+      await writeFile(file.path, file.content);
+    }
+  }
+  console.log(`
+${clientClassName} generation complete!`);
+  return {
+    name,
+    resourceNames: topLevelResources.map((r) => r.className),
+    files: shouldWrite ? void 0 : generatedFiles
+  };
+}
+
+// src/cli/commands/generate.ts
+async function runGenerate(config, options) {
+  const runtimePackage = config.runtimePackage || "@moinax/orc";
+  let clients = config.clients;
+  if (options.client) {
+    clients = clients.filter((c) => c.name.toLowerCase() === options.client.toLowerCase());
+    if (clients.length === 0) {
+      console.error(`Error: Client "${options.client}" not found in configuration.`);
+      console.log("Available clients:", config.clients.map((c) => c.name).join(", "));
+      process.exit(1);
+    }
+  }
+  if (options.spec && !options.client) {
+    console.error("Error: --spec requires --client to be specified");
+    process.exit(1);
+  }
+  console.log("ORC - OpenAPI Rest Client Generator");
+  console.log("====================================");
+  console.log(`Generating ${clients.length} client(s): ${clients.map((c) => c.name).join(", ")}`);
+  if (options.spec) {
+    console.log(`Using custom spec: ${options.spec}`);
+  }
+  const results = [];
+  for (const clientConfig of clients) {
+    try {
+      const result = await generateClient(clientConfig, {
+        specOverride: options.spec,
+        runtimePackage
+      });
+      results.push(result);
+    } catch (error) {
+      console.error(`
+Error generating ${clientConfig.name}Client:`, error.message);
+      process.exit(1);
+    }
+  }
+  console.log("\n" + "=".repeat(60));
+  console.log("All clients generated successfully!");
+  console.log("=".repeat(60));
+  for (const result of results) {
+    console.log(`
+${result.name}Client resources: ${result.resourceNames.join(", ")}`);
+  }
+}
+
+// src/cli/commands/init.ts
+import fs4 from "fs";
+import path4 from "path";
+var CONFIG_TEMPLATE = `import { defineConfig } from '@moinax/orc/config';
+
+export default defineConfig({
+  clients: [
+    {
+      name: 'MyApi',
+      spec: 'https://api.example.com/openapi.json',
+      output: 'src/lib/api/my-api-client',
+    },
+  ],
+});
+`;
+async function runInit() {
+  const configPath = path4.join(process.cwd(), "orc.config.ts");
+  if (fs4.existsSync(configPath)) {
+    console.error(`Config file already exists: ${configPath}`);
+    process.exit(1);
+  }
+  fs4.writeFileSync(configPath, CONFIG_TEMPLATE);
+  console.log(`Created config file: ${configPath}`);
+  console.log("\nEdit the file to configure your API clients, then run:");
+  console.log("  orc generate");
+}
+
+// src/cli.ts
+var CONFIG_NAMES = ["orc.config.ts", "orc.config.js", "orc.config.mjs"];
+async function loadConfig() {
+  const cwd = process.cwd();
+  for (const configName of CONFIG_NAMES) {
+    const configPath = path5.join(cwd, configName);
+    if (fs5.existsSync(configPath)) {
+      console.log(`Using config: ${configPath}`);
+      const jiti = createJiti(cwd, { interopDefault: true });
+      const config = await jiti.import(configPath);
+      return config;
+    }
+  }
+  throw new Error(
+    `No config file found. Create one with 'orc init' or add one of: ${CONFIG_NAMES.join(", ")}`
+  );
+}
+var program = new Command();
+program.name("orc").description("ORC - OpenAPI Rest Client Generator").version("0.1.0");
+program.command("generate").description("Generate TypeScript API clients from OpenAPI specs").option("-c, --client <name>", "Generate a specific client only").option("-s, --spec <url>", "Override spec URL (requires --client)").action(async (options) => {
+  const config = await loadConfig();
+  await runGenerate(config, options);
+});
+program.command("init").description("Scaffold a new orc.config.ts file").action(async () => {
+  await runInit();
+});
+program.parse();
+//# sourceMappingURL=cli.js.map