@accelbyte/codegen 4.1.5 → 4.2.0

package/dist/accelbyte-codegen.js

@@ -21,9 +21,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/cli.ts
-var import_path5 = __toESM(require("path"));
+var cli_exports = {};
+module.exports = __toCommonJS(cli_exports);
+var import_path6 = __toESM(require("path"));
 var import_yargs = __toESM(require("yargs"));
 
 // src/CliParser.ts
@@ -87,18 +90,55 @@ var CliParser = class _CliParser {
 
 // src/CodeGenerator.ts
 var import_swagger_parser = __toESM(require("@apidevtools/swagger-parser"));
-var import_fs4 = __toESM(require("fs"));
-var import_path3 = __toESM(require("path"));
+var import_fs5 = __toESM(require("fs"));
+var import_path4 = __toESM(require("path"));
+
+// src/CodegenConfig.ts
+var import_fs2 = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_url = require("url");
+var CodegenConfig = class _CodegenConfig {
+  static config = {};
+  static async loadConfig(configDir) {
+    const configPath = import_path.default.join(configDir, "abcodegen.config.ts");
+    if (!import_fs2.default.existsSync(configPath)) {
+      _CodegenConfig.config = {};
+      return;
+    }
+    const loaded = await import((0, import_url.pathToFileURL)(configPath).href);
+    _CodegenConfig.config = loaded.default ?? loaded ?? {};
+  }
+  static shouldProduceIndexFiles() {
+    return _CodegenConfig.config.shouldProduceIndexFiles ?? true;
+  }
+  static getBasePath() {
+    return _CodegenConfig.config.basePath;
+  }
+  static getOverrideAsAny() {
+    return _CodegenConfig.config.overrideAsAny;
+  }
+  static splitOutputByServiceName() {
+    return _CodegenConfig.config.unstable_splitOutputByServiceName ?? false;
+  }
+  /** Reset to defaults — used for testing */
+  static reset() {
+    _CodegenConfig.config = {};
+  }
+  /** Set config directly — used for testing */
+  static setConfig(config) {
+    _CodegenConfig.config = config;
+  }
+};
 
 // src/ParserUtils.ts
 var import_fast_json_patch = require("fast-json-patch");
-var import_fs3 = __toESM(require("fs"));
+var import_fs4 = __toESM(require("fs"));
 var import_lodash = __toESM(require("lodash"));
-var import_path2 = __toESM(require("path"));
+var import_path3 = __toESM(require("path"));
 
 // src/helpers/utils.ts
-var import_fs2 = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
+var import_fs3 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
 var capitalize = (string) => {
   return string.charAt(0).toUpperCase() + string.slice(1);
 };
@@ -160,7 +200,8 @@ var getResponseType = ({
   defaultType = "unknown"
 }) => {
   const responseClass = responseClasses.length === 1 ? responseClasses?.[0] : "unknown";
-  const responseType = responseClass !== "unknown" ? responseClasses?.[0] : defaultType;
+  const rawResponseType = responseClass !== "unknown" ? responseClasses?.[0] : defaultType;
+  const responseType = rawResponseType === "__dictionary__" ? "Record<string, any>" : rawResponseType;
   return {
     responseType,
     responseTypeInAxiosResponse: `Promise<AxiosResponse<${responseType}>>`,
@@ -175,10 +216,10 @@ var getImportableVarMap = () => ({
   zod: ["z"]
 });
 var makeNewImportVarMap = () => ({
-  axios: ["AxiosInstance", "AxiosRequestConfig"],
-  "@accelbyte/sdk": ["SDKRequestConfig"]
+  axios: ["AxiosInstance", "AxiosRequestConfig"]
 });
-var generateImports = (body, importStatements, makeNewImportVarMap3, getImportableVarMap3) => {
+var CLASS_TYPE_ONLY_VARS = /* @__PURE__ */ new Set(["AxiosInstance", "AxiosRequestConfig", "AxiosResponse", "SdkSetConfigParam", "Response"]);
+var generateImports = (body, importStatements, makeNewImportVarMap3, getImportableVarMap3, typeOnlyVars = /* @__PURE__ */ new Set()) => {
   const usedImportVarMap = makeNewImportVarMap3;
   const importableVarMap = getImportableVarMap3;
   for (const [moduleSource, importableVars] of Object.entries(importableVarMap)) {
@@ -189,22 +230,45 @@ var generateImports = (body, importStatements, makeNewImportVarMap3, getImportab
       }
     }
   }
-  const generatedImports = Object.keys(usedImportVarMap).sort().map((moduleSource) => {
-    return `import { ${usedImportVarMap[moduleSource].sort().join(", ")} } from '${moduleSource}'`;
-  }).join("\n");
+  const importLines = [];
+  for (const moduleSource of Object.keys(usedImportVarMap).sort()) {
+    const allVars = usedImportVarMap[moduleSource];
+    const valueVars = allVars.filter((v) => !typeOnlyVars.has(v)).sort();
+    const typeVars = allVars.filter((v) => typeOnlyVars.has(v)).sort();
+    if (valueVars.length > 0) {
+      importLines.push(`import { ${valueVars.join(", ")} } from '${moduleSource}'`);
+    }
+    if (typeVars.length > 0) {
+      importLines.push(`import type { ${typeVars.join(", ")} } from '${moduleSource}'`);
+    }
+  }
+  const generatedImports = importLines.join("\n");
   return `${generatedImports}
 ${importStatements.sort().join("\n")}`;
 };
 var templateClass = (className, body, importStatements) => {
+  const attributes = {
+    definitions: ["private axiosInstance: AxiosInstance", "private namespace: string", "private useSchemaValidation: boolean"],
+    assignments: ["this.axiosInstance = axiosInstance", "this.namespace = namespace", "this.useSchemaValidation = useSchemaValidation"]
+  };
+  let namespaceConstructor = "namespace";
+  if (!body.includes(".replace('{namespace}', this.namespace)")) {
+    namespaceConstructor = "_namespace";
+    attributes.definitions.splice(1, 1);
+    attributes.assignments.splice(1, 1);
+  }
   return `/**
  * AUTO GENERATED
  */
-${generateImports(body, importStatements, makeNewImportVarMap(), getImportableVarMap())}
+${generateImports(body, importStatements, makeNewImportVarMap(), getImportableVarMap(), CLASS_TYPE_ONLY_VARS)}
 
 export class ${className} {
-  // @ts-ignore
-  // prettier-ignore
-  constructor(private axiosInstance: AxiosInstance, private namespace: string, private useSchemaValidation = true) {}
+  ${attributes.definitions.join("\n")}
+
+  constructor(axiosInstance: AxiosInstance, ${namespaceConstructor}: string, useSchemaValidation = true) {
+    ${attributes.assignments.join("\n")}
+  }
+
   ${body}
 }
   `;
@@ -219,6 +283,15 @@ var makeNewImportVarMap2 = () => ({
   "@accelbyte/sdk": ["AccelByteSDK", "SdkSetConfigParam", "ApiUtils", "Network"],
   axios: ["AxiosRequestConfig", "AxiosResponse"]
 });
+var API_TYPE_ONLY_VARS = /* @__PURE__ */ new Set([
+  "AxiosRequestConfig",
+  "AxiosResponse",
+  "AxiosDefaults",
+  "HeadersDefaults",
+  "AccelByteSDK",
+  "SdkSetConfigParam",
+  "Response"
+]);
 var templateApiClass = (className, body, importStatements, returnMethods) => {
   const returnsMethodsWithDescription = Object.keys(returnMethods).reduce((acc, key) => {
     acc += `
@@ -230,43 +303,45 @@ ${key},`;
   return `/**
  * AUTO GENERATED
  */
-/* eslint-disable camelcase */
-// @ts-ignore -> ts-expect-error TS6133
-${generateImports(body, importStatements, makeNewImportVarMap2(), getImportableVarMap2())}
+${generateImports(body, importStatements, makeNewImportVarMap2(), getImportableVarMap2(), API_TYPE_ONLY_VARS)}
 ${`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 ?? []
+  const interceptorsOverride = args?.axiosConfig?.interceptors
 
-  if (requestConfigOverrides || baseURLOverride || interceptorsOverride.length > 0) {
+  if (requestConfigOverrides || baseURLOverride || interceptorsOverride) {
     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 (interceptorsOverride) {
+      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)
+        if (interceptor.type === 'response') {
+          axiosInstance.interceptors.response.use(interceptor.onSuccess, interceptor.onError)
+        }
       }
+    } else {
+      axiosInstance.interceptors = sdkAssembly.axiosInstance.interceptors
     }
   }
 
   ${body}
-  
+
   return {
     ${returnsMethodsWithDescription}
   }
@@ -277,7 +352,7 @@ export function ${className}(sdk: AccelByteSDK, args?: SdkSetConfigParam) {
 // src/ParserQueryUtils.ts
 var ParserQueryUtils = class {
   /**
-   * convert csv 'aa,bb' into "aa='aa', bb='bb'"
+   * convert csv 'aa,bb' into "aa = 'Sdk.Class.aa', bb = 'Sdk.Class.bb'"
    */
   static createQueryKeys(classNameWithoutApi, csvMethodNames, sdkName) {
     const keys = csvMethodNames.split(",");
@@ -288,7 +363,7 @@ var ParserQueryUtils = class {
         const cleanedKey = trimmedKey.replace(/^(get|update|create|patch|delete|post|fetch)[_]?/, "");
         if (!processedKeys.has(cleanedKey)) {
           processedKeys.add(cleanedKey);
-          acc += `${cleanedKey} = '${capitalize(sdkName)}.${classNameWithoutApi}.${cleanedKey}'`;
+          acc += `${cleanedKey}: '${capitalize(sdkName)}.${classNameWithoutApi}.${cleanedKey}'`;
           if (index < keys.length - 1) {
             acc += ",\n";
           }
@@ -302,42 +377,51 @@ var ParserQueryUtils = class {
 
 // 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 lines = [];
+  lines.push("import type { AccelByteSDK, ApiError, SdkSetConfigParam } from '@accelbyte/sdk'");
+  const axiosTypes = ["AxiosError", "AxiosResponse"].filter((t) => body.includes(t));
+  if (axiosTypes.length) {
+    lines.push(`import type { ${axiosTypes.join(", ")} } from 'axios'`);
+  }
+  const rqValues = ["useMutation", "useQuery"].filter((t) => body.includes(t));
+  if (rqValues.length) {
+    lines.push(`import { ${rqValues.join(", ")} } from '@tanstack/react-query'`);
+  }
+  const rqTypes = ["UseMutationOptions", "UseMutationResult", "UseQueryOptions", "UseQueryResult"].filter((t) => body.includes(t));
+  if (rqTypes.length) {
+    lines.push(`import type { ${rqTypes.join(", ")} } from '@tanstack/react-query'`);
+  }
+  lines.push(`import { ${className} } from "../${className}.js"`);
+  return lines.join("\n") + "\n";
 };
 var templateQuery = (className, body, importStatements, serviceNameTitle, returnMethods, paramImports, sdkName) => {
   const classNameWithoutApi = className.replace("Api", "");
   const queryKeys = ParserQueryUtils.createQueryKeys(classNameWithoutApi, returnMethods, sdkName);
   const generatedImports = generateImports2(body, className);
+  const queryKeyBlock = `export const Key_${classNameWithoutApi} = {
+  ${queryKeys}
+} as const`;
   return `/**
  * AUTO GENERATED
  */
-/* eslint-disable camelcase */
 ${generatedImports}
 ${filterUsedImports(paramImports, body)}
 
-export enum Key_${classNameWithoutApi} {
-  ${queryKeys}
-}
+${queryKeyBlock}
 
   ${body}
   `;
 };
 function filterUsedImports(importArr, body) {
-  return importArr.filter((path8) => {
-    const start = path8.indexOf("{") + 1;
-    const end = path8.indexOf("}");
+  return importArr.filter((path9) => {
+    const start = path9.indexOf("{") + 1;
+    const end = path9.indexOf("}");
     if (start > 0 && end > start) {
-      const importName = path8.slice(start, end).trim();
+      const importName = path9.slice(start, end).trim();
       return body.includes(importName);
     }
     return false;
-  }).map((path8) => path8).join("\n") + "\n";
+  }).map((path9) => path9).join("\n") + "\n";
 }
 
 // src/ParserUtils.ts
@@ -354,8 +438,8 @@ var REMOVED_KEYWORDS = [
   "/{namespace}/"
 ];
 var ParserUtils = class _ParserUtils {
-  static getVersionSuffixFromPath(path8) {
-    const version2_3_4_etc = path8.match(/\/v([2-9]|[1-9]\d+)\/+/);
+  static getVersionSuffixFromPath(path9) {
+    const version2_3_4_etc = path9.match(/\/v([2-9]|[1-9]\d+)\/+/);
     const methodSuffix = version2_3_4_etc ? `_v${version2_3_4_etc[1]}` : "";
     return methodSuffix;
   }
@@ -437,13 +521,14 @@ var ParserUtils = class _ParserUtils {
   };
   static parseRefImport = (bodyParam) => {
     const $ref = bodyParam?.schema?.$ref || bodyParam?.schema?.items?.$ref;
-    if (!$ref) {
+    if (!$ref || $ref.endsWith("__dictionary__")) {
       return null;
     }
     const type = _ParserUtils.parseRefType($ref);
     return `import { ${type} } from '../../generated-definitions/${type}.js'`;
   };
   static parseRefType = ($ref) => {
+    if ($ref.endsWith("__dictionary__")) return "__dictionary__";
     let ref = $ref.replace(".", "/");
     if (ref[ref.length - 1] === "." || ref[ref.length - 1] === "/") {
       ref = ref.slice(0, -1);
@@ -550,14 +635,14 @@ var ParserUtils = class _ParserUtils {
    * to this
    * `createGenerateByRequestIdByUserId`
    */
-  static generateNaturalLangMethod = ({ servicePrefix, path: path8, httpMethod, isForm, existingMethods, permissionType }) => {
-    let path_ = path8;
+  static generateNaturalLangMethod = ({ servicePrefix, path: path9, httpMethod, isForm, existingMethods, permissionType }) => {
+    let path_ = path9;
     path_ = path_.replace(`/${servicePrefix}/`, "/");
     REMOVED_KEYWORDS.forEach((prefix) => {
       path_ = path_.replace(prefix, "/");
     });
     path_ = path_.substring(1);
-    const isPlural = httpMethod === "get" && !(path8.slice(-1) === "}");
+    const isPlural = httpMethod === "get" && !(path9.slice(-1) === "}");
     if (!isPlural) {
       path_ = _ParserUtils.replaceAll(path_, "ies/", "y/");
       path_ = _ParserUtils.replaceAll(path_, "s/", "/");
@@ -600,9 +685,9 @@ var ParserUtils = class _ParserUtils {
     const genPath = import_lodash.default.upperFirst(lastWords) + "/" + listBeforeLastWords.join("/") + listByParams.reverse().join("/");
     let generatedMethod = import_lodash.default.camelCase(mappedMethod(httpMethod, isForm, permissionType) + genPath);
     generatedMethod = _ParserUtils.replaceAll(generatedMethod, "Byword", "_By");
-    const testedGeneratedMethod = generatedMethod + _ParserUtils.getVersionSuffixFromPath(path8);
-    generatedMethod = resolveConflicts({ path: path8, generatedMethod, testedGeneratedMethod, existingMethods });
-    generatedMethod = generatedMethod + _ParserUtils.getVersionSuffixFromPath(path8);
+    const testedGeneratedMethod = generatedMethod + _ParserUtils.getVersionSuffixFromPath(path9);
+    generatedMethod = resolveConflicts({ path: path9, generatedMethod, testedGeneratedMethod, existingMethods });
+    generatedMethod = generatedMethod + _ParserUtils.getVersionSuffixFromPath(path9);
     return generatedMethod;
   };
   static filterBodyParams(parameters) {
@@ -618,17 +703,17 @@ var ParserUtils = class _ParserUtils {
     return parameters.filter((parameter) => parameter.in === "query");
   }
   static mkdirIfNotExist(dirToCreate) {
-    if (!import_fs3.default.existsSync(dirToCreate)) {
-      import_fs3.default.mkdirSync(dirToCreate, { recursive: true });
+    if (!import_fs4.default.existsSync(dirToCreate)) {
+      import_fs4.default.mkdirSync(dirToCreate, { recursive: true });
     }
   }
   static writeClassFile(distDir, apiName, apiBuffer, imports) {
     const fileContent = templateClass(apiName, apiBuffer, imports);
-    import_fs3.default.writeFileSync(`${distDir}/${apiName}.ts`, _ParserUtils.prependCopyrightHeader(fileContent));
+    import_fs4.default.writeFileSync(`${distDir}/${apiName}.ts`, _ParserUtils.prependCopyrightHeader(fileContent));
   }
   static writeAtomFile(distDir, apiName, fileContent) {
     _ParserUtils.mkdirIfNotExist(distDir);
-    import_fs3.default.writeFileSync(`${distDir}/${apiName}.atom.ts`, _ParserUtils.prependCopyrightHeader(fileContent));
+    import_fs4.default.writeFileSync(`${distDir}/${apiName}.atom.ts`, _ParserUtils.prependCopyrightHeader(fileContent));
   }
   static writeQueryFile(distDir, apiName, apiBuffer, imports, serviceNameTitle, returnMethods, paramImports, sdkName) {
     if (apiBuffer.length < 1) {
@@ -637,20 +722,21 @@ var ParserUtils = class _ParserUtils {
     const queryFileName = `${apiName.replace("Api", "")}.query`;
     _ParserUtils.mkdirIfNotExist(distDir);
     const fileContent = templateQuery(apiName, apiBuffer, imports, serviceNameTitle, returnMethods, paramImports, sdkName);
-    import_fs3.default.writeFileSync(`${distDir}/${queryFileName}.ts`, _ParserUtils.prependCopyrightHeader(fileContent));
+    import_fs4.default.writeFileSync(`${distDir}/${queryFileName}.ts`, _ParserUtils.prependCopyrightHeader(fileContent));
     return queryFileName;
   }
   static writeXVersion(distDir, xversionJson, apiInfo) {
+    import_fs4.default.mkdirSync(distDir, { recursive: true });
     if (xversionJson) {
       console.log("x-version:", xversionJson);
-      import_fs3.default.writeFileSync(`${distDir}/version.json`, JSON.stringify(xversionJson, null, 2));
+      import_fs4.default.writeFileSync(`${distDir}/version.json`, JSON.stringify(xversionJson, null, 2));
     } else {
       const customVersion = {
         ...apiInfo,
         gitHash: apiInfo.version
       };
       console.error(`!!!! Missing x-version for ${distDir} ${customVersion}`);
-      import_fs3.default.writeFileSync(`${distDir}/version.json`, JSON.stringify(customVersion, null, 2));
+      import_fs4.default.writeFileSync(`${distDir}/version.json`, JSON.stringify(customVersion, null, 2));
     }
   }
   static writeApiFile(distDir, apiName, apiBuffer, imports, returnMethodsDescription) {
@@ -659,28 +745,28 @@ var ParserUtils = class _ParserUtils {
       newImports.push(el.replace("../../generated-definitions", "../generated-definitions"));
     });
     const fileContent = templateApiClass(apiName, apiBuffer, newImports, returnMethodsDescription);
-    import_fs3.default.writeFileSync(`${distDir}/${apiName}.ts`, _ParserUtils.prependCopyrightHeader(fileContent));
+    import_fs4.default.writeFileSync(`${distDir}/${apiName}.ts`, _ParserUtils.prependCopyrightHeader(fileContent));
   }
   static writeApiMainFile(distDir, serviceName, fileContent) {
-    import_fs3.default.writeFileSync(`${distDir}/${serviceName}.ts`, _ParserUtils.prependCopyrightHeader(fileContent));
+    import_fs4.default.writeFileSync(`${distDir}/${serviceName}.ts`, _ParserUtils.prependCopyrightHeader(fileContent));
   }
   static writeSnippetFile(distDir, name, docBuffer) {
     let snippetFileName = _ParserUtils.replaceAll(name, " ", "-").toLowerCase();
     snippetFileName = snippetFileName.replace("justice-", "");
     snippetFileName = "snippet-" + snippetFileName + ".json";
-    import_fs3.default.writeFileSync(`${distDir}/${snippetFileName}`, docBuffer);
+    import_fs4.default.writeFileSync(`${distDir}/${snippetFileName}`, docBuffer);
   }
   static writeDefinitionFile(distDir, name, buffer) {
     _ParserUtils.mkdirIfNotExist(distDir);
-    import_fs3.default.writeFileSync(import_path2.default.join(distDir, `${name}.ts`), _ParserUtils.prependCopyrightHeader(buffer));
+    import_fs4.default.writeFileSync(import_path3.default.join(distDir, `${name}.ts`), _ParserUtils.prependCopyrightHeader(buffer));
   }
   static writeAllImportsFile(distDir, buffer) {
     _ParserUtils.mkdirIfNotExist(distDir);
-    import_fs3.default.writeFileSync(import_path2.default.join(distDir, "all-imports.ts"), _ParserUtils.prependCopyrightHeader(buffer));
+    import_fs4.default.writeFileSync(import_path3.default.join(distDir, "all-imports.ts"), _ParserUtils.prependCopyrightHeader(buffer));
   }
   static writeAllQueryImportsFile(distDir, buffer) {
     _ParserUtils.mkdirIfNotExist(distDir);
-    import_fs3.default.writeFileSync(import_path2.default.join(distDir, "all-query-imports.ts"), _ParserUtils.prependCopyrightHeader(buffer));
+    import_fs4.default.writeFileSync(import_path3.default.join(distDir, "all-query-imports.ts"), _ParserUtils.prependCopyrightHeader(buffer));
   }
   static toCamelCase(str) {
     return str.split("/").map(function(word, index) {
@@ -706,15 +792,15 @@ var ParserUtils = class _ParserUtils {
     });
   }
   static applyPatchIfExists(swaggerFilePath, possibleSwaggerPatchFilePath, swaggerPatchedFilePath, swaggerPatchedDir) {
-    if (!import_fs3.default.existsSync(swaggerPatchedDir)) {
-      import_fs3.default.mkdirSync(swaggerPatchedDir, { recursive: true });
+    if (!import_fs4.default.existsSync(swaggerPatchedDir)) {
+      import_fs4.default.mkdirSync(swaggerPatchedDir, { recursive: true });
     }
-    if (!import_fs3.default.existsSync(possibleSwaggerPatchFilePath)) {
-      import_fs3.default.copyFileSync(swaggerFilePath, swaggerPatchedFilePath);
+    if (!import_fs4.default.existsSync(possibleSwaggerPatchFilePath)) {
+      import_fs4.default.copyFileSync(swaggerFilePath, swaggerPatchedFilePath);
       return;
     }
-    const swaggerContent = JSON.parse(import_fs3.default.readFileSync(swaggerFilePath, "utf8"));
-    const swaggerPatchFileContent = JSON.parse(import_fs3.default.readFileSync(possibleSwaggerPatchFilePath, "utf8"));
+    const swaggerContent = JSON.parse(import_fs4.default.readFileSync(swaggerFilePath, "utf8"));
+    const swaggerPatchFileContent = JSON.parse(import_fs4.default.readFileSync(possibleSwaggerPatchFilePath, "utf8"));
     for (const patchEntry of swaggerPatchFileContent) {
       const segments = patchEntry.path.split("/").filter(Boolean);
       let currentNode = swaggerContent;
@@ -742,7 +828,7 @@ var ParserUtils = class _ParserUtils {
       }
     }
     const { newDocument } = (0, import_fast_json_patch.applyPatch)(swaggerContent, swaggerPatchFileContent);
-    import_fs3.default.writeFileSync(swaggerPatchedFilePath, JSON.stringify(newDocument, null, 2));
+    import_fs4.default.writeFileSync(swaggerPatchedFilePath, JSON.stringify(newDocument, null, 2));
   }
   static getRelativePathToWebSdkSrcFolder(srcFolder, targetSrcFolder) {
     const replaced = srcFolder.replace(/\\/g, "/");
@@ -757,8 +843,8 @@ var ParserUtils = class _ParserUtils {
  */
 ${content}`;
   };
-  static sortPathParamsByPath = (pathParams, path8) => {
-    const params = path8.match(/{\w*}/g) || [];
+  static sortPathParamsByPath = (pathParams, path9) => {
+    const params = path9.match(/{\w*}/g) || [];
     const cleanParams = params.map((param) => param.replace("{", "").replace("}", ""));
     return pathParams.sort((a, b) => cleanParams.indexOf(a.name) - cleanParams.indexOf(b.name));
   };
@@ -782,30 +868,40 @@ var mappedMethod = (httpMethod, isForm, permissionType) => {
     return "delete";
   }
 };
-var resolveConflicts = ({ path: path8, generatedMethod, testedGeneratedMethod, existingMethods }) => {
+var resolveConflicts = ({ path: path9, generatedMethod, testedGeneratedMethod, existingMethods }) => {
   let _testedGenMethod = testedGeneratedMethod;
   try {
-    testConflict(path8, _testedGenMethod, existingMethods);
+    testConflict(path9, _testedGenMethod, existingMethods);
   } catch (e) {
-    if (path8.indexOf("/namespaces/") >= 0) {
+    if (path9.indexOf("/namespaces/") >= 0) {
       generatedMethod += "_ByNS";
       _testedGenMethod += "_ByNS";
     }
   }
   try {
-    testConflict(path8, _testedGenMethod, existingMethods);
+    testConflict(path9, _testedGenMethod, existingMethods);
   } catch (e) {
-    if (path8.indexOf("/admin/") >= 0) {
+    if (path9.indexOf("/admin/") >= 0) {
       generatedMethod += "_admin";
       _testedGenMethod += "_admin";
     }
   }
-  testConflict(path8, _testedGenMethod, existingMethods);
+  try {
+    testConflict(path9, _testedGenMethod, existingMethods);
+  } catch (e) {
+    const parentSegmentMatch = path9.match(/\/([^/{}]+)\/{[^}]+}\/[^/]*$/);
+    if (parentSegmentMatch) {
+      const suffix = "_By" + import_lodash.default.upperFirst(import_lodash.default.camelCase(parentSegmentMatch[1]));
+      generatedMethod += suffix;
+      _testedGenMethod += suffix;
+    }
+  }
+  testConflict(path9, _testedGenMethod, existingMethods);
   return generatedMethod;
 };
-var testConflict = (path8, generatedMethod, existingMethods) => {
+var testConflict = (path9, generatedMethod, existingMethods) => {
   if (existingMethods[generatedMethod]) {
-    const conflictingMethod = { path: path8, generatedMethod };
+    const conflictingMethod = { path: path9, generatedMethod };
     throw Error(
       `Duplicate method conflict in ${JSON.stringify(conflictingMethod)},
  existingMethods: ${JSON.stringify(existingMethods, null, 2)}`
@@ -922,7 +1018,7 @@ var OpenApiSpec = import_zod2.z.object({
 var templateApiMethod = ({
   classMethod,
   httpMethod,
-  path: path8,
+  path: path9,
   pathParams,
   bodyParams,
   responseClasses,
@@ -931,12 +1027,12 @@ var templateApiMethod = ({
   methodParamsNoTypes,
   xSecurity
 }) => {
-  let newPath = `'${path8}'`;
+  let newPath = `'${path9}'`;
   let snippetMethod = "";
   for (const pathParam of pathParams) {
     const type = ParserUtils.parseType(pathParam);
     const pName = pathParam.name === "namespace" ? "this.namespace" : pathParam.name;
-    if (path8.match(`{${pathParam.name}}`)) {
+    if (path9.match(`{${pathParam.name}}`)) {
       if (type === "string") {
         newPath = `${newPath}.replace('{${pathParam.name}}', ${pName})`;
       } else {
@@ -944,9 +1040,9 @@ var templateApiMethod = ({
       }
     }
   }
-  const snippetShellArgs = ["--location --request", `${httpMethod} '__DOMAIN__${path8}'`, "--header 'accept: application/json'"];
+  const snippetShellArgs = ["--location --request", `${httpMethod} '__DOMAIN__${path9}'`, "--header 'accept: application/json'"];
   const snippetApiArgs = [];
-  if (xSecurity !== void 0 || path8.includes("/admin")) {
+  if (xSecurity !== void 0 || path9.includes("/admin")) {
     snippetShellArgs.push("--header 'Authorization: Bearer {access_token}'");
     snippetApiArgs.push("{ axiosConfig: { request: { headers: { Authorization: 'Bearer {access_token}' } } } }".trim());
   }
@@ -984,7 +1080,7 @@ var templateMethod = ({
   classMethod,
   description,
   httpMethod,
-  path: path8,
+  path: path9,
   pathParams,
   bodyParams,
   queryParams,
@@ -994,9 +1090,9 @@ var templateMethod = ({
 }) => {
   let methodParams = "";
   let methodParamsNoTypes = "";
-  let newPath = `'${path8}'`;
+  let newPath = `'${path9}'`;
   let importStatements = [];
-  const sortedPathParams = ParserUtils.sortPathParamsByPath(pathParams, path8);
+  const sortedPathParams = ParserUtils.sortPathParamsByPath(pathParams, path9);
   for (const pathParam of sortedPathParams) {
     const type = ParserUtils.parseType(pathParam);
     if (pathParam.name !== "namespace") {
@@ -1004,7 +1100,7 @@ var templateMethod = ({
       methodParamsNoTypes += pathParam.name + ", ";
     }
     const pName = pathParam.name === "namespace" ? "this.namespace" : pathParam.name;
-    if (path8.match(`{${pathParam.name}}`)) {
+    if (path9.match(`{${pathParam.name}}`)) {
       if (type === "string") {
         newPath = `${newPath}.replace('{${pathParam.name}}', ${pName})`;
       } else {
@@ -1015,6 +1111,7 @@ var templateMethod = ({
   let dataType = null;
   if (httpMethod !== "get") {
     dataType = ParserUtils.parseBodyParamsType(bodyParams);
+    if (dataType === "__dictionary__") dataType = "Record<string, any>";
     importStatements = ParserUtils.parseBodyParamsImports(bodyParams);
     methodParams += dataType ? `data: ${dataType},` : "";
     methodParamsNoTypes += dataType ? `data,` : "";
@@ -1038,7 +1135,7 @@ var templateMethod = ({
   }
   const isFileUpload = methodParams.indexOf("data: {file") > -1;
   const { responseType, responseTypeInResponse } = getResponseType({ responseClasses });
-  const resolvedResponseClassValidated = responseType !== "unknown" ? `${responseType}` : "z.unknown()";
+  const resolvedResponseClassValidated = responseClasses.length === 1 && responseClasses[0] === "__dictionary__" ? "z.record(z.string(), z.any())" : responseType !== "unknown" ? `${responseType}` : "z.unknown()";
   methodParams = (queryParamsType ? `${methodParams} ${queryParamsType}` : methodParams).replace(/,\s*$/, "");
   methodParamsNoTypes = queryParamsType ? `${methodParamsNoTypes} queryParams` : methodParamsNoTypes;
   const isGuardInvoked = ["get", "post", "put", "patch", "delete"].includes(httpMethod);
@@ -1069,7 +1166,7 @@ var POST_FETCH_INCLUDES_PATH = ["/table-query/"];
 var templateQueryMethod = ({
   classMethod,
   httpMethod,
-  path: path8,
+  path: path9,
   pathParams,
   responseClasses,
   methodParams,
@@ -1077,14 +1174,14 @@ var templateQueryMethod = ({
   description,
   deprecated
 }) => {
-  const isPostFetch = httpMethod === "post" && (POST_FETCH_INCLUDES_PATH.some((p) => path8.includes(p)) || path8.endsWith("/list"));
+  const isPostFetch = httpMethod === "post" && (POST_FETCH_INCLUDES_PATH.some((p) => path9.includes(p)) || path9.endsWith("/list"));
   const isFetch = classMethod.startsWith("fetch");
   const isGet = httpMethod === "get" || isPostFetch || isFetch;
   const queryMethod = isGet ? "useQuery" : "useMutation";
   let mParams = "";
   let mParamsNoTypes = "";
-  let newPath = `'${path8}'`;
-  const sortedPathParams = ParserUtils.sortPathParamsByPath(pathParams, path8);
+  let newPath = `'${path9}'`;
+  const sortedPathParams = ParserUtils.sortPathParamsByPath(pathParams, path9);
   for (const pathParam of sortedPathParams) {
     const type = ParserUtils.parseType(pathParam);
     if (pathParam.name !== "namespace") {
@@ -1092,7 +1189,7 @@ var templateQueryMethod = ({
       mParamsNoTypes += pathParam.name + ", ";
     }
     const pName = pathParam.name === "namespace" ? "this.namespace" : pathParam.name;
-    if (path8.match(`{${pathParam.name}}`)) {
+    if (path9.match(`{${pathParam.name}}`)) {
       if (type === "string") {
         newPath = `${newPath}.replace('{${pathParam.name}}', ${pName})`;
       } else {
@@ -1127,7 +1224,7 @@ export const ${_methodName} = (
       const response = 
             (await ${apiGenName}(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).
                 ${classMethod}(${_methodParamsImpl}))
-      callback && callback(response)
+      callback?.(response)
       return response.data
   }
   
@@ -1152,7 +1249,7 @@ export const ${_methodName} = (
       const response = 
             (await ${apiGenName}(sdk, { coreConfig: input.coreConfig, axiosConfig: input.axiosConfig }).
                 ${classMethod}(${_methodParamsImpl}))
-      callback && callback(response.data)
+      callback?.(response.data)
       return response.data
   }
   
@@ -1331,11 +1428,11 @@ var SwaggerReaderHelpers = class _SwaggerReaderHelpers {
       admin: {},
       public: {}
     };
-    for (const [path8, operation] of sortedPathsByLength) {
-      if (path8.indexOf("/healthz") >= 0) {
+    for (const [path9, operation] of sortedPathsByLength) {
+      if (path9.indexOf("/healthz") >= 0) {
         continue;
       }
-      const isAdminEndpoint = path8.indexOf("/admin/") > -1;
+      const isAdminEndpoint = path9.indexOf("/admin/") > -1;
       const picked = isAdminEndpoint ? result.admin : result.public;
       const {
         arrayDefinitions,
@@ -1353,25 +1450,27 @@ var SwaggerReaderHelpers = class _SwaggerReaderHelpers {
       const httpMethods = Object.keys(operation);
       for (const httpMethod of httpMethods) {
         const endpoint = await Endpoint.parseAsync(operation[httpMethod]).catch((error) => {
-          console.error(JSON.stringify({ path: path8, httpMethod }, null, 2));
+          console.error(JSON.stringify({ path: path9, httpMethod }, null, 2));
           throw error;
         });
         if (!endpoint.tags) continue;
         const [tag] = endpoint.tags;
-        const pathWithBase = `${api.basePath ?? ""}${path8}`;
+        const configBasePath = CodegenConfig.getBasePath();
+        const effectiveBasePath = configBasePath !== void 0 ? configBasePath : api.basePath ?? "";
+        const pathWithBase = `${effectiveBasePath}${path9}`;
         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: path8,
+          path: path9,
           httpMethod,
           isForm,
           existingMethods: tagToClassMethodsMapByType[tag],
           permissionType
         });
-        tagToClassMethodsMapByType[tag][classMethod] = `${path8} ${httpMethod}`;
-        generatedMethods[`${path8} ${httpMethod}`] = `${classMethod}`;
+        tagToClassMethodsMapByType[tag][classMethod] = `${path9} ${httpMethod}`;
+        generatedMethods[`${path9} ${httpMethod}`] = `${classMethod}`;
         if (!snippetMap[pathWithBase]) {
           snippetMap[pathWithBase] = {};
         }
@@ -1380,7 +1479,7 @@ var SwaggerReaderHelpers = class _SwaggerReaderHelpers {
         const responseClass = responseClasses.length > 1 ? null : responseClasses?.[0];
         const { className, classGenName } = ParserUtils.generateClassName(tag, isAdminEndpoint);
         tagToClassImportsRecord[className] = tagToClassImportsRecord[className] ? tagToClassImportsRecord[className] : {};
-        if (responseClass) {
+        if (responseClass && responseClass !== "__dictionary__") {
           tagToClassImportsRecord[className][responseClass] = `import { ${responseClass} } from '../../generated-definitions/${responseClass}.js'`;
         }
         if (responseClass && responseClass.endsWith("Array")) {
@@ -1526,6 +1625,20 @@ var TemplateZod = class {
   // --
   render = (fileName, definition, duplicates) => {
     this.duplicates = duplicates;
+    const overrideAsAny = CodegenConfig.getOverrideAsAny();
+    const override = overrideAsAny?.[fileName];
+    if (override !== void 0) {
+      const shouldOverride = typeof override === "function" ? override(definition) : override;
+      if (shouldOverride) {
+        const template2 = `import { z } from 'zod'
+
+export const ${fileName} = z.any()
+
+export interface ${fileName} extends z.TypeOf<typeof ${fileName}> {}
+  `;
+        return { buffer: template2, duplicateFound: false };
+      }
+    }
     const content = this.parseToZodSchema(definition, definition.required || []);
     const containsRecursiveType = this.importClasses.has(fileName);
     if (containsRecursiveType) {
@@ -1614,7 +1727,14 @@ ${exportedTypeString}
       };
     } else if (type) {
       if (type === "object" && definition.additionalProperties) {
-        const zodAttribute = this.parseToZodAttribute("", definition.additionalProperties, [""]);
+        const additionalProps = definition.additionalProperties;
+        if (Object.keys(additionalProps).length === 0) {
+          return {
+            schemaString: `${schemaAttribute} z.record(z.any())${schemaRequired}`,
+            typeString: `${typeAttribute} Record<string, any>${typeNullishability}`
+          };
+        }
+        const zodAttribute = this.parseToZodAttribute("", additionalProps, [""]);
         return {
           schemaString: `${schemaAttribute} z.record(${zodAttribute.schemaString})${schemaRequired}`,
           typeString: `${typeAttribute} Record<string, ${zodAttribute.typeString}>${typeNullishability}`
@@ -1800,8 +1920,11 @@ var CodeGenerator = class _CodeGenerator {
     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 });
+    const isSplitByService = CodegenConfig.splitOutputByServiceName();
+    const srcFolder = isSplitByService ? import_path4.default.join(CliParser.getOutputPath(), serviceName) : CliParser.getOutputPath();
+    const targetSrcFolder = `${CliParser.getOutputPath()}/`;
     if (!CliParser.isGenerateSnippetOnly()) {
-      ParserUtils.writeXVersion(_CodeGenerator.srcFolder(), api["x-version"], api.info);
+      ParserUtils.writeXVersion(srcFolder, api["x-version"], api.info);
     }
     const parsedInformation = await SwaggerReaderHelpers.parseAllEndpoints({ api, sdkName, serviceName });
     if (CliParser.getSnippetOutputPath()) {
@@ -1827,11 +1950,10 @@ var CodeGenerator = class _CodeGenerator {
       console.log("\nSuccessfully generate SDK snippets only\n----------\n\n");
       return;
     }
-    const DIST_DIR = (isAdmin) => `${_CodeGenerator.getGeneratedFolder(isAdmin)}`;
-    const DIST_DIR_ENDPOINTS = (isAdmin) => import_path3.default.join(DIST_DIR(isAdmin), "endpoints");
-    const DIST_DIR_QUERIES = (isAdmin) => import_path3.default.join(DIST_DIR(isAdmin), "queries");
-    const DIST_DEFINITION_DIR = import_path3.default.join(_CodeGenerator.srcFolder(), "generated-definitions");
-    const targetSrcFolder = `${_CodeGenerator.srcFolder()}/`;
+    const DIST_DIR = (isAdmin) => import_path4.default.join(srcFolder, isAdmin ? "generated-admin" : "generated-public");
+    const DIST_DIR_ENDPOINTS = (isAdmin) => import_path4.default.join(DIST_DIR(isAdmin), "endpoints");
+    const DIST_DIR_QUERIES = (isAdmin) => import_path4.default.join(DIST_DIR(isAdmin), "queries");
+    const DIST_DEFINITION_DIR = import_path4.default.join(srcFolder, "generated-definitions");
     _CodeGenerator.prepareDirs(DIST_DEFINITION_DIR, DIST_DIR, DIST_DIR_ENDPOINTS, DIST_DIR_QUERIES);
     const mainApiList = [];
     const generatedDefinitions = [];
@@ -1872,30 +1994,31 @@ var CodeGenerator = class _CodeGenerator {
           ParserUtils.writeApiFile(DIST_DIR(isAdminEndpoint), apiGenName, apiBuffer, imports, tagToSdkFunctionDescription[tag]);
           apiList.push(apiGenName);
           indexImportsSet.add(
-            ParserUtils.getRelativePathToWebSdkSrcFolder(import_path3.default.join(DIST_DIR_ENDPOINTS(isAdminEndpoint), `${classGenName}`), targetSrcFolder)
+            ParserUtils.getRelativePathToWebSdkSrcFolder(import_path4.default.join(DIST_DIR_ENDPOINTS(isAdminEndpoint), `${classGenName}`), targetSrcFolder)
           );
           indexImportsSet.add(
-            ParserUtils.getRelativePathToWebSdkSrcFolder(import_path3.default.join(DIST_DIR(isAdminEndpoint), `${apiGenName}`), targetSrcFolder)
+            ParserUtils.getRelativePathToWebSdkSrcFolder(import_path4.default.join(DIST_DIR(isAdminEndpoint), `${apiGenName}`), targetSrcFolder)
           );
           queryFileName && queryImportsSet.add(
             ParserUtils.getRelativePathToWebSdkSrcFolder(
-              import_path3.default.join(DIST_DIR(isAdminEndpoint), "queries", `${queryFileName}`),
+              import_path4.default.join(DIST_DIR(isAdminEndpoint), "queries", `${queryFileName}`),
               targetSrcFolder
             )
           );
         }
         mainApiList.push(...apiList);
-        indexImportsSet.add(
-          ParserUtils.getRelativePathToWebSdkSrcFolder(import_path3.default.join(_CodeGenerator.srcFolder(), serviceNameTitle), targetSrcFolder)
-        );
+        if (CodegenConfig.shouldProduceIndexFiles()) {
+          indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(import_path4.default.join(srcFolder, serviceNameTitle), targetSrcFolder));
+        }
       };
       const writeDefinitions = (api2) => {
         const duplicates = /* @__PURE__ */ new Map();
         const definitions = api2?.components?.schemas || api2.definitions;
         for (const ref in definitions) {
+          if (ref === "__dictionary__") continue;
           const definition = definitions[ref];
           const fileName = ParserUtils.parseRefType(ref);
-          const fileExist = import_fs4.default.existsSync(import_path3.default.join(DIST_DEFINITION_DIR, `${fileName}.ts`));
+          const fileExist = import_fs5.default.existsSync(import_path4.default.join(DIST_DEFINITION_DIR, `${fileName}.ts`));
           if (fileExist) {
             const duplicateName = ParserUtils.toCamelCaseWord(ref).replace(".", "").replace(".", "");
             duplicates.set(ref, duplicateName);
@@ -1903,13 +2026,13 @@ var CodeGenerator = class _CodeGenerator {
           const { buffer } = new TemplateZod().render(fileName, definition, /* @__PURE__ */ new Map());
           generatedDefinitions.push(fileName);
           ParserUtils.writeDefinitionFile(DIST_DEFINITION_DIR, fileName, buffer);
-          indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(import_path3.default.join(DIST_DEFINITION_DIR, fileName), targetSrcFolder));
+          indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(import_path4.default.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(import_path3.default.join(DIST_DEFINITION_DIR, arrayClass), targetSrcFolder));
+          indexImportsSet.add(ParserUtils.getRelativePathToWebSdkSrcFolder(import_path4.default.join(DIST_DEFINITION_DIR, arrayClass), targetSrcFolder));
         }
       };
       writeApiEndpointFiles(isAdmin);
@@ -1917,9 +2040,11 @@ var CodeGenerator = class _CodeGenerator {
     };
     generatePublicOrAdmin(true);
     generatePublicOrAdmin(false);
-    const isGenerateWebSocket = CliParser.isGenerateWebSocket();
-    const apiIndexBuff = templateApiIndex(serviceNameTitle, mainApiList, isGenerateWebSocket);
-    ParserUtils.writeApiMainFile(_CodeGenerator.srcFolder(), serviceNameTitle, apiIndexBuff);
+    if (CodegenConfig.shouldProduceIndexFiles()) {
+      const isGenerateWebSocket = CliParser.isGenerateWebSocket();
+      const apiIndexBuff = templateApiIndex(serviceNameTitle, mainApiList, isGenerateWebSocket);
+      ParserUtils.writeApiMainFile(srcFolder, serviceNameTitle, apiIndexBuff);
+    }
     console.log("\nCOMPLETED\n----------\n\n");
     return { indexImports: indexImportsSet, queryImports: queryImportsSet };
   };
@@ -1927,29 +2052,30 @@ var CodeGenerator = class _CodeGenerator {
 };
 
 // src/SwaggerDownloader.ts
+var fs6 = __toESM(require("fs"));
 var https = __toESM(require("https"));
-var fs5 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+var path6 = __toESM(require("path"));
 var SwaggerDownloader = class _SwaggerDownloader {
   static getDestFile = (targetFileName) => {
     const destPath = CliParser.getResolvedSwaggersOutputPath();
-    const destFile = path5.join(destPath, targetFileName);
-    if (fs5.existsSync(destFile)) return destFile;
-    if (!fs5.existsSync(destPath)) fs5.mkdirSync(destPath);
-    fs5.writeFileSync(destFile, "");
+    const destFile = path6.join(destPath, targetFileName);
+    if (fs6.existsSync(destFile)) return destFile;
+    if (!fs6.existsSync(destPath)) fs6.mkdirSync(destPath);
+    fs6.writeFileSync(destFile, "");
     return destFile;
   };
   // session-api.json contains illegal URL encoded character that breaks the codegen
   // e.g. "$ref": "#/definitions/map%5Bstring%5Dinterface%20%7B%7D"
   static postSanitizeDownloadedFile = (filePath) => {
     const searchStr = ["%5B", "%5D", "%20", "%7B", "%7D"];
-    fs5.readFile(filePath, "utf8", (err, data) => {
+    fs6.readFile(filePath, "utf8", (err, data) => {
       if (err) throw err;
       let result = data;
+      result = result.replace(new RegExp("map%5Bstring%5Dinterface%20%7B%7D", "g"), "__dictionary__").replace(new RegExp("map\\[string\\]interface \\{\\}", "g"), "__dictionary__").replace(new RegExp("map\\[string\\]any", "g"), "__dictionary__");
       searchStr.forEach((s) => {
         result = result.replace(new RegExp(s, "g"), " ");
       });
-      fs5.writeFile(filePath, result, "utf8", (err2) => {
+      fs6.writeFile(filePath, result, "utf8", (err2) => {
         if (err2) throw err2;
         console.log("File updated successfully.");
       });
@@ -1967,7 +2093,7 @@ var SwaggerDownloader = class _SwaggerDownloader {
           if (response.statusCode !== 200) {
             console.log(`SwaggerDownload error with status code: ${response.statusCode}`);
           } else {
-            fs5.writeFileSync(destFile, JSON.stringify(JSON.parse(data), null, 2), "utf-8");
+            fs6.writeFileSync(destFile, JSON.stringify(JSON.parse(data), null, 2), "utf-8");
             _SwaggerDownloader.postSanitizeDownloadedFile(destFile);
             console.log(`SwaggerDownload ${url} completed with status code: ${response.statusCode}`);
           }
@@ -1990,8 +2116,8 @@ var SwaggerDownloader = class _SwaggerDownloader {
 };
 
 // src/WebsocketGenerator.ts
-var import_fs5 = __toESM(require("fs"));
-var import_path4 = __toESM(require("path"));
+var import_fs6 = __toESM(require("fs"));
+var import_path5 = __toESM(require("path"));
 
 // src/templates/template-ws-class.ts
 var definitionToFunctionName = (type) => {
@@ -2006,7 +2132,7 @@ var renderSendFunction = (name, definition) => {
     send({ type: '${name}', ...data })
   }`;
 };
-var templateWebsocketClass = (name, path8, definitions) => {
+var templateWebsocketClass = (name, path9, definitions) => {
   const requestDefinitions = Object.keys(definitions).filter((key) => {
     const val = definitions[key];
     return val["x-type"] == "request";
@@ -2065,7 +2191,7 @@ const messageSerializer = (data: Record<string, any>) => {
 export function WebSocketClass(sdk: AccelByteSDK, args?: SdkSetConfigParam) {
   const sdkAssembly = sdk.assembly()
   const baseURL = (args?.coreConfig?.baseURL ?? sdkAssembly.coreConfig.baseURL).replace('http', 'ws')
-  const path = '${path8}'
+  const path = '${path9}'
   const url = baseURL + path
   let ws: WebSocket | null = null
   let isDisconnectManually = false
@@ -2314,9 +2440,9 @@ ${renderUnion(["response", "notification"], definitions)}
 // src/WebsocketGenerator.ts
 var WebsocketGenerator = class {
   static srcFolder = () => CliParser.getOutputPath();
-  static outputFolder = () => import_path4.default.join(this.srcFolder(), "generated-websocket");
+  static outputFolder = () => import_path5.default.join(this.srcFolder(), "generated-websocket");
   static schemaContent = () => {
-    const fileContent = JSON.parse(import_fs5.default.readFileSync(CliParser.getWebSocketSchemaPath(), "utf8"));
+    const fileContent = JSON.parse(import_fs6.default.readFileSync(CliParser.getWebSocketSchemaPath(), "utf8"));
     return fileContent;
   };
   static prepareDirs = () => {
@@ -2326,11 +2452,11 @@ var WebsocketGenerator = class {
     const { name, path: wsPath, definitions } = this.schemaContent();
     const templateDefinitions = templateWebsocketDefinitions(definitions);
     this.prepareDirs();
-    const filePath = import_path4.default.join(this.outputFolder(), "WebSocketDefinitions.ts");
-    import_fs5.default.writeFileSync(filePath, templateDefinitions, "utf8");
+    const filePath = import_path5.default.join(this.outputFolder(), "WebSocketDefinitions.ts");
+    import_fs6.default.writeFileSync(filePath, templateDefinitions, "utf8");
     const templateClass2 = templateWebsocketClass(name, wsPath, definitions);
-    const filePathClass = import_path4.default.join(this.outputFolder(), "WebSocketClass.ts");
-    import_fs5.default.writeFileSync(filePathClass, templateClass2, "utf8");
+    const filePathClass = import_path5.default.join(this.outputFolder(), "WebSocketClass.ts");
+    import_fs6.default.writeFileSync(filePathClass, templateClass2, "utf8");
   };
 };
 
@@ -2343,24 +2469,28 @@ var generateSdk = async () => {
   if (CliParser.isGenerateWebSocket()) {
     WebsocketGenerator.main();
   }
+  if (!CodegenConfig.shouldProduceIndexFiles()) {
+    return;
+  }
   const indexImportsSet = /* @__PURE__ */ new Set();
   const queryImportsSet = /* @__PURE__ */ new Set();
   const filenamesSet = /* @__PURE__ */ new Set();
   for (const set of arrayOfSets) {
     set.indexImports.forEach((value) => {
-      const fileName = import_path5.default.basename(value);
+      const fileName = import_path6.default.basename(value);
       if (!filenamesSet.has(fileName)) {
         indexImportsSet.add(value);
         filenamesSet.add(fileName);
       }
     });
     set.queryImports.forEach((value) => {
-      const fileName = import_path5.default.basename(value);
+      const fileName = import_path6.default.basename(value);
       if (!filenamesSet.has(fileName)) {
         queryImportsSet.add(value);
       }
     });
   }
+  const outputPath = CliParser.getOutputPath();
   const indexImportsArray = Array.from(indexImportsSet).sort();
   const queryImportsArray = Array.from(queryImportsSet).sort();
   const filesToImport = indexImportsArray.map((fileToImport) => {
@@ -2369,8 +2499,8 @@ var generateSdk = async () => {
   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"));
+  ParserUtils.writeAllImportsFile(outputPath, filesToImport.join("\n"));
+  ParserUtils.writeAllQueryImportsFile(outputPath, queryFilesToImport.join("\n"));
 };
 import_yargs.default.command("download-swaggers", "Download swaggers JSON files", (yargs2) => {
   CliParser.createInstance(yargs2);
@@ -2386,6 +2516,7 @@ import_yargs.default.command("download-swaggers", "Download swaggers JSON files"
     return true;
   });
   CliParser.createInstance(yargs2);
+  await CodegenConfig.loadConfig(import_path6.default.dirname(import_path6.default.resolve(CliParser.getConfigPath())));
   await generateSdk();
 }).option("config", {
   description: "Path to the config file with backend service URLs.",