Concrete IMetadataStore. Decorators call the merge*/add* methods; the DecoratorPlugin and other consumers read the readonly controllers, services, and routes maps.

Describes the OpenAPI operation for a route handler.

Documents a response status for a route handler. May be applied multiple times to describe several responses.

Assigns OpenAPI tags to a controller. Tags are inherited by every route in the controller and merged with any method-level tags.

Binds the parsed JSON request body.

Removes a registered custom parameter resolver (intended for tests).

Marks a class as a controller and assigns a base path prefix for all its routes.

Binds a cookie value parsed from the Cookie request header.

Creates a custom class or method decorator that stores metadata readable by the DecoratorPlugin and custom decorator handlers.

Binds the active request context — for a handler that sets its own status code, adds a header, or returns a streaming response.

Binds the authenticated principal (ctx.request.user).

Binds a value produced by an application-registered resolver.

Creates the DecoratorPlugin.

Discovers decorated classes by scanning a directory and importing files.

Returns the resolver registered for a custom parameter type, if any.

Binds a request header value.

Declares the constructor injection tokens for a class, one per constructor argument in argument order. The DecoratorPlugin resolves each token (from the DI container or the service registry) and passes the results to the constructor.

Marks a class as injectable (eligible for DI container registration). When the DecoratorPlugin runs, injectable classes in its services list (or discovered) are registered with the DI container when present, or instantiated directly otherwise.

Groups controllers and providers under one class.

Marks a constructor dependency as optional: when the token has no provider, the argument receives undefined instead of failing construction.

Binds a path parameter.

Binds handler arguments to request sources, positionally.

Parses cookies from a Cookie request header into a name→value record.

Requires the authenticated principal to hold any of the given permissions. May be applied at the class or method level (method overrides class).

Marks an unrestricted route as public in the OpenAPI document: its schema carries security: [], so a document-level security requirement does not apply to it.

Binds the whole query record.

Registers a resolver for a custom parameter type created with a Custom(name) source. current-user resolves directly; Ctx() uses an internal marker and also resolves directly. Application custom parameter types, including one named context, use this registry.

A handler may also return a HandlerResult from ctx.response — a redirect, most usefully — instead of the props bag. That is what makes POST-redirect-GET expressible on a rendered route: a form handler returns the props to re-render itself with errors, or ctx.response.redirect(...) once the submission is accepted. HandlerResult is branded (__handlerResult: true), so widening the union costs nothing: a props bag of the wrong shape is still a compile error.

Resolves a single parameter value from the request context. The result may be a promise (for body and custom resolvers); callers should await it.

Resolves an ordered argument array for a handler from its parameter metadata. Arguments are placed by parameter index, so undecorated parameters receive undefined.

Requires the authenticated principal to hold any of the given roles. May be applied at the class level (default for all routes) or method level (overrides the class default).

Attaches error filters to a controller or route. Filters run last in the route middleware chain.

Attaches guards to a controller or route. Guards run before the handler and may short-circuit by responding without calling next().

Attaches interceptors to a controller or route. Interceptors wrap the handler invocation (pre- and post-processing via next()).

Attaches a request body schema to the decorated route handler.

Attaches a path parameter schema to the decorated route handler.

Attaches a query parameter schema to the decorated route handler.

Assigns an API version prefix to a controller. Combined with @Controller, the effective path is version + basePath + routePath (e.g. '/v1/users').

Configuration for ApiOperation.

Configuration for ApiResponse.

Options for DecoratorPlugin.

Discovery configuration.

Result of a discovery scan.

Options for Injectable.

What a @Module declares.

A token marked optional by Optional.

Metadata captured by a parameter decorator, later resolved by the resolveParameters function.

A declaration of where one handler argument comes from.

Resolves a custom parameter value (from a Custom(name) source) at request time.

A factory producing a method decorator that registers a route for a given HTTP verb.

A constructor dependency: a capability token, or a token wrapped by Optional.

A middleware value accepted by pipeline decorators: either a bare MiddlewareFunction or a class implementing IMiddleware.

Loads a module from a specifier. Defaults to the global dynamic import; injectable for tests.

Where a request parameter is sourced from.

The decorator Render(Component) returns: assignable to a handler whose return is the component's props bag, sync or async, with any parameter list. A handler returning the WRONG shape fails compilation naming the mismatch — strictly stronger than NestJS's @Render('users/index'), a string checked against nothing.

A standard class decorator that records metadata and leaves the class as it is. Returning nothing means the class is never replaced, which is what keeps a decorated class identical to its undecorated self at runtime.

A standard decorator valid in either the class or the method position, discriminating on context.kind.

A standard method decorator that records metadata and leaves the method as it is.

Maps a tuple of sources onto the handler parameter tuple they bind.

Registers a DELETE route on the decorated method.

Registers a GET route on the decorated method.

Registers a HEAD route on the decorated method.

The process-wide singleton decorators write to. The DecoratorPlugin registers this same instance under CAPABILITIES.METADATA_STORE so ctx.metadata resolves to it.

Registers an OPTIONS route on the decorated method.

Registers a PATCH route on the decorated method.

Registers a POST route on the decorated method.

Registers a PUT route on the decorated method.