react-query-lightbase-codegen 1.6.3 → 2.0.0

package/dist/config/loadConfig.d.ts

@@ -0,0 +1,2 @@
+import type { OpenAPIConfig } from "../types/config";
+export declare function loadConfig(configPath: string): Promise<OpenAPIConfig>;

package/dist/config/loadConfig.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+const promises_1 = require("node:fs/promises");
+async function loadConfig(configPath) {
+    try {
+        const configContent = await (0, promises_1.readFile)(configPath, "utf-8");
+        const config = JSON.parse(configContent);
+        // Validate required fields
+        if (!config.specSource) {
+            throw new Error("specSource is required in configuration");
+        }
+        if (!config.exportDir) {
+            throw new Error("exportDir is required in configuration");
+        }
+        return config;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to load configuration: ${error.message}`);
+        }
+        throw new Error("Failed to load configuration: Unknown error");
+    }
+}

package/dist/generator/clientGenerator.d.ts

@@ -0,0 +1,13 @@
+import type { OpenAPIV3 } from "openapi-types";
+import type { OpenAPIConfig } from "../types/config";
+export interface OperationInfo {
+    method: string;
+    path: string;
+    operationId: string;
+    summary?: string;
+    description?: string;
+    parameters?: OpenAPIV3.ParameterObject[];
+    requestBody?: OpenAPIV3.RequestBodyObject;
+    responses: OpenAPIV3.ResponsesObject;
+}
+export declare function generateApiClient(spec: OpenAPIV3.Document, config: OpenAPIConfig): string;

package/dist/generator/clientGenerator.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateApiClient = generateApiClient;
+const utils_1 = require("../utils");
+function resolveSchema(schema, spec) {
+    if (!schema)
+        return undefined;
+    if ("$ref" in schema) {
+        const index = schema.$ref.split("/").pop();
+        return spec.components?.schemas?.[index];
+    }
+    return schema;
+}
+function generateAxiosMethod(operation, spec) {
+    const { method, path, operationId, summary, description, parameters, requestBody, responses } = operation;
+    // Generate JSDoc
+    const jsDocLines = ["/**"];
+    if (summary)
+        jsDocLines.push(` * ${summary}`);
+    if (description)
+        jsDocLines.push(` * ${description}`);
+    // Add parameter descriptions
+    parameters?.forEach((param) => {
+        const desc = param.description ? ` - ${param.description}` : "";
+        jsDocLines.push(` * @param ${param.in === "path" ? "params." : param.in === "query" ? "query." : ""}${param.name}${desc}`);
+    });
+    if (requestBody && "description" in requestBody) {
+        jsDocLines.push(` * @param data - ${requestBody.description}`);
+    }
+    // Add return type description
+    const responseDetails = Object.entries(responses).find(([code]) => code.startsWith("2"));
+    if (responseDetails) {
+        const [code, response] = responseDetails;
+        const responseObj = response;
+        const desc = "description" in responseObj ? responseObj.description : "";
+        const contentType = responseObj.content?.["application/json"]?.schema;
+        const typeName = `${operationId}Response${code}`;
+        if (contentType) {
+            if (desc) {
+                jsDocLines.push(` * @returns ${desc}`);
+            }
+            jsDocLines.push(` * @see ${typeName}`);
+        }
+        else if (desc) {
+            jsDocLines.push(` * @returns ${desc}`);
+        }
+    }
+    jsDocLines.push(" */");
+    const urlParams = parameters?.filter((p) => p.in === "path") || [];
+    const queryParams = parameters?.filter((p) => p.in === "query") || [];
+    const isFormData = requestBody && "content" in requestBody && requestBody.content?.["multipart/form-data"];
+    const formDataSchema = isFormData
+        ? resolveSchema(requestBody.content["multipart/form-data"].schema, spec)
+        : undefined;
+    const requestBodySchema = requestBody?.content?.["application/json"]?.schema
+        ? resolveSchema(requestBody.content["application/json"].schema, spec)
+        : undefined;
+    // Build data type parts
+    const dataProps = [];
+    // Add path and query parameters
+    urlParams.forEach((p) => {
+        const safeName = (0, utils_1.sanitizePropertyName)(p.name);
+        dataProps.push(`${safeName}: ${getTypeFromParam(p)}`);
+    });
+    queryParams.forEach((p) => {
+        const safeName = (0, utils_1.sanitizePropertyName)(p.name);
+        dataProps.push(`${safeName}${p.required ? "" : "?"}: ${getTypeFromParam(p)}`);
+    });
+    // Add request body type if it exists
+    const hasData = (parameters && parameters.length > 0) || operation.requestBody;
+    let dataType = "undefined";
+    const namedType = (0, utils_1.pascalCase)(operationId);
+    if (hasData) {
+        if (requestBody && dataProps.length > 0) {
+            dataType = `T.${namedType}Request & { ${dataProps.join("; ")} }`;
+        }
+        else if (requestBody) {
+            dataType = `T.${namedType}Request`;
+        }
+        else if (dataProps.length > 0) {
+            dataType = `{ ${dataProps.join("; ")} }`;
+        }
+        else {
+            dataType = "Record<string, never>";
+        }
+    }
+    // Get response type from 2xx response
+    const successResponse = Object.entries(responses).find(([code]) => code.startsWith("2"));
+    const responseType = successResponse ? `T.${`${namedType}Response${successResponse[0]}`}` : "any";
+    const urlWithParams = urlParams.length > 0 ? path.replace(/{(\w+)}/g, "${data.$1}") : path;
+    const methodBody = [
+        "const apiClient = getApiClient();",
+        `const url = \`${urlWithParams}\`;`,
+        queryParams.length > 0
+            ? `const queryData = {
+				${queryParams.map((p) => `["${p.name}"]: data["${p.name}"]`).join(",\n				")}
+			};`
+            : "",
+        requestBodySchema?.properties
+            ? `const bodyData = {
+				${Object.entries(requestBodySchema.properties)
+                .map(([key]) => `${key}: data.${key}`)
+                .join(",\n				")}
+			};`
+            : "",
+        formDataSchema?.properties
+            ? `const formData = new FormData();
+			${Object.entries(formDataSchema.properties)
+                .map(([key, prop]) => {
+                const schemaProperty = prop;
+                const isBinary = schemaProperty.format === "binary";
+                return formDataSchema?.required?.includes(key)
+                    ? `formData.append("${key}", ${isBinary ? "" : "String("}${queryParams.length > 0 ? "bodyData" : "data"}.${key}${isBinary ? "" : ")"});`
+                    : `if (${queryParams.length > 0 ? "bodyData" : "data"}.${key} != null) {
+							formData.append("${key}", ${isBinary ? "" : "String("}${queryParams.length > 0 ? "bodyData" : "data"}.${key}${isBinary ? "" : ")"});
+						}`;
+            })
+                .join("\n			")}`
+            : "",
+        `return apiClient.${method.toLowerCase()}<${responseType}>(url, {
+			${queryParams.length > 0 ? "params: queryData," : ""}
+			${requestBody ? `data: ${isFormData ? "formData" : "bodyData"},` : ""}
+			${isFormData ? `config: { headers: { 'Content-Type': 'multipart/form-data', ...config.headers }, ...config },` : "...config"}
+		});`,
+    ]
+        .filter(Boolean)
+        .join("\n	");
+    return `
+	${jsDocLines.join("\n	")}
+	export function ${(0, utils_1.camelCase)(operationId)}(data${hasData ? `: ${dataType}` : "?: undefined"}, config?: AxiosRequestConfig): Promise<AxiosResponse<${responseType}>> {
+		${methodBody}
+	}`;
+}
+function getTypeFromParam(param) {
+    if ("schema" in param) {
+        const schema = param.schema;
+        switch (schema.type) {
+            case "string":
+                return "string";
+            case "integer":
+            case "number":
+                return "number";
+            case "boolean":
+                return "boolean";
+            case "array":
+                return "Array<any>"; // You might want to make this more specific
+            default:
+                return "any";
+        }
+    }
+    return "any";
+}
+function generateApiClient(spec, config) {
+    const operations = [];
+    const resolveParameters = (parameters) => {
+        return parameters.map((p) => {
+            if ("$ref" in p) {
+                const index = p.$ref.split("/").pop();
+                return spec.components?.schemas?.[index];
+            }
+            return p;
+        });
+    };
+    const resolveRequestBody = (requestBody) => {
+        if (!requestBody)
+            return undefined;
+        if ("$ref" in requestBody) {
+            const index = requestBody.$ref.split("/").pop();
+            return spec.components?.schemas?.[index];
+        }
+        return requestBody;
+    };
+    // Collect all operations
+    Object.entries(spec.paths || {}).forEach(([path, pathItem]) => {
+        if (!pathItem)
+            return;
+        ["get", "post", "put", "delete", "patch"].forEach((method) => {
+            const operation = pathItem[method];
+            if (!operation)
+                return;
+            operations.push({
+                method: method.toUpperCase(),
+                path,
+                operationId: `${method}${(0, utils_1.sanitizeTypeName)(operation.operationId || `${path.replace(/\W+/g, "_")}`)}`,
+                summary: operation.summary,
+                description: operation.description,
+                parameters: resolveParameters([...(pathItem.parameters || []), ...(operation.parameters || [])]),
+                requestBody: resolveRequestBody(operation.requestBody),
+                responses: operation.responses,
+            });
+        });
+    });
+    const title = (0, utils_1.specTitle)(spec);
+    return `import type { AxiosResponse, AxiosRequestConfig } from 'axios';
+import { getApiClient } from './apiClient';
+import type * as T from './${title}.schema';
+
+${operations.map((op) => generateAxiosMethod(op, spec)).join("\n\n")}`;
+}

