@zerooneit/expressive-tea 1.3.0-beta.5 → 2.0.0

package/decorators/module.d.ts

@@ -1,5 +1,6 @@
-import { Express, Router } from 'express';
-import { ExpressiveTeaModuleProps } from '@expressive-tea/commons/interfaces';
+import { type ExpressiveTeaModuleProps } from '@expressive-tea/commons';
+import { type Constructor } from '../types/core';
+import { type ModulizedClass } from '../mixins/module';
 /**
  * @typedef {Object} ExpressiveTeaModuleProps
  * @property {Object[]} controllers Controllers Assigned to Module
@@ -13,22 +14,21 @@ import { ExpressiveTeaModuleProps } from '@expressive-tea/commons/interfaces';
  * Module Decorator is a Class Decorator which is help to register a Module into Expressive Tea. A module is a
  * placeholder over a mountpoint. We can considerate a module like a container which provide isolation and modularity
  * for our project. This module can be mounted in different applications and will move all the controller routes too.
+ *
  * @decorator {ClassDecorator} Module - Module Class Register Decorator
- * @param {ExpressiveTeaModuleProps} options
+ * @template TBase - The base constructor type being decorated
+ * @param {ExpressiveTeaModuleProps} options - Module configuration options
+ * @returns {(target: TBase) => ModulizedClass<TBase>} Decorator function that returns a modulized class
  * @summary Module Decorator
+ *
  * @example
  * {REPLACE-AT}Module({
- *   controllers: [],
- *   providers: [],
- *   mountpoint: '/'
+ *   controllers: [UserController],
+ *   providers: [UserService],
+ *   mountpoint: '/api'
  * })
- * class Example {}
+ * class ApiModule {}
+ *
+ * @since 1.0.0
  */
-export declare function Module(options: ExpressiveTeaModuleProps): <T extends new (...args: any[]) => {}>(Module: T) => {
-    new (...args: any[]): {
-        readonly settings: ExpressiveTeaModuleProps;
-        readonly router: Router;
-        readonly controllers: any[];
-        __register(server: Express): void;
-    };
-} & T;
+export declare function Module<TBase extends Constructor = Constructor>(options: ExpressiveTeaModuleProps): (target: TBase) => ModulizedClass<TBase>;

package/decorators/module.js

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Module = void 0;
-const express_1 = require("express");
-const lodash_1 = require("lodash");
-const DependencyInjection_1 = require("../services/DependencyInjection");
+exports.Module = Module;
+const module_1 = require("../mixins/module");
 /**
  * @typedef {Object} ExpressiveTeaModuleProps
  * @property {Object[]} controllers Controllers Assigned to Module
@@ -17,32 +15,25 @@ const DependencyInjection_1 = require("../services/DependencyInjection");
  * Module Decorator is a Class Decorator which is help to register a Module into Expressive Tea. A module is a
  * placeholder over a mountpoint. We can considerate a module like a container which provide isolation and modularity
  * for our project. This module can be mounted in different applications and will move all the controller routes too.
+ *
  * @decorator {ClassDecorator} Module - Module Class Register Decorator
- * @param {ExpressiveTeaModuleProps} options
+ * @template TBase - The base constructor type being decorated
+ * @param {ExpressiveTeaModuleProps} options - Module configuration options
+ * @returns {(target: TBase) => ModulizedClass<TBase>} Decorator function that returns a modulized class
  * @summary Module Decorator
+ *
  * @example
  * {REPLACE-AT}Module({
- *   controllers: [],
- *   providers: [],
- *   mountpoint: '/'
+ *   controllers: [UserController],
+ *   providers: [UserService],
+ *   mountpoint: '/api'
  * })
- * class Example {}
+ * class ApiModule {}
+ *
+ * @since 1.0.0
  */
 function Module(options) {
     return (Module) => {
-        return class ExpressiveTeaModule extends Module {
-            constructor(...args) {
-                super(...args);
-                this.router = (0, express_1.Router)();
-                this.settings = options;
-                (0, lodash_1.each)(this.settings.providers, P => DependencyInjection_1.default.setProvider(P));
-                this.controllers = (0, lodash_1.map)(this.settings.controllers, C => new C());
-            }
-            __register(server) {
-                (0, lodash_1.each)(this.controllers, c => c.__mount(this.router));
-                server.use(this.settings.mountpoint, this.router);
-            }
-        };
+        return (0, module_1.Modulize)(Module, options);
     };
 }
