@bagelink/sdk 0.0.1027 → 0.0.1033

package/dist/index.cjs

@@ -6,8 +6,8 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 
 const axios__default = /*#__PURE__*/_interopDefaultCompat(axios$1);
 
-const toCamelCase = (str) => str?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toLowerCase()) || str;
-const toPascalCase = (str) => str?.replaceAll(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toUpperCase()) || str;
+const toCamelCase = (str) => str?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toLowerCase()) || str || "";
+const toPascalCase = (str) => str?.replaceAll(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toUpperCase()) || str || "";
 function formatType(typeName) {
   typeName = typeName.replaceAll("-", "").replaceAll(/(post|put)$/gi, "").replaceAll(/^body_/gi, "");
   return toPascalCase(typeName);
@@ -122,15 +122,25 @@ function generateResponseType(responses) {
   return types.join(" | ");
 }
 function generateAxiosFunction(method, formattedPath, allParams, responseTypeStr, parameters, requestBodyPayload) {
-  let axiosFunction = `async (${allParams})${responseTypeStr} => axios.${method}(`;
-  const paramStr = parameters?.config?.params ? `, { params: {${parameters.config.params}} }` : "";
-  if (["get", "delete"].includes(method)) {
-    axiosFunction += `${formattedPath}${paramStr}`;
-  } else if (["post", "put", "patch", "delete"].includes(method)) {
+  if (allParams === "undefined")
+    allParams = "";
+  let axiosFunction = `async (${allParams})${responseTypeStr} => {`;
+  if (requestBodyPayload === "formData") {
+    const paramStr = parameters?.config?.params ? `params: {${parameters.config.params}}` : "";
+    axiosFunction += `
+		const formData = new FormData()
+		formData.append('upload', file)
+		return axios.${method}(${formattedPath}, formData, {
+			headers: { 'Content-Type': 'multipart/form-data' },
+			onUploadProgress: options?.onUploadProgress${paramStr ? `,
+            ${paramStr}` : ""}
+		})`;
+  } else {
+    const paramStr = parameters?.config?.params ? `, { params: {${parameters.config.params}} }` : "";
     const bodyVar = requestBodyPayload ? `${requestBodyPayload}` : "{}";
-    axiosFunction += `${formattedPath}, ${bodyVar}${paramStr}`;
+    axiosFunction += `return axios.${method}(${formattedPath}${["get", "delete"].includes(method) ? paramStr : `, ${bodyVar}${paramStr}`})`;
   }
-  axiosFunction += ")";
+  axiosFunction += "}";
   return axiosFunction;
 }
 const pathParamRegex = /\{([^}]+)\}/g;
@@ -144,14 +154,25 @@ function formatPathWithParams(path) {
   return formattedPath;
 }
 function generateRequestBody(requestBody) {
-  const bodySchema = requestBody?.content["application/json"]?.schema;
-  if (!bodySchema)
+  if (!requestBody?.content)
     return { requestBodyParam: "", requestBodyPayload: "" };
+  const { content } = requestBody;
+  const multipartFormData = content["multipart/form-data"] || {};
+  if (multipartFormData.schema?.$ref?.includes("Body_upload_files")) {
+    return {
+      requestBodyParam: "file: File, options?: UploadOptions & { dirPath?: string, tags?: string[] }",
+      requestBodyPayload: "formData"
+    };
+  }
+  const jsonContent = requestBody.content["application/json"];
+  if (!jsonContent || !jsonContent.schema) {
+    return { requestBodyParam: "", requestBodyPayload: "" };
+  }
+  const bodySchema = jsonContent.schema;
   const requestBodyType = schemaToType(bodySchema);
   collectTypeForImportStatement(requestBodyType);
   const requestBodyPayload = toCamelCase(bodySchema.title) || toCamelCase(requestBodyType) || "requestBody";
-  const defaultValue = requestBody.content["application/json"].schema?.default;
-  const requestBodyParam = formatVarType(requestBodyPayload, bodySchema, defaultValue);
+  const requestBodyParam = formatVarType(requestBodyPayload, bodySchema, bodySchema.default);
   return { requestBodyParam, requestBodyPayload };
 }
 function combineAllParams(parameters, requestBodyParam) {
@@ -163,44 +184,54 @@ function combineAllParams(parameters, requestBodyParam) {
   allParamsArray = allParamsArray.filter((p) => p).sort((a, b) => (a.includes("?") ? 1 : -1) - (b.includes("?") ? 1 : -1));
   return allParamsArray.join(", ");
 }
-function generateFunctionParameters(params) {
-  if (!params || params.length === 0)
+function generateFunctionParameters(params, isFileUpload = false) {
+  if (!params?.length)
     return {};
+  if (isFileUpload) {
+    return {
+      config: {
+        params: "dir_path: options?.dirPath, tags: options?.tags"
+      },
+      params: ""
+      // Empty string to ensure file is the first parameter
+    };
+  }
   const functionParams = [];
   const paramList = [];
   for (const param of params) {
     const paramType = schemaToType(param.schema);
     collectTypeForImportStatement(paramType);
     const paramName = param.name;
-    const varName = toCamelCase(param.name) || "param";
+    const varName = toCamelCase(param.name);
     if (param.in === "path" || param.in === "query" || param.in === "header") {
-      const defaultValue = param.schema.default;
-      const varType = formatVarType(varName, param.schema, param.required, defaultValue);
-      functionParams.push(varType);
+      functionParams.push(formatVarType(varName, param.schema, param.required, param.schema.default));
     }
     if (param.in === "query" || param.in === "header") {
-      if (paramName === varName)
-        paramList.push(paramName);
-      else
-        paramList.push(`'${paramName}': ${varName}`);
+      paramList.push(paramName === varName ? paramName : `'${paramName}': ${varName}`);
     }
   }
-  const paramsString = functionParams.join(", ");
-  const config = {};
-  if (paramList.length > 0)
-    config.params = paramList.join(", ");
-  return { params: paramsString, config };
+  return {
+    params: functionParams.join(", "),
+    config: paramList.length ? { params: paramList.join(", ") } : {}
+  };
 }
 function generateFunctionForOperation(method, path, operation) {
   if (!operation)
     return "";
-  const parameters = generateFunctionParameters(operation.parameters);
-  const responseType = generateResponseType(operation.responses);
-  const formattedPath = formatPathWithParams(path);
+  const isFileUpload = operation.requestBody?.content["multipart/form-data"]?.schema?.$ref?.includes("Body_upload_files");
+  const parameters = generateFunctionParameters(operation.parameters, isFileUpload);
   const { requestBodyParam, requestBodyPayload } = generateRequestBody(operation.requestBody);
-  const allParams = combineAllParams(parameters, requestBodyParam);
+  const allParams = isFileUpload ? "file: File, options?: UploadOptions & { dirPath?: string, tags?: string[] }" : combineAllParams(parameters, requestBodyParam);
+  const responseType = generateResponseType(operation.responses);
   const responseTypeStr = responseType ? `: Promise<AxiosResponse<${responseType}>>` : "";
-  return generateAxiosFunction(method, formattedPath, allParams, responseTypeStr, parameters, requestBodyPayload);
+  return generateAxiosFunction(
+    method,
+    formatPathWithParams(path),
+    allParams,
+    responseTypeStr,
+    parameters,
+    requestBodyPayload
+  );
 }
 const generateRandomString = () => Math.random().toString(36).slice(7);
 function fileTemplate(tsString, typeForImport, baseURL) {
@@ -208,6 +239,12 @@ function fileTemplate(tsString, typeForImport, baseURL) {
 		 import type { AxiosResponse } from 'axios';
 		 import type {${typeForImport.join(", ")}} from './types.d';
 		
+	interface UploadOptions {
+		onUploadProgress?: (progressEvent: any) => void
+		dirPath?: string
+		tags?: string[]
+	}
+	
 	export const axios = ax.create({baseURL:${baseURL}});
 	${tsString}`;
   const doubleQuoteRegex = /"([^"]+)":/g;
@@ -457,12 +494,14 @@ class BagelAuth {
   }
 }
 class Bagel {
-  constructor({ host, onError }) {
+  constructor({ host, fileBaseUrl, onError }) {
     __publicField(this, "host");
+    __publicField(this, "fileBaseUrl");
     __publicField(this, "onError");
     __publicField(this, "read_table");
     __publicField(this, "auth", new BagelAuth(this));
     this.host = host?.replace(/\/$/, "");
+    this.fileBaseUrl = fileBaseUrl?.replace(/\/$/, "");
     if (!this.host) {
       return this;
     }

package/dist/index.d.cts

@@ -71,8 +71,9 @@ declare class BagelAuth {
 }
 declare class Bagel {
     host?: string;
+    fileBaseUrl?: string;
     onError?: (err: any) => void;
-    constructor({ host, onError }: {
+    constructor({ host, fileBaseUrl, onError }: {
         [key: string]: any;
     });
     read_table: Tables | undefined;

package/dist/index.d.mts

@@ -71,8 +71,9 @@ declare class BagelAuth {
 }
 declare class Bagel {
     host?: string;
+    fileBaseUrl?: string;
     onError?: (err: any) => void;
-    constructor({ host, onError }: {
+    constructor({ host, fileBaseUrl, onError }: {
         [key: string]: any;
     });
     read_table: Tables | undefined;

package/dist/index.d.ts

@@ -71,8 +71,9 @@ declare class BagelAuth {
 }
 declare class Bagel {
     host?: string;
+    fileBaseUrl?: string;
     onError?: (err: any) => void;
-    constructor({ host, onError }: {
+    constructor({ host, fileBaseUrl, onError }: {
         [key: string]: any;
     });
     read_table: Tables | undefined;

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import axios$1 from 'axios';
 
-const toCamelCase = (str) => str?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toLowerCase()) || str;
-const toPascalCase = (str) => str?.replaceAll(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toUpperCase()) || str;
+const toCamelCase = (str) => str?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toLowerCase()) || str || "";
+const toPascalCase = (str) => str?.replaceAll(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toUpperCase()) || str || "";
 function formatType(typeName) {
   typeName = typeName.replaceAll("-", "").replaceAll(/(post|put)$/gi, "").replaceAll(/^body_/gi, "");
   return toPascalCase(typeName);
@@ -116,15 +116,25 @@ function generateResponseType(responses) {
   return types.join(" | ");
 }
 function generateAxiosFunction(method, formattedPath, allParams, responseTypeStr, parameters, requestBodyPayload) {
-  let axiosFunction = `async (${allParams})${responseTypeStr} => axios.${method}(`;
-  const paramStr = parameters?.config?.params ? `, { params: {${parameters.config.params}} }` : "";
-  if (["get", "delete"].includes(method)) {
-    axiosFunction += `${formattedPath}${paramStr}`;
-  } else if (["post", "put", "patch", "delete"].includes(method)) {
+  if (allParams === "undefined")
+    allParams = "";
+  let axiosFunction = `async (${allParams})${responseTypeStr} => {`;
+  if (requestBodyPayload === "formData") {
+    const paramStr = parameters?.config?.params ? `params: {${parameters.config.params}}` : "";
+    axiosFunction += `
+		const formData = new FormData()
+		formData.append('upload', file)
+		return axios.${method}(${formattedPath}, formData, {
+			headers: { 'Content-Type': 'multipart/form-data' },
+			onUploadProgress: options?.onUploadProgress${paramStr ? `,
+            ${paramStr}` : ""}
+		})`;
+  } else {
+    const paramStr = parameters?.config?.params ? `, { params: {${parameters.config.params}} }` : "";
     const bodyVar = requestBodyPayload ? `${requestBodyPayload}` : "{}";
-    axiosFunction += `${formattedPath}, ${bodyVar}${paramStr}`;
+    axiosFunction += `return axios.${method}(${formattedPath}${["get", "delete"].includes(method) ? paramStr : `, ${bodyVar}${paramStr}`})`;
   }
-  axiosFunction += ")";
+  axiosFunction += "}";
   return axiosFunction;
 }
 const pathParamRegex = /\{([^}]+)\}/g;
@@ -138,14 +148,25 @@ function formatPathWithParams(path) {
   return formattedPath;
 }
 function generateRequestBody(requestBody) {
-  const bodySchema = requestBody?.content["application/json"]?.schema;
-  if (!bodySchema)
+  if (!requestBody?.content)
     return { requestBodyParam: "", requestBodyPayload: "" };
+  const { content } = requestBody;
+  const multipartFormData = content["multipart/form-data"] || {};
+  if (multipartFormData.schema?.$ref?.includes("Body_upload_files")) {
+    return {
+      requestBodyParam: "file: File, options?: UploadOptions & { dirPath?: string, tags?: string[] }",
+      requestBodyPayload: "formData"
+    };
+  }
+  const jsonContent = requestBody.content["application/json"];
+  if (!jsonContent || !jsonContent.schema) {
+    return { requestBodyParam: "", requestBodyPayload: "" };
+  }
+  const bodySchema = jsonContent.schema;
   const requestBodyType = schemaToType(bodySchema);
   collectTypeForImportStatement(requestBodyType);
   const requestBodyPayload = toCamelCase(bodySchema.title) || toCamelCase(requestBodyType) || "requestBody";
-  const defaultValue = requestBody.content["application/json"].schema?.default;
-  const requestBodyParam = formatVarType(requestBodyPayload, bodySchema, defaultValue);
+  const requestBodyParam = formatVarType(requestBodyPayload, bodySchema, bodySchema.default);
   return { requestBodyParam, requestBodyPayload };
 }
 function combineAllParams(parameters, requestBodyParam) {
@@ -157,44 +178,54 @@ function combineAllParams(parameters, requestBodyParam) {
   allParamsArray = allParamsArray.filter((p) => p).sort((a, b) => (a.includes("?") ? 1 : -1) - (b.includes("?") ? 1 : -1));
   return allParamsArray.join(", ");
 }
-function generateFunctionParameters(params) {
-  if (!params || params.length === 0)
+function generateFunctionParameters(params, isFileUpload = false) {
+  if (!params?.length)
     return {};
+  if (isFileUpload) {
+    return {
+      config: {
+        params: "dir_path: options?.dirPath, tags: options?.tags"
+      },
+      params: ""
+      // Empty string to ensure file is the first parameter
+    };
+  }
   const functionParams = [];
   const paramList = [];
   for (const param of params) {
     const paramType = schemaToType(param.schema);
     collectTypeForImportStatement(paramType);
     const paramName = param.name;
-    const varName = toCamelCase(param.name) || "param";
+    const varName = toCamelCase(param.name);
     if (param.in === "path" || param.in === "query" || param.in === "header") {
-      const defaultValue = param.schema.default;
-      const varType = formatVarType(varName, param.schema, param.required, defaultValue);
-      functionParams.push(varType);
+      functionParams.push(formatVarType(varName, param.schema, param.required, param.schema.default));
     }
     if (param.in === "query" || param.in === "header") {
-      if (paramName === varName)
-        paramList.push(paramName);
-      else
-        paramList.push(`'${paramName}': ${varName}`);
+      paramList.push(paramName === varName ? paramName : `'${paramName}': ${varName}`);
     }
   }
-  const paramsString = functionParams.join(", ");
-  const config = {};
-  if (paramList.length > 0)
-    config.params = paramList.join(", ");
-  return { params: paramsString, config };
+  return {
+    params: functionParams.join(", "),
+    config: paramList.length ? { params: paramList.join(", ") } : {}
+  };
 }
 function generateFunctionForOperation(method, path, operation) {
   if (!operation)
     return "";
-  const parameters = generateFunctionParameters(operation.parameters);
-  const responseType = generateResponseType(operation.responses);
-  const formattedPath = formatPathWithParams(path);
+  const isFileUpload = operation.requestBody?.content["multipart/form-data"]?.schema?.$ref?.includes("Body_upload_files");
+  const parameters = generateFunctionParameters(operation.parameters, isFileUpload);
   const { requestBodyParam, requestBodyPayload } = generateRequestBody(operation.requestBody);
-  const allParams = combineAllParams(parameters, requestBodyParam);
+  const allParams = isFileUpload ? "file: File, options?: UploadOptions & { dirPath?: string, tags?: string[] }" : combineAllParams(parameters, requestBodyParam);
+  const responseType = generateResponseType(operation.responses);
   const responseTypeStr = responseType ? `: Promise<AxiosResponse<${responseType}>>` : "";
-  return generateAxiosFunction(method, formattedPath, allParams, responseTypeStr, parameters, requestBodyPayload);
+  return generateAxiosFunction(
+    method,
+    formatPathWithParams(path),
+    allParams,
+    responseTypeStr,
+    parameters,
+    requestBodyPayload
+  );
 }
 const generateRandomString = () => Math.random().toString(36).slice(7);
 function fileTemplate(tsString, typeForImport, baseURL) {
@@ -202,6 +233,12 @@ function fileTemplate(tsString, typeForImport, baseURL) {
 		 import type { AxiosResponse } from 'axios';
 		 import type {${typeForImport.join(", ")}} from './types.d';
 		
+	interface UploadOptions {
+		onUploadProgress?: (progressEvent: any) => void
+		dirPath?: string
+		tags?: string[]
+	}
+	
 	export const axios = ax.create({baseURL:${baseURL}});
 	${tsString}`;
   const doubleQuoteRegex = /"([^"]+)":/g;
@@ -451,12 +488,14 @@ class BagelAuth {
   }
 }
 class Bagel {
-  constructor({ host, onError }) {
+  constructor({ host, fileBaseUrl, onError }) {
     __publicField(this, "host");
+    __publicField(this, "fileBaseUrl");
     __publicField(this, "onError");
     __publicField(this, "read_table");
     __publicField(this, "auth", new BagelAuth(this));
     this.host = host?.replace(/\/$/, "");
+    this.fileBaseUrl = fileBaseUrl?.replace(/\/$/, "");
     if (!this.host) {
       return this;
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bagelink/sdk",
   "type": "module",
-  "version": "0.0.1027",
+  "version": "0.0.1033",
   "description": "Bagel core sdk packages",
   "author": {
     "name": "Neveh Allon",

package/src/index.ts

@@ -189,11 +189,13 @@ class BagelAuth {
 }
 export class Bagel {
 	host?: string
+	fileBaseUrl?: string
 
 	onError?: (err: any) => void
 
-	constructor({ host, onError }: { [key: string]: any }) {
+	constructor({ host, fileBaseUrl, onError }: { [key: string]: any }) {
 		this.host = host?.replace(/\/$/, '')
+		this.fileBaseUrl = fileBaseUrl?.replace(/\/$/, '')
 		if (!this.host) {
 			return this
 		}

package/src/openAPITools/functionGenerator.ts

@@ -75,17 +75,29 @@ function generateAxiosFunction(
 	parameters: any,
 	requestBodyPayload: string,
 ): string {
-	let axiosFunction = `async (${allParams})${responseTypeStr} => axios.${method}(`
-	const paramStr = parameters?.config?.params ? `, { params: {${parameters.config.params}} }` : ''
+	if (allParams === 'undefined') allParams = ''
 
-	if (['get', 'delete'].includes(method)) {
-		axiosFunction += `${formattedPath}${paramStr}`
-	} else if (['post', 'put', 'patch', 'delete'].includes(method)) {
-		const bodyVar = requestBodyPayload ? `${requestBodyPayload}` : '{}'
+	let axiosFunction = `async (${allParams})${responseTypeStr} => {`
+
+	if (requestBodyPayload === 'formData') {
+		const paramStr = parameters?.config?.params
+			? `params: {${parameters.config.params}}`
+			: ''
 
-		axiosFunction += `${formattedPath}, ${bodyVar}${paramStr}`
+		axiosFunction += `
+		const formData = new FormData()
+		formData.append('upload', file)
+		return axios.${method}(${formattedPath}, formData, {
+			headers: { 'Content-Type': 'multipart/form-data' },
+			onUploadProgress: options?.onUploadProgress${paramStr ? `,\n            ${paramStr}` : ''}
+		})`
+	} else {
+		const paramStr = parameters?.config?.params ? `, { params: {${parameters.config.params}} }` : ''
+		const bodyVar = requestBodyPayload ? `${requestBodyPayload}` : '{}'
+		axiosFunction += `return axios.${method}(${formattedPath}${['get', 'delete'].includes(method) ? paramStr : `, ${bodyVar}${paramStr}`})`
 	}
-	axiosFunction += ')'
+
+	axiosFunction += '}'
 	return axiosFunction
 }
 
@@ -103,13 +115,28 @@ function formatPathWithParams(path: string) {
 }
 
 function generateRequestBody(requestBody?: RequestBodyObject): { [key: string]: string } {
-	const bodySchema = requestBody?.content['application/json']?.schema
-	if (!bodySchema) return { requestBodyParam: '', requestBodyPayload: '' }
+	if (!requestBody?.content) return { requestBodyParam: '', requestBodyPayload: '' }
+
+	const { content } = requestBody
+	const multipartFormData = content['multipart/form-data'] || {}
+	if (multipartFormData.schema?.$ref?.includes('Body_upload_files')) {
+		return {
+			requestBodyParam: 'file: File, options?: UploadOptions & { dirPath?: string, tags?: string[] }',
+			requestBodyPayload: 'formData'
+		}
+	}
+
+	// Handle regular JSON requests
+	const jsonContent = requestBody.content['application/json']
+	if (!jsonContent || !jsonContent.schema) {
+		return { requestBodyParam: '', requestBodyPayload: '' }
+	}
+
+	const bodySchema = jsonContent.schema
 	const requestBodyType = schemaToType(bodySchema)
 	collectTypeForImportStatement(requestBodyType)
 	const requestBodyPayload = toCamelCase(bodySchema.title) || toCamelCase(requestBodyType) || 'requestBody'
-	const defaultValue = requestBody.content['application/json'].schema?.default
-	const requestBodyParam = formatVarType(requestBodyPayload, bodySchema, defaultValue)
+	const requestBodyParam = formatVarType(requestBodyPayload, bodySchema, bodySchema.default)
 	return { requestBodyParam, requestBodyPayload }
 }
 
@@ -131,8 +158,19 @@ function combineAllParams(parameters: { params?: string }, requestBodyParam: str
 	return allParamsArray.join(', ')
 }
 
-function generateFunctionParameters(params?: ParameterObject[]) {
-	if (!params || params.length === 0) return {}
+function generateFunctionParameters(params?: ParameterObject[], isFileUpload = false) {
+	if (!params?.length) return {}
+
+	// For file uploads, we want to handle query parameters differently
+	if (isFileUpload) {
+		// Don't include these as function parameters, they'll be part of options
+		return {
+			config: {
+				params: 'dir_path: options?.dirPath, tags: options?.tags'
+			},
+			params: '' // Empty string to ensure file is the first parameter
+		}
+	}
 
 	const functionParams: string[] = []
 	const paramList: string[] = []
@@ -141,34 +179,47 @@ function generateFunctionParameters(params?: ParameterObject[]) {
 		const paramType = schemaToType(param.schema)
 		collectTypeForImportStatement(paramType)
 		const paramName = param.name
-		const varName = toCamelCase(param.name) || 'param'
+		const varName = toCamelCase(param.name)
+
 		if (param.in === 'path' || param.in === 'query' || param.in === 'header') {
-			const defaultValue = param.schema.default
-			const varType = formatVarType(varName, param.schema, param.required, defaultValue)
-			functionParams.push(varType)
+			functionParams.push(formatVarType(varName, param.schema, param.required, param.schema.default))
 		}
+
 		if (param.in === 'query' || param.in === 'header') {
-			if (paramName === varName) paramList.push(paramName)
-			else paramList.push(`'${paramName}': ${varName}`)
+			paramList.push(paramName === varName ? paramName : `'${paramName}': ${varName}`)
 		}
 	}
 
-	const paramsString = functionParams.join(', ')
-	const config: { params?: string } = {}
-
-	if (paramList.length > 0) config.params = paramList.join(', ')
-	return { params: paramsString, config }
+	return {
+		params: functionParams.join(', '),
+		config: paramList.length ? { params: paramList.join(', ') } : {}
+	}
 }
 
 function generateFunctionForOperation(method: string, path: string, operation: OperationObject): string {
 	if (!operation) return ''
-	const parameters = generateFunctionParameters(operation.parameters)
-	const responseType = generateResponseType(operation.responses)
-	const formattedPath = formatPathWithParams(path)
+
+	// Check if this is a file upload operation by looking at the schema reference
+	const isFileUpload = operation.requestBody?.content['multipart/form-data']?.schema?.$ref?.includes('Body_upload_files')
+	const parameters = generateFunctionParameters(operation.parameters, isFileUpload)
 	const { requestBodyParam, requestBodyPayload } = generateRequestBody(operation.requestBody)
-	const allParams = combineAllParams(parameters, requestBodyParam)
+
+	// For file uploads, ignore the regular parameter generation
+	const allParams = isFileUpload
+		? 'file: File, options?: UploadOptions & { dirPath?: string, tags?: string[] }'
+		: combineAllParams(parameters, requestBodyParam)
+
+	const responseType = generateResponseType(operation.responses)
 	const responseTypeStr = responseType ? `: Promise<AxiosResponse<${responseType}>>` : ''
-	return generateAxiosFunction(method, formattedPath, allParams, responseTypeStr, parameters, requestBodyPayload)
+
+	return generateAxiosFunction(
+		method,
+		formatPathWithParams(path),
+		allParams,
+		responseTypeStr,
+		parameters,
+		requestBodyPayload
+	)
 }
 
 const generateRandomString = () => Math.random().toString(36).slice(7)
@@ -179,6 +230,12 @@ function fileTemplate(tsString: string, typeForImport: string[], baseURL: string
 		 import type { AxiosResponse } from 'axios';
 		 import type {${typeForImport.join(', ')}} from './types.d';
 		
+	interface UploadOptions {
+		onUploadProgress?: (progressEvent: any) => void
+		dirPath?: string
+		tags?: string[]
+	}
+	
 	export const axios = ax.create({baseURL:${baseURL}});
 	${tsString}`
 	)
@@ -186,8 +243,13 @@ function fileTemplate(tsString: string, typeForImport: string[], baseURL: string
 	return templateCode.replace(doubleQuoteRegex, '$1:')
 }
 
-const functionsInventory: { [key: string]: any } = {}
-const pathOperations: any[] = []
+interface PathOperation {
+	path: string
+	method: string
+}
+
+const functionsInventory: Record<string, string> = {}
+const pathOperations: PathOperation[] = []
 
 function hasConflict(path: string, method: string) {
 	const cleanPathName = path.split('/').filter(p => p && !(/\{|\}/).test(p)).join('/')

package/src/openAPITools/openApiTypes.ts

@@ -17,6 +17,9 @@ export interface PathItemObject {
 	put?: OperationObject
 	post?: OperationObject
 	delete?: OperationObject
+	patch?: OperationObject
+	options?: OperationObject
+	head?: OperationObject
 }
 
 export interface SchemasObject { [schema: string]: SchemaObject }
@@ -37,15 +40,17 @@ export interface ResponsesObject { [statusCode: string]: ResponseObject }
 
 export interface SchemaObject {
 	type?: string
+	format?: string
 	properties?: { [property: string]: SchemaObject }
 	items?: SchemaObject
 	$ref?: string
-	enum: string[]
+	enum?: string[]
 	anyOf?: SchemaObject[]
 	allOf?: SchemaObject[]
 	title?: string
 	description?: string
-	default: any
+	default?: any
+	required?: string[]
 }
 
 export interface ParameterObject {
@@ -58,6 +63,7 @@ export interface ParameterObject {
 export interface RequestBodyObject {
 	description?: string
 	content: { [mediaType: string]: MediaTypeObject }
+	required?: boolean
 }
 
 export interface ResponseObject {
@@ -67,4 +73,19 @@ export interface ResponseObject {
 
 export interface MediaTypeObject {
 	schema?: SchemaObject
+	encoding?: { [key: string]: EncodingObject }
+}
+
+export interface EncodingObject {
+	contentType?: string
+	headers?: { [key: string]: HeaderObject }
+	style?: string
+	explode?: boolean
+	allowReserved?: boolean
+}
+
+export interface HeaderObject {
+	description?: string
+	required?: boolean
+	schema?: SchemaObject
 }

package/src/openAPITools/utils.ts

@@ -1,7 +1,7 @@
 import type { SchemaObject } from './openApiTypes'
 
-export const toCamelCase = (str?: string) => str?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || '').replace(/^./, str => str.toLowerCase()) || str
-export const toPascalCase = (str?: string) => str?.replaceAll(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || '').replace(/^./, str => str.toUpperCase()) || str
+export const toCamelCase = (str?: string) => str?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || '').replace(/^./, str => str.toLowerCase()) || str || ''
+export const toPascalCase = (str?: string) => str?.replaceAll(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || '').replace(/^./, str => str.toUpperCase()) || str || ''
 
 export function formatType(typeName: string): string {
 	// eslint-disable-next-line regexp/no-unused-capturing-group