@accelbyte/codegen 3.1.0 → 4.0.1

package/dist/accelbyte-codegen.mjs

@@ -1,74 +1,158 @@
-import yargs from 'yargs';
-import { z } from 'zod';
-import * as fs from 'fs';
-import fs__default, { writeFileSync, readFileSync } from 'fs';
-import * as path from 'path';
-import path__default from 'path';
-import SwaggerParser from '@apidevtools/swagger-parser';
-import { applyPatch } from 'fast-json-patch';
-import _ from 'lodash';
-import semver from 'semver';
-import * as https from 'https';
+#!/usr/bin/env node
 
-const SwaggersConfig = z.array(z.array(z.string()));
-class CliParser {
+// 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(yargs) {
-    this.argv = yargs.parse();
+  constructor(yargs2) {
+    this.argv = yargs2.parse();
   }
-  static createInstance = (yargs) => {
-    CliParser._instance = new CliParser(yargs);
-    return CliParser._instance;
+  static createInstance = (yargs2) => {
+    _CliParser._instance = new _CliParser(yargs2);
+    return _CliParser._instance;
   };
-  static instance = (yargs) => {
-    if (!CliParser._instance && yargs) {
-      return CliParser.createInstance(yargs);
+  static instance = (yargs2) => {
+    if (!_CliParser._instance && yargs2) {
+      return _CliParser.createInstance(yargs2);
     }
-    return CliParser._instance;
+    return _CliParser._instance;
   };
   static getConfigPath = () => {
-    return CliParser.instance().argv.config;
+    return _CliParser.instance().argv.config;
   };
   static getConfigFile = () => {
-    const configPath = CliParser.getConfigPath();
-    if (!configPath)
-      throw new Error("Missing config file");
-    const config = JSON.parse(fs__default.readFileSync(configPath, "utf8"));
+    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;
+    return _CliParser.instance().argv.output;
   };
   static getSwaggersOutputPath = () => {
-    return CliParser.instance().argv.swaggersOutput;
+    return _CliParser.instance().argv.swaggersOutput;
   };
   static getResolvedSwaggersOutputPath = () => {
-    return path.resolve(CliParser.getSwaggersOutputPath());
+    return path.resolve(_CliParser.getSwaggersOutputPath());
   };
   static getSnippetOutputPath = () => {
-    return CliParser.instance().argv.snippetOutput;
+    return _CliParser.instance().argv.snippetOutput;
+  };
+  static skipReactQuery = () => {
+    return _CliParser.instance().argv.skipReactQuery;
   };
-  static skipVersionSync = () => {
-    return CliParser.instance().argv.skipVersionSync;
+  static isGenerateSnippetOnly = () => {
+    return _CliParser.instance().argv.snippetOnly;
   };
+};
+
+// 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;
+var escapeComment = (string) => string.replace(/\*\//g, "*\\/").replace(/\n/g, "\n   * ");
+var generateJsDoc = ({ indentation = 4, lines }) => {
+  const indent = " ".repeat(indentation);
+  const formattedLines = lines.filter(Boolean).map((line) => `${indent} * ${line}`).join("\n");
+  return `${indent}/**
+${formattedLines}
+${indent} */`;
+};
+var extractDescription = (description, options) => {
+  const { indentation = 2, responseClasses, other, isDeprecated } = options;
+  return description ? generateJsDoc({
+    lines: [
+      isDeprecated ? "@deprecated" : "",
+      escapeComment(description),
+      ...responseClasses.length > 1 ? [" ", "#### Response type:", ...responseClasses.map((val) => `- \`${val}\``)] : "",
+      ...options?.other ? other : ""
+    ],
+    indentation
+  }) : "";
+};
+var getResponseType = ({
+  responseClasses,
+  defaultType = "unknown"
+}) => {
+  const responseClass = responseClasses.length === 1 ? responseClasses?.[0] : "unknown";
+  const responseType = responseClass !== "unknown" ? responseClasses?.[0] : defaultType;
+  return {
+    responseType,
+    responseTypeInAxiosResponse: `Promise<AxiosResponse<${responseType}>>`,
+    responseTypeInResponse: `Promise<Response<${responseType}>>`
+  };
+};
 
-const getImportableVarMap$1 = () => ({
-  "@accelbyte/sdk": ["CodeGenUtil", "IResponse", "Validate"],
-  axios: ["AxiosRequestConfig", "AxiosResponse"],
+// src/templates/template-class.ts
+var getImportableVarMap = () => ({
+  "@accelbyte/sdk": ["CodeGenUtil", "Response", "Validate", "SdkSetConfigParam"],
+  axios: ["AxiosResponse"],
   zod: ["z"]
 });
-const makeNewImportVarMap$1 = () => ({
-  axios: ["AxiosInstance"],
+var makeNewImportVarMap = () => ({
+  axios: ["AxiosInstance", "AxiosRequestConfig"],
   "@accelbyte/sdk": ["SDKRequestConfig"]
 });
-const generateImports$1 = (body, importStatements, makeNewImportVarMap2, getImportableVarMap2) => {
-  const usedImportVarMap = makeNewImportVarMap2;
-  const importableVarMap = getImportableVarMap2;
+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_])`);
@@ -83,33 +167,125 @@ const generateImports$1 = (body, importStatements, makeNewImportVarMap2, getImpo
   return `${generatedImports}
 ${importStatements.sort().join("\n")}`;
 };
-const templateClass = (className, body, importStatements) => {
+var templateClass = (className, body, importStatements) => {
   return `/**
  * AUTO GENERATED
  */
-${generateImports$1(body, importStatements, makeNewImportVarMap$1(), getImportableVarMap$1())}
+${generateImports(body, importStatements, makeNewImportVarMap(), getImportableVarMap())}
 
 export class ${className} {
   // @ts-ignore
+  // prettier-ignore
   constructor(private axiosInstance: AxiosInstance, private namespace: string, private useSchemaValidation = true) {}
   ${body}
 }
   `;
 };
 
-const generateImports = (body, className) => {
-  const generatedImports = `import { AccelbyteSDK, ApiArgs, ApiError } from '@accelbyte/sdk'
-import { AxiosError } from 'axios'
+// 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: ["AxiosRequestConfig", "AxiosResponse"]
+});
+var templateApiClass = (className, body, importStatements, returnMethods) => {
+  const returnsMethodsWithDescription = Object.keys(returnMethods).reduce((acc, key) => {
+    acc += `
+    ${returnMethods[key]}
+${key},`;
+    return acc;
+  }, "");
+  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 useSchemaValidation = args?.coreConfig?.useSchemaValidation ?? sdkAssembly.coreConfig.useSchemaValidation
+  
+  let axiosInstance = sdkAssembly.axiosInstance
+  const requestConfigOverrides = args?.axiosConfig?.request
+  const baseURLOverride = args?.coreConfig?.baseURL
+  const interceptorsOverride = args?.axiosConfig?.interceptors ?? []
+
+  if (requestConfigOverrides || baseURLOverride || interceptorsOverride.length > 0) {
+    const requestConfig = ApiUtils.mergeAxiosConfigs(sdkAssembly.axiosInstance.defaults as AxiosRequestConfig, {
+      ...(baseURLOverride ? { baseURL: baseURLOverride } : {}),
+      ...requestConfigOverrides
+    })
+    axiosInstance = Network.create(requestConfig)
+
+    for (const interceptor of interceptorsOverride) {
+      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 {
+    ${returnsMethodsWithDescription}
+  }
+}
+  `;
+};
+
+// 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;
 };
-const templateQuery = (className, body, importStatements, serviceNameTitle, returnMethods, paramImports) => {
+var templateQuery = (className, body, importStatements, serviceNameTitle, returnMethods, paramImports, sdkName) => {
   const classNameWithoutApi = className.replace("Api", "");
-  const queryKeys = ParserUtils.createQueryKeys(classNameWithoutApi, returnMethods);
-  const generatedImports = generateImports(body, className);
+  const queryKeys = ParserQueryUtils.createQueryKeys(classNameWithoutApi, returnMethods, sdkName);
+  const generatedImports = generateImports2(body, className);
   return `/**
  * AUTO GENERATED
  */
@@ -125,117 +301,19 @@ export enum Key_${classNameWithoutApi} {
   `;
 };
 function filterUsedImports(importArr, body) {
-  return importArr.filter((path) => {
-    const start = path.indexOf("{") + 1;
-    const end = path.indexOf("}");
+  return importArr.filter((path7) => {
+    const start = path7.indexOf("{") + 1;
+    const end = path7.indexOf("}");
     if (start > 0 && end > start) {
-      const importName = path.slice(start, end).trim();
+      const importName = path7.slice(start, end).trim();
       return body.includes(importName);
     }
     return false;
-  }).map((path) => path).join("\n") + "\n";
-}
-
-const getImportableVarMap = () => ({
-  "@accelbyte/sdk": ["CodeGenUtil", "IResponse", "Validate", "ApiArgs", "Network", "AccelbyteSDK"]
-});
-const makeNewImportVarMap = () => ({
-  "@accelbyte/sdk": ["AccelbyteSDK", "ApiArgs", "ApiUtils"]
-});
-const templateApiClass = (className, body, importStatements, returnMethods) => {
-  const $className = className.replace("Api", "$");
-  return `/**
- * AUTO GENERATED
- */
-/* eslint-disable camelcase */
-// @ts-ignore -> ts-expect-error TS6133
-${generateImports$1(body, importStatements, makeNewImportVarMap(), getImportableVarMap())}
-${`import { ${$className} } from './endpoints/${$className}.js'
-`}
-
-export function ${className}(sdk: AccelbyteSDK, args?: ApiArgs) {
-  const sdkAssembly = sdk.assembly()
-  
-  const namespace = args?.namespace ? args?.namespace : sdkAssembly.namespace
-  const requestConfig = ApiUtils.mergedConfigs(sdkAssembly.config, args)
-  const useSchemaValidation = sdkAssembly.useSchemaValidation
-  ${body}
-  
-  return {
-    ${returnMethods}
-  }
-}
-  `;
-};
-
-const VersionBumpType = z.enum(["CUTOFF", "RELEASE", "HOTFIX", "BREAKING"]);
-class VersionHelpers {
-  static getNextVersion = ({
-    serviceVersion,
-    versionBumpType,
-    sdkVersion,
-    nextPrereleaseId
-  }) => {
-    if (versionBumpType !== void 0) {
-      const parsed = VersionBumpType.safeParse(versionBumpType);
-      if (!parsed.success) {
-        throw new Error(`Invalid process.env.VERSION_BUMP_TYPE: ${versionBumpType}`);
-      }
-      if ((parsed.data === "HOTFIX" || parsed.data === "RELEASE") && nextPrereleaseId) {
-        throw new Error(`process.env.PRERELEASE_ID should be empty when process.env.VERSION_BUMP_TYPE is "HOTFIX" or "PRELEASE".`);
-      }
-    }
-    const serviceSemvers = semver.parse(serviceVersion);
-    const sdkSemvers = semver.parse(sdkVersion);
-    if (serviceSemvers === null) {
-      throw new Error(`Invalid service version: ${serviceVersion}`);
-    }
-    if (sdkSemvers === null) {
-      throw new Error(`Invalid sdk version: ${sdkVersion}`);
-    }
-    const { major: currentMajor, minor: currentMinor, patch: currentPatch, prerelease: currentPrerelease } = sdkSemvers;
-    let nextMajor = currentMajor;
-    let nextMinor = currentMinor;
-    let nextPatch = currentPatch;
-    switch (versionBumpType) {
-      case VersionBumpType.Enum.BREAKING: {
-        nextMajor++;
-        nextMinor = 0;
-        nextPatch = 0;
-        break;
-      }
-      case VersionBumpType.Enum.CUTOFF: {
-        nextMinor++;
-        nextPatch = 0;
-        break;
-      }
-      case VersionBumpType.Enum.RELEASE:
-        break;
-      case VersionBumpType.Enum.HOTFIX: {
-        nextPatch++;
-        break;
-      }
-    }
-    let nextVersion = [
-      nextMajor,
-      nextMinor,
-      nextPatch
-    ].join(".");
-    if (nextPrereleaseId) {
-      if (nextMinor !== currentMinor) {
-        nextVersion += `-${nextPrereleaseId}.0`;
-      } else {
-        if (currentPrerelease.length)
-          nextVersion += `-${currentPrerelease.join(".")}`;
-        nextVersion = semver.inc(nextVersion, "prerelease", void 0, nextPrereleaseId);
-      }
-    }
-    return nextVersion;
-  };
+  }).map((path7) => path7).join("\n") + "\n";
 }
 
-const UNDEFINED_SWAGGER_SEMVER = "0.0.0";
-const REMOVED_KEYWORDS = [
+// src/ParserUtils.ts
+var REMOVED_KEYWORDS = [
   "/admin/",
   "/public/",
   "/v1/",
@@ -247,52 +325,34 @@ const REMOVED_KEYWORDS = [
   "/namespaces/",
   "/{namespace}/"
 ];
-class ParserUtils {
-  static createQueryKeys(classNameWithoutApi, csvMethodNames) {
-    const keys = csvMethodNames.split(",");
-    const processedKeys = /* @__PURE__ */ new Set();
-    const enumString = keys.reduce((acc, key, index) => {
-      const trimmedKey = key.trim();
-      const isDeprecated = key.indexOf("_DEPRECATED") > 0;
-      if (trimmedKey && !isDeprecated) {
-        const cleanedKey = trimmedKey.replace(/^(get|update|create|patch|delete)[_]?/, "");
-        if (!processedKeys.has(cleanedKey)) {
-          processedKeys.add(cleanedKey);
-          acc += `${cleanedKey} = '${classNameWithoutApi}.${cleanedKey}'`;
-          if (index < keys.length - 1) {
-            acc += ",\n";
-          }
-        }
-      }
-      return acc;
-    }, "");
-    return enumString;
-  }
-  static addDeprecatedSuffix(isDeprecated, methodName) {
-    if (isDeprecated) {
-      return methodName + "_DEPRECATED";
-    } else {
-      return methodName;
-    }
+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 classGenName = isAdmin ? className + "Admin$" : className + "$";
-    return { className, classGenName };
+    const formattedApiName = removeAdminPrefix(className);
+    const classGenName = isAdmin ? formattedApiName + "Admin$" : formattedApiName + "$";
+    return { className: formattedApiName, classGenName };
   };
   static generateApiName = (tag, isAdmin) => {
     const apiName = _.upperFirst(_.camelCase(tag));
-    const apiGenName = isAdmin ? apiName + "AdminApi" : apiName + "Api";
+    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);
+      const mappedDefaultValue = definition.default.map(
+        (defaultValue2) => typeof defaultValue2 === "string" ? `'${defaultValue2}'` : defaultValue2
+      );
       defaultValue = `[${mappedDefaultValue.join(", ")}]`;
     }
     if (definition.type === "string") {
@@ -301,24 +361,21 @@ class ParserUtils {
     return `${attrName}: ${defaultValue}`;
   };
   static parseType = (pathParam) => {
-    if (isSwaggerIntegerType(pathParam.type || pathParam?.schema?.type))
-      return "number";
+    if (isSwaggerIntegerType(pathParam.type || pathParam?.schema?.type)) return "number";
     if (pathParam.type === "array") {
-      if (isSwaggerIntegerType(pathParam.items.type))
-        return "number[]";
+      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[]";
+      if (isSwaggerIntegerType(pathParam.schema.items.type)) return "number[]";
       return `${pathParam.schema.items.type ?? "any"}[]`;
     }
-    if (pathParam?.schema?.type)
-      return pathParam.schema.type;
+    if (pathParam?.schema?.type) return pathParam.schema.type;
     return pathParam.type;
   };
   static parseQueryParamsType = (queryParams) => {
-    return queryParams.map((queryParam) => ParserUtils.parseAttributeType(queryParam)).join(", ");
+    const result = queryParams.map((queryParam) => _ParserUtils.parseAttributeType(queryParam)).join(", ");
+    return result;
   };
   static isAnyQueryParamRequired = (queryParams) => {
     return queryParams.some((queryParam) => queryParam.required);
@@ -333,11 +390,11 @@ class ParserUtils {
     return result;
   };
   static parseQueryParamsDefault = (queryParams) => {
-    const result = queryParams.filter((queryParam) => !!queryParam.default && !queryParam.required).map(ParserUtils.parseQueryParamAttributeDefault).join(",");
+    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);
+    return bodyParams.map((bodyParams2) => _ParserUtils.parseRefImport(bodyParams2)).filter(Boolean);
   };
   static parseImportDir = ($ref) => {
     let ref = $ref.replace(".", "/");
@@ -355,7 +412,7 @@ class ParserUtils {
     if (!$ref) {
       return null;
     }
-    const type = ParserUtils.parseRefType($ref);
+    const type = _ParserUtils.parseRefType($ref);
     return `import { ${type} } from '../../generated-definitions/${type}.js'`;
   };
   static parseRefType = ($ref) => {
@@ -373,10 +430,13 @@ class ParserUtils {
       const enums = definition.enum.map((enm) => definition.type === "string" ? `'${enm}'` : enm).join(" | ");
       return `${attrName}${required}: ${enums}`;
     }
-    if (definition.type && ParserUtils.parseType(definition) === "number") {
+    if (definition.type && _ParserUtils.parseType(definition) === "number") {
       return `${attrName}${required}: number`;
     }
-    if (definition?.schema?.type && ParserUtils.parseType(definition) === "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") {
@@ -401,47 +461,44 @@ class ParserUtils {
   };
   static parseBodyParamsType = (bodyParams) => {
     const [bodyParam] = bodyParams;
-    if (!bodyParam)
-      return null;
+    if (!bodyParam) return null;
     if (bodyParams.length > 0 && bodyParam?.name !== "body" && !bodyParam?.schema) {
-      let retBodyParams = `{${bodyParams.map((bodyParam2) => ParserUtils.parseAttributeType(bodyParam2)).join(",")}}`;
+      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[]";
+      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)}[]`;
+      return `${_ParserUtils.parseRefType(bodyParam.schema.items.$ref)}[]`;
     }
     if (bodyParam?.schema?.$ref) {
-      return ParserUtils.parseRefType(bodyParam.schema.$ref);
+      return _ParserUtils.parseRefType(bodyParam.schema.$ref);
     }
     if (bodyParam?.schema?.additionalProperties?.type === "object") {
       return "any";
     }
     return null;
   };
-  static get2xxResponse(methodEntity) {
+  static get2xxResponses(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 ;
+    const responseClasses = [];
+    const statusCodes = keys.filter((key) => String(key).startsWith("2"));
+    statusCodes.forEach((key) => {
+      const sch = methodEntity[key].schema;
+      const schV3 = methodEntity[key].content && methodEntity[key].content["application/json"].schema;
+      if (sch?.$ref) {
+        responseClasses.push(_ParserUtils.parseRefType(sch.$ref));
+      } else if (sch?.type === "array" && sch.items?.$ref) {
+        responseClasses.push(`${_ParserUtils.parseRefType(sch.items.$ref)}Array`);
+      } else if (schV3?.$ref) {
+        responseClasses.push(_ParserUtils.parseRefType(schV3.$ref));
+      } else {
       }
     });
-    return responseClass;
+    return responseClasses;
   }
   static isFormUrlEncoded(httpMethod, contentTypes) {
     if (!contentTypes || contentTypes.length < 1) {
@@ -458,17 +515,24 @@ class ParserUtils {
     }
     return parameters.filter((parameter) => parameter.in === "path");
   }
-  static generateNaturalLangMethod = ({ servicePrefix, path: path2, httpMethod, isForm, existingMethods }) => {
-    let path_ = path2;
+  /**
+   * 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" && !(path2.slice(-1) === "}");
+    const isPlural = httpMethod === "get" && !(path7.slice(-1) === "}");
     if (!isPlural) {
-      path_ = ParserUtils.replaceAll(path_, "ies/", "y/");
-      path_ = ParserUtils.replaceAll(path_, "s/", "/");
+      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$/, "");
@@ -506,9 +570,11 @@ class ParserUtils {
       }
     });
     const genPath = _.upperFirst(lastWords) + "/" + listBeforeLastWords.join("/") + listByParams.reverse().join("/");
-    let generatedMethod = _.camelCase(mappedMethod(httpMethod, isForm) + genPath);
-    generatedMethod = ParserUtils.replaceAll(generatedMethod, "Byword", "_By");
-    generatedMethod = resolveConflicts(path2, generatedMethod, existingMethods);
+    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) {
@@ -524,90 +590,76 @@ class ParserUtils {
     return parameters.filter((parameter) => parameter.in === "query");
   }
   static mkdirIfNotExist(dirToCreate) {
-    if (!fs__default.existsSync(dirToCreate)) {
-      fs__default.mkdirSync(dirToCreate, { recursive: true });
+    if (!fs3.existsSync(dirToCreate)) {
+      fs3.mkdirSync(dirToCreate, { recursive: true });
     }
   }
   static writeClassFile(distDir, apiName, apiBuffer, imports) {
     const fileContent = templateClass(apiName, apiBuffer, imports);
-    fs__default.writeFileSync(`${distDir}/${apiName}.ts`, ParserUtils.prependCopyrightHeader(fileContent));
+    fs3.writeFileSync(`${distDir}/${apiName}.ts`, _ParserUtils.prependCopyrightHeader(fileContent));
   }
   static writeAtomFile(distDir, apiName, fileContent) {
-    ParserUtils.mkdirIfNotExist(distDir);
-    fs__default.writeFileSync(`${distDir}/${apiName}.atom.ts`, ParserUtils.prependCopyrightHeader(fileContent));
+    _ParserUtils.mkdirIfNotExist(distDir);
+    fs3.writeFileSync(`${distDir}/${apiName}.atom.ts`, _ParserUtils.prependCopyrightHeader(fileContent));
   }
-  static writeQueryFile(distDir, apiName, apiBuffer, imports, serviceNameTitle, returnMethods, paramImports) {
+  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);
-    fs__default.writeFileSync(`${distDir}/${queryFileName}.ts`, ParserUtils.prependCopyrightHeader(fileContent));
+    _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);
-      fs__default.writeFileSync(`${distDir}/version.json`, JSON.stringify(xversionJson, null, 2));
+      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);
-      fs__default.writeFileSync(`${distDir}/version.json`, JSON.stringify(customVersion, null, 2));
+      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) {
+  static writeApiFile(distDir, apiName, apiBuffer, imports, returnMethodsDescription) {
     const newImports = [];
-    imports.forEach((el, index) => {
+    imports.forEach((el) => {
       newImports.push(el.replace("../../generated-definitions", "../generated-definitions"));
     });
-    const fileContent = templateApiClass(apiName, apiBuffer, newImports, returnMethods);
-    fs__default.writeFileSync(`${distDir}/${apiName}.ts`, ParserUtils.prependCopyrightHeader(fileContent));
+    const fileContent = templateApiClass(apiName, apiBuffer, newImports, returnMethodsDescription);
+    fs3.writeFileSync(`${distDir}/${apiName}.ts`, _ParserUtils.prependCopyrightHeader(fileContent));
   }
   static writeApiMainFile(distDir, serviceName, fileContent) {
-    fs__default.writeFileSync(`${distDir}/${serviceName}.ts`, ParserUtils.prependCopyrightHeader(fileContent));
+    fs3.writeFileSync(`${distDir}/${serviceName}.ts`, _ParserUtils.prependCopyrightHeader(fileContent));
   }
   static writeSnippetFile(distDir, name, docBuffer) {
-    let snippetFileName = ParserUtils.replaceAll(name, " ", "-").toLowerCase();
+    let snippetFileName = _ParserUtils.replaceAll(name, " ", "-").toLowerCase();
     snippetFileName = snippetFileName.replace("justice-", "");
     snippetFileName = "snippet-" + snippetFileName + ".json";
-    fs__default.writeFileSync(`${distDir}/${snippetFileName}`, docBuffer);
+    fs3.writeFileSync(`${distDir}/${snippetFileName}`, docBuffer);
   }
   static writeDefinitionFile(distDir, name, buffer) {
-    ParserUtils.mkdirIfNotExist(distDir);
-    fs__default.writeFileSync(path__default.join(distDir, `${name}.ts`), ParserUtils.prependCopyrightHeader(buffer));
+    _ParserUtils.mkdirIfNotExist(distDir);
+    fs3.writeFileSync(path3.join(distDir, `${name}.ts`), _ParserUtils.prependCopyrightHeader(buffer));
   }
   static writeAllImportsFile(distDir, buffer) {
-    ParserUtils.mkdirIfNotExist(distDir);
-    fs__default.writeFileSync(path__default.join(distDir, "all-imports.ts"), ParserUtils.prependCopyrightHeader(buffer));
-  }
-  static syncPackageVersion(apiInfo, skipVersionSync, prereleaseId) {
-    if (skipVersionSync)
-      return;
-    const currDir = process.cwd();
-    const { packageJSON, pathToPackageJSON } = ParserUtils.getPackageJSONInfo(currDir);
-    const nextSemver = VersionHelpers.getNextVersion({
-      serviceVersion: apiInfo["x-version"] || apiInfo.version || UNDEFINED_SWAGGER_SEMVER,
-      versionBumpType: process.env.VERSION_BUMP_TYPE,
-      sdkVersion: packageJSON.version,
-      nextPrereleaseId: prereleaseId
-    });
-    packageJSON.version = nextSemver;
-    writeFileSync(pathToPackageJSON, JSON.stringify(packageJSON, null, 2));
+    _ParserUtils.mkdirIfNotExist(distDir);
+    fs3.writeFileSync(path3.join(distDir, "all-imports.ts"), _ParserUtils.prependCopyrightHeader(buffer));
   }
-  static getPackageJSONInfo(dir) {
-    const pathToPackageJSON = path__default.join(dir, "./package.json");
-    return { packageJSON: JSON.parse(readFileSync(pathToPackageJSON, "utf-8")), pathToPackageJSON };
+  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);
+      return _ParserUtils.toCamelCaseWord(word);
     }).join("");
   }
   static toCamelCaseWord(word) {
@@ -626,15 +678,15 @@ class ParserUtils {
     });
   }
   static applyPatchIfExists(swaggerFilePath, possibleSwaggerPatchFilePath, swaggerPatchedFilePath, swaggerPatchedDir) {
-    if (!fs__default.existsSync(swaggerPatchedDir)) {
-      fs__default.mkdirSync(swaggerPatchedDir, { recursive: true });
+    if (!fs3.existsSync(swaggerPatchedDir)) {
+      fs3.mkdirSync(swaggerPatchedDir, { recursive: true });
     }
-    if (!fs__default.existsSync(possibleSwaggerPatchFilePath)) {
-      fs__default.copyFileSync(swaggerFilePath, swaggerPatchedFilePath);
+    if (!fs3.existsSync(possibleSwaggerPatchFilePath)) {
+      fs3.copyFileSync(swaggerFilePath, swaggerPatchedFilePath);
       return;
     }
-    const swaggerContent = JSON.parse(fs__default.readFileSync(swaggerFilePath, "utf8"));
-    const swaggerPatchFileContent = JSON.parse(fs__default.readFileSync(possibleSwaggerPatchFilePath, "utf8"));
+    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;
@@ -644,29 +696,32 @@ class ParserUtils {
         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:
+          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.
+                "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"));
+              ].join("\n")
+            );
           }
         }
         currentNode = currentNode[effectiveSegment];
       }
     }
     const { newDocument } = applyPatch(swaggerContent, swaggerPatchFileContent);
-    fs__default.writeFileSync(swaggerPatchedFilePath, JSON.stringify(newDocument, null, 2));
+    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 = new Date().getFullYear();
+    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
@@ -674,17 +729,21 @@ class ParserUtils {
  */
 ${content}`;
   };
-  static sortPathParamsByPath = (pathParams, path2) => {
-    const params = path2.match(/{\w*}/g) || [];
+  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));
   };
-}
-const mappedMethod = (httpMethod, isForm) => {
+};
+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") {
@@ -695,440 +754,221 @@ const mappedMethod = (httpMethod, isForm) => {
     return "delete";
   }
 };
-const resolveConflicts = (path2, generatedMethod, existingMethods) => {
+var resolveConflicts = ({ path: path7, generatedMethod, testedGeneratedMethod, existingMethods }) => {
+  let _testedGenMethod = testedGeneratedMethod;
   try {
-    testConflict(path2, generatedMethod, existingMethods);
+    testConflict(path7, _testedGenMethod, existingMethods);
   } catch (e) {
-    if (path2.indexOf("/namespaces/") >= 0) {
+    if (path7.indexOf("/namespaces/") >= 0) {
       generatedMethod += "_ByNS";
+      _testedGenMethod += "_ByNS";
     }
   }
   try {
-    testConflict(path2, generatedMethod, existingMethods);
+    testConflict(path7, _testedGenMethod, existingMethods);
   } catch (e) {
-    if (path2.indexOf("/v4/") >= 0) {
-      generatedMethod += "_v4";
-    }
-  }
-  try {
-    testConflict(path2, generatedMethod, existingMethods);
-  } catch (e) {
-    if (path2.indexOf("/v3/") >= 0) {
-      generatedMethod += "_v3";
-    }
-  }
-  try {
-    testConflict(path2, generatedMethod, existingMethods);
-  } catch (e) {
-    if (path2.indexOf("/v2/") >= 0) {
-      generatedMethod += "_v2";
-    }
-  }
-  try {
-    testConflict(path2, generatedMethod, existingMethods);
-  } catch (e) {
-    if (path2.indexOf("/admin/") >= 0) {
+    if (path7.indexOf("/admin/") >= 0) {
       generatedMethod += "_admin";
+      _testedGenMethod += "_admin";
     }
   }
-  testConflict(path2, generatedMethod, existingMethods);
+  testConflict(path7, _testedGenMethod, existingMethods);
   return generatedMethod;
 };
-const testConflict = (path2, generatedMethod, existingMethods) => {
+var testConflict = (path7, generatedMethod, existingMethods) => {
   if (existingMethods[generatedMethod]) {
-    const conflictingMethod = { path: path2, generatedMethod };
-    throw Error(`Duplicate method conflict in ${JSON.stringify(conflictingMethod)},
- existingMethods: ${JSON.stringify(existingMethods, null, 2)}`);
+    const conflictingMethod = { path: path7, generatedMethod };
+    throw Error(
+      `Duplicate method conflict in ${JSON.stringify(conflictingMethod)},
+ existingMethods: ${JSON.stringify(existingMethods, null, 2)}`
+    );
   }
 };
-const isSwaggerIntegerType = (type) => {
+var isSwaggerIntegerType = (type) => {
   return type === "integer" || type === "int";
 };
 
-class TemplateZod {
-  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'
-`;
+// 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,
+  httpMethod,
+  path: path7,
+  pathParams,
+  bodyParams,
+  responseClasses,
+  classGenName,
+  methodParams,
+  methodParamsNoTypes,
+  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}))`;
+      }
     }
-    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 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("{ axiosConfig: { request: { 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 template = `import { z } from 'zod'
-${imports}
-
-${exportedVariableString}
-
-${exportedTypeString}
+  }
+  const snippetShell = `curl ${snippetShellArgs.join(" \\\n    ")}`;
+  const { responseType, responseTypeInAxiosResponse } = getResponseType({ responseClasses });
+  const methodImpl = `
+  async function ${classMethod}(${methodParams}): ${responseTypeInAxiosResponse} {
+    const $ = new ${classGenName}(axiosInstance, namespace, useSchemaValidation)
+    const resp = await $.${classMethod}(${methodParamsNoTypes})
+    if (resp.error) throw resp.error
+    return resp.response
+  }
   `;
-    return { buffer: template, duplicateFound: this.duplicateFound };
+  const snippetPromiseString = responseType !== "unknown" ? `Promise<${responseType}>` : "Promise";
+  snippetMethod += `${classMethod}(${methodParams}) 
+   // return ${snippetPromiseString}`;
+  return {
+    generatedMethodString: methodImpl,
+    snippetApiArgs,
+    snippetMethod,
+    snippetShell
   };
-  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
-    };
-  };
-}
-class TemplateZodArray {
-  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;
-  };
-}
-const getZodNumberType = (type) => {
-  if (type === "integer") {
-    return {
-      schemaString: "number().int",
-      typeString: "number"
-    };
-  }
-  return {
-    schemaString: type,
-    typeString: type
-  };
-};
-const 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}`
-  };
-};
-
-const 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
-  `;
 };
 