package/dist/generator/instanceGenerator.d.ts

@@ -0,0 +1 @@
+export declare function generateInstance(): string;

package/dist/generator/instanceGenerator.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateInstance = generateInstance;
+function generateInstance() {
+    return `import type { AxiosInstance } from 'axios';
+
+let apiClient: AxiosInstance;
+
+export function setApiClient(instance: AxiosInstance): void {
+	apiClient = instance;
+}
+
+export function getApiClient(): AxiosInstance {
+	if (!apiClient) {
+		throw new Error('API client not configured. Call setApiClient with an axios instance first.');
+	}
+	return apiClient;
+}
+
+export { apiClient };`;
+}

package/dist/generator/reactQueryGenerator.d.ts

@@ -0,0 +1,2 @@
+import type { OpenAPIV3 } from "openapi-types";
+export declare function generateReactQuery(spec: OpenAPIV3.Document): string;

package/dist/generator/reactQueryGenerator.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateReactQuery = generateReactQuery;
+const utils_1 = require("../utils");
+function generateQueryOptions(operation, spec) {
+    const { operationId, parameters, requestBody } = operation;
+    const hasData = (parameters && parameters.length > 0) || operation.requestBody;
+    // Helper to get required fields from a schema
+    const getRequiredFields = (schema, context) => {
+        if ("$ref" in schema) {
+            const refType = schema.$ref.split("/").pop();
+            const refSchema = context.schemas[refType];
+            return refSchema?.required?.map((p) => `'${p}'`) || [];
+        }
+        return schema.required?.map((p) => `'${p}'`) || [];
+    };
+    // Get required parameter names from both parameters and request body
+    const requiredParams = [
+        ...(parameters?.filter((p) => p.required).map((p) => `'${p.name}'`) || []),
+        ...(requestBody && "content" in requestBody && requestBody.content?.["application/json"]?.schema
+            ? getRequiredFields(requestBody.content["application/json"].schema, {
+                schemas: spec.components?.schemas || {},
+            })
+            : []),
+        ...(requestBody && "content" in requestBody && requestBody.content?.["multipart/form-data"]?.schema
+            ? getRequiredFields(requestBody.content["multipart/form-data"].schema, {
+                schemas: spec.components?.schemas || {},
+            })
+            : []),
+    ];
+    const namedQuery = (0, utils_1.camelCase)(operationId);
+    return `
+export const ${namedQuery}QueryOptions = (
+  ${hasData ? `params: Partial<Parameters<typeof apiClient.${namedQuery}>[0]>, config?: Partial<Parameters<typeof apiClient.${namedQuery}>[1]>` : ""}
+) => {
+  const enabled = ${hasData ? `hasDefinedProps(params, ${requiredParams.join(", ")})` : "true"};
+  return queryOptions({
+    queryKey: ['${(0, utils_1.camelCase)(operationId)}', ${hasData ? "params" : "undefined"}],
+    queryFn: enabled ? async () => {
+      const response = await apiClient.${namedQuery}(${hasData ? "params" : "undefined"}, config);
+      return response.data;
+    } : skipToken,
+  });
+};`;
+}
+function generateReactQuery(spec) {
+    const operations = [];
+    // Collect operations (same as in clientGenerator)
+    Object.entries(spec.paths || {}).forEach(([path, pathItem]) => {
+        if (!pathItem)
+            return;
+        ["get", "post", "put", "delete", "patch"].forEach((method) => {
+            const operation = pathItem[method];
+            if (!operation)
+                return;
+            operations.push({
+                method: method.toUpperCase(),
+                path,
+                operationId: `${method}${(0, utils_1.sanitizeTypeName)(operation.operationId || `${path.replace(/\W+/g, "_")}`)}`,
+                summary: operation.summary,
+                description: operation.description,
+                parameters: [
+                    ...(pathItem.parameters || []),
+                    ...(operation.parameters || []),
+                ],
+                requestBody: operation.requestBody,
+                responses: operation.responses,
+            });
+        });
+    });
+    return `import { queryOptions, skipToken } from '@tanstack/react-query';
+	import * as apiClient from './${(0, utils_1.specTitle)(spec)}.client';
+const hasDefinedProps = <T extends { [P in K]?: any }, K extends PropertyKey>(
+  obj: T,
+  ...keys: K[]
+): obj is T & { [P in K]-?: Exclude<T[P], undefined> } => {
+  return keys.every((k) => obj[k] !== undefined);
+};
+
+${operations.map((op) => generateQueryOptions(op, spec)).join("\n\n")}
+`;
+}

