@iamalond/nestjs-i18next 1.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matvey iamAlond
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,72 @@
+<div align="center">
+   <h1>
+       <a href="#"><img src="https://nestjs.com/img/logo-small.svg" width="120" alt="Nest Logo"></a>
+   </h1>
+   🌍 Internalize your <a href="https://nestjs.com">NestJS</a> application using the nestjs-i18next module<b>
+   <br/><br/>
+</div>
+
+<p align="center">
+    <a href='https://img.shields.io/npm/v/@iamalond/nestjs-i18next'><img src="https://img.shields.io/npm/v/@iamalond/nestjs-i18next" alt="NPM Version" /></a>
+    <a href='https://img.shields.io/npm/l/@iamalond/nestjs-i18next'><img src="https://img.shields.io/npm/l/@iamalond/nestjs-i18next" alt="NPM License" /></a>
+    <a href='https://img.shields.io/npm/dm/@iamalond/nestjs-i18next'><img src="https://img.shields.io/npm/dm/@iamalond/nestjs-i18next" alt="NPM Downloads" /></a>
+    <a href='https://img.shields.io/github/last-commit/iamalond/@iamalond/nestjs-i18next'><img src="https://img.shields.io/github/last-commit/iamalond/@iamalond/nestjs-i18next" alt="Last commit" /></a>
+</p>
+
+## About the Project
+
+**nestjs-i18next** is an internationalization module for NestJS applications.
+
+The project was inspired by the popular `nestjs-i18n` module, but with a major enhancement: **full type-safety for translation arguments**. No more `any` in your translations — your keys and variables are strictly typed based on your JSON files.
+
+### Key Features:
+
+- 🛡️ **Strict Typing**: Automatic type generation for paths and arguments.
+- 🧩 **ICU Format**: Support for variables and complex pluralization (similar to the `i18next-icu` plugin).
+- 🔄 **Live Reload**: Watch for translation file changes without restarting the server.
+- 📂 **Recursive Namespaces**: Support for nested subfolders to organize your translations cleanly.
+
+---
+
+## Installation
+
+```bash
+npm install nestjs-i18next
+yarn add nestjs-i18next
+pnpm add nestjs-i18next
+```
+
+## Usage
+
+```typescript
+import { I18NextModule } from '@iamalond/nestjs-i18next';
+
+@Module({
+    imports: [
+        I18nextModule.forRoot({
+            fallbackLanguage: 'en',
+            throwOnMissingKey: true,
+            logging: true,
+            generatedTypesPath: path.join(process.cwd(), 'src/i18n/index.d.ts'),
+            loadingOptions: {
+                path: path.join(process.cwd(), 'src/i18n'),
+                subfolders: true, // recursive loading
+                watch: true
+            }
+        })
+    ]
+})
+export class AppModule {}
+```
+
+## File Structure
+
+By default, the module uses the locale/ns.json structure. With subfolders: true, you can use recursive nesting. Keys will be resolved as namespace.subfolder.key:
+
+```bash
+src/i18n/
+├── en/
+│   ├── common.json
+│   └── auth/
+│       └── errors.json  <-- key will be "auth.errors.invalid_password"
+```

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './nestjs-i18next';
+export * from './nestjs-i18next.module';
+export * from './nestjs-i18next.module-definition';
+export * from './nestjs-i18next.service';

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./nestjs-i18next"), exports);
+tslib_1.__exportStar(require("./nestjs-i18next.module"), exports);
+tslib_1.__exportStar(require("./nestjs-i18next.module-definition"), exports);
+tslib_1.__exportStar(require("./nestjs-i18next.service"), exports);

package/dist/nestjs-i18next.d.ts

@@ -0,0 +1,24 @@
+export type I18nextModuleOptions = {
+    fallbackLanguage: string;
+    loadingOptions: {
+        path: string;
+        subfolders?: boolean;
+        watch?: boolean;
+    };
+    logging?: boolean;
+    throwOnMissingKey?: boolean;
+    generatedTypesPath?: string;
+};
+export type TranslateOptions<P, T> = {
+    lang?: string;
+    defaultValue?: string;
+    debug?: boolean;
+} & (Extract<T, {
+    key: P;
+}> extends {
+    args: infer A;
+} ? {
+    args: A;
+} : {
+    args?: never;
+});

