@vercube/core 0.0.1 → 0.0.2-beta.1

package/dist/index.cjs

@@ -34,8 +34,8 @@ const __vercube_logger = __toESM(require("@vercube/logger"));
 const c12 = __toESM(require("c12"));
 const defu = __toESM(require("defu"));
 
-//#region node_modules/.pnpm/@oxc-project+runtime@0.63.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js
-var require_decorate = __commonJS({ "node_modules/.pnpm/@oxc-project+runtime@0.63.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js"(exports, module) {
+//#region node_modules/.pnpm/@oxc-project+runtime@0.65.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js
+var require_decorate = __commonJS({ "node_modules/.pnpm/@oxc-project+runtime@0.65.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js"(exports, module) {
 	function __decorate(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);
@@ -86,6 +86,9 @@ var PluginsRegistry = class {
 
 //#endregion
 //#region packages/core/src/Services/Hooks/HooksService.ts
+/**
+* This class is responsible for managing events.
+*/
 var HooksService = class {
 	fLastId = 0;
 	fHandlers = new Map();
@@ -201,6 +204,13 @@ var RouterAfterInitHook = class {};
 
 //#endregion
 //#region packages/core/src/Services/Router/Router.ts
+/**
+* Router service responsible for managing application routes
+* 
+* This class provides functionality to initialize the router,
+* register routes, and resolve incoming requests to their
+* appropriate handlers.
+*/
 var Router = class {
 	/**
 	* Service for triggering application hooks
@@ -250,12 +260,27 @@ var Router = class {
 
 //#endregion
 //#region packages/core/src/Resolvers/RouterParam.ts
+/**
+* Resolves a router parameter from the event object
+* @param param - The parameter name to resolve from the router event
+* @param event - The router event object containing parameters
+* @returns The resolved parameter value if it exists, null otherwise
+* @example
+* ```typescript
+* const value = resolveRouterParam('id', routerEvent);
+* // Returns the 'id' parameter value from routerEvent.params or null
+* ```
+*/
 function resolveRouterParam(param, event) {
 	return event.params?.[param] ?? null;
 }
 
 //#endregion
 //#region packages/core/src/Errors/HttpError.ts
+/**
+* Represents an HTTP error.
+* @extends {Error}
+*/
 var HttpError = class HttpError extends Error {
 	/**
 	* The HTTP status code associated with the error.
@@ -278,6 +303,10 @@ var HttpError = class HttpError extends Error {
 
 //#endregion
 //#region packages/core/src/Errors/Http/BadRequestError.ts
+/**
+* Represents a Bad Request error (HTTP 400).
+* @extends {HttpError}
+*/
 var BadRequestError = class BadRequestError extends HttpError {
 	/**
 	* The name of the error.
@@ -298,6 +327,26 @@ var BadRequestError = class BadRequestError extends HttpError {
 
 //#endregion
 //#region packages/core/src/Resolvers/Body.ts
+/**
+* Resolves and parses the request body from a RouterEvent.
+* 
+* @param {RouterTypes.RouterEvent} event - The router event containing the request to process
+* @returns {Promise<unknown>} A promise that resolves to:
+*   - The parsed JSON body if the request contains valid JSON
+*   - undefined if the request body is empty
+* @throws {BadRequestError} If the request body contains invalid JSON
+* 
+* @example
+* const body = await resolveRequestBody(event);
+* if (body) {
+*   // Process the parsed body
+* }
+* 
+* @remarks
+* - Currently only supports JSON content type
+* - Returns undefined for empty request bodies
+* - Throws BadRequestError for malformed JSON
+*/
 async function resolveRequestBody(event) {
 	const text = await event.request.text();
 	if (!text) return void 0;
@@ -310,10 +359,21 @@ async function resolveRequestBody(event) {
 
 //#endregion
 //#region packages/core/src/Resolvers/Query.ts
+/**
+* Resolves a single query parameter from the URL of a router event
+* @param name - The name of the query parameter to resolve
+* @param event - The router event containing the request URL
+* @returns The value of the query parameter if found, null otherwise
+*/
 function resolveQueryParam(name, event) {
 	const url = new URL(event.request.url);
 	return url.searchParams.get(name);
 }
+/**
+* Resolves all query parameters from the URL of a router event
+* @param event - The router event containing the request URL
+* @returns An object containing all query parameters as key-value pairs
+*/
 function resolveQueryParams(event) {
 	const url = new URL(event.request.url);
 	const params = {};
@@ -323,15 +383,29 @@ function resolveQueryParams(event) {
 
 //#endregion
 //#region packages/core/src/Resolvers/Headers.ts
+/**
+* Retrieves a specific header value from the request
+* @param {string} header - The name of the header to retrieve
+* @param {RouterTypes.RouterEvent} event - The router event containing the request
+* @returns {string | null} The header value if found, null otherwise
+*/
 function getRequestHeader(header, event) {
 	return event.request.headers.get(header);
 }
+/**
+* Retrieves all headers from the request
+* @param {RouterTypes.RouterEvent} event - The router event containing the request
+* @returns {Headers} The complete Headers object from the request
+*/
 function getRequestHeaders(event) {
 	return event.request.headers;
 }
 
 //#endregion
 //#region packages/core/src/Services/Metadata/MetadataResolver.ts
+/**
+* Class responsible for resolving metadata for route handlers.
+*/
 var MetadataResolver = class {
 	/**
 	* Resolves the URL for a given instance and path.
@@ -407,10 +481,24 @@ var MetadataResolver = class {
 
 //#endregion
 //#region packages/core/src/Services/ErrorHandler/ErrorHandlerProvider.ts
+/**
+* Abstract class representing an error handler provider
+* Provides a common interface for different error handler implementations
+*
+* @abstract
+* @class ErrorHandlerProvider
+*/
 var ErrorHandlerProvider = class {};
 
 //#endregion
 //#region packages/core/src/Services/Middleware/GlobalMiddlewareRegistry.ts
+/**
+* Manages global middleware registration and retrieval
+* 
+* This class provides functionality to register and retrieve global middleware
+* configurations. It allows for adding middleware with specific options and
+* retrieving them in a standardized format.
+*/
 var GlobalMiddlewareRegistry = class {
 	fMiddlewares = new Set();
 	/**
@@ -442,13 +530,20 @@ var GlobalMiddlewareRegistry = class {
 
 //#endregion
 //#region packages/core/src/Services/Router/RequestHandler.ts
+/**
+* Handles HTTP requests by preparing and executing route handlers with their associated middlewares
+* 
+* The RequestHandler is responsible for:
+* - Preparing route handlers with their metadata
+* - Executing middleware chains (before and after)
+* - Processing request/response lifecycle
+* - Error handling during request processing
+*/
 var RequestHandler = class {
 	/** Resolver for extracting metadata from controller classes and methods */
 	gMetadataResolver;
 	/** DI container for resolving dependencies */
 	gContainer;
-	/** Provider for handling errors during request processing */
-	gErrorHandlerProvider;
 	gGlobalMiddlewareRegistry;
 	/**
 	* Prepares a route handler by resolving its metadata and middlewares
@@ -507,8 +602,8 @@ var RequestHandler = class {
 					methodArgs: args
 				});
 				if (hookResponse instanceof Response) return hookResponse;
-			} catch (error) {
-				return this.gErrorHandlerProvider.handleError(error);
+			} catch (error_) {
+				this.gContainer.get(ErrorHandlerProvider).handleError(error_);
 			}
 			for (const action of actions) {
 				const actionResponse = action.handler(request, fakeResponse);
@@ -524,8 +619,8 @@ var RequestHandler = class {
 			for await (const hook of middlewares?.afterMiddlewares ?? []) try {
 				const hookResponse = await hook.middleware.onResponse?.(request, fakeResponse, handlerResponse);
 				if (hookResponse !== null) fakeResponse = this.processOverrideResponse(hookResponse, fakeResponse);
-			} catch (error) {
-				return this.gErrorHandlerProvider.handleError(error);
+			} catch (error_) {
+				this.gContainer.get(ErrorHandlerProvider).handleError(error_);
 			}
 			const body = fakeResponse?.body ?? JSON.stringify(handlerResponse);
 			return new Response(body, {
@@ -534,7 +629,7 @@ var RequestHandler = class {
 				headers: fakeResponse.headers
 			});
 		} catch (error_) {
-			return this.gErrorHandlerProvider.handleError(error_);
+			return this.gContainer.get(ErrorHandlerProvider).handleError(error_);
 		}
 	}
 	/**
@@ -565,7 +660,6 @@ var RequestHandler = class {
 };
 (0, import_decorate.default)([(0, __vercube_di.Inject)(MetadataResolver)], RequestHandler.prototype, "gMetadataResolver", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(__vercube_di.Container)], RequestHandler.prototype, "gContainer", void 0);
-(0, import_decorate.default)([(0, __vercube_di.Inject)(ErrorHandlerProvider)], RequestHandler.prototype, "gErrorHandlerProvider", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(GlobalMiddlewareRegistry)], RequestHandler.prototype, "gGlobalMiddlewareRegistry", void 0);
 
 //#endregion
@@ -588,6 +682,15 @@ const mime = { getType(ext) {
 
 //#endregion
 //#region packages/core/src/Services/Router/StaticRequestHandler.ts
+/**
+* Handles serving static files over HTTP
+* 
+* The StaticRequestHandler is responsible for:
+* - Serving static files from configured directories
+* - Setting appropriate content types and headers
+* - Handling caching and ETags
+* - Processing GET requests for static assets
+*/
 var StaticRequestHandler = class {
 	/**
 	* The options for the static server
@@ -653,7 +756,19 @@ var StaticRequestHandler = class {
 
 //#endregion
 //#region packages/core/src/Services/HttpServer/HttpServer.ts
+/**
+* HTTP server implementation for handling incoming web requests
+* 
+* This class is responsible for:
+* - Initializing and managing the HTTP server
+* - Routing incoming requests to appropriate handlers
+* - Processing HTTP responses
+*/
 var HttpServer = class {
+	/**
+	* DI container for resolving dependencies
+	*/
+	gContainer;
 	/**
 	* Router service for resolving routes
 	*/
@@ -663,10 +778,6 @@ var HttpServer = class {
 	*/
 	gRequestHandler;
 	/**
-	* Error handler provider for managing error responses
-	*/
-	gErrorHandlerProvider;
-	/**
 	* Static server for serving static files
 	*/
 	gStaticRequestHandler;
@@ -684,10 +795,10 @@ var HttpServer = class {
 		const { port, host } = config.server ?? {};
 		this.fServer = (0, srvx.serve)({
 			bun: { error: (error) => {
-				return this.gErrorHandlerProvider.handleError(error);
+				return this.gContainer.get(ErrorHandlerProvider).handleError(error);
 			} },
 			deno: { onError: (error) => {
-				return this.gErrorHandlerProvider.handleError(error);
+				return this.gContainer.get(ErrorHandlerProvider).handleError(error);
 			} },
 			hostname: host,
 			port,
@@ -727,17 +838,20 @@ var HttpServer = class {
 			}
 			return this.gRequestHandler.handleRequest(request, route);
 		} catch (error) {
-			return this.gErrorHandlerProvider.handleError(error);
+			return this.gContainer.get(ErrorHandlerProvider).handleError(error);
 		}
 	}
 };
+(0, import_decorate.default)([(0, __vercube_di.Inject)(__vercube_di.Container)], HttpServer.prototype, "gContainer", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], HttpServer.prototype, "gRouter", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(RequestHandler)], HttpServer.prototype, "gRequestHandler", void 0);
-(0, import_decorate.default)([(0, __vercube_di.Inject)(ErrorHandlerProvider)], HttpServer.prototype, "gErrorHandlerProvider", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(StaticRequestHandler)], HttpServer.prototype, "gStaticRequestHandler", void 0);
 
 //#endregion
 //#region packages/core/src/Common/App.ts
+/**
+* Represents the main application class.
+*/
 var App = class {
 	gRouter;
 	gPluginsRegistry;
@@ -814,6 +928,13 @@ var App = class {
 
 //#endregion
 //#region packages/logger/dist/Providers/index.mjs
+/**
+* Abstract base class for implementing log provider.
+* Providers are responsible for processing and outputting log messages to various destinations.
+* Each appender can be initialized with custom options and handles message processing according to its implementation.
+*
+* @template T - The type of options used to initialize the appender
+*/
 var LoggerProvider = class {};
 const isColorAllowed = () => !process.env.NO_COLOR;
 const colorIfAllowed = (colorFn) => {
@@ -836,6 +957,9 @@ const LOG_LEVEL_COLORS = {
 	warn: colors.yellow,
 	error: colors.red
 };
+/**
+* ConsoleProvider class for logging messages to the console.
+*/
 var ConsoleProvider = class extends LoggerProvider {
 	/**
 	* Initializes the appender with the provided options.
@@ -855,10 +979,23 @@ var ConsoleProvider = class extends LoggerProvider {
 
 //#endregion
 //#region packages/core/src/Services/Validation/ValidationProvider.ts
+/**
+* Abstract class representing a validation provider
+* Provides a common interface for different validation implementations
+* 
+* @abstract
+* @class ValidationProvider
+*/
 var ValidationProvider = class {};
 
 //#endregion
 //#region packages/core/src/Services/Validation/StandardSchemaValidationProvider.ts
+/**
+* StandardSchemaValidationProvider implements validation using StandardSchema schema validation
+* @see https://github.com/standard-schema/standard-schema
+* @class
+* @implements {ValidationProvider}
+*/
 var StandardSchemaValidationProvider = class {
 	/**
 	* Validates data against a schema
@@ -873,6 +1010,10 @@ var StandardSchemaValidationProvider = class {
 
 //#endregion
 //#region packages/core/src/Services/Config/RuntimeConfig.ts
+/**
+* RuntimeConfig class manages the runtime configuration for the Vercube application.
+* This class provides a centralized way to access and modify runtime configuration settings.
+*/
 var RuntimeConfig = class {
 	/**
 	* Private field to store the runtime configuration object.
@@ -897,6 +1038,10 @@ var RuntimeConfig = class {
 
 //#endregion
 //#region packages/core/src/Errors/Http/InternalServerError.ts
+/**
+* Represents an Internal Server error (HTTP 500).
+* @extends {HttpError}
+*/
 var InternalServerError = class InternalServerError extends HttpError {
 	/**
 	* The name of the error.
@@ -916,26 +1061,36 @@ var InternalServerError = class InternalServerError extends HttpError {
 
 //#endregion
 //#region packages/core/src/Services/ErrorHandler/DefaultErrorHandlerProvider.ts
+/**
+* Default error handler provider
+*
+* @class DefaultErrorHandlerProvider
+*/
 var DefaultErrorHandlerProvider = class extends ErrorHandlerProvider {
 	gLogger;
 	/**
 	* Handles an error that occurred during request processing
-	* 
+	*
 	* @param error - The Error object containing error details
 	* @returns Promise<Response> | Response - The response to be sent to the client
 	*/
 	handleError(error) {
-		const _internalError = new InternalServerError();
+		const _internalError = new InternalServerError(error?.message ?? "Internal server error");
 		const status = error?.status ?? 500;
 		if (error instanceof HttpError) return new Response(JSON.stringify({ ...error }, void 0, 2), { status });
 		this.gLogger.error(error);
-		return new Response(JSON.stringify({ ...error?.cause ?? _internalError.cause }, void 0, 2), { status });
+		return new Response(JSON.stringify({ ...error?.cause ?? _internalError }, void 0, 2), { status });
 	}
 };
 (0, import_decorate.default)([(0, __vercube_di.Inject)(__vercube_logger.Logger)], DefaultErrorHandlerProvider.prototype, "gLogger", void 0);
 
 //#endregion
 //#region packages/core/src/Common/Container.ts
+/**
+* Creates and configures a new dependency injection container for the application.
+*
+* @returns {Container} A configured dependency injection container.
+*/
 function createContainer(config) {
 	const container = new __vercube_di.Container();
 	container.bindInstance(__vercube_di.Container, container);
@@ -963,6 +1118,10 @@ function createContainer(config) {
 
 //#endregion
 //#region packages/core/src/Utils/InternalUtils.ts
+/**
+* Generate random hash
+* @returns string
+*/
 function generateRandomHash() {
 	const hashByPerformance = Math.floor(Date.now() * 1e3).toString(16);
 	const hashByMath = () => (Math.floor(Math.random() * 16777215) | 1048576).toString(16);
@@ -971,6 +1130,10 @@ function generateRandomHash() {
 
 //#endregion
 //#region packages/core/src/Config/DefaultConfig.ts
+/**
+* Default configuration for the Vercube application.
+* This configuration serves as the base settings and can be overridden by user configuration.
+*/
 const defaultConfig = {
 	logLevel: "debug",
 	production: false,
@@ -1001,6 +1164,11 @@ const defaultConfig = {
 
 //#endregion
 //#region packages/core/src/Config/Loader.ts
+/**
+* Loads the configuration object for the application
+* @param {ConfigTypes.Config} overrides - The configuration object to load
+* @returns {ConfigTypes.Config} The loaded configuration object
+*/
 async function loadVercubeConfig(overrides) {
 	const config = await (0, c12.loadConfig)({
 		name: "vercube",
@@ -1014,6 +1182,11 @@ async function loadVercubeConfig(overrides) {
 
 //#endregion
 //#region packages/core/src/Common/CreateApp.ts
+/**
+* Creates and initializes an instance of the App.
+*
+* @returns {Promise<App>} A promise that resolves to an instance of the App.
+*/
 async function createApp(cfg) {
 	const config = await loadVercubeConfig(cfg);
 	const container = createContainer(config);
@@ -1027,12 +1200,26 @@ async function createApp(cfg) {
 
 //#endregion
 //#region packages/core/src/Config/Config.ts
+/**
+* Defines a configuration object for the application
+* @param {ConfigTypes.Config} config - The configuration object to validate
+* @returns {ConfigTypes.Config} The validated configuration object
+*/
 function defineConfig(config) {
 	return config;
 }
 
 //#endregion
 //#region packages/core/src/Middleware/ValidationMiddleware.ts
+/**
+* Middleware for validating request data against a schema
+* @class ValidationMiddleware
+* @implements {BaseMiddleware}
+* @description Validates incoming request data against a provided schema
+* @example
+* const middleware = new ValidationMiddleware();
+* await middleware.use(event, { schema: myValidationSchema });
+*/
 var ValidationMiddleware = class {
 	gValidationProvider;
 	/**
@@ -1059,6 +1246,10 @@ var ValidationMiddleware = class {
 
 //#endregion
 //#region packages/core/src/Utils/Utils.ts
+/**
+* Creates a new metadata context.
+* @returns {MetadataTypes.Ctx} The new metadata context.
+*/
 function createMetadataCtx() {
 	return {
 		__controller: { path: "" },
@@ -1066,6 +1257,10 @@ function createMetadataCtx() {
 		__methods: {}
 	};
 }
+/**
+* Creates a new metadata method.
+* @returns {MetadataTypes.Method} The new metadata method.
+*/
 function createMetadataMethod() {
 	return {
 		req: null,
@@ -1075,10 +1270,19 @@ function createMetadataMethod() {
 		actions: []
 	};
 }
+/**
+* Initializes the metadata for a given target and property name.
+* @param {any} target - The target to initialize metadata for.
+* @param {string} propertyName - The name of the property to initialize metadata for.
+*/
 function initializeMetadataMethod(target, propertyName) {
 	if (!target.__metadata.__methods[propertyName]) target.__metadata.__methods[propertyName] = createMetadataMethod();
 	return target.__metadata.__methods[propertyName];
 }
+/**
+* Initializes the metadata for a given target.
+* @param {any} target - The target to initialize metadata for.
+*/
 function initializeMetadata(target) {
 	if (!target.__metadata) target.__metadata = createMetadataCtx();
 	if (!target.__metadata.__methods) target.__metadata.__methods = {};
@@ -1088,6 +1292,12 @@ function initializeMetadata(target) {
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Body.ts
+/**
+* @class BodyDecorator
+* @extends BaseDecorator<BodyDecoratorOptions>
+*
+* A decorator class that handles the metadata for HTTP request bodies.
+*/
 var BodyDecorator = class extends __vercube_di.BaseDecorator {
 	/**
 	* @method created
@@ -1111,12 +1321,30 @@ var BodyDecorator = class extends __vercube_di.BaseDecorator {
 		});
 	}
 };
+/**
+* @function Body
+* @returns {Function} A decorator function that registers the BodyDecorator.
+*
+* This function creates and returns a decorator that can be used to annotate
+* a parameter in a method to indicate that it should be populated with the
+* body of an HTTP request. The decorator uses the BodyDecorator class to
+* handle the metadata associated with the parameter.
+*/
 function Body(options) {
 	return (0, __vercube_di.createDecorator)(BodyDecorator, options);
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Connect.ts
+/**
+* A decorator class for handling HTTP CONNECT requests.
+*
+* This class extends the BaseDecorator and is used to register CONNECT routes
+* with the Router. It also resolves metadata for the route handler
+* using the MetadataResolver.
+*
+* @extends {BaseDecorator<ConnectDecoratorOptions>}
+*/
 var ConnectDecorator = class extends __vercube_di.BaseDecorator {
 	gRouter;
 	gRequestHandler;
@@ -1146,12 +1374,30 @@ var ConnectDecorator = class extends __vercube_di.BaseDecorator {
 (0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], ConnectDecorator.prototype, "gRouter", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(RequestHandler)], ConnectDecorator.prototype, "gRequestHandler", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(MetadataResolver)], ConnectDecorator.prototype, "gMetadataResolver", void 0);
+/**
+* A factory function for creating a ConnectDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method with CONNECT route information.
+*
+* @param {string} path - The path for the CONNECT route.
+* @return {Function} The decorator function.
+*/
 function Connect(path) {
 	return (0, __vercube_di.createDecorator)(ConnectDecorator, { path });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Controller.ts
+/**
+* A factory function for creating a Controller decorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a class with controller metadata, including the base path for the controller.
+*
+* @param {string} path - The base path for the controller.
+* @return {Function} The decorator function.
+*/
 function Controller(path) {
 	return function internalDecorator(target) {
 		const meta = initializeMetadata(target.prototype);
@@ -1164,6 +1410,15 @@ function Controller(path) {
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Delete.ts
+/**
+* A decorator class for handling HTTP DELETE requests.
+*
+* This class extends the BaseDecorator and is used to register DELETE routes
+* with the Router. It also resolves metadata for the route handler
+* using the MetadataResolver.
+*
+* @extends {BaseDecorator<DeleteDecoratorOptions>}
+*/
 var DeleteDecorator = class extends __vercube_di.BaseDecorator {
 	gRouter;
 	gRequestHandler;
@@ -1195,12 +1450,30 @@ var DeleteDecorator = class extends __vercube_di.BaseDecorator {
 (0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], DeleteDecorator.prototype, "gRouter", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(RequestHandler)], DeleteDecorator.prototype, "gRequestHandler", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(MetadataResolver)], DeleteDecorator.prototype, "gMetadataResolver", void 0);
+/**
+* A factory function for creating a DeleteDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method with DELETE route information.
+*
+* @param {string} path - The path for the DELETE route.
+* @return {Function} The decorator function.
+*/
 function Delete(path) {
 	return (0, __vercube_di.createDecorator)(DeleteDecorator, { path });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Get.ts
+/**
+* A decorator class for handling HTTP GET requests.
+*
+* This class extends the BaseDecorator and is used to register GET routes
+* with the Router. It also resolves metadata for the route handler
+* using the MetadataResolver.
+*
+* @extends {BaseDecorator<GetDecoratorOptions>}
+*/
 var GetDecorator = class extends __vercube_di.BaseDecorator {
 	gRouter;
 	gRequestHandler;
@@ -1232,12 +1505,30 @@ var GetDecorator = class extends __vercube_di.BaseDecorator {
 (0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], GetDecorator.prototype, "gRouter", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(RequestHandler)], GetDecorator.prototype, "gRequestHandler", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(MetadataResolver)], GetDecorator.prototype, "gMetadataResolver", void 0);
+/**
+* A decorator function for handling HTTP GET requests.
+*
+* This function creates an instance of the GetDecorator class and registers
+* the GET route with the specified path.
+*
+* @param {string} path - The path for the GET route.
+* @returns {Function} - The decorator function.
+*/
 function Get(path) {
 	return (0, __vercube_di.createDecorator)(GetDecorator, { path });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Head.ts
+/**
+* A decorator class for handling HTTP HEAD requests.
+*
+* This class extends the BaseDecorator and is used to register HEAD routes
+* with the Router. It also resolves metadata for the route handler
+* using the MetadataResolver.
+*
+* @extends {BaseDecorator<HeadDecoratorOptions>}
+*/
 var HeadDecorator = class extends __vercube_di.BaseDecorator {
 	gRouter;
 	gRequestHandler;
@@ -1269,12 +1560,30 @@ var HeadDecorator = class extends __vercube_di.BaseDecorator {
 (0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], HeadDecorator.prototype, "gRouter", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(RequestHandler)], HeadDecorator.prototype, "gRequestHandler", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(MetadataResolver)], HeadDecorator.prototype, "gMetadataResolver", void 0);
+/**
+* A factory function for creating a HeadDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method with HEAD route information.
+*
+* @param {string} path - The path for the HEAD route.
+* @return {Function} The decorator function.
+*/
 function Head(path) {
 	return (0, __vercube_di.createDecorator)(HeadDecorator, { path });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Header.ts
+/**
+* A decorator class for handling HTTP header parameters.
+*
+* This class extends the BaseDecorator and is used to register header parameters
+* with the MetadataResolver. It ensures that the metadata for the property is created
+* and adds the header information to the metadata.
+*
+* @extends {BaseDecorator<HeaderDecoratorOptions>}
+*/
 var HeaderDecorator = class extends __vercube_di.BaseDecorator {
 	/**
 	* Called when the decorator is created.
@@ -1292,12 +1601,31 @@ var HeaderDecorator = class extends __vercube_di.BaseDecorator {
 		});
 	}
 };
+/**
+* A decorator function for handling HTTP header parameters.
+*
+* This function creates a HeaderDecorator with the specified name and registers it.
+* It is used to annotate a parameter in a method to indicate that it should be
+* populated with the value of a specific HTTP header.
+*
+* @param {string} name - The name of the HTTP header to bind to the parameter.
+* @returns {Function} - A decorator function that registers the HeaderDecorator.
+*/
 function Header(name) {
 	return (0, __vercube_di.createDecorator)(HeaderDecorator, { name });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Headers.ts
+/**
+* This class is responsible for managing headers decorator.
+*
+* This class extends the BaseDecorator and is used to register headers parameters
+* with the MetadataResolver. It ensures that the metadata for the property is created
+* and adds the headers information to the metadata.
+*
+* @extends {BaseDecorator<{}>}
+*/
 var HeadersDecorator = class extends __vercube_di.BaseDecorator {
 	/**
 	* Called when the decorator is created.
@@ -1314,12 +1642,29 @@ var HeadersDecorator = class extends __vercube_di.BaseDecorator {
 		});
 	}
 };
+/**
+* A factory function for creating a HeadersDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method parameter with headers information.
+*
+* @return {Function} The decorator function.
+*/
 function Headers$1() {
 	return (0, __vercube_di.createDecorator)(HeadersDecorator, {});
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Options.ts
+/**
+* A decorator class for handling HTTP OPTIONS requests.
+*
+* This class extends the BaseDecorator and is used to register OPTIONS routes
+* with the Router. It also resolves metadata for the route handler
+* using the MetadataResolver.
+*
+* @extends {BaseDecorator<OptionsDecoratorOptions>}
+*/
 var OptionsDecorator = class extends __vercube_di.BaseDecorator {
 	gRouter;
 	gRequestHandler;
@@ -1351,12 +1696,30 @@ var OptionsDecorator = class extends __vercube_di.BaseDecorator {
 (0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], OptionsDecorator.prototype, "gRouter", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(RequestHandler)], OptionsDecorator.prototype, "gRequestHandler", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(MetadataResolver)], OptionsDecorator.prototype, "gMetadataResolver", void 0);
+/**
+* A factory function for creating an OptionsDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method with OPTIONS route information.
+*
+* @param {string} path - The path for the OPTIONS route.
+* @return {Function} The decorator function.
+*/
 function Options(path) {
 	return (0, __vercube_di.createDecorator)(OptionsDecorator, { path });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Param.ts
+/**
+* This class is responsible for managing parameter decorators.
+*
+* This class extends the BaseDecorator and is used to register parameter information
+* with the MetadataResolver. It ensures that the metadata for the property is created
+* and adds the parameter information to the metadata.
+*
+* @extends {BaseDecorator<ParamDecoratorOptions>}
+*/
 var ParamDecorator = class extends __vercube_di.BaseDecorator {
 	gMetadataResolver;
 	/**
@@ -1376,12 +1739,32 @@ var ParamDecorator = class extends __vercube_di.BaseDecorator {
 	}
 };
 (0, import_decorate.default)([(0, __vercube_di.Inject)(MetadataResolver)], ParamDecorator.prototype, "gMetadataResolver", void 0);
+/**
+* A factory function for creating a ParamDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method parameter with parameter information.
+*
+* @param {string} name - The name of the parameter.
+* @param {Object} [opts] - Optional settings for the parameter.
+* @param {boolean} [opts.decode=false] - Whether to decode the parameter.
+* @return {Function} The decorator function.
+*/
 function Param(name) {
 	return (0, __vercube_di.createDecorator)(ParamDecorator, { name });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Patch.ts
+/**
+* A decorator class for handling HTTP PATCH requests.
+*
+* This class extends the BaseDecorator and is used to register PATCH routes
+* with the Router. It also resolves metadata for the route handler
+* using the MetadataResolver.
+*
+* @extends {BaseDecorator<PatchDecoratorOptions>}
+*/
 var PatchDecorator = class extends __vercube_di.BaseDecorator {
 	gRouter;
 	gRequestHandler;
@@ -1411,12 +1794,30 @@ var PatchDecorator = class extends __vercube_di.BaseDecorator {
 (0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], PatchDecorator.prototype, "gRouter", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(RequestHandler)], PatchDecorator.prototype, "gRequestHandler", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(MetadataResolver)], PatchDecorator.prototype, "gMetadataResolver", void 0);
+/**
+* A factory function for creating a PatchDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method with PATCH route information.
+*
+* @param {string} path - The path for the PATCH route.
+* @return {Function} The decorator function.
+*/
 function Patch(path) {
 	return (0, __vercube_di.createDecorator)(PatchDecorator, { path });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Post.ts
+/**
+* A decorator class for handling HTTP POST requests.
+*
+* This class extends the BaseDecorator and is used to register POST routes
+* with the Router. It also resolves metadata for the route handler
+* using the MetadataResolver.
+*
+* @extends {BaseDecorator<PostDecoratorOptions>}
+*/
 var PostDecorator = class extends __vercube_di.BaseDecorator {
 	gRouter;
 	gMetadataResolver;
@@ -1448,12 +1849,30 @@ var PostDecorator = class extends __vercube_di.BaseDecorator {
 (0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], PostDecorator.prototype, "gRouter", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(MetadataResolver)], PostDecorator.prototype, "gMetadataResolver", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(RequestHandler)], PostDecorator.prototype, "gRequestHandler", void 0);
+/**
+* A factory function for creating a PostDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method with POST route information.
+*
+* @param {string} path - The path for the POST route.
+* @return {Function} The decorator function.
+*/
 function Post(path) {
 	return (0, __vercube_di.createDecorator)(PostDecorator, { path });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Put.ts
+/**
+* A decorator class for handling HTTP PUT requests.
+*
+* This class extends the BaseDecorator and is used to register PUT routes
+* with the Router. It also resolves metadata for the route handler
+* using the MetadataResolver.
+*
+* @extends {BaseDecorator<PutDecoratorOptions>}
+*/
 var PutDecorator = class extends __vercube_di.BaseDecorator {
 	gRouter;
 	gRequestHandler;
@@ -1485,12 +1904,30 @@ var PutDecorator = class extends __vercube_di.BaseDecorator {
 (0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], PutDecorator.prototype, "gRouter", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(RequestHandler)], PutDecorator.prototype, "gRequestHandler", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(MetadataResolver)], PutDecorator.prototype, "gMetadataResolver", void 0);
+/**
+* A factory function for creating a PutDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method with PUT route information.
+*
+* @param {string} path - The path for the PUT route.
+* @return {Function} The decorator function.
+*/
 function Put(path) {
 	return (0, __vercube_di.createDecorator)(PutDecorator, { path });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/QueryParam.ts
+/**
+* This class is responsible for managing query parameter decorators.
+*
+* This class extends the BaseDecorator and is used to register query parameter information
+* with the MetadataResolver. It ensures that the metadata for the property is created
+* and adds the query parameter information to the metadata.
+*
+* @extends {BaseDecorator<QueryDecoratorOptions>}
+*/
 var QueryParamDecorator = class extends __vercube_di.BaseDecorator {
 	/**
 	* Called when the decorator is created.
@@ -1516,12 +1953,30 @@ var QueryParamDecorator = class extends __vercube_di.BaseDecorator {
 		});
 	}
 };
+/**
+* A factory function for creating a QueryDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method parameter with query parameter information.
+*
+* @param {QueryParamDecoratorOptions} options - The options for the decorator.
+* @return {Function} The decorator function.
+*/
 function QueryParam(options) {
 	return (0, __vercube_di.createDecorator)(QueryParamDecorator, options);
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/QueryParams.ts
+/**
+* This class is responsible for managing query parameters decorators.
+*
+* This class extends the BaseDecorator and is used to register query parameters information
+* with the MetadataResolver. It ensures that the metadata for the property is created
+* and adds the query parameters information to the metadata.
+*
+* @extends {BaseDecorator<QueryDecoratorOptions>}
+*/
 var QueryParamsDecorator = class extends __vercube_di.BaseDecorator {
 	/**
 	* Called when the decorator is created.
@@ -1547,12 +2002,30 @@ var QueryParamsDecorator = class extends __vercube_di.BaseDecorator {
 		});
 	}
 };
+/**
+* A factory function for creating a QueryParamsDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method parameter with query parameter information.
+*
+* @param {QueryParamsDecoratorOptions} options - The options for the decorator.
+* @return {Function} The decorator function.
+*/
 function QueryParams(options) {
 	return (0, __vercube_di.createDecorator)(QueryParamsDecorator, options);
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Request.ts
+/**
+* This class is responsible for managing request decorators.
+*
+* This class extends the BaseDecorator and is used to register request information
+* with the MetadataResolver. It ensures that the metadata for the property is created
+* and adds the request information to the metadata.
+*
+* @extends {BaseDecorator<{}>}
+*/
 var RequestDecorator = class extends __vercube_di.BaseDecorator {
 	/**
 	* Called when the decorator is created.
@@ -1569,12 +2042,29 @@ var RequestDecorator = class extends __vercube_di.BaseDecorator {
 		});
 	}
 };
+/**
+* A factory function for creating a RequestDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method parameter with request information.
+*
+* @return {Function} The decorator function.
+*/
 function Request() {
 	return (0, __vercube_di.createDecorator)(RequestDecorator, {});
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Response.ts
+/**
+* This class is responsible for managing response decorators.
+*
+* This class extends the BaseDecorator and is used to register response information
+* with the MetadataResolver. It ensures that the metadata for the property is created
+* and adds the response information to the metadata.
+*
+* @extends {BaseDecorator<{}>}
+*/
 var ResponseDecorator = class extends __vercube_di.BaseDecorator {
 	/**
 	* Called when the decorator is created.
@@ -1591,12 +2081,29 @@ var ResponseDecorator = class extends __vercube_di.BaseDecorator {
 		});
 	}
 };
+/**
+* A factory function for creating a ResponseDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method parameter with response information.
+*
+* @return {Function} The decorator function.
+*/
 function Response$1() {
 	return (0, __vercube_di.createDecorator)(ResponseDecorator, {});
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Trace.ts
+/**
+* A decorator class for handling HTTP TRACE requests.
+*
+* This class extends the BaseDecorator and is used to register TRACE routes
+* with the Router. It also resolves metadata for the route handler
+* using the MetadataResolver.
+*
+* @extends {BaseDecorator<TraceDecoratorOptions>}
+*/
 var TraceDecorator = class extends __vercube_di.BaseDecorator {
 	gRouter;
 	gRequestHandler;
@@ -1628,12 +2135,25 @@ var TraceDecorator = class extends __vercube_di.BaseDecorator {
 (0, import_decorate.default)([(0, __vercube_di.Inject)(Router)], TraceDecorator.prototype, "gRouter", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(RequestHandler)], TraceDecorator.prototype, "gRequestHandler", void 0);
 (0, import_decorate.default)([(0, __vercube_di.Inject)(MetadataResolver)], TraceDecorator.prototype, "gMetadataResolver", void 0);
+/**
+* A factory function for creating a TraceDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method with TRACE route information.
+*
+* @param {string} path - The path for the TRACE route.
+* @return {Function} The decorator function.
+*/
 function Trace(path) {
 	return (0, __vercube_di.createDecorator)(TraceDecorator, { path });
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/SetHeader.ts
+/**
+* A decorator that sets a header on the response.
+* @extends {BaseDecorator<SetHeaderDecoratorOptions>}
+*/
 var SetHeaderDecorator = class extends __vercube_di.BaseDecorator {
 	/**
 	* Called when the decorator is created.
@@ -1650,6 +2170,12 @@ var SetHeaderDecorator = class extends __vercube_di.BaseDecorator {
 		} });
 	}
 };
+/**
+* Creates a SetHeader decorator.
+* @param {string} key - The header key.
+* @param {string} value - The header value.
+* @returns {Function} The decorator function.
+*/
 function SetHeader(key, value) {
 	return (0, __vercube_di.createDecorator)(SetHeaderDecorator, {
 		key,
@@ -1659,6 +2185,13 @@ function SetHeader(key, value) {
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Status.ts
+/**
+
+* A decorator that sets a status on the response.
+
+* @extends {BaseDecorator<StatusDecoratorOptions>}
+
+*/
 var StatusDecorator = class extends __vercube_di.BaseDecorator {
 	/**
 	
@@ -1675,6 +2208,15 @@ var StatusDecorator = class extends __vercube_di.BaseDecorator {
 		method.actions.push({ handler: () => ({ status: this.options.code }) });
 	}
 };
+/**
+
+* Creates a Status decorator.
+
+* @param {number} code - The status value.
+
+* @returns {Function} The decorator function.
+
+*/
 function Status(code) {
 	return (0, __vercube_di.createDecorator)(StatusDecorator, { code });
 }
@@ -1704,6 +2246,17 @@ var RedirectDecorator = class extends __vercube_di.BaseDecorator {
 		} });
 	}
 };
+/**
+
+* Creates a Redirect decorator.
+
+* @param {string} location - The location header value.
+
+* @param {number} [code=301] - The status code.
+
+* @returns {Function} The decorator function.
+
+*/
 function Redirect(location, code = 301) {
 	return (0, __vercube_di.createDecorator)(RedirectDecorator, {
 		location,
@@ -1713,6 +2266,28 @@ function Redirect(location, code = 301) {
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Middleware.ts
+/**
+* Decorator that applies middleware to a class or method
+* @param middleware - The middleware class to apply
+* @param opts - Optional configuration parameters
+* @param opts.type - The type of middleware ('before' or 'after')
+* @param opts.priority - Priority order for middleware execution (default: 999)
+* @returns A decorator function that can be applied to classes or methods
+*
+* @example
+* ```typescript
+* @Middleware(AuthMiddleware)
+* class UserController {
+*   // ...
+* }
+*
+* // Or on a specific method:
+* @Middleware(ValidationMiddleware, { type: 'before', priority: 1 })
+* public async createUser() {
+*   // ...
+* }
+* ```
+*/
 function Middleware(middleware, opts) {
 	return function internalDecorator(target, propertyName) {
 		const ctx = propertyName ? target : target.prototype;
@@ -1727,6 +2302,12 @@ function Middleware(middleware, opts) {
 
 //#endregion
 //#region packages/core/src/Decorators/Http/MultipartFormData.ts
+/**
+* @class MultipartFormDataDecorator
+* @extends BaseDecorator<MultipartFormDataOptions>
+*
+* A decorator class that handles the metadata for HTTP request bodies.
+*/
 var MultipartFormDataDecorator = class extends __vercube_di.BaseDecorator {
 	/**
 	* @method created
@@ -1742,12 +2323,35 @@ var MultipartFormDataDecorator = class extends __vercube_di.BaseDecorator {
 		});
 	}
 };
+/**
+* Decorator function that marks a parameter as multipart/form-data request body.
+* This decorator will automatically parse incoming multipart form data
+* 
+* @decorator
+* @returns {Function} A decorator function that can be applied to method parameters
+* 
+* @example
+* class UserController {
+*   uploadFile(@MultipartFormData() formData: MyData) {
+*     // Handle multipart form data
+*   }
+* }
+*/
 function MultipartFormData() {
 	return (0, __vercube_di.createDecorator)(MultipartFormDataDecorator, {});
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Http/Session.ts
+/**
+* This class is responsible for managing session decorators.
+*
+* This class extends the BaseDecorator and is used to register session information
+* with the MetadataResolver. It ensures that the metadata for the property is created
+* and adds the session information to the metadata.
+*
+* @extends {BaseDecorator<{}>}
+*/
 var SessionDecorator = class extends __vercube_di.BaseDecorator {
 	gRuntimeConfig;
 	/**
@@ -1771,12 +2375,23 @@ var SessionDecorator = class extends __vercube_di.BaseDecorator {
 	}
 };
 (0, import_decorate.default)([(0, __vercube_di.Inject)(RuntimeConfig)], SessionDecorator.prototype, "gRuntimeConfig", void 0);
+/**
+* A factory function for creating a SessionDecorator.
+*
+* This function returns a decorator function that can be used to annotate
+* a method parameter with session information.
+*
+* @return {Function} The decorator function.
+*/
 function Session() {
 	return (0, __vercube_di.createDecorator)(SessionDecorator, {});
 }
 
 //#endregion
 //#region packages/core/src/Decorators/Hooks/Listen.ts
+/**
+* This class is responsible for managing cache decorator.
+*/
 var ListenDecorator = class extends __vercube_di.BaseDecorator {
 	gHooksService;
 	fHook;
@@ -1795,12 +2410,22 @@ var ListenDecorator = class extends __vercube_di.BaseDecorator {
 	}
 };
 (0, import_decorate.default)([(0, __vercube_di.Inject)(HooksService)], ListenDecorator.prototype, "gHooksService", void 0);
+/**
+* This decorator stores metadata about hook listeners. It can be later used along with function
+* applyEventListeners() to automatically register all listeners.
+*
+* @param hookType hook to listen for
+* @return decorator function
+*/
 function Listen(hookType) {
 	return (0, __vercube_di.createDecorator)(ListenDecorator, { hookType });
 }
 
 //#endregion
 //#region packages/core/src/Services/Plugins/BasePlugin.ts
+/**
+* Represents a Plugin.
+*/
 var BasePlugin = class {
 	/**
 	* The name of the plugin.
@@ -1816,10 +2441,17 @@ var BasePlugin = class {
 
 //#endregion
 //#region packages/core/src/Services/Middleware/BaseMiddleware.ts
+/**
+* BaseMiddleware class that serves as a base for all middleware implementations.
+*/
 var BaseMiddleware = class {};
 
 //#endregion
 //#region packages/core/src/Errors/Http/ForbiddenError.ts
+/**
+* Represents a Forbidden error (HTTP 403).
+* @extends {HttpError}
+*/
 var ForbiddenError = class ForbiddenError extends HttpError {
 	/**
 	* The name of the error.
@@ -1839,6 +2471,10 @@ var ForbiddenError = class ForbiddenError extends HttpError {
 
 //#endregion
 //#region packages/core/src/Errors/Http/MethodNotAllowedError.ts
+/**
+* Represents a Method Not Allowed error (HTTP 405).
+* @extends {HttpError}
+*/
 var MethodNotAllowedError = class MethodNotAllowedError extends HttpError {
 	/**
 	* The name of the error.
@@ -1858,6 +2494,10 @@ var MethodNotAllowedError = class MethodNotAllowedError extends HttpError {
 
 //#endregion
 //#region packages/core/src/Errors/Http/NotAcceptableError.ts
+/**
+* Represents a Not Acceptable error (HTTP 406).
+* @extends {HttpError}
+*/
 var NotAcceptableError = class NotAcceptableError extends HttpError {
 	/**
 	* The name of the error.
@@ -1877,6 +2517,10 @@ var NotAcceptableError = class NotAcceptableError extends HttpError {
 
 //#endregion
 //#region packages/core/src/Errors/Http/NotFoundError.ts
+/**
+* Represents a Not Found error (HTTP 404).
+* @extends {HttpError}
+*/
 var NotFoundError = class NotFoundError extends HttpError {
 	/**
 	* The name of the error.
@@ -1896,6 +2540,10 @@ var NotFoundError = class NotFoundError extends HttpError {
 
 //#endregion
 //#region packages/core/src/Errors/Http/UnauthorizedError.ts
+/**
+* Represents an Unauthorized error (HTTP 401).
+* @extends {HttpError}
+*/
 var UnauthorizedError = class UnauthorizedError extends HttpError {
 	/**
 	* The name of the error.
@@ -1989,8 +2637,10 @@ exports.Body = Body
 exports.Connect = Connect
 exports.Controller = Controller
 exports.Delete = Delete
+exports.ErrorHandlerProvider = ErrorHandlerProvider
 exports.ForbiddenError = ForbiddenError
 exports.Get = Get
+exports.GlobalMiddlewareRegistry = GlobalMiddlewareRegistry
 exports.HTTPStatus = HTTPStatus
 exports.Head = Head
 exports.Header = Header