@zenofolio/hyper-decor 1.0.75 → 1.0.81

package/README.md

@@ -109,6 +109,48 @@ async create(@Body(CreateUserDto) data: CreateUserDto) { ... }
 
 ---
 
+## Testing
+
+`@zenofolio/hyper-decor` incluye una utilidad potente y fácil de usar inspirada en NestJS para facilitar el testing de servicios, módulos y controladores.
+
+### HyperTest
+La clase `HyperTest` permite crear entornos de prueba aislados con soporte completo para el ciclo de vida `onInit` de forma recursiva.
+
+#### 1. Bootstrap de una línea (Simplicidad total)
+Ideal para pruebas rápidas de integración de una aplicación, módulo o servicio.
+```typescript
+import { HyperTest } from "@zenofolio/hyper-decor";
+
+const module = await HyperTest.create(AppModule);
+const service = await module.get(MyService);
+```
+
+#### 2. Sobrescritura de Proveedores (Mocks)
+Puedes reemplazar dependencias fácilmente usando el API de construcción (builder).
+```typescript
+const module = await HyperTest.createTestingModule({
+    imports: [AppModule]
+})
+.overrideProvider(AuthService).useValue(mockAuth)
+.compile();
+
+const service = module.get(AuthService);
+const app = await module.createHyperApplication();
+```
+
+#### 3. Soporte para Clases Abstractas e Inyección Profunda
+El sistema soporta la resolución de implementaciones a través de clases abstractas como tokens y garantiza que todo el árbol de dependencias ejecute su `onInit` antes de comenzar la prueba.
+
+### Reset del Contenedor
+Para evitar la persistencia de instancias entre tests, `HyperTest` proporciona una utilidad de limpieza.
+```typescript
+beforeEach(() => {
+    HyperTest.reset();
+});
+```
+
+---
+
 ## Licencia
 
 MIT

package/dist/__internals/helpers/prepare.helper.js

@@ -275,6 +275,16 @@ function ensureResolvable(target) {
         tsyringe_1.container.register(target, target);
     }
 }
+function registerRoutes(target, instance, router, namespace, log) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const methods = getMethodMetadataMap(target);
+        for (const key of Object.keys(methods)) {
+            const route = methods[key].route;
+            if (route)
+                yield prepareRoute(target, router, route, instance, namespace, log);
+        }
+    });
+}
 function prepareController(descriptor, context, log) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
@@ -285,12 +295,7 @@ function prepareController(descriptor, context, log) {
         yield prepareImportsInternal((_a = metadata.imports) !== null && _a !== void 0 ? _a : [], context, log);
         yield registerInstanceHandlers(instance, target, context.namespace, log);
         applyCommonPipeline(target.name, { use: (...args) => router.use(...args) }, data, log);
-        const methods = getMethodMetadataMap(target);
-        for (const key of Object.keys(methods)) {
-            const route = methods[key].route;
-            if (route)
-                yield prepareRoute(target, router, route, instance, context.namespace, log);
-        }
+        yield registerRoutes(target, instance, router, context.namespace, log);
         context.parentRouter.use(context.prefix, router);
     });
 }
@@ -319,6 +324,8 @@ function prepareModule(descriptor, context, log) {
                 }, log);
             }
         }
