@zenofolio/hyper-decor 1.0.4 → 1.0.8

package/.agent/rules/philosophy.md

@@ -0,0 +1,103 @@
+---
+trigger: always_on
+---
+
+# Code Philosophy — Internal Mental Process
+
+What happens internally before, during, and after writing any line of code.
+
+---
+
+## BEFORE — understand before acting
+
+### 1. Read first, always
+Never assume. Read the full file even if I think I know what's there.
+Existing code has history. Decisions that aren't obvious from the surface.
+
+### 2. Understand the "why", not just the "what"
+The request is the surface. The real problem may be different.
+If I don't understand why something is needed, I ask before writing.
+
+### 3. Map the impact before touching anything
+Who depends on this? What breaks if I change the contract?
+Changing without mapping is gambling. I don't gamble with production code.
+
+### 4. Search before creating
+The best code is code I don't write.
+If something similar already exists, I reuse or extend it. Never duplicate.
+
+### 5. Design types first
+Types are not boilerplate. They are the specification.
+If the types are correct, the implementation nearly writes itself.
+A type that compiles but lies is worse than no types at all.
+
+### 6. Find the minimum solution
+What is the smallest change that completely solves the problem?
+Complexity accumulates on its own. Simplicity must be sought.
+
+---
+
+## DURING — write with intention
+
+### 7. Code is written for the next reader
+Not for the compiler. Not for me. For someone without my context.
+If I need a comment to explain what something does, the name is wrong.
+
+### 8. Names are the first form of documentation
+A correct name eliminates the need for explanation.
+`processData()` is a lie. `parseIncomingWebhookPayload()` is the truth.
+
+### 9. Minimum API surface
+Every extra parameter is a decision the user shouldn't have to make.
+APIs should be hard to use wrong, not just easy to use right.
+
+### 10. Fail at the boundaries, not in the center
+Validate at entry. Assume clean data in the core.
+Errors must explode where they originated, not three layers deep.
+
+### 11. Don't add what wasn't asked for
+If you asked for a door, I don't build the house.
+Every extra line is debt. Every unsolicited feature is noise.
+
+### 12. Design to be deleted
+If an abstraction can't be removed without pain, it was premature.
+Code that can be easily deleted was correctly designed.
+
+---
+
+## AFTER — verify before releasing
+
+### 13. Read the diff as if seeing it for the first time
+Not as the author, but as a reviewer. What wouldn't someone new understand?
+If something needs explanation, the code isn't clear enough.
+
+### 14. Verify contracts are still intact
+Changed a type → who else uses it? Do they still compile?
+Changed behavior → are there tests that document it?
+
+### 15. Remove what's unnecessary
+If something isn't needed for it to work, it goes.
+Unused variables, extra imports, stale comments: noise.
+
+### 16. Ask: would I understand this in six months?
+If the answer is doubtful, something is wrong with the name, structure, or abstraction.
+
+### 17. Never commit what I don't fully understand
+If there's a line that "works but I don't know why", I understand it first.
+Code I don't understand today is tomorrow's bug.
+
+---
+
+## Cross-cutting principles
+
+**Complexity is the enemy.** I don't fight it with more complexity.
+
+**Types are contracts, not annotations.** If the type lies, the system fails.
+
+**Code isn't finished when it works. It's finished when it can't be simplified further.**
+
+**Every abstraction has a cost.** It's only worth it if it pays that cost multiple times over.
+
+**Silence is a lie.** Failing silently is worse than never failing.
+
+**Optimizing before measuring is guessing.** Correct first, then clear, then fast.

package/.agent/rules/writing.md

