@accelbyte/codegen 0.0.0-dev-20240828032938 → 0.0.0-dev-20240828055251

package/dist/accelbyte-codegen.mjs

@@ -0,0 +1,1910 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import yargs from "yargs";
+import path6 from "path";
+
+// src/CliParser.ts
+import fs from "fs";
+import * as path from "path";
+import { z } from "zod";
+var SwaggersConfig = z.array(z.array(z.string()));
+var CliParser = class _CliParser {
+  static _instance;
+  argv;
+  constructor(yargs2) {
+    this.argv = yargs2.parse();
+  }
+  static createInstance = (yargs2) => {
+    _CliParser._instance = new _CliParser(yargs2);
+    return _CliParser._instance;
+  };
+  static instance = (yargs2) => {
+    if (!_CliParser._instance && yargs2) {
+      return _CliParser.createInstance(yargs2);
+    }
+    return _CliParser._instance;
+  };
+  static getConfigPath = () => {
+    return _CliParser.instance().argv.config;
+  };
+  static getConfigFile = () => {
+    const configPath = _CliParser.getConfigPath();
+    if (!configPath) throw new Error("Missing config file");
+    const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    if (!SwaggersConfig.safeParse(config).success) {
+      throw new Error("Wrong config file format");
+    }
+    return config;
+  };
+  static getOutputPath = () => {
+    return _CliParser.instance().argv.output;
+  };
+  static getSwaggersOutputPath = () => {
+    return _CliParser.instance().argv.swaggersOutput;
+  };
+  static getResolvedSwaggersOutputPath = () => {
+    return path.resolve(_CliParser.getSwaggersOutputPath());
+  };
+  static getSnippetOutputPath = () => {
+    return _CliParser.instance().argv.snippetOutput;
+  };
+  static skipReactQuery = () => {
+    return _CliParser.instance().argv.skipReactQuery;
+  };
+};
+
+// src/CodeGenerator.ts
+import SwaggerParser from "@apidevtools/swagger-parser";
+import fs4 from "fs";
+import path4 from "path";
+
+// src/ParserUtils.ts
+import { applyPatch } from "fast-json-patch";
+import fs3 from "fs";
+import _ from "lodash";
+import path3 from "path";
+
+// src/helpers/utils.ts
+import fs2 from "fs";
+import path2 from "path";
+var capitalize = (string) => {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+};
+function isObject(o) {
+  return o instanceof Object && o.constructor === Object;
+}
+var getPermission = (endpoint) => {
+  const xSecurity = endpoint["x-security"];
+  let xSecurityPerm = void 0;
+  if (Array.isArray(xSecurity)) {
+    for (const obj of xSecurity) {
+      if (obj?.userPermissions) {
+        xSecurityPerm = obj.userPermissions;
+      }
+      if (obj?.groupPermissions) {
+        xSecurityPerm = obj.groupPermissions;
+      }
+    }
+  } else if (isObject(xSecurity)) {
+    xSecurityPerm = xSecurity?.userPermission;
+  }
+  return xSecurityPerm;
+};
+var PermissionRegex = /\[(\w+)\]/;
+var getPermissionType = (permission) => {
+  if (!permission) return null;
+  if (Array.isArray(permission)) {
+    const perm = permission?.[0];
+    if (!perm) return null;
+    const [_3, type2] = perm?.match(PermissionRegex);
+    return type2 || null;
+  }
+  const [_2, type] = permission?.match(PermissionRegex);
+  return type || null;
+};
+var removeAdminPrefix = (name) => name.startsWith("Admin") && name !== "Admin" ? name.replace(/^Admin/, "") : name;
+function extractDescription(description, options) {
+  return description ? `
+  /**${options?.isDeprecated ? "\n   * @deprecated" : ""}
+   * ${description.replace(/\*\//g, "*\\/").replace(/\n/g, "\n   * ")} 
+   */` : "";
+}
+
+// src/templates/template-class.ts
+var getImportableVarMap = () => ({
+  "@accelbyte/sdk": ["CodeGenUtil", "Response", "Validate", "SdkSetConfigParam"],
+  axios: ["AxiosResponse"],
+  zod: ["z"]
+});
+var makeNewImportVarMap = () => ({
+  axios: ["AxiosInstance", "AxiosRequestConfig"],
+  "@accelbyte/sdk": ["SDKRequestConfig"]
+});
+var generateImports = (body, importStatements, makeNewImportVarMap3, getImportableVarMap3) => {
+  const usedImportVarMap = makeNewImportVarMap3;
+  const importableVarMap = getImportableVarMap3;
+  for (const [moduleSource, importableVars] of Object.entries(importableVarMap)) {
+    for (const importableVar of importableVars) {
+      const importVarRegex = new RegExp(`(?<![\\d\\w_])${importableVar}(?![\\d\\w_])`);
+      if (body.match(importVarRegex)) {
+        usedImportVarMap[moduleSource] = [...usedImportVarMap[moduleSource] || [], importableVar];
+      }
+    }
+  }
+  const generatedImports = Object.keys(usedImportVarMap).sort().map((moduleSource) => {
+    return `import { ${usedImportVarMap[moduleSource].sort().join(", ")} } from '${moduleSource}'`;
+  }).join("\n");
+  return `${generatedImports}
+${importStatements.sort().join("\n")}`;
+};
+var templateClass = (className, body, importStatements) => {
+  return `/**
+ * AUTO GENERATED
+ */
+${generateImports(body, importStatements, makeNewImportVarMap(), getImportableVarMap())}
+
+export class ${className} {
+  // @ts-ignore
+  // prettier-ignore
+  constructor(private axiosInstance: AxiosInstance, private namespace: string, private useSchemaValidation = true) {}
+  ${body}
+}
+  `;
+};
+
+// src/templates/template-api-class.ts
+var getImportableVarMap2 = () => ({
+  "@accelbyte/sdk": ["CodeGenUtil", "Response", "Validate", "SdkSetConfigParam", "Network", "AccelByteSDK"],
+  axios: ["AxiosDefaults", "HeadersDefaults"]
+});
+var makeNewImportVarMap2 = () => ({
+  "@accelbyte/sdk": ["AccelByteSDK", "SdkSetConfigParam", "ApiUtils", "Network"],
+  axios: ["AxiosResponse"]
+});
+var templateApiClass = (className, body, importStatements, returnMethods) => {
+  const $className = className.replace(/Api$/, "$");
+  return `/**
+ * AUTO GENERATED
+ */
+/* eslint-disable camelcase */
+// @ts-ignore -> ts-expect-error TS6133
+${generateImports(body, importStatements, makeNewImportVarMap2(), getImportableVarMap2())}
+${`import { ${$className} } from './endpoints/${$className}.js'
+`}
+
+export function ${className}(sdk: AccelByteSDK, args?: SdkSetConfigParam) {
+  const sdkAssembly = sdk.assembly()
+  
+  const namespace = args?.coreConfig?.namespace ?? sdkAssembly.coreConfig.namespace
+  const requestConfig = ApiUtils.mergeAxiosConfigs(sdkAssembly.axiosConfig.request, args?.axiosConfig?.request)
+  const interceptors = args?.axiosConfig?.interceptors ?? sdkAssembly.axiosConfig.interceptors ?? []
+  const useSchemaValidation = sdkAssembly.coreConfig.useSchemaValidation
+  const axiosInstance = Network.create(requestConfig)
+  
+  for (const interceptor of interceptors) {
+    if(interceptor.type === 'request') {
+      axiosInstance.interceptors.request.use(interceptor?.onRequest, interceptor.onError)
+    }
+
+    if(interceptor.type === 'response') {
+      axiosInstance.interceptors.response.use(interceptor?.onSuccess, interceptor.onError)
+    }
+  }
+
+  ${body}
+  
+  return {
+    ${returnMethods}
+  }
+}
+  `;
+};
+
+// src/ParserQueryUtils.ts
+var ParserQueryUtils = class {
+  /**
+   * convert csv 'aa,bb' into "aa='aa', bb='bb'"
+   */
+  static createQueryKeys(classNameWithoutApi, csvMethodNames, sdkName) {
+    const keys = csvMethodNames.split(",");
+    const processedKeys = /* @__PURE__ */ new Set();
+    const enumString = keys.reduce((acc, key, index) => {
+      const trimmedKey = key.trim();
+      if (trimmedKey) {
+        const cleanedKey = trimmedKey.replace(/^(get|update|create|patch|delete|post|fetch)[_]?/, "");
+        if (!processedKeys.has(cleanedKey)) {
+          processedKeys.add(cleanedKey);
+          acc += `${cleanedKey} = '${capitalize(sdkName)}.${classNameWithoutApi}.${cleanedKey}'`;
+          if (index < keys.length - 1) {
+            acc += ",\n";
+          }
+        }
+      }
+      return acc;
+    }, "");
+    return enumString;
+  }
+};
+
+// src/templates/template-query.ts
+var generateImports2 = (body, className) => {
+  const generatedImports = `import { AccelByteSDK, SdkSetConfigParam, ApiError } from '@accelbyte/sdk'
+import { AxiosError, AxiosResponse } from 'axios'
+// @ts-ignore
+import { useQuery, UseQueryOptions, UseQueryResult, useMutation, UseMutationOptions, UseMutationResult } from '@tanstack/react-query'
+import { ${className} } from "../${className}.js"
+`;
+  return generatedImports;
+};
+var templateQuery = (className, body, importStatements, serviceNameTitle, returnMethods, paramImports, sdkName) => {
+  const classNameWithoutApi = className.replace("Api", "");
+  const queryKeys = ParserQueryUtils.createQueryKeys(classNameWithoutApi, returnMethods, sdkName);
+  const generatedImports = generateImports2(body, className);
+  return `/**
+ * AUTO GENERATED
+ */
+/* eslint-disable camelcase */
+${generatedImports}
+${filterUsedImports(paramImports, body)}
+
+export enum Key_${classNameWithoutApi} {
+  ${queryKeys}
+}
+
+  ${body}
+  `;
+};
+function filterUsedImports(importArr, body) {
+  return importArr.filter((path7) => {
+    const start = path7.indexOf("{") + 1;
+    const end = path7.indexOf("}");
+    if (start > 0 && end > start) {
+      const importName = path7.slice(start, end).trim();
+      return body.includes(importName);
+    }
+    return false;
+  }).map((path7) => path7).join("\n") + "\n";
+}
+
+// src/ParserUtils.ts
+var REMOVED_KEYWORDS = [
+  "/admin/",
+  "/public/",
+  "/v1/",
+  "/v2/",
+  "/v3/",
+  "/v4/",
+  "/v5/",
+  "/namespace/",
+  "/namespaces/",
+  "/{namespace}/"
+];
+var ParserUtils = class _ParserUtils {
+  static getVersionSuffixFromPath(path7) {
+    const version2_3_4_etc = path7.match(/\/v([2-9]|[1-9]\d+)\/+/);
+    const methodSuffix = version2_3_4_etc ? `_v${version2_3_4_etc[1]}` : "";
+    return methodSuffix;
+  }
+  static replaceAll = (text, search, replace) => {
+    return text.split(search).join(replace);
+  };
+  static generateClassName = (tag, isAdmin) => {
+    const className = _.upperFirst(_.camelCase(tag));
+    const formattedApiName = removeAdminPrefix(className);
+    const classGenName = isAdmin ? formattedApiName + "Admin$" : formattedApiName + "$";
+    return { className: formattedApiName, classGenName };
+  };
+  static generateApiName = (tag, isAdmin) => {
+    const apiName = _.upperFirst(_.camelCase(tag));
+    const formattedApiName = removeAdminPrefix(apiName);
+    const apiGenName = isAdmin ? formattedApiName + "AdminApi" : formattedApiName + "Api";
+    return { apiName, apiGenName };
+  };
+  static parseQueryParamAttributeDefault = (definition) => {
+    const attrName = definition.name.slice(definition.name.lastIndexOf(".") + 1);
+    let defaultValue = definition.default;
+    if (definition.type === "array" && Array.isArray(definition.default)) {
+      const mappedDefaultValue = definition.default.map(
+        (defaultValue2) => typeof defaultValue2 === "string" ? `'${defaultValue2}'` : defaultValue2
+      );
+      defaultValue = `[${mappedDefaultValue.join(", ")}]`;
+    }
+    if (definition.type === "string") {
+      defaultValue = `'${definition.default}'`;
+    }
+    return `${attrName}: ${defaultValue}`;
+  };
+  static parseType = (pathParam) => {
+    if (isSwaggerIntegerType(pathParam.type || pathParam?.schema?.type)) return "number";
+    if (pathParam.type === "array") {
+      if (isSwaggerIntegerType(pathParam.items.type)) return "number[]";
+      return `${pathParam.items.type ?? "any"}[]`;
+    }
+    if (pathParam?.schema?.type === "array") {
+      if (isSwaggerIntegerType(pathParam.schema.items.type)) return "number[]";
+      return `${pathParam.schema.items.type ?? "any"}[]`;
+    }
+    if (pathParam?.schema?.type) return pathParam.schema.type;
+    return pathParam.type;
+  };
+  static parseQueryParamsType = (queryParams) => {
+    const result = queryParams.map((queryParam) => _ParserUtils.parseAttributeType(queryParam)).join(", ");
+    return result;
+  };
+  static isAnyQueryParamRequired = (queryParams) => {
+    return queryParams.some((queryParam) => queryParam.required);
+  };
+  static convertDashesToTitleCase = (str) => {
+    const result = str.split("-").map((word, index) => {
+      if (index === 0) {
+        return word.charAt(0).toUpperCase() + word.slice(1);
+      }
+      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    }).join("");
+    return result;
+  };
+  static parseQueryParamsDefault = (queryParams) => {
+    const result = queryParams.filter((queryParam) => !!queryParam.default && !queryParam.required).map(_ParserUtils.parseQueryParamAttributeDefault).join(",");
+    return result ? `${result},` : "";
+  };
+  static parseBodyParamsImports = (bodyParams) => {
+    return bodyParams.map((bodyParams2) => _ParserUtils.parseRefImport(bodyParams2)).filter(Boolean);
+  };
+  static parseImportDir = ($ref) => {
+    let ref = $ref.replace(".", "/");
+    if (ref[ref.length - 1] === "." || ref[ref.length - 1] === "/") {
+      ref = ref.slice(0, -1);
+    }
+    if (!ref.includes("/")) {
+      return "";
+    } else {
+      return ref.slice(0, ref.lastIndexOf("/")).replace("#", ".");
+    }
+  };
+  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 '../../generated-definitions/${type}.js'`;
+  };
+  static parseRefType = ($ref) => {
+    let ref = $ref.replace(".", "/");
+    if (ref[ref.length - 1] === "." || ref[ref.length - 1] === "/") {
+      ref = ref.slice(0, -1);
+    }
+    const val = ref.slice(ref.lastIndexOf("/") + 1);
+    return _.upperFirst(_.camelCase(val)).replace(/( \w)/g, (group) => group.replace(" ", "").toUpperCase());
+  };
+  static parseAttributeType = (definition) => {
+    const required = definition.required ? "" : "?";
+    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 && _ParserUtils.parseType(definition) === "number") {
+      return `${attrName}${required}: number`;
+    }
+    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 === "file") {
+      return `${attrName}${required}: File`;
+    }
+    if (definition?.schema?.type && definition.schema.type === "file") {
+      return `${attrName}${required}: File`;
+    }
+    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 [bodyParam] = bodyParams;
+    if (!bodyParam) return null;
+    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 (bodyParam?.schema?.type === "array" && !bodyParam?.schema?.items?.$ref) {
+      if (isSwaggerIntegerType(bodyParam.schema.items.type)) return "number[]";
+      return `${bodyParam.schema.items.type ?? "any"}[]`;
+    }
+    if (bodyParam?.schema?.type === "array" && bodyParam?.schema?.items?.$ref) {
+      return `${_ParserUtils.parseRefType(bodyParam.schema.items.$ref)}[]`;
+    }
+    if (bodyParam?.schema?.$ref) {
+      return _ParserUtils.parseRefType(bodyParam.schema.$ref);
+    }
+    if (bodyParam?.schema?.additionalProperties?.type === "object") {
+      return "any";
+    }
+    return null;
+  };
+  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 {
+        }
+      }
+    });
+    return responseClass;
+  }
+  static isFormUrlEncoded(httpMethod, contentTypes) {
+    if (!contentTypes || contentTypes.length < 1) {
+      return false;
+    }
+    if (!["post", "put", "patch"].includes(httpMethod)) {
+      return false;
+    }
+    return contentTypes.includes("application/x-www-form-urlencoded");
+  }
+  static filterPathParams(parameters) {
+    if (!parameters) {
+      return [];
+    }
+    return parameters.filter((parameter) => parameter.in === "path");
+  }
+  /**
+   * This method converts this
+   * POST `/gdpr/public/namespaces/{namespace}/users/{userId}/requests/{requestDate}/generate`
+   *
+   * to this
+   * `createGenerateByRequestIdByUserId`
+   */
+  static generateNaturalLangMethod = ({ servicePrefix, path: path7, httpMethod, isForm, existingMethods, permissionType }) => {
+    let path_ = path7;
+    path_ = path_.replace(`/${servicePrefix}/`, "/");
+    REMOVED_KEYWORDS.forEach((prefix) => {
+      path_ = path_.replace(prefix, "/");
+    });
+    path_ = path_.substring(1);
+    const isPlural = httpMethod === "get" && !(path7.slice(-1) === "}");
+    if (!isPlural) {
+      path_ = _ParserUtils.replaceAll(path_, "ies/", "y/");
+      path_ = _ParserUtils.replaceAll(path_, "s/", "/");
+      if (path_.indexOf("status") < 0) {
+        path_ = path_.replace(/ies$/, "y");
+        path_ = path_.replace(/s$/, "");
+      }
+    }
+    const arrLastWords = path_.split("}/");
+    let lastWords = arrLastWords[arrLastWords.length - 1];
+    const extractLastWord = (lastWords_) => {
+      let res = lastWords_;
+      res = res.split("/{")[0];
+      return res;
+    };
+    lastWords = extractLastWord(lastWords);
+    if (lastWords.indexOf("{") >= 0 && arrLastWords.length > 1) {
+      lastWords = arrLastWords[arrLastWords.length - 2];
+      lastWords = extractLastWord(lastWords);
+    }
+    const listBeforeLastWords = [];
+    let foundParam = false;
+    const listByParams = [];
+    const pathElements = path_.split("/");
+    pathElements.slice().reverse().forEach((item) => {
+      if (item.indexOf("}") >= 0) {
+        foundParam = true;
+        let param = item.replace("{", "");
+        param = param.replace("}", "");
+        param = "Byword" + _.upperFirst(param);
+        listByParams.push(param);
+      } else if (!foundParam) {
+        if (lastWords.indexOf(item) === -1) {
+          listBeforeLastWords.push(item);
+        }
+      } else {
+        foundParam = false;
+      }
+    });
+    const genPath = _.upperFirst(lastWords) + "/" + listBeforeLastWords.join("/") + listByParams.reverse().join("/");
+    let generatedMethod = _.camelCase(mappedMethod(httpMethod, isForm, permissionType) + genPath);
+    generatedMethod = _ParserUtils.replaceAll(generatedMethod, "Byword", "_By");
+    const testedGeneratedMethod = generatedMethod + _ParserUtils.getVersionSuffixFromPath(path7);
+    generatedMethod = resolveConflicts({ path: path7, generatedMethod, testedGeneratedMethod, existingMethods });
+    generatedMethod = generatedMethod + _ParserUtils.getVersionSuffixFromPath(path7);
+    return generatedMethod;
+  };
+  static filterBodyParams(parameters) {
+    if (Array.isArray(parameters) && parameters.length > 0) {
+      return parameters.filter((parameter) => parameter.in === "body" || parameter.in === "formData");
+    }
+    return [];
+  }
+  static filterQueryParameters(parameters) {
+    if (!parameters) {
+      return [];
+    }
+    return parameters.filter((parameter) => parameter.in === "query");
+  }
+  static mkdirIfNotExist(dirToCreate) {
+    if (!fs3.existsSync(dirToCreate)) {
+      fs3.mkdirSync(dirToCreate, { recursive: true });
+    }
+  }
+  static writeClassFile(distDir, apiName, apiBuffer, imports) {
+    const fileContent = templateClass(apiName, apiBuffer, imports);
+    fs3.writeFileSync(`${distDir}/${apiName}.ts`, _ParserUtils.prependCopyrightHeader(fileContent));
+  }
+  static writeAtomFile(distDir, apiName, fileContent) {
+    _ParserUtils.mkdirIfNotExist(distDir);
+    fs3.writeFileSync(`${distDir}/${apiName}.atom.ts`, _ParserUtils.prependCopyrightHeader(fileContent));
+  }
+  static writeQueryFile(distDir, apiName, apiBuffer, imports, serviceNameTitle, returnMethods, paramImports, sdkName) {
+    if (apiBuffer.length < 1) {
+      return null;
+    }
+    const queryFileName = `${apiName.replace("Api", "")}.query`;
+    _ParserUtils.mkdirIfNotExist(distDir);
+    const fileContent = templateQuery(apiName, apiBuffer, imports, serviceNameTitle, returnMethods, paramImports, sdkName);
+    fs3.writeFileSync(`${distDir}/${queryFileName}.ts`, _ParserUtils.prependCopyrightHeader(fileContent));
+    return queryFileName;
+  }
+  static writeXVersion(distDir, xversionJson, apiInfo) {
+    if (xversionJson) {
+      console.log("x-version:", xversionJson);
+      fs3.writeFileSync(`${distDir}/version.json`, JSON.stringify(xversionJson, null, 2));
+    } else {
+      const customVersion = {
+        ...apiInfo,
+        gitHash: apiInfo.version
+      };
+      console.error(`!!!! Missing x-version for ${distDir} ${customVersion}`);
+      fs3.writeFileSync(`${distDir}/version.json`, JSON.stringify(customVersion, null, 2));
+    }
+  }
+  static writeApiFile(distDir, apiName, apiBuffer, imports, returnMethods) {
+    const newImports = [];
+    imports.forEach((el) => {
+      newImports.push(el.replace("../../generated-definitions", "../generated-definitions"));
+    });
+    const fileContent = templateApiClass(apiName, apiBuffer, newImports, returnMethods);
+    fs3.writeFileSync(`${distDir}/${apiName}.ts`, _ParserUtils.prependCopyrightHeader(fileContent));
+  }
+  static writeApiMainFile(distDir, serviceName, fileContent) {
+    fs3.writeFileSync(`${distDir}/${serviceName}.ts`, _ParserUtils.prependCopyrightHeader(fileContent));
+  }
+  static writeSnippetFile(distDir, name, docBuffer) {
+    let snippetFileName = _ParserUtils.replaceAll(name, " ", "-").toLowerCase();
+    snippetFileName = snippetFileName.replace("justice-", "");
+    snippetFileName = "snippet-" + snippetFileName + ".json";
+    fs3.writeFileSync(`${distDir}/${snippetFileName}`, docBuffer);
+  }
+  static writeDefinitionFile(distDir, name, buffer) {
+    _ParserUtils.mkdirIfNotExist(distDir);
+    fs3.writeFileSync(path3.join(distDir, `${name}.ts`), _ParserUtils.prependCopyrightHeader(buffer));
+  }
+  static writeAllImportsFile(distDir, buffer) {
+    _ParserUtils.mkdirIfNotExist(distDir);
+    fs3.writeFileSync(path3.join(distDir, "all-imports.ts"), _ParserUtils.prependCopyrightHeader(buffer));
+  }
+  static writeAllQueryImportsFile(distDir, buffer) {
+    _ParserUtils.mkdirIfNotExist(distDir);
+    fs3.writeFileSync(path3.join(distDir, "all-query-imports.ts"), _ParserUtils.prependCopyrightHeader(buffer));
+  }
+  static toCamelCase(str) {
+    return str.split("/").map(function(word, index) {
+      if (index === 0) {
+        return word.toLowerCase();
+      }
+      return _ParserUtils.toCamelCaseWord(word);
+    }).join("");
+  }
+  static toCamelCaseWord(word) {
+    if (!word) {
+      return "";
+    }
+    word = word.replace(/(-\w)/g, (m) => m[1].toUpperCase());
+    return word.charAt(0).toUpperCase() + word.slice(1);
+  }
+  static toTitleCaseWord(word) {
+    if (!word) {
+      return "";
+    }
+    return word.replace(/\w\S*/g, (txt) => {
+      return txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase();
+    });
+  }
+  static applyPatchIfExists(swaggerFilePath, possibleSwaggerPatchFilePath, swaggerPatchedFilePath, swaggerPatchedDir) {
+    if (!fs3.existsSync(swaggerPatchedDir)) {
+      fs3.mkdirSync(swaggerPatchedDir, { recursive: true });
+    }
+    if (!fs3.existsSync(possibleSwaggerPatchFilePath)) {
+      fs3.copyFileSync(swaggerFilePath, swaggerPatchedFilePath);
+      return;
+    }
+    const swaggerContent = JSON.parse(fs3.readFileSync(swaggerFilePath, "utf8"));
+    const swaggerPatchFileContent = JSON.parse(fs3.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);
+    fs3.writeFileSync(swaggerPatchedFilePath, JSON.stringify(newDocument, null, 2));
+  }
+  static getRelativePathToWebSdkSrcFolder(srcFolder, targetSrcFolder) {
+    const replaced = srcFolder.replace(/\\/g, "/");
+    return replaced.replace(/\\/g, "/").replace(targetSrcFolder, "./");
+  }
+  static prependCopyrightHeader = (content) => {
+    const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+    return `/* 
+ * Copyright (c) 2022${currentYear > 2022 ? `-${currentYear}` : ""} AccelByte Inc. All Rights Reserved
+ * This is licensed software from AccelByte Inc, for limitations
+ * and restrictions contact your company contract manager.
+ */
+${content}`;
+  };
+  static sortPathParamsByPath = (pathParams, path7) => {
+    const params = path7.match(/{\w*}/g) || [];
+    const cleanParams = params.map((param) => param.replace("{", "").replace("}", ""));
+    return pathParams.sort((a, b) => cleanParams.indexOf(a.name) - cleanParams.indexOf(b.name));
+  };
+};
+var mappedMethod = (httpMethod, isForm, permissionType) => {
+  if (httpMethod === "get") {
+    return "get";
+  } else if (httpMethod === "post" && isForm) {
+    return "post";
+  } else if (httpMethod === "post" && permissionType === "READ") {
+    return "fetch";
+  } else if (httpMethod === "post" && permissionType === "UPDATE") {
+    return "update";
+  } else if (httpMethod === "post") {
+    return "create";
+  } else if (httpMethod === "put") {
+    return "update";
+  } else if (httpMethod === "patch") {
+    return "patch";
+  } else if (httpMethod === "delete") {
+    return "delete";
+  }
+};
+var resolveConflicts = ({ path: path7, generatedMethod, testedGeneratedMethod, existingMethods }) => {
+  let _testedGenMethod = testedGeneratedMethod;
+  try {
+    testConflict(path7, _testedGenMethod, existingMethods);
+  } catch (e) {
+    if (path7.indexOf("/namespaces/") >= 0) {
+      generatedMethod += "_ByNS";
+      _testedGenMethod += "_ByNS";
+    }
+  }
+  try {
+    testConflict(path7, _testedGenMethod, existingMethods);
+  } catch (e) {
+    if (path7.indexOf("/admin/") >= 0) {
+      generatedMethod += "_admin";
+      _testedGenMethod += "_admin";
+    }
+  }
+  testConflict(path7, _testedGenMethod, existingMethods);
+  return generatedMethod;
+};
+var testConflict = (path7, generatedMethod, existingMethods) => {
+  if (existingMethods[generatedMethod]) {
+    const conflictingMethod = { path: path7, generatedMethod };
+    throw Error(
+      `Duplicate method conflict in ${JSON.stringify(conflictingMethod)},
+ existingMethods: ${JSON.stringify(existingMethods, null, 2)}`
+    );
+  }
+};
+var isSwaggerIntegerType = (type) => {
+  return type === "integer" || type === "int";
+};
+
+// src/Swagger.ts
+import { z as z2 } from "zod";
+var Schema = z2.object({
+  $ref: z2.string().nullish(),
+  type: z2.union([z2.literal("array"), z2.literal("object"), z2.literal("file"), z2.literal("string"), z2.literal("boolean"), z2.literal("integer")]).nullish(),
+  items: z2.object({
+    $ref: z2.string().nullish(),
+    type: z2.string().nullish()
+  }).nullish(),
+  properties: z2.union([z2.array(z2.string()).nullish(), z2.record(z2.object({ type: z2.string() })).nullish()]),
+  description: z2.string().nullish(),
+  additionalProperties: z2.object({
+    type: z2.string().nullish()
+  }).nullish()
+});
+var Definition = z2.object({
+  required: z2.array(z2.string()).nullish(),
+  properties: z2.record(
+    z2.object({
+      type: z2.string()
+    })
+  ).nullish()
+});
+var Definitions = z2.record(Definition);
+var EndpointParametersType = z2.enum(["apiKey", "boolean", "int", "integer", "number", "string", "array", "file"]);
+var EndpointParametersIn = z2.enum(["body", "formData", "header", "path", "query"]);
+var EndpointParameters = z2.object({
+  type: EndpointParametersType.nullish(),
+  description: z2.string().nullish(),
+  name: z2.string(),
+  in: EndpointParametersIn,
+  required: z2.boolean().nullish(),
+  schema: Schema.nullish(),
+  default: z2.union([z2.boolean(), z2.string(), z2.number(), z2.array(z2.any())]).nullish(),
+  enum: z2.array(z2.union([z2.boolean(), z2.string(), z2.number()])).nullish(),
+  items: z2.object({
+    type: z2.string(),
+    enum: z2.array(z2.any()).nullish()
+  }).nullish()
+});
+var Endpoint = z2.object({
+  description: z2.string().nullish(),
+  consumes: z2.array(z2.string()).nullish(),
+  produces: z2.array(z2.string()).nullish(),
+  tags: z2.array(z2.string()).nullish(),
+  summary: z2.string().nullish(),
+  operationId: z2.string(),
+  deprecated: z2.boolean().nullish(),
+  responses: z2.record(
+    z2.object({
+      description: z2.string().nullish(),
+      schema: Schema.nullish(),
+      content: z2.object({
+        "application/json": z2.object({
+          schema: Schema.nullish()
+        })
+      }).nullish()
+    })
+  ),
+  parameters: z2.array(EndpointParameters).nullish(),
+  requestBody: z2.object({
+    required: z2.boolean().nullish(),
+    content: z2.object({
+      "application/json": z2.object({
+        schema: Schema.nullish()
+      }).nullish()
+    }).nullish()
+  }).nullish(),
+  // The proper type is z.array(z.record(z.array(z.string()))).nullish() but somehow there are endpoints with
+  // an object type instead of an array type, so, yeah.
+  //
+  // Services with this error: sdk-iam, sdk-ugc.
+  "x-security": z2.any().nullish()
+});
+var Operation2 = z2.object({
+  get: Endpoint.nullish(),
+  post: Endpoint.nullish(),
+  patch: Endpoint.nullish(),
+  delete: Endpoint.nullish(),
+  put: Endpoint.nullish()
+});
+var Paths = z2.record(Operation2);
+var OpenApiSpec = z2.object({
+  paths: Paths,
+  definitions: Definitions,
+  basePath: z2.string(),
+  info: z2.object({
+    description: z2.string(),
+    title: z2.string(),
+    contact: z2.object({
+      name: z2.string(),
+      url: z2.string(),
+      email: z2.string()
+    }),
+    version: z2.string()
+  }),
+  schemes: z2.array(z2.string()).nullish(),
+  components: z2.object({
+    schemas: Definitions
+  }).nullish()
+});
+
+// src/templates/template-api-method.ts
+var templateApiMethod = ({
+  classMethod,
+  description,
+  httpMethod,
+  path: path7,
+  pathParams,
+  bodyParams,
+  responseClass,
+  classGenName,
+  methodParams,
+  methodParamsNoTypes,
+  deprecated,
+  xSecurity
+}) => {
+  let newPath = `'${path7}'`;
+  let snippetMethod = "";
+  for (const pathParam of pathParams) {
+    const type = ParserUtils.parseType(pathParam);
+    const pName = pathParam.name === "namespace" ? "this.namespace" : pathParam.name;
+    if (path7.match(`{${pathParam.name}}`)) {
+      if (type === "string") {
+        newPath = `${newPath}.replace('{${pathParam.name}}', ${pName})`;
+      } else {
+        newPath = `${newPath}.replace('{${pathParam.name}}', String(${pName}))`;
+      }
+    }
+  }
+  const snippetShellArgs = ["--location --request", `${httpMethod} '__DOMAIN__${path7}'`, "--header 'accept: application/json'"];
+  const snippetApiArgs = [];
+  if (xSecurity !== void 0 || path7.includes("/admin")) {
+    snippetShellArgs.push("--header 'Authorization: Bearer {access_token}'");
+    snippetApiArgs.push("{ config: { headers: { Authorization: 'Bearer {access_token}' }  }}".trim());
+  }
+  if (httpMethod !== "get") {
+    const curlParams = bodyParams?.map((ob) => {
+      return ` "${ob.name}": ""`;
+    });
+    if (curlParams.length > 0) {
+      snippetShellArgs.push(`--data-raw '{ ${curlParams}}'`);
+    }
+  }
+  const snippetShell = `curl ${snippetShellArgs.join(" \\\n    ")}`;
+  const descriptionText = extractDescription(description, { isDeprecated: deprecated });
+  const resolvedResponseClass = responseClass || "unknown";
+  const responseType = resolvedResponseClass !== "unknown" ? `${resolvedResponseClass}` : "unknown";
+  const methodImpl = `
+  ${descriptionText}
+  async function ${classMethod}(${methodParams}): Promise<AxiosResponse<${responseType}>> {
+    const $ = new ${classGenName}(axiosInstance, namespace, useSchemaValidation)
+    const resp = await $.${classMethod}(${methodParamsNoTypes})
+    if (resp.error) throw resp.error
+    return resp.response
+  }
+  `;
+  const snippetPromiseString = responseType !== "unknown" ? `Promise<${responseType}>` : "Promise";
+  snippetMethod += `${classMethod}(${methodParams}) 
+   // return ${snippetPromiseString}`;
+  return {
+    generatedMethodString: methodImpl,
+    snippetApiArgs,
+    snippetMethod,
+    snippetShell
+  };
+};
+
+// src/templates/template-method.ts
+var templateMethod = ({
+  classMethod,
+  description,
+  httpMethod,
+  path: path7,
+  pathParams,
+  bodyParams,
+  queryParams,
+  isFormUrlEncoded,
+  responseClass,
+  deprecated
+}) => {
+  let methodParams = "";
+  let methodParamsNoTypes = "";
+  let newPath = `'${path7}'`;
+  let importStatements = [];
+  const sortedPathParams = ParserUtils.sortPathParamsByPath(pathParams, path7);
+  for (const pathParam of sortedPathParams) {
+    const type = ParserUtils.parseType(pathParam);
+    if (pathParam.name !== "namespace") {
+      methodParams += pathParam.name + `:${type}, `;
+      methodParamsNoTypes += pathParam.name + ", ";
+    }
+    const pName = pathParam.name === "namespace" ? "this.namespace" : pathParam.name;
+    if (path7.match(`{${pathParam.name}}`)) {
+      if (type === "string") {
+        newPath = `${newPath}.replace('{${pathParam.name}}', ${pName})`;
+      } else {
+        newPath = `${newPath}.replace('{${pathParam.name}}', String(${pName}))`;
+      }
+    }
+  }
+  let dataType = null;
+  if (httpMethod !== "get") {
+    dataType = ParserUtils.parseBodyParamsType(bodyParams);
+    importStatements = ParserUtils.parseBodyParamsImports(bodyParams);
+    methodParams += dataType ? `data: ${dataType},` : "";
+    methodParamsNoTypes += dataType ? `data,` : "";
+  }
+  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 AxiosRequestConfig` : "const params = {} as AxiosRequestConfig";
+  const isPostPutPatch = ["post", "put", "patch"].includes(httpMethod);
+  const isDelete = ["delete"].includes(httpMethod);
+  let dataPayload = "{params}";
+  const descriptionText = extractDescription(description, { isDeprecated: deprecated });
+  let formPayloadString = "";
+  if (isFormUrlEncoded) {
+    formPayloadString = ``;
+    const params = "{ ...params, headers: { ...params.headers, 'content-type': 'application/x-www-form-urlencoded' } }";
+    dataPayload = dataType ? `CodeGenUtil.getFormUrlEncodedData(data), ${params}` : `null, ${params}`;
+  } else if (isPostPutPatch) {
+    dataPayload = dataType ? `data, {params}` : "null, {params}";
+  } else if (isDelete) {
+    dataPayload = dataType ? `{data, params}` : "{params}";
+  }
+  const isFileUpload = methodParams.indexOf("data: {file") > -1;
+  const resolvedResponseClass = responseClass || "unknown";
+  const resolvedResponseClassValidated = responseClass || "z.unknown()";
+  methodParams = (queryParamsType ? `${methodParams} ${queryParamsType}` : methodParams).replace(/,\s*$/, "");
+  methodParamsNoTypes = queryParamsType ? `${methodParamsNoTypes} queryParams` : methodParamsNoTypes;
+  const isGuardInvoked = ["get", "post", "put", "patch", "delete"].includes(httpMethod);
+  const responseType = resolvedResponseClass !== "unknown" ? `${resolvedResponseClass}` : "unknown";
+  const responseSyncType = "Response";
+  const generatedMethodName = `${classMethod}(${methodParams}): Promise<${responseSyncType}<${responseType}>>`;
+  let methodImpl = `${descriptionText}
+  ${generatedMethodName} {
+    ${queryParamsDefault}
+    const url = ${newPath}    ${formPayloadString} ${isFileUpload ? "\n// TODO file upload not implemented" : ""}
+    const resultPromise = this.axiosInstance.${httpMethod}(url, ${dataPayload})
+
+${`    return Validate.validateOrReturnResponse(this.useSchemaValidation, () => resultPromise, ${resolvedResponseClassValidated}, '${resolvedResponseClassValidated}')`}
+  }
+  `;
+  if (!isGuardInvoked) {
+    methodImpl = ``;
+  }
+  const res = {
+    methodImpl,
+    methodParams,
+    methodParamsNoTypes,
+    importStatements
+  };
+  return res;
+};
+
+// src/templates/template-query-method.ts
+var POST_FETCH_INCLUDES_PATH = ["/table-query/"];
+var templateQueryMethod = ({
+  classMethod,
+  httpMethod,
+  path: path7,
+  pathParams,
+  responseClass,
+  methodParams,
+  apiGenName
+}) => {
+  const isPostFetch = httpMethod === "post" && (POST_FETCH_INCLUDES_PATH.some((p) => path7.includes(p)) || path7.endsWith("/list"));
+  const isFetch = classMethod.startsWith("fetch");
+  const isGet = httpMethod === "get" || isPostFetch || isFetch;
+  const queryMethod = isGet ? "useQuery" : "useMutation";
+  let mParams = "";
+  let mParamsNoTypes = "";
+  let newPath = `'${path7}'`;
+  const sortedPathParams = ParserUtils.sortPathParamsByPath(pathParams, path7);
+  for (const pathParam of sortedPathParams) {
+    const type = ParserUtils.parseType(pathParam);
+    if (pathParam.name !== "namespace") {
+      mParams += pathParam.name + `:${type}, `;
+      mParamsNoTypes += pathParam.name + ", ";
+    }
+    const pName = pathParam.name === "namespace" ? "this.namespace" : pathParam.name;
+    if (path7.match(`{${pathParam.name}}`)) {
+      if (type === "string") {
+        newPath = `${newPath}.replace('{${pathParam.name}}', ${pName})`;
+      } else {
+        newPath = `${newPath}.replace('{${pathParam.name}}', String(${pName}))`;
+      }
+    }
+  }
+  const resolvedResponseClass = responseClass || "unknown";
+  let _methodName = convertMethodNameToHook({ classMethod, apiGenName, isPostFetch, isFetch });
+  const _responseType = resolvedResponseClass !== "unknown" ? `${resolvedResponseClass}` : "unknown";
+  const _methodParams = methodParams && methodParams.length > 0 ? `& { ${methodParams} }` : "";
+  const _methodParamsImpl = convertToMethodImplArgs(methodParams);
+  const queryMethodImpl = `
+
+export const ${_methodName} = (
+    sdk: AccelByteSDK,
+    input: SdkSetConfigParam ${_methodParams},
+    options?: Omit<UseQueryOptions<${_responseType}, AxiosError<ApiError>>, 'queryKey'>,
+    callback?: (data: AxiosResponse<${_responseType}>) => void
+  ): UseQueryResult<${_responseType}, AxiosError<ApiError>> => { 
+  //
+  const queryFn = (
+  sdk: AccelByteSDK, 
+  input: Parameters<typeof ${_methodName}>[1]
+  ) => async () => {
+      const response = 
+            (await ${apiGenName}(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).
+                ${classMethod}(${_methodParamsImpl}))
+      callback && callback(response)
+      return response.data
+  }
+  
+  return ${queryMethod}<${_responseType}, AxiosError<ApiError>>({
+    queryKey: [${createQueryKey(apiGenName, classMethod)}, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  })
+}
+  
+  `;
+  const mutationMethodImpl = `
+
+export const ${_methodName} = (
+    sdk: AccelByteSDK,
+    options?: Omit<UseMutationOptions<${_responseType}, AxiosError<ApiError>, SdkSetConfigParam ${_methodParams}>, 'mutationKey'>,
+    callback?: (data: ${_responseType}) => void
+  ): UseMutationResult<${_responseType}, AxiosError<ApiError>, SdkSetConfigParam ${_methodParams}> => { 
+  //
+  const mutationFn = async (input: SdkSetConfigParam ${_methodParams}) => {
+      const response = 
+            (await ${apiGenName}(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).
+                ${classMethod}(${_methodParamsImpl}))
+      callback && callback(response.data)
+      return response.data
+  }
+  
+  return useMutation({
+    mutationKey: [${createQueryKey(apiGenName, classMethod)}],
+    mutationFn,
+    ...options
+  })
+}
+  
+  `;
+  return isGet ? queryMethodImpl : mutationMethodImpl;
+};
+function createQueryKey(className, methodName) {
+  const prefixRegex = /^(get|create|update|delete|patch|post|fetch)[_]?/i;
+  const cleanedMethodName = methodName.replace(prefixRegex, "").trim();
+  const finalMethodName = cleanedMethodName.charAt(0).toUpperCase() + cleanedMethodName.slice(1);
+  return `Key_${className.replace("Api", "")}.${finalMethodName}`;
+}
+var prefixMappings = {
+  get: "use",
+  create: "useCreate",
+  patch: "usePatch",
+  update: "useUpdate",
+  delete: "useDelete",
+  post: "usePost",
+  fetch: "useFetch"
+};
+function convertMethodNameToHook({
+  classMethod,
+  apiGenName,
+  isPostFetch,
+  isFetch
+}) {
+  for (const [originalPrefix, newPrefix] of Object.entries(prefixMappings)) {
+    if (classMethod.startsWith(originalPrefix)) {
+      return `use${apiGenName}_${capitalize(classMethod)}`;
+    }
+  }
+  return classMethod;
+}
+function convertToMethodImplArgs(methodArgs) {
+  const properties = methodArgs.split(/,\s*(?![^{}]*\})/).map((prop) => prop.trim()).filter(Boolean);
+  const formattedProperties = [];
+  properties.forEach((prop) => {
+    if (prop.includes(": {")) {
+      const propertyName = prop.split(": {")[0].replace("?", "").trim();
+      formattedProperties.push(`input.${propertyName}`);
+    } else {
+      const colonIndex = prop.indexOf(":");
+      const propertyName = prop.substring(0, colonIndex).replace("?", "").trim();
+      formattedProperties.push(`input.${propertyName}`);
+    }
+  });
+  return formattedProperties.join(", ");
+}
+
+// src/templates/template-sdk-snippet.ts
+var templateSdkSnippet = ({
+  serviceNameTitle,
+  apiName,
+  snippetMethod,
+  snippetApiArgs: snippetApiArgsParam
+}) => {
+  const methodArr = snippetMethod.split("//");
+  const snippetApiArgs = ["sdk", ...snippetApiArgsParam];
+  let normMethod = normalizeMethodSnippet(methodArr[0].trim(), "data:");
+  normMethod = normalizeMethodSnippet(normMethod, "queryParams:");
+  normMethod = normalizeMethodSnippet(normMethod, "queryParams?:");
+  normMethod += "\n\n//" + methodArr[1];
+  const sdkSnippet = `import { Accelbyte } from '@accelbyte/sdk'
+import { ${serviceNameTitle} } from '@accelbyte/sdk-${serviceNameTitle.toLowerCase()}'
+
+const sdk = Accelbyte.SDK({
+  options: {
+    baseURL: 'https://demo.accelbyte.io',
+    clientId: '77f88506b6174c3ea4d925f5b4096ce8',
+    namespace: 'accelbyte',
+    redirectURI: 'http://localhost:3030'
+  }
+})
+
+${serviceNameTitle}.${apiName}(${snippetApiArgs.join(", ")})
+  .${normMethod}`;
+  return sdkSnippet;
+};
+var normalizeMethodSnippet = (methodInput, splitWord) => {
+  const split1 = methodInput.split(splitWord);
+  if (!split1[1]) {
+    return methodInput;
+  }
+  let split2 = split1[1].trim();
+  split2 = ParserUtils.replaceAll(split2, "{", "");
+  split2 = ParserUtils.replaceAll(split2, "})", "");
+  split2 = split2.split(",");
+  let params = "";
+  split2.forEach((p) => {
+    params += "\n             " + ParserUtils.replaceAll(p.trim(), ")", "") + ",";
+  });
+  params = params.slice(0, -1);
+  const result = split1[0] + splitWord + " {" + params + "\n    })";
+  return result;
+};
+
+// src/helpers/SwaggerReaderHelpers.ts
+var GIT_URL = "https://github.com/AccelByte/accelbyte-web-sdk/blob/main/packages";
+var SwaggerReaderHelpers = class _SwaggerReaderHelpers {
+  static getServicePrefix = (servicePaths) => servicePaths[servicePaths.length - 1].split("/")[1];
+  static parseAllEndpoints = async ({
+    api,
+    sdkName,
+    serviceName
+  }) => {
+    const result = {
+      admin: {
+        arrayDefinitions: [],
+        snippetMap: {},
+        tagToClassImportsRecord: {},
+        tagToEndpointClassesRecord: {},
+        tagToSdkClientRecord: {},
+        tagToSdkFunctionNamesRecord: {},
+        tagToSdkImportsRecord: {},
+        tagToEndpointQueryRecord: {}
+      },
+      public: {
+        arrayDefinitions: [],
+        snippetMap: {},
+        tagToClassImportsRecord: {},
+        tagToEndpointClassesRecord: {},
+        tagToSdkClientRecord: {},
+        tagToSdkFunctionNamesRecord: {},
+        tagToSdkImportsRecord: {},
+        tagToEndpointQueryRecord: {}
+      }
+    };
+    const sortedPathsByLength = new Map(
+      Object.entries(api.paths).sort((a, b) => {
+        if (a[0].length === b[0].length) {
+          return a[0].localeCompare(b[0]);
+        } else {
+          return a[0].length - b[0].length;
+        }
+      })
+    );
+    const sortedKeys = Array.from(sortedPathsByLength.keys());
+    const servicePrefix = _SwaggerReaderHelpers.getServicePrefix(sortedKeys);
+    const tagToClassMethodsMap = {
+      admin: {},
+      public: {}
+    };
+    for (const [path7, operation] of sortedPathsByLength) {
+      if (path7.indexOf("/healthz") >= 0) {
+        continue;
+      }
+      const isAdminEndpoint = path7.indexOf("/admin/") > -1;
+      const picked = isAdminEndpoint ? result.admin : result.public;
+      const {
+        arrayDefinitions,
+        snippetMap,
+        tagToClassImportsRecord,
+        tagToEndpointClassesRecord,
+        tagToSdkClientRecord,
+        tagToSdkFunctionNamesRecord,
+        tagToSdkImportsRecord,
+        tagToEndpointQueryRecord
+      } = picked;
+      const tagToClassMethodsMapByType = isAdminEndpoint ? tagToClassMethodsMap.admin : tagToClassMethodsMap.public;
+      const generatedMethods = {};
+      const httpMethods = Object.keys(operation);
+      for (const httpMethod of httpMethods) {
+        const endpoint = await Endpoint.parseAsync(operation[httpMethod]).catch((error) => {
+          console.error(JSON.stringify({ path: path7, httpMethod }, null, 2));
+          throw error;
+        });
+        if (!endpoint.tags) continue;
+        const [tag] = endpoint.tags;
+        const pathWithBase = `${api.basePath ?? ""}${path7}`;
+        const permissionType = getPermissionType(getPermission(endpoint));
+        tagToClassMethodsMapByType[tag] = tagToClassMethodsMapByType[tag] ? tagToClassMethodsMapByType[tag] : {};
+        const isForm = endpoint.consumes && endpoint.consumes[0] === "application/x-www-form-urlencoded";
+        const classMethod = ParserUtils.generateNaturalLangMethod({
+          servicePrefix,
+          path: path7,
+          httpMethod,
+          isForm,
+          existingMethods: tagToClassMethodsMapByType[tag],
+          permissionType
+        });
+        tagToClassMethodsMapByType[tag][classMethod] = `${path7} ${httpMethod}`;
+        generatedMethods[`${path7} ${httpMethod}`] = `${classMethod}`;
+        if (!snippetMap[pathWithBase]) {
+          snippetMap[pathWithBase] = {};
+        }
+        const description = endpoint.description?.replace(/\s+/g, " ") || "";
+        const responseClass = ParserUtils.get2xxResponse(endpoint.responses);
+        const { className, classGenName } = ParserUtils.generateClassName(tag, isAdminEndpoint);
+        tagToClassImportsRecord[className] = tagToClassImportsRecord[className] ? tagToClassImportsRecord[className] : {};
+        if (responseClass) {
+          const importTypeClass = ParserUtils.parseRefType(responseClass);
+          tagToClassImportsRecord[className][importTypeClass] = `import { ${importTypeClass} } from '../../generated-definitions/${importTypeClass}.js'`;
+        }
+        if (responseClass && responseClass.endsWith("Array")) {
+          arrayDefinitions.push(responseClass);
+        }
+        const queryParams = ParserUtils.filterQueryParameters(endpoint.parameters);
+        const isFormUrlEncoded = ParserUtils.isFormUrlEncoded(httpMethod, endpoint.consumes);
+        const pathParams = ParserUtils.filterPathParams(endpoint.parameters);
+        let bodyParams = ParserUtils.filterBodyParams(endpoint.parameters);
+        const deprecated = !!endpoint.deprecated;
+        if (endpoint.requestBody) {
+          bodyParams = [
+            {
+              name: "body",
+              in: "body",
+              schema: endpoint.requestBody.content["application/json"]?.schema
+            }
+          ];
+        }
+        const { methodImpl, methodParams, methodParamsNoTypes, importStatements } = templateMethod({
+          classMethod,
+          description,
+          httpMethod,
+          path: pathWithBase,
+          pathParams,
+          bodyParams,
+          queryParams,
+          isFormUrlEncoded,
+          responseClass,
+          deprecated
+        });
+        tagToEndpointClassesRecord[tag] = (tagToEndpointClassesRecord[tag] || "") + methodImpl;
+        const { apiGenName } = ParserUtils.generateApiName(tag, isAdminEndpoint);
+        const queryMethodImpl = templateQueryMethod({
+          classMethod,
+          httpMethod,
+          path: pathWithBase,
+          pathParams,
+          responseClass,
+          methodParams,
+          apiGenName
+        });
+        tagToEndpointQueryRecord[tag] = (tagToEndpointQueryRecord[tag] || "") + queryMethodImpl;
+        const { generatedMethodString, snippetApiArgs, snippetMethod, snippetShell } = templateApiMethod({
+          classMethod,
+          description,
+          httpMethod,
+          path: pathWithBase,
+          pathParams,
+          bodyParams,
+          responseClass,
+          classGenName,
+          methodParams,
+          methodParamsNoTypes,
+          deprecated,
+          xSecurity: endpoint["x-security"]
+        });
+        tagToSdkClientRecord[tag] = (tagToSdkClientRecord[tag] || "") + generatedMethodString;
+        tagToSdkFunctionNamesRecord[tag] = (tagToSdkFunctionNamesRecord[tag] || "") + classMethod + ",";
+        tagToSdkImportsRecord[tag] = tagToSdkImportsRecord[tag] ? [.../* @__PURE__ */ new Set([...importStatements, ...tagToSdkImportsRecord[tag]])] : [...new Set(importStatements)];
+        const serviceNameTitle = ParserUtils.convertDashesToTitleCase(serviceName);
+        const resultSnippet = templateSdkSnippet({
+          serviceNameTitle,
+          apiName: apiGenName,
+          snippetMethod,
+          snippetApiArgs
+        });
+        const currentSnippetMap = {};
+        snippetMap[pathWithBase][httpMethod] = currentSnippetMap;
+        currentSnippetMap.web = resultSnippet;
+        const generatedDirName = isAdminEndpoint ? "generated-admin" : "generated-public";
+        currentSnippetMap.webGit = GIT_URL + `/sdk-${sdkName}/src/${generatedDirName}/${apiGenName}.ts`;
+        currentSnippetMap.shell = snippetShell;
+      }
+    }
+    for (const key in result) {
+      result[key].arrayDefinitions = Array.from(new Set(result[key].arrayDefinitions));
+    }
+    return result;
+  };
+};
+
+// src/templates/template-api-index.ts
+var templateApiIndex = (serviceName, serviceNameTitle, apiList) => {
+  let imports = "";
+  let returnStatement = "";
+  for (const cl of apiList) {
+    const dir = cl.toLowerCase().includes("admin") && cl !== "AdminApi" ? "generated-admin" : "generated-public";
+    imports += `
+import { ${cl} } from './${dir}/${cl}.js'`;
+    returnStatement += `
+${cl}, `;
+  }
+  return `/**
+ * AUTO GENERATED
+ */
+${imports}
+
+const apis = {
+${returnStatement}
+}
+
+export const ${serviceNameTitle} = apis
+  `;
+};
+
+// src/templates/template-zod.ts
+var TemplateZod = class {
+  duplicates;
+  duplicateFound = false;
+  //
+  importClasses = /* @__PURE__ */ new Set();
+  // --
+  render = (fileName, definition, duplicates) => {
+    this.duplicates = duplicates;
+    const content = this.parseToZodSchema(definition, definition.required || []);
+    const containsRecursiveType = this.importClasses.has(fileName);
+    if (containsRecursiveType) {
+      this.importClasses.delete(fileName);
+    }
+    let imports = "";
+    for (const cl of Array.from(this.importClasses).sort()) {
+      imports += `import { ${cl} } from './${cl}.js'
+`;
+    }
+    let exportedVariableString;
+    let exportedTypeString;
+    if (containsRecursiveType) {
+      exportedVariableString = `
+export const ${fileName}: z.ZodType<${fileName}> = z.lazy(() =>
+          ${content.schemaString}
+        )
+      `;
+      exportedTypeString = `
+export interface ${fileName} {
+          ${content.typeString}
+}
+`;
+    } else {
+      exportedVariableString = `export const ${fileName} = ${content.schemaString}`;
+      exportedTypeString = `export interface ${fileName} extends z.TypeOf<typeof ${fileName}> {}`;
+    }
+    const template = `import { z } from 'zod'
+${imports}
+
+${exportedVariableString}
+
+${exportedTypeString}
+  `;
+    return { buffer: template, duplicateFound: this.duplicateFound };
+  };
+  // --
+  parseToZodSchema = (definition, requiredAttrs) => {
+    if (definition.additionalProperties) {
+      return this.parseToZodAttribute("", definition, []);
+    }
+    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 schemaFields = [];
+    const typeFields = [];
+    for (const property of properties) {
+      const [name, definition2] = property;
+      const result = this.parseToZodAttribute(name, definition2, requiredAttrs);
+      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(";")
+    };
+  };
+  // --
+  parseToZodAttribute = (name, definition, requiredAttrs) => {
+    const isRequired = requiredAttrs.includes(name) || name === "";
+    const schemaRequired = isRequired ? "" : ".nullish()";
+    const typeRequired = isRequired ? "" : "?";
+    const typeNullishability = isRequired ? "" : " | null | undefined";
+    const schemaAttribute = name ? `'${name}':` : "";
+    const typeAttribute = name ? `'${name}'${typeRequired}:` : "";
+    const type = definition?.type;
+    if (definition.properties) {
+      const result = this.parseToZodSchema(definition, requiredAttrs);
+      return {
+        schemaString: `${schemaAttribute} ${result.schemaString}${schemaRequired}`,
+        typeString: `${typeAttribute} ${result.typeString}${typeNullishability}`
+      };
+    } else if (type) {
+      if (type === "object" && definition.additionalProperties) {
+        const zodAttribute = this.parseToZodAttribute("", definition.additionalProperties, [""]);
+        return {
+          schemaString: `${schemaAttribute} z.record(${zodAttribute.schemaString})${schemaRequired}`,
+          typeString: `${typeAttribute} Record<string, ${zodAttribute.typeString}>${typeNullishability}`
+        };
+      }
+      if (type === "object" && !definition.additionalProperties && !name) {
+        return {
+          schemaString: `z.any()`,
+          typeString: "any"
+        };
+      }
+      if (type === "object" && !definition.additionalProperties) {
+        return {
+          schemaString: `${schemaAttribute} z.record(z.any())${schemaRequired}`,
+          typeString: `${typeAttribute} Record<string, any>${typeNullishability}`
+        };
+      }
+      if (type === "integer" || type === "number") {
+        const effectiveType = getZodNumberType(type);
+        return {
+          schemaString: `${schemaAttribute} z.${effectiveType.schemaString}()${schemaRequired}`,
+          typeString: `${typeAttribute} ${effectiveType.typeString}${typeNullishability}`
+        };
+      }
+      if (type === "array") {
+        const items = definition.items;
+        const ref2 = items?.$ref;
+        let model2;
+        if (ref2) {
+          const refType = ParserUtils.parseRefType(ref2);
+          this.importClasses.add(refType);
+          model2 = {
+            schemaString: refType,
+            typeString: refType
+          };
+        } else if (items) {
+          if (items.type === "array") {
+            const ref3 = items.items?.$ref;
+            if (ref3) {
+              const refType = ParserUtils.parseRefType(ref3);
+              this.importClasses.add(refType);
+              model2 = {
+                schemaString: refType,
+                typeString: refType
+              };
+            } else if (items.items) {
+              model2 = this.parseEnumItems(items.items);
+            }
+            return {
+              schemaString: `${schemaAttribute} z.array(z.array(${model2.schemaString}))${schemaRequired}`,
+              typeString: `${typeAttribute} ${model2.typeString}[]${typeNullishability}`
+            };
+          } else {
+            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}`,
+          typeString: `${typeAttribute} ${model2.typeString}[]${typeNullishability}`
+        };
+      }
+      if (type !== "object") {
+        const result = extractEnumObject(type, isRequired, definition.enum);
+        return {
+          schemaString: `${schemaAttribute} ${result.schemaString}`,
+          typeString: `${typeAttribute} ${result.typeString}`
+        };
+      }
+    }
+    const ref = definition.$ref;
+    let model = `z.record(z.any())`;
+    if (ref) {
+      model = ParserUtils.parseRefType(ref);
+      const fullModelName = ref.replace("#/definitions/", "");
+      this.duplicateFound = this.duplicates.has(fullModelName);
+      if (this.duplicateFound) {
+        model = this.duplicates.get(fullModelName);
+      }
+      this.importClasses.add(model);
+      model = `${model}`;
+    }
+    return {
+      schemaString: `${schemaAttribute} ${model}${schemaRequired}`,
+      typeString: `${typeAttribute} ${model}${typeNullishability}`
+    };
+  };
+  parseEnumItems = (items) => {
+    if (items.enum) {
+      const enumStr = items.enum.map((e) => {
+        return `"${e}"`;
+      });
+      return {
+        schemaString: `z.enum([${enumStr}])`,
+        typeString: `(${enumStr.join(" | ")})`
+      };
+    }
+    if (items.type === "object") {
+      return this.parseToZodSchema(items, items.required);
+    }
+    let effectiveType;
+    if (items.type === "integer" || items.type === "number") {
+      effectiveType = getZodNumberType(items.type);
+    } else {
+      effectiveType = { typeString: items.type, schemaString: items.type };
+    }
+    return {
+      schemaString: `z.${effectiveType.schemaString}()`,
+      typeString: effectiveType.typeString
+    };
+  };
+};
+var TemplateZodArray = class {
+  //
+  render = (name) => {
+    const cls = name.replace("Array", "");
+    const template = `import { z } from 'zod'
+import { ${cls} } from './${cls}.js'
+  
+export const ${name} = z.array(${cls})
+
+export interface ${name} extends z.TypeOf<typeof ${name}> {}
+  `;
+    return template;
+  };
+};
+var getZodNumberType = (type) => {
+  if (type === "integer") {
+    return {
+      schemaString: "number().int",
+      typeString: "number"
+    };
+  }
+  return {
+    schemaString: type,
+    typeString: type
+  };
+};
+var extractEnumObject = (type, isRequired, enumArr) => {
+  const schemaRequired = isRequired ? "" : ".nullish()";
+  const typeNullishability = isRequired ? "" : " | null | undefined";
+  if (enumArr) {
+    const enumStr = enumArr.map((e) => {
+      return `"${e}"`;
+    });
+    return {
+      schemaString: `z.enum([${enumStr}])${schemaRequired}`,
+      typeString: `(${enumStr.join(" | ")}${typeNullishability})`
+    };
+  }
+  return {
+    schemaString: `z.${type}()${schemaRequired}`,
+    typeString: `${type}${typeNullishability}`
+  };
+};
+
+// src/CodeGenerator.ts
+var CodeGenerator = class _CodeGenerator {
+  static srcFolder = () => CliParser.getOutputPath();
+  static getGeneratedFolder = (isAdmin) => isAdmin ? `${_CodeGenerator.srcFolder()}/generated-admin` : `${_CodeGenerator.srcFolder()}/generated-public`;
+  static getGeneratedSnippetsFolder = () => `${CliParser.getSnippetOutputPath()}/generated-snippets`;
+  static prepareDirs = (DIST_DEFINITION_DIR, DIST_DIR, DIST_DIR_ENDPOINTS, DIST_DIR_QUERIES) => {
+    ParserUtils.mkdirIfNotExist(DIST_DEFINITION_DIR);
+    ParserUtils.mkdirIfNotExist(DIST_DIR(true));
+    ParserUtils.mkdirIfNotExist(DIST_DIR(false));
+    ParserUtils.mkdirIfNotExist(DIST_DIR_ENDPOINTS(true));
+    ParserUtils.mkdirIfNotExist(DIST_DIR_ENDPOINTS(false));
+    ParserUtils.mkdirIfNotExist(DIST_DIR_QUERIES(true));
+  };
+  static main = async (nameArray) => {
+    const serviceName = nameArray[0];
+    const sdkName = nameArray[1];
+    const swaggerFile = nameArray[2];
+    const parser = new SwaggerParser();
+    const swaggerFilePath = `${CliParser.getSwaggersOutputPath()}/${swaggerFile}`;
+    const api = await parser.parse(swaggerFilePath);
+    const serviceNameTitle = ParserUtils.convertDashesToTitleCase(serviceName);
+    const indexImportsSet = /* @__PURE__ */ new Set();
+    const queryImportsSet = /* @__PURE__ */ new Set();
+    const apiInfo = { ...api.info, "x-version": api["x-version"]?.version };
+    console.log("----------\nGenerating API:", { title: apiInfo.title, version: apiInfo.version });
+    ParserUtils.writeXVersion(_CodeGenerator.srcFolder(), api["x-version"], api.info);
+    const parsedInformation = await SwaggerReaderHelpers.parseAllEndpoints({ api, sdkName, serviceName });
+    if (CliParser.getSnippetOutputPath()) {
+      try {
+        ParserUtils.writeSnippetFile(
+          _CodeGenerator.getGeneratedSnippetsFolder(),
+          api.info.title,
+          JSON.stringify(
+            {
+              ...parsedInformation.public.snippetMap,
+              ...parsedInformation.admin.snippetMap
+            },
+            null,
+            2
+          )
+        );
+      } catch (err) {
+        console.log("Generating snippets", err);
+      }
+    }
+    const DIST_DIR = (isAdmin) => `${_CodeGenerator.getGeneratedFolder(isAdmin)}`;
+    const DIST_DIR_ENDPOINTS = (isAdmin) => path4.join(DIST_DIR(isAdmin), "endpoints");
+    const DIST_DIR_QUERIES = (isAdmin) => path4.join(DIST_DIR(isAdmin), "queries");
+    const DIST_DEFINITION_DIR = path4.join(_CodeGenerator.srcFolder(), "generated-definitions");
+    const targetSrcFolder = `${_CodeGenerator.srcFolder()}/`;
+    _CodeGenerator.prepareDirs(DIST_DEFINITION_DIR, DIST_DIR, DIST_DIR_ENDPOINTS, DIST_DIR_QUERIES);
+    const mainApiList = [];
+    const generatedDefinitions = [];
+    const generatePublicOrAdmin = (isAdmin) => {
+      const parsedInformationByType = isAdmin ? parsedInformation.admin : parsedInformation.public;
+      const {
+        arrayDefinitions,
+        tagToClassImportsRecord,
+        tagToEndpointClassesRecord,
+        tagToSdkClientRecord,
+        tagToSdkFunctionNamesRecord,
+        tagToSdkImportsRecord,
+        tagToEndpointQueryRecord
+      } = parsedInformationByType;
+      const writeApiEndpointFiles = (isAdminEndpoint) => {
+        const apiList = [];
+        for (const tag in tagToEndpointClassesRecord) {
+          const { className, classGenName } = ParserUtils.generateClassName(tag, isAdminEndpoint);
+          const classBuffer = tagToEndpointClassesRecord[tag];
+          const imports = [.../* @__PURE__ */ new Set([...tagToSdkImportsRecord[tag], ...Object.values(tagToClassImportsRecord[className])])];
+          const apiImports = [.../* @__PURE__ */ new Set([...tagToSdkImportsRecord[tag], ...Object.values(tagToClassImportsRecord[className])])];
+          apiImports.push(`import { ${classGenName} } from './endpoints/${classGenName}.js'`);
+          ParserUtils.writeClassFile(DIST_DIR_ENDPOINTS(isAdminEndpoint), classGenName, classBuffer, imports);
+          const { apiGenName } = ParserUtils.generateApiName(tag, isAdminEndpoint);
+          const queryBuffer = tagToEndpointQueryRecord[tag];
+          const queryFileName = !CliParser.skipReactQuery() && ParserUtils.writeQueryFile(
+            DIST_DIR_QUERIES(isAdminEndpoint),
+            apiGenName,
+            queryBuffer,
+            apiImports,
+            serviceNameTitle,
+            tagToSdkFunctionNamesRecord[tag],
+            imports,
+            sdkName
+          );
+          const apiBuffer = tagToSdkClientRecord[tag];
+          ParserUtils.writeApiFile(DIST_DIR(isAdminEndpoint), apiGenName, apiBuffer, imports, tagToSdkFunctionNamesRecord[tag]);
+          apiList.push(apiGenName);
+          indexImportsSet.add(
+            ParserUtils.getRelativePathToWebSdkSrcFolder(path4.join(DIST_DIR_ENDPOINTS(isAdminEndpoint), `${classGenName}`), targetSrcFolder)
+          );
+          indexImportsSet.add(
+            ParserUtils.getRelativePathToWebSdkSrcFolder(path4.join(DIST_DIR(isAdminEndpoint), `${apiGenName}`), targetSrcFolder)
+          );
+          queryFileName && queryImportsSet.add(
+            ParserUtils.getRelativePathToWebSdkSrcFolder(
+              path4.join(DIST_DIR(isAdminEndpoint), "queries", `${queryFileName}`),
+              targetSrcFolder
+            )
+          );
+        }
+        mainApiList.push(...apiList);
+        indexImportsSet.add(
+          ParserUtils.getRelativePathToWebSdkSrcFolder(path4.join(_CodeGenerator.srcFolder(), serviceNameTitle), targetSrcFolder)
+        );
+      };
+      const writeDefinitions = (api2) => {
+        const duplicates = /* @__PURE__ */ new Map();
+        const definitions = api2?.components?.schemas || api2.definitions;
+        for (const ref in definitions) {
+          const definition = definitions[ref];
+          const fileName = ParserUtils.parseRefType(ref);
+          const fileExist = fs4.existsSync(path4.join(DIST_DEFINITION_DIR, `${fileName}.ts`));
+          if (fileExist) {
+            const duplicateName = ParserUtils.toCamelCaseWord(ref).replace(".", "").replace(".", "");
+            duplicates.set(ref, duplicateName);
+          }
+          const { buffer } = new TemplateZod().render(fileName, definition, /* @__PURE__ */ new Map());
+          generatedDefinitions.push(fileName);
+          ParserUtils.writeDefinitionFile(DIST_DEFINITION_DIR, fileName, buffer);
+          indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path4.join(DIST_DEFINITION_DIR, fileName), targetSrcFolder));
+        }
+        for (const arrayClass of arrayDefinitions) {
+          const buffer = new TemplateZodArray().render(arrayClass);
+          generatedDefinitions.push(arrayClass);
+          ParserUtils.writeDefinitionFile(DIST_DEFINITION_DIR, arrayClass, buffer);
+          indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path4.join(DIST_DEFINITION_DIR, arrayClass), targetSrcFolder));
+        }
+      };
+      writeApiEndpointFiles(isAdmin);
+      writeDefinitions(api);
+    };
+    generatePublicOrAdmin(true);
+    generatePublicOrAdmin(false);
+    const apiIndexBuff = templateApiIndex(serviceName, serviceNameTitle, mainApiList);
+    ParserUtils.writeApiMainFile(_CodeGenerator.srcFolder(), serviceNameTitle, apiIndexBuff);
+    console.log("\nCOMPLETED\n----------\n\n");
+    return { indexImports: indexImportsSet, queryImports: queryImportsSet };
+  };
+  // end of main
+};
+
+// src/SwaggerDownloader.ts
+import * as https from "https";
+import * as fs5 from "fs";
+import * as path5 from "path";
+var SwaggerDownloader = class _SwaggerDownloader {
+  static getDestFile = (targetFileName) => {
+    const destPath = CliParser.getResolvedSwaggersOutputPath();
+    const destFile = path5.join(destPath, targetFileName);
+    if (fs5.existsSync(destFile)) return destFile;
+    if (!fs5.existsSync(destPath)) fs5.mkdirSync(destPath);
+    fs5.writeFileSync(destFile, "");
+    return destFile;
+  };
+  // session-api.json contains illegal URL encoded character that breaks the codegen
+  // e.g. "$ref": "#/definitions/map%5Bstring%5Dinterface%20%7B%7D"
+  static postSanitizeDownloadedFile = (filePath) => {
+    const searchStr = ["%5B", "%5D", "%20", "%7B", "%7D"];
+    fs5.readFile(filePath, "utf8", (err, data) => {
+      if (err) throw err;
+      let result = data;
+      searchStr.forEach((s) => {
+        result = result.replace(new RegExp(s, "g"), " ");
+      });
+      fs5.writeFile(filePath, result, "utf8", (err2) => {
+        if (err2) throw err2;
+        console.log("File updated successfully.");
+      });
+    });
+  };
+  static downloadFile = async (targetFileName, url) => {
+    const destFile = _SwaggerDownloader.getDestFile(targetFileName);
+    let data = "";
+    return new Promise((resolve2) => {
+      const request = https.get(url, function(response) {
+        response.on("data", (chunk) => {
+          data += chunk;
+        });
+        response.on("end", () => {
+          if (response.statusCode !== 200) {
+            console.log(`SwaggerDownload error with status code: ${response.statusCode}`);
+          } else {
+            fs5.writeFileSync(destFile, JSON.stringify(JSON.parse(data), null, 2), "utf-8");
+            _SwaggerDownloader.postSanitizeDownloadedFile(destFile);
+            console.log(`SwaggerDownload ${url} completed with status code: ${response.statusCode}`);
+          }
+          resolve2(void 0);
+        });
+      });
+      request.on("error", (err) => {
+        console.log(`SwaggerDownloader failed for "${targetFileName}" and "${url}"`, err);
+      });
+    });
+  };
+  static main = async () => {
+    const swaggers = CliParser.getConfigFile();
+    for (const ref in swaggers) {
+      const targetFileName = swaggers[ref][2];
+      const url = swaggers[ref][3];
+      await _SwaggerDownloader.downloadFile(targetFileName, url);
+    }
+  };
+};
+
+// src/cli.ts
+var generateSdk = async () => {
+  const arrayOfSets = await Promise.all(CliParser.getConfigFile().map((config) => CodeGenerator.main(config)));
+  const indexImportsSet = /* @__PURE__ */ new Set();
+  const queryImportsSet = /* @__PURE__ */ new Set();
+  const filenamesSet = /* @__PURE__ */ new Set();
+  for (const set of arrayOfSets) {
+    set.indexImports.forEach((value) => {
+      const fileName = path6.basename(value);
+      if (!filenamesSet.has(fileName)) {
+        indexImportsSet.add(value);
+        filenamesSet.add(fileName);
+      }
+    });
+    set.queryImports.forEach((value) => {
+      const fileName = path6.basename(value);
+      if (!filenamesSet.has(fileName)) {
+        queryImportsSet.add(value);
+      }
+    });
+  }
+  const indexImportsArray = Array.from(indexImportsSet).sort();
+  const queryImportsArray = Array.from(queryImportsSet).sort();
+  const filesToImport = indexImportsArray.map((fileToImport) => {
+    return `export * from '${fileToImport.replace("\\", "/")}.js'`;
+  });
+  const queryFilesToImport = queryImportsArray.map((fileToImport) => {
+    return `export * from '${fileToImport.replace("\\", "/")}.js'`;
+  });
+  ParserUtils.writeAllImportsFile(CliParser.getOutputPath(), filesToImport.join("\n"));
+  ParserUtils.writeAllQueryImportsFile(CliParser.getOutputPath(), queryFilesToImport.join("\n"));
+};
+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) => {
+  yargs2.check(({ output }) => {
+    if (!output?.trim()) {
+      throw new Error("output is required for generate-code");
+    }
+    return true;
+  });
+  CliParser.createInstance(yargs2);
+  await generateSdk();
+}).option("config", {
+  description: "Config file providing backend services URL.",
+  type: "string",
+  demandOption: true
+}).option("swaggersOutput", {
+  description: "Output path for downloaded swaggers JSON files.",
+  type: "string",
+  demandOption: true
+}).option("output", {
+  description: "Output path for generated code. Required for generate-code",
+  type: "string"
+}).option("skipReactQuery", {
+  description: "Skip generating react query",
+  type: "boolean"
+}).demandCommand(1).help().argv;
+//# sourceMappingURL=accelbyte-codegen.mjs.map