@accelbyte/codegen 1.0.0-alpha.3 → 1.0.0-alpha.6

package/dist/accelbyte-codegen.js

@@ -11,10 +11,7 @@ var _ = require('lodash');
 var fastJsonPatch = require('fast-json-patch');
 var https = require('https');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
+function _interopNamespaceDefault(e) {
   var n = Object.create(null);
   if (e) {
     Object.keys(e).forEach(function (k) {
@@ -22,25 +19,18 @@ function _interopNamespace(e) {
         var d = Object.getOwnPropertyDescriptor(e, k);
         Object.defineProperty(n, k, d.get ? d : {
           enumerable: true,
-          get: function () {
-            return e[k];
-          }
+          get: function () { return e[k]; }
         });
       }
     });
   }
-  n['default'] = e;
+  n.default = e;
   return Object.freeze(n);
 }
 
-var yargs__default = /*#__PURE__*/_interopDefaultLegacy(yargs);
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
-var SwaggerParser__default = /*#__PURE__*/_interopDefaultLegacy(SwaggerParser);
-var ___default = /*#__PURE__*/_interopDefaultLegacy(_);
-var https__namespace = /*#__PURE__*/_interopNamespace(https);
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+var https__namespace = /*#__PURE__*/_interopNamespaceDefault(https);
 
 const SwaggersConfig = zod.z.array(zod.z.array(zod.z.string()));
 class CliParser {
@@ -66,7 +56,7 @@ class CliParser {
     const configPath = CliParser.getConfigPath();
     if (!configPath)
       throw new Error("Missing config file");
-    const config = JSON.parse(fs__default['default'].readFileSync(configPath, "utf8"));
+    const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
     if (!SwaggersConfig.safeParse(config).success) {
       throw new Error("Wrong config file format");
     }
@@ -86,6 +76,86 @@ class CliParser {
   };
 }
 
+const Schema = zod.z.object({
+  $ref: zod.z.string().nullish(),
+  type: zod.z.union([
+    zod.z.literal("array"),
+    zod.z.literal("object"),
+    zod.z.literal("file"),
+    zod.z.literal("string"),
+    zod.z.literal("boolean")
+  ]).nullish(),
+  items: zod.z.object({
+    $ref: zod.z.string().nullish(),
+    type: zod.z.string().nullish()
+  }).nullish(),
+  properties: zod.z.array(zod.z.string()).nullish(),
+  description: zod.z.string().nullish(),
+  additionalProperties: zod.z.object({
+    type: zod.z.string().nullish()
+  }).nullish()
+});
+const Definition = zod.z.object({
+  required: zod.z.array(zod.z.string()).nullish(),
+  properties: zod.z.record(zod.z.object({
+    type: zod.z.string()
+  })).nullish()
+});
+const Definitions = zod.z.record(Definition);
+const EndpointParametersType = zod.z.enum(["apiKey", "boolean", "int", "integer", "number", "string", "array", "file"]);
+const EndpointParametersIn = zod.z.enum(["body", "formData", "header", "path", "query"]);
+const EndpointParameters = zod.z.object({
+  type: EndpointParametersType.nullish(),
+  description: zod.z.string().nullish(),
+  name: zod.z.string(),
+  in: EndpointParametersIn,
+  required: zod.z.boolean().nullish(),
+  schema: Schema.nullish(),
+  default: zod.z.union([zod.z.boolean(), zod.z.string(), zod.z.number()]).nullish(),
+  enum: zod.z.array(zod.z.union([zod.z.boolean(), zod.z.string(), zod.z.number()])).nullish(),
+  items: zod.z.object({
+    type: zod.z.string()
+  }).nullish()
+});
+const Endpoint = zod.z.object({
+  description: zod.z.string().nullish(),
+  consumes: zod.z.array(zod.z.string()).nullish(),
+  produces: zod.z.array(zod.z.string()).nullish(),
+  tags: zod.z.array(zod.z.string()).nullish(),
+  summary: zod.z.string().nullish(),
+  operationId: zod.z.string(),
+  deprecated: zod.z.boolean().nullish(),
+  responses: zod.z.record(zod.z.object({
+    description: zod.z.string().nullish(),
+    schema: Schema.nullish()
+  })),
+  parameters: zod.z.array(EndpointParameters).nullish()
+});
+const Operation = zod.z.object({
+  get: Endpoint.nullish(),
+  post: Endpoint.nullish(),
+  patch: Endpoint.nullish(),
+  delete: Endpoint.nullish(),
+  put: Endpoint.nullish()
+});
+const Paths = zod.z.record(Operation);
+zod.z.object({
+  paths: Paths,
+  definitions: Definitions,
+  basePath: zod.z.string(),
+  info: zod.z.object({
+    description: zod.z.string(),
+    title: zod.z.string(),
+    contact: zod.z.object({
+      name: zod.z.string(),
+      url: zod.z.string(),
+      email: zod.z.string()
+    }),
+    version: zod.z.string()
+  }),
+  schemes: zod.z.array(zod.z.string()).nullish()
+});
+
 const getImportableVarMap = () => ({
   "@accelbyte/sdk": ["CodeGenUtil", "SdkCache", "IResponse", "IResponseWithSync", "Validate"],
   axios: ["AxiosRequestConfig", "AxiosResponse"],
@@ -131,44 +201,30 @@ ${body}
 `.replace(/, \)/g, ")").trim();
 
 class ParserUtils {
-  static parseQueryParamAttributeDefault = (name, definition) => {
-    const attrName = name.slice(name.lastIndexOf(".") + 1);
+  static parseQueryParamAttributeDefault = (definition) => {
+    const attrName = definition.name.slice(definition.name.lastIndexOf(".") + 1);
     const defaultValue = definition.type === "string" ? `'${definition.default}'` : definition.default;
     return `${attrName}: ${defaultValue}`;
   };
-  static parseType = (type) => {
-    if (type === "integer")
+  static parseType = (pathParam) => {
+    if (pathParam.type === "int" || pathParam.type === "integer")
       return "number";
-    if (type === "array")
-      return "any[]";
-    return type;
+    if (pathParam.type === "array")
+      return `${pathParam.items.type ?? "any"}[]`;
+    return pathParam.type;
   };
   static parseQueryParamsType = (queryParams) => {
-    return queryParams.map((p) => ParserUtils.parseAttributeType(p.name, p)).join(",");
+    return queryParams.map((queryParam) => ParserUtils.parseAttributeType(queryParam)).join(",");
   };
   static isAnyQueryParamRequired = (queryParams) => {
-    queryParams.forEach((p) => {
-      if (p.required) {
-        return true;
-      }
-    });
-    return false;
+    return queryParams.some((queryParam) => queryParam.required);
   };
   static parseQueryParamsDefault = (queryParams) => {
-    const result = queryParams.filter((p) => !!p.default).map((p) => ParserUtils.parseQueryParamAttributeDefault(p.name, p)).join(",");
+    const result = queryParams.filter((queryParam) => !!queryParam.default && !queryParam.required).map(ParserUtils.parseQueryParamAttributeDefault).join(",");
     return result ? `${result},` : "";
   };
   static parseBodyParamsImports = (bodyParams) => {
-    const ret = bodyParams.map((p) => {
-      if (p?.schema?.$ref)
-        return ParserUtils.parseRefImport(p.schema.$ref, p);
-      if (p?.schema?.items?.$ref)
-        return ParserUtils.parseRefImport(p.schema.items.$ref, p);
-      if (p?.$ref)
-        return ParserUtils.parseRefImport(p.$ref, p);
-      return null;
-    }).filter((p) => !!p);
-    return ret;
+    return bodyParams.map(ParserUtils.parseRefImport).filter(Boolean);
   };
   static parseImportDir = ($ref) => {
     let ref = $ref.replace(".", "/");
@@ -181,7 +237,11 @@ class ParserUtils {
       return ref.slice(0, ref.lastIndexOf("/")).replace("#", ".");
     }
   };
-  static parseRefImport = ($ref, p) => {
+  static parseRefImport = (bodyParam) => {
+    const $ref = bodyParam?.schema?.$ref || bodyParam?.schema?.items?.$ref;
+    if (!$ref) {
+      return null;
+    }
     const type = ParserUtils.parseRefType($ref);
     return `import { ${type} } from './definitions/${type}'`;
   };
@@ -191,16 +251,16 @@ class ParserUtils {
       ref = ref.slice(0, -1);
     }
     const val = ref.slice(ref.lastIndexOf("/") + 1);
-    return ___default['default'].upperFirst(___default['default'].camelCase(val));
+    return _.upperFirst(_.camelCase(val)).replace(/( \w)/g, (group) => group.replace(" ", "").toUpperCase());
   };
-  static parseAttributeType = (name, definition) => {
+  static parseAttributeType = (definition) => {
     const required = definition.required ? "" : "?";
-    const attrName = name.slice(name.lastIndexOf(".") + 1);
-    if (definition.enums) {
-      const enums = definition.enums.map((enm) => definition.type === "string" ? `'${enm}'` : enm).join(" | ");
+    const attrName = definition.name.slice(definition.name.lastIndexOf(".") + 1);
+    if (definition.enum) {
+      const enums = definition.enum.map((enm) => definition.type === "string" ? `'${enm}'` : enm).join(" | ");
       return `${attrName}${required}: ${enums}`;
     }
-    if (definition.type && definition.type === "integer") {
+    if (definition.type && ParserUtils.parseType(definition) === "number") {
       return `${attrName}${required}: number`;
     }
     if (definition.type && definition.type === "array") {
@@ -212,29 +272,29 @@ class ParserUtils {
     return `${attrName}${required}: any`;
   };
   static parseBodyParamsType = (bodyParams) => {
-    const [p] = bodyParams;
-    if (!p)
+    const [bodyParam] = bodyParams;
+    if (!bodyParam)
       return null;
-    if (bodyParams.length > 0 && p?.name !== "body" && !p?.schema) {
-      let retBodyParams = `{${bodyParams.map((p2) => ParserUtils.parseAttributeType(p2.name, p2)).join(",")}}`;
+    if (bodyParams.length > 0 && bodyParam?.name !== "body" && !bodyParam?.schema) {
+      let retBodyParams = `{${bodyParams.map((bodyParam2) => ParserUtils.parseAttributeType(bodyParam2)).join(",")}}`;
       retBodyParams = retBodyParams.replace("file?: file", "file?: File");
       return retBodyParams;
     }
-    if (p?.schema?.type === "array" && !p?.schema?.items?.$ref) {
-      return `${p.schema.items.type ?? "any"}[]`;
+    if (bodyParam?.schema?.type === "array" && !bodyParam?.schema?.items?.$ref) {
+      return `${bodyParam.schema.items.type ?? "any"}[]`;
     }
-    if (p?.schema?.type === "array" && p?.schema?.items?.$ref) {
-      return `${ParserUtils.parseRefType(p.schema.items.$ref)}[]`;
+    if (bodyParam?.schema?.type === "array" && bodyParam?.schema?.items?.$ref) {
+      return `${ParserUtils.parseRefType(bodyParam.schema.items.$ref)}[]`;
     }
-    if (p?.schema.$ref) {
-      return ParserUtils.parseRefType(p.schema.$ref);
+    if (bodyParam?.schema.$ref) {
+      return ParserUtils.parseRefType(bodyParam.schema.$ref);
     }
-    if (p?.schema?.additionalProperties?.type === "object") {
+    if (bodyParam?.schema?.additionalProperties?.type === "object") {
       return "any";
     }
     return null;
   };
-  static get2xxResponse(methodEntity, path2) {
+  static get2xxResponse(methodEntity) {
     const keys = Object.keys(methodEntity);
     let responseClass = null;
     keys.forEach((key) => {
@@ -259,31 +319,30 @@ class ParserUtils {
     }
     return contentTypes.includes("application/x-www-form-urlencoded");
   }
-  static getPathParams(parametersArray) {
-    if (!parametersArray) {
+  static filterPathParams(parameters) {
+    if (!parameters) {
       return [];
     }
-    const res = [];
-    for (const p of parametersArray) {
-      if (p.in === "path") {
-        res.push(p);
-      }
-    }
-    return res;
+    return parameters.filter((parameter) => parameter.in === "path");
   }
-  static generateClassMethod(path2, parametersArray, httpMethod, className) {
+  static generateClassMethod({
+    path: path2,
+    endpoint,
+    httpMethod,
+    className
+  }) {
     let replacedIdsPath = path2;
-    if (parametersArray) {
-      for (const p of parametersArray) {
-        if (p.in === "path") {
-          replacedIdsPath = replacedIdsPath.replace("{" + p.name + "}", "By" + ParserUtils.toTitleCaseWord(p.name));
+    if (endpoint.parameters) {
+      for (const parameter of endpoint.parameters) {
+        if (parameter.in === "path") {
+          replacedIdsPath = replacedIdsPath.replace("{" + parameter.name + "}", "By" + ParserUtils.toTitleCaseWord(parameter.name));
           replacedIdsPath = replacedIdsPath.replace("/iam", "");
           replacedIdsPath = replacedIdsPath.replace("/odin-config", "");
         }
       }
     }
     let classMethod = httpMethod + "/" + replacedIdsPath;
-    classMethod = ___default['default'].camelCase(classMethod);
+    classMethod = _.camelCase(classMethod);
     classMethod = classMethod.replace("PublicNamespacesByNamespace", "");
     classMethod = classMethod.replace("AdminNamespacesByNamespace", "Admin");
     const searchWord = "NamespacesByNamespace";
@@ -294,45 +353,38 @@ class ParserUtils {
     }
     return classMethod;
   }
-  static getBodyParams(parametersArray) {
-    if (!parametersArray)
-      return [];
-    if (!___default['default'].isArray(parametersArray) && parametersArray)
-      return [parametersArray].filter((p) => p.in === "body" || p.in === "formData");
-    return parametersArray.filter((p) => p.in === "body" || p.in === "formData");
+  static filterBodyParams(parameters) {
+    if (Array.isArray(parameters) && parameters.length > 0) {
+      return parameters.filter((parameter) => parameter.in === "body" || parameter.in === "formData");
+    }
+    return [];
   }
-  static getQueryParameters(parametersArray) {
-    if (!parametersArray) {
+  static filterQueryParameters(parameters) {
+    if (!parameters) {
       return [];
     }
-    const res = [];
-    for (const p of parametersArray) {
-      if (p.in === "query") {
-        res.push(p);
-      }
-    }
-    return res;
+    return parameters.filter((parameter) => parameter.in === "query");
   }
   static mkdirIfNotExist(dirToCreate) {
-    if (!fs__default['default'].existsSync(dirToCreate)) {
-      fs__default['default'].mkdirSync(dirToCreate, { recursive: true });
+    if (!fs.existsSync(dirToCreate)) {
+      fs.mkdirSync(dirToCreate, { recursive: true });
     }
   }
   static writeClassFile(distDir, apiName, apiBuffer, imports) {
     const fileContent = templateClass(apiName, apiBuffer, imports);
-    fs__default['default'].writeFileSync(`${distDir}/${apiName}.ts`, ParserUtils.prependCopyrightHeader(fileContent));
+    fs.writeFileSync(`${distDir}/${apiName}.ts`, ParserUtils.prependCopyrightHeader(fileContent));
   }
   static writeJsdocFile(distDir, nameArray, apiBuffer) {
     const jsdocFile = templateJsdocFile(nameArray[0], apiBuffer);
-    fs__default['default'].writeFileSync(`${distDir}/docs/${nameArray[0]}.md`, jsdocFile);
+    fs.writeFileSync(`${distDir}/docs/${nameArray[0]}.md`, jsdocFile);
   }
   static writeDefinitionFile(distDir, name, buffer) {
     ParserUtils.mkdirIfNotExist(distDir);
-    fs__default['default'].writeFileSync(path__default['default'].join(distDir, `${name}.ts`), ParserUtils.prependCopyrightHeader(buffer));
+    fs.writeFileSync(path.join(distDir, `${name}.ts`), ParserUtils.prependCopyrightHeader(buffer));
   }
   static writeAllImportsFile(distDir, buffer, isAdminWebSdk) {
     ParserUtils.mkdirIfNotExist(distDir);
-    fs__default['default'].writeFileSync(path__default['default'].join(distDir, `all-${isAdminWebSdk ? "admin" : "public"}-imports.ts`), ParserUtils.prependCopyrightHeader(buffer));
+    fs.writeFileSync(path.join(distDir, `all-${isAdminWebSdk ? "admin" : "public"}-imports.ts`), ParserUtils.prependCopyrightHeader(buffer));
   }
   static toCamelCase(str) {
     return str.split("/").map(function(word, index) {
@@ -358,24 +410,17 @@ class ParserUtils {
     });
   }
   static applyPatchIfExists(swaggerFilePath, possibleSwaggerPatchFilePath, swaggerPatchedFilePath, swaggerPatchedDir) {
-    if (!fs__default['default'].existsSync(swaggerPatchedDir)) {
-      fs__default['default'].mkdirSync(swaggerPatchedDir, { recursive: true });
+    if (!fs.existsSync(swaggerPatchedDir)) {
+      fs.mkdirSync(swaggerPatchedDir, { recursive: true });
     }
-    if (!fs__default['default'].existsSync(possibleSwaggerPatchFilePath)) {
-      fs__default['default'].copyFileSync(swaggerFilePath, swaggerPatchedFilePath);
+    if (!fs.existsSync(possibleSwaggerPatchFilePath)) {
+      fs.copyFileSync(swaggerFilePath, swaggerPatchedFilePath);
       return;
     }
-    const swaggerContent = JSON.parse(fs__default['default'].readFileSync(swaggerFilePath, "utf8"));
-    const swaggerPatchFileContent = JSON.parse(fs__default['default'].readFileSync(possibleSwaggerPatchFilePath, "utf8"));
+    const swaggerContent = JSON.parse(fs.readFileSync(swaggerFilePath, "utf8"));
+    const swaggerPatchFileContent = JSON.parse(fs.readFileSync(possibleSwaggerPatchFilePath, "utf8"));
     const { newDocument } = fastJsonPatch.applyPatch(swaggerContent, swaggerPatchFileContent);
-    fs__default['default'].writeFileSync(swaggerPatchedFilePath, JSON.stringify(newDocument, null, 2));
-  }
-  static mapKeys(map_) {
-    const methods_ = [];
-    for (const m in map_) {
-      methods_.push(m);
-    }
-    return methods_;
+    fs.writeFileSync(swaggerPatchedFilePath, JSON.stringify(newDocument, null, 2));
   }
   static getRelativePathToWebSdkSrcFolder(srcFolder, targetSrcFolder) {
     const replaced = srcFolder.replace(/\\/g, "/");
@@ -392,7 +437,7 @@ ${content}`;
   };
 }
 
-const templateJsdocMethod = (classMethod, httpMethod, path, pathParams, bodyParams, queryParams) => {
+const templateJsdocMethod = ({ classMethod, httpMethod, path, pathParams, bodyParams, queryParams }) => {
   let jsdoc = "";
   let methodSignature = "";
   let newPath = path;
@@ -429,21 +474,31 @@ const templateJsdocMethod = (classMethod, httpMethod, path, pathParams, bodyPara
 `;
 };
 
-const templateMethod = (classMethod, description, httpMethod, path, pathParams, bodyParams, queryParams, isFormUrlEncoded, responseClass) => {
+const templateMethod = ({
+  classMethod,
+  description,
+  httpMethod,
+  path,
+  pathParams,
+  bodyParams,
+  queryParams,
+  isFormUrlEncoded,
+  responseClass
+}) => {
   let methodSignature = "";
   let newPath = `'${path}'`;
   let dependencies = [];
-  for (const p of pathParams) {
-    const type = ParserUtils.parseType(p.type);
-    if (p.name !== "namespace") {
-      methodSignature += p.name + `:${type}, `;
+  for (const pathParam of pathParams) {
+    const type = ParserUtils.parseType(pathParam);
+    if (pathParam.name !== "namespace") {
+      methodSignature += pathParam.name + `:${type}, `;
     }
-    const pName = p.name === "namespace" ? "this.namespace" : p.name;
-    if (path.match(`{${p.name}}`)) {
+    const pName = pathParam.name === "namespace" ? "this.namespace" : pathParam.name;
+    if (path.match(`{${pathParam.name}}`)) {
       if (type === "string") {
-        newPath = `${newPath}.replace('{${p.name}}', ${pName})`;
+        newPath = `${newPath}.replace('{${pathParam.name}}', ${pName})`;
       } else {
-        newPath = `${newPath}.replace('{${p.name}}', String(${pName}))`;
+        newPath = `${newPath}.replace('{${pathParam.name}}', String(${pName}))`;
       }
     }
   }
@@ -453,8 +508,8 @@ const templateMethod = (classMethod, description, httpMethod, path, pathParams,
     dependencies = ParserUtils.parseBodyParamsImports(bodyParams);
     methodSignature += dataType ? `data: ${dataType},` : "";
   }
-  ParserUtils.isAnyQueryParamRequired(queryParams);
-  const queryParamsType = queryParams.length ? `queryParams${"?"}: {${ParserUtils.parseQueryParamsType(queryParams)}}` : "";
+  const isAnyRequired = ParserUtils.isAnyQueryParamRequired(queryParams);
+  const queryParamsType = queryParams.length ? `queryParams${isAnyRequired ? "" : "?"}: {${ParserUtils.parseQueryParamsType(queryParams)}}` : "";
   const queryParamsDefault = queryParams.length ? `const params = {${ParserUtils.parseQueryParamsDefault(queryParams)} ...queryParams} as SDKRequestConfig` : "const params = {} as SDKRequestConfig";
   const isPostPutPatch = ["post", "put", "patch"].includes(httpMethod);
   const isDelete = ["delete"].includes(httpMethod);
@@ -479,74 +534,30 @@ const templateMethod = (classMethod, description, httpMethod, path, pathParams,
   const parameters = (queryParamsType ? `${methodSignature} ${queryParamsType}` : methodSignature).replace(/,\s*$/, "");
   let methodImpl = "";
   const isCacheFetch = ["get"].includes(httpMethod) && resolvedResponseClass !== "unknown";
-  const isCacheFetchUnknown = ["get"].includes(httpMethod) && resolvedResponseClass === "unknown";
   const cachedFetchMethod = classMethod.replace("get", "fetch");
   const deprecateTag = isCacheFetch ? `/**
  * @deprecated Use "${cachedFetchMethod}()" instead.
  */` : "";
-  let isGuardInvoked = false;
-  if (isCacheFetch) {
-    methodImpl = `${descriptionText}
-  ${cachedFetchMethod}<T = ${resolvedResponseClass}>(${parameters}): Promise<IResponseWithSync<T>> {
+  const isGuardInvoked = ["get", "post", "put", "patch", "delete"].includes(httpMethod);
+  const methodName = httpMethod === "get" ? cachedFetchMethod : ["post", "put", "patch", "delete"].includes(httpMethod) ? classMethod : "";
+  const methodGenerics = resolvedResponseClass !== "unknown" ? `<T = ${resolvedResponseClass}>` : "";
+  const responseType = resolvedResponseClass !== "unknown" ? `T` : "unknown";
+  const responseSyncType = httpMethod === "get" ? "IResponseWithSync" : ["post", "put", "patch", "delete"].includes(httpMethod) ? "IResponse" : "";
+  methodImpl = `${descriptionText}
+  ${methodName}${methodGenerics}(${parameters}): Promise<${responseSyncType}<${responseType}>> {
     ${queryParamsDefault}
     const url = ${newPath}    ${formPayloadString} ${isFileUpload ? "\n// TODO file upload not implemented" : ""}
     const resultPromise = this.axiosInstance.${httpMethod}(url, ${dataPayload})
-    
-    const res = () => Validate.responseType(() => resultPromise, ${resolvedResponseClassValidated})
 
-    if (!this.cache) {
-      return SdkCache.withoutCache(res)
-    }
-    const cacheKey = url + CodeGenUtil.hashCode(JSON.stringify({ params }))
-    return SdkCache.withCache(cacheKey, res)
-  }
-  `;
-    isGuardInvoked = true;
-  }
-  if (isCacheFetchUnknown) {
-    methodImpl = `${descriptionText}
-  ${cachedFetchMethod}(${parameters}): Promise<IResponseWithSync<unknown>> {
-    ${queryParamsDefault}
-    const url = ${newPath}    ${formPayloadString} ${isFileUpload ? "\n// TODO file upload not implemented" : ""}
-    const resultPromise = this.axiosInstance.${httpMethod}(url, ${dataPayload})
-    
-    const res = () => Validate.responseType(() => resultPromise, z.unknown())
+${httpMethod === "get" ? `const res = () => Validate.responseType(() => resultPromise, ${resolvedResponseClassValidated})
 
     if (!this.cache) {
       return SdkCache.withoutCache(res)
     }
     const cacheKey = url + CodeGenUtil.hashCode(JSON.stringify({ params }))
-    return SdkCache.withCache(cacheKey, res)
-  }
-  `;
-    isGuardInvoked = true;
-  }
-  const withTypeGuard = ["post", "put", "patch", "delete"].includes(httpMethod) && resolvedResponseClass !== "unknown";
-  if (withTypeGuard) {
-    methodImpl = `${descriptionText}
-  ${classMethod}<T = ${resolvedResponseClass}>(${parameters}): Promise<IResponse<T>> {
-    ${queryParamsDefault}
-    const url = ${newPath}    ${formPayloadString} ${isFileUpload ? "\n// TODO file upload not implemented" : ""}
-    const resultPromise = this.axiosInstance.${httpMethod}(url, ${dataPayload})
-    
-    return Validate.responseType(() => resultPromise, ${resolvedResponseClassValidated})    
+    return SdkCache.withCache(cacheKey, res)` : ""}${["post", "put", "patch", "delete"].includes(httpMethod) ? `return Validate.responseType(() => resultPromise, ${resolvedResponseClassValidated})` : ""}
   }
   `;
-    isGuardInvoked = true;
-  }
-  const withTypeGuardUnknown = ["post", "put", "patch", "delete"].includes(httpMethod) && resolvedResponseClass === "unknown";
-  if (withTypeGuardUnknown) {
-    methodImpl = `${descriptionText}
-  ${classMethod}(${parameters}): Promise<IResponse<unknown>> {
-    ${queryParamsDefault}
-    const url = ${newPath}    ${formPayloadString} ${isFileUpload ? "\n// TODO file upload not implemented" : ""}
-    const resultPromise = this.axiosInstance.${httpMethod}(url, ${dataPayload})
-    
-    return Validate.responseType(() => resultPromise, z.unknown())    
-  }
-  `;
-    isGuardInvoked = true;
-  }
   if (!isGuardInvoked) {
     methodImpl = `${descriptionText}
       ${deprecateTag}
@@ -564,12 +575,12 @@ class TemplateZod {
   duplicates;
   duplicateFound = false;
   importClasses = /* @__PURE__ */ new Set();
-  render = (name, definition, duplicates) => {
+  render = (fileName, definition, duplicates) => {
     this.duplicates = duplicates;
     const content = this.parseToZodSchema(definition, definition.required || []);
-    const containsRecursiveType = this.importClasses.has(name);
+    const containsRecursiveType = this.importClasses.has(fileName);
     if (containsRecursiveType) {
-      this.importClasses.delete(name);
+      this.importClasses.delete(fileName);
     }
     let imports = "";
     for (const cl of Array.from(this.importClasses).sort()) {
@@ -580,18 +591,18 @@ class TemplateZod {
     let exportedTypeString;
     if (containsRecursiveType) {
       exportedVariableString = `
-        export const ${name}: z.ZodType<${name}> = z.lazy(() =>
+        export const ${fileName}: z.ZodType<${fileName}> = z.lazy(() =>
           ${content.schemaString}
         )
       `;
       exportedTypeString = `
-        export type ${name} = {
+        export type ${fileName} = {
           ${content.typeString}
         }
       `;
     } else {
-      exportedVariableString = `export const ${name} = ${content.schemaString}`;
-      exportedTypeString = `export type ${name} = z.TypeOf<typeof ${name}>`;
+      exportedVariableString = `export const ${fileName} = ${content.schemaString}`;
+      exportedTypeString = `export type ${fileName} = z.TypeOf<typeof ${fileName}>`;
     }
     const template = `import { z } from 'zod'
   ${imports}
@@ -780,10 +791,10 @@ const extractEnumObject = (type, isRequired, enumArr) => {
 };
 
 class CodeGenerator {
-  static getPatchedDir = () => path__default['default'].join(CliParser.getSwaggersOutputPath(), "patched");
+  static getPatchedDir = () => path.join(CliParser.getSwaggersOutputPath(), "patched");
   static getGeneratedPublicFolder = () => `${CliParser.getOutputPath()}/generated-public`;
   static getGeneratedAdminFolder = () => `${CliParser.getOutputPath()}/generated-admin`;
-  static iterateApi = (api) => {
+  static iterateApi = async (api) => {
     const apiBufferByTag = {};
     const jsDocApiBufferByTag = {};
     const dependenciesByTag = {};
@@ -796,15 +807,21 @@ class CodeGenerator {
       } else if (!CliParser.isAdmin() && isAdminEndpoint) {
         continue;
       }
-      const entity = api.paths[path2];
-      const methods = ParserUtils.mapKeys(entity);
-      for (const httpMethod of methods) {
-        const e = entity[httpMethod];
-        const [tag] = e.tags;
-        const description = e.description;
-        const isDeprecated = e.deprecated;
-        const responseClass = ParserUtils.get2xxResponse(e.responses, path2);
-        const className = ___default['default'].upperFirst(___default['default'].camelCase(tag));
+      const operation = api.paths[path2];
+      const httpMethods = Object.keys(operation);
+      for (const httpMethod of httpMethods) {
+        const endpoint = await Endpoint.parseAsync(operation[httpMethod]).catch((error) => {
+          console.error(JSON.stringify({ path: path2, httpMethod }, null, 2));
+          throw error;
+        });
+        if (!endpoint.tags) {
+          continue;
+        }
+        const [tag] = endpoint.tags;
+        const description = endpoint.description;
+        const isDeprecated = endpoint.deprecated;
+        const responseClass = ParserUtils.get2xxResponse(endpoint.responses);
+        const className = _.upperFirst(_.camelCase(tag));
         classImports[className] = classImports[className] ? classImports[className] : {};
         if (!isDeprecated) {
           if (responseClass) {
@@ -814,15 +831,30 @@ class CodeGenerator {
           if (responseClass && responseClass.endsWith("Array")) {
             arrayDefinitions.push(responseClass);
           }
-          const isFormUrlEncoded = ParserUtils.isFormUrlEncoded(httpMethod, e.consumes);
-          const queryParams = ParserUtils.getQueryParameters(e.parameters);
-          const pathParams = ParserUtils.getPathParams(e.parameters);
-          const bodyParams = ParserUtils.getBodyParams(e.parameters);
-          const classMethod = ParserUtils.generateClassMethod(path2, e.parameters, httpMethod, className);
-          const baseAndPath = `${api.basePath ?? ""}${path2}`;
-          const [generatedMethodString, importStatements] = templateMethod(classMethod, description, httpMethod, baseAndPath, pathParams, bodyParams, queryParams, isFormUrlEncoded, responseClass);
+          const isFormUrlEncoded = ParserUtils.isFormUrlEncoded(httpMethod, endpoint.consumes);
+          const queryParams = ParserUtils.filterQueryParameters(endpoint.parameters);
+          const pathParams = ParserUtils.filterPathParams(endpoint.parameters);
+          const bodyParams = ParserUtils.filterBodyParams(endpoint.parameters);
+          const classMethod = ParserUtils.generateClassMethod({
+            path: path2,
+            endpoint,
+            httpMethod,
+            className
+          });
+          const pathWithBase = `${api.basePath ?? ""}${path2}`;
+          const [generatedMethodString, importStatements] = templateMethod({
+            classMethod,
+            description,
+            httpMethod,
+            path: pathWithBase,
+            pathParams,
+            bodyParams,
+            queryParams,
+            isFormUrlEncoded,
+            responseClass
+          });
           apiBufferByTag[tag] = (apiBufferByTag[tag] || "") + generatedMethodString;
-          jsDocApiBufferByTag[tag] = (jsDocApiBufferByTag[tag] || "") + templateJsdocMethod(classMethod, httpMethod, path2, pathParams, bodyParams, queryParams);
+          jsDocApiBufferByTag[tag] = (jsDocApiBufferByTag[tag] || "") + templateJsdocMethod({ classMethod, httpMethod, path: path2, pathParams, bodyParams, queryParams });
           dependenciesByTag[tag] = dependenciesByTag[tag] ? [.../* @__PURE__ */ new Set([...importStatements, ...dependenciesByTag[tag]])] : [...new Set(importStatements)];
         }
       }
@@ -833,11 +865,11 @@ class CodeGenerator {
   static main = async (nameArray) => {
     const serviceName = nameArray[0];
     const swaggerFile = nameArray[2];
-    const parser = new SwaggerParser__default['default']();
+    const parser = new SwaggerParser();
     const generatedFolder = CliParser.isAdmin() ? CodeGenerator.getGeneratedAdminFolder() : CodeGenerator.getGeneratedPublicFolder();
     const DIST_DIR = `${generatedFolder}/${serviceName}`;
-    const DIST_DOCS_DIR = path__default['default'].join(DIST_DIR, "docs");
-    const DIST_DEFINITION_DIR = path__default['default'].join(DIST_DIR, "definitions");
+    const DIST_DOCS_DIR = path.join(DIST_DIR, "docs");
+    const DIST_DEFINITION_DIR = path.join(DIST_DIR, "definitions");
     const swaggerFilePath = `${CliParser.getSwaggersOutputPath()}/${swaggerFile}`;
     const swaggerPatchedFilePath = `${CodeGenerator.getPatchedDir()}/${swaggerFile}`;
     const swaggerPatchFilePath = `${swaggerFilePath}patch`;
@@ -848,28 +880,28 @@ class CodeGenerator {
     ParserUtils.mkdirIfNotExist(DIST_DIR);
     ParserUtils.mkdirIfNotExist(DIST_DOCS_DIR);
     ParserUtils.mkdirIfNotExist(DIST_DEFINITION_DIR);
-    const { apiBufferByTag, dependenciesByTag, classImports, arrayDefinitions } = CodeGenerator.iterateApi(api);
+    const { apiBufferByTag, dependenciesByTag, classImports, arrayDefinitions } = await CodeGenerator.iterateApi(api);
     const targetSrcFolder = `${CliParser.getOutputPath()}/`;
     for (const tag in apiBufferByTag) {
-      const className = ___default['default'].upperFirst(___default['default'].camelCase(tag));
+      const className = _.upperFirst(_.camelCase(tag));
       const apiBuffer = apiBufferByTag[tag];
       const imports = [.../* @__PURE__ */ new Set([...dependenciesByTag[tag], ...Object.values(classImports[className])])];
       const classGenName = CliParser.isAdmin() ? className + "Admin$" : className + "$";
       ParserUtils.writeClassFile(DIST_DIR, classGenName, apiBuffer, imports);
-      indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path__default['default'].join(DIST_DIR, `${classGenName}`), targetSrcFolder));
+      indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path.join(DIST_DIR, `${classGenName}`), targetSrcFolder));
     }
     const duplicates = /* @__PURE__ */ new Map();
     for (const ref in api.definitions) {
       const definition = api.definitions[ref];
       let fileName = ParserUtils.parseRefType(ref);
-      const fileExist = fs__default['default'].existsSync(path__default['default'].join(DIST_DEFINITION_DIR, `${fileName}.ts`));
+      const fileExist = fs.existsSync(path.join(DIST_DEFINITION_DIR, `${fileName}.ts`));
       if (fileExist) {
         fileName = ParserUtils.toCamelCaseWord(ref).replace(".", "").replace(".", "");
         duplicates.set(ref, fileName);
       }
       const { buffer } = new TemplateZod().render(fileName, definition, /* @__PURE__ */ new Map());
       ParserUtils.writeDefinitionFile(DIST_DEFINITION_DIR, fileName, buffer);
-      indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path__default['default'].join(DIST_DEFINITION_DIR, fileName), targetSrcFolder));
+      indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path.join(DIST_DEFINITION_DIR, fileName), targetSrcFolder));
     }
     for (const ref in api.definitions) {
       const definition = api.definitions[ref];
@@ -877,13 +909,13 @@ class CodeGenerator {
       const { buffer, duplicateFound } = new TemplateZod().render(fileName, definition, duplicates);
       if (duplicateFound) {
         ParserUtils.writeDefinitionFile(DIST_DEFINITION_DIR, fileName, buffer);
-        indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path__default['default'].join(DIST_DEFINITION_DIR, fileName), targetSrcFolder));
+        indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path.join(DIST_DEFINITION_DIR, fileName), targetSrcFolder));
       }
     }
     for (const arrayClass of arrayDefinitions) {
       const buffer = new TemplateZodArray().render(arrayClass);
       ParserUtils.writeDefinitionFile(DIST_DEFINITION_DIR, arrayClass, buffer);
-      indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path__default['default'].join(DIST_DEFINITION_DIR, arrayClass), targetSrcFolder));
+      indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path.join(DIST_DEFINITION_DIR, arrayClass), targetSrcFolder));
     }
     console.log("\n----------\nCOMPLETED.\n----------\n\n");
     return indexImportsSet;
@@ -926,7 +958,7 @@ class SwaggerDownloader {
   };
 }
 
-yargs__default['default'].command("download-swaggers", "Download swaggers JSON files", (yargs2) => {
+yargs.command("download-swaggers", "Download swaggers JSON files", (yargs2) => {
   CliParser.createInstance(yargs2);
   SwaggerDownloader.main();
 }).command("generate-code", "Generate code based on downloaded swagger files", async (yargs2) => {
@@ -942,7 +974,7 @@ yargs__default['default'].command("download-swaggers", "Download swaggers JSON f
   const filenamesSet = /* @__PURE__ */ new Set();
   for (const set of arrayOfSets) {
     set.forEach((value) => {
-      const fileName = path__default['default'].basename(value);
+      const fileName = path.basename(value);
       if (!filenamesSet.has(fileName)) {
         indexImportsSet.add(value);
         filenamesSet.add(fileName);