-exports.Module = Module;

package/decorators/proxy.d.ts

@@ -1,13 +1,28 @@
-import { ExpressiveTeaProxyOptions, ExpressiveTeaProxyProperty, MethodDecorator } from '@expressive-tea/commons/types';
-import { Express, RequestHandler } from 'express';
-export declare function ProxyContainer(source: string, targetUrl: string): <T extends new (...args: any[]) => any>(ProxyContainerClass: T) => {
-    new (...args: any[]): {
-        [x: string]: any;
-        readonly source: string;
-        readonly target: string;
-        readonly proxyHandler: RequestHandler;
-        __register(server: Express): void;
-    };
-} & T;
+import { type ExpressiveTeaProxyOptions, type ExpressiveTeaProxyProperty, type MethodDecorator } from '@expressive-tea/commons';
+import { type ProxifiedClass } from '../mixins/proxy';
+import { type Constructor } from '../types/core';
+/**
+ * ProxyContainer decorator - Creates an HTTP proxy for a microservice
+ *
+ * Transforms a class into an HTTP proxy that forwards requests from a source path
+ * to a target URL. Supports custom request/response transformations and options.
+ *
+ * @template TBase - The base constructor type being decorated
+ * @param {string} source - The source path to proxy from (e.g., '/api')
+ * @param {string} targetUrl - The target URL to proxy to (e.g., 'http://api.example.com')
+ * @returns {(target: TBase) => ProxifiedClass<TBase>} Decorator function that returns a proxified class
+ *
+ * @example
+ * {REPLACE-AT}ProxyContainer('/api', 'http://api.example.com')
+ * class ApiProxy {
+ *   {REPLACE-AT}ProxyOption('host')
+ *   getHost() {
+ *     return 'http://api.example.com';
+ *   }
+ * }
+ *
+ * @since 1.0.0
+ */
+export declare function ProxyContainer<TBase extends Constructor = Constructor>(source: string, targetUrl: string): (ProxyContainerClass: TBase) => ProxifiedClass<TBase>;
 export declare function ProxyOption(option: ExpressiveTeaProxyOptions): MethodDecorator;
 export declare function ProxyProperty(option: ExpressiveTeaProxyProperty, value: any): PropertyDecorator;

package/decorators/proxy.js

@@ -1,70 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProxyProperty = exports.ProxyOption = exports.ProxyContainer = void 0;
-const Metadata_1 = require("@expressive-tea/commons/classes/Metadata");
-const httpProxy = require("express-http-proxy");
-const object_helper_1 = require("@expressive-tea/commons/helpers/object-helper");
-const lodash_1 = require("lodash");
+exports.ProxyContainer = ProxyContainer;
+exports.ProxyOption = ProxyOption;
+exports.ProxyProperty = ProxyProperty;
+const commons_1 = require("@expressive-tea/commons");
+const commons_2 = require("@expressive-tea/commons");
 const RequestExceptions_1 = require("../exceptions/RequestExceptions");