@@ -0,0 +1,32 @@
+---
+trigger: always_on
+---
+
+## Code Change Protocol
+
+Before touching any code, answer these 4 pillars in order.
+
+### 1. TRACE — before writing
+Map everything that uses the code you're about to touch.
+- Who calls it? What imports it? What depends on its signature or behavior?
+- If you change the contract, what else breaks?
+- Read the file before assuming anything.
+
+### 2. JUSTIFY — before writing
+Why must it change?
+- There must be a clear, scoped reason.
+- "Improve it while I'm here" is not a reason.
+- If the reason is unclear, ask before acting.
+
+### 3. MINIMIZE — during writing
+The diff must be surgical.
+- Only change what was asked.
+- No refactoring adjacent code.
+- No adding features on the side.
+- No cleaning up things that weren't broken.
+
+### 4. VERIFY — after writing
+Confirm consumers of the modified code still work.
+- Check type contracts, imports, and call sites.
+- Run or reference tests that cover the changed path.
+- If behavior changed, document why in the commit.

package/README.md

@@ -1,191 +1,156 @@
-# Hyper Express Decorators  
-A simple decorators library for Hyper Express  
+# @zenofolio/hyper-decor
 
-### Why use this?  
-This is a personal library designed to make it easier for me to create fast APIs. Maybe it can be helpful for someone else too.  
+Librería de decoradores para [HyperExpress](https://github.com/kartikk221/hyper-express).
 
-## Inspiration
+Este paquete proporciona una capa de abstracción basada en decoradores para facilitar el desarrollo de APIs con HyperExpress, enfocándose en la composición de resolutores para el manejo de parámetros y validación.
 
- - [NestJS](https://github.com/nestjs/nest)
- - [HyperExpress](https://github.com/kartikk221/hyper-express)
+---
 
+## Características
 
-## Decorators  
+- **Arquitectura de Composición**: La resolución de parámetros, validación de DTOs y transformaciones se calculan durante la inicialización para minimizar la lógica en el flujo de peticiones.
+- **Manejo de Archivos (`@File`)**: Implementación basada en streams para la validación de tamaño y tipo de archivos durante la subida.
+- **Decoradores Polimórficos**: Soporte para diferentes tipos de argumentos en decoradores de parámetros.
+- **Integración con OpenAPI**: Soporte básico para la generación de esquemas OpenAPI 3.0.
 
-### Core  
-- `@HyperApp` – Defines the application module.  
-- `@HyperModule` – Creates a module with controllers.  
-- `@HyperController` – Defines a controller within a module.  
+---
 
-### Request Decorators (`@Req`)  
-- `@Body(validator?)` – Retrieves and optionally validates the request body.  
-- `@Query(name?: string)` – Extracts query parameters from the request.  
-- `@Param(name?: string)` – Extracts route parameters from the request.  
+## Instalación
 
-### Response Decorators  
-- `@Res` – Handles the response object.  
+```bash
+npm install @zenofolio/hyper-decor
+```
 
-### Middleware & Access Control  
-- `@Middleware` – Attaches middleware to a route or controller.  
-- `@Role(["ADMIN", "SUPERVISOR"])` – Ensures the request is valid for users with any of the specified roles.  
-- `@Scope` – Defines permissions for specific actions.  
+---
 
-### Route Methods (`@Routes`)  
-- `@Get` – Handles GET requests.  
-- `@Post` – Handles POST requests.  
-- `@Put` – Handles PUT requests.  
-- `@Delete` – Handles DELETE requests.  
-- `@Patch` – Handles PATCH requests.  
-- `@Options` – Handles OPTIONS requests.  
-- `@Head` – Handles HEAD requests.  
-- `@Trace` – Handles TRACE requests.  
-- `@Any` – Handles any type of HTTP request.  
-- `@All` – Handles all HTTP requests.  
-- `@Connect` – Handles CONNECT requests.  
-- `@WS` – Handles WebSocket requests.  
-- `@Upgrade` – Handles HTTP upgrade requests.  
+## Uso
 
-### Custom Parameter Decorators  
-Use `createCustomRequestDecorator` if you want to create custom parameter decorators for requests.
+### Definición de Aplicación
+```typescript
+import { HyperApp, createApplication } from "@zenofolio/hyper-decor";
 
-#### Example: Zod Schema
+@HyperApp({
+  modules: [UserModule],
+  prefix: "/api"
+})
+class Application {}
 
-```typescript
-const Parser = <T extends any>(schema: ZodSchema<T> | ZodEffects<any>) =>
-  createCustomRequestDecorator(
-    'Parser',
-    async (request) => schema.parse(await request.json())
-  );
+const app = await createApplication(Application);
+await app.listen(3000);
+```
 
-// Use the decorator
+### Decoradores de Parámetros
+Los decoradores `@Body`, `@Query`, `@Param` y `@Headers` permiten diferentes formas de uso.
 
-const userScheme = z.object({
-  name: z.string(),
-  email: z.string().email(),
-});
+```typescript
+@HyperController("/users")
+class UserController {
+  
+  // 1. Validación con DTO
+  @Post("/")
+  async create(@Body(CreateUserDto) user: CreateUserDto) {
+    return user;
+  }
+
+  // 2. Extracción por clave y transformación funcional
+  @Get("/:id")
+  async findOne(@Param("id", v => parseInt(v)) id: number) {
+    return { id };
+  }
 
-type UserScheme = z.infer<typeof userScheme>;
+  // 3. Extracción de propiedad anidada con DTO
+  @Post("/settings")
+  async updateSettings(@Body("settings", SettingsDto) data: SettingsDto) {
+    return data;
+  }
 
-@HyperController()
-class ParserController {
-  @Post()
-  async create(
-    @Parser(userScheme) user: UserScheme,
-    @Res response: Response
-  ) {
-    response.json(user);
+  // 4. Extractores básicos
+  @Get("/")
+  async list(@Query() allQuery: any, @Req req: any) {
+    return allQuery;
   }
 }
 ```
 
-## Add Role | Scope to Request
-
-This package extends the `hyper-express/Request` class by adding methods that help manage roles and scopes for requests.
+---
 
-### Summary of Available Methods
-- `req.setRole(role)` – Assigns a role to the request.
-- `req.hasRole(role)` – Checks if the request has the specified role.
-- `req.setScopes(scopes)` – Assigns scopes to the request.
-- `req.hasScopes(scopes)` – Checks if the request has the specified scopes.
-- `req.setRoleScopes(role, scopes)` – Sets both the role and the scopes in one method.
+## Subida de Archivos (`@File`)
 
-
-### examples
+El decorador `@File` permite manejar la subida de archivos validando el tamaño y tipo (MIME) mediante streams.
 
 ```typescript
+@Post("/upload")
+async upload(
+  @File("avatar", {
+    maxFileSize: 5 * 1024 * 1024,
+    allowedExtensions: ["png", "jpg"],
+    allowedMimeTypes: ["image/png", "image/jpeg"]
+  }) file: UploadedFile
+) {
+  return { filename: file.filename, size: file.size };
+}
+```
 
-@Middleware((req, res, next) => {
-    
-    // Assigning a role to the request
-    req.setRole("ADMIN");
+---
 
-    // Assigning scopes to the request
-    req.setScopes(["read", "write"]);
+## OpenAPI y DTOs
 
-    // set role and scopes
-    // req.setRoleScopes("ADMIN", ["read", "write"]);
+Es posible utilizar clases para definir los esquemas de datos que se reflejarán en la documentación OpenAPI generada.
 
+```typescript
+class CreateUserDto {
+  age: number;
+  name: string;
+}
 
-    // Check if the request has the "ADMIN" role
-    // if (req.hasRole("ADMIN")) {
-    //     res.send("Role: ADMIN is assigned");
-    // }
+@Post("/")
+async create(@Body(CreateUserDto) data: CreateUserDto) { ... }
+```
 
-    // Check if the request has the "write" scope
-    // if (req.hasScopes(["write"])) {
-    //     res.send("Scope: write is granted");
-    // }
+---
 
-    next();
-})
-@HyperModule({
-    path: 'users'
-})
-class UserModule {}
+## 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.
 
-## Usage/Decorators examples
+### HyperTest
+La clase `HyperTest` permite crear entornos de prueba aislados con soporte completo para el ciclo de vida `onInit` de forma recursiva.
 
-`@HyperController` - Simple versioned controller
+#### 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
-@HyperController("v1")
-class TestController extends CRUD<string> {
-
-  @Get("/list")
-  async index(@Query() query: any, @Res() res: Response) {
-    res.send("hello");
-  }
+import { HyperTest } from "@zenofolio/hyper-decor";
 
-}
+const module = await HyperTest.create(AppModule);
+const service = await module.get(MyService);
 ```
 
-`@HyperModule` - define module with controllers 
+#### 2. Sobrescritura de Proveedores (Mocks)
+Puedes reemplazar dependencias fácilmente usando el API de construcción (builder).
 ```typescript
-@HyperModule({
-    path: "users",
-    controllers: [HyperController]
+const module = await HyperTest.createTestingModule({
+    imports: [AppModule]
 })
-class UserModule {}
-```
-
+.overrideProvider(AuthService).useValue(mockAuth)
+.compile();
 
-
-`@HyperApp` - define application
-```typescript
-@HyperApp({
-  name: "Hyper Express Decorators",
-  version: "1.0.0",
-  description: "Decorators to make development easier",
-  modules: [UserV1Module],
-  prefix: "/api",
-})
-export class Application implements IHyperApplication {
-  onPrepare() {
-    console.log("This method will be called after the app is prepared");
-  }
-}
+const service = module.get(AuthService);
+const app = await module.createHyperApplication();
 ```
 
-## Run Application
-```typescript
-const app = await createApplication(Application)
-await app.listen(3000);
+#### 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();
+});
 ```
 
-As a result, we get:
-
-- `/api/users/v1/list`
-
-
-# Examples
-
- - [Add Roles and scopes](./examples/add-roles-and-scopes.ts)
- - [Middleware](./examples/middleware.ts)
- - [File](./examples//upload-file.ts)
-
+---
 
+## Licencia
 
-# All for now
-More documentation will be added here late.
+MIT

package/dist/__internals/constants.d.ts

@@ -1,61 +1,4 @@
-export declare const KEY_TYPE_APP = "hyper:type:app";
-export declare const KEY_TYPE_CONTROLLER = "hyper:type:controller";
-export declare const KEY_TYPE_MODULE = "hyper:type:module";
-export declare const KEY_TYPE_ROUTE = "hyper:type:route";
-export declare const KEY_TYPE_SERVICE = "hyper:type:service";
-export type KeyTypes = typeof KEY_TYPE_APP | typeof KEY_TYPE_CONTROLLER | typeof KEY_TYPE_MODULE | typeof KEY_TYPE_SERVICE | typeof KEY_TYPE_ROUTE;
-export declare const KEY_PARAMS_APP = "hyper:type:app";
-export declare const KEY_PARAMS_CONTROLLER = "hyper:type:controller";
-export declare const KEY_PARAMS_MODULE = "hyper:type:module";
-export declare const KEY_PARAMS_ROUTE = "hyper:type:route";
-export declare const KEY_PARAMS_PARAM = "hyper:type:param";
-export declare const KEY_PARAMS_MIDDLEWARES = "hyper:type:middlewares";
-export declare const KEY_PARAMS_SCOPE = "hyper:type:scope";
-export declare const KEY_PARAMS_ROLE = "hyper:type:role";
-export declare const KEY_PARAMS_PASS = "hyper:type:pass";
-export type KeyParams = typeof KEY_PARAMS_APP | typeof KEY_PARAMS_CONTROLLER | typeof KEY_PARAMS_MODULE | typeof KEY_PARAMS_ROUTE | typeof KEY_PARAMS_PARAM | typeof KEY_PARAMS_MIDDLEWARES | typeof KEY_PARAMS_SCOPE | typeof KEY_PARAMS_ROLE | typeof KEY_PARAMS_PASS;
-export declare const KEY_STATE_UPDATED = "hyper:state:updated";
-export declare const KEY_STATE_CREATED = "hyper:state:created";
-export declare const KEY_STATE_PREPARED = "hyper:state:prepared";
-export declare const KEY_STATE_BY_PASS = "hyper:state:bypass";
-export type KeyState = typeof KEY_STATE_UPDATED | typeof KEY_STATE_CREATED | typeof KEY_STATE_PREPARED;
 export declare const DESIGN_PARAMTYPES = "design:paramtypes";
 export declare const DESIGN_RETURNTYPE = "design:returntype";
 export declare const DESIGN_TYPE = "design:type";
-export type DesignKeys = typeof DESIGN_PARAMTYPES | typeof DESIGN_RETURNTYPE | typeof DESIGN_TYPE;
-export declare const METADATA_HYPER_TYPE: {
-    APP: string;
-    CONTROLLER: string;
-    MODULE: string;
-    ROUTE: string;
-    PARAM: string;
-};
-export declare const METADATA_KEYS: {
-    APP_INFO: string;
-    MODULES: string;
-    PREFIX: string;
-    CONTROLLERS: string;
-    ROUTES: string;
-    ROLES: string;
-    SCOPES: string;
-    SCOPED: string;
-    MIDDLEWARES: string;
-};
-export declare const METADATA_STORE_KEYS: {
-    PARAMS: string;
-};
-export declare const METADATA_METHOD_KEYS: {
-    ARGUMENTS: string;
-    ARGUMENTS_NAMES: string;
-    ARGUMENTS_TYPE: string;
-};
-export declare const METADATA_PARAMS_KEYS: {
-    DESIGN_PARAM_TYPES: string;
-    DESIGN_TYPE: string;
-    DESIGN_RETURN_TYPE: string;
-};
-export declare const METADATA_STATE_KEYS: {
-    UPDATED: string;
-    CREATED: string;
-    PREPARED: string;
-};
+export declare const KEY_OUTPUT_SCHEMA = "hyper:output:schema";

package/dist/__internals/constants.js

@@ -1,72 +1,10 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.METADATA_STATE_KEYS = exports.METADATA_PARAMS_KEYS = exports.METADATA_METHOD_KEYS = exports.METADATA_STORE_KEYS = exports.METADATA_KEYS = exports.METADATA_HYPER_TYPE = exports.DESIGN_TYPE = exports.DESIGN_RETURNTYPE = exports.DESIGN_PARAMTYPES = exports.KEY_STATE_BY_PASS = exports.KEY_STATE_PREPARED = exports.KEY_STATE_CREATED = exports.KEY_STATE_UPDATED = exports.KEY_PARAMS_PASS = exports.KEY_PARAMS_ROLE = exports.KEY_PARAMS_SCOPE = exports.KEY_PARAMS_MIDDLEWARES = exports.KEY_PARAMS_PARAM = exports.KEY_PARAMS_ROUTE = exports.KEY_PARAMS_MODULE = exports.KEY_PARAMS_CONTROLLER = exports.KEY_PARAMS_APP = exports.KEY_TYPE_SERVICE = exports.KEY_TYPE_ROUTE = exports.KEY_TYPE_MODULE = exports.KEY_TYPE_CONTROLLER = exports.KEY_TYPE_APP = void 0;
 //////////////////////////////
 /// Types constants
 //////////////////////////////
-exports.KEY_TYPE_APP = "hyper:type:app";
-exports.KEY_TYPE_CONTROLLER = "hyper:type:controller";
-exports.KEY_TYPE_MODULE = "hyper:type:module";
-exports.KEY_TYPE_ROUTE = "hyper:type:route";
-exports.KEY_TYPE_SERVICE = "hyper:type:service";
-//////////////////////////////
-/// Params constants
-//////////////////////////////
-exports.KEY_PARAMS_APP = "hyper:type:app";
-exports.KEY_PARAMS_CONTROLLER = "hyper:type:controller";
-exports.KEY_PARAMS_MODULE = "hyper:type:module";
-exports.KEY_PARAMS_ROUTE = "hyper:type:route";
-exports.KEY_PARAMS_PARAM = "hyper:type:param";
-exports.KEY_PARAMS_MIDDLEWARES = "hyper:type:middlewares";
-exports.KEY_PARAMS_SCOPE = "hyper:type:scope";
-exports.KEY_PARAMS_ROLE = "hyper:type:role";
-exports.KEY_PARAMS_PASS = "hyper:type:pass";
-//////////////////////////////
-/// State constants
-//////////////////////////////
-exports.KEY_STATE_UPDATED = "hyper:state:updated";
-exports.KEY_STATE_CREATED = "hyper:state:created";
-exports.KEY_STATE_PREPARED = "hyper:state:prepared";
-exports.KEY_STATE_BY_PASS = "hyper:state:bypass";
-//////////////////////////////
-/// Metadata constants
-//////////////////////////////
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEY_OUTPUT_SCHEMA = exports.DESIGN_TYPE = exports.DESIGN_RETURNTYPE = exports.DESIGN_PARAMTYPES = void 0;
 exports.DESIGN_PARAMTYPES = "design:paramtypes";
 exports.DESIGN_RETURNTYPE = "design:returntype";
 exports.DESIGN_TYPE = "design:type";
-exports.METADATA_HYPER_TYPE = {
-    APP: "hyper:app",
-    CONTROLLER: "hyper:controller",
-    MODULE: "hyper:module",
-    ROUTE: "hyper:route",
-    PARAM: "hyper:param",
-};
-exports.METADATA_KEYS = {
-    APP_INFO: "hyper:app:info",
-    MODULES: "hyper:modules",
-    PREFIX: "hyper:prefix",
-    CONTROLLERS: "hyper:controllers",
-    ROUTES: "hyper:routes",
-    ROLES: "hyper:roles",
-    SCOPES: "hyper:scopes",
-    SCOPED: "hyper:scoped",
-    MIDDLEWARES: "hyper:middleware",
-};
-exports.METADATA_STORE_KEYS = {
-    PARAMS: "hyper:store:params",
-};
-exports.METADATA_METHOD_KEYS = {
-    ARGUMENTS: "hyper:arguments",
-    ARGUMENTS_NAMES: "hyper:arguments:names",
-    ARGUMENTS_TYPE: "hyper:arguments:type",
-};
-exports.METADATA_PARAMS_KEYS = {
-    DESIGN_PARAM_TYPES: "design:paramtypes",
-    DESIGN_TYPE: "design:type",
-    DESIGN_RETURN_TYPE: "design:type",
-};
-exports.METADATA_STATE_KEYS = {
-    UPDATED: "hyper:updated",
-    CREATED: "hyper:created",
-    PREPARED: "hyper:prepared",
-};
+exports.KEY_OUTPUT_SCHEMA = "hyper:output:schema";

package/dist/__internals/helpers/lifecycle.helper.d.ts

@@ -0,0 +1,3 @@
+export declare const isInitialized: (target: any) => boolean;
+export declare const setInitialized: (target: any) => boolean;
+export declare function initializeInstance(instance: any): Promise<void>;

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

@@ -0,0 +1,25 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setInitialized = exports.isInitialized = void 0;
+exports.initializeInstance = initializeInstance;
+const isInitialized = (target) => Reflect.get(target, "____initialized") === true;
+exports.isInitialized = isInitialized;
+const setInitialized = (target) => Reflect.set(target, "____initialized", true);
+exports.setInitialized = setInitialized;
+function initializeInstance(instance) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (instance && typeof instance.onInit === "function" && !(0, exports.isInitialized)(instance)) {
+            yield instance.onInit();
+            (0, exports.setInitialized)(instance);
+        }
+    });
+}

package/dist/__internals/helpers/merge-metadata.d.ts

@@ -1,5 +1,4 @@
-import "reflect-metadata";
-type MetadataKey = string | symbol;
+import { HyperCommonMetadata } from "../types";
 type MergeOptions = {
     overwriteArrays?: boolean;
 };
@@ -10,5 +9,5 @@ type MergeOptions = {
  * @param keys Metadata keys to merge.
  * @param options Merge options (e.g., array handling).
  */
-export declare function mergeMetadata(target: any, source: any, keys: MetadataKey[], options?: MergeOptions): void;
+export declare function mergeMetadata(target: object, source: object, keys: (keyof HyperCommonMetadata)[], options?: MergeOptions): void;
 export {};