@accelbyte/codegen 1.0.0-alpha.1 → 1.0.0-alpha.12

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) {
@@ -27,18 +24,13 @@ function _interopNamespace(e) {
       }
     });
   }
-  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 {
@@ -64,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");
     }
@@ -109,15 +101,15 @@ const generateImports = (body, importStatements) => {
 ${importStatements.sort().join("\n")}`;
 };
 const templateClass = (className, body, importStatements) => `/**
-   * DON'T EDIT THIS FILE, it is AUTO GENERATED
-   */
-  ${generateImports(body, importStatements)}
+ * DON'T EDIT THIS FILE, it is AUTO GENERATED
+ */
+${generateImports(body, importStatements)}
 
-  export class ${className} {
-      // @ts-ignore
-      constructor(private axiosInstance: AxiosInstance, private namespace: string, private cache = false) {}
+export class ${className} {
+  // @ts-ignore
+  constructor(private axiosInstance: AxiosInstance, private namespace: string, private cache = false) {}
   ${body}
-  }
+}
   `;
 
 const templateJsdocFile = (apiName, body) => `
@@ -129,44 +121,34 @@ ${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" || pathParam?.schema?.type === "integer")
       return "number";
-    if (type === "array")
-      return "any[]";
-    return type;
+    if (pathParam.type === "array")
+      return `${pathParam.items.type ?? "any"}[]`;
+    if (pathParam?.schema?.type === "array")
+      return `${pathParam.schema.items.type ?? "any"}[]`;
+    if (pathParam?.schema?.type)
+      return pathParam.schema.type;
+    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(".", "/");
@@ -179,7 +161,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}'`;
   };
@@ -189,60 +175,72 @@ 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?.schema?.type && ParserUtils.parseType(definition) === "number") {
       return `${attrName}${required}: number`;
     }
     if (definition.type && definition.type === "array") {
       return `${attrName}${required}: ${definition.items.type ?? "any"}[]`;
     }
+    if (definition?.schema?.type && definition.schema.type === "array") {
+      return `${attrName}${required}: ${definition.schema.items.type ?? "any"}[]`;
+    }
     if (definition.type && definition.type) {
       return `${attrName}${required}: ${definition.type} | null`;
     }
+    if (definition?.schema?.type && definition.schema.type) {
+      return `${attrName}${required}: ${definition.schema.type} | null`;
+    }
     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) => {
       if (String(key).startsWith("2")) {
         const sch = methodEntity[key].schema;
+        const schV3 = methodEntity[key].content && methodEntity[key].content["application/json"].schema;
         if (sch?.$ref) {
           responseClass = ParserUtils.parseRefType(sch.$ref);
         } else if (sch?.type === "array" && sch.items?.$ref) {
           responseClass = ParserUtils.parseRefType(sch.items.$ref);
           responseClass = `${responseClass}Array`;
+        } else if (schV3?.$ref) {
+          responseClass = ParserUtils.parseRefType(schV3.$ref);
         } else ;
       }
     });
@@ -257,33 +255,32 @@ 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 = classMethod.replace("PublicNamespacesByNamespace", "");
-    classMethod = classMethod.replace("AdminNamespacesByNamespace", "Admin");
+    classMethod = _.camelCase(classMethod);
+    classMethod = classMethod.replace("PublicNamespacesByNamespace", "Ns");
+    classMethod = classMethod.replace("AdminNamespacesByNamespace", "AdminNs");
     const searchWord = "NamespacesByNamespace";
     const nsExistInsideMethod = classMethod.indexOf(searchWord) > 0 && classMethod.indexOf(searchWord) + searchWord.length < classMethod.length;
     const excludedClasses = ["Policies"];
