@expressots/adapter-express 3.0.0-beta.4.2 → 4.0.0-preview.1

package/lib/esm/types/adapter-express/application-express.types.d.ts

@@ -0,0 +1,23 @@
+import express from "express";
+/**
+ * ExpressHandler Type
+ *
+ * The ExpressHandler type is a union type that represents various types of Express middleware functions.
+ * It can be one of the following types:
+ * - express.ErrorRequestHandler: Handles errors in the middleware pipeline.
+ * - express.RequestParamHandler: Handles parameters in the middleware pipeline.
+ * - express.RequestHandler: General request handler.
+ * - undefined: Represents the absence of a handler.
+ */
+export type ExpressHandler = express.ErrorRequestHandler | express.RequestParamHandler | express.RequestHandler | undefined;
+/**
+ * MiddlewareConfig Interface
+ *
+ * The MiddlewareConfig interface specifies the structure for middleware configuration objects.
+ * - path: Optional. The route path for which the middleware is configured.
+ * - middlewares: An array of ExpressHandler types that make up the middleware pipeline for the route specified by 'path'.
+ */
+export type MiddlewareConfig = {
+    path?: string;
+    middlewares: Array<ExpressHandler>;
+};

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

@@ -0,0 +1,8 @@
+import type { NextFunction, Request, Response } from "express";
+import { interfaces as inversifyInterfaces } from "@expressots/core";
+import type { HttpContext } from "./interfaces.js";
+export declare abstract class BaseMiddleware implements BaseMiddleware {
+    httpContext: HttpContext;
+    protected bind<T>(serviceIdentifier: inversifyInterfaces.ServiceIdentifier<T>): inversifyInterfaces.BindingToSyntax<T>;
+    abstract handler(req: Request, res: Response, next: NextFunction): void;
+}

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

@@ -0,0 +1,97 @@
+import type { Request } from "express";
+import type { Middleware, MiddlewareClass } from "./interfaces.js";
+/**
+ * Type definition for middleware condition functions.
+ * Can be synchronous (returns boolean) or asynchronous (returns Promise<boolean>).
+ */
+export type MiddlewareCondition = (req: Request) => boolean | Promise<boolean>;
+/**
+ * Configuration object for conditional middleware execution.
+ * When the condition evaluates to true, the middleware is executed.
+ * When false, the middleware is skipped and next() is called.
+ */
+export interface ConditionalMiddlewareConfig {
+    /**
+     * The condition function that determines whether the middleware should execute.
+     * Receives the Express Request object and returns a boolean or Promise<boolean>.
+     */
+    condition: MiddlewareCondition;
+    /**
+     * The middleware to execute when the condition is true.
+     * Can be any valid ExpressoTS middleware type (function, class instance, or container-bound).
+     */
+    middleware: Middleware;
+    /**
+     * Whether to skip middleware execution when condition is false.
+     * Default: true (skip if condition is false, execute if true)
+     * If false, the behavior is inverted (execute if condition is false).
+     */
+    skipOnFalse?: boolean;
+}
+/**
+ * Symbol to identify conditional middleware configuration objects.
+ * Used internally for type checking.
+ */
+export declare const CONDITIONAL_MIDDLEWARE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is a ConditionalMiddlewareConfig.
+ */
+export declare function isConditionalMiddleware(item: unknown): item is ConditionalMiddlewareConfig;
+/**
+ * Creates a conditional middleware configuration that executes the middleware
+ * when the condition evaluates to true.
+ *
+ * @param condition - Function that receives the Request and returns boolean or Promise<boolean>
+ * @param middleware - The middleware to execute when condition is true
+ * @returns ConditionalMiddlewareConfig object
+ *
+ * @example
+ * ```typescript
+ * // Phase 2: Class reference support - no 'new' keyword needed
+ * @Get("/admin",
+ *   when(req => req.hostname.startsWith("admin."), AdminMiddleware),
+ *   AuthMiddleware
+ * )
+ * async adminHandler() {}
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Async condition with class reference (Phase 2)
+ * @Get("/api",
+ *   when(async req => {
+ *     const user = await getUser(req);
+ *     return user.isAdmin;
+ *   }, AdminMiddleware)
+ * )
+ * async apiHandler() {}
+ * ```
+ */
+export declare function when(condition: MiddlewareCondition, middleware: Middleware | MiddlewareClass | any): ConditionalMiddlewareConfig;
+/**
+ * Creates a conditional middleware configuration that executes the middleware
+ * when the condition evaluates to false (inverse of `when`).
+ *
+ * @param condition - Function that receives the Request and returns boolean or Promise<boolean>
+ * @param middleware - The middleware to execute when condition is false
+ * @returns ConditionalMiddlewareConfig object
+ *
+ * @example
+ * ```typescript
+ * // Phase 2: Class reference support - no 'new' keyword needed
+ * @Get("/public",
+ *   unless(req => req.headers.authorization, AuthMiddleware)
+ * )
+ * async publicHandler() {}
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Skip authentication for public routes (Phase 2: class reference)
+ * @Get("/health",
+ *   unless(req => req.path.startsWith("/api"), AuthMiddleware)
+ * )
+ * async healthCheck() {}
+ * ```
+ */
+export declare function unless(condition: MiddlewareCondition, middleware: Middleware | MiddlewareClass | any): ConditionalMiddlewareConfig;

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

@@ -0,0 +1,57 @@
+export declare const TYPE: {
+    AuthProvider: symbol;
+    Controller: symbol;
+    HttpContext: symbol;
+};
+export declare const METADATA_KEY: {
+    controller: string;
+    controllerMethod: string;
+    controllerParameter: string;
+    httpContext: string;
+    version: string;
+    accept: string;
+    consumes: string;
+    produces: string;
+    csvOptions: string;
+    xmlOptions: string;
+    yamlOptions: string;
+    streamResponse: string;
+    validationSchema: string;
+    validationOptions: string;
+    exceptionFilter: string;
+    controllerExceptionFilters: string;
+    methodExceptionFilters: string;
+};
+export declare const HTTP_CODE_METADATA: {
+    httpCode: string;
+    statusCode: string;
+    path: string;
+};
+export declare const RENDER_METADATA_KEY: unique symbol;
+export declare enum PARAMETER_TYPE {
+    REQUEST = 0,
+    RESPONSE = 1,
+    PARAMS = 2,
+    QUERY = 3,
+    BODY = 4,
+    HEADERS = 5,
+    COOKIES = 6,
+    NEXT = 7,
+    PRINCIPAL = 8
+}
+export declare enum HTTP_VERBS_ENUM {
+    all = "ALL",
+    connect = "CONNECT",
+    delete = "DELETE",
+    get = "GET",
+    head = "HEAD",
+    options = "OPTIONS",
+    patch = "PATCH",
+    post = "POST",
+    propfind = "PROPFIND",
+    put = "PUT",
+    trace = "TRACE"
+}
+export declare const DUPLICATED_CONTROLLER_NAME: (name: string) => string;
+export declare const NO_CONTROLLERS_FOUND = "No controller found! Please ensure that you have register at least one Controller.";
+export declare const DEFAULT_ROUTING_ROOT_PATH = "/";

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

@@ -0,0 +1,6 @@
+import type { OutgoingHttpHeaders } from "node:http";
+export declare abstract class HttpContent {
+    private _headers;
+    get headers(): OutgoingHttpHeaders;
+    abstract readAsync(): Promise<string | Record<string, unknown> | Record<string, unknown>[]>;
+}

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);
+}