@noxfly/noxus 1.1.10 → 1.2.0

package/README.md

@@ -48,6 +48,8 @@ npm i -D @noxfly/noxus
 
 Because you only need types during development, using the `-D` argument will make this package a `devDependency`, thus won't be present on your build.
 
+> ⚠️ The default entry (`@noxfly/noxus`) only exposes renderer-friendly helpers and types. Import Electron main-process APIs from `@noxfly/noxus/main`.
+
 ## Basic use
 
 When employing "main", we consider this is the electron side of your application.
@@ -61,7 +63,7 @@ However, you can feel free to keep both merged, this won't change anything, but
 ```ts
 // main/index.ts
 
-import { bootstrapApplication } from '@noxfly/noxus';
+import { bootstrapApplication } from '@noxfly/noxus/main';
 import { AppModule } from './modules/app.module.ts';
 import { Application } from './modules/app.service.ts';
 
@@ -81,7 +83,7 @@ main();
 ```ts
 // main/modules/app.service.ts
 
-import { IApp, Injectable, Logger } from '@noxfly/noxus';
+import { IApp, Injectable, Logger } from '@noxfly/noxus/main';
 
 @Injectable('singleton')
 export class Application implements IApp {
@@ -101,7 +103,7 @@ export class Application implements IApp {
 ```ts
 // main/modules/app.module.ts
 
-import { Module } from '@noxfly/noxus';
+import { Module } from '@noxfly/noxus/main';
 
 @Module({
     imports: [UsersModule], // import modules to be found here
@@ -116,7 +118,7 @@ export class AppModule {}
 ```ts
 // main/modules/users/users.module.ts
 
-import { Module } from '@noxfly/noxus';
+import { Module } from '@noxfly/noxus/main';
 
 @Module({
     providers: [UsersService],
@@ -128,7 +130,7 @@ export class UsersModule {}
 ```ts
 // main/modules/users/users.service.ts
 
-import { Injectable } from '@noxfly/noxus';
+import { Injectable } from '@noxfly/noxus/main';
 
 @Injectable()
 export class UsersService {
@@ -147,7 +149,7 @@ export class UsersService {
 ```ts
 // main/modules/users/users.controller.ts
 
-import { Controller, Get } from '@noxfly/noxus';
+import { Controller, Get } from '@noxfly/noxus/main';
 import { UsersService } from './users.service.ts';
 
 @Controller('users')
@@ -174,7 +176,7 @@ Further upgrades might include new decorators like `@Param()`, `@Body()` etc...
 ```ts
 // main/guards/auth.guard.ts
 
-import { IGuard, Injectable, MaybeAsync, Request } from '@noxfly/noxus';
+import { IGuard, Injectable, MaybeAsync, Request } from '@noxfly/noxus/main';
 
 @Injectable()
 export class AuthGuard implements IGuard {
@@ -394,7 +396,7 @@ throw new UnavailableException();
 You can decide to inject an Injectable without passing by the constructor, as follow :
 
 ```ts
-import { inject } from '@noxfly/noxus';
+import { inject } from '@noxfly/noxus/main';
 import { MyClass } from 'src/myclass';
 
 const instance: MyClass = inject(MyClass);
@@ -407,7 +409,7 @@ Declare middlewares as follow :
 ```ts
 // renderer/middlewares.ts
 
-import { IMiddleware, Injectable, Request, IResponse, NextFunction } from '@noxfly/noxus';
+import { IMiddleware, Injectable, Request, IResponse, NextFunction } from '@noxfly/noxus/main';
 
 @Injectable()
 export class MiddlewareA implements IMiddleware {
@@ -481,6 +483,64 @@ A -> B -> C -> D -> AuthGuard -> RoleGuard -> [action] -> D -> C -> B -> A.
 
 if a middleware throw any exception or put the response status higher or equal to 400, the pipeline immediatly stops and the response is returned, weither it is done before or after the call to the next function.
 
+
+
+
+
+## Listening to events from the main process
+
+Starting from v1.2, the main process can push messages to renderer processes without the request/response flow.
+
+```ts
+// main/users/users.controller.ts
+import { Controller, Post, Request, NoxSocket } from '@noxfly/noxus/main';
+
+@Controller('users')
+export class UsersController {
+    constructor(private readonly socket: NoxSocket) {}
+
+    @Post('create')
+    public async create(request: Request): Promise<void> {
+        const payload = { nickname: request.body.nickname };
+
+        this.socket.emitToRenderer(request.event.senderId, 'users:created', payload);
+        // or broadcast to every connected renderer: this.socket.emit('users:created', payload);
+    }
+}
+```
+
+On the renderer side, leverage the `RendererEventRegistry` to register and clean up listeners. The registry only handles push events, so it plays nicely with the existing request handling code above.
+
+```ts
+import { RendererEventRegistry, RendererEventSubscription } from '@noxfly/noxus';
+
+private readonly events = new RendererEventRegistry();
+
+constructor() {
+    // ... after the MessagePort is ready
+    this.port.onmessage = (event) => {
+        if(this.events.tryDispatchFromMessageEvent(event)) {
+            return;
+        }
+
+        this.onMessage(event); // existing request handling
+    };
+}
+
+public onUsersCreated(): RendererEventSubscription {
+    return this.events.subscribe('users:created', (payload) => {
+        // react to the event
+    });
+}
+
+public teardown(): void {
+    this.events.clear();
+}
+```
+
+
+
+
 ## Contributing
 
 1. Clone the repo

package/dist/index-5OkVPHfI.d.mts

@@ -0,0 +1,268 @@
+/**
+ * @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>;
+
+
+/**
+ * IGuard interface defines a guard that can be used to protect routes.
+ * It has a `canActivate` method that takes a request and returns a MaybeAsync boolean.
+ * The `canActivate` method can return either a value or a Promise.
+ * Use it on a class that should be registered as a guard in the application.
+ * Guards can be used to protect routes or controller actions.
+ * For example, you can use guards to check if the user is authenticated or has the right permissions.
+ * You can use the `Authorize` decorator to register guards for a controller or a controller action.
+ * @see Authorize
+ */
+interface IGuard {
+    canActivate(request: Request): MaybeAsync<boolean>;
+}
+/**
+ * Can be used to protect the routes of a controller.
+ * Can be used on a controller class or on a controller method.
+ */
+declare function Authorize(...guardClasses: Type<IGuard>[]): MethodDecorator & ClassDecorator;
+/**
+ * Gets the guards for a controller or a controller action.
+ * @param controllerName The name of the controller to get the guards for.
+ * @returns An array of guards for the controller.
+ */
+declare function getGuardForController(controllerName: string): Type<IGuard>[];
+/**
+ * Gets the guards for a controller action.
+ * @param controllerName The name of the controller to get the guards for.
+ * @param actionName The name of the action to get the guards for.
+ * @returns An array of guards for the controller action.
+ */
+declare function getGuardForControllerAction(controllerName: string, actionName: string): Type<IGuard>[];
+
+
+/**
+ * IRouteMetadata interface defines the metadata for a route.
+ * It includes the HTTP method, path, handler name, and guards associated with the route.
+ * This metadata is used to register the route in the application.
+ * This is the configuration that waits a route's decorator.
+ */
+interface IRouteMetadata {
+    method: HttpMethod;
+    path: string;
+    handler: string;
+    guards: Type<IGuard>[];
+}
+/**
+ * The different HTTP methods that can be used in the application.
+ */
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'BATCH';
+/**
+ * Atomic HTTP verbs supported by controllers. BATCH is handled at the router level only.
+ */
+type AtomicHttpMethod = Exclude<HttpMethod, 'BATCH'>;
+/**
+ * Gets the route metadata for a given target class.
+ * This metadata includes the HTTP method, path, handler, and guards defined by the route decorators.
+ * @see Get
+ * @see Post
+ * @see Put
+ * @see Patch
+ * @see Delete
+ * @param target The target class to get the route metadata from.
+ * @returns An array of route metadata if it exists, otherwise an empty array.
+ */
+declare function getRouteMetadata(target: Type<unknown>): IRouteMetadata[];
+/**
+ * Route decorator that defines a leaf in the routing tree, attaching it to a controller method
+ * that will be called when the route is matched.
+ * This route will have to be called with the GET method.
+ */
+declare const Get: (path: string) => MethodDecorator;
+/**
+ * Route decorator that defines a leaf in the routing tree, attaching it to a controller method
+ * that will be called when the route is matched.
+ * This route will have to be called with the POST method.
+ */
+declare const Post: (path: string) => MethodDecorator;
+/**
+ * Route decorator that defines a leaf in the routing tree, attaching it to a controller method
+ * that will be called when the route is matched.
+ * This route will have to be called with the PUT method.
+ */
+declare const Put: (path: string) => MethodDecorator;
+/**
+ * Route decorator that defines a leaf in the routing tree, attaching it to a controller method
+ * that will be called when the route is matched.
+ * This route will have to be called with the PATCH method.
+ */
+declare const Patch: (path: string) => MethodDecorator;
+/**
+ * Route decorator that defines a leaf in the routing tree, attaching it to a controller method
+ * that will be called when the route is matched.
+ * This route will have to be called with the DELETE method.
+ */
+declare const Delete: (path: string) => MethodDecorator;
+declare const ROUTE_METADATA_KEY: unique symbol;
+
+
+/**
+ * Represents a lifetime of a binding in the dependency injection system.
+ * It can be one of the following:
+ * - 'singleton': The instance is created once and shared across the application.
+ * - 'scope': The instance is created once per scope (e.g., per request).
+ * - 'transient': A new instance is created every time it is requested.
+ */
+type Lifetime = 'singleton' | 'scope' | 'transient';
+/**
+ * Represents a binding in the dependency injection system.
+ * It contains the lifetime of the binding, the implementation type, and optionally an instance.
+ */
+interface IBinding {
+    lifetime: Lifetime;
+    implementation: Type<unknown>;
+    instance?: InstanceType<Type<unknown>>;
+}
+/**
+ * AppInjector is the root dependency injection container.
+ * It is used to register and resolve dependencies in the application.
+ * It supports different lifetimes for dependencies:
+ * This should not be manually instantiated, outside of the framework.
+ * Use the `RootInjector` instance instead.
+ */
+declare class AppInjector {
+    readonly name: string | null;
+    bindings: Map<Type<unknown>, IBinding>;
+    singletons: Map<Type<unknown>, unknown>;
+    scoped: Map<Type<unknown>, unknown>;
+    constructor(name?: string | null);
+    /**
+     * Typically used to create a dependency injection scope
+     * at the "scope" level (i.e., per-request lifetime).
+     *
+     * SHOULD NOT BE USED by anything else than the framework itself.
+     */
+    createScope(): AppInjector;
+    /**
+     * Called when resolving a dependency,
+     * i.e., retrieving the instance of a given class.
+     */
+    resolve<T extends Type<unknown>>(target: T): InstanceType<T>;
+    /**
+     *
+     */
+    private instantiate;
+}
+/**
+ * Injects a type from the dependency injection system.
+ * This function is used to retrieve an instance of a type that has been registered in the dependency injection system.
+ * It is typically used in the constructor of a class to inject dependencies.
+ * @param t - The type to inject.
+ * @returns An instance of the type.
+ * @throws If the type is not registered in the dependency injection system.
+ */
+declare function inject<T>(t: Type<T>): T;
+declare const RootInjector: AppInjector;
+
+
+/**
+ * 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 id: string;
+    readonly method: HttpMethod;
+    readonly path: string;
+    readonly body: any;
+    readonly context: AppInjector;
+    readonly params: Record<string, string>;
+    constructor(event: Electron.MessageEvent, id: string, method: HttpMethod, path: string, body: any);
+}
+/**
+ * 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;
+}
+interface IBatchRequestItem<TBody = unknown> {
+    requestId?: string;
+    path: string;
+    method: AtomicHttpMethod;
+    body?: TBody;
+}
+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;
+
+/**
+ * Lightweight event registry to help renderer processes subscribe to
+ * push messages sent by the main process through Noxus.
+ */
+
+type RendererEventHandler<TPayload = unknown> = (payload: TPayload) => void;
+interface RendererEventSubscription {
+    unsubscribe(): void;
+}
+declare class RendererEventRegistry {
+    private readonly listeners;
+    /**
+     *
+     */
+    subscribe<TPayload>(eventName: string, handler: RendererEventHandler<TPayload>): RendererEventSubscription;
+    /**
+     *
+     */
+    unsubscribe<TPayload>(eventName: string, handler: RendererEventHandler<TPayload>): void;
+    /**
+     *
+     */
+    clear(eventName?: string): void;
+    /**
+     *
+     */
+    dispatch<TPayload>(message: IRendererEventMessage<TPayload>): void;
+    /**
+     *
+     */
+    tryDispatchFromMessageEvent(event: MessageEvent): boolean;
+    /**
+     *
+     */
+    hasHandlers(eventName: string): boolean;
+}
+
+export { AppInjector as A, Delete as D, Get as G, type HttpMethod as H, type IResponse as I, type Lifetime as L, type MaybeAsync as M, Post as P, Request as R, type Type as T, type IGuard as a, type IBinding as b, RootInjector as c, Authorize as d, getGuardForControllerAction as e, type IRouteMetadata as f, getGuardForController as g, type AtomicHttpMethod as h, inject as i, getRouteMetadata as j, Put as k, Patch as l, ROUTE_METADATA_KEY as m, type IRequest as n, type IBatchRequestItem as o, type IBatchRequestPayload as p, type IBatchResponsePayload as q, RENDERER_EVENT_TYPE as r, type IRendererEventMessage as s, createRendererEventMessage as t, isRendererEventMessage as u, type RendererEventHandler as v, type RendererEventSubscription as w, RendererEventRegistry as x };

package/dist/index-5OkVPHfI.d.ts

@@ -0,0 +1,268 @@
+/**
+ * @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>;
+
+
+/**
+ * IGuard interface defines a guard that can be used to protect routes.
+ * It has a `canActivate` method that takes a request and returns a MaybeAsync boolean.
+ * The `canActivate` method can return either a value or a Promise.
+ * Use it on a class that should be registered as a guard in the application.
+ * Guards can be used to protect routes or controller actions.
+ * For example, you can use guards to check if the user is authenticated or has the right permissions.
+ * You can use the `Authorize` decorator to register guards for a controller or a controller action.
+ * @see Authorize
+ */
+interface IGuard {
+    canActivate(request: Request): MaybeAsync<boolean>;
+}
+/**
+ * Can be used to protect the routes of a controller.
+ * Can be used on a controller class or on a controller method.
+ */
+declare function Authorize(...guardClasses: Type<IGuard>[]): MethodDecorator & ClassDecorator;
+/**
+ * Gets the guards for a controller or a controller action.
+ * @param controllerName The name of the controller to get the guards for.
+ * @returns An array of guards for the controller.
+ */
+declare function getGuardForController(controllerName: string): Type<IGuard>[];
+/**
+ * Gets the guards for a controller action.
+ * @param controllerName The name of the controller to get the guards for.
+ * @param actionName The name of the action to get the guards for.
+ * @returns An array of guards for the controller action.
+ */
+declare function getGuardForControllerAction(controllerName: string, actionName: string): Type<IGuard>[];
+
+
+/**
+ * IRouteMetadata interface defines the metadata for a route.
+ * It includes the HTTP method, path, handler name, and guards associated with the route.
+ * This metadata is used to register the route in the application.
+ * This is the configuration that waits a route's decorator.
+ */
+interface IRouteMetadata {
+    method: HttpMethod;
+    path: string;
+    handler: string;
+    guards: Type<IGuard>[];
+}
+/**
+ * The different HTTP methods that can be used in the application.
+ */
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'BATCH';
+/**
+ * Atomic HTTP verbs supported by controllers. BATCH is handled at the router level only.
+ */
+type AtomicHttpMethod = Exclude<HttpMethod, 'BATCH'>;
+/**
+ * Gets the route metadata for a given target class.
+ * This metadata includes the HTTP method, path, handler, and guards defined by the route decorators.
+ * @see Get
+ * @see Post
+ * @see Put
+ * @see Patch
+ * @see Delete
+ * @param target The target class to get the route metadata from.
+ * @returns An array of route metadata if it exists, otherwise an empty array.
+ */
+declare function getRouteMetadata(target: Type<unknown>): IRouteMetadata[];
+/**
+ * Route decorator that defines a leaf in the routing tree, attaching it to a controller method
+ * that will be called when the route is matched.
+ * This route will have to be called with the GET method.
+ */
+declare const Get: (path: string) => MethodDecorator;
+/**
+ * Route decorator that defines a leaf in the routing tree, attaching it to a controller method
+ * that will be called when the route is matched.
+ * This route will have to be called with the POST method.
+ */
+declare const Post: (path: string) => MethodDecorator;
+/**
+ * Route decorator that defines a leaf in the routing tree, attaching it to a controller method
+ * that will be called when the route is matched.
+ * This route will have to be called with the PUT method.
+ */
+declare const Put: (path: string) => MethodDecorator;
+/**
+ * Route decorator that defines a leaf in the routing tree, attaching it to a controller method
+ * that will be called when the route is matched.
+ * This route will have to be called with the PATCH method.
+ */
+declare const Patch: (path: string) => MethodDecorator;
+/**
+ * Route decorator that defines a leaf in the routing tree, attaching it to a controller method
+ * that will be called when the route is matched.
+ * This route will have to be called with the DELETE method.
+ */
+declare const Delete: (path: string) => MethodDecorator;
+declare const ROUTE_METADATA_KEY: unique symbol;
+
+
+/**
+ * Represents a lifetime of a binding in the dependency injection system.
+ * It can be one of the following:
+ * - 'singleton': The instance is created once and shared across the application.
+ * - 'scope': The instance is created once per scope (e.g., per request).
+ * - 'transient': A new instance is created every time it is requested.
+ */
+type Lifetime = 'singleton' | 'scope' | 'transient';
+/**
+ * Represents a binding in the dependency injection system.
+ * It contains the lifetime of the binding, the implementation type, and optionally an instance.
+ */
+interface IBinding {
+    lifetime: Lifetime;
+    implementation: Type<unknown>;
+    instance?: InstanceType<Type<unknown>>;
+}
+/**
+ * AppInjector is the root dependency injection container.
+ * It is used to register and resolve dependencies in the application.
+ * It supports different lifetimes for dependencies:
+ * This should not be manually instantiated, outside of the framework.
+ * Use the `RootInjector` instance instead.
+ */
+declare class AppInjector {
+    readonly name: string | null;
+    bindings: Map<Type<unknown>, IBinding>;
+    singletons: Map<Type<unknown>, unknown>;
+    scoped: Map<Type<unknown>, unknown>;
+    constructor(name?: string | null);
+    /**
+     * Typically used to create a dependency injection scope
+     * at the "scope" level (i.e., per-request lifetime).
+     *
+     * SHOULD NOT BE USED by anything else than the framework itself.
+     */
+    createScope(): AppInjector;
+    /**
+     * Called when resolving a dependency,
+     * i.e., retrieving the instance of a given class.
+     */
+    resolve<T extends Type<unknown>>(target: T): InstanceType<T>;
+    /**
+     *
+     */
+    private instantiate;
+}
+/**
+ * Injects a type from the dependency injection system.
+ * This function is used to retrieve an instance of a type that has been registered in the dependency injection system.
+ * It is typically used in the constructor of a class to inject dependencies.
+ * @param t - The type to inject.
+ * @returns An instance of the type.
+ * @throws If the type is not registered in the dependency injection system.
+ */
+declare function inject<T>(t: Type<T>): T;
+declare const RootInjector: AppInjector;
+
+
+/**
+ * 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 id: string;
+    readonly method: HttpMethod;
+    readonly path: string;
+    readonly body: any;
+    readonly context: AppInjector;
+    readonly params: Record<string, string>;
+    constructor(event: Electron.MessageEvent, id: string, method: HttpMethod, path: string, body: any);
+}
+/**
+ * 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;
+}
+interface IBatchRequestItem<TBody = unknown> {
+    requestId?: string;
+    path: string;
+    method: AtomicHttpMethod;
+    body?: TBody;
+}
+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;
+
+/**
+ * Lightweight event registry to help renderer processes subscribe to
+ * push messages sent by the main process through Noxus.
+ */
+
+type RendererEventHandler<TPayload = unknown> = (payload: TPayload) => void;
+interface RendererEventSubscription {
+    unsubscribe(): void;
+}
+declare class RendererEventRegistry {
+    private readonly listeners;
+    /**
+     *
+     */
+    subscribe<TPayload>(eventName: string, handler: RendererEventHandler<TPayload>): RendererEventSubscription;
+    /**
+     *
+     */
+    unsubscribe<TPayload>(eventName: string, handler: RendererEventHandler<TPayload>): void;
+    /**
+     *
+     */
+    clear(eventName?: string): void;
+    /**
+     *
+     */
+    dispatch<TPayload>(message: IRendererEventMessage<TPayload>): void;
+    /**
+     *
+     */
+    tryDispatchFromMessageEvent(event: MessageEvent): boolean;
+    /**
+     *
+     */
+    hasHandlers(eventName: string): boolean;
+}
+
+export { AppInjector as A, Delete as D, Get as G, type HttpMethod as H, type IResponse as I, type Lifetime as L, type MaybeAsync as M, Post as P, Request as R, type Type as T, type IGuard as a, type IBinding as b, RootInjector as c, Authorize as d, getGuardForControllerAction as e, type IRouteMetadata as f, getGuardForController as g, type AtomicHttpMethod as h, inject as i, getRouteMetadata as j, Put as k, Patch as l, ROUTE_METADATA_KEY as m, type IRequest as n, type IBatchRequestItem as o, type IBatchRequestPayload as p, type IBatchResponsePayload as q, RENDERER_EVENT_TYPE as r, type IRendererEventMessage as s, createRendererEventMessage as t, isRendererEventMessage as u, type RendererEventHandler as v, type RendererEventSubscription as w, RendererEventRegistry as x };