package/dist/nestjs-i18next.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nestjs-i18next.json-loader.d.ts

@@ -0,0 +1,18 @@
+import { OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+import { I18nextModuleOptions } from './nestjs-i18next';
+export declare class I18nextJsonLoader implements OnModuleInit, OnModuleDestroy {
+    protected readonly options: I18nextModuleOptions;
+    private readonly logger;
+    private watcher;
+    private watchTimeout;
+    constructor(options: I18nextModuleOptions);
+    onModuleInit(): void;
+    onModuleDestroy(): void;
+    private onRefreshCb?;
+    onChange(cb: () => void): void;
+    private startWatcher;
+    parseTransitions(): Record<string, any> | undefined;
+    private readDirectory;
+    private generateTypes;
+    private generateUnionType;
+}

package/dist/nestjs-i18next.json-loader.js

@@ -0,0 +1,157 @@
+"use strict";
+var I18nextJsonLoader_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18nextJsonLoader = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const nestjs_i18next_module_definition_1 = require("./nestjs-i18next.module-definition");
+let I18nextJsonLoader = I18nextJsonLoader_1 = class I18nextJsonLoader {
+    constructor(options) {
+        this.options = options;
+        this.logger = new common_1.Logger(I18nextJsonLoader_1.name);
+        this.watcher = null;
+        this.watchTimeout = null;
+    }
+    onModuleInit() {
+        if (this.options.loadingOptions.watch) {
+            this.startWatcher();
+        }
+    }
+    onModuleDestroy() {
+        this.watcher?.close();
+        if (this.watchTimeout)
+            clearTimeout(this.watchTimeout);
+    }
+    onChange(cb) {
+        this.logger.debug('Watch file changes');
+        this.onRefreshCb = cb;
+    }
+    startWatcher() {
+        const targetPath = path_1.default.resolve(process.cwd(), this.options.loadingOptions.path);
+        try {
+            this.watcher = fs_1.default.watch(targetPath, { recursive: true }, (eventType, filename) => {
+                if (filename && filename.endsWith('.json')) {
+                    if (this.watchTimeout)
+                        clearTimeout(this.watchTimeout);
+                    this.watchTimeout = setTimeout(() => {
+                        if (this.options.logging) {
+                            this.logger.log(`Translation file changed. Checking translation changes...`);
+                        }
+                        if (this.onRefreshCb)
+                            this.onRefreshCb();
+                        this.watchTimeout = null;
+                    }, 100);
+                }
+            });
+        }
+        catch (e) {
+            this.logger.error(`Could not start watcher: ${e.message}`);
+        }
+    }
+    parseTransitions() {
+        const translations = {};
+        if (!fs_1.default.existsSync(this.options.loadingOptions.path)) {
+            this.logger.error(`Translations directory not found: ${this.options.loadingOptions.path}`);
+            return;
+        }
+        const languages = fs_1.default
+            .readdirSync(this.options.loadingOptions.path)
+            .filter(f => fs_1.default.statSync(path_1.default.join(this.options.loadingOptions.path, f)).isDirectory());
+        for (const lang of languages) {
+            const langPath = path_1.default.join(this.options.loadingOptions.path, lang);
+            translations[lang] = this.readDirectory(langPath);
+        }
+        if (this.options.generatedTypesPath) {
+            this.generateTypes(translations);
+        }
+        return translations;
+    }
+    readDirectory(dirPath) {
+        const result = {};
+        const files = fs_1.default.readdirSync(dirPath);
+        for (const file of files) {
+            const fullPath = path_1.default.join(dirPath, file);
+            const stat = fs_1.default.statSync(fullPath);
+            if (stat.isDirectory() && this.options.loadingOptions.subfolders) {
+                result[file] = this.readDirectory(fullPath);
+            }
+            else if (stat.isFile() && file.endsWith('.json')) {
+                const ns = path_1.default.parse(file).name;
+                try {
+                    const content = fs_1.default.readFileSync(fullPath, 'utf-8');
+                    result[ns] = JSON.parse(content);
+                }
+                catch (e) {
+                    this.logger.warn(`Failed to parse JSON at ${fullPath}, skipping this file`);
+                }
+            }
+        }
+        return result;
+    }
+    generateTypes(translations) {
+        const outputPath = this.options.generatedTypesPath;
+        if (!outputPath)
+            return;
+        this.logger.log(`Checking translations changes for generated types...`);
+        const schema = translations[this.options.fallbackLanguage];
+        const fileContent = `/* STOP!!! DO NOT EDIT, file generated by nestjs-i18next */
+
+/* eslint-disable */
+/* prettier-ignore */
+export type I18nTranslations = ${this.generateUnionType(schema)};
+
+/* prettier-ignore */
+export type I18nPath = I18nTranslations['key'];
+
+/* prettier-ignore */
+export type ExtractArgs<P extends I18nPath> = Extract<I18nTranslations, { key: P }> extends { args: infer A }
+    ? A
+    : never;
+`;
+        fs_1.default.mkdirSync(path_1.default.dirname(outputPath), {
+            recursive: true
+        });
+        let currentFileContent = null;
+        try {
+            currentFileContent = fs_1.default.readFileSync(outputPath, 'utf8');
+        }
+        catch (err) {
+            this.logger.error(err);
+        }
+        if (currentFileContent != fileContent) {
+            fs_1.default.writeFileSync(outputPath, fileContent);
+            this.logger
+                .log(`Translations types generated in: ${outputPath}. Please do not edit this file manually.
+                `);
+        }
+        else {
+            this.logger.log('No translations changes detected');
+        }
+    }
+    generateUnionType(obj, prefix = '') {
+        const entries = Object.entries(obj);
+        return entries
+            .map(([key, value]) => {
+            const fullKey = prefix ? `${prefix}.${key}` : key;
+            if (typeof value === 'string') {
+                const simpleVars = [...value.matchAll(/{{(\w+)}}/g)].map(m => m[1]);
+                const icuVars = [...value.matchAll(/{(\w+),\s*plural/g)].map(m => m[1]);
+                const allVars = [...new Set([...simpleVars, ...icuVars])];
+                if (allVars.length === 0) {
+                    return `{ key: "${fullKey}" }`;
+                }
+                const args = allVars.map(v => `"${v}": any`).join(', ');
+                return `{ key: "${fullKey}", args: { ${args} } }`;
+            }
+            return this.generateUnionType(value, fullKey);
+        })
+            .join('\n    | ');
+    }
+};
+exports.I18nextJsonLoader = I18nextJsonLoader;
+exports.I18nextJsonLoader = I18nextJsonLoader = I18nextJsonLoader_1 = tslib_1.__decorate([
+    tslib_1.__param(0, (0, common_1.Inject)(nestjs_i18next_module_definition_1.MODULE_OPTIONS_TOKEN)),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], I18nextJsonLoader);

package/dist/nestjs-i18next.module-definition.d.ts

@@ -0,0 +1,4 @@
+import { I18nextModuleOptions } from './nestjs-i18next';
+export declare const ConfigurableModuleClass: import("@nestjs/common").ConfigurableModuleCls<I18nextModuleOptions, "forRoot", "createLibraryOptions", {
+    isGlobal: boolean;
+}>, MODULE_OPTIONS_TOKEN: string | symbol;

package/dist/nestjs-i18next.module-definition.js

@@ -0,0 +1,13 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODULE_OPTIONS_TOKEN = exports.ConfigurableModuleClass = void 0;
+const common_1 = require("@nestjs/common");
+_a = new common_1.ConfigurableModuleBuilder()
+    .setClassMethodName('forRoot')
+    .setFactoryMethodName('createLibraryOptions')
+    .setExtras({ isGlobal: true }, (definition, extras) => ({
+    ...definition,
+    global: extras.isGlobal
+}))
+    .build(), exports.ConfigurableModuleClass = _a.ConfigurableModuleClass, exports.MODULE_OPTIONS_TOKEN = _a.MODULE_OPTIONS_TOKEN;

package/dist/nestjs-i18next.module.d.ts

@@ -0,0 +1,7 @@
+import { OnModuleInit } from '@nestjs/common';
+import { ConfigurableModuleClass } from './nestjs-i18next.module-definition';
+export declare class I18nextModule extends ConfigurableModuleClass implements OnModuleInit {
+    private readonly logger;
+    private readonly options;
+    onModuleInit(): void;
+}

package/dist/nestjs-i18next.module.js

@@ -0,0 +1,31 @@
+"use strict";
+var I18nextModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18nextModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const nestjs_i18next_json_loader_1 = require("./nestjs-i18next.json-loader");
+const nestjs_i18next_module_definition_1 = require("./nestjs-i18next.module-definition");
+const nestjs_i18next_service_1 = require("./nestjs-i18next.service");
+let I18nextModule = I18nextModule_1 = class I18nextModule extends nestjs_i18next_module_definition_1.ConfigurableModuleClass {
+    constructor() {
+        super(...arguments);
+        this.logger = new common_1.Logger(I18nextModule_1.name);
+    }
+    onModuleInit() {
+        if (this.options.logging) {
+            this.logger.log(`I18nextModule initialized with options: ${JSON.stringify(this.options)}`);
+        }
+    }
+};
+exports.I18nextModule = I18nextModule;
+tslib_1.__decorate([
+    (0, common_1.Inject)(nestjs_i18next_module_definition_1.MODULE_OPTIONS_TOKEN),
+    tslib_1.__metadata("design:type", Object)
+], I18nextModule.prototype, "options", void 0);
+exports.I18nextModule = I18nextModule = I18nextModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({
+        providers: [nestjs_i18next_service_1.I18nextService, nestjs_i18next_json_loader_1.I18nextJsonLoader],
+        exports: [nestjs_i18next_service_1.I18nextService]
+    })
+], I18nextModule);

