@asyncapi/cli 3.4.2 → 3.5.1

package/lib/utils/generate/mapBaseUrl.d.ts

@@ -0,0 +1,6 @@
+import { IMapBaseUrlToFlag } from '../../domains/models/generate/Flags';
+export declare function getMapBaseUrlToFolderResolver(urlToFolder: IMapBaseUrlToFlag): {
+    order: number;
+    canRead(): boolean;
+    read(file: any): Promise<unknown>;
+};

package/lib/utils/generate/mapBaseUrl.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMapBaseUrlToFolderResolver = getMapBaseUrlToFolderResolver;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+function getMapBaseUrlToFolderResolver(urlToFolder) {
+    return {
+        order: 1,
+        canRead() {
+            return true;
+        },
+        read(file) {
+            const baseUrl = urlToFolder.url;
+            const baseDir = urlToFolder.folder;
+            return new Promise((resolve, reject) => {
+                let localpath = file.url;
+                localpath = localpath.replace(baseUrl, baseDir);
+                try {
+                    fs.readFile(localpath, (err, data) => {
+                        if (err) {
+                            reject(`Error opening file "${localpath}"`);
+                        }
+                        else {
+                            resolve(data);
+                        }
+                    });
+                }
+                catch (err) {
+                    reject(`Error opening file "${localpath}"`);
+                }
+            });
+        }
+    };
+}

package/lib/utils/generate/parseParams.d.ts

@@ -0,0 +1,3 @@
+export declare function paramParser(inputs?: string[]): Record<string, any>;
+export declare function disableHooksParser(inputs?: string[]): Record<string, any>;
+export declare function mapBaseURLParser(input?: string): any;

package/lib/utils/generate/parseParams.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paramParser = paramParser;
+exports.disableHooksParser = disableHooksParser;
+exports.mapBaseURLParser = mapBaseURLParser;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+function paramParser(inputs) {
+    if (!inputs) {
+        return {};
+    }
+    const params = {};
+    for (const input of inputs) {
+        if (!input.includes('=')) {
+            throw new Error(`Invalid param ${input}. It must be in the format of --param name1=value1 name2=value2 `);
+        }
+        const [paramName, paramValue] = input.split(/=(.+)/, 2);
+        params[String(paramName)] = paramValue;
+    }
+    return params;
+}
+function disableHooksParser(inputs) {
+    if (!inputs) {
+        return {};
+    }
+    const disableHooks = {};
+    for (const input of inputs) {
+        const [hookType, hookNames] = input.split(/=/);
+        if (!hookType) {
+            throw new Error('Invalid --disable-hook flag. It must be in the format of: --disable-hook <hookType> or --disable-hook <hookType>=<hookName1>,<hookName2>,...');
+        }
+        if (hookNames) {
+            disableHooks[String(hookType)] = hookNames.split(',');
+        }
+        else {
+            disableHooks[String(hookType)] = true;
+        }
+    }
+    return disableHooks;
+}
+function mapBaseURLParser(input) {
+    if (!input) {
+        return;
+    }
+    const mapBaseURLToFolder = {};
+    const re = /(.*):(.*)/g; // NOSONAR
+    let mapping = [];
+    if ((mapping = re.exec(input)) === null || mapping.length !== 3) {
+        throw new Error('Invalid --map-base-url flag. A mapping <url>:<folder> with delimiter : expected.');
+    }
+    mapBaseURLToFolder.url = mapping[1].replace(/\/$/, '');
+    mapBaseURLToFolder.folder = path_1.default.resolve(mapping[2]);
+    const isURL = /^https?:/;
+    if (!isURL.test(mapBaseURLToFolder.url.toLowerCase())) {
+        throw new Error('Invalid --map-base-url flag. The mapping <url>:<folder> requires a valid http/https url and valid folder with delimiter `:`.');
+    }
+    return mapBaseURLToFolder;
+}

package/lib/utils/generate/prompts.d.ts