-const constants_1 = require("@expressive-tea/commons/constants");
-const NON_ASYNC_METHODS = ['host'];
+const commons_3 = require("@expressive-tea/commons");
+const proxy_1 = require("../mixins/proxy");
+const NON_ASYNC_METHODS = new Set(['host']);
+/**
+ * ProxyContainer decorator - Creates an HTTP proxy for a microservice
+ *
+ * Transforms a class into an HTTP proxy that forwards requests from a source path
+ * to a target URL. Supports custom request/response transformations and options.
+ *
+ * @template TBase - The base constructor type being decorated
+ * @param {string} source - The source path to proxy from (e.g., '/api')
+ * @param {string} targetUrl - The target URL to proxy to (e.g., 'http://api.example.com')
+ * @returns {(target: TBase) => ProxifiedClass<TBase>} Decorator function that returns a proxified class
+ *
+ * @example
+ * {REPLACE-AT}ProxyContainer('/api', 'http://api.example.com')
+ * class ApiProxy {
+ *   {REPLACE-AT}ProxyOption('host')
+ *   getHost() {
+ *     return 'http://api.example.com';
+ *   }
+ * }
+ *
+ * @since 1.0.0
+ */
 function ProxyContainer(source, targetUrl) {
     return (ProxyContainerClass) => {
-        class ExpressiveTeaProxy extends ProxyContainerClass {
-            constructor(...args) {
-                super(...args);
-                this.source = source;
-                this.target = targetUrl;
-                const options = {};
-                const host = Metadata_1.default.get(constants_1.PROXY_SETTING_KEY, this, constants_1.PROXY_METHODS.HOST);
-                for (const value of Object.values(constants_1.PROXY_METHODS)) {
-                    if (value !== constants_1.PROXY_METHODS.HOST) {
-                        options[value] = Metadata_1.default.get(constants_1.PROXY_SETTING_KEY, this, value);
-                    }
-                }
-                for (const value of Object.values(constants_1.PROXY_PROPERTIES)) {
-                    const key = Metadata_1.default.get(constants_1.PROXY_SETTING_KEY, this, value);
-                    if (!(0, lodash_1.isUndefined)(key)) {
-                        // @ts-ignore:next-line
-                        options[value] = this[key];
-                    }
-                }
-                this.proxyHandler = httpProxy(host ? host.value.bind(this) : this.target);
-            }
-            __register(server) {
-                const proxyMetadata = Metadata_1.default.get(constants_1.PROXY_SETTING_KEY, (0, object_helper_1.getClass)(this));
-                console.info(`[PROXY - ${proxyMetadata.name}] ${this.source} -> ${this.target}`);
-                server.use(this.source, this.proxyHandler);
-            }
-        }
-        ;
         const settings = {
             source,
             targetUrl,
             name: ProxyContainerClass.name
         };
-        Metadata_1.default.set(constants_1.PROXY_SETTING_KEY, settings, ProxyContainerClass);
-        return ExpressiveTeaProxy;
+        commons_1.Metadata.set(commons_3.PROXY_SETTING_KEY, settings, ProxyContainerClass);
+        return (0, proxy_1.Proxify)(ProxyContainerClass, source, targetUrl);
     };
 }