package/dist/nestjs-i18next.service.d.ts

@@ -0,0 +1,25 @@
+import { OnModuleInit } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { I18nextModuleOptions, TranslateOptions } from './nestjs-i18next';
+import { I18nextJsonLoader } from './nestjs-i18next.json-loader';
+export declare class I18nextService<T extends {
+    key: string;
+}> implements OnModuleInit {
+    protected readonly options: I18nextModuleOptions;
+    private readonly jsonLoader;
+    private readonly logger;
+    private readonly translations$;
+    constructor(options: I18nextModuleOptions, jsonLoader: I18nextJsonLoader);
+    onModuleInit(): void;
+    refresh(): void;
+    get state$(): Observable<Record<string, any>>;
+    private get currentTranslations();
+    getSupportedLanguages(): string[];
+    getTranslations(): Record<string, any>;
+    getTranslationsForNamespace(lang: string): any;
+    translate<P extends T['key']>(key: P, options: TranslateOptions<P, T>): string;
+    t<P extends T['key']>(key: P, options: TranslateOptions<P, T>): string;
+    private getValueByKey;
+    private replaceArgs;
+    private handleMissingKey;
+}

package/dist/nestjs-i18next.service.js

@@ -0,0 +1,129 @@
+"use strict";
+var I18nextService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18nextService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const rxjs_1 = require("rxjs");
+const nestjs_i18next_json_loader_1 = require("./nestjs-i18next.json-loader");
+const nestjs_i18next_module_definition_1 = require("./nestjs-i18next.module-definition");
+let I18nextService = I18nextService_1 = class I18nextService {
+    constructor(options, jsonLoader) {
+        this.options = options;
+        this.jsonLoader = jsonLoader;
+        this.logger = new common_1.Logger(I18nextService_1.name);
+        this.translations$ = new rxjs_1.BehaviorSubject({});
+    }
+    onModuleInit() {
+        this.jsonLoader.onChange(() => {
+            this.refresh();
+        });
+        this.refresh();
+    }
+    refresh() {
+        const loaded = this.jsonLoader.parseTransitions();
+        if (loaded) {
+            this.translations$.next(loaded);
+            if (this.options.logging) {
+                this.logger.log(`Translations updated. Loaded languages: ${Object.keys(loaded).length}`);
+            }
+        }
+    }
+    get state$() {
+        return this.translations$
+            .asObservable()
+            .pipe((0, rxjs_1.distinctUntilChanged)((prev, curr) => JSON.stringify(prev) === JSON.stringify(curr)));
+    }
+    get currentTranslations() {
+        return this.translations$.getValue();
+    }
+    getSupportedLanguages() {
+        return Object.keys(this.currentTranslations);
+    }
+    getTranslations() {
+        return this.currentTranslations;
+    }
+    getTranslationsForNamespace(lang) {
+        return this.currentTranslations[lang];
+    }
+    translate(key, options) {
+        return this.t(key, options);
+    }
+    t(key, options) {
+        const { lang, debug, defaultValue } = options || {};
+        const fallback = this.options.fallbackLanguage;
+        let result = this.getValueByKey(key, lang ?? fallback);
+        if (result === undefined && lang && lang !== fallback) {
+            result = this.getValueByKey(key, fallback);
+        }
+        if (result === undefined) {
+            if (defaultValue)
+                return defaultValue;
+            return this.handleMissingKey(key, lang ?? fallback);
+        }
+        if (debug) {
+            return key;
+        }
+        if (typeof result === 'string') {
+            const args = options?.args;
+            return args ? this.replaceArgs(result, args, lang ?? fallback) : result;
+        }
+        return String(result);
+    }
+    getValueByKey(key, lang) {
+        const translations = this.currentTranslations[lang];
+        if (!translations)
+            return undefined;
+        const keys = key.split('.');
+        let current = translations;
+        for (const k of keys) {
+            current = current?.[k];
+            if (current === undefined)
+                return undefined;
+        }
+        return current;
+    }
+    replaceArgs(text, args, lang) {
+        // 1. Find ICU plural: {key, plural, =0 {..} one {..} few {..} many {..} other {..}}
+        const icuRegex = /{(\w+),\s*plural,\s*([^{}]*({[^{}]*}[^{}]*)*)}/g;
+        const processedText = text.replace(icuRegex, (match, propName, rulesString) => {
+            const value = args[propName];
+            if (value === undefined)
+                return match;
+            // Extract args
+            const ruleRegex = /(=?\w+)\s*{([^}]+)}/g;
+            const rules = {};
+            let m;
+            while ((m = ruleRegex.exec(rulesString)) !== null) {
+                rules[m[1]] = m[2];
+            }
+            // Select values (=0, =1)
+            if (rules[`=${value}`])
+                return rules[`=${value}`];
+            // Use categories (one, few, many, other)
+            const pluralCategory = new Intl.PluralRules(lang).select(value);
+            const result = rules[pluralCategory] || rules['other'] || '';
+            // Use # in plurals for value
+            return result.replace(/#/g, String(value));
+        });
+        // 2. Args {{key}} as args.key
+        return processedText.replace(/{{(\w+)}}/g, (match, key) => {
+            return args[key] !== undefined ? String(args[key]) : match;
+        });
+    }
+    handleMissingKey(key, lang) {
+        if (this.options.throwOnMissingKey) {
+            throw new Error(`Translation key "${key}" not found for language "${lang}"`);
+        }
+        if (this.options.logging) {
+            this.logger.warn(`Missing key: "${key}" in language: "${lang}"`);
+        }
+        return key;
+    }
+};
+exports.I18nextService = I18nextService;
+exports.I18nextService = I18nextService = I18nextService_1 = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, common_1.Inject)(nestjs_i18next_module_definition_1.MODULE_OPTIONS_TOKEN)),
+    tslib_1.__metadata("design:paramtypes", [Object, nestjs_i18next_json_loader_1.I18nextJsonLoader])
+], I18nextService);