package/dist/generator/schemaGenerator.d.ts

@@ -0,0 +1,5 @@
+import type { OpenAPIV3 } from "openapi-types";
+/**
+ * Generates TypeScript interface definitions from OpenAPI schemas
+ */
+export declare function generateTypeDefinitions(spec: OpenAPIV3.Document): string;

package/dist/generator/schemaGenerator.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypeDefinitions = generateTypeDefinitions;
+const utils_1 = require("../utils");
+/**
+ * Converts OpenAPI schema type to TypeScript type
+ */
+function getTypeFromSchema(schema, context) {
+    if (!schema)
+        return "any";
+    if ("$ref" in schema) {
+        const refType = schema.$ref.split("/").pop();
+        return (0, utils_1.sanitizeTypeName)(refType);
+    }
+    // Handle enum types properly
+    if (schema.enum) {
+        return schema.enum.map((e) => (typeof e === "string" ? `'${e}'` : e)).join(" | ");
+    }
+    switch (schema.type) {
+        case "string":
+            return "string";
+        case "number":
+        case "integer":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "array": {
+            const itemType = getTypeFromSchema(schema.items, context);
+            return `Array<${itemType}>`;
+        }
+        case "object":
+            if (schema.properties) {
+                const properties = Object.entries(schema.properties)
+                    .map(([key, prop]) => {
+                    const isRequired = schema.required?.includes(key);
+                    const propertyType = getTypeFromSchema(prop, context);
+                    const safeName = (0, utils_1.sanitizePropertyName)(key);
+                    return `  ${safeName}${isRequired ? "" : "?"}: ${propertyType};`;
+                })
+                    .join("\n");
+                return `{\n${properties}\n}`;
+            }
+            if (schema.additionalProperties) {
+                const valueType = typeof schema.additionalProperties === "boolean"
+                    ? "any"
+                    : getTypeFromSchema(schema.additionalProperties, context);
+                return `Record<string, ${valueType}>`;
+            }
+            return "Record<string, any>";
+        default:
+            return "any";
+    }
+}
+function generateTypeDefinition(badName, schema, context) {
+    const description = !("$ref" in schema) && schema.description ? `/**\n * ${schema.description}\n */\n` : "";
+    const name = (0, utils_1.sanitizeTypeName)(badName);
+    const typeValue = getTypeFromSchema(schema, context);
+    // Use 'type' for primitives, unions, and simple types
+    // Use 'interface' only for complex objects with properties
+    const isInterface = !("$ref" in schema) && schema.type === "object" && schema.properties;
+    const namedInterface = (0, utils_1.pascalCase)(name);
+    return isInterface
+        ? `${description}export interface ${name} ${typeValue}\n\n`
+        : `${description}export type ${namedInterface} = ${typeValue}\n\n`;
+}
+/**
+ * Generates TypeScript interface definitions from OpenAPI schemas
+ */
+function generateTypeDefinitions(spec) {
+    const context = {
+        schemas: spec.components?.schemas || {},
+        generatedTypes: new Set(),
+    };
+    let output = "/* Generated TypeScript Definitions */\n\n";
+    // Generate types for all schema definitions
+    for (const [name, schema] of Object.entries(context.schemas)) {
+        if (context.generatedTypes.has(name))
+            continue;
+        output += generateTypeDefinition(name, schema, context);
+        context.generatedTypes.add(name);
+    }
+    // Generate request/response types
+    if (spec.paths) {
+        for (const [path, pathItem] of Object.entries(spec.paths)) {
+            for (const [method, operation] of Object.entries(pathItem)) {
+                if (method === "$ref")
+                    continue;
+                const operationObject = operation;
+                if (!operationObject)
+                    continue;
+                // Generate request body type
+                if (operationObject.requestBody) {
+                    const content = operationObject.requestBody.content;
+                    const jsonContent = content["application/json"] || content["multipart/form-data"];
+                    if (jsonContent?.schema) {
+                        const typeName = (0, utils_1.sanitizeTypeName)(`${operationObject.operationId}Request`);
+                        output += generateTypeDefinition(typeName, jsonContent.schema, context);
+                    }
+                }
+                // Generate response types
+                if (operationObject.responses) {
+                    for (const [code, response] of Object.entries(operationObject.responses)) {
+                        const responseObj = response;
+                        const content = responseObj.content?.["application/json"];
+                        if (content?.schema) {
+                            const opName = `${method}${(0, utils_1.sanitizeTypeName)(operationObject.operationId || `${path.replace(/\W+/g, "_")}`)}`;
+                            const typeName = (0, utils_1.sanitizeTypeName)(`${opName}_Response${code}`);
+                            output += generateTypeDefinition(typeName, content.schema, context);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return output;
+}

package/dist/index.d.ts

@@ -1,3 +1,5 @@
-import { convertSwaggerFile } from './convertSwaggerFile.js';
-import { importSpecs } from './importSpecs.js';
-export { importSpecs, convertSwaggerFile };
+import type { OpenAPIConfig } from "./types/config";
+/**
+ * Main function to generate the API client
+ */
+export declare function codegenerate(config: OpenAPIConfig): Promise<void>;

package/dist/index.js

@@ -1,4 +1,106 @@
-import { convertSwaggerFile } from './convertSwaggerFile.js';
-import { importSpecs } from './importSpecs.js';
-export { importSpecs, convertSwaggerFile };
-//# sourceMappingURL=index.js.map
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codegenerate = codegenerate;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const axios_1 = __importDefault(require("axios"));
+const yaml = __importStar(require("yaml"));
+const clientGenerator_1 = require("./generator/clientGenerator");
+const instanceGenerator_1 = require("./generator/instanceGenerator");
+const reactQueryGenerator_1 = require("./generator/reactQueryGenerator");
+const schemaGenerator_1 = require("./generator/schemaGenerator");
+const utils_1 = require("./utils");
+/**
+ * Loads the OpenAPI specification from either a URL or local file
+ */
+async function loadOpenAPISpec(specSource) {
+    try {
+        if (specSource.startsWith("http")) {
+            const response = await axios_1.default.get(specSource);
+            // Check if response is YAML by looking for common YAML indicators
+            const isYaml = typeof response.data === "string" &&
+                (response.data.trim().startsWith("openapi:") || response.data.trim().startsWith("swagger:"));
+            return isYaml ? yaml.parse(response.data) : response.data;
+        }
+        const content = await (0, promises_1.readFile)(specSource, "utf-8");
+        // Handle both JSON and YAML formats
+        return specSource.endsWith(".json") ? JSON.parse(content) : yaml.parse(content);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to load OpenAPI spec: ${error.message}`);
+        }
+        throw new Error("Failed to load OpenAPI spec: Unknown error");
+    }
+}
+/**
+ * Main function to generate the API client
+ */
+async function codegenerate(config) {
+    try {
+        // Load specs
+        const specs = Array.isArray(config.specSource)
+            ? await Promise.all(config.specSource.map(loadOpenAPISpec))
+            : [await loadOpenAPISpec(config.specSource)];
+        // Create export directory if it doesn't exist
+        await (0, promises_1.mkdir)(config.exportDir, { recursive: true });
+        // Generate and write type definitions
+        const instance = (0, instanceGenerator_1.generateInstance)();
+        await (0, promises_1.writeFile)((0, node_path_1.resolve)(config.exportDir, "apiClient.ts"), instance, "utf-8");
+        // Generate for each spec...
+        for (const spec of specs) {
+            const title = (0, utils_1.specTitle)(spec);
+            // Generate and write type definitions
+            const typeDefinitions = (0, schemaGenerator_1.generateTypeDefinitions)(spec);
+            await (0, promises_1.writeFile)((0, node_path_1.resolve)(config.exportDir, `${title}.schema.ts`), typeDefinitions, "utf-8");
+            // Generate and write API client
+            const clientCode = (0, clientGenerator_1.generateApiClient)(spec, config);
+            await (0, promises_1.writeFile)((0, node_path_1.resolve)(config.exportDir, `${title}.client.ts`), clientCode, "utf-8");
+            // Generate and write React Query options
+            const queryCode = (0, reactQueryGenerator_1.generateReactQuery)(spec);
+            await (0, promises_1.writeFile)((0, node_path_1.resolve)(config.exportDir, `${title}.queryOptions.ts`), queryCode, "utf-8");
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to generate API client: ${error.message}`);
+        }
+        throw new Error("Failed to generate API client: Unknown error");
+    }
+}

package/dist/types/config.d.ts

@@ -0,0 +1,11 @@
+export interface OpenAPIConfig {
+    /**
+     * OpenAPI specification source - can be a URL or local file path
+     * Supports JSON, YAML, or YML formats
+     */
+    specSource: string | string[];
+    /**
+     * Directory where generated files will be exported
+     */
+    exportDir: string;
+}

package/dist/types/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types.d.ts

@@ -0,0 +1,5 @@
+export interface Config {
+    input: string;
+    output: string;
+    axiosInstancePath: string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });