@noxfly/noxus 3.0.0-dev.0 → 3.0.0-dev.10

package/dist/main.d.mts

@@ -1,15 +1,242 @@
-import { T as Type, a as TokenKey } from './app-injector-Bz3Upc0y.mjs';
-export { A as AppInjector, F as ForwardRefFn, b as ForwardReference, I as IBinding, L as Lifetime, M as MaybeAsync, R as RootInjector, c as Token, f as forwardRef, i as inject, t as token } from './app-injector-Bz3Upc0y.mjs';
-import { f as Request, a as IResponse, G as Guard, M as Middleware } from './request-qJ9EiDZc.mjs';
-export { A as AtomicHttpMethod, D as Delete, h as Get, H as HttpMethod, c as IBatchRequestItem, e as IBatchRequestPayload, d as IBatchResponsePayload, I as IRendererEventMessage, b as IRequest, j as IRouteMetadata, k as IRouteOptions, N as NextFunction, P as Patch, l as Post, m as Put, R as RENDERER_EVENT_TYPE, g as createRendererEventMessage, n as getRouteMetadata, o as isAtomicHttpMethod, i as isRendererEventMessage } from './request-qJ9EiDZc.mjs';
 import { BrowserWindow } from 'electron/main';
-export { BadGatewayException, BadRequestException, ConflictException, ForbiddenException, GatewayTimeoutException, HttpVersionNotSupportedException, Injectable, InjectableOptions, InsufficientStorageException, InternalServerException, LogLevel, Logger, LoopDetectedException, MethodNotAllowedException, NetworkAuthenticationRequiredException, NetworkConnectTimeoutException, NotAcceptableException, NotExtendedException, NotFoundException, NotImplementedException, PaymentRequiredException, RequestTimeoutException, ResponseException, ServiceUnavailableException, TooManyRequestsException, UnauthorizedException, UpgradeRequiredException, VariantAlsoNegotiatesException } from './child.mjs';
 
 /**
  * @copyright 2025 NoxFly
  * @license MIT
  * @author NoxFly
  */
