node-honest 0.0.1 → 0.1.0

package/dist/index.d.ts

@@ -1,16 +1,1539 @@
-import 'reflect-metadata';
-export * from './application';
-export * from './application-context';
-export * from './components';
-export * from './constants';
-export * from './decorators';
-export * from './loggers';
-export * from './di';
-export * from './errors';
-export * from './handlers';
-export * from './helpers';
-export * from './interfaces';
-export * from './registries';
-export * from './testing';
-export * from './types';
-export * from './utils';
+import * as hono from 'hono';
+import { Context as Context$1, Next, Hono } from 'hono';
+import * as hono_utils_html from 'hono/utils/html';
+import { PropsWithChildren } from 'hono/jsx';
+import { ContentfulStatusCode } from 'hono/utils/http-status';
+
+/**
+ * App-level registry where your application can publish and read pipeline data by key.
+ * Available to bootstrap code, services, and any code with access to `app`.
+ * Enables composition without hard coupling: producers and consumers use namespaced keys.
+ */
+interface IApplicationContext {
+    /**
+     * Get a value by key. Caller provides type for type safety.
+     * @param key - Namespaced registry key (e.g. 'app.config', 'openapi.spec')
+     * @returns The value or undefined if not set
+     */
+    get<T>(key: string): T | undefined;
+    /**
+     * Set a value by key.
+     * @param key - Namespaced registry key
+     * @param value - Value to store
+     */
+    set<T>(key: string, value: T): void;
+    /**
+     * Check if a key is present.
+     * @param key - Registry key
+     * @returns true if the key exists
+     */
+    has(key: string): boolean;
+    /**
+     * Remove a key and its value.
+     * @param key - Registry key
+     * @returns true if the key existed and was removed
+     */
+    delete(key: string): boolean;
+    /**
+     * Iterate over all registered keys.
+     */
+    keys(): IterableIterator<string>;
+}
+
+/**
+ * Symbol to use when marking a route as version-neutral
+ * Version-neutral routes are accessible both with and without version prefix
+ */
+declare const VERSION_NEUTRAL: unique symbol;
+
+/**
+ * Internal request-context keys used by the Honest runtime pipeline.
+ */
+declare const HONEST_PIPELINE_CONTROLLER_KEY = "__honest_controllerClass";
+declare const HONEST_PIPELINE_HANDLER_KEY = "__honest_handlerName";
+declare const HONEST_PIPELINE_BODY_CACHE_KEY = "__honest.body.cache";
+
+/**
+ * Interface for controller configuration options
+ */
+interface ControllerOptions {
+    /**
+     * API prefix for this controller's routes, overrides global prefix
+     */
+    prefix?: string | null;
+    /**
+     * API version for this controller's routes (e.g. 1 becomes /v1), overrides global version
+     * Set to null to explicitly opt out of versioning even when global version is set
+     * Set to VERSION_NEUTRAL to make routes accessible both with and without version prefix
+     * Set to an array of numbers to make routes available at multiple versions
+     */
+    version?: number | null | typeof VERSION_NEUTRAL | number[];
+}
+
+/**
+ * Represents a class constructor type
+ * Used throughout the framework for type-safe dependency injection and component registration
+ *
+ * @template T - The type of instance that the constructor creates
+ * @example
+ * ```ts
+ * class MyService {}
+ * const myConstructor: Constructor<MyService> = MyService;
+ * ```
+ */
+type Constructor<T = any> = new (...args: any[]) => T;
+
+/**
+ * Interface for dependency injection containers
+ * Defines the contract that DI containers must implement to work with the Honest framework
+ * Handles the creation and management of dependency instances
+ */
+interface DiContainer {
+    /**
+     * Resolves a dependency from the container
+     * Creates a new instance or returns an existing one based on the container's configuration
+     * @param target - The class constructor to resolve
+     * @returns An instance of the requested class with all dependencies injected
+     * @throws {Error} If the dependency cannot be resolved
+     */
+    resolve<T>(target: Constructor<T>): T;
+    /**
+     * Registers a pre-created instance in the container
+     * Used for singleton instances or mocks in testing
+     * @param target - The class constructor to register the instance for
+     * @param instance - The pre-created instance to use
+     * @throws {Error} If registration fails
+     */
+    register<T>(target: Constructor<T>, instance: T): void;
+    /**
+     * Checks whether the container already holds an instance for the given class
+     * @param target - The class constructor to check
+     * @returns true if an instance has been resolved or registered
+     */
+    has<T>(target: Constructor<T>): boolean;
+    /**
+     * Removes all cached instances from the container
+     * Useful for resetting state between tests
+     */
+    clear(): void;
+}
+
+/**
+ * Log level.
+ */
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Log category used to filter or route events.
+ */
+type LogCategory = 'startup' | 'routes' | 'plugins' | 'deprecations' | 'pipeline' | 'di' | 'errors';
+/**
+ * Structured log event emitted by Honest runtime components.
+ */
+interface LogEvent {
+    level: LogLevel;
+    category: LogCategory;
+    message: string;
+    details?: Record<string, unknown>;
+}
+/**
+ * Logger contract.
+ */
+interface ILogger {
+    emit(event: LogEvent): void;
+}
+
+interface ErrorResponse {
+    status: number;
+    message: string;
+    timestamp: string;
+    path: string;
+    requestId?: string;
+    code?: string;
+    details?: Record<string, any>;
+    errors?: Array<{
+        property: string;
+        constraints: Record<string, string>;
+    }>;
+}
+
+/**
+ * Interface for exception filters
+ * Filters handle and transform exceptions thrown during request processing
+ */
+interface IFilter {
+    /**
+     * Method to catch and handle exceptions
+     * @param exception - The exception that was thrown
+     * @param context - The Hono context object
+     * @returns A Response object or undefined if the exception should be passed to the next filter
+     */
+    catch(exception: Error, context: Context$1): Promise<Response | undefined> | Response | undefined;
+}
+/**
+ * Type for exception filters
+ * Can be either a class implementing IFilter or an instance of IFilter
+ */
+type FilterType = Constructor<IFilter> | IFilter;
+
+/**
+ * Interface defining a guard.
+ * Guards determine whether a request should be handled by the route handler or not.
+ */
+interface IGuard {
+    /**
+     * Method to implement the guard logic.
+     * Return true to allow the request to proceed, false to deny.
+     *
+     * @param context - The Hono context object
+     * @returns A boolean or Promise<boolean> indicating if the request is allowed
+     */
+    canActivate(context: Context$1): boolean | Promise<boolean>;
+}
+/**
+ * Type for guard classes
+ * Can be either a constructor of IGuard or an instance of IGuard
+ */
+type GuardType = Constructor<IGuard> | IGuard;
+
+/**
+ * Input contract for invoking route handlers and mapping results to HTTP responses.
+ */
+interface HandlerInvocationInput {
+    handler: (...args: unknown[]) => Promise<unknown> | unknown;
+    args: unknown[];
+    context: Context$1;
+    contextIndex?: number;
+}
+
+/**
+ * Options for configuring the Honest application
+ */
+interface HonestOptions {
+    /**
+     * Emit actionable startup guidance when initialization fails.
+     * - `true` enables concise hints
+     * - object form enables verbose hints with additional context
+     */
+    startupGuide?: boolean | {
+        verbose?: boolean;
+    };
+    /**
+     * Enable debug logging for startup diagnostics.
+     * - `true` enables all debug logs
+     * - object form enables specific categories
+     */
+    debug?: boolean | {
+        routes?: boolean;
+        plugins?: boolean;
+        pipeline?: boolean;
+        di?: boolean;
+        startup?: boolean;
+    };
+    /**
+     * Optional logger for structured framework events.
+     */
+    logger?: ILogger;
+    /**
+     * Optional strict-mode checks for startup validation.
+     */
+    strict?: {
+        /**
+         * When enabled, startup fails if no routes were registered.
+         */
+        requireRoutes?: boolean;
+    };
+    /**
+     * Optional warnings for unstable/deprecated behavior.
+     */
+    deprecations?: {
+        /**
+         * Print pre-v1 instability warning during startup.
+         */
+        printPreV1Warning?: boolean;
+    };
+    /**
+     * Container instance for dependency injection
+     */
+    container?: DiContainer;
+    /**
+     * Hono-specific options
+     */
+    hono?: {
+        /**
+         * Whether to use strict matching for routes
+         */
+        strict?: boolean;
+        /**
+         * Custom router to use
+         */
+        router?: any;
+        /**
+         * Function to extract path from request
+         */
+        getPath?: (request: Request, options?: any) => string;
+    };
+    /**
+     * Global routing options
+     */
+    routing?: {
+        /**
+         * Global API prefix to apply to all routes (e.g. /api)
+         */
+        prefix?: string;
+        /**
+         * Global API version to apply to all routes (e.g. 1 becomes /v1)
+         * Set to VERSION_NEUTRAL to make routes accessible both with and without version prefix
+         * Set to an array of numbers to make routes available at multiple versions
+         */
+        version?: number | typeof VERSION_NEUTRAL | number[];
+    };
+    /**
+     * Global components to apply to all routes
+     */
+    components?: {
+        /**
+         * Global middleware to apply to all routes
+         */
+        middleware?: MiddlewareType[];
+        /**
+         * Global guards to apply to all routes
+         */
+        guards?: GuardType[];
+        /**
+         * Global pipes to apply to all routes
+         */
+        pipes?: PipeType[];
+        /**
+         * Global exception filters to apply to all routes
+         */
+        filters?: FilterType[];
+    };
+    /**
+     * Plugins for extending the application functionality.
+     * Each entry can be a plain plugin or an object with plugin and optional pre/post processors.
+     */
+    plugins?: PluginEntry[];
+    /**
+     * Default exception handler to use when no filter matches
+     */
+    onError?: (error: unknown, context: Context$1) => Response | Promise<Response>;
+    /**
+     * Default not found handler for routes that don't match any pattern
+     */
+    notFound?: (context: Context$1) => Response | Promise<Response>;
+}
+
+/**
+ * Options for HTTP method decorators (@Get, @Post, @Put, @Delete, etc.)
+ *
+ * @example
+ * ```typescript
+ * @Get('users', { prefix: 'api', version: 2 })
+ * getUsers() {
+ *   // ...
+ * }
+ * ```
+ */
+interface HttpMethodOptions {
+    /**
+     * Optional prefix for this specific route, overrides controller and global prefix.
+     * Set to null to explicitly remove any prefix for this route.
+     *
+     * @example
+     * ```typescript
+     * @Get('users', { prefix: 'api' })     // -> /api/users
+     * @Get('users', { prefix: null })      // -> /users (no prefix)
+     * @Get('users', { prefix: 'v2/api' })  // -> /v2/api/users
+     * ```
+     */
+    prefix?: string | null;
+    /**
+     * API version for this specific route, overrides controller and global version.
+     *
+     * @example
+     * ```typescript
+     * @Get('users', { version: 1 })           // -> /v1/users
+     * @Get('users', { version: null })        // -> /users (no version)
+     * @Get('users', { version: VERSION_NEUTRAL }) // -> Both /users and /v1/users
+     * @Get('users', { version: [1, 2] })     // -> Both /v1/users and /v2/users
+     * ```
+     */
+    version?: number | null | typeof VERSION_NEUTRAL | number[];
+}
+
+/**
+ * Interface for HTTP middleware components
+ * Middleware can process requests before they reach the route handler
+ * and modify both the request and response
+ */
+interface IMiddleware {
+    /**
+     * Processes an HTTP request/response
+     * @param c - The Hono context containing request and response information
+     * @param next - Function to call the next middleware in the chain
+     * @returns A Promise that resolves to a Response or void
+     * @throws {Error} If middleware processing fails
+     */
+    use(c: Context$1, next: Next): Promise<Response | void>;
+}
+/**
+ * Type for middleware implementations
+ * Can be either a class implementing IMiddleware or an instance of IMiddleware
+ */
+type MiddlewareType = Constructor<IMiddleware> | IMiddleware;
+
+/**
+ * Options for configuring a module
+ */
+interface ModuleOptions {
+    /**
+     * List of controller classes
+     */
+    controllers?: Constructor[];
+    /**
+     * List of service classes
+     */
+    services?: Constructor[];
+    /**
+     * List of imported modules
+     */
+    imports?: Constructor[];
+}
+
+/**
+ * Metadata for route parameters
+ */
+interface ParameterMetadata {
+    /**
+     * Parameter index
+     */
+    index: number;
+    /**
+     * Parameter name (body, param, query, etc.)
+     */
+    name: string;
+    /**
+     * Additional parameter data (e.g., param name)
+     */
+    data?: unknown;
+    /**
+     * Optional factory function to transform the data
+     */
+    factory: (data: unknown, ctx: Context$1) => unknown | Promise<unknown>;
+    /**
+     * The class type of the parameter
+     */
+    metatype?: Constructor<unknown>;
+}
+
+/**
+ * Metadata about an argument being processed by a pipe
+ */
+interface ArgumentMetadata {
+    /**
+     * The type of argument (body, query, param, header, request, response, context, variable, or custom)
+     */
+    type: 'body' | 'query' | 'param' | 'header' | 'request' | 'response' | 'context' | 'variable' | string;
+    /**
+     * The class type of the argument
+     */
+    metatype?: Constructor<unknown>;
+    /**
+     * Additional data about the argument
+     */
+    data?: string;
+}
+/**
+ * Interface for transformation pipes
+ * Pipes transform input data before it reaches the route handler
+ */
+interface IPipe {
+    /**
+     * Transforms the input value according to the pipe's logic
+     * @param value - The value to transform
+     * @param metadata - Metadata about the argument being transformed
+     * @returns The transformed value, which can be synchronous or asynchronous
+     * @throws {Error} If the transformation fails or validation fails
+     */
+    transform(value: unknown, metadata: ArgumentMetadata): Promise<unknown> | unknown;
+}
+/**
+ * Type for pipe implementations
+ * Can be either a class implementing IPipe or an instance of IPipe
+ */
+type PipeType = Constructor<IPipe> | IPipe;
+
+/**
+ * Internal metadata for defining a route. This interface is used by the framework
+ * to store route information collected from decorators.
+ *
+ * @example
+ * ```typescript
+ * // Internal representation of:
+ * @Controller('users')
+ * class UsersController {
+ *   @Get(':id')
+ *   getUser(@Param('id') id: string) {}
+ * }
+ * ```
+ */
+interface RouteDefinition {
+    /**
+     * Route path relative to the controller's base path.
+     * Supports path parameters using colon syntax.
+     *
+     * @example ':id' | 'users/:userId/posts/:postId' | ''
+     */
+    path: string;
+    /**
+     * HTTP method for the route (GET, POST, PUT, DELETE, etc.)
+     */
+    method: string;
+    /**
+     * Name of the method in the controller class that handles this route
+     */
+    handlerName: string | symbol;
+    /**
+     * Route-specific API version, overrides controller and global version.
+     *
+     * @example
+     * ```typescript
+     * version: 1              // -> /v1/...
+     * version: null          // -> /... (no version)
+     * version: VERSION_NEUTRAL // -> Both /... and /v1/...
+     * version: [1, 2]       // -> Both /v1/... and /v2/...
+     * ```
+     */
+    version?: number | null | typeof VERSION_NEUTRAL | number[];
+    /**
+     * Route-specific prefix that overrides controller and global prefix.
+     * Set to null to explicitly remove any prefix.
+     *
+     * @example 'api' | 'v2/api' | null
+     */
+    prefix?: string | null;
+}
+
+type MetadataComponentType = 'middleware' | 'guard' | 'pipe' | 'filter';
+interface MetadataComponentTypeMap {
+    middleware: MiddlewareType;
+    guard: GuardType;
+    pipe: PipeType;
+    filter: FilterType;
+}
+/**
+ * Runtime metadata access contract used by framework managers.
+ */
+interface IMetadataRepository {
+    hasController(controller: Constructor): boolean;
+    getControllerPath(controller: Constructor): string;
+    getControllerOptions(controller: Constructor): ControllerOptions;
+    getRoutes(controller: Constructor): RouteDefinition[];
+    getParameters(controller: Constructor): Map<string | symbol, ParameterMetadata[]>;
+    getContextIndices(controller: Constructor): Map<string | symbol, number>;
+    getModuleOptions(module: Constructor): ModuleOptions | undefined;
+    getControllerComponents<T extends MetadataComponentType>(type: T, controller: Constructor): MetadataComponentTypeMap[T][];
+    getHandlerComponents<T extends MetadataComponentType>(type: T, controller: Constructor, handlerName: string | symbol): MetadataComponentTypeMap[T][];
+}
+
+/**
+ * Input contract for route-parameter resolution.
+ */
+interface ParameterResolutionInput {
+    controllerName: string;
+    handlerName: string | symbol;
+    handlerArity: number;
+    handlerParams: ReadonlyArray<ParameterMetadata>;
+    handlerPipes: ReadonlyArray<IPipe>;
+    context: Context$1;
+}
+
+/**
+ * Request-scoped keys used by the framework pipeline.
+ */
+interface PipelineContextValues {
+    controllerClass?: Constructor;
+    handlerName?: string;
+    bodyCache?: unknown;
+}
+
+/**
+ * Processor callback for plugin pre/post hooks.
+ * Receives app, hono, and the application context (registry) for sharing pipeline data.
+ */
+type PluginProcessor = (app: Application, hono: Hono, ctx: IApplicationContext) => void | Promise<void>;
+/**
+ * Optional metadata for plugin diagnostics.
+ */
+interface PluginMeta {
+    /**
+     * Stable plugin name used for diagnostics.
+     */
+    name?: string;
+}
+/**
+ * Object form of a plugin entry with optional pre/post processors.
+ * Processors run before (pre) or after (post) the plugin's lifecycle hooks.
+ */
+interface PluginEntryObject {
+    plugin: IPlugin | Constructor<IPlugin>;
+    /**
+     * Optional stable plugin name for diagnostics.
+     * Takes precedence over plugin.meta.name.
+     */
+    name?: string;
+    preProcessors?: PluginProcessor[];
+    postProcessors?: PluginProcessor[];
+}
+/**
+ * Interface for Honest framework plugins
+ * Plugins can extend the framework's functionality by hooking into
+ * different stages of the application lifecycle
+ */
+interface IPlugin {
+    /**
+     * Optional metadata for plugin diagnostics.
+     */
+    meta?: PluginMeta;
+    /**
+     * Application logger, injected by the framework before lifecycle hooks run.
+     * Use this to emit structured log events from within plugin code.
+     */
+    logger?: ILogger;
+    /**
+     * Hook that runs before module registration begins.
+     * Use this to set up plugin functionality that modules might depend on.
+     * @param app - The Honest application instance
+     * @param hono - The underlying Hono application instance
+     */
+    beforeModulesRegistered?: (app: Application, hono: Hono) => void | Promise<void>;
+    /**
+     * Hook that runs after all modules have been registered.
+     * Use this to perform cleanup or setup that requires all modules to be ready.
+     * @param app - The Honest application instance
+     * @param hono - The underlying Hono application instance
+     */
+    afterModulesRegistered?: (app: Application, hono: Hono) => void | Promise<void>;
+}
+/**
+ * Type for plugin implementations
+ * Can be either a class implementing IPlugin or an instance of IPlugin
+ */
+type PluginType = Constructor<IPlugin> | IPlugin;
+/**
+ * Plugin entry: either a plain plugin or an object wrapping a plugin with optional processors.
+ * Use the object form to attach preProcessors (run before lifecycle hooks) and postProcessors
+ * (run after). Processors receive (app, hono, ctx) where ctx is the application context.
+ */
+type PluginEntry = PluginType | PluginEntryObject;
+
+/**
+ * Route information for registered routes
+ */
+interface RouteInfo {
+    /**
+     * Controller name
+     */
+    controller: string | symbol;
+    /**
+     * Handler method name
+     */
+    handler: string | symbol;
+    /**
+     * HTTP method
+     */
+    method: string;
+    /**
+     * Effective prefix
+     */
+    prefix: string;
+    /**
+     * Effective version
+     */
+    version?: string;
+    /**
+     * Controller route path
+     */
+    route: string;
+    /**
+     * Method path
+     */
+    path: string;
+    /**
+     * Complete path (prefix + version + route + path)
+     */
+    fullPath: string;
+    /**
+     * Parameter metadata for the handler
+     */
+    parameters: ParameterMetadata[];
+}
+
+/**
+ * Contract for checking whether classes are registered as injectable services.
+ */
+interface IServiceRegistry {
+    isService(service: Constructor): boolean;
+}
+
+/**
+ * Main application class for the Honest framework.
+ *
+ * All per-app runtime state (routes, global components, DI container) is
+ * instance-based. Static decorator metadata lives in MetadataRegistry and
+ * is shared across all Application instances in the same process.
+ */
+declare class Application {
+    private readonly hono;
+    private readonly container;
+    private readonly context;
+    private readonly routeRegistry;
+    private readonly metadataRepository;
+    private readonly componentManager;
+    private readonly routeManager;
+    private readonly logger;
+    private readonly options;
+    constructor(options: HonestOptions | undefined, metadataRepository: IMetadataRepository);
+    private setupErrorHandlers;
+    private shouldEmitRouteDiagnostics;
+    private emitStartupGuide;
+    register(moduleClass: Constructor): Promise<Application>;
+    static create(rootModule: Constructor, options?: HonestOptions): Promise<{
+        app: Application;
+        hono: Hono;
+    }>;
+    getApp(): Hono;
+    getContainer(): DiContainer;
+    getContext(): IApplicationContext;
+    getRoutes(): ReadonlyArray<RouteInfo>;
+}
+
+/**
+ * Map-backed implementation of the app-level registry.
+ * Used by Application so the app (bootstrap, services, any code with `app`) can share pipeline data by key.
+ */
+declare class ApplicationContext implements IApplicationContext {
+    private readonly store;
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T): void;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+    keys(): IterableIterator<string>;
+}
+
+type HtmlAttributes = Record<string, string | number | boolean>;
+interface MetaTag {
+    property: string;
+    content: string;
+    name?: string;
+    prefix?: string;
+}
+interface SiteData {
+    title: string;
+    description?: string;
+    image?: string;
+    url?: string;
+    locale?: string;
+    type?: string;
+    siteName?: string;
+    customMeta?: MetaTag[];
+    scripts?: (string | {
+        src: string;
+        async?: boolean;
+        defer?: boolean;
+    })[];
+    stylesheets?: string[];
+    favicon?: string;
+    twitterCard?: 'summary' | 'summary_large_image' | 'app' | 'player';
+    csp?: string;
+    htmlAttributes?: HtmlAttributes;
+    headAttributes?: HtmlAttributes;
+    bodyAttributes?: HtmlAttributes;
+}
+declare const Layout: (props: PropsWithChildren<SiteData>) => hono_utils_html.HtmlEscapedString | Promise<hono_utils_html.HtmlEscapedString>;
+
+/**
+ * Decorator that marks a class as a controller
+ * Controllers are responsible for handling incoming requests and returning responses
+ * @param route - The base route for all endpoints in this controller
+ * @param options - Configuration options for the controller
+ * @returns A class decorator function
+ */
+declare function Controller(route?: string, options?: ControllerOptions): ClassDecorator;
+
+/**
+ * GET method decorator
+ * The GET method requests a representation of the specified resource.
+ * Requests using GET should only retrieve data and should not contain a request content.
+ * @param path - The route path
+ */
+declare const Get: (path?: string, options?: HttpMethodOptions) => MethodDecorator;
+/**
+ * POST method decorator
+ * The POST method submits an entity to the specified resource,
+ * often causing a change in state or side effects on the server.
+ * @param path - The route path
+ */
+declare const Post: (path?: string, options?: HttpMethodOptions) => MethodDecorator;
+/**
+ * PUT method decorator
+ * The PUT method replaces all current representations of the target resource with the request content.
+ * @param path - The route path
+ */
+declare const Put: (path?: string, options?: HttpMethodOptions) => MethodDecorator;
+/**
+ * DELETE method decorator
+ * The DELETE method deletes the specified resource.
+ * @param path - The route path
+ */
+declare const Delete: (path?: string, options?: HttpMethodOptions) => MethodDecorator;
+/**
+ * PATCH method decorator
+ * The PATCH method applies partial modifications to a resource.
+ * @param path - The route path
+ */
+declare const Patch: (path?: string, options?: HttpMethodOptions) => MethodDecorator;
+/**
+ * OPTIONS method decorator
+ * The OPTIONS method describes the communication options for the target resource.
+ * @param path - The route path
+ */
+declare const Options: (path?: string, options?: HttpMethodOptions) => MethodDecorator;
+/**
+ * ALL method decorator (matches all HTTP methods)
+ * @param path - The route path
+ */
+declare const All: (path?: string, options?: HttpMethodOptions) => MethodDecorator;
+
+/**
+ * Decorator that marks a class as a module
+ * Modules are used to organize the application structure and dependencies
+ * @param options - Configuration options for the module
+ * @returns A class decorator function
+ */
+declare function Module(options?: ModuleOptions): ClassDecorator;
+
+/**
+ * Decorator that marks a class as a controller
+ * Controllers are responsible for handling incoming requests and returning responses
+ * @param route - The base route for all endpoints in this controller
+ * @param options - Configuration options for the controller
+ * @returns A class decorator function
+ */
+declare function View(route?: string, options?: ControllerOptions): ClassDecorator;
+/**
+ * GET method decorator
+ * The GET method requests a representation of the specified resource.
+ * Requests using GET should only retrieve data and should not contain a request content.
+ * @param path - The route path
+ */
+declare const Page: (path?: string, options?: HttpMethodOptions) => MethodDecorator;
+/**
+ * Decorator that marks a class as a module
+ * Modules are used to organize the application structure and dependencies
+ * @param options - Configuration options for the module
+ * @returns A class decorator function
+ */
+declare function MvcModule(options?: ModuleOptions & {
+    views?: Constructor[];
+}): ClassDecorator;
+
+/**
+ * Decorator that binds the request body to a parameter
+ * @param data - Optional property name to extract from the body
+ */
+declare const Body: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * Decorator that binds a route parameter to a parameter
+ * @param data - The parameter name in the route
+ */
+declare const Param: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * Decorator that binds a query parameter to a parameter
+ * @param data - The query parameter name
+ */
+declare const Query: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * Decorator that binds a header value to a parameter
+ * @param data - The header name
+ */
+declare const Header: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * Decorator that binds the request object to a parameter
+ */
+declare const Req: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+declare const Request$1: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * Decorator that binds the response object to a parameter
+ */
+declare const Res: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+declare const Response$1: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * Decorator that binds the context object to a parameter
+ */
+declare const Ctx: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+declare const Context: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * Decorator that binds a context variable to a parameter
+ * @param data - The variable name to retrieve from context
+ */
+declare const Var: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+declare const Variable: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+
+/**
+ * Decorator that marks a class as a service
+ * Services are singleton classes that can be injected as dependencies
+ * @returns A class decorator function
+ */
+declare function Service(): ClassDecorator;
+
+type ComponentType = 'middleware' | 'guard' | 'pipe' | 'filter';
+type ComponentInstance = MiddlewareType | GuardType | PipeType | FilterType;
+interface ComponentTypeMap {
+    middleware: MiddlewareType;
+    guard: GuardType;
+    pipe: PipeType;
+    filter: FilterType;
+}
+/**
+ * Central registry for managing application metadata
+ * Stores and provides access to:
+ * - Route definitions and controller configurations
+ * - Service and module registrations
+ * - Parameter metadata and context indices
+ * - Component registrations at global, controller, and handler levels
+ */
+declare class MetadataRegistry {
+    /**
+     * Stores route definitions for each controller
+     * Maps controller classes to their route configurations
+     */
+    private static readonly routes;
+    /**
+     * Stores base paths for controllers
+     * Maps controller classes to their route prefixes
+     */
+    private static readonly controllers;
+    /**
+     * Stores configuration options for controllers
+     * Includes settings like versioning and prefix options
+     */
+    private static readonly controllerOptions;
+    /**
+     * Registry of service classes
+     * Used for dependency injection and lifecycle management
+     */
+    private static readonly services;
+    /**
+     * Stores configuration options for modules
+     * Includes imports, exports, providers, and controllers
+     */
+    private static readonly modules;
+    /**
+     * Stores parameter metadata for controller methods
+     * Used for parameter transformation and validation
+     */
+    private static readonly parameters;
+    /**
+     * Stores indices of context parameters in controller methods
+     * Used for optimizing context injection
+     */
+    private static readonly contextIndices;
+    /**
+     * Registry for controller-level components
+     * Components registered here apply to all routes in a specific controller
+     */
+    private static readonly controller;
+    /**
+     * Registry for handler-level components
+     * Components registered here apply to specific route handlers
+     * Keyed by controller constructor then handler name for collision-safe lookups
+     */
+    private static readonly handler;
+    /**
+     * Gets all route definitions for a controller
+     * @param controller - The controller class to get routes for
+     * @returns Array of route definitions for the controller
+     */
+    static getRoutes(controller: Constructor): RouteDefinition[];
+    /**
+     * Set routes for a controller
+     */
+    static setRoutes(controller: Constructor, routes: RouteDefinition[]): void;
+    /**
+     * Add a route to a controller
+     */
+    static addRoute(controller: Constructor, route: RouteDefinition): void;
+    /**
+     * Get controller path
+     */
+    static getControllerPath(controller: Constructor): string;
+    /**
+     * Check if a class is registered as a controller.
+     */
+    static hasController(controller: Constructor): boolean;
+    /**
+     * Set controller path
+     */
+    static setControllerPath(controller: Constructor, path: string): void;
+    /**
+     * Get controller options
+     */
+    static getControllerOptions(controller: Constructor): ControllerOptions;
+    /**
+     * Set controller options
+     */
+    static setControllerOptions(controller: Constructor, options: ControllerOptions): void;
+    /**
+     * Check if class is a service
+     */
+    static isService(service: Constructor): boolean;
+    /**
+     * Add a service
+     */
+    static addService(service: Constructor): void;
+    /**
+     * Get all services
+     */
+    static getAllServices(): Set<Constructor>;
+    /**
+     * Get module options
+     */
+    static getModuleOptions(module: Constructor): ModuleOptions | undefined;
+    /**
+     * Set module options
+     */
+    static setModuleOptions(module: Constructor, options: ModuleOptions): void;
+    /**
+     * Get parameter metadata
+     */
+    static getParameters(controller: Constructor): Map<string | symbol, ParameterMetadata[]>;
+    /**
+     * Set parameter metadata
+     */
+    static setParameterMap(controller: Constructor, params: Map<string | symbol, ParameterMetadata[]>): void;
+    /**
+     * Get context indices
+     */
+    static getContextIndices(controller: Constructor): Map<string | symbol, number>;
+    /**
+     * Set context indices
+     */
+    static setContextIndices(controller: Constructor, indices: Map<string | symbol, number>): void;
+    /**
+     * Register a component at the controller level
+     */
+    static registerController<T extends ComponentType>(type: T, controller: Constructor, component: ComponentTypeMap[T]): void;
+    /**
+     * Get all controller-level components of a specific type for a controller
+     */
+    static getController<T extends ComponentType>(type: T, controller: Constructor): ComponentTypeMap[T][];
+    /**
+     * Register a component at the handler level
+     */
+    static registerHandler<T extends ComponentType>(type: T, controller: Constructor, handlerName: string | symbol, component: ComponentTypeMap[T]): void;
+    /**
+     * Get all handler-level components of a specific type for a handler
+     */
+    static getHandler<T extends ComponentType>(type: T, controller: Constructor, handlerName: string | symbol): ComponentTypeMap[T][];
+    /**
+     * Clears handler-level component registrations created via {@link registerHandler}.
+     * Does not remove decorator-defined routes, controllers, or modules.
+     */
+    static clearHandlerComponents(): void;
+    /**
+     * Clears all registered decorator metadata.
+     * Primarily used for testing. Warning: clearing after importing decorated classes
+     * (e.g. shared fixtures) removes their metadata until those modules are re-evaluated.
+     */
+    static clear(): void;
+}
+
+/**
+ * Immutable metadata repository for a single Application instance.
+ * Captures a deep copy of all metadata reachable from a root module at creation time,
+ * isolating the application from later mutations to the static MetadataRegistry.
+ */
+declare class MetadataRepository implements IMetadataRepository {
+    private readonly controllerPaths;
+    private readonly controllerOptions;
+    private readonly routes;
+    private readonly parameters;
+    private readonly contextIndices;
+    private readonly modules;
+    private readonly controllerComponents;
+    private readonly handlerComponents;
+    static fromRootModule(rootModule: Constructor): MetadataRepository;
+    hasController(controller: Constructor): boolean;
+    getControllerPath(controller: Constructor): string;
+    getControllerOptions(controller: Constructor): ControllerOptions;
+    getRoutes(controller: Constructor): RouteDefinition[];
+    getParameters(controller: Constructor): Map<string | symbol, ParameterMetadata[]>;
+    getContextIndices(controller: Constructor): Map<string | symbol, number>;
+    getModuleOptions(module: Constructor): ModuleOptions | undefined;
+    getControllerComponents<T extends MetadataComponentType>(type: T, controller: Constructor): MetadataComponentTypeMap[T][];
+    getHandlerComponents<T extends MetadataComponentType>(type: T, controller: Constructor, handlerName: string | symbol): MetadataComponentTypeMap[T][];
+    private captureModuleGraph;
+    private captureController;
+    private cloneRouteDefinition;
+}
+
+/**
+ * Registry for managing and querying route information in the application.
+ *
+ * Each Application instance owns its own RouteRegistry, ensuring routes
+ * from one app never leak into another.
+ */
+declare class RouteRegistry {
+    private readonly routes;
+    registerRoute(routeInfo: RouteInfo): void;
+    getRoutes(): ReadonlyArray<RouteInfo>;
+    getRoutesByController(controllerName: string | symbol): ReadonlyArray<RouteInfo>;
+    getRoutesByMethod(method: string): ReadonlyArray<RouteInfo>;
+    getRoutesByPath(pattern: RegExp): ReadonlyArray<RouteInfo>;
+    clear(): void;
+}
+
+/**
+ * Adapter exposing service checks through the DI service registry contract.
+ */
+declare class StaticServiceRegistry implements IServiceRegistry {
+    isService(service: Constructor): boolean;
+}
+
+/**
+ * Generic decorator that applies components of a specific type to a controller class or method
+ * @template T - The type of component being applied
+ * @param type - The component type identifier
+ * @param components - Array of components to apply
+ * @returns A decorator function that can be used at class or method level
+ */
+declare function UseComponent<T extends ComponentType>(type: T, ...components: ComponentTypeMap[T][]): (target: Constructor | object, propertyKey?: string | symbol) => void;
+
+/**
+ * Decorator that applies exception filters to a controller class or method
+ * @param filters - Array of exception filters to apply
+ * @returns A decorator function that can be used at class or method level
+ */
+declare function UseFilters(...filters: FilterType[]): (target: Constructor | object, propertyKey?: string | symbol) => void;
+
+/**
+ * Decorator that applies guards to a controller class or method
+ * Guards determine whether a request should be handled by the route handler
+ * @param guards - Array of guards to apply
+ * @returns A decorator function that can be used at class or method level
+ */
+declare function UseGuards(...guards: GuardType[]): (target: Constructor | object, propertyKey?: string | symbol) => void;
+
+/**
+ * Decorator that applies middleware to a controller class or method
+ * Middleware functions run before the route handler and can modify the request/response
+ * @param middleware - Array of middleware functions to apply
+ * @returns A decorator function that can be used at class or method level
+ */
+declare function UseMiddleware(...middleware: MiddlewareType[]): (target: Constructor | object, propertyKey?: string | symbol) => void;
+
+/**
+ * Decorator that applies transformation pipes to a controller class or method
+ * Pipes transform input data before it reaches the route handler
+ * @param pipes - Array of pipes to apply
+ * @returns A decorator function that can be used at class or method level
+ */
+declare function UsePipes(...pipes: PipeType[]): (target: Constructor | object, propertyKey?: string | symbol) => void;
+
+/**
+ * Default logger that writes structured events to console.
+ */
+declare class ConsoleLogger implements ILogger {
+    emit(event: LogEvent): void;
+}
+
+/**
+ * Logger implementation that intentionally does nothing.
+ */
+declare class NoopLogger implements ILogger {
+    emit(_event: LogEvent): void;
+}
+
+/**
+ * Dependency Injection container that manages class instances and their dependencies
+ */
+declare class Container implements DiContainer {
+    private readonly serviceRegistry;
+    private readonly logger;
+    private readonly debugDi;
+    constructor(serviceRegistry?: IServiceRegistry, logger?: ILogger, debugDi?: boolean);
+    /**
+     * Map of class constructors to their instances
+     */
+    private instances;
+    private emitLog;
+    /**
+     * Resolves a class instance, creating it if necessary and injecting its dependencies
+     * @param target - The class constructor to resolve
+     * @returns An instance of the target class
+     */
+    resolve<T>(target: Constructor<T>): T;
+    /**
+     * Internal recursive resolver with circular dependency tracking
+     */
+    private resolveWithTracking;
+    /**
+     * Registers a pre-created instance for a class
+     * @param target - The class constructor to register
+     * @param instance - The instance to register
+     */
+    register<T>(target: Constructor<T>, instance: T): void;
+    has<T>(target: Constructor<T>): boolean;
+    clear(): void;
+}
+
+interface FrameworkErrorOptions {
+    status?: number;
+    code: string;
+    category: string;
+    remediation?: string;
+    details?: Record<string, unknown>;
+    cause?: unknown;
+}
+/**
+ * Structured framework-level error with machine-readable metadata.
+ */
+declare class FrameworkError extends Error {
+    readonly status?: number;
+    readonly code: string;
+    readonly category: string;
+    readonly remediation?: string;
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, options: FrameworkErrorOptions);
+}
+
+/**
+ * Handler for managing application-wide error responses
+ * Provides a consistent way to handle and format error responses across the application
+ */
+declare class ErrorHandler {
+    /**
+     * Creates a middleware function that handles error responses
+     * @returns A middleware function that formats and returns error responses using createErrorResponse
+     */
+    static handle(): (err: unknown, c: Context$1) => Promise<Response & hono.TypedResponse<{
+        status: number;
+        message: string;
+        timestamp: string;
+        path: string;
+        requestId?: string | undefined;
+        code?: string | undefined;
+        details?: {
+            [x: string]: any;
+        } | undefined;
+        errors?: {
+            property: string;
+            constraints: {
+                [x: string]: string;
+            };
+        }[] | undefined;
+    }, -1 | 100 | 102 | 103 | 200 | 201 | 202 | 203 | 206 | 207 | 208 | 226 | 300 | 301 | 302 | 303 | 305 | 306 | 307 | 308 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511, "json">>;
+}
+
+/**
+ * Handler for managing 404 Not Found responses
+ * Provides a consistent way to handle requests to non-existent routes
+ */
+declare class NotFoundHandler {
+    /**
+     * Creates a middleware function that handles 404 Not Found responses
+     * @returns A middleware function that returns a JSON response with a 404 status
+     */
+    static handle(): (c: Context$1) => Promise<Response & hono.TypedResponse<{
+        message: string;
+    }, 404, "json">>;
+}
+
+/**
+ * Creates a standardized error response object
+ * @param exception - The error or exception object to process
+ * @param context - The Hono context object containing request information
+ * @param options - Optional configuration for the error response
+ * @param options.status - HTTP status code to override the default
+ * @param options.title - Custom error message to override the default
+ * @param options.detail - Additional error details
+ * @param options.code - Custom error code
+ * @param options.additionalDetails - Extra information to include in the response
+ * @returns Object containing the formatted error response and HTTP status code
+ */
+declare function createErrorResponse(exception: unknown, context: Context$1, options?: {
+    status?: number;
+    title?: string;
+    detail?: string;
+    code?: string;
+    additionalDetails?: Record<string, unknown>;
+}): {
+    response: ErrorResponse;
+    status: ContentfulStatusCode;
+};
+
+/**
+ * Creates a decorator factory for HTTP method handlers
+ * @param method - The HTTP method type (GET, POST, PUT, etc.)
+ * @returns A method decorator factory that accepts a path and options
+ * @example
+ * ```ts
+ * const Get = createHttpMethodDecorator(HttpMethod.GET);
+ *
+ * class Controller {
+ *   @Get('/users')
+ *   getUsers() { }
+ * }
+ * ```
+ */
+declare function createHttpMethodDecorator(method: string): (path?: string, options?: HttpMethodOptions) => MethodDecorator;
+
+/**
+ * Creates a parameter decorator factory for route handlers
+ * @template T - The type of the parameter value after transformation
+ * @param type - The type identifier for the parameter
+ * @param factory - Optional function to transform the parameter value
+ * @returns A parameter decorator function that registers parameter metadata
+ * @example
+ * ```ts
+ * const Body = createParamDecorator('body', async (data, ctx) => {
+ *   const body = await ctx.req.json();
+ *   return data ? body[data] : body;
+ * });
+ * ```
+ */
+declare function createParamDecorator<T = unknown>(type: string, factory?: (data: unknown, ctx: Context$1) => T | Promise<T>): (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+
+/**
+ * Options for creating a lightweight test module.
+ */
+interface TestModuleOptions extends ModuleOptions {
+    /**
+     * Optional class name to improve diagnostics in test output.
+     */
+    name?: string;
+}
+/**
+ * Options for creating a test application instance.
+ */
+interface CreateTestApplicationOptions extends TestModuleOptions {
+    /**
+     * Existing module class to bootstrap.
+     * If omitted, a module is created from controllers/services/imports.
+     */
+    module?: Constructor;
+    /**
+     * Honest application options passed to Application.create.
+     */
+    appOptions?: HonestOptions;
+}
+/**
+ * Options for creating a test application around a single controller.
+ */
+interface CreateControllerTestApplicationOptions extends Omit<TestModuleOptions, 'controllers'> {
+    /**
+     * Controller class to mount in the generated test module.
+     */
+    controller: Constructor;
+    /**
+     * Honest application options passed to Application.create.
+     */
+    appOptions?: HonestOptions;
+}
+/**
+ * Result object returned by createTestApplication.
+ */
+interface TestApplication {
+    /**
+     * Honest application instance.
+     */
+    app: Application;
+    /**
+     * Underlying Hono app.
+     */
+    hono: Hono;
+    /**
+     * Convenience request helper for tests.
+     * Relative paths are resolved against http://localhost.
+     */
+    request: (input: string | Request, init?: RequestInit) => Promise<Response>;
+}
+/**
+ * Override a service token with a pre-built test instance.
+ */
+interface ServiceTestOverride<T = unknown> {
+    provide: Constructor<T>;
+    useValue: T;
+}
+/**
+ * Options for creating a service-only test container.
+ */
+interface CreateServiceTestContainerOptions {
+    /**
+     * Optional service overrides registered before any resolve calls.
+     */
+    overrides?: ServiceTestOverride[];
+    /**
+     * Optional services to resolve immediately so tests can assert warm startup state.
+     */
+    preload?: Constructor[];
+    /**
+     * Optional logger used when debugDi is enabled.
+     */
+    logger?: ILogger;
+    /**
+     * Enable DI diagnostics while resolving services.
+     */
+    debugDi?: boolean;
+}
+/**
+ * Service-only test harness around the DI container.
+ */
+interface TestServiceContainer {
+    container: DiContainer;
+    get<T>(target: Constructor<T>): T;
+    register<T>(target: Constructor<T>, instance: T): void;
+    has<T>(target: Constructor<T>): boolean;
+    clear(): void;
+}
+
+/**
+ * Create a test-friendly application instance with a convenience request helper.
+ */
+declare function createTestApplication(options?: CreateTestApplicationOptions): Promise<TestApplication>;
+
+/**
+ * Create a test application for a single controller with optional services/imports.
+ */
+declare function createControllerTestApplication(options: CreateControllerTestApplicationOptions): Promise<TestApplication>;
+
+/**
+ * Create a lightweight DI container for service-only tests without HTTP bootstrap.
+ */
+declare function createServiceTestContainer(options?: CreateServiceTestContainerOptions): TestServiceContainer;
+
+/**
+ * Create a runtime module class for tests without boilerplate.
+ */
+declare function createTestingModule(options?: TestModuleOptions): Constructor;
+
+/**
+ * Type guard that checks if a value is undefined
+ * @param obj - The value to check
+ * @returns True if the value is undefined, false otherwise
+ */
+declare const isUndefined: (obj: unknown) => obj is undefined;
+/**
+ * Type guard that checks if a value is null or undefined
+ * @param val - The value to check
+ * @returns True if the value is null or undefined, false otherwise
+ */
+declare const isNil: (val: unknown) => val is null | undefined;
+/**
+ * Type guard that checks if a value is an object (excluding null)
+ * @param val - The value to check
+ * @returns True if the value is a non-null object, false otherwise
+ */
+declare const isObject: (val: unknown) => val is Record<PropertyKey, unknown>;
+/**
+ * Type guard that checks if a value is a plain object (not a class instance or array)
+ * Determines if an object is a simple key-value store created by object literals
+ *
+ * @param val - The value to check
+ * @returns True if the value is a plain object, false otherwise
+ * @example
+ * ```ts
+ * isPlainObject({}) // true
+ * isPlainObject(new Class()) // false
+ * isPlainObject([]) // false
+ * ```
+ */
+declare const isPlainObject: (val: unknown) => val is Record<string, unknown>;
+/**
+ * Type guard that checks if a value is a function
+ * @param val - The value to check
+ * @returns True if the value is a function, false otherwise
+ */
+declare const isFunction: (val: unknown) => val is Function;
+/**
+ * Type guard that checks if a value is a string
+ * @param val - The value to check
+ * @returns True if the value is a string, false otherwise
+ */
+declare const isString: (val: unknown) => val is string;
+/**
+ * Type guard that checks if a value is a number
+ * @param val - The value to check
+ * @returns True if the value is a number, false otherwise
+ */
+declare const isNumber: (val: unknown) => val is number;
+/**
+ * Checks if an array is empty
+ * @param array - The array to check
+ * @returns True if the array has no elements, false otherwise
+ */
+declare const isEmpty: (array: unknown[]) => boolean;
+/**
+ * Type guard that checks if a value is a symbol
+ * @param val - The value to check
+ * @returns True if the value is a symbol, false otherwise
+ */
+declare const isSymbol: (val: unknown) => val is symbol;
+/**
+ * Ensures a path starts with a leading slash
+ * @param path - The path to process
+ * @returns The path with a leading slash, or empty string if path is undefined
+ * @example
+ * ```ts
+ * addLeadingSlash('test') // '/test'
+ * addLeadingSlash('/test') // '/test'
+ * ```
+ */
+declare const addLeadingSlash: (path?: string) => string;
+/**
+ * Normalizes a path by ensuring:
+ * - Starts with a single slash
+ * - No trailing slashes
+ * - No consecutive slashes
+ *
+ * @param path - The path to normalize
+ * @returns The normalized path
+ * @example
+ * ```ts
+ * normalizePath('//test//') // '/test'
+ * normalizePath('test/path//') // '/test/path'
+ * ```
+ */
+declare const normalizePath: (path?: string) => string;
+/**
+ * Removes the trailing slash from a path
+ * @param path - The path to process
+ * @returns The path without a trailing slash
+ * @example
+ * ```ts
+ * stripEndSlash('/test/') // '/test'
+ * stripEndSlash('/test') // '/test'
+ * ```
+ */
+declare const stripEndSlash: (path: string) => string;
+/**
+ * Checks if a value is a constructor function (callable with `new`).
+ * A constructor function must:
+ * - Be a function
+ * - Have a non-null prototype (excludes arrow functions, which have no prototype)
+ * - Have a prototype that is not a function (excludes rare edge cases)
+ * - Have at least the built-in 'constructor' on prototype (so empty classes are constructors)
+ *
+ * @param val - The value to check
+ * @returns True if the value is a constructor function, false otherwise
+ * @example
+ * ```ts
+ * class Test {}
+ * isConstructor(Test) // true
+ * isConstructor(() => {}) // false
+ * ```
+ */
+declare const isConstructor: (val: unknown) => boolean;
+
+export { All, Application, ApplicationContext, type ArgumentMetadata, Body, type ComponentInstance, type ComponentType, type ComponentTypeMap, ConsoleLogger, type Constructor, Container, Context, Controller, type ControllerOptions, type CreateControllerTestApplicationOptions, type CreateServiceTestContainerOptions, type CreateTestApplicationOptions, Ctx, Delete, type DiContainer, ErrorHandler, type ErrorResponse, type FilterType, FrameworkError, type FrameworkErrorOptions, Get, type GuardType, HONEST_PIPELINE_BODY_CACHE_KEY, HONEST_PIPELINE_CONTROLLER_KEY, HONEST_PIPELINE_HANDLER_KEY, type HandlerInvocationInput, Header, type HonestOptions, type HtmlAttributes, type HttpMethodOptions, type IApplicationContext, type IFilter, type IGuard, type ILogger, type IMetadataRepository, type IMiddleware, type IPipe, type IPlugin, type IServiceRegistry, Layout, type LogCategory, type LogEvent, type LogLevel, type MetaTag, type MetadataComponentType, type MetadataComponentTypeMap, MetadataRegistry, MetadataRepository, type MiddlewareType, Module, type ModuleOptions, MvcModule, NoopLogger, NotFoundHandler, Options, Page, Param, type ParameterMetadata, type ParameterResolutionInput, Patch, type PipeType, type PipelineContextValues, type PluginEntry, type PluginEntryObject, type PluginMeta, type PluginProcessor, type PluginType, Post, Put, Query, Req, Request$1 as Request, Res, Response$1 as Response, type RouteDefinition, type RouteInfo, RouteRegistry, Service, type ServiceTestOverride, type SiteData, StaticServiceRegistry, type TestApplication, type TestModuleOptions, type TestServiceContainer, UseComponent, UseFilters, UseGuards, UseMiddleware, UsePipes, VERSION_NEUTRAL, Var, Variable, View, addLeadingSlash, createControllerTestApplication, createErrorResponse, createHttpMethodDecorator, createParamDecorator, createServiceTestContainer, createTestApplication, createTestingModule, isConstructor, isEmpty, isFunction, isNil, isNumber, isObject, isPlainObject, isString, isSymbol, isUndefined, normalizePath, stripEndSlash };