@@ -0,0 +1,4 @@
+export declare function promptForAsyncAPIPath(): Promise<string>;
+export declare function promptForLanguage(defaultLanguage: string): Promise<string>;
+export declare function promptForTemplate(): Promise<string>;
+export declare function promptForOutputDir(): Promise<string>;

package/lib/utils/generate/prompts.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptForAsyncAPIPath = promptForAsyncAPIPath;
+exports.promptForLanguage = promptForLanguage;
+exports.promptForTemplate = promptForTemplate;
+exports.promptForOutputDir = promptForOutputDir;
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const prompts_1 = require("@clack/prompts");
+const OPERATION_CANCELLED_ERROR = 'Operation cancelled';
+function promptForAsyncAPIPath() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const asyncapi = yield (0, prompts_1.text)({
+            message: 'Please provide the path to the AsyncAPI document',
+            placeholder: 'asyncapi.yaml',
+            defaultValue: 'asyncapi.yaml',
+            validate(value) {
+                if (!value) {
+                    return 'The path to the AsyncAPI document is required';
+                }
+                else if (!fs_1.default.existsSync(value)) {
+                    return 'The file does not exist';
+                }
+            }
+        });
+        if ((0, prompts_1.isCancel)(asyncapi)) {
+            throw new Error(OPERATION_CANCELLED_ERROR);
+        }
+        return asyncapi;
+    });
+}
+function promptForLanguage(defaultLanguage) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const language = yield (0, prompts_1.text)({
+            message: 'Please provide the language of the generated client',
+            placeholder: defaultLanguage,
+            defaultValue: defaultLanguage,
+        });
+        if ((0, prompts_1.isCancel)(language)) {
+            throw new Error(OPERATION_CANCELLED_ERROR);
+        }
+        return language;
+    });
+}
+function promptForTemplate() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const template = yield (0, prompts_1.text)({
+            message: 'Please provide the name of the generator template',
+            placeholder: '@asyncapi/html-template',
+            defaultValue: '@asyncapi/html-template',
+        });
+        if ((0, prompts_1.isCancel)(template)) {
+            throw new Error(OPERATION_CANCELLED_ERROR);
+        }
+        return template;
+    });
+}
+function promptForOutputDir() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const output = yield (0, prompts_1.text)({
+            message: 'Please provide the output directory',
+            placeholder: './docs',
+            validate(value) {
+                if (!value) {
+                    return 'The output directory is required';
+                }
+                else if (typeof value !== 'string') {
+                    return 'The output directory must be a string';
+                }
+            }
+        });
+        if ((0, prompts_1.isCancel)(output)) {
+            throw new Error(OPERATION_CANCELLED_ERROR);
+        }
+        return output;
+    });
+}

package/lib/utils/generate/registry.d.ts

@@ -0,0 +1,2 @@
+export declare function registryURLParser(input?: string): void;
+export declare function registryValidation(registryUrl?: string, registryAuth?: string, registryToken?: string): Promise<void>;

package/lib/utils/generate/registry.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registryURLParser = registryURLParser;
+exports.registryValidation = registryValidation;
+const tslib_1 = require("tslib");
+function registryURLParser(input) {
+    if (!input) {
+        return;
+    }
+    const isURL = /^https?:/;
+    if (!isURL.test(input.toLowerCase())) {
+        throw new Error('Invalid --registry-url flag. The param requires a valid http/https url.');
+    }
+}
+function registryValidation(registryUrl, registryAuth, registryToken) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (!registryUrl) {
+            return;
+        }
+        try {
+            const response = yield fetch(registryUrl);
+            if (response.status === 401 && !registryAuth && !registryToken) {
+                throw new Error('You Need to pass either registryAuth in username:password encoded in Base64 or need to pass registryToken');
+            }
+        }
+        catch (error) {
+            throw new Error(`Can't fetch registryURL: ${registryUrl}`);
+        }
+    });
+}

package/lib/utils/{fileWatcher.d.ts → generate/watcher.d.ts}