+interface Type<T> extends Function {
+    new (...args: any[]): T;
+}
+/**
+ * Represents a generic type that can be either a value or a promise resolving to that value.
+ */
+type MaybeAsync<T> = T | Promise<T>;
+
+
+/**
+ * A function that returns a type.
+ * Used for forward references to types that are not yet defined.
+ */
+interface ForwardRefFn<T = any> {
+    (): Type<T>;
+}
+/**
+ * A wrapper class for forward referenced types.
+ */
+declare class ForwardReference<T = any> {
+    readonly forwardRefFn: ForwardRefFn<T>;
+    constructor(forwardRefFn: ForwardRefFn<T>);
+}
+/**
+ * Creates a forward reference to a type.
+ * @param fn A function that returns the type.
+ * @returns A ForwardReference instance.
+ */
+declare function forwardRef<T = any>(fn: ForwardRefFn<T>): ForwardReference<T>;
+
+
+/**
+ * A DI token uniquely identifies a dependency.
+ * It can wrap a class (Type<T>) or be a named symbol token.
+ *
+ * Using tokens instead of reflect-metadata means dependencies are
+ * declared explicitly — no magic type inference, no emitDecoratorMetadata.
+ *
+ * @example
+ * // Class token (most common)
+ * const MY_SERVICE = token(MyService);
+ *
+ * // Named symbol token (for interfaces or non-class values)
+ * const DB_URL = token<string>('DB_URL');
+ */
+declare class Token<T> {
+    readonly target: Type<T> | string;
+    readonly description: string;
+    constructor(target: Type<T> | string);
+    toString(): string;
+}
+/**
+ * Creates a DI token for a class type or a named value.
+ *
+ * @example
+ * export const MY_SERVICE = token(MyService);
+ * export const DB_URL = token<string>('DB_URL');
+ */
+declare function token<T>(target: Type<T> | string): Token<T>;
+/**
+ * The key used to look up a class token in the registry.
+ * For class tokens, the key is the class constructor itself.
+ * For named tokens, the key is the Token instance.
+ */
+type TokenKey<T = unknown> = Type<T> | Token<T>;
+
+
+/**
+ * Lifetime of a binding in the DI container.
+ * - singleton: created once, shared for the lifetime of the app.
+ * - scope:     created once per request scope.
+ * - transient: new instance every time it is resolved.
+ */
+type Lifetime = 'singleton' | 'scope' | 'transient';
+/**
+ * Internal representation of a registered binding.
+ */
+interface IBinding<T = unknown> {
+    lifetime: Lifetime;
+    implementation: Type<T>;
+    /** Explicit constructor dependencies, declared by the class itself. */
+    deps: ReadonlyArray<TokenKey>;
+    instance?: T;
+}
+/**
+ * AppInjector is the core DI container.
+ * It no longer uses reflect-metadata — all dependency information
+ * comes from explicitly declared `deps` arrays on each binding.
+ */
+declare class AppInjector {
+    readonly name: string | null;
+    readonly bindings: Map<Type<unknown> | Token<unknown>, IBinding<unknown>>;
+    readonly singletons: Map<Type<unknown> | Token<unknown>, unknown>;
+    readonly scoped: Map<Type<unknown> | Token<unknown>, unknown>;
+    constructor(name?: string | null);
+    /**
+     * Creates a child scope for per-request lifetime resolution.
+     */
+    createScope(): AppInjector;
+    /**
+     * Registers a binding explicitly.
+     */
+    register<T>(key: TokenKey<T>, implementation: Type<T>, lifetime: Lifetime, deps?: ReadonlyArray<TokenKey>): void;
+    /**
+     * Resolves a dependency by token or class reference.
+     */
+    resolve<T>(target: TokenKey<T> | ForwardReference<T>): T;
+    private _resolveForwardRef;
+    private _instantiate;
+}
+/**
+ * The global root injector. All singletons live here.
+ */
+declare const RootInjector: AppInjector;
+/**
+ * Resets the root injector to a clean state.
+ * **Intended for testing only** — clears all bindings, singletons, and scoped instances
+ * so that each test can start from a fresh DI container without restarting the process.
+ */
+declare function resetRootInjector(): void;
+/**
+ * Convenience function: resolve a token from the root injector.
+ */
+declare function inject<T>(t: TokenKey<T> | ForwardReference<T>): T;
+
+
+/**
+ * A middleware intercepts requests before they reach guards and the handler.
+ * Implement this interface and pass the class to @Controller({ middlewares }) or per-route options.
+ */
+type Middleware = (request: Request, response: IResponse, next: NextFunction) => MaybeAsync<void>;
+type NextFunction = () => Promise<void>;
+
+
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'BATCH';
+type AtomicHttpMethod = Exclude<HttpMethod, 'BATCH'>;
+declare function isAtomicHttpMethod(m: unknown): m is AtomicHttpMethod;
+interface IRouteOptions {
+    /**
+     * Guards specific to this route (merged with controller guards).
+     */
+    guards?: Guard[];
+    /**
+     * Middlewares specific to this route (merged with controller middlewares).
+     */
+    middlewares?: Middleware[];
+}
+interface IRouteMetadata {
+    method: HttpMethod;
+    path: string;
+    handler: string;
+    guards: Guard[];
+    middlewares: Middleware[];
+}
+declare function getRouteMetadata(target: object): IRouteMetadata[];
+declare const Get: (path: string, options?: IRouteOptions) => MethodDecorator;
+declare const Post: (path: string, options?: IRouteOptions) => MethodDecorator;
+declare const Put: (path: string, options?: IRouteOptions) => MethodDecorator;
+declare const Patch: (path: string, options?: IRouteOptions) => MethodDecorator;
+declare const Delete: (path: string, options?: IRouteOptions) => MethodDecorator;
+
+
+/**
+ * The Request class represents an HTTP request in the Noxus framework.
+ * It encapsulates the request data, including the event, ID, method, path, and body.
+ * It also provides a context for dependency injection through the AppInjector.
+ */
+declare class Request {
+    readonly event: Electron.MessageEvent;
+    readonly senderId: number;
+    readonly id: string;
+    readonly method: HttpMethod;
+    readonly path: string;
+    readonly body: unknown;
+    readonly context: AppInjector;
+    readonly params: Record<string, string>;
+    readonly query: Record<string, unknown>;
+    constructor(event: Electron.MessageEvent, senderId: number, id: string, method: HttpMethod, path: string, body: unknown, query?: Record<string, unknown>);
+}
+/**
+ * The IRequest interface defines the structure of a request object.
+ * It includes properties for the sender ID, request ID, path, method, and an optional body.
+ * This interface is used to standardize the request data across the application.
+ */
+interface IRequest<TBody = unknown> {
+    senderId: number;
+    requestId: string;
+    path: string;
+    method: HttpMethod;
+    body?: TBody;
+    query?: Record<string, unknown>;
+}
+interface IBatchRequestItem<TBody = unknown> {
+    requestId?: string;
+    path: string;
+    method: AtomicHttpMethod;
+    body?: TBody;
+    query?: Record<string, unknown>;
+}
+interface IBatchRequestPayload {
+    requests: IBatchRequestItem[];
+}
+/**
+ * Creates a Request object from the IPC event data.
+ * This function extracts the necessary information from the IPC event and constructs a Request instance.
+ */
+interface IResponse<TBody = unknown> {
+    requestId: string;
+    status: number;
+    body?: TBody;
+    error?: string;
+    stack?: string;
+}
+interface IBatchResponsePayload {
+    responses: IResponse[];
+}
+declare const RENDERER_EVENT_TYPE = "noxus:event";
+interface IRendererEventMessage<TPayload = unknown> {
+    type: typeof RENDERER_EVENT_TYPE;
+    event: string;
+    payload?: TPayload;
+}
+declare function createRendererEventMessage<TPayload = unknown>(event: string, payload?: TPayload): IRendererEventMessage<TPayload>;
+declare function isRendererEventMessage(value: unknown): value is IRendererEventMessage;
+
+
+/**
+ * A guard decides whether an incoming request should reach the handler.
+ * Implement this interface and pass the class to @Controller({ guards }) or @Get('path', { guards }).
+ */
+type Guard = (request: Request) => MaybeAsync<boolean>;
+
 
 interface ILazyRoute {
     load: () => Promise<unknown>;
@@ -31,9 +258,18 @@ declare class Router {
     private readonly routes;
     private readonly rootMiddlewares;
     private readonly lazyRoutes;
+    private lazyLoadLock;
     registerController(controllerClass: Type<unknown>, pathPrefix: string, routeGuards?: Guard[], routeMiddlewares?: Middleware[]): this;
     registerLazyRoute(pathPrefix: string, load: () => Promise<unknown>, guards?: Guard[], middlewares?: Middleware[]): this;
     defineRootMiddleware(middleware: Middleware): this;
+    getRegisteredRoutes(): Array<{
+        method: string;
+        path: string;
+    }>;
+    getLazyRoutes(): Array<{
+        prefix: string;
+        loaded: boolean;
+    }>;
     handle(request: Request): Promise<IResponse>;
     private handleAtomic;
     private handleBatch;
@@ -72,6 +308,11 @@ interface WindowRecord {
     window: BrowserWindow;
     id: number;
 }
+/**
+ * @description
+ * The events emitted by WindowManager when windows are created, closed, focused, or blurred.
+ */
+type WindowEvent = 'created' | 'closed' | 'focused' | 'blurred';
 /**
  * WindowManager is a singleton service that centralizes BrowserWindow lifecycle.
  *
@@ -96,6 +337,7 @@ interface WindowRecord {
  */
 declare class WindowManager {
     private readonly _windows;
+    private readonly listeners;
     private _mainWindowId;
     /**
      * Creates a BrowserWindow, optionally performs an animated expand to the
@@ -129,6 +371,7 @@ declare class WindowManager {
      */
     createSplash(options?: Electron.BrowserWindowConstructorOptions & {
         animationDuration?: number;
+        expandToWorkArea?: boolean;
     }): Promise<BrowserWindow>;
     /** Returns all currently open windows. */
     getAll(): BrowserWindow[];
@@ -153,6 +396,8 @@ declare class WindowManager {
      * Broadcasts a message to all open windows.
      */
     broadcast(channel: string, ...args: unknown[]): void;
+    on(event: WindowEvent, handler: (win: BrowserWindow) => void): () => void;
+    private _emit;
     private _register;
     /**
      * Animates the window to the full work area of the primary display.
@@ -162,6 +407,20 @@ declare class WindowManager {
     private _expandToWorkArea;
 }
 
+interface RendererChannels {
+    request: Electron.MessageChannelMain;
+    socket: Electron.MessageChannelMain;
+}
+declare class NoxSocket {
+    private readonly channels;
+    register(senderId: number, requestChannel: Electron.MessageChannelMain, socketChannel: Electron.MessageChannelMain): void;
+    get(senderId: number): RendererChannels | undefined;
+    unregister(senderId: number): void;
+    getSenderIds(): number[];
+    emit<TPayload = unknown>(eventName: string, payload?: TPayload, targetSenderIds?: number[]): void;
+    emitToRenderer<TPayload = unknown>(senderId: number, eventName: string, payload?: TPayload): boolean;
+}
+
 
 /**
  * Your application service should implement IApp.
@@ -191,10 +450,11 @@ interface IApp {
     onActivated(): Promise<void>;
 }
 declare class NoxApp {
-    private appService;
     private readonly router;
     private readonly socket;
     readonly windowManager: WindowManager;
+    private appService;
+    constructor(router: Router, socket: NoxSocket, windowManager: WindowManager);
     init(): Promise<this>;
     /**
      * Registers a lazy route. The file behind this prefix is dynamically
@@ -236,6 +496,107 @@ declare class NoxApp {
     private shutdownChannel;
 }
 
+/**
+ * Logger is a utility class for logging messages to the console.
+ */
+type LogLevel = 'debug' | 'comment' | 'log' | 'info' | 'warn' | 'error' | 'critical';
+declare namespace Logger {
+    /**
+     * Sets the log level for the logger.
+     * This function allows you to change the log level dynamically at runtime.
+     * This won't affect the startup logs.
+     *
+     * If the parameter is a single LogLevel, all log levels with equal or higher severity will be enabled.
+
+    * If the parameter is an array of LogLevels, only the specified levels will be enabled.
+     *
+     * @param level Sets the log level for the logger.
+     */
+    function setLogLevel(level: LogLevel | LogLevel[]): void;
+    /**
+     * Logs a message to the console with log level LOG.
+     * This function formats the message with a timestamp, process ID, and the name of the caller function or class.
+     * It uses different colors for different log levels to enhance readability.
+     * @param args The arguments to log.
+     */
+    function log(...args: any[]): void;
+    /**
+     * Logs a message to the console with log level INFO.
+     * This function formats the message with a timestamp, process ID, and the name of the caller function or class.
+     * It uses different colors for different log levels to enhance readability.
+     * @param args The arguments to log.
+     */
+    function info(...args: any[]): void;
+    /**
+     * Logs a message to the console with log level WARN.
+     * This function formats the message with a timestamp, process ID, and the name of the caller function or class.
+     * It uses different colors for different log levels to enhance readability.
+     * @param args The arguments to log.
+     */
+    function warn(...args: any[]): void;
+    /**
+     * Logs a message to the console with log level ERROR.
+     * This function formats the message with a timestamp, process ID, and the name of the caller function or class.
+     * It uses different colors for different log levels to enhance readability.
+     * @param args The arguments to log.
+     */
+    function error(...args: any[]): void;
+    /**
+     * Logs a message to the console with log level ERROR and a grey color scheme.
+     */
+    function errorStack(...args: any[]): void;
+    /**
+     * Logs a message to the console with log level DEBUG.
+     * This function formats the message with a timestamp, process ID, and the name of the caller function or class.
+     * It uses different colors for different log levels to enhance readability.
+     * @param args The arguments to log.
+     */
+    function debug(...args: any[]): void;
+    /**
+     * Logs a message to the console with log level COMMENT.
+     * This function formats the message with a timestamp, process ID, and the name of the caller function or class.
+     * It uses different colors for different log levels to enhance readability.
+     * @param args The arguments to log.
+     */
+    function comment(...args: any[]): void;
+    /**
+     * Logs a message to the console with log level CRITICAL.
+     * This function formats the message with a timestamp, process ID, and the name of the caller function or class.
+     * It uses different colors for different log levels to enhance readability.
+     * @param args The arguments to log.
+     */
+    function critical(...args: any[]): void;
+    /**
+     * Enables logging to a file output for the specified log levels.
+     * @param filepath The path to the log file.
+     * @param levels The log levels to enable file logging for. Defaults to all levels.
+     */
+    function enableFileLogging(filepath: string, levels?: LogLevel[]): void;
+    /**
+     * Disables logging to a file output for the specified log levels.
+     * @param levels The log levels to disable file logging for. Defaults to all levels.
+     */
+    function disableFileLogging(levels?: LogLevel[]): void;
+    const colors: {
+        black: string;
+        grey: string;
+        red: string;
+        green: string;
+        brown: string;
+        blue: string;
+        purple: string;
+        darkGrey: string;
+        lightRed: string;
+        lightGreen: string;
+        yellow: string;
+        lightBlue: string;
+        magenta: string;
+        cyan: string;
+        white: string;
+        initial: string;
+    };
+}
+
 
 /**
  * A single route entry in the application routing table.
@@ -250,10 +611,12 @@ interface RouteDefinition {
      * Dynamic import function returning the controller file.
      * The controller is loaded lazily on the first IPC request targeting this prefix.
      *
+     * Optional when the route only serves as a parent for `children`.
+     *
      * @example
      * load: () => import('./modules/users/users.controller')
      */
-    load: () => Promise<unknown>;
+    load?: () => Promise<unknown>;
     /**
      * Guards applied to every action in this controller.
      * Merged with action-level guards.
@@ -264,6 +627,11 @@ interface RouteDefinition {
      * Merged with action-level middlewares.
      */
     middlewares?: Middleware[];
+    /**
+     * Nested child routes. Guards and middlewares declared here are
+     * inherited (merged) by all children.
+     */
+    children?: RouteDefinition[];
 }
 /**
  * Defines the application routing table.
@@ -272,6 +640,9 @@ interface RouteDefinition {
  * This is the single source of truth for routing — no path is declared
  * in @Controller(), preventing duplicate route prefixes across controllers.
  *
+ * Supports nested routes via the `children` property. Guards and middlewares
+ * from parent entries are inherited (merged) into each child.
+ *
  * @example
  * export const routes = defineRoutes([
  *     {
@@ -280,16 +651,17 @@ interface RouteDefinition {
  *         guards: [authGuard],
  *     },
  *     {
- *         path: 'orders',
- *         load: () => import('./modules/orders/orders.controller'),
- *         guards: [authGuard],
- *         middlewares: [logMiddleware],
+ *         path: 'admin',
+ *         guards: [authGuard, adminGuard],
+ *         children: [
+ *             { path: 'users',    load: () => import('./admin/users.controller') },
+ *             { path: 'products', load: () => import('./admin/products.controller') },
+ *         ],
  *     },
  * ]);
  */
 declare function defineRoutes(routes: RouteDefinition[]): RouteDefinition[];
 
-
 /**
  * A singleton value override: provides an already-constructed instance
  * for a given token, bypassing the DI factory.
@@ -344,12 +716,96 @@ interface BootstrapConfig {
      * ]
      */
     eagerLoad?: Array<() => Promise<unknown>>;
+    /**
+     * Controls framework log verbosity.
+     * - `'debug'`: all messages (default during development).
+     * - `'info'`: info, warn, error, critical only.
+     * - `'none'`: completely silent — no framework logs.
+     *
+     * You can also pass an array of specific log levels to enable.
+     */
+    logLevel?: 'debug' | 'info' | 'none' | LogLevel[];
 }
 /**
  * Bootstraps the Noxus application.
  */
 declare function bootstrapApplication(config?: BootstrapConfig): Promise<NoxApp>;
 
+declare class ResponseException extends Error {
+    readonly status: number;
+    constructor(message?: string);
+    constructor(statusCode?: number, message?: string);
+}
+declare class BadRequestException extends ResponseException {
+    readonly status = 400;
+}
+declare class UnauthorizedException extends ResponseException {
+    readonly status = 401;
+}
+declare class PaymentRequiredException extends ResponseException {
+    readonly status = 402;
+}
+declare class ForbiddenException extends ResponseException {
+    readonly status = 403;
+}
+declare class NotFoundException extends ResponseException {
+    readonly status = 404;
+}
+declare class MethodNotAllowedException extends ResponseException {
+    readonly status = 405;
+}
+declare class NotAcceptableException extends ResponseException {
+    readonly status = 406;
+}
+declare class RequestTimeoutException extends ResponseException {
+    readonly status = 408;
+}
+declare class ConflictException extends ResponseException {
+    readonly status = 409;
+}
+declare class UpgradeRequiredException extends ResponseException {
+    readonly status = 426;
+}
+declare class TooManyRequestsException extends ResponseException {
+    readonly status = 429;
+}
+declare class InternalServerException extends ResponseException {
+    readonly status = 500;
+}
+declare class NotImplementedException extends ResponseException {
+    readonly status = 501;
+}
+declare class BadGatewayException extends ResponseException {
+    readonly status = 502;
+}
+declare class ServiceUnavailableException extends ResponseException {
+    readonly status = 503;
+}
+declare class GatewayTimeoutException extends ResponseException {
+    readonly status = 504;
+}
+declare class HttpVersionNotSupportedException extends ResponseException {
+    readonly status = 505;
+}
+declare class VariantAlsoNegotiatesException extends ResponseException {
+    readonly status = 506;
+}
+declare class InsufficientStorageException extends ResponseException {
+    readonly status = 507;
+}
+declare class LoopDetectedException extends ResponseException {
+    readonly status = 508;
+}
+declare class NotExtendedException extends ResponseException {
+    readonly status = 510;
+}
+declare class NetworkAuthenticationRequiredException extends ResponseException {
+    readonly status = 511;
+}
+declare class NetworkConnectTimeoutException extends ResponseException {
+    readonly status = 599;
+}
+
 
 interface ControllerOptions {
     /**
@@ -377,18 +833,54 @@ interface IControllerMetadata {
 declare function Controller(options?: ControllerOptions): ClassDecorator;
 declare function getControllerMetadata(target: object): IControllerMetadata | undefined;
 
-interface RendererChannels {
-    request: Electron.MessageChannelMain;
-    socket: Electron.MessageChannelMain;
-}
-declare class NoxSocket {
-    private readonly channels;
-    register(senderId: number, requestChannel: Electron.MessageChannelMain, socketChannel: Electron.MessageChannelMain): void;
-    get(senderId: number): RendererChannels | undefined;
-    unregister(senderId: number): void;
-    getSenderIds(): number[];
-    emit<TPayload = unknown>(eventName: string, payload?: TPayload, targetSenderIds?: number[]): number;
-    emitToRenderer<TPayload = unknown>(senderId: number, eventName: string, payload?: TPayload): boolean;
+
+interface InjectableOptions {
+    /**
+     * Lifetime of this injectable.
+     * @default 'scope'
+     */
+    lifetime?: Lifetime;
+    /**
+     * Explicit list of constructor dependencies, in the same order as the constructor parameters.
+     * Each entry is either a class constructor or a Token created with token().
+     *
+     * This replaces reflect-metadata / emitDecoratorMetadata entirely.
+     *
+     * @example
+     * @Injectable({ lifetime: 'singleton', deps: [MyRepo, DB_URL] })
+     * class MyService {
+     *   constructor(private repo: MyRepo, private dbUrl: string) {}
+     * }
+     */
+    deps?: ReadonlyArray<TokenKey>;
 }
+/**
+ * Marks a class as injectable into the Noxus DI container.
+ *
+ * Unlike the v2 @Injectable, this decorator:
+ * - Does NOT require reflect-metadata or emitDecoratorMetadata.
+ * - Requires you to declare deps explicitly when the class has constructor parameters.
+ * - Supports standalone usage — no module declaration needed.
+ *
+ * @example
+ * // No dependencies
+ * @Injectable()
+ * class Logger {}
+ *
+ * // With dependencies
+ * @Injectable({ lifetime: 'singleton', deps: [Logger, MyRepo] })
+ * class MyService {
+ *   constructor(private logger: Logger, private repo: MyRepo) {}
+ * }
+ *
+ * // With a named token
+ * const DB_URL = token<string>('DB_URL');
+ *
+ * @Injectable({ deps: [DB_URL] })
+ * class DbService {
+ *   constructor(private url: string) {}
+ * }
+ */
+declare function Injectable(options?: InjectableOptions): ClassDecorator;
 
-export { type BootstrapConfig, Controller, type ControllerAction, type ControllerOptions, Guard, type IApp, type IControllerMetadata, type ILazyRoute, IResponse, type IRouteDefinition, Middleware, NoxApp, NoxSocket, Request, type RouteDefinition, Router, type SingletonOverride, TokenKey, Type, type WindowConfig, WindowManager, type WindowRecord, bootstrapApplication, defineRoutes, getControllerMetadata };
+export { AppInjector, type AtomicHttpMethod, BadGatewayException, BadRequestException, type BootstrapConfig, ConflictException, Controller, type ControllerAction, type ControllerOptions, Delete, ForbiddenException, type ForwardRefFn, ForwardReference, GatewayTimeoutException, Get, type Guard, type HttpMethod, HttpVersionNotSupportedException, type IApp, type IBatchRequestItem, type IBatchRequestPayload, type IBatchResponsePayload, type IBinding, type IControllerMetadata, type ILazyRoute, type IRendererEventMessage, type IRequest, type IResponse, type IRouteDefinition, type IRouteMetadata, type IRouteOptions, Injectable, type InjectableOptions, InsufficientStorageException, InternalServerException, type Lifetime, type LogLevel, Logger, LoopDetectedException, type MaybeAsync, MethodNotAllowedException, type Middleware, NetworkAuthenticationRequiredException, NetworkConnectTimeoutException, type NextFunction, NotAcceptableException, NotExtendedException, NotFoundException, NotImplementedException, NoxApp, NoxSocket, Patch, PaymentRequiredException, Post, Put, RENDERER_EVENT_TYPE, Request, RequestTimeoutException, ResponseException, RootInjector, type RouteDefinition, Router, ServiceUnavailableException, type SingletonOverride, Token, type TokenKey, TooManyRequestsException, type Type, UnauthorizedException, UpgradeRequiredException, VariantAlsoNegotiatesException, type WindowConfig, type WindowEvent, WindowManager, type WindowRecord, bootstrapApplication, createRendererEventMessage, defineRoutes, forwardRef, getControllerMetadata, getRouteMetadata, inject, isAtomicHttpMethod, isRendererEventMessage, resetRootInjector, token };