@expressots/adapter-express 3.0.0 → 4.0.0-preview.3

package/lib/esm/types/adapter-express/express-utils/content-negotiation-decorators.d.ts

@@ -0,0 +1,94 @@
+import "reflect-metadata";
+import type { CsvFormatOptions, XmlFormatOptions, YamlFormatOptions } from "@expressots/core";
+/**
+ * Accept decorator to specify which content types this route accepts for responses.
+ * Used for content negotiation based on Accept header.
+ * @param contentTypes - Array of accepted content types (e.g., ["application/json", "application/xml"])
+ * @returns MethodDecorator
+ * @example
+ * ```typescript
+ * @Accept("application/json", "application/xml")
+ * @Get("/users")
+ * getUsers() {
+ *   return [{ id: 1, name: "John" }];
+ * }
+ * ```
+ * @public API
+ */
+export declare function Accept(...contentTypes: Array<string>): MethodDecorator;
+/**
+ * Consumes decorator to specify which content types this route consumes for requests.
+ * Used for content negotiation based on Content-Type header.
+ * @param contentTypes - Array of consumed content types (e.g., ["application/json", "application/xml"])
+ * @returns MethodDecorator
+ * @example
+ * ```typescript
+ * @Consumes("application/json", "application/xml")
+ * @Post("/users")
+ * createUser(@body() user: UserDto) {
+ *   return this.userService.create(user);
+ * }
+ * ```
+ * @public API
+ */
+export declare function Consumes(...contentTypes: Array<string>): MethodDecorator;
+/**
+ * Produces decorator to specify which content types this route produces for responses.
+ * Alias for @Accept() decorator.
+ * @param contentTypes - Array of produced content types
+ * @returns MethodDecorator
+ * @public API
+ */
+export declare function Produces(...contentTypes: Array<string>): MethodDecorator;
+/**
+ * CsvOptions decorator to configure CSV formatting options for a route.
+ * @param options - CSV formatting options
+ * @returns MethodDecorator
+ * @example
+ * ```typescript
+ * @CsvOptions({ fields: ["id", "name"], includeHeaders: true })
+ * @Get("/users")
+ * getUsers() {
+ *   return [{ id: 1, name: "John", email: "john@example.com" }];
+ * }
+ * ```
+ * @public API
+ */
+export declare function CsvOptions(options: CsvFormatOptions): MethodDecorator;
+/**
+ * XmlOptions decorator to configure XML formatting options for a route.
+ * @param options - XML formatting options
+ * @returns MethodDecorator
+ * @example
+ * ```typescript
+ * @XmlOptions({ rootElement: "users", itemElement: "user", prettyPrint: true })
+ * @Get("/users")
+ * getUsers() {
+ *   return [{ id: 1, name: "John" }];
+ * }
+ * ```
+ * @public API
+ */
+export declare function XmlOptions(options: XmlFormatOptions): MethodDecorator;
+/**
+ * YamlOptions decorator to configure YAML formatting options for a route.
+ * @param options - YAML formatting options
+ * @returns MethodDecorator
+ * @public API
+ */
+export declare function YamlOptions(options: YamlFormatOptions): MethodDecorator;
+/**
+ * StreamResponse decorator to indicate that the response should be streamed.
+ * Useful for large datasets.
+ * @returns MethodDecorator
+ * @example
+ * ```typescript
+ * @StreamResponse()
+ * @Get("/large-dataset")
+ * getLargeDataset() {
+ *   return this.dataService.streamLargeDataset(); // Returns async iterator
+ * }
+ * ```
+ * @public API
+ */
+export declare function StreamResponse(): MethodDecorator;

package/lib/esm/types/adapter-express/express-utils/decorators.d.ts

