react-query-lightbase-codegen 2.3.0 → 2.3.2

package/dist/generator/clientGenerator.d.ts

@@ -1,5 +1,4 @@
 import type { OpenAPIV3 } from "openapi-types";
-import type { OpenAPIConfig } from "../types/config";
 export interface OperationInfo {
     method: string;
     path: string;
@@ -10,4 +9,4 @@ export interface OperationInfo {
     requestBody?: OpenAPIV3.RequestBodyObject;
     responses: OpenAPIV3.ResponsesObject;
 }
-export declare function generateApiClient(spec: OpenAPIV3.Document, config: OpenAPIConfig): string;
+export declare function generateApiClient(spec: OpenAPIV3.Document): string;

package/dist/generator/clientGenerator.js

@@ -65,11 +65,11 @@ function generateAxiosMethod(operation, spec) {
     // Add path and query parameters
     urlParams.forEach((p) => {
         const safeName = (0, utils_1.sanitizePropertyName)(p.name);
-        dataProps.push(`${safeName}: ${getTypeFromParam(p)}`);
+        dataProps.push(`${safeName}: ${(0, utils_1.getTypeFromSchema)(p.schema)}`);
     });
     queryParams.forEach((p) => {
         const safeName = (0, utils_1.sanitizePropertyName)(p.name);
-        dataProps.push(`${safeName}${p.required ? "" : "?"}: ${getTypeFromParam(p)}`);
+        dataProps.push(`${safeName}${p.required ? "" : "?"}: ${(0, utils_1.getTypeFromSchema)(p.schema)}`);
     });
     // Add request body type if it exists
     const hasData = (parameters && parameters.length > 0) || operation.requestBody;
@@ -134,35 +134,15 @@ function generateAxiosMethod(operation, spec) {
         .filter(Boolean)
         .join("\n	");
     const requestParms = hasData
-        ? `props: ${(0, utils_1.pascalCase)(operationId)}Params & { axiosConfig?: AxiosRequestConfig; }`
+        ? `props: T.${(0, utils_1.pascalCase)(operationId)}Params & { axiosConfig?: AxiosRequestConfig; }`
         : "props?: { axiosConfig?: AxiosRequestConfig }";
     return `
-	${hasData ? `export type ${(0, utils_1.pascalCase)(operationId)}Params = ${dataType};` : ""}
 	${jsDocLines.join("\n	")}
 	export async function ${(0, utils_1.camelCase)(operationId)}(${requestParms}): Promise<${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) {
+function generateApiClient(spec) {
     const operations = [];
     const resolveParameters = (parameters) => {
         return parameters.map((p) => {

package/dist/generator/schemaGenerator.js

@@ -2,62 +2,9 @@
 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);
-    }
-    const nullable = schema.nullable ? " | null" : "";
-    // Handle enum types properly
-    if (schema.enum) {
-        return schema.enum.map((e) => (typeof e === "string" ? `'${e}'` : e)).join(" | ") + nullable;
-    }
-    switch (schema.type) {
-        case "string":
-            if ("format" in schema && schema.format === "binary") {
-                return `string | { name?: string; type?: string; uri: string }${nullable}`;
-            }
-            return `string${nullable}`;
-        case "number":
-        case "integer":
-            return `number${nullable}`;
-        case "boolean":
-            return `boolean${nullable}`;
-        case "array": {
-            const itemType = getTypeFromSchema(schema.items, context);
-            return `Array<${itemType}>${nullable}`;
-        }
-        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 `{${properties}\n}${nullable}`;
-            }
-            if (schema.additionalProperties) {
-                const valueType = typeof schema.additionalProperties === "boolean"
-                    ? "any"
-                    : getTypeFromSchema(schema.additionalProperties, context);
-                return `Record<string, ${valueType}>${nullable}`;
-            }
-            return `Record<string, any>${nullable}`;
-        default:
-            return `any${nullable}`;
-    }
-}
-function generateTypeDefinition(name, schema, context) {
+function generateTypeDefinition(name, schema) {
     const description = !("$ref" in schema) && schema.description ? `/**\n * ${schema.description}\n */\n` : "";
-    const typeValue = getTypeFromSchema(schema, context);
+    const typeValue = (0, utils_1.getTypeFromSchema)(schema);
     // 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;
@@ -78,7 +25,7 @@ function generateTypeDefinitions(spec) {
     for (const [name, schema] of Object.entries(context.schemas)) {
         if (context.generatedTypes.has(name))
             continue;
-        output += generateTypeDefinition(name, schema, context);
+        output += generateTypeDefinition(name, schema);
         context.generatedTypes.add(name);
     }
     // Generate request/response types
@@ -90,32 +37,67 @@ function generateTypeDefinitions(spec) {
                 const operationObject = operation;
                 if (!operationObject)
                     continue;
-                const operationId = `${(0, utils_1.sanitizeTypeName)(operationObject.operationId || `${path.replace(/\W+/g, "_")}`)}`;
+                const { operationId: badOperationId, requestBody, responses, parameters } = operationObject;
+                const operationId = `${(0, utils_1.sanitizeTypeName)(badOperationId || `${path.replace(/\W+/g, "_")}`)}`;
                 // Generate request body type
-                if (operationObject.requestBody) {
-                    const content = operationObject.requestBody.content;
+                if (requestBody) {
+                    const content = requestBody.content;
                     const jsonContent = content["application/ld+json"] ??
                         content["application/json"] ??
                         content["multipart/form-data"] ??
                         content["application/octet-stream"];
                     if (jsonContent?.schema) {
                         const typeName = `${operationId}Request`;
-                        output += generateTypeDefinition(typeName, jsonContent.schema, context);
+                        output += generateTypeDefinition(typeName, jsonContent.schema);
                     }
                 }
                 // Generate response types
-                if (operationObject.responses) {
-                    for (const [code, response] of Object.entries(operationObject.responses)) {
+                if (responses) {
+                    for (const [code, response] of Object.entries(responses)) {
                         const responseObj = response;
                         const content = responseObj.content?.["application/ld+json"] ??
                             responseObj.content?.["application/json"] ??
                             responseObj.content?.["application/octet-stream"];
                         if (content?.schema) {
                             const typeName = `${operationId}Response${code}`;
-                            output += generateTypeDefinition(typeName, content.schema, context);
+                            output += generateTypeDefinition(typeName, content.schema);
                         }
                     }
                 }
+                // Build data type parts
+                const dataProps = [];
+                const urlParams = (parameters?.filter((p) => "in" in p && p.in === "path") ||
+                    []);
+                const queryParams = (parameters?.filter((p) => "in" in p && p.in === "query") ||
+                    []);
+                // Add path and query parameters
+                urlParams.forEach((p) => {
+                    const safeName = (0, utils_1.sanitizePropertyName)(p.name);
+                    dataProps.push(`${safeName}: ${(0, utils_1.getTypeFromSchema)(p.schema)}`);
+                });
+                queryParams.forEach((p) => {
+                    const safeName = (0, utils_1.sanitizePropertyName)(p.name);
+                    dataProps.push(`${safeName}${p.required ? "" : "?"}: ${(0, utils_1.getTypeFromSchema)(p.schema)}`);
+                });
+                // Add request body type if it exists
+                const hasData = (parameters && parameters.length > 0) || requestBody;
+                let dataType = "undefined";
+                const namedType = (0, utils_1.pascalCase)(operationId);
+                if (hasData) {
+                    if (requestBody && dataProps.length > 0) {
+                        dataType = `${namedType}Request & { ${dataProps.join("; ")} }`;
+                    }
+                    else if (requestBody) {
+                        dataType = `${namedType}Request`;
+                    }
+                    else if (dataProps.length > 0) {
+                        dataType = `{ ${dataProps.join("; ")} }`;
+                    }
+                    else {
+                        dataType = "Record<string, never>";
+                    }
+                    output += `\n\nexport type ${(0, utils_1.pascalCase)(operationId)}Params = ${dataType};\n\n`;
+                }
             }
         }
     }

package/dist/index.js

@@ -90,7 +90,7 @@ async function codegenerate(config) {
             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);
+            const clientCode = (0, clientGenerator_1.generateApiClient)(spec);
             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);

package/dist/utils.d.ts

@@ -33,3 +33,21 @@ export declare function sanitizePropertyName(name: string): string;
  */
 export declare function sanitizeTypeName(name: string): string;
 export declare function specTitle(spec: OpenAPIV3.Document): string;
+/**
+ * Converts an OpenAPI schema object into a TypeScript type string.
+ *
+ * Handles:
+ * - References ($ref) by extracting the type name
+ * - Nullable types by appending "| null"
+ * - Enums by creating union types of the values
+ * - Basic types (string, number, boolean)
+ * - Binary format strings as a union with file metadata object
+ * - Arrays by recursively getting the item type
+ * - Objects with properties by creating interfaces
+ * - Objects with additionalProperties as Records
+ * - Fallback to "any" for unknown types
+ *
+ * @param param - The OpenAPI schema/parameter object to convert
+ * @returns The TypeScript type as a string
+ */
+export declare function getTypeFromSchema(schema: OpenAPIV3.ParameterObject | OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject | undefined): string | undefined;

package/dist/utils.js

@@ -5,6 +5,7 @@ exports.pascalCase = pascalCase;
 exports.sanitizePropertyName = sanitizePropertyName;
 exports.sanitizeTypeName = sanitizeTypeName;
 exports.specTitle = specTitle;
+exports.getTypeFromSchema = getTypeFromSchema;
 function camelCase(str) {
     return str
         .replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase())
@@ -53,3 +54,87 @@ function sanitizeTypeName(name) {
 function specTitle(spec) {
     return camelCase(spec.info.title.toLowerCase().replace(/\s+/g, "-"));
 }
+/**
+ * Converts an OpenAPI schema object into a TypeScript type string.
+ *
+ * Handles:
+ * - References ($ref) by extracting the type name
+ * - Nullable types by appending "| null"
+ * - Enums by creating union types of the values
+ * - Basic types (string, number, boolean)
+ * - Binary format strings as a union with file metadata object
+ * - Arrays by recursively getting the item type
+ * - Objects with properties by creating interfaces
+ * - Objects with additionalProperties as Records
+ * - Fallback to "any" for unknown types
+ *
+ * @param param - The OpenAPI schema/parameter object to convert
+ * @returns The TypeScript type as a string
+ */
+function getTypeFromSchema(schema) {
+    if (!schema)
+        return undefined;
+    // Handle $ref by extracting the referenced type name
+    if ("$ref" in schema) {
+        const refType = schema.$ref.split("/").pop();
+        return sanitizeTypeName(refType);
+    }
+    // Add "| null" for nullable types
+    const nullable = "nullable" in schema && schema.nullable ? " | null" : "";
+    // Handle enums as union types
+    if ("enum" in schema && schema.enum) {
+        if (Object.values(schema.enum)?.length > 0) {
+            return (Object.values(schema.enum)
+                .map((e) => (typeof e === "string" ? `'${e}'` : e))
+                .join(" | ") + nullable);
+        }
+        return schema.enum.map((e) => (typeof e === "string" ? `'${e}'` : e)).join(" | ") + nullable;
+    }
+    // Handle types based on the "type" property
+    if ("type" in schema) {
+        switch (schema.type) {
+            case "string":
+                // Special case for binary format strings
+                if ("format" in schema && schema.format === "binary") {
+                    return `string | { name?: string; type?: string; uri: string }${nullable}`;
+                }
+                return `string${nullable}`;
+            case "number":
+            case "integer":
+                return `number${nullable}`;
+            case "boolean":
+                return `boolean${nullable}`;
+            case "array": {
+                // Recursively get the array item type
+                const itemType = getTypeFromSchema(schema.items);
+                return `Array<${itemType}>${nullable}`;
+            }
+            case "object":
+                // Handle objects with defined properties
+                if (schema.properties) {
+                    const properties = Object.entries(schema.properties)
+                        .map(([key, prop]) => {
+                        const isRequired = schema.required?.includes(key);
+                        const propertyType = getTypeFromSchema(prop);
+                        const safeName = sanitizePropertyName(key);
+                        return `  ${safeName}${isRequired ? "" : "?"}: ${propertyType};`;
+                    })
+                        .join("\n");
+                    return `{${properties}\n}${nullable}`;
+                }
+                // Handle objects with additionalProperties
+                if (schema.additionalProperties) {
+                    const valueType = typeof schema.additionalProperties === "boolean"
+                        ? "any"
+                        : getTypeFromSchema(schema.additionalProperties);
+                    return `Record<string, ${valueType}>${nullable}`;
+                }
+                // Default object type when no properties specified
+                return `Record<string, any>${nullable}`;
+            default:
+                return `any${nullable}`;
+        }
+    }
+    // Fallback for schemas without a type
+    return "any";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "react-query-lightbase-codegen",
-	"version": "2.3.0",
+	"version": "2.3.2",
 	"license": "MIT",
 	"description": "Generate Axios API clients and React Query options from OpenAPI specifications",
 	"exports": "./dist/index.js",

package/src/generator/clientGenerator.ts

@@ -1,6 +1,12 @@
 import type { OpenAPIV3 } from "openapi-types";
-import type { OpenAPIConfig } from "../types/config";
-import { camelCase, pascalCase, sanitizePropertyName, sanitizeTypeName, specTitle } from "../utils";
+import {
+	camelCase,
+	getTypeFromSchema,
+	pascalCase,
+	sanitizePropertyName,
+	sanitizeTypeName,
+	specTitle,
+} from "../utils";
 
 export interface OperationInfo {
 	method: string;
@@ -93,11 +99,11 @@ function generateAxiosMethod(operation: OperationInfo, spec: OpenAPIV3.Document)
 	// Add path and query parameters
 	urlParams.forEach((p) => {
 		const safeName = sanitizePropertyName(p.name);
-		dataProps.push(`${safeName}: ${getTypeFromParam(p)}`);
+		dataProps.push(`${safeName}: ${getTypeFromSchema(p.schema)}`);
 	});
 	queryParams.forEach((p) => {
 		const safeName = sanitizePropertyName(p.name);
-		dataProps.push(`${safeName}${p.required ? "" : "?"}: ${getTypeFromParam(p)}`);
+		dataProps.push(`${safeName}${p.required ? "" : "?"}: ${getTypeFromSchema(p.schema)}`);
 	});
 
 	// Add request body type if it exists
@@ -167,38 +173,17 @@ function generateAxiosMethod(operation: OperationInfo, spec: OpenAPIV3.Document)
 		.join("\n	");
 
 	const requestParms = hasData
-		? `props: ${pascalCase(operationId)}Params & { axiosConfig?: AxiosRequestConfig; }`
+		? `props: T.${pascalCase(operationId)}Params & { axiosConfig?: AxiosRequestConfig; }`
 		: "props?: { axiosConfig?: AxiosRequestConfig }";
 
 	return `
-	${hasData ? `export type ${pascalCase(operationId)}Params = ${dataType};` : ""}
 	${jsDocLines.join("\n	")}
 	export async function ${camelCase(operationId)}(${requestParms}): Promise<${responseType}> {
 		${methodBody}
 	}`;
 }
 
-function getTypeFromParam(param: OpenAPIV3.ParameterObject): string {
-	if ("schema" in param) {
-		const schema = param.schema as OpenAPIV3.SchemaObject;
-		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";
-}
-
-export function generateApiClient(spec: OpenAPIV3.Document, config: OpenAPIConfig): string {
+export function generateApiClient(spec: OpenAPIV3.Document): string {
 	const operations: OperationInfo[] = [];
 
 	const resolveParameters = (

package/src/generator/schemaGenerator.ts

@@ -1,79 +1,17 @@
 import type { OpenAPIV3 } from "openapi-types";
-import { sanitizePropertyName, sanitizeTypeName } from "../utils";
+import { getTypeFromSchema, pascalCase, sanitizePropertyName, sanitizeTypeName } from "../utils";
 
 interface SchemaContext {
 	schemas: { [key: string]: OpenAPIV3.SchemaObject };
 	generatedTypes: Set<string>;
 }
 
-/**
- * Converts OpenAPI schema type to TypeScript type
- */
-function getTypeFromSchema(
-	schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject,
-	context: SchemaContext
-): string {
-	if (!schema) return "any";
-
-	if ("$ref" in schema) {
-		const refType = schema.$ref.split("/").pop();
-		return sanitizeTypeName(refType as string);
-	}
-	const nullable = schema.nullable ? " | null" : "";
-
-	// Handle enum types properly
-	if (schema.enum) {
-		return schema.enum.map((e) => (typeof e === "string" ? `'${e}'` : e)).join(" | ") + nullable;
-	}
-
-	switch (schema.type) {
-		case "string":
-			if ("format" in schema && schema.format === "binary") {
-				return `string | { name?: string; type?: string; uri: string }${nullable}`;
-			}
-
-			return `string${nullable}`;
-		case "number":
-		case "integer":
-			return `number${nullable}`;
-		case "boolean":
-			return `boolean${nullable}`;
-		case "array": {
-			const itemType = getTypeFromSchema(schema.items, context);
-			return `Array<${itemType}>${nullable}`;
-		}
-		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 = sanitizePropertyName(key);
-						return `  ${safeName}${isRequired ? "" : "?"}: ${propertyType};`;
-					})
-					.join("\n");
-				return `{${properties}\n}${nullable}`;
-			}
-			if (schema.additionalProperties) {
-				const valueType =
-					typeof schema.additionalProperties === "boolean"
-						? "any"
-						: getTypeFromSchema(schema.additionalProperties, context);
-				return `Record<string, ${valueType}>${nullable}`;
-			}
-			return `Record<string, any>${nullable}`;
-		default:
-			return `any${nullable}`;
-	}
-}
-
 function generateTypeDefinition(
 	name: string,
-	schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject,
-	context: SchemaContext
+	schema: OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject
 ): string {
 	const description = !("$ref" in schema) && schema.description ? `/**\n * ${schema.description}\n */\n` : "";
-	const typeValue = getTypeFromSchema(schema, context);
+	const typeValue = getTypeFromSchema(schema);
 
 	// Use 'type' for primitives, unions, and simple types
 	// Use 'interface' only for complex objects with properties
@@ -98,7 +36,7 @@ export function generateTypeDefinitions(spec: OpenAPIV3.Document): string {
 	// 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);
+		output += generateTypeDefinition(name, schema);
 		context.generatedTypes.add(name);
 	}
 
@@ -110,11 +48,12 @@ export function generateTypeDefinitions(spec: OpenAPIV3.Document): string {
 
 				const operationObject = operation as OpenAPIV3.OperationObject;
 				if (!operationObject) continue;
-				const operationId = `${sanitizeTypeName(operationObject.operationId || `${path.replace(/\W+/g, "_")}`)}`;
+				const { operationId: badOperationId, requestBody, responses, parameters } = operationObject;
+				const operationId = `${sanitizeTypeName(badOperationId || `${path.replace(/\W+/g, "_")}`)}`;
 
 				// Generate request body type
-				if (operationObject.requestBody) {
-					const content = (operationObject.requestBody as OpenAPIV3.RequestBodyObject).content;
+				if (requestBody) {
+					const content = (requestBody as OpenAPIV3.RequestBodyObject).content;
 					const jsonContent =
 						content["application/ld+json"] ??
 						content["application/json"] ??
@@ -122,13 +61,13 @@ export function generateTypeDefinitions(spec: OpenAPIV3.Document): string {
 						content["application/octet-stream"];
 					if (jsonContent?.schema) {
 						const typeName = `${operationId}Request`;
-						output += generateTypeDefinition(typeName, jsonContent.schema as OpenAPIV3.SchemaObject, context);
+						output += generateTypeDefinition(typeName, jsonContent.schema as OpenAPIV3.SchemaObject);
 					}
 				}
 
 				// Generate response types
-				if (operationObject.responses) {
-					for (const [code, response] of Object.entries(operationObject.responses)) {
+				if (responses) {
+					for (const [code, response] of Object.entries(responses)) {
 						const responseObj = response as OpenAPIV3.ResponseObject;
 						const content =
 							responseObj.content?.["application/ld+json"] ??
@@ -136,10 +75,46 @@ export function generateTypeDefinitions(spec: OpenAPIV3.Document): string {
 							responseObj.content?.["application/octet-stream"];
 						if (content?.schema) {
 							const typeName = `${operationId}Response${code}`;
-							output += generateTypeDefinition(typeName, content.schema as OpenAPIV3.SchemaObject, context);
+							output += generateTypeDefinition(typeName, content.schema as OpenAPIV3.SchemaObject);
 						}
 					}
 				}
+
+				// Build data type parts
+				const dataProps: string[] = [];
+
+				const urlParams = (parameters?.filter((p) => "in" in p && p.in === "path") ||
+					[]) as OpenAPIV3.ParameterObject[];
+				const queryParams = (parameters?.filter((p) => "in" in p && p.in === "query") ||
+					[]) as OpenAPIV3.ParameterObject[];
+
+				// Add path and query parameters
+				urlParams.forEach((p) => {
+					const safeName = sanitizePropertyName(p.name);
+					dataProps.push(`${safeName}: ${getTypeFromSchema(p.schema)}`);
+				});
+				queryParams.forEach((p) => {
+					const safeName = sanitizePropertyName(p.name);
+					dataProps.push(`${safeName}${p.required ? "" : "?"}: ${getTypeFromSchema(p.schema)}`);
+				});
+
+				// Add request body type if it exists
+				const hasData = (parameters && parameters.length > 0) || requestBody;
+
+				let dataType = "undefined";
+				const namedType = pascalCase(operationId);
+				if (hasData) {
+					if (requestBody && dataProps.length > 0) {
+						dataType = `${namedType}Request & { ${dataProps.join("; ")} }`;
+					} else if (requestBody) {
+						dataType = `${namedType}Request`;
+					} else if (dataProps.length > 0) {
+						dataType = `{ ${dataProps.join("; ")} }`;
+					} else {
+						dataType = "Record<string, never>";
+					}
+					output += `\n\nexport type ${pascalCase(operationId)}Params = ${dataType};\n\n`;
+				}
 			}
 		}
 	}

package/src/index.ts

@@ -62,7 +62,7 @@ export async function codegenerate(config: OpenAPIConfig): Promise<void> {
 			await writeFile(resolve(config.exportDir, `${title}.schema.ts`), typeDefinitions, "utf-8");
 
 			// Generate and write API client
-			const clientCode = generateApiClient(spec, config);
+			const clientCode = generateApiClient(spec);
 			await writeFile(resolve(config.exportDir, `${title}.client.ts`), clientCode, "utf-8");
 
 			// Generate and write React Query options

package/src/utils.ts

@@ -52,3 +52,103 @@ export function sanitizeTypeName(name: string): string {
 export function specTitle(spec: OpenAPIV3.Document): string {
 	return camelCase(spec.info.title.toLowerCase().replace(/\s+/g, "-"));
 }
+
+/**
+ * Converts an OpenAPI schema object into a TypeScript type string.
+ *
+ * Handles:
+ * - References ($ref) by extracting the type name
+ * - Nullable types by appending "| null"
+ * - Enums by creating union types of the values
+ * - Basic types (string, number, boolean)
+ * - Binary format strings as a union with file metadata object
+ * - Arrays by recursively getting the item type
+ * - Objects with properties by creating interfaces
+ * - Objects with additionalProperties as Records
+ * - Fallback to "any" for unknown types
+ *
+ * @param param - The OpenAPI schema/parameter object to convert
+ * @returns The TypeScript type as a string
+ */
+export function getTypeFromSchema(
+	schema: OpenAPIV3.ParameterObject | OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject | undefined
+): string | undefined {
+	if (!schema) return undefined;
+	// Handle $ref by extracting the referenced type name
+	if ("$ref" in schema) {
+		const refType = schema.$ref.split("/").pop();
+		return sanitizeTypeName(refType as string);
+	}
+
+	// Add "| null" for nullable types
+	const nullable = "nullable" in schema && schema.nullable ? " | null" : "";
+
+	// Handle enums as union types
+	if ("enum" in schema && schema.enum) {
+		if (Object.values(schema.enum)?.length > 0) {
+			return (
+				Object.values(schema.enum)
+					.map((e) => (typeof e === "string" ? `'${e}'` : e))
+					.join(" | ") + nullable
+			);
+		}
+		return schema.enum.map((e) => (typeof e === "string" ? `'${e}'` : e)).join(" | ") + nullable;
+	}
+
+	// Handle types based on the "type" property
+	if ("type" in schema) {
+		switch (schema.type) {
+			case "string":
+				// Special case for binary format strings
+				if ("format" in schema && schema.format === "binary") {
+					return `string | { name?: string; type?: string; uri: string }${nullable}`;
+				}
+				return `string${nullable}`;
+
+			case "number":
+			case "integer":
+				return `number${nullable}`;
+
+			case "boolean":
+				return `boolean${nullable}`;
+
+			case "array": {
+				// Recursively get the array item type
+				const itemType = getTypeFromSchema(schema.items);
+				return `Array<${itemType}>${nullable}`;
+			}
+
+			case "object":
+				// Handle objects with defined properties
+				if (schema.properties) {
+					const properties = Object.entries(schema.properties)
+						.map(([key, prop]) => {
+							const isRequired = schema.required?.includes(key);
+							const propertyType = getTypeFromSchema(prop);
+							const safeName = sanitizePropertyName(key);
+							return `  ${safeName}${isRequired ? "" : "?"}: ${propertyType};`;
+						})
+						.join("\n");
+					return `{${properties}\n}${nullable}`;
+				}
+
+				// Handle objects with additionalProperties
+				if (schema.additionalProperties) {
+					const valueType =
+						typeof schema.additionalProperties === "boolean"
+							? "any"
+							: getTypeFromSchema(schema.additionalProperties);
+					return `Record<string, ${valueType}>${nullable}`;
+				}
+
+				// Default object type when no properties specified
+				return `Record<string, any>${nullable}`;
+
+			default:
+				return `any${nullable}`;
+		}
+	}
+
+	// Fallback for schemas without a type
+	return "any";
+}