package/package.json

@@ -0,0 +1,114 @@
+{
+	"name": "@iamalond/nestjs-i18next",
+	"description": "🌍 i18next module for NestJS",
+	"version": "1.3.0",
+	"scripts": {
+		"build": "rimraf -rf dist && tsc -p tsconfig.build.json",
+		"prepublish:npm": "npm run build",
+		"publish:npm": "release-it",
+		"commit": "cz",
+		"prepublish:dev": "npm run build",
+		"publish:dev": "npm publish --access public --tag dev",
+		"prepare": "husky",
+		"format": "prettier --write \"{src,apps,libs,test}/**/*.ts\"",
+		"lint": "eslint --ignore-pattern .gitignore \"{src,apps,libs,test}/**/*.ts\"",
+		"lint:fix": "npm run lint -- --fix",
+		"test": "jest",
+		"test:watch": "jest --watch",
+		"test:cov": "jest --coverage",
+		"test:ci": "jest --ci --passWithNoTests --coverage"
+	},
+	"lint-staged": {
+		"*.ts": [
+			"npm run format",
+			"npm run lint:fix"
+		]
+	},
+	"directories": {
+		"lib": "src",
+		"test": "test"
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"keywords": [
+		"nestjs",
+		"i18n",
+		"i18next",
+		"internationalization",
+		"internationalisation",
+		"internationalize",
+		"internationalise",
+		"international",
+		"internationalize",
+		"locale"
+	],
+	"license": "MIT",
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/iamAlond/nestjs-i18next.git"
+	},
+	"bugs": {
+		"url": "https://github.com/iamAlond/nestjs-i18next"
+	},
+	"author": "Matvey iamAlond",
+	"contributors": [
+		"Matvey iamAlond"
+	],
+	"config": {
+		"commitizen": {
+			"path": "cz-conventional-changelog"
+		}
+	},
+	"dependencies": {
+		"tslib": "^2.8.1"
+	},
+	"devDependencies": {
+		"@commitlint/cli": "20.5.0",
+		"@commitlint/config-angular": "20.5.0",
+		"@eslint/eslintrc": "^3.3.5",
+		"@eslint/js": "^10.0.1",
+		"@nestjs/common": "11.1.17",
+		"@nestjs/core": "11.1.17",
+		"@nestjs/testing": "^11.1.17",
+		"@release-it/conventional-changelog": "^10.0.6",
+		"@types/jest": "^30.0.0",
+		"@types/node": "25.5.0",
+		"commitizen": "^4.3.1",
+		"cz-conventional-changelog": "^3.3.0",
+		"eslint": "^10.1.0",
+		"eslint-config-prettier": "10.1.8",
+		"eslint-plugin-import": "^2.32.0",
+		"eslint-plugin-prettier": "5.5.5",
+		"globals": "^17.4.0",
+		"husky": "9.1.7",
+		"jest": "^30.3.0",
+		"lint-staged": "16.4.0",
+		"prettier": "3.8.1",
+		"reflect-metadata": "0.2.2",
+		"release-it": "19.2.4",
+		"rimraf": "6.1.3",
+		"rxjs": "7.8.2",
+		"ts-jest": "^29.4.9",
+		"ts-node": "10.9.2",
+		"typescript": "6.0.2",
+		"typescript-eslint": "^8.58.0"
+	},
+	"peerDependencies": {
+		"@nestjs/common": "^8.0.0 || ^9.0.0 || ^10.0.0 || ^11.0.0",
+		"@nestjs/core": "^8.0.0 || ^9.0.0 || ^10.0.0 || ^11.0.0",
+		"reflect-metadata": "^0.2.1",
+		"rxjs": "^7.2.0"
+	}
+}