@@ -292,45 +289,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) {
@@ -356,24 +346,40 @@ 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 { 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);
+    const swaggerContent = JSON.parse(fs.readFileSync(swaggerFilePath, "utf8"));
+    const swaggerPatchFileContent = JSON.parse(fs.readFileSync(possibleSwaggerPatchFilePath, "utf8"));
+    for (const patchEntry of swaggerPatchFileContent) {
+      const segments = patchEntry.path.split("/").filter(Boolean);
+      let currentNode = swaggerContent;
+      let aggregatedPath = "";
+      for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        aggregatedPath += `/${segment}`;
+        const effectiveSegment = segment.replace(/(~1)/g, "/").replace(/(~0)/g, "~");
+        if (!currentNode[effectiveSegment]) {
+          if (i + 1 === segments.length && patchEntry.op === "add") ; else {
+            throw new Error([
+              `JSON patch error: operation "${patchEntry.op}" on path "${aggregatedPath}" fails because the path doesn't exist in ${swaggerFilePath}. This may be caused by:
+`,
+              "1. The related service has patched the service, so patch is no longer needed.",
+              "2. There is a breaking change on the service that causes the path to change.\n",
+              `In any case, revisit this file: "${possibleSwaggerPatchFilePath}", then try again.
+`
+            ].join("\n"));
+          }
+        }
+        currentNode = currentNode[effectiveSegment];
+      }
     }
-    return methods_;
+    const { newDocument } = fastJsonPatch.applyPatch(swaggerContent, swaggerPatchFileContent);
+    fs.writeFileSync(swaggerPatchedFilePath, JSON.stringify(newDocument, null, 2));
   }
   static getRelativePathToWebSdkSrcFolder(srcFolder, targetSrcFolder) {
     const replaced = srcFolder.replace(/\\/g, "/");
@@ -390,7 +396,104 @@ ${content}`;
   };
 }
 
-const templateJsdocMethod = (classMethod, httpMethod, path, pathParams, bodyParams, queryParams) => {
+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"), zod.z.literal("integer")]).nullish(),
+  items: zod.z.object({
+    $ref: zod.z.string().nullish(),
+    type: zod.z.string().nullish()
+  }).nullish(),
+  properties: zod.z.union([zod.z.array(zod.z.string()).nullish(), zod.z.record(zod.z.object({ type: 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(),
+    content: zod.z.object({
+      "application/json": zod.z.object({
+        schema: Schema.nullish()
+      })
+    }).nullish()
+  })),
+  parameters: zod.z.array(EndpointParameters).nullish(),
+  requestBody: zod.z.object({
+    required: zod.z.boolean(),
+    content: zod.z.object({
+      "application/json": zod.z.object({
+        schema: Schema.nullish()
+      })
+    }).nullish()
+  }).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(),
+  components: zod.z.object({
+    schemas: Definitions
+  }).nullish()
+});
+
+const templateJsdocMethod = ({
+  classMethod,
+  httpMethod,
+  path,
+  pathParams,
+  bodyParams,
+  queryParams
+}) => {
   let jsdoc = "";
   let methodSignature = "";
   let newPath = path;
@@ -427,21 +530,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}))`;
       }
     }
   }