-exports.ProxyContainer = ProxyContainer;
 function ProxyOption(option) {
     return (target, propertyKey, descriptor) => {
-        if (NON_ASYNC_METHODS.includes(option) && (0, object_helper_1.isAsyncFunction)(descriptor.value)) {
+        if (NON_ASYNC_METHODS.has(option) && (0, commons_2.isAsyncFunction)(descriptor.value)) {
             throw new RequestExceptions_1.GenericRequestException(`${String(propertyKey)} must not be declared as Async Function.`);
         }
-        Metadata_1.default.set(constants_1.PROXY_SETTING_KEY, descriptor, target, option);
+        commons_1.Metadata.set(commons_3.PROXY_SETTING_KEY, descriptor, target, option);
     };
 }
-exports.ProxyOption = ProxyOption;
 function ProxyProperty(option, value) {
     return (target, propertyKey) => {
-        Metadata_1.default.set(constants_1.PROXY_SETTING_KEY, propertyKey, target, option);
-        let currentValue = target[propertyKey];
+        commons_1.Metadata.set(commons_3.PROXY_SETTING_KEY, propertyKey, target, option);
         Object.defineProperty(target, propertyKey, {
             get: () => value,
-            set: () => { currentValue = value; }
         });
     };
 }
-exports.ProxyProperty = ProxyProperty;

package/decorators/router.d.ts

@@ -1,6 +1,7 @@
-import { Router } from 'express';
-import { ExpressiveTeaHandlerOptions } from '@expressive-tea/commons/interfaces';
-import { ClassDecorator, ExpressMiddlewareHandler, MethodDecorator } from '@expressive-tea/commons/types';
+import { type ClassDecorator, type MethodDecorator } from '@expressive-tea/commons';
+import { type RouterizedClass } from '../mixins/route';
+import { type Constructor, TFunction } from '../types/core';
+import { type RequestHandler } from 'express';
 /**
  * @module Decorators/Router
  */
@@ -11,21 +12,21 @@ import { ClassDecorator, ExpressMiddlewareHandler, MethodDecorator } from '@expr
  * to allow Expressive Tea Setting up the Controller as part of a Module.
  *
  * @decorator {ClassDecorator} Route - Assign a route to controller endpoints.
+ * @template TBase - The base constructor type being decorated
+ * @param {string} mountpoint - Register the url part to mount the Controller (default: '/')
+ * @returns {(target: TBase) => RouterizedClass<TBase>} Decorator function that returns a routerized class
  * @summary Generate a Placeholder endpoint root for controller routes.
- * @param {string} mountpoint Register the url part to mount the Controller.
+ *
  * @example
- * {REPLACE-AT}Route('/)
- * class Example {}
+ * {REPLACE-AT}Route('/users')
+ * class UserController {
+ *   {REPLACE-AT}Get('/')
+ *   getUsers() { return ['user1', 'user2']; }
+ * }
+ *
+ * @since 1.0.0
  */
-export declare function Route(mountpoint?: string): <T extends new (...args: any[]) => any>(RouterClass: T) => {
-    new (...args: any[]): {
-        [x: string]: any;
-        readonly router: Router;
-        readonly mountpoint: string;
-        __mount(parent: Router): any;
-        __registerHandler(options: ExpressiveTeaHandlerOptions): ExpressMiddlewareHandler;
-    };
-} & T;
+export declare function Route<TBase extends Constructor = Constructor>(mountpoint?: string): (RouterClass: TBase) => RouterizedClass<TBase>;
 /**
  * Define a GET Endpoint response over the controller router and can define in which route should be responds and
  * by default this is responding to everything on the controller root path.
@@ -178,7 +179,7 @@ export declare function Param(route?: string): (target: object, propertyKey: str
  *
  * @param {Function} middleware Register a middleware over router.
  */
-export declare function Middleware(middleware: any): ClassDecorator & MethodDecorator;
+export declare function Middleware(middleware: RequestHandler | TFunction<RequestHandler>): ClassDecorator & MethodDecorator;
 /**
  * Will generate a GET route to respond rendering a view template setting up before; the controller method <b>MUST</b>
  * return an object in order to fulfilled the local variables into the view.

package/decorators/router.js

@@ -1,12 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.View = exports.Middleware = exports.Param = exports.Delete = exports.Patch = exports.Put = exports.Post = exports.Get = exports.Route = void 0;
-const express_1 = require("express");
-const lodash_1 = require("lodash");
-const Metadata_1 = require("@expressive-tea/commons/classes/Metadata");
+exports.Route = Route;
+exports.Get = Get;
+exports.Post = Post;
+exports.Put = Put;
+exports.Patch = Patch;
+exports.Delete = Delete;
+exports.Param = Param;
+exports.Middleware = Middleware;
+exports.View = View;
+const commons_1 = require("@expressive-tea/commons");
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call */
 const decorators_1 = require("../helpers/decorators");
 const server_1 = require("../helpers/server");
-const constants_1 = require("@expressive-tea/commons/constants");
+const commons_2 = require("@expressive-tea/commons");
+const route_1 = require("../mixins/route");
 /**
  * @module Decorators/Router
  */
@@ -17,45 +25,25 @@ const constants_1 = require("@expressive-tea/commons/constants");
  * to allow Expressive Tea Setting up the Controller as part of a Module.
  *
  * @decorator {ClassDecorator} Route - Assign a route to controller endpoints.
+ * @template TBase - The base constructor type being decorated
+ * @param {string} mountpoint - Register the url part to mount the Controller (default: '/')
+ * @returns {(target: TBase) => RouterizedClass<TBase>} Decorator function that returns a routerized class
  * @summary Generate a Placeholder endpoint root for controller routes.
- * @param {string} mountpoint Register the url part to mount the Controller.
+ *
  * @example
- * {REPLACE-AT}Route('/)
- * class Example {}
+ * {REPLACE-AT}Route('/users')
+ * class UserController {
+ *   {REPLACE-AT}Get('/')
+ *   getUsers() { return ['user1', 'user2']; }
+ * }
+ *
+ * @since 1.0.0
  */
 function Route(mountpoint = '/') {
     return (RouterClass) => {
-        return class ExpressiveTeaRoute extends RouterClass {
-            constructor(...args) {
-                super(...args);
-                const handlers = Metadata_1.default.get(constants_1.ROUTER_HANDLERS_KEY, this) || [];
-                this.router = (0, express_1.Router)();
-                this.mountpoint = mountpoint;
-                (0, lodash_1.each)(handlers, h => {
-                    const middlewares = h.handler.$middlewares || [];
-                    this.router[h.verb](h.route, ...middlewares, this.__registerHandler(h));
-                });
-            }
-            __mount(parent) {
-                const rootMiddlewares = Metadata_1.default.get(constants_1.ROUTER_MIDDLEWARES_KEY, this) || [];
-                parent.use(this.mountpoint, ...rootMiddlewares, this.router);
-                return this;
-            }
-            __registerHandler(options) {
-                const self = this;
-                const decoratedArguments = Metadata_1.default.get(constants_1.ARGUMENTS_KEY, options.target, options.propertyKey);
-                const annotations = Metadata_1.default.get(constants_1.ROUTER_ANNOTATIONS_KEY, options.target, options.propertyKey);
-                return server_1.executeRequest.bind({
-                    options,
-                    decoratedArguments,
-                    annotations,
-                    self
-                });
-            }
-        };
+        return (0, route_1.Routerize)(RouterClass, mountpoint);
     };
 }
-exports.Route = Route;
 /**
  * Define a GET Endpoint response over the controller router and can define in which route should be responds and
  * by default this is responding to everything on the controller root path.
@@ -76,7 +64,6 @@ exports.Route = Route;
 function Get(route = '*') {
     return (0, server_1.generateRoute)(route, 'get');
 }
-exports.Get = Get;
 /**
  * Define a POST Endpoint response over the controller router and can define in which route should be responds and
  * by default this is responding to everything on the controller root path.
@@ -97,7 +84,6 @@ exports.Get = Get;
 function Post(route = '*') {
     return (0, server_1.generateRoute)(route, 'post');
 }
-exports.Post = Post;
 /**
  * Define a PUT Endpoint response over the controller router and can define in which route should be responds and
  * by default this is responding to everything on the controller root path.
@@ -118,7 +104,6 @@ exports.Post = Post;
 function Put(route = '*') {
     return (0, server_1.generateRoute)(route, 'put');
 }
-exports.Put = Put;
 /**
  * Define a PATCH Endpoint response over the controller router and can define in which route should be responds and
  * by default this is responding to everything on the controller root path.
@@ -139,7 +124,6 @@ exports.Put = Put;
 function Patch(route = '*') {
     return (0, server_1.generateRoute)(route, 'patch');
 }
-exports.Patch = Patch;
 /**
  * Define a DELETE Endpoint response over the controller router and can define in which route should be responds and
  * by default this is responding to everything on the controller root path.
@@ -160,7 +144,6 @@ exports.Patch = Patch;
 function Delete(route = '*') {
     return (0, server_1.generateRoute)(route, 'delete');
 }
-exports.Delete = Delete;
 /**
  * Define a Route path parameter transformation method as mentioned on Express this is just call by controller endpoints
  * route paths and it helps to define logic on each route path parameters. Example, you can require transform userId
@@ -197,7 +180,6 @@ exports.Delete = Delete;
 function Param(route = '*') {
     return (0, server_1.generateRoute)(route, 'param');
 }
-exports.Param = Param;
 /**
  * Middleware Decorator is following the middleware functionality inheritance from Express framework itself and follow
  * the same rules, that execute any code before response the request and can change the current request or response
@@ -228,15 +210,14 @@ exports.Param = Param;
  */
 function Middleware(middleware) {
     return (target, property, descriptor) => {
-        if (!property) {
-            rootMiddleware(target, middleware);
+        if (property) {
+            routeMiddleware(target, descriptor, middleware);
         }
         else {
-            routeMiddleware(target, descriptor, middleware);
+            rootMiddleware(target, middleware);
         }
     };
 }
-exports.Middleware = Middleware;
 /**
  * Will generate a GET route to respond rendering a view template setting up before; the controller method <b>MUST</b>
  * return an object in order to fulfilled the local variables into the view.
@@ -254,19 +235,18 @@ exports.Middleware = Middleware;
  *
  */
 function View(viewName, route) {
-    route = route || `/${viewName}`;
+    route = route !== null && route !== void 0 ? route : `/${viewName}`;
     return (target, propertyKey, descriptor) => {
         (0, decorators_1.addAnnotation)('view', target, propertyKey, viewName);
         (0, server_1.router)('get', route, target, descriptor.value, propertyKey);
     };
 }
-exports.View = View;
 function rootMiddleware(target, middleware) {
-    const existedRoutesHandlers = Metadata_1.default.get(constants_1.ROUTER_MIDDLEWARES_KEY, target) || [];
+    const existedRoutesHandlers = commons_1.Metadata.get(commons_2.ROUTER_MIDDLEWARES_KEY, target) || [];
     existedRoutesHandlers.unshift(middleware);
-    Metadata_1.default.set(constants_1.ROUTER_MIDDLEWARES_KEY, existedRoutesHandlers, target);
+    commons_1.Metadata.set(commons_2.ROUTER_MIDDLEWARES_KEY, existedRoutesHandlers, target);
 }
-function routeMiddleware(target, descriptor, middleware) {
+function routeMiddleware(_, descriptor, middleware) {
     descriptor.value.$middlewares = descriptor.value.$middlewares || [];
     descriptor.value.$middlewares.unshift(middleware);
 }

package/decorators/server.d.ts

@@ -1,6 +1,7 @@
-import { Express } from 'express';
-import { BOOT_STAGES } from '@expressive-tea/commons/constants';
-import { ExpressiveTeaPotSettings, ExpressiveTeaServerProps, ExpressiveTeaStaticFileServer, ExpressiveTeaCupSettings } from '@expressive-tea/commons/interfaces';
+import { type Express } from 'express';
+import { type BOOT_STAGES } from '@expressive-tea/commons';
+import { type ExpressiveTeaPotSettings, type ExpressiveTeaServerProps, type ExpressiveTeaStaticFileServer, type ExpressiveTeaCupSettings } from '@expressive-tea/commons';
+import { Newable } from 'inversify';
 /**
  * Plug Class Decorator create a simple plugin to execute in one of the public stages defined on BOOT_STAGES, might
  * be useful to attach a simple Express Server configuration.
@@ -16,7 +17,7 @@ import { ExpressiveTeaPotSettings, ExpressiveTeaServerProps, ExpressiveTeaStatic
  * {REPLACE-AT}Plug(BOOT_STAGES.BOOT_DEPENDENCIES, 'test', s => console.log, true)
  * class Example extends Boot {}
  */
-export declare function Plug(stage: BOOT_STAGES, name: string, method: (server?: Express | never, ...extraArgs: unknown[]) => Promise<any> | any, required?: boolean): (target: any) => void;
+export declare function Plug(stage: BOOT_STAGES, name: string, method: (server?: Express, ...extraArgs: unknown[]) => Promise<void> | void, required?: boolean): (target: any) => void;
 /**
  * Since version 1.1.0 Expressive Tea allow to use external plugins using the node
  * package @expressive-tea/plugin. This plugin engine allows to create more complex plugin configuration and provision
@@ -29,7 +30,7 @@ export declare function Plug(stage: BOOT_STAGES, name: string, method: (server?:
  * @version 1.1.0
  * @link https://www.npmjs.com/package/@expressive-tea/plugin Expressive Tea Plugin
  */
-export declare function Pour(Plugin: any, ...pluginArgs: any[]): (target: any) => void;
+export declare function Pour(Plugin: Newable<any>, ...pluginArgs: any[]): (target: any) => void;
 /**
  * Server Settings Singleton Class Decorator this Provide the Configuration to the server or another component on
  * the projects,is working as a container to store user and library settings.
@@ -67,9 +68,8 @@ export declare function ExpressDirective(name: string, ...settings: any[]): (tar
  * All properties will contains the settings value or undefined if current settings is not founded.
  * @decorator {PropertyDecorator} Setting - Assign Server Settings to Property as default value.
  * @summary Automatically assign a settings declared on the Server Settings decorator to a class property.
- * @param {string} settingName The Setting name tha
  */
-export declare function Setting(settingName: string): (target: any, propertyName: string) => any;
+export declare function Setting(): (target: any, propertyName: string) => any;
 /**
  * Register Modules Method Decorator this Method Decorator is used at bootstrap level and should decorate bootstrap class
  * and register modules.
@@ -87,6 +87,6 @@ export declare function Proxies(proxyContainers: any[]): (target: any) => void;
  * @param {Class} Module
  * @deprecated Use the new decorator Modules that allow add modules into registered modules.
  */
-export declare function RegisterModule(Module: any): (target: any, property: any) => void;
+export declare function RegisterModule(Module: any): (_: any, __: any) => never;
 export declare function Teapot(teapotSettings: ExpressiveTeaPotSettings): (target: object) => void;
 export declare function Teacup(teacupSettings: ExpressiveTeaCupSettings): (target: object) => void;