-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(), z.array(z.any())]).nullish(),
-  enum: z.array(z.union([z.boolean(), z.string(), z.number()])).nullish(),
-  items: z.object({
-    type: z.string(),
-    enum: z.array(z.any()).nullish()
-  }).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().nullish(),
-    content: z.object({
-      "application/json": z.object({
-        schema: Schema.nullish()
-      }).nullish()
-    }).nullish()
-  }).nullish(),
-  "x-security": z.any().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 templateMethod = ({
+// src/templates/template-method.ts
+var templateMethod = ({
   classMethod,
   description,
   httpMethod,
-  path,
+  path: path7,
   pathParams,
   bodyParams,
   queryParams,
   isFormUrlEncoded,
-  responseClass,
+  responseClasses,
   deprecated
 }) => {
   let methodParams = "";
   let methodParamsNoTypes = "";
-  let newPath = `'${path}'`;
+  let newPath = `'${path7}'`;
   let importStatements = [];
-  const sortedPathParams = ParserUtils.sortPathParamsByPath(pathParams, path);
+  const sortedPathParams = ParserUtils.sortPathParamsByPath(pathParams, path7);
   for (const pathParam of sortedPathParams) {
     const type = ParserUtils.parseType(pathParam);
     if (pathParam.name !== "namespace") {
@@ -1136,7 +976,7 @@ const templateMethod = ({
       methodParamsNoTypes += pathParam.name + ", ";
     }
     const pName = pathParam.name === "namespace" ? "this.namespace" : pathParam.name;
-    if (path.match(`{${pathParam.name}}`)) {
+    if (path7.match(`{${pathParam.name}}`)) {
       if (type === "string") {
         newPath = `${newPath}.replace('{${pathParam.name}}', ${pName})`;
       } else {
@@ -1153,14 +993,11 @@ const templateMethod = ({
   }
   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 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 = description ? `
-  /**${deprecated ? "\n   * @deprecated" : ""}
-   * ${description.replace(/\n/g, "\n   * ")} 
-   */` : "";
+  const descriptionText = extractDescription(description, { isDeprecated: deprecated, responseClasses });
   let formPayloadString = "";
   if (isFormUrlEncoded) {
     formPayloadString = ``;
@@ -1172,17 +1009,14 @@ const templateMethod = ({
     dataPayload = dataType ? `{data, params}` : "{params}";
   }
   const isFileUpload = methodParams.indexOf("data: {file") > -1;
-  const resolvedResponseClass = responseClass || "unknown";
-  const resolvedResponseClassValidated = responseClass || "z.unknown()";
+  const { responseType, responseTypeInResponse } = getResponseType({ responseClasses });
+  const resolvedResponseClassValidated = responseType !== "unknown" ? `${responseType}` : "z.unknown()";
   methodParams = (queryParamsType ? `${methodParams} ${queryParamsType}` : methodParams).replace(/,\s*$/, "");
   methodParamsNoTypes = queryParamsType ? `${methodParamsNoTypes} queryParams` : methodParamsNoTypes;
-  let methodImpl = "";
   const isGuardInvoked = ["get", "post", "put", "patch", "delete"].includes(httpMethod);
-  const responseType = resolvedResponseClass !== "unknown" ? `${resolvedResponseClass}` : "unknown";
-  const generateMethodName = () => `${classMethod}(${methodParams}): Promise<${responseSyncType}<${responseType}>>`;
-  const responseSyncType = "IResponse";
-  methodImpl = `${descriptionText}
-  ${generateMethodName()} {
+  const generatedMethodName = `${classMethod}(${methodParams}): ${responseTypeInResponse}`;
+  let methodImpl = `${descriptionText}
+  ${generatedMethodName} {
     ${queryParamsDefault}
     const url = ${newPath}    ${formPayloadString} ${isFileUpload ? "\n// TODO file upload not implemented" : ""}
     const resultPromise = this.axiosInstance.${httpMethod}(url, ${dataPayload})
@@ -1202,26 +1036,35 @@ ${`    return Validate.validateOrReturnResponse(this.useSchemaValidation, () =>
   return res;
 };
 
-const templateApiMethod = ({
+// src/templates/template-query-method.ts
+var POST_FETCH_INCLUDES_PATH = ["/table-query/"];
+var templateQueryMethod = ({
   classMethod,
-  description,
   httpMethod,
-  path,
+  path: path7,
   pathParams,
-  bodyParams,
-  responseClass,
-  classGenName,
+  responseClasses,
   methodParams,
-  methodParamsNoTypes,
-  deprecated,
-  xSecurity
+  apiGenName,
+  description,
+  deprecated
 }) => {
-  let newPath = `'${path}'`;
-  let snippetMethod = "";
-  for (const pathParam of pathParams) {
+  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 (path.match(`{${pathParam.name}}`)) {
+    if (path7.match(`{${pathParam.name}}`)) {
       if (type === "string") {
         newPath = `${newPath}.replace('{${pathParam.name}}', ${pName})`;
       } else {
@@ -1229,48 +1072,121 @@ const templateApiMethod = ({
       }
     }
   }
-  const snippetShellArgs = ["--location --request", `${httpMethod} '__DOMAIN__${path}'`, "--header 'accept: application/json'"];
-  const snippetApiArgs = [];
-  if (xSecurity !== void 0 || path.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 { responseType } = getResponseType({ responseClasses });
+  let _methodName = convertMethodNameToHook({ classMethod, apiGenName, isGet });
+  const _methodParams = methodParams && methodParams.length > 0 ? `& { ${methodParams} }` : "";
+  const _methodParamsImpl = convertToMethodImplArgs(methodParams);
+  const queryKey = createQueryKey(apiGenName, classMethod);
+  const descriptionText = extractDescription(description, {
+    isDeprecated: deprecated,
+    responseClasses,
+    other: [" ", "#### Default Query Options", "The default options include:", "```", "{", `   queryKey: [${queryKey}, input]`, "}", "```"]
+  });
+  const queryMethodImpl = `
+
+${descriptionText}
+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
   }
-  const snippetShell = `curl ${snippetShellArgs.join(" \\\n    ")}`;
-  const descriptionText = description ? `
-  /**${deprecated ? "\n   * @deprecated" : ""}
-   * ${description.replace(/\n/g, "\n   * ")} 
-   */` : "";
-  const resolvedResponseClass = responseClass || "unknown";
-  const responseType = resolvedResponseClass !== "unknown" ? `${resolvedResponseClass}` : "unknown";
-  const methodImpl = `
+  
+  return ${queryMethod}<${responseType}, AxiosError<ApiError>>({
+    queryKey: [${queryKey}, input],
+    queryFn: queryFn(sdk, input),
+    ...options
+  })
+}
+  
+  `;
+  const mutationMethodImpl = `
+
   ${descriptionText}
-  async function ${classMethod}(${methodParams}): Promise<${responseType}> {
-    const $ = new ${classGenName}(Network.create(requestConfig), namespace, useSchemaValidation)
-    const resp = await $.${classMethod}(${methodParamsNoTypes})
-    if (resp.error) throw resp.error
-    return resp.response.data
+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: [${queryKey}],
+    mutationFn,
+    ...options
+  })
+}
+  
   `;
-  const snippetPromiseString = responseType !== "unknown" ? `Promise<${responseType}>` : "Promise";
-  snippetMethod += `${classMethod}(${methodParams}) 
-   // return ${snippetPromiseString}`;
-  return {
-    generatedMethodString: methodImpl,
-    snippetApiArgs,
-    snippetMethod,
-    snippetShell
-  };
+  return isGet ? queryMethodImpl : mutationMethodImpl;
+};
+function versionMutationSuffixMethodName(baseMethodName) {
+  const parts = baseMethodName.split(/(_v\d+)$/);
+  const name = parts[0];
+  const versionSuffix = parts[1] || "";
+  const res = `${name}Mutation${versionSuffix}`;
+  return res;
+}
+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, isGet }) {
+  for (const [originalPrefix] of Object.entries(prefixMappings)) {
+    if (classMethod.startsWith(originalPrefix)) {
+      const methodName = !isGet ? versionMutationSuffixMethodName(classMethod) : classMethod;
+      return `use${apiGenName}_${capitalize(methodName)}`;
+    }
+  }
+  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(", ");
+}
 
-const templateSdkSnippet = ({
+// src/templates/template-sdk-snippet.ts
+var templateSdkSnippet = ({
   serviceNameTitle,
   apiName,
   snippetMethod,
@@ -1282,11 +1198,11 @@ const templateSdkSnippet = ({
   normMethod = normalizeMethodSnippet(normMethod, "queryParams:");
   normMethod = normalizeMethodSnippet(normMethod, "queryParams?:");
   normMethod += "\n\n//" + methodArr[1];
-  const sdkSnippet = `import { Accelbyte } from '@accelbyte/sdk'
+  const sdkSnippet = `import { AccelByte } from '@accelbyte/sdk'
 import { ${serviceNameTitle} } from '@accelbyte/sdk-${serviceNameTitle.toLowerCase()}'
 
-const sdk = Accelbyte.SDK({
-  options: {
+const sdk = AccelByte.SDK({
+  coreConfig: {
     baseURL: 'https://demo.accelbyte.io',
     clientId: '77f88506b6174c3ea4d925f5b4096ce8',
     namespace: 'accelbyte',
@@ -1298,7 +1214,7 @@ ${serviceNameTitle}.${apiName}(${snippetApiArgs.join(", ")})
   .${normMethod}`;
   return sdkSnippet;
 };
-const normalizeMethodSnippet = (methodInput, splitWord) => {
+var normalizeMethodSnippet = (methodInput, splitWord) => {
   const split1 = methodInput.split(splitWord);
   if (!split1[1]) {
     return methodInput;
@@ -1316,327 +1232,486 @@ const normalizeMethodSnippet = (methodInput, splitWord) => {
   return result;
 };
 
-const templateQueryMethod = ({
-  classMethod,
-  httpMethod,
-  path,
-  pathParams,
-  responseClass,
-  methodParams,
-  apiGenName,
-  isFormUrlEncoded,
-  deprecated
-}) => {
-  if (isFormUrlEncoded || deprecated) {
-    return "";
+// 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: {},
+        tagToSdkFunctionDescription: {}
+      },
+      public: {
+        arrayDefinitions: [],
+        snippetMap: {},
+        tagToClassImportsRecord: {},
+        tagToEndpointClassesRecord: {},
+        tagToSdkClientRecord: {},
+        tagToSdkFunctionNamesRecord: {},
+        tagToSdkImportsRecord: {},
+        tagToEndpointQueryRecord: {},
+        tagToSdkFunctionDescription: {}
+      }
+    };
+    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,
+        tagToSdkFunctionDescription
+      } = 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 responseClasses = ParserUtils.get2xxResponses(endpoint.responses);
+        const responseClass = responseClasses.length > 1 ? null : responseClasses?.[0];
+        const { className, classGenName } = ParserUtils.generateClassName(tag, isAdminEndpoint);
+        tagToClassImportsRecord[className] = tagToClassImportsRecord[className] ? tagToClassImportsRecord[className] : {};
+        if (responseClass) {
+          tagToClassImportsRecord[className][responseClass] = `import { ${responseClass} } from '../../generated-definitions/${responseClass}.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,
+          responseClasses,
+          deprecated
+        });
+        tagToEndpointClassesRecord[tag] = (tagToEndpointClassesRecord[tag] || "") + methodImpl;
+        const { apiGenName } = ParserUtils.generateApiName(tag, isAdminEndpoint);
+        const queryMethodImpl = templateQueryMethod({
+          classMethod,
+          httpMethod,
+          path: pathWithBase,
+          pathParams,
+          responseClasses,
+          methodParams,
+          apiGenName,
+          deprecated,
+          description
+        });
+        tagToEndpointQueryRecord[tag] = (tagToEndpointQueryRecord[tag] || "") + queryMethodImpl;
+        const fnDescription = extractDescription(description, { isDeprecated: deprecated, responseClasses });
+        const tagFnDescriptions = tagToSdkFunctionDescription[tag];
+        tagToSdkFunctionDescription[tag] = {
+          ...tagFnDescriptions,
+          [classMethod]: fnDescription
+        };
+        const { generatedMethodString, snippetApiArgs, snippetMethod, snippetShell } = templateApiMethod({
+          classMethod,
+          httpMethod,
+          path: pathWithBase,
+          pathParams,
+          bodyParams,
+          responseClasses,
+          classGenName,
+          methodParams,
+          methodParamsNoTypes,
+          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 = (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}, `;
   }
-  const isPostFetch = httpMethod === "post" && (path.includes("/table-query/") || path.endsWith("/list"));
-  const isAdmin = path.indexOf("/admin/") > 0;
-  const isGet = httpMethod === "get" || isPostFetch;
-  let queryMethod = isGet ? "useQuery" : "useMutation";
-  let mParams = "";
-  let mParamsNoTypes = "";
-  let newPath = `'${path}'`;
-  const sortedPathParams = ParserUtils.sortPathParamsByPath(pathParams, path);
-  for (const pathParam of sortedPathParams) {
-    const type = ParserUtils.parseType(pathParam);
-    if (pathParam.name !== "namespace") {
-      mParams += pathParam.name + `:${type}, `;
-      mParamsNoTypes += pathParam.name + ", ";
+  return `/**
+ * AUTO GENERATED
+ */
+${imports}
+import { author, name, version } from '../package.json'
+
+console.log(\`\${name}@\${version}\`)
+
+const apis = {
+${returnStatement}
+  version: () => console.log({
+    version,
+    name,
+    author
+  })
+}
+
+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);
     }
-    const pName = pathParam.name === "namespace" ? "this.namespace" : pathParam.name;
-    if (path.match(`{${pathParam.name}}`)) {
-      if (type === "string") {
-        newPath = `${newPath}.replace('{${pathParam.name}}', ${pName})`;
-      } else {
-        newPath = `${newPath}.replace('{${pathParam.name}}', String(${pName}))`;
+    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);
     }
-  }
-  const resolvedResponseClass = responseClass || "unknown";
-  let _methodName = convertMethodName(classMethod, isPostFetch);
-  _methodName = isAdmin ? _methodName.replace("use", "useAdm") : _methodName;
-  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: ApiArgs ${_methodParams},
-    options?: Omit<UseQueryOptions<${_responseType}, AxiosError<ApiError>>, 'queryKey'>,
-    callback?: (data: ${_responseType}) => void
-  ): UseQueryResult<${_responseType}, AxiosError<ApiError>> => { 
+    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 {
   //
-  const queryFn = (
-  sdk: AccelbyteSDK, 
-  input: Parameters<typeof ${_methodName}>[1]
-  ) => async () => {
-      const data = 
-            (await ${apiGenName}(sdk, { namespace: input.namespace }).
-                ${classMethod}(${_methodParamsImpl}))
-      callback && callback(data)
-      return data
-  }
-  
-  return ${queryMethod}<${_responseType}, AxiosError<ApiError>>({
-    queryKey: [${createQueryKey(apiGenName, classMethod)}, input],
-    queryFn: queryFn(sdk, input),
-    ...options
-  })
-}
+  render = (name) => {
+    const cls = name.replace("Array", "");
+    const template = `import { z } from 'zod'
+import { ${cls} } from './${cls}.js'
   
-  `;
-  const mutationMethodImpl = `
+export const ${name} = z.array(${cls})
 
-export const ${_methodName} = (
-    sdk: AccelbyteSDK,
-    options?: Omit<UseMutationOptions<${_responseType}, AxiosError<ApiError>, ApiArgs ${_methodParams}>, 'mutationKey'>,
-    callback?: (data: ${_responseType}) => void
-  ): UseMutationResult<${_responseType}, AxiosError<ApiError>, ApiArgs ${_methodParams}> => { 
-  //
-  const mutationFn = async (input: ApiArgs ${_methodParams}) => {
-      const data = 
-            (await ${apiGenName}(sdk, { namespace: input.namespace, config: input.config }).
-                ${classMethod}(${_methodParamsImpl}))
-      callback && callback(data)
-      return data
-  }
-  
-  return useMutation({
-    mutationKey: [${createQueryKey(apiGenName, classMethod)}],
-    mutationFn,
-    ...options
-  })
-}
-  
+export interface ${name} extends z.TypeOf<typeof ${name}> {}
   `;
-  return isGet ? queryMethodImpl : mutationMethodImpl;
+    return template;
+  };
 };
-function createQueryKey(className, methodName) {
-  if (methodName.indexOf("_DEPRECATED") > 0) {
-    return "";
+var getZodNumberType = (type) => {
+  if (type === "integer") {
+    return {
+      schemaString: "number().int",
+      typeString: "number"
+    };
   }
-  const prefixRegex = /^(get|create|update|delete|patch)[_]?/i;
-  const cleanedMethodName = methodName.replace(prefixRegex, "").trim();
-  const finalMethodName = cleanedMethodName.charAt(0).toUpperCase() + cleanedMethodName.slice(1);
-  return `Key_${className.replace("Api", "")}.${finalMethodName}`;
-}
-const prefixMappings = {
-  get: "use",
-  create: "useCreate",
-  patch: "usePatch",
-  update: "useUpdate",
-  delete: "useDelete"
+  return {
+    schemaString: type,
+    typeString: type
+  };
 };
-function convertMethodName(classMethod, isPostFetch) {
-  for (const [originalPrefix, newPrefix] of Object.entries(prefixMappings)) {
-    if (classMethod.startsWith(originalPrefix)) {
-      if (isPostFetch) {
-        return classMethod.replace(originalPrefix, "useFetch");
-      }
-      const newMethodName = classMethod.replace(originalPrefix, newPrefix);
-      if (originalPrefix === "get") {
-        return newMethodName;
-      } else {
-        return newMethodName + "Mutation";
-      }
-    }
-  }
-  return classMethod;
-}
-function convertToMethodImplArgs(methodArgs) {
-  let properties = methodArgs.split(/,\s*(?![^{}]*\})/).map((prop) => prop.trim()).filter(Boolean);
-  let 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(", ");
-}
-
-const GIT_URL = "https://github.com/AccelByte/accelbyte-web-sdk/blob/main/packages";
-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: {}
+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})`
     };
-    for (const [path, operation] of sortedPathsByLength) {
-      if (path.indexOf("/healthz") >= 0) {
-        continue;
-      }
-      const isAdminEndpoint = path.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 httpMethods = Object.keys(operation);
-      for (const httpMethod of httpMethods) {
-        const endpoint = await Endpoint.parseAsync(operation[httpMethod]).catch((error) => {
-          console.error(JSON.stringify({ path, httpMethod }, null, 2));
-          throw error;
-        });
-        if (!endpoint.tags)
-          continue;
-        const [tag] = endpoint.tags;
-        const pathWithBase = `${api.basePath ?? ""}${path}`;
-        tagToClassMethodsMapByType[tag] = tagToClassMethodsMapByType[tag] ? tagToClassMethodsMapByType[tag] : {};
-        const isForm = endpoint.consumes && endpoint.consumes[0] === "application/x-www-form-urlencoded";
-        const classMethod = ParserUtils.generateNaturalLangMethod({
-          servicePrefix,
-          path,
-          httpMethod,
-          isForm,
-          existingMethods: tagToClassMethodsMapByType[tag]
-        });
-        tagToClassMethodsMapByType[tag][classMethod] = `${path} ${httpMethod}`;
-        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: ParserUtils.addDeprecatedSuffix(deprecated, 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: ParserUtils.addDeprecatedSuffix(deprecated, classMethod),
-          httpMethod,
-          path: pathWithBase,
-          pathParams,
-          responseClass,
-          methodParams,
-          apiGenName,
-          isFormUrlEncoded,
-          deprecated
-        });
-        tagToEndpointQueryRecord[tag] = (tagToEndpointQueryRecord[tag] || "") + queryMethodImpl;
-        const { generatedMethodString, snippetApiArgs, snippetMethod, snippetShell } = templateApiMethod({
-          classMethod: ParserUtils.addDeprecatedSuffix(deprecated, 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] || "") + ParserUtils.addDeprecatedSuffix(deprecated, 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;
+  }
+  return {
+    schemaString: `z.${type}()${schemaRequired}`,
+    typeString: `${type}${typeNullishability}`
   };
-}
+};
 
-class CodeGenerator {
+// src/CodeGenerator.ts
+var CodeGenerator = class _CodeGenerator {
   static srcFolder = () => CliParser.getOutputPath();
-  static getGeneratedFolder = (isAdmin) => isAdmin ? `${CodeGenerator.srcFolder()}/generated-admin` : `${CodeGenerator.srcFolder()}/generated-public`;
+  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);
@@ -1655,28 +1730,42 @@ class CodeGenerator {
     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.syncPackageVersion(apiInfo, CliParser.skipVersionSync(), process.env.PRERELEASE_ID);
-    ParserUtils.writeXVersion(CodeGenerator.srcFolder(), api["x-version"], api.info);
+    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));
+        ParserUtils.mkdirIfNotExist(_CodeGenerator.getGeneratedSnippetsFolder());
+        ParserUtils.writeSnippetFile(
+          _CodeGenerator.getGeneratedSnippetsFolder(),
+          api.info.title,
+          JSON.stringify(
+            {
+              ...parsedInformation.public.snippetMap,
+              ...parsedInformation.admin.snippetMap
+            },
+            null,
+            2
+          )
+        );
       } catch (err) {
-        console.log("Generating snippets", err);
+        console.error("Error generating snippets", err);
       }
     }
-    const DIST_DIR = (isAdmin) => `${CodeGenerator.getGeneratedFolder(isAdmin)}`;
-    const DIST_DIR_ENDPOINTS = (isAdmin) => path__default.join(DIST_DIR(isAdmin), "endpoints");
-    const DIST_DIR_QUERIES = (isAdmin) => path__default.join(DIST_DIR(isAdmin), "queries");
-    const DIST_DEFINITION_DIR = path__default.join(CodeGenerator.srcFolder(), "generated-definitions");
-    const targetSrcFolder = `${CodeGenerator.srcFolder()}/`;
-    CodeGenerator.prepareDirs(DIST_DEFINITION_DIR, DIST_DIR, DIST_DIR_ENDPOINTS, DIST_DIR_QUERIES);
+    if (CliParser.isGenerateSnippetOnly()) {
+      console.log("\nSuccessfully generate SDK snippets only\n----------\n\n");
+      return;
+    }
+    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 {
@@ -1686,7 +1775,8 @@ class CodeGenerator {
         tagToSdkClientRecord,
         tagToSdkFunctionNamesRecord,
         tagToSdkImportsRecord,
-        tagToEndpointQueryRecord
+        tagToEndpointQueryRecord,
+        tagToSdkFunctionDescription
       } = parsedInformationByType;
       const writeApiEndpointFiles = (isAdminEndpoint) => {
         const apiList = [];
@@ -1699,16 +1789,36 @@ class CodeGenerator {
           ParserUtils.writeClassFile(DIST_DIR_ENDPOINTS(isAdminEndpoint), classGenName, classBuffer, imports);
           const { apiGenName } = ParserUtils.generateApiName(tag, isAdminEndpoint);
           const queryBuffer = tagToEndpointQueryRecord[tag];
-          const queryFileName = ParserUtils.writeQueryFile(DIST_DIR_QUERIES(isAdminEndpoint), apiGenName, queryBuffer, apiImports, serviceNameTitle, tagToSdkFunctionNamesRecord[tag], imports);
+          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]);
+          ParserUtils.writeApiFile(DIST_DIR(isAdminEndpoint), apiGenName, apiBuffer, imports, tagToSdkFunctionDescription[tag]);
           apiList.push(apiGenName);
-          indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path__default.join(DIST_DIR_ENDPOINTS(isAdminEndpoint), `${classGenName}`), targetSrcFolder));
-          indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path__default.join(DIST_DIR(isAdminEndpoint), `${apiGenName}`), targetSrcFolder));
-          queryFileName && indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path__default.join(DIST_DIR(isAdminEndpoint), "queries", `${queryFileName}`), targetSrcFolder));
+          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(path__default.join(CodeGenerator.srcFolder(), serviceNameTitle), targetSrcFolder));
+        indexImportsSet.add(
+          ParserUtils.getRelativePathToWebSdkSrcFolder(path4.join(_CodeGenerator.srcFolder(), serviceNameTitle), targetSrcFolder)
+        );
       };
       const writeDefinitions = (api2) => {
         const duplicates = /* @__PURE__ */ new Map();
@@ -1716,19 +1826,21 @@ class CodeGenerator {
         for (const ref in definitions) {
           const definition = definitions[ref];
           const fileName = ParserUtils.parseRefType(ref);
-          const fileExist = fs__default.existsSync(path__default.join(DIST_DEFINITION_DIR, `${fileName}.ts`));
+          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(path__default.join(DIST_DEFINITION_DIR, fileName), targetSrcFolder));
+          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(path__default.join(DIST_DEFINITION_DIR, arrayClass), targetSrcFolder));
+          indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(path4.join(DIST_DEFINITION_DIR, arrayClass), targetSrcFolder));
         }
       };
       writeApiEndpointFiles(isAdmin);
@@ -1736,44 +1848,47 @@ class CodeGenerator {
     };
     generatePublicOrAdmin(true);
     generatePublicOrAdmin(false);
-    const apiIndexBuff = templateApiIndex(serviceName, serviceNameTitle, mainApiList);
-    ParserUtils.writeApiMainFile(CodeGenerator.srcFolder(), serviceNameTitle, apiIndexBuff);
+    const apiIndexBuff = templateApiIndex(serviceNameTitle, mainApiList);
+    ParserUtils.writeApiMainFile(_CodeGenerator.srcFolder(), serviceNameTitle, apiIndexBuff);
     console.log("\nCOMPLETED\n----------\n\n");
-    return indexImportsSet;
+    return { indexImports: indexImportsSet, queryImports: queryImportsSet };
   };
-}
+  // end of main
+};
 
-class SwaggerDownloader {
+// 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 = path.join(destPath, targetFileName);
-    if (fs.existsSync(destFile))
-      return destFile;
-    if (!fs.existsSync(destPath))
-      fs.mkdirSync(destPath);
-    fs.writeFileSync(destFile, "");
+    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"];
-    fs.readFile(filePath, "utf8", (err, data) => {
-      if (err)
-        throw err;
+    fs5.readFile(filePath, "utf8", (err, data) => {
+      if (err) throw err;
       let result = data;
       searchStr.forEach((s) => {
         result = result.replace(new RegExp(s, "g"), " ");
       });
-      fs.writeFile(filePath, result, "utf8", (err2) => {
-        if (err2)
-          throw err2;
+      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);
+    const destFile = _SwaggerDownloader.getDestFile(targetFileName);
     let data = "";
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const request = https.get(url, function(response) {
         response.on("data", (chunk) => {
           data += chunk;
@@ -1782,11 +1897,11 @@ class SwaggerDownloader {
           if (response.statusCode !== 200) {
             console.log(`SwaggerDownload error with status code: ${response.statusCode}`);
           } else {
-            fs.writeFileSync(destFile, JSON.stringify(JSON.parse(data), null, 2), "utf-8");
-            SwaggerDownloader.postSanitizeDownloadedFile(destFile);
+            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}`);
           }
-          resolve(void 0);
+          resolve2(void 0);
         });
       });
       request.on("error", (err) => {
@@ -1799,29 +1914,45 @@ class SwaggerDownloader {
     for (const ref in swaggers) {
       const targetFileName = swaggers[ref][2];
       const url = swaggers[ref][3];
-      await SwaggerDownloader.downloadFile(targetFileName, url);
+      await _SwaggerDownloader.downloadFile(targetFileName, url);
     }
   };
-}
+};
 
-const generateSdk = async () => {
+// src/cli.ts
+var generateSdk = async () => {
   const arrayOfSets = await Promise.all(CliParser.getConfigFile().map((config) => CodeGenerator.main(config)));
+  if (CliParser.isGenerateSnippetOnly()) {
+    return;
+  }
   const indexImportsSet = /* @__PURE__ */ new Set();
+  const queryImportsSet = /* @__PURE__ */ new Set();
   const filenamesSet = /* @__PURE__ */ new Set();
   for (const set of arrayOfSets) {
-    set.forEach((value) => {
-      const fileName = path__default.basename(value);
+    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);
@@ -1846,5 +1977,11 @@ yargs.command("download-swaggers", "Download swaggers JSON files", (yargs2) => {
 }).option("output", {
   description: "Output path for generated code. Required for generate-code",
   type: "string"
+}).option("skipReactQuery", {
+  description: "Skip generating react query",
+  type: "boolean"
+}).option("snippetOnly", {
+  description: "Only generate snippet",
+  type: "boolean"
 }).demandCommand(1).help().argv;
-//# sourceMappingURL=accelbyte-codegen.mjs.map
+//# sourceMappingURL=accelbyte-codegen.mjs.map