@@ -451,8 +564,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);
@@ -477,74 +590,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 key = url + CodeGenUtil.hashCode(JSON.stringify({ params }))
-    return SdkCache.withCache(key, 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 key = url + CodeGenUtil.hashCode(JSON.stringify({ params }))
-    return SdkCache.withCache(key, res)
+    const cacheKey = url + CodeGenUtil.hashCode(JSON.stringify({ params }))
+    return SdkCache.withCache(cacheKey, res)` : ""}${["post", "put", "patch", "delete"].includes(httpMethod) ? `    return Validate.responseType(() => resultPromise, ${resolvedResponseClassValidated})` : ""}
   }
   `;
-    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})    
-  }
-  `;
-    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}
@@ -562,41 +631,41 @@ 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()) {
-      imports += `  import { ${cl} } from './${cl}'
+      imports += `import { ${cl} } from './${cl}'
 `;
     }
     let exportedVariableString;
     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 interface ${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 interface ${fileName} extends z.TypeOf<typeof ${fileName}> {}`;
     }
     const template = `import { z } from 'zod'
-  ${imports}
+${imports}
 
-  ${exportedVariableString}
+${exportedVariableString}
 
-  ${exportedTypeString}
+${exportedTypeString}
   `;
     return { buffer: template, duplicateFound: this.duplicateFound };
   };
@@ -604,13 +673,17 @@ class TemplateZod {
     if (definition.additionalProperties) {
       return this.parseToZodAttribute("", definition, []);
     }
-    if (!definition.properties) {
+    let properties;
+    if (definition.properties) {
+      properties = Object.entries(definition.properties);
+    } else if (definition.items?.properties) {
+      properties = Object.entries(definition.items.properties);
+    } else {
       return {
         schemaString: "z.any()",
         typeString: "any"
       };
     }
-    const properties = Object.entries(definition.properties);
     const schemaFields = [];
     const typeFields = [];
     for (const property of properties) {
@@ -619,6 +692,12 @@ class TemplateZod {
       schemaFields.push(result.schemaString);
       typeFields.push(result.typeString);
     }
+    if (definition?.type === "array") {
+      return {
+        schemaString: `z.array(z.object({${schemaFields.join(",")}}))`,
+        typeString: typeFields.join(";")
+      };
+    }
     return {
       schemaString: `z.object({${schemaFields.join(",")}})`,
       typeString: typeFields.join(";")
@@ -660,7 +739,8 @@ class TemplateZod {
         };
       }
       if (type === "array") {
-        const ref2 = definition.items?.$ref;
+        const items = definition.items;
+        const ref2 = items?.$ref;
         let model2;
         if (ref2) {
           const refType = ParserUtils.parseRefType(ref2);
@@ -669,9 +749,13 @@ class TemplateZod {
             schemaString: refType,
             typeString: refType
           };
-        } else {
-          const items = definition.items;
+        } else if (items) {
           model2 = this.parseEnumItems(items);
+        } else {
+          return {
+            schemaString: `${schemaAttribute} z.array(z.any())${schemaRequired}`,
+            typeString: `${typeAttribute} any[]${typeNullishability}`
+          };
         }
         return {
           schemaString: `${schemaAttribute} z.array(${model2.schemaString})${schemaRequired}`,
@@ -738,11 +822,11 @@ class TemplateZodArray {
   render = (name) => {
     const cls = name.replace("Array", "");
     const template = `import { z } from 'zod'
-  import { ${cls} } from './${cls}'
+import { ${cls} } from './${cls}'
   
-  export const ${name} = z.array(${cls})
+export const ${name} = z.array(${cls})
 
-  export type ${name} = z.TypeOf<typeof ${name}>
+export interface ${name} extends z.TypeOf<typeof ${name}> {}
   `;
     return template;
   };
@@ -778,10 +862,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 = {};
@@ -794,15 +878,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) {
@@ -812,15 +902,39 @@ 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);
+          let bodyParams = ParserUtils.filterBodyParams(endpoint.parameters);
+          const classMethod = ParserUtils.generateClassMethod({
+            path: path2,
+            endpoint,
+            httpMethod,
+            className
+          });
+          if (endpoint.requestBody) {
+            bodyParams = [
+              {
+                name: "body",
+                in: "body",
+                schema: endpoint.requestBody.content["application/json"].schema
+              }
+            ];
+          }
+          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)];
         }
       }
@@ -831,11 +945,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`;
@@ -846,42 +960,43 @@ 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];
+    const definitions = api?.components?.schemas || api.definitions;
+    for (const ref in definitions) {
+      const definition = 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];
+    for (const ref in definitions) {
+      const definition = definitions[ref];
       const fileName = ParserUtils.parseRefType(ref);
       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;
@@ -924,7 +1039,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) => {
@@ -940,7 +1055,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);