@@ -0,0 +1,257 @@
+import "reflect-metadata";
+import { PARAMETER_TYPE, HTTP_VERBS_ENUM } from "./constants.js";
+import type { HandlerDecorator, Middleware, NewableFunction } from "./interfaces.js";
+import { Request } from "express";
+export declare const injectHttpContext: ParameterDecorator & PropertyDecorator;
+/**
+ * Controller decorator to define a new controller
+ * @param path route path
+ * @param middleware array of middleware to be applied to all routes in the controller
+ * @public API
+ */
+export declare function controller(path: string, ...middleware: Array<Middleware>): (target: NewableFunction) => void;
+/**
+ * Http decorator to define the status code for a route
+ * @param code
+ * @returns MethodDecorator
+ * @example ```typescript
+ * @Http(200)
+ * @Get("/")
+ * hello() {
+ *  return "Hello World";
+ * }
+ * ```
+ * @public API
+ */
+export declare function Http(code: number): (target: object, key: string | symbol, descriptor: TypedPropertyDescriptor<any>) => void;
+/**
+ * Version decorator to define the API version for a controller or route method
+ * @param version API version (e.g., "1", "1.0", "v1", or 1)
+ * @returns ClassDecorator | MethodDecorator
+ * @example ```typescript
+ * @Version("1")
+ * @controller("/users")
+ * class UserController {}
+ *
+ * // Or at method level:
+ * @Version("2")
+ * @Get("/")
+ * getUsers() {
+ *   return "v2 users";
+ * }
+ * ```
+ * @public API
+ */
+export declare function Version(version: string | number): (target: any, key?: string | symbol, descriptor?: any) => void;
+/**
+ * Decorator to allow accept all HTTP methods
+ * @param path route path, wildcard
+ * @param middleware array of middleware to be applied to all routes defined in path logic
+ * @public API
+ */
+export declare function All(path: string, ...middleware: Array<Middleware>): HandlerDecorator;
+/**
+ * Decorator to allow GET HTTP method
+ * @param path route path
+ * @param middleware array of middleware to be applied to the route
+ * @public API
+ */
+export declare function Get(path: string, ...middleware: Array<Middleware>): HandlerDecorator;
+/**
+ * Decorator to allow POST HTTP method
+ * @param path route path
+ * @param middleware array of middleware to be applied to the route
+ * @public API
+ */
+export declare function Post(path: string, ...middleware: Array<Middleware>): HandlerDecorator;
+/**
+ * Decorator to allow PUT HTTP method
+ * @param path route path
+ * @param middleware array of middleware to be applied to the route
+ * @public API
+ */
+export declare function Put(path: string, ...middleware: Array<Middleware>): HandlerDecorator;
+/**
+ * Decorator to allow PATCH HTTP method
+ * @param path route path
+ * @param middleware array of middleware to be applied to the route
+ * @public API
+ */
+export declare function Patch(path: string, ...middleware: Array<Middleware>): HandlerDecorator;
+/**
+ * Decorator to allow HEAD HTTP method
+ * @param path route path
+ * @param middleware array of middleware to be applied to the route
+ * @public API
+ */
+export declare function Head(path: string, ...middleware: Array<Middleware>): HandlerDecorator;
+/**
+ * Decorator to allow DELETE HTTP method
+ * @param path route path
+ * @param middleware array of middleware to be applied to the route
+ * @public API
+ */
+export declare function Delete(path: string, ...middleware: Array<Middleware>): HandlerDecorator;
+/**
+ * Decorator to allow custom HTTP method
+ * @param method custom HTTP method
+ * @param path route path
+ * @param middleware array of middleware to be applied to the route
+ * @public API
+ */
+export declare function Method(method: keyof typeof HTTP_VERBS_ENUM, path: string, ...middleware: Array<Middleware>): HandlerDecorator;
+/**
+ * Parameter decorator to inject the request object
+ * @returns ParameterDecorator
+ */
+export declare const request: () => ParameterDecorator;
+/**
+ * Parameter decorator to inject the response object
+ * @returns ParameterDecorator
+ */
+export declare const response: () => ParameterDecorator;
+/**
+ * Parameter decorator to inject parameters from the route
+ * @returns ParameterDecorator
+ */
+export declare const param: (paramName?: string) => ParameterDecorator;
+/**
+ * Parameter decorator to inject query parameters
+ * @returns ParameterDecorator
+ */
+export declare const query: (queryParamName?: string) => ParameterDecorator;
+/**
+ * Parameter decorator to inject the request body
+ * @returns ParameterDecorator
+ */
+export declare const body: () => ParameterDecorator;
+/**
+ * Parameter decorator to inject the request headers
+ * @returns ParameterDecorator
+ */
+export declare const headers: (headerName?: string) => ParameterDecorator;
+/**
+ * Parameter decorator to inject the request cookies
+ * @returns ParameterDecorator
+ */
+export declare const cookies: (cookieName?: string) => ParameterDecorator;
+/**
+ * Parameter decorator next function
+ * @returns ParameterDecorator
+ */
+export declare const next: () => ParameterDecorator;
+/**
+ * Parameter decorator to inject the principal object obtained from AuthProvider
+ * @returns ParameterDecorator
+ */
+export declare const principal: () => ParameterDecorator;
+/**
+ * Parameter decorator to inject the request object
+ * @returns ParameterDecorator
+ * @param type - The type of parameter to inject
+ * @param parameterName - The name of the parameter to inject
+ * @public API
+ */
+export declare function params(type: PARAMETER_TYPE, parameterName?: string): ParameterDecorator;
+/**
+ * Render decorator to define the template and default data for a route
+ * @param template The template to render
+ * @param defaultData The default data to pass to the template
+ * @returns MethodDecorator
+ * @public API
+ */
+export declare function Render(template: string, defaultData?: Record<string, unknown>): MethodDecorator;
+export declare function getRenderMetadata(target: object, propertyKey: string | symbol): {
+    template?: string;
+    defaultData?: Record<string, unknown>;
+};
+/**
+ * Multer storage engine interface
+ */
+export interface StorageEngine {
+    _handleFile(req: Request, file: MulterFile, callback: (error?: Error | null, info?: Partial<MulterFile>) => void): void;
+    _removeFile(req: Request, file: MulterFile, callback: (error: Error | null) => void): void;
+}
+/**
+ * Multer file interface
+ */
+export interface MulterFile {
+    fieldname: string;
+    originalname: string;
+    encoding: string;
+    mimetype: string;
+    size: number;
+    destination?: string;
+    filename?: string;
+    path?: string;
+    buffer?: Buffer;
+}
+/**
+ * Multer limits interface
+ */
+export interface MulterLimits {
+    fieldNameSize?: number;
+    fieldSize?: number;
+    fields?: number;
+    fileSize?: number;
+    files?: number;
+    parts?: number;
+    headerPairs?: number;
+}
+/**
+ * Multer options interface
+ */
+export interface MulterOptions {
+    dest?: string;
+    storage?: StorageEngine;
+    limits?: MulterLimits;
+    fileFilter?: FileFilter;
+}
+export type FileFilterCallback = (error: Error | null, acceptFile: boolean) => void;
+export type FileFilter = (req: Request, file: MulterFile, callback: FileFilterCallback) => void;
+type FieldOptions = {
+    fieldName: string;
+    maxCount?: number;
+};
+/**
+ * File upload decorator to handle file uploads.
+ *
+ * This decorator integrates with the global upload configuration
+ * set via `Middleware.upload()` in app.ts. If global config exists,
+ * it will be used as defaults, with local options taking precedence.
+ *
+ * @param options - Field configuration (fieldName, maxCount, none, any)
+ * @param multerOptions - Optional multer options (overrides global config)
+ * @default { none: true }
+ * @returns MethodDecorator
+ *
+ * @example
+ * ```typescript
+ * // In app.ts - configure globally (optional)
+ * this.Middleware.upload({
+ *   destination: './uploads',
+ *   limits: { fileSize: 10 * 1024 * 1024 }
+ * });
+ *
+ * // In controller - uses global config automatically
+ * @Post('avatar')
+ * @FileUpload({ fieldName: 'avatar' })
+ * uploadAvatar(req: Request) {
+ *   return req.file;
+ * }
+ *
+ * // Override global config for specific endpoint
+ * @Post('document')
+ * @FileUpload({ fieldName: 'doc' }, { limits: { fileSize: 50 * 1024 * 1024 } })
+ * uploadDocument(req: Request) {
+ *   return req.file;
+ * }
+ * ```
+ *
+ * @public API
+ */
+export declare function FileUpload(options?: FieldOptions | Array<FieldOptions> | {
+    none?: boolean;
+    any?: boolean;
+}, multerOptions?: MulterOptions): MethodDecorator;
+export {};