+        // Direct routes on module
+        yield registerRoutes(target, instance, router, context.namespace, log);
         // Controllers
         if ((_c = metadata.controllers) === null || _c === void 0 ? void 0 : _c.length) {
             for (const c of metadata.controllers) {
@@ -364,6 +371,8 @@ function prepareApplication(options, Target, log) {
         yield prepareImportsInternal((_b = options.imports) !== null && _b !== void 0 ? _b : [], context, log);
         yield registerInstanceHandlers(appInstance, Target, context.namespace, log);
         applyCommonPipeline(Target.name, { use: (...args) => appServer.use(...args) }, data, log);
+        // Direct routes on app
+        yield registerRoutes(Target, appInstance, appServer, context.namespace, log);
         if ((_c = options.modules) === null || _c === void 0 ? void 0 : _c.length) {
             for (const m of options.modules) {
                 const mData = getData(m).metadata;

package/dist/common/testing.d.ts

@@ -0,0 +1,56 @@
+import "reflect-metadata";
+import { InjectionToken } from "tsyringe";
+import { Constructor, HyperAppMetadata, ImportType } from "../lib/server/decorators/types";
+export type Token<T = any> = InjectionToken<T> | Constructor<T> | string | (abstract new (...args: any[]) => T);
+/**
+ * 🧪 TestingModule
+ * Holds the context of a compiled test environment.
+ */
+export declare class TestingModule {
+    private target?;
+    constructor(target?: Constructor | undefined);
+    /**
+     * Resolves a dependency from the container and ensures it's initialized.
+     */
+    resolve<T>(token: Token<T>): Promise<T>;
+    /**
+     * Shortcut for resolve (consistent with NestJS)
+     */
+    get<T>(token: Token<T>): Promise<T>;
+    /**
+     * Creates the full HyperExpress application proxy.
+     */
+    createHyperApplication(): Promise<any>;
+}
+/**
+ * 🛠️ TestingModuleBuilder
+ * Fluent API for configuring the testing module.
+ */
+export declare class TestingModuleBuilder {
+    private metadata;
+    constructor(metadata: Partial<HyperAppMetadata>);
+    overrideProvider(token: Token): any;
+    compile(): Promise<TestingModule>;
+}
+/**
+ * 🚀 HyperTest
+ * Entry point for creating testing environments.
+ */
+export declare class HyperTest {
+    /**
+     * Ultra-simple one-liner to boot a module or app.
+     * const module = await HyperTest.create(AppModule);
+     */
+    static create(Target: Constructor, options?: {
+        providers?: ImportType[];
+    }): Promise<TestingModule>;
+    /**
+     * Full builder API for complex configurations.
+     */
+    static createTestingModule(metadata: Partial<HyperAppMetadata>): TestingModuleBuilder;
+    /**
+     * Resets the global container instances (but keeps registrations).
+     * Useful between tests when isolation is not possible.
+     */
+    static reset(): void;
+}

package/dist/common/testing.js

@@ -0,0 +1,193 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperTest = exports.TestingModuleBuilder = exports.TestingModule = void 0;
+require("reflect-metadata");
+const tsyringe_1 = require("tsyringe");
+const stores_1 = require("../__internals/stores");
+const lifecycle_helper_1 = require("../__internals/helpers/lifecycle.helper");
+const bootstrap_1 = require("./bootstrap");
+const HyperApp_1 = require("../lib/server/decorators/HyperApp");
+/**
+ * 🧪 TestingModule
+ * Holds the context of a compiled test environment.
+ */
+class TestingModule {
+    constructor(target) {
+        this.target = target;
+    }
+    /**
+     * Resolves a dependency from the container and ensures it's initialized.
+     */
+    resolve(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield deepResolve(token);
+        });
+    }
+    /**
+     * Shortcut for resolve (consistent with NestJS)
+     */
+    get(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.resolve(token);
+        });
+    }
+    /**
+     * Creates the full HyperExpress application proxy.
+     */
+    createHyperApplication() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.target) {
+                throw new Error("Cannot create application without a target module/app.");
+            }
+            return yield (0, bootstrap_1.createApplication)(this.target);
+        });
+    }
+}
+exports.TestingModule = TestingModule;
+/**
+ * 🛠️ TestingModuleBuilder
+ * Fluent API for configuring the testing module.
+ */
+class TestingModuleBuilder {
+    constructor(metadata) {
+        this.metadata = metadata;
+    }
+    overrideProvider(token) {
+        return {
+            useValue: (value) => {
+                tsyringe_1.container.register(token, { useValue: value });
+                return this;
+            },
+            useClass: (target) => {
+                tsyringe_1.container.register(token, { useClass: target });
+                return this;
+            },
+            useFactory: (factory) => {
+                tsyringe_1.container.register(token, { useFactory: factory });
+                return this;
+            }
+        };
+    }
+    compile() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 1. Create a synthetic app if needed
+            let SyntheticApp = class SyntheticApp {
+            };
+            SyntheticApp = __decorate([
+                (0, HyperApp_1.HyperApp)(this.metadata)
+            ], SyntheticApp);
+            // 2. Deep initialize all defined imports/providers
+            if (this.metadata.imports) {
+                for (const item of this.metadata.imports) {
+                    const token = typeof item === "object" && "token" in item ? item.token : item;
+                    yield deepResolve(token);
+                }
+            }
+            return new TestingModule(SyntheticApp);
+        });
+    }
+}
+exports.TestingModuleBuilder = TestingModuleBuilder;
+/**
+ * 🚀 HyperTest
+ * Entry point for creating testing environments.
+ */
+class HyperTest {
+    /**
+     * Ultra-simple one-liner to boot a module or app.
+     * const module = await HyperTest.create(AppModule);
+     */
+    static create(Target, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const builder = this.createTestingModule({
+                imports: [Target, ...((options === null || options === void 0 ? void 0 : options.providers) || [])]
+            });
+            const module = yield builder.compile();
+            // Ensure the target itself is deep-resolved
+            yield deepResolve(Target);
+            return module;
+        });
+    }
+    /**
+     * Full builder API for complex configurations.
+     */
+    static createTestingModule(metadata) {
+        return new TestingModuleBuilder(metadata);
+    }
+    /**
+     * Resets the global container instances (but keeps registrations).
+     * Useful between tests when isolation is not possible.
+     */
+    static reset() {
+        tsyringe_1.container.clearInstances();
+    }
+}
+exports.HyperTest = HyperTest;
+/**
+ * 🔄 deepResolve
+ * Recursively resolves a token and ensures its onInit chain is executed.
+ */
+function deepResolve(token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const instance = tsyringe_1.container.resolve(token);
+        // 1. Get the actual implementation constructor to inspect dependencies.
+        // We prefer instance.constructor because if token is an abstract class,
+        // dependencies are defined on the implementation.
+        const target = (instance === null || instance === void 0 ? void 0 : instance.constructor) || (typeof token === "function" ? token : null);
+        // 2. Recursive resolution of dependencies (Bottom-up initialization)
+        if (target && typeof target === "function") {
+            const paramTypes = Reflect.getMetadata("design:paramtypes", target) || [];
+            const injectionTokens = Reflect.getOwnMetadata("injectionTokens", target) || {};
+            for (let i = 0; i < paramTypes.length; i++) {
+                // Use @inject token if present, otherwise use design:paramtype
+                const dep = injectionTokens[i] || paramTypes[i];
+                // Avoid cycles or primitives
+                if (dep && typeof dep === "function" && dep !== Object && dep !== Array && dep !== String && dep !== Number && dep !== Boolean) {
+                    yield deepResolve(dep);
+                }
+            }
+        }
+        // 3. Metadata Discovery (traversing @HyperApp, @HyperModule, etc.)
+        const metadata = stores_1.HyperMeta.get(target);
+        if (metadata) {
+            // Resolve imports
+            if (metadata.imports && Array.isArray(metadata.imports)) {
+                for (const item of metadata.imports) {
+                    const depToken = typeof item === "object" && item !== null && "token" in item ? item.token : item;
+                    if (depToken)
+                        yield deepResolve(depToken);
+                }
+            }
+            // Resolve modules recursively
+            if (metadata.modules && Array.isArray(metadata.modules)) {
+                for (const m of metadata.modules) {
+                    yield deepResolve(m);
+                }
+            }
+            // Resolve controllers
+            if (metadata.controllers && Array.isArray(metadata.controllers)) {
+                for (const c of metadata.controllers) {
+                    yield deepResolve(c);
+                }
+            }
+        }
+        // 4. Initialize the instance itself
+        yield (0, lifecycle_helper_1.initializeInstance)(instance);
+        return instance;
+    });
+}