@@ -46,3 +46,6 @@ export declare class Watcher {
      */
     closeWatcher(path: string): void;
 }
+export declare function runWatchMode(thisArg: any, asyncapi: string, template: string, output: string, generatorClass: any, // ✅ passed in
+watchHandler: (changedFiles: Record<string, any>) => Promise<void>): Promise<void>;
+export declare function watcherHandler(thisArg: any, asyncapi: string, template: string, output: string, options: Record<string, any>, genOption: any, interactive: boolean): (changedFiles: Record<string, any>) => Promise<void>;

package/lib/utils/{fileWatcher.js → generate/watcher.js}

@@ -2,12 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Watcher = void 0;
 exports.isLocalTemplate = isLocalTemplate;
+exports.runWatchMode = runWatchMode;
+exports.watcherHandler = watcherHandler;
 const tslib_1 = require("tslib");
 // eslint-disable security/detect-object-injection
 const fs = tslib_1.__importStar(require("fs"));
 const util_1 = require("util");
 const chokidar_1 = tslib_1.__importDefault(require("chokidar"));
 const lstat = (0, util_1.promisify)(fs.lstat);
+const path_1 = tslib_1.__importDefault(require("path"));
+const picocolors_1 = require("picocolors");
+const SpecificationFile_1 = require("../../domains/models/SpecificationFile");
+const generator_error_1 = require("../../errors/generator-error");
 function isLocalTemplate(templatePath) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
         const stats = yield lstat(templatePath);
@@ -39,10 +45,7 @@ class Watcher {
      * @param {*} errorCallback Calback to call when it is no longer possible to watch a file.
      */
     initiateWatchOnPath(path, changeCallback, errorCallback) {
-        const watcher = chokidar_1.default.watch(path, {
-            ignoreInitial: true,
-            ignored: this.ignorePaths,
-        });
+        const watcher = chokidar_1.default.watch(path, { ignoreInitial: true, ignored: this.ignorePaths });
         watcher.on('all', (eventType, changedPath) => this.fileChanged(path, changedPath, eventType, changeCallback, errorCallback));
         this.watchers[String(path)] = watcher;
     }
@@ -70,10 +73,7 @@ class Watcher {
         try {
             if (fs.existsSync(listenerPath)) {
                 const newEventType = this.convertEventType(eventType);
-                this.filesChanged[String(changedPath)] = {
-                    eventType: newEventType,
-                    path: changedPath,
-                };
+                this.filesChanged[String(changedPath)] = { eventType: newEventType, path: changedPath };
                 // Since multiple changes can occur at the same time, lets wait a bit before processing.
                 if (this.fsWait) {
                     return;
@@ -161,3 +161,70 @@ class Watcher {
     }
 }
 exports.Watcher = Watcher;
+function runWatchMode(thisArg, asyncapi, template, output, generatorClass, // ✅ passed in
+watchHandler) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const specification = yield (0, SpecificationFile_1.load)(asyncapi);
+        const watchDir = path_1.default.resolve(template);
+        const outputPath = path_1.default.resolve(watchDir, output);
+        const transpiledTemplatePath = path_1.default.resolve(watchDir, generatorClass.TRANSPILED_TEMPLATE_LOCATION); // ✅ use dynamic class
+        const ignorePaths = [outputPath, transpiledTemplatePath];
+        const specificationFile = specification.getFilePath();
+        // Template name is needed as it is not always a part of the cli command
+        // There is a use case that you run generator from a root of the template with `./` path
+        let templateName = '';
+        try {
+            // eslint-disable-next-line
+            templateName = require(path_1.default.resolve(watchDir, 'package.json')).name;
+        }
+        catch (_) {
+            // intentional
+        }
+        let watcher;
+        if (specificationFile) {
+            thisArg.log(`[WATCHER] Watching for changes in the template directory ${(0, picocolors_1.magenta)(watchDir)} and in the AsyncAPI file ${(0, picocolors_1.magenta)(specificationFile)}`);
+            watcher = new Watcher([specificationFile, watchDir], ignorePaths);
+        }
+        else {
+            thisArg.log(`[WATCHER] Watching for changes in the template directory ${(0, picocolors_1.magenta)(watchDir)}`);
+            watcher = new Watcher(watchDir, ignorePaths);
+        }
+        if (!(yield thisArg.isLocalTemplate(path_1.default.resolve(generatorClass.DEFAULT_TEMPLATES_DIR, templateName)))) {
+            thisArg.warn(`WARNING: ${template} is a remote template. Changes may be lost on subsequent installations.`);
+        }
+        yield watcher.watch(watchHandler, (paths) => {
+            thisArg.error(`[WATCHER] Could not find the file path ${paths}, are you sure it still exists? If it has been deleted or moved please rerun the generator.`, {
+                exit: 1,
+            });
+        });
+    });
+}
+function watcherHandler(thisArg, asyncapi, template, output, options, genOption, interactive) {
+    return (changedFiles) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        console.clear();
+        console.log('[WATCHER] Change detected');
+        for (const [, value] of Object.entries(changedFiles)) {
+            let eventText;
+            switch (value.eventType) {
+                case 'changed':
+                    eventText = (0, picocolors_1.green)(value.eventType);
+                    break;
+                case 'removed':
+                    eventText = (0, picocolors_1.red)(value.eventType);
+                    break;
+                case 'renamed':
+                    eventText = (0, picocolors_1.yellow)(value.eventType);
+                    break;
+                default:
+                    eventText = (0, picocolors_1.yellow)(value.eventType);
+            }
+            thisArg.log(`\t${(0, picocolors_1.magenta)(value.path)} was ${eventText}`);
+        }
+        try {
+            yield thisArg.generate(asyncapi, template, output, options, genOption, interactive);
+        }
+        catch (err) {
+            throw new generator_error_1.GeneratorError(err);
+        }
+    });
+}