package/lib/esm/types/adapter-express/express-utils/exception-filter-decorators.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Re-export exception filter decorators from core for backward compatibility
+ * These decorators are now part of @expressots/core to avoid circular dependencies
+ * @public API
+ */
+export { Catch, UseFilters } from "@expressots/core";

package/lib/esm/types/adapter-express/express-utils/guard-context-factory.d.ts

@@ -0,0 +1,17 @@
+import "reflect-metadata";
+import { Request, Response } from "express";
+import { interfaces } from "@expressots/core";
+import type { GuardContext } from "@expressots/core";
+import type { IScopeExtractor } from "./scope-extractor.interface.js";
+/**
+ * Factory for creating GuardContext from Express request/response
+ */
+export declare class GuardContextFactory {
+    private container;
+    private scopeExtractor;
+    constructor(container: interfaces.Container, scopeExtractor: IScopeExtractor);
+    /**
+     * Create GuardContext from Express request/response
+     */
+    create(req: Request, res: Response): Promise<GuardContext>;
+}

package/lib/esm/types/adapter-express/express-utils/guard-middleware.d.ts

@@ -0,0 +1,22 @@
+import { Request, Response, NextFunction } from "express";
+import { Container } from "@expressots/core";
+import { GuardExecutor } from "@expressots/core";
+import { GuardContextFactory } from "./guard-context-factory.js";
+/**
+ * Express middleware that executes guards before route handler
+ */
+export declare class GuardMiddleware {
+    private executor;
+    private contextFactory;
+    private container;
+    constructor(executor: GuardExecutor, contextFactory: GuardContextFactory, container: Container);
+    /**
+     * Express middleware function
+     */
+    execute: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    /**
+     * Extract guards from request metadata
+     * @private
+     */
+    private extractGuards;
+}