package/dist/index.d.ts

@@ -14,3 +14,4 @@ export * from "./common/transport";
 export * from "./common/message-bus";
 export * from "./__internals/transform/transform.registry";
 export * from "./lib/openapi";
+export * from "./common/testing";

package/dist/index.js

@@ -30,3 +30,4 @@ __exportStar(require("./common/transport"), exports);
 __exportStar(require("./common/message-bus"), exports);
 __exportStar(require("./__internals/transform/transform.registry"), exports);
 __exportStar(require("./lib/openapi"), exports);
+__exportStar(require("./common/testing"), exports);

package/dist/lib/server/decorators/HyperService.d.ts

@@ -1,7 +1,8 @@
 import "reflect-metadata";
+import { Constructor } from "./types";
 interface ServiceDecoratorOptions {
     singleton?: boolean;
-    token?: string | symbol;
+    token?: string | symbol | Constructor | (abstract new (...args: any[]) => any);
 }
 /**
  * 🚀 HyperService Decorator

package/dist/lib/server/decorators/types.d.ts

@@ -9,7 +9,7 @@ export interface IsSingleton {
 }
 export type Constructor<R = object> = new (...args: any[]) => R;
 export type ImportObject = {
-    token: InjectionToken;
+    token: (abstract new (...args: any[]) => any) | InjectionToken;
     useClass?: Constructor;
     useValue?: any;
     useFactory?: (...args: any[]) => any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenofolio/hyper-decor",
-  "version": "1.0.75",
+  "version": "1.0.81",
   "description": "Project core with utilities and features",
   "main": "dist/index.js",
   "author": "zenozaga",
@@ -67,6 +67,10 @@
       "node": "./dist/extension.js",
       "default": "./src/extension.ts"
     },
+    "./testing": {
+      "node": "./dist/common/testing.js",
+      "default": "./src/common/testing.ts"
+    },
     "./openapi": {
       "node": "./dist/lib/openapi/index.js",
       "default": "./src/lib/openapi/index.ts"

package/dist/__internals/creators/request.creator.d.ts

@@ -1,2 +0,0 @@
-import "reflect-metadata";
-export default function createParamDecorator(sourceKey: any, decoratorName: string, keyOrSchema?: string | any, schemaOrTransform?: any, isWholeSource?: boolean): ParameterDecorator;

package/dist/__internals/creators/request.creator.js

@@ -1,173 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = createParamDecorator;
-require("reflect-metadata");
-const constants_1 = require("../constants");
-const decorator_base_1 = require("../decorator-base");
-const WrongPlaceException_1 = __importDefault(require("../../exeptions/WrongPlaceException"));
-const function_util_1 = require("../utils/function.util");
-const object_util_1 = require("../utils/object.util");
-const transform_registry_1 = require("../transform/transform.registry");
-const identitySelector = (value) => value;
-const identityTransformer = (value) => value;
-function createParamDecorator(sourceKey, decoratorName, keyOrSchema, schemaOrTransform, isWholeSource = false) {
-    const _sourceKey = sourceKey;
-    return (0, decorator_base_1.DecoratorHelper)({
-        type: constants_1.KEY_TYPE_CONTROLLER,
-        key: constants_1.KEY_PARAMS_PARAM,
-        options: (options, Target, propertyKey, parameterIndex) => {
-            const isProperty = typeof parameterIndex === "number";
-            if (!isProperty) {
-                throw new WrongPlaceException_1.default(decoratorName, "parameter", `${Target.constructor.name}.${String(propertyKey)}`, Target);
-            }
-            const saved = options !== null && options !== void 0 ? options : { params: {} };
-            const method = Target[propertyKey];
-            const names = (0, function_util_1.extractArgsNames)(method);
-            const types = Reflect.getMetadata(constants_1.DESIGN_PARAMTYPES, Target, propertyKey);
-            const name = names === null || names === void 0 ? void 0 : names[parameterIndex];
-            const type = types === null || types === void 0 ? void 0 : types[parameterIndex];
-            let key = undefined;
-            let inputSchemaOrFn = undefined;
-            let wholeSource = isWholeSource;
-            if (typeof keyOrSchema === "string") {
-                key = keyOrSchema;
-                inputSchemaOrFn = schemaOrTransform;
-            }
-            else if (keyOrSchema !== undefined) {
-                inputSchemaOrFn = keyOrSchema;
-                wholeSource = true;
-            }
-            const hasKey = key !== undefined && key !== "";
-            const hasTransform = inputSchemaOrFn !== undefined;
-            const extractor = createExtractor(_sourceKey);
-            const selector = createSelector(key);
-            const transformer = createTransformer(inputSchemaOrFn, _sourceKey, wholeSource);
-            const resolver = composeResolver(extractor, selector, transformer, hasKey, hasTransform);
-            if (name && saved) {
-                let methodParams = saved.params[propertyKey];
-                if (!methodParams) {
-                    methodParams = saved.params[propertyKey] = [];
-                }
-                methodParams.push({
-                    name,
-                    type,
-                    index: parameterIndex,
-                    key: _sourceKey,
-                    method: propertyKey.toString(),
-                    resolver,
-                    schema: inputSchemaOrFn,
-                    isWholeSource: wholeSource,
-                });
-                if (methodParams.length > 1) {
-                    methodParams.sort((a, b) => a.index - b.index);
-                }
-                Reflect.defineMetadata(constants_1.KEY_PARAMS_PARAM, saved, method);
-            }
-            return saved;
-        },
-    });
-}
-//////////////////////////
-/// Functions
-/////////////////////////
-function createBodyExtractor() {
-    return (req) => __awaiter(this, void 0, void 0, function* () {
-        const request = req;
-        const cachedBody = request.body;
-        if (cachedBody !== undefined) {
-            return cachedBody;
-        }
-        const body = yield req.json();
-        request.body = body;
-        return body;
-    });
-}
-function createReqExtractor() {
-    return (req) => __awaiter(this, void 0, void 0, function* () { return req; });
-}
-function createResExtractor() {
-    return (_req, res) => __awaiter(this, void 0, void 0, function* () { return res; });
-}
-function createGenericExtractor(sourceKey) {
-    return (req) => __awaiter(this, void 0, void 0, function* () { return req[sourceKey]; });
-}
-function createExtractor(sourceKey) {
-    switch (sourceKey) {
-        case "body":
-            return createBodyExtractor();
-        case "req":
-            return createReqExtractor();
-        case "res":
-            return createResExtractor();
-        default:
-            return createGenericExtractor(sourceKey);
-    }
-}
-function createSelector(key) {
-    if (key === undefined || key === "") {
-        return identitySelector;
-    }
-    return (value) => (0, object_util_1.$get)(value, key, value);
-}
-function createDirectTransformer(fn) {
-    return (value) => fn(value);
-}
-function createRegistryTransformer(schema, sourceKey, isWholeSource) {
-    const options = { isWholeSource };
-    const from = sourceKey;
-    return (value, req, res) => transform_registry_1.transformRegistry.resolve({
-        data: value,
-        schema,
-        options,
-        req,
-        res,
-        from,
-    });
-}
-function createTransformer(inputSchemaOrFn, sourceKey, isWholeSource) {
-    if (inputSchemaOrFn === undefined) {
-        return identityTransformer;
-    }
-    if (typeof inputSchemaOrFn === "function" &&
-        inputSchemaOrFn.prototype === undefined) {
-        return createDirectTransformer(inputSchemaOrFn);
-    }
-    if (typeof inputSchemaOrFn === "function" ||
-        typeof inputSchemaOrFn === "string") {
-        return createRegistryTransformer(inputSchemaOrFn, sourceKey, isWholeSource);
-    }
-    return identityTransformer;
-}
-function composeResolver(extractor, selector, transformer, hasKey, hasTransform) {
-    if (!hasKey && !hasTransform) {
-        return extractor;
-    }
-    if (hasKey && !hasTransform) {
-        return (req, res) => __awaiter(this, void 0, void 0, function* () {
-            const value = yield extractor(req, res);
-            return selector(value);
-        });
-    }
-    if (!hasKey && hasTransform) {
-        return (req, res) => __awaiter(this, void 0, void 0, function* () {
-            const value = yield extractor(req, res);
-            return transformer(value, req, res);
-        });
-    }
-    return (req, res) => __awaiter(this, void 0, void 0, function* () {
-        const value = yield extractor(req, res);
-        return transformer(selector(value), req, res);
-    });
-}

package/dist/__internals/creators/routes.creator.d.ts

@@ -1,9 +0,0 @@
-import "reflect-metadata";
-/**
- * Helper function to create route decorators for HTTP methods.
- *
- * @param {string} method - The HTTP method (e.g., GET, POST).
- * @returns {(path?: string) => MethodDecorator} - A method decorator for defining routes.
- *
- */
-export default function createRouteDecorator<T extends any = undefined>(method: string): (path?: string, options?: T) => MethodDecorator & ClassDecorator;