package/oclif.manifest.json

@@ -750,6 +750,158 @@
         "versions.js"
       ]
     },
+    "generate:client": {
+      "aliases": [],
+      "args": {
+        "language": {
+          "description": "The language you want the client generated for. Available target languages: dart, java, javascript, python",
+          "name": "language",
+          "required": true
+        },
+        "asyncapi": {
+          "description": "- Local path, url or context-name pointing to AsyncAPI file",
+          "name": "asyncapi",
+          "required": false
+        }
+      },
+      "description": "Generates clients baked-in AsyncAPI Generator. Available for: dart, java, javascript, python. If some language is not supported or you want to improve existing client, join us at https://github.com/asyncapi/generator",
+      "examples": [
+        "asyncapi generate client javascript asyncapi.yaml --param version=1.0.0 singleFile=true --output ./docs --force-write"
+      ],
+      "flags": {
+        "help": {
+          "char": "h",
+          "description": "Show CLI help.",
+          "name": "help",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "disable-hook": {
+          "char": "d",
+          "description": "Disable a specific hook type or hooks from a given hook type",
+          "name": "disable-hook",
+          "hasDynamicHelp": false,
+          "multiple": true,
+          "type": "option"
+        },
+        "no-interactive": {
+          "description": "Disable interactive mode and run with the provided flags.",
+          "name": "no-interactive",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "install": {
+          "char": "i",
+          "description": "Installs the template and its dependencies (defaults to false)",
+          "name": "install",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "debug": {
+          "description": "Enable more specific errors in the console",
+          "name": "debug",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "no-overwrite": {
+          "char": "n",
+          "description": "Glob or path of the file(s) to skip when regenerating",
+          "name": "no-overwrite",
+          "hasDynamicHelp": false,
+          "multiple": true,
+          "type": "option"
+        },
+        "output": {
+          "char": "o",
+          "description": "Directory where to put the generated files (defaults to current directory)",
+          "name": "output",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "force-write": {
+          "description": "Force writing of the generated files to given directory even if it is a git repo with unstaged files or not empty dir (defaults to false)",
+          "name": "force-write",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "watch": {
+          "char": "w",
+          "description": "Watches the template directory and the AsyncAPI document, and re-generate the files when changes occur. Ignores the output directory.",
+          "name": "watch",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "param": {
+          "char": "p",
+          "description": "Additional param to pass to templates",
+          "name": "param",
+          "hasDynamicHelp": false,
+          "multiple": true,
+          "type": "option"
+        },
+        "map-base-url": {
+          "description": "Maps all schema references from base url to local folder",
+          "name": "map-base-url",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "registry-url": {
+          "description": "Specifies the URL of the private registry for fetching templates and dependencies",
+          "name": "registry-url",
+          "default": "https://registry.npmjs.org",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "registry-auth": {
+          "description": "The registry username and password encoded with base64, formatted as username:password",
+          "name": "registry-auth",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "registry-token": {
+          "description": "The npm registry authentication token, that can be passed instead of base64 encoded username and password",
+          "name": "registry-token",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "proxyHost": {
+          "description": "Name of the ProxyHost",
+          "name": "proxyHost",
+          "required": false,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "proxyPort": {
+          "description": "Port number number for the proxyHost.",
+          "name": "proxyPort",
+          "required": false,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "generate:client",
+      "pluginAlias": "@asyncapi/cli",
+      "pluginName": "@asyncapi/cli",
+      "pluginType": "core",
+      "isESM": false,
+      "relativePath": [
+        "lib",
+        "apps",
+        "cli",
+        "commands",
+        "generate",
+        "client.js"
+      ]
+    },
     "generate:fromTemplate": {
       "aliases": [],
       "args": {
@@ -787,7 +939,6 @@
         "no-interactive": {
           "description": "Disable interactive mode and run with the provided flags.",
           "name": "no-interactive",
-          "required": false,
           "allowNo": false,
           "type": "boolean"
         },
@@ -899,7 +1050,6 @@
       "pluginAlias": "@asyncapi/cli",
       "pluginName": "@asyncapi/cli",
       "pluginType": "core",
-      "strict": true,
       "isESM": false,
       "relativePath": [
         "lib",
@@ -1609,6 +1759,13 @@
           "name": "suppressLogs",
           "allowNo": false,
           "type": "boolean"
+        },
+        "noBrowser": {
+          "char": "B",
+          "description": "Pass this to not open browser automatically upon running the command",
+          "name": "noBrowser",
+          "allowNo": false,
+          "type": "boolean"
         }
       },
       "hasDynamicHelp": false,
@@ -1669,6 +1826,13 @@
           "required": false,
           "allowNo": false,
           "type": "boolean"
+        },
+        "noBrowser": {
+          "char": "B",
+          "description": "Pass this to not open browser automatically upon running the command",
+          "name": "noBrowser",
+          "allowNo": false,
+          "type": "boolean"
         }
       },
       "hasDynamicHelp": false,
@@ -1978,5 +2142,5 @@
       ]
     }
   },
-  "version": "3.4.2"
+  "version": "3.5.1"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@asyncapi/cli",
   "description": "All in one CLI for all AsyncAPI tools",
-  "version": "3.4.2",
+  "version": "3.5.1",
   "author": "@asyncapi",
   "bin": {
     "asyncapi": "./bin/run_bin"
@@ -18,7 +18,7 @@
     "@asyncapi/optimizer": "^1.0.4",
     "@asyncapi/parser": "^3.3.0",
     "@asyncapi/problem": "^1.0.0",
-    "@asyncapi/protobuf-schema-parser": "^3.5.1",
+    "@asyncapi/protobuf-schema-parser": "^3.6.0",
     "@asyncapi/raml-dt-schema-parser": "^4.0.24",
     "@asyncapi/studio": "^0.24.2",
     "@changesets/changelog-git": "^0.2.0",
@@ -37,7 +37,7 @@
     "express": "^4.17.1",
     "fast-levenshtein": "^3.0.0",
     "fs-extra": "^11.1.0",
-    "generator-v2": "npm:@asyncapi/generator@2.4.1",
+    "generator-v2": "npm:@asyncapi/generator@2.8.3",
     "helmet": "^8.1.0",
     "https-proxy-agent": "^7.0.6",
     "inquirer": "^8.2.0",
@@ -92,6 +92,7 @@
     "mocha": "^10.2.0",
     "nodemon": "^3.1.10",
     "nyc": "^15.1.0",
+    "puppeteer": "^24.17.0",
     "rimraf": "^3.0.2",
     "simple-git": "^3.16.0",
     "supertest": "^7.1.4",
@@ -160,7 +161,7 @@
   },
   "repository": "asyncapi/cli",
   "scripts": {
-    "build": "rimraf lib && node scripts/fetch-asyncapi-example.js && tsc && tsc-alias --project tsconfig.json && oclif manifest && echo \"Build Completed\"",
+    "build": "rimraf lib && node scripts/fetch-asyncapi-example.js && npm run generate:languages && tsc && tsc-alias --project tsconfig.json && oclif manifest && echo \"Build Completed\"",
     "bump:github-action": "cd github-action/lib/ && node bump-action-version.js",
     "bump:version": "npx -p @changesets/cli@2.27.7 changeset version && npm run bump:github-action",
     "dev": "tsc --watch",
@@ -170,6 +171,7 @@
     "generate:assets": "npm run generate:readme:toc && npm run generate:commands",
     "generate:commands": "npm run generate:readme:create && npm run generate:readme:commands && node ./scripts/updateUsageDocs.js && rimraf ./scripts/README.md",
     "generate:readme:toc": "markdown-toc -i README.md",
+    "generate:languages": "node scripts/generateTypesForGenerateCommand.js",
     "prepare": "lefthook install",
     "lint": "eslint --max-warnings 5 --config .eslintrc .",
     "lint:fix": "eslint --max-warnings 5 --config .eslintrc . --fix",
@@ -197,7 +199,7 @@
     "api:prod": "npm run api:build && cross-env NODE_ENV=production PORT=80 node lib/apps/api/server.js",
     "api:docker": "docker run -it -p 80:80 asyncapi/server-api",
     "api:build:docker": "docker build -t asyncapi/server-api -f ./src/apps/api/Dockerfile .",
-    "api:build": "rimraf lib && tsc && tsc-alias --project tsconfig.json",
+    "api:build": "rimraf lib && npm run generate:languages && tsc && tsc-alias --project tsconfig.json",
     "api:test": ""
   },
   "types": "lib/index.d.ts"

package/scripts/generateTypesForGenerateCommand.js

@@ -0,0 +1,40 @@
+const { writeFile } = require('fs/promises');
+const path = require('path');
+const { listBakedInTemplates } = require('generator-v2');
+
+async function generateClientLanguages() {
+  const bakedInClients = listBakedInTemplates({ type: 'client' });
+
+  const targets = Array.from(new Set(bakedInClients.map(t => t.target))).sort();
+
+  const enumEntries = targets
+    .map(t => `  ${capitalize(t)} = '${t}',`)
+    .join('\n');
+
+  const fileContent = `// Auto-generated. Do not edit manually.
+export enum AvailableLanguage {
+${enumEntries}
+}
+
+export const availableLanguages = [${targets.map(t => `'${t}'`).join(', ')}] as const;
+export type AvailableLanguageType = typeof availableLanguages[number];
+
+/**
+ * Returns the first available language as the default option.
+ */
+export const getDefaultLanguage = (): AvailableLanguageType => availableLanguages[0];
+`;
+
+  const outputPath = path.join(__dirname, '../src/domains/models/generate/ClientLanguages.ts');
+  await writeFile(outputPath, fileContent);
+
+  console.log('✅ ClientLanguages.ts generated');
+}
+
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+generateClientLanguages().catch(err => {
+  throw new Error(`Failed to generate ClientLanguages.ts: ${err.message}`);
+});