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

package/dist/accelbyte-codegen.mjs

@@ -78,15 +78,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) => `
@@ -98,44 +98,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(".", "/");
@@ -148,7 +138,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}'`;
   };
@@ -158,60 +152,72 @@ class ParserUtils {
       ref = ref.slice(0, -1);
     }
     const val = ref.slice(ref.lastIndexOf("/") + 1);
-    return _.upperFirst(_.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 ;
       }
     });
@@ -226,24 +232,23 @@ 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", "");
         }
@@ -251,8 +256,8 @@ class ParserUtils {
     }
     let classMethod = httpMethod + "/" + replacedIdsPath;
     classMethod = _.camelCase(classMethod);
-    classMethod = classMethod.replace("PublicNamespacesByNamespace", "");
-    classMethod = classMethod.replace("AdminNamespacesByNamespace", "Admin");
+    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"];
@@ -261,24 +266,17 @@ class ParserUtils {
     }
     return classMethod;
   }
-  static getBodyParams(parametersArray) {
-    if (!parametersArray)
-      return [];
-    if (!_.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.existsSync(dirToCreate)) {
@@ -334,16 +332,32 @@ class ParserUtils {
     }
     const swaggerContent = JSON.parse(fs__default.readFileSync(swaggerFilePath, "utf8"));
     const swaggerPatchFileContent = JSON.parse(fs__default.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];
+      }
+    }
     const { newDocument } = applyPatch(swaggerContent, swaggerPatchFileContent);
     fs__default.writeFileSync(swaggerPatchedFilePath, JSON.stringify(newDocument, null, 2));
   }
-  static mapKeys(map_) {
-    const methods_ = [];
-    for (const m in map_) {
-      methods_.push(m);
-    }
-    return methods_;
-  }
   static getRelativePathToWebSdkSrcFolder(srcFolder, targetSrcFolder) {
     const replaced = srcFolder.replace(/\\/g, "/");
     return replaced.replace(/\\/g, "/").replace(targetSrcFolder, "./");
@@ -359,7 +373,104 @@ ${content}`;
   };
 }
 
-const templateJsdocMethod = (classMethod, httpMethod, path, pathParams, bodyParams, queryParams) => {
+const Schema = z.object({
+  $ref: z.string().nullish(),
+  type: z.union([z.literal("array"), z.literal("object"), z.literal("file"), z.literal("string"), z.literal("boolean"), z.literal("integer")]).nullish(),
+  items: z.object({
+    $ref: z.string().nullish(),
+    type: z.string().nullish()
+  }).nullish(),
+  properties: z.union([z.array(z.string()).nullish(), z.record(z.object({ type: z.string() })).nullish()]),
+  description: z.string().nullish(),
+  additionalProperties: z.object({
+    type: z.string().nullish()
+  }).nullish()
+});
+const Definition = z.object({
+  required: z.array(z.string()).nullish(),
+  properties: z.record(z.object({
+    type: z.string()
+  })).nullish()
+});
+const Definitions = z.record(Definition);
+const EndpointParametersType = z.enum(["apiKey", "boolean", "int", "integer", "number", "string", "array", "file"]);
+const EndpointParametersIn = z.enum(["body", "formData", "header", "path", "query"]);
+const EndpointParameters = z.object({
+  type: EndpointParametersType.nullish(),
+  description: z.string().nullish(),
+  name: z.string(),
+  in: EndpointParametersIn,
+  required: z.boolean().nullish(),
+  schema: Schema.nullish(),
+  default: z.union([z.boolean(), z.string(), z.number()]).nullish(),
+  enum: z.array(z.union([z.boolean(), z.string(), z.number()])).nullish(),
+  items: z.object({
+    type: z.string()
+  }).nullish()
+});
+const Endpoint = z.object({
+  description: z.string().nullish(),
+  consumes: z.array(z.string()).nullish(),
+  produces: z.array(z.string()).nullish(),
+  tags: z.array(z.string()).nullish(),
+  summary: z.string().nullish(),
+  operationId: z.string(),
+  deprecated: z.boolean().nullish(),
+  responses: z.record(z.object({
+    description: z.string().nullish(),
+    schema: Schema.nullish(),
+    content: z.object({
+      "application/json": z.object({
+        schema: Schema.nullish()
+      })
+    }).nullish()
+  })),
+  parameters: z.array(EndpointParameters).nullish(),
+  requestBody: z.object({
+    required: z.boolean(),
+    content: z.object({
+      "application/json": z.object({
+        schema: Schema.nullish()
+      })
+    }).nullish()
+  }).nullish()
+});
+const Operation = z.object({
+  get: Endpoint.nullish(),
+  post: Endpoint.nullish(),
+  patch: Endpoint.nullish(),
+  delete: Endpoint.nullish(),
+  put: Endpoint.nullish()
+});
+const Paths = z.record(Operation);
+z.object({
+  paths: Paths,
+  definitions: Definitions,
+  basePath: z.string(),
+  info: z.object({
+    description: z.string(),
+    title: z.string(),
+    contact: z.object({
+      name: z.string(),
+      url: z.string(),
+      email: z.string()
+    }),
+    version: z.string()
+  }),
+  schemes: z.array(z.string()).nullish(),
+  components: z.object({
+    schemas: Definitions
+  }).nullish()
+});
+
+const templateJsdocMethod = ({
+  classMethod,
+  httpMethod,
+  path,
+  pathParams,
+  bodyParams,
+  queryParams
+}) => {
   let jsdoc = "";
   let methodSignature = "";
   let newPath = path;
@@ -396,21 +507,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}))`;
       }
     }
   }
@@ -420,8 +541,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);
@@ -446,74 +567,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)
-  }
-  `;
-    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())    
+    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;
-  }
   if (!isGuardInvoked) {
     methodImpl = `${descriptionText}
       ${deprecateTag}
@@ -531,41 +608,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 };
   };
@@ -573,13 +650,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) {
@@ -588,6 +669,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(";")
@@ -629,7 +716,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);
@@ -638,9 +726,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}`,
@@ -707,11 +799,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;
   };
@@ -750,7 +842,7 @@ class CodeGenerator {
   static getPatchedDir = () => path__default.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 = {};
@@ -763,14 +855,20 @@ 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 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) {
@@ -781,15 +879,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)];
         }
       }
@@ -815,7 +937,7 @@ 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 = _.upperFirst(_.camelCase(tag));
@@ -826,8 +948,9 @@ class CodeGenerator {
       indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path__default.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.existsSync(path__default.join(DIST_DEFINITION_DIR, `${fileName}.ts`));
       if (fileExist) {
@@ -838,8 +961,8 @@ class CodeGenerator {
       ParserUtils.writeDefinitionFile(DIST_DEFINITION_DIR, fileName, buffer);
       indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path__default.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) {