package/dist/__internals/creators/routes.creator.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = createRouteDecorator;
-require("reflect-metadata");
-const constants_1 = require("../constants");
-const decorator_base_1 = require("../decorator-base");
-/**
- * Helper function to create route decorators for HTTP methods.
- *
- * @param {string} method - The HTTP method (e.g., GET, POST).
- * @returns {(path?: string) => MethodDecorator} - A method decorator for defining routes.
- *
- */
-function createRouteDecorator(method) {
-    return (path = "/", options) => (0, decorator_base_1.DecoratorHelper)({
-        type: constants_1.KEY_TYPE_CONTROLLER,
-        key: constants_1.KEY_PARAMS_ROUTE,
-        targetResolver: (target) => { var _a; return (_a = target.constructor) !== null && _a !== void 0 ? _a : target; },
-        options: (data, Target, propertyKey, descriptor) => {
-            // add openAPI data here
-            var _a;
-            const handler = descriptor.value;
-            if (typeof handler !== "function")
-                return data;
-            const saved = (_a = Reflect.getMetadata(constants_1.KEY_PARAMS_ROUTE, Target)) !== null && _a !== void 0 ? _a : {
-                routes: new Set(),
-            };
-            saved.routes.add({
-                className: Target.name,
-                method,
-                path,
-                propertyKey,
-                handler: handler,
-                options,
-            });
-            return saved;
-        },
-    });
-}