package/lib/esm/types/adapter-express/express-utils/guard-utils.d.ts

@@ -0,0 +1,11 @@
+import "reflect-metadata";
+import type { GuardClass, IGuard } from "@expressots/core";
+import type { NewableFunction } from "./interfaces.js";
+/**
+ * Extract guards from controller metadata
+ */
+export declare function getControllerGuards(constructor: NewableFunction): Array<GuardClass | IGuard>;
+/**
+ * Extract guards from method metadata
+ */
+export declare function getMethodGuards(constructor: NewableFunction, methodName: string | symbol): Array<GuardClass | IGuard>;

package/lib/esm/types/adapter-express/express-utils/http-context-store.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Per-request HttpContext storage.
+ *
+ * Replaces the previous `Reflect.defineMetadata(METADATA_KEY.httpContext, ctx, req)`
+ * call in `InversifyExpressServer.build()`, which paid the cost of
+ * `reflect-metadata` map allocation and key lookup on every single request.
+ *
+ * A `WeakMap<Request, HttpContext>` is functionally identical (lookup keyed
+ * by request reference, GC'd when the request goes out of scope) and is
+ * substantially cheaper on the hot path because it bypasses
+ * `reflect-metadata`'s string-keyed metadata store.
+ *
+ * Both `InversifyExpressServer` and `GuardContextFactory` use this module
+ * so they observe the same per-request value.
+ */
+import type { Request } from "express";
+import type { HttpContext } from "./interfaces.js";
+export declare function setHttpContext(req: Request, ctx: HttpContext): void;
+export declare function getHttpContext(req: Request): HttpContext | undefined;
+export declare function hasHttpContext(req: Request): boolean;

package/lib/esm/types/adapter-express/express-utils/http-status-middleware.d.ts

@@ -0,0 +1,26 @@
+import "reflect-metadata";
+import { Request, Response, NextFunction } from "express";
+import { ExpressoMiddleware } from "@expressots/core";
+/**
+ * Middleware that applies the status code to the response.
+ * @returns express.RequestHandler
+ */
+export declare class HttpStatusCodeMiddleware extends ExpressoMiddleware {
+    private globalPrefix;
+    constructor(globalPrefix?: string);
+    use(req: Request, res: Response, next: NextFunction): void | Promise<void>;
+    /**
+     * Find the matching parameter path.
+     * @param path - The path to match.
+     * @param mapping - The mapping to check.
+     * @param method - The method to check.
+     * @returns The status code if found, otherwise null.
+     **/
+    private findMatchingParameterPath;
+    /**
+     * Set the default status code based on the request method.
+     * @param req - The request object.
+     * @param res - The response object.
+     **/
+    private setDefaultStatusCode;
+}

package/lib/esm/types/adapter-express/express-utils/httpResponseMessage.d.ts

@@ -0,0 +1,14 @@
+import type { OutgoingHttpHeaders } from "node:http";
+import { HttpContent } from "./content/httpContent.js";
+export declare class HttpResponseMessage {
+    private _content;
+    private _headers;
+    get headers(): OutgoingHttpHeaders;
+    set headers(headers: OutgoingHttpHeaders);
+    get content(): HttpContent;
+    set content(value: HttpContent);
+    private _statusCode;
+    get statusCode(): number;
+    set statusCode(code: number);
+    constructor(statusCode?: number);
+}

package/lib/esm/types/adapter-express/express-utils/index.d.ts

@@ -0,0 +1,30 @@
+export * from "./decorators.js";
+export { Accept, Consumes, Produces, CsvOptions, XmlOptions, YamlOptions, StreamResponse, } from "./content-negotiation-decorators.js";
+export { Controller } from "./interfaces.js";
+export { Patterns, pattern } from "./route-constraints.js";
+export { when, unless, isConditionalMiddleware } from "./conditional-middleware.js";
+export type { ConditionalMiddlewareConfig, MiddlewareCondition } from "./conditional-middleware.js";
+export { combine, sequence, isComposedMiddleware } from "./middleware-composition.js";
+export type { ComposedMiddlewareConfig } from "./middleware-composition.js";
+export { Catch, UseFilters } from "./exception-filter-decorators.js";
+export { getControllerGuards, getMethodGuards } from "./guard-utils.js";
+export { GuardContextFactory } from "./guard-context-factory.js";
+export { GuardMiddleware } from "./guard-middleware.js";
+export { InterceptorMiddleware, createInterceptorMiddleware } from "./interceptor-middleware.js";
+export { ScopeExtractor } from "./scope-extractor.js";
+export type { IScopeExtractor } from "./scope-extractor.interface.js";
+export { PermissionPreloaderMiddleware } from "./permission-preloader.middleware.js";
+export { TYPE } from "./constants.js";
+export type { AuthProvider, Principal } from "./interfaces.js";
+export { setupAuthorizationForExpress } from "./setup-authorization.js";
+export { setupEventSystemForExpress } from "./setup-event-system.js";
+export type { EventSystemOptions, EventSystemSetupResult } from "./setup-event-system.js";
+export { setupInterceptorsForExpress } from "./setup-interceptors.js";
+export type { InterceptorSystemOptions, InterceptorSystemSetupResult, BuiltInInterceptor, InterceptorClass, } from "./setup-interceptors.js";
+export { setupLazyLoadingForExpress } from "./setup-lazy-loading.js";
+export type { LazyLoadingOptions, LazyLoadingSetupResult, LazyLoadingExpressOptions, LazyLoadingExpressResult, LazyRouteMapping, } from "./setup-lazy-loading.js";
+export { createLazyModuleMiddleware, createRouteMappings } from "./lazy-module-middleware.js";
+export { validatedBody, validatedQuery, validatedParam, validatedHeaders, Validate, getValidationMetadata, hasValidationMetadata, } from "./validation-decorators.js";
+export type { ValidationSchemaMetadata, SchemaType, ValidatedDecoratorOptions, } from "./validation-decorators.js";
+export { ValidationService } from "./validation-service.js";
+export { getHttpContext, hasHttpContext } from "./http-context-store.js";

package/lib/esm/types/adapter-express/express-utils/interceptor-middleware.d.ts

@@ -0,0 +1,40 @@
+import { Request, Response, NextFunction } from "express";
+import { Container, interfaces, InterceptorExecutor } from "@expressots/core";
+import "reflect-metadata";
+/**
+ * Express middleware that executes interceptors around route handler
+ *
+ * @layer internal
+ * @audience framework-developers
+ *
+ * @summary Quick Start
+ * InterceptorMiddleware integrates the interceptor system with Express.
+ * It wraps the route handler with interceptors defined via @UseInterceptors().
+ *
+ * @internal
+ */
+export declare class InterceptorMiddleware {
+    private executor;
+    private container;
+    constructor(executor: InterceptorExecutor, container: Container);
+    /**
+     * Create middleware for a specific controller and method
+     * @param controllerClass - Controller class
+     * @param methodName - Method name
+     * @param handler - Original route handler
+     */
+    createMiddleware(controllerClass: NewableFunction, methodName: string | symbol, handler: (req: Request, res: Response, next: NextFunction) => Promise<unknown>): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    /**
+     * Extract interceptors from controller and method metadata
+     * @private
+     */
+    private extractInterceptors;
+}
+/**
+ * Factory function to create interceptor middleware
+ * @param container - DI container
+ * @param controllerClass - Controller class
+ * @param methodName - Method name
+ * @param handler - Original handler
+ */
+export declare function createInterceptorMiddleware(container: interfaces.Container | Container, controllerClass: NewableFunction, methodName: string | symbol, handler: (req: Request, res: Response, next: NextFunction) => Promise<unknown>): (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/lib/esm/types/adapter-express/express-utils/interfaces.d.ts

@@ -0,0 +1,115 @@
+import type { Application, NextFunction, Request, RequestHandler, Response } from "express";
+import { interfaces as inversifyInterfaces } from "@expressots/core";
+import { HTTP_VERBS_ENUM, PARAMETER_TYPE } from "./constants.js";
+import { HttpResponseMessage } from "./httpResponseMessage.js";
+/**
+ * Type for a constructor function (class)
+ */
+export type NewableFunction = abstract new (...args: Array<any>) => any;
+type Prototype<T> = {
+    [P in keyof T]: T[P] extends NewableFunction ? T[P] : T[P] | undefined;
+} & {
+    constructor: NewableFunction;
+};
+interface ConstructorFunction<T = Record<string, unknown>> {
+    new (...args: Array<unknown>): T;
+    prototype: Prototype<T>;
+}
+export type DecoratorTarget<T = unknown> = ConstructorFunction<T> | Prototype<T>;
+export interface IExpressoMiddleware {
+    use(req: Request, res: Response, next: NextFunction): Promise<void> | void;
+}
+/**
+ * Conditional middleware configuration type.
+ * Import from conditional-middleware.ts for the full ConditionalMiddlewareConfig interface.
+ */
+export interface ConditionalMiddlewareConfig {
+    condition: (req: Request) => boolean | Promise<boolean>;
+    middleware: Middleware;
+    skipOnFalse?: boolean;
+}
+/**
+ * Composed middleware configuration type.
+ * Import from middleware-composition.ts for the full ComposedMiddlewareConfig interface.
+ */
+export interface ComposedMiddlewareConfig {
+    middleware: Array<Middleware>;
+    type: "combine" | "sequence";
+}
+/**
+ * Middleware class constructor type.
+ * Supports classes that extend ExpressoMiddleware or implement IExpressoMiddleware.
+ * Accepts both concrete and abstract class constructors.
+ * Phase 2: Supports class references without 'new' keyword.
+ */
+export type MiddlewareClass = (new (...args: Array<unknown>) => IExpressoMiddleware) | (abstract new (...args: Array<unknown>) => IExpressoMiddleware);
+/**
+ * Union type for all supported middleware types.
+ * Phase 2: Includes class constructors (class references) for cleaner API.
+ * Note: Uses 'any' for class constructors to support typeof class types (e.g., typeof AdminMiddleware).
+ */
+export type Middleware = string | symbol | RequestHandler | IExpressoMiddleware | ConditionalMiddlewareConfig | MiddlewareClass | {
+    prototype: IExpressoMiddleware;
+} | any;
+export type ControllerHandler = (...params: Array<unknown>) => unknown;
+export type BaseController = Record<string, ControllerHandler>;
+export interface Controller {
+}
+export interface ControllerMetadata {
+    middleware: Array<Middleware>;
+    path: string;
+    target: DecoratorTarget;
+    version?: string | number;
+}
+export interface ControllerMethodMetadata extends ControllerMetadata {
+    key: string;
+    method: keyof typeof HTTP_VERBS_ENUM;
+    version?: string | number;
+}
+export interface ControllerParameterMetadata {
+    [methodName: string]: Array<ParameterMetadata>;
+}
+export interface ParameterMetadata {
+    index: number;
+    injectRoot: boolean;
+    parameterName?: string | undefined;
+    type: PARAMETER_TYPE;
+}
+export type ExtractedParameters = Array<ParameterMetadata> | [Request, Response, NextFunction] | Array<unknown>;
+export type HandlerDecorator = (target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => void;
+export type ConfigFunction = (app: Application) => void;
+export interface RoutingConfig {
+    rootPath: string;
+}
+export interface Principal<T = unknown> {
+    details: T;
+    isAuthenticated(): Promise<boolean>;
+    isInRole(role: string): Promise<boolean>;
+    isResourceOwner(resourceId: unknown): Promise<boolean>;
+}
+export interface AuthProvider {
+    getUser(req: Request, res: Response, next: NextFunction): Promise<Principal>;
+}
+export interface HttpContext<T = unknown> {
+    container: inversifyInterfaces.Container;
+    request: Request;
+    response: Response;
+    user: Principal<T>;
+}
+export interface IHttpActionResult {
+    executeAsync(): Promise<HttpResponseMessage>;
+}
+export interface RouteDetails {
+    args?: Array<string>;
+    route: string;
+}
+export interface RouteInfo {
+    controller: string;
+    endpoints: Array<RouteDetails>;
+}
+export interface RawMetadata {
+    controllerMetadata: ControllerMetadata;
+    methodMetadata: Array<ControllerMethodMetadata>;
+    parameterMetadata: ControllerParameterMetadata;
+}
+export {};