package/dist/__internals/decorator-base.d.ts

@@ -1,30 +0,0 @@
-import "reflect-metadata";
-export type DecoratorBaseTypes = "APP" | "MODULE" | "CONTROLLER" | "ROUTE" | "MIDDLEWARE";
-type DefineResolve<T> = (old: T, target?: any, property?: any, descriptor?: any) => T;
-interface onDefineResolve<T> {
-    (data: {
-        key: string;
-        options: T;
-        target: any;
-        property?: any;
-        descriptor?: any;
-    }, defineData: (options: T) => void): void;
-}
-interface BeseDecoratorOptions<T extends any = any> {
-    type?: DecoratorBaseTypes | string;
-    key: string;
-    options: T | DefineResolve<T>;
-    targetResolver?: (target: any, propertyKey?: any, descriptorOrIndex?: any) => any;
-    onDefineData?: onDefineResolve<T>;
-}
-interface BeseDecorator<T> {
-    (target: T): any;
-    (target: T, propertyKey?: any, descriptor?: any): any;
-}
-type TransformFunction<TOptions, T> = (options: TOptions, target: T, propertyKey?: any, descriptor?: any) => any;
-export declare function DecoratorHelper<T, Target extends any = any>({ key, type, options, targetResolver, onDefineData }: BeseDecoratorOptions<T>, ...transformers: TransformFunction<T, Target>[]): BeseDecorator<Target>;
-export declare const defineDecorData: <T>(key: string, options: T | DefineResolve<T>, target: any, property?: any, descriptor?: any) => void;
-export declare const getDecorData: <T>(key: string, target: any, property?: any) => T;
-export declare const hasDecorData: (key: string, target: any, property?: any) => boolean;
-export declare const extractDecorData: <T>(target: any) => T | undefined;
-export {};