honest-node 1.0.0

package/dist/application.js

@@ -0,0 +1,224 @@
+import { Hono } from 'hono';
+import { emitStartupGuide as emitStartupGuideLogs } from './application/startup-guide';
+import { normalizePluginEntries } from './application/plugin-entries';
+import { ApplicationContext } from './application-context';
+import { ConsoleLogger } from './loggers';
+import { Container } from './di';
+import { ErrorHandler, NotFoundHandler } from './handlers';
+import { ComponentManager, RouteManager } from './managers';
+import { MetadataRepository, RouteRegistry } from './registries';
+import { isObject } from './utils';
+/**
+ * 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.
+ */
+export class Application {
+    hono;
+    container;
+    context;
+    routeRegistry;
+    metadataRepository;
+    componentManager;
+    routeManager;
+    logger;
+    options;
+    constructor(options = {}, metadataRepository) {
+        this.options = isObject(options) ? options : {};
+        const debugPipeline = this.options.debug === true ||
+            (typeof this.options.debug === 'object' && Boolean(this.options.debug.pipeline));
+        const debugDi = this.options.debug === true || (typeof this.options.debug === 'object' && Boolean(this.options.debug.di));
+        this.hono = new Hono(this.options.hono);
+        this.logger = this.options.logger || new ConsoleLogger();
+        this.container = this.options.container || new Container(undefined, this.logger, debugDi);
+        this.context = new ApplicationContext();
+        this.routeRegistry = new RouteRegistry();
+        this.metadataRepository = metadataRepository;
+        this.componentManager = new ComponentManager(this.container, this.metadataRepository, this.logger);
+        this.componentManager.setupGlobalComponents(this.options);
+        this.setupErrorHandlers();
+        this.routeManager = new RouteManager(this.hono, this.container, this.routeRegistry, this.componentManager, this.metadataRepository, this.logger, {
+            prefix: this.options.routing?.prefix,
+            version: this.options.routing?.version,
+            debugPipeline
+        });
+        if (this.options.deprecations?.printPreV1Warning) {
+            this.logger.emit({
+                level: 'warn',
+                category: 'deprecations',
+                message: 'Pre-v1 warning: APIs may change before 1.0.0.'
+            });
+        }
+    }
+    setupErrorHandlers() {
+        this.hono.notFound(this.options.notFound || NotFoundHandler.handle());
+        this.hono.onError(this.options.onError || ErrorHandler.handle());
+    }
+    shouldEmitRouteDiagnostics() {
+        const debug = this.options.debug;
+        return debug === true || (typeof debug === 'object' && Boolean(debug.routes));
+    }
+    emitStartupGuide(error, rootModule) {
+        emitStartupGuideLogs(this.logger, this.options.startupGuide, error, rootModule);
+    }
+    async register(moduleClass) {
+        const controllers = await this.componentManager.registerModule(moduleClass);
+        const debugRoutes = this.shouldEmitRouteDiagnostics();
+        for (const controller of controllers) {
+            const controllerStartedAt = Date.now();
+            const routeCountBefore = this.routeRegistry.getRoutes().length;
+            try {
+                await this.routeManager.registerController(controller);
+                if (debugRoutes) {
+                    this.logger.emit({
+                        level: 'info',
+                        category: 'routes',
+                        message: 'Registered controller routes',
+                        details: {
+                            controller: controller.name,
+                            routeCountAdded: this.routeRegistry.getRoutes().length - routeCountBefore,
+                            registrationDurationMs: Date.now() - controllerStartedAt
+                        }
+                    });
+                }
+            }
+            catch (error) {
+                if (debugRoutes) {
+                    this.logger.emit({
+                        level: 'error',
+                        category: 'routes',
+                        message: 'Failed to register controller routes',
+                        details: {
+                            controller: controller.name,
+                            registrationDurationMs: Date.now() - controllerStartedAt,
+                            errorMessage: error instanceof Error ? error.message : String(error)
+                        }
+                    });
+                }
+                throw error;
+            }
+        }
+        return this;
+    }
+    static async create(rootModule, options = {}) {
+        const startupStartedAt = Date.now();
+        const metadataSnapshot = MetadataRepository.fromRootModule(rootModule);
+        const app = new Application(options, metadataSnapshot);
+        const entries = normalizePluginEntries(options.plugins);
+        const ctx = app.getContext();
+        const debug = options.debug;
+        const debugPlugins = debug === true || (typeof debug === 'object' && debug.plugins);
+        const debugRoutes = debug === true || (typeof debug === 'object' && debug.routes);
+        const debugStartup = debug === true || (typeof debug === 'object' && (debug.startup || debugRoutes));
+        let strictNoRoutesFailureEmitted = false;
+        try {
+            if (debugPlugins && entries.length > 0) {
+                app.logger.emit({
+                    level: 'info',
+                    category: 'plugins',
+                    message: `Plugin order: ${entries.map(({ name }) => name).join(' -> ')}`
+                });
+            }
+            for (const { plugin, preProcessors } of entries) {
+                plugin.logger = app.logger;
+                for (const fn of preProcessors) {
+                    await fn(app, app.hono, ctx);
+                }
+                if (plugin.beforeModulesRegistered) {
+                    await plugin.beforeModulesRegistered(app, app.hono);
+                }
+            }
+            await app.register(rootModule);
+            const routes = app.getRoutes();
+            if (debugStartup) {
+                app.logger.emit({
+                    level: 'info',
+                    category: 'startup',
+                    message: `Application registered ${routes.length} route(s)`,
+                    details: {
+                        routeCount: routes.length,
+                        rootModule: rootModule.name
+                    }
+                });
+            }
+            if (options.strict?.requireRoutes && routes.length === 0) {
+                strictNoRoutesFailureEmitted = true;
+                app.logger.emit({
+                    level: 'error',
+                    category: 'startup',
+                    message: 'Strict mode failed: no routes were registered',
+                    details: {
+                        rootModule: rootModule.name,
+                        requireRoutes: true,
+                        startupDurationMs: Date.now() - startupStartedAt
+                    }
+                });
+                const strictError = new Error('Strict mode: no routes were registered. Check your module/controller decorators.');
+                app.emitStartupGuide(strictError, rootModule);
+                throw strictError;
+            }
+            if (debugRoutes) {
+                app.logger.emit({
+                    level: 'info',
+                    category: 'routes',
+                    message: 'Registered routes',
+                    details: {
+                        routes: routes.map((route) => `${route.method.toUpperCase()} ${route.fullPath}`)
+                    }
+                });
+            }
+            for (const { plugin, postProcessors } of entries) {
+                if (plugin.afterModulesRegistered) {
+                    await plugin.afterModulesRegistered(app, app.hono);
+                }
+                for (const fn of postProcessors) {
+                    await fn(app, app.hono, ctx);
+                }
+            }
+            if (debugStartup) {
+                app.logger.emit({
+                    level: 'info',
+                    category: 'startup',
+                    message: 'Application startup completed',
+                    details: {
+                        rootModule: rootModule.name,
+                        pluginCount: entries.length,
+                        routeCount: routes.length,
+                        startupDurationMs: Date.now() - startupStartedAt
+                    }
+                });
+            }
+            return { app, hono: app.getApp() };
+        }
+        catch (error) {
+            app.emitStartupGuide(error, rootModule);
+            if (debugStartup && !strictNoRoutesFailureEmitted) {
+                app.logger.emit({
+                    level: 'error',
+                    category: 'startup',
+                    message: 'Application startup failed',
+                    details: {
+                        rootModule: rootModule.name,
+                        startupDurationMs: Date.now() - startupStartedAt,
+                        errorMessage: error instanceof Error ? error.message : String(error)
+                    }
+                });
+            }
+            throw error;
+        }
+    }
+    getApp() {
+        return this.hono;
+    }
+    getContainer() {
+        return this.container;
+    }
+    getContext() {
+        return this.context;
+    }
+    getRoutes() {
+        return this.routeRegistry.getRoutes();
+    }
+}

package/dist/components/index.d.ts

@@ -0,0 +1 @@
+export * from './layout.component';

package/dist/components/index.js

@@ -0,0 +1 @@
+export * from './layout.component';

package/dist/components/layout.component.d.ts

@@ -0,0 +1,31 @@
+import type { PropsWithChildren } from 'hono/jsx';
+export type HtmlAttributes = Record<string, string | number | boolean>;
+export interface MetaTag {
+    property: string;
+    content: string;
+    name?: string;
+    prefix?: string;
+}
+export 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;
+}
+export declare const Layout: (props: PropsWithChildren<SiteData>) => import("hono/utils/html").HtmlEscapedString | Promise<import("hono/utils/html").HtmlEscapedString>;

package/dist/components/layout.component.js

@@ -0,0 +1,94 @@
+import { html, raw } from 'hono/html';
+const defaultSiteData = {
+    type: 'website',
+    locale: 'en_US'
+};
+const attrsToString = (attrs) => {
+    if (!attrs) {
+        return '';
+    }
+    return Object.entries(attrs)
+        .map(([key, value]) => {
+        if (typeof value === 'boolean') {
+            return value ? key : '';
+        }
+        const escapedValue = String(value).replace(/"/g, '"');
+        return `${key}="${escapedValue}"`;
+    })
+        .filter(Boolean)
+        .join(' ');
+};
+export const Layout = (props) => {
+    const data = { ...defaultSiteData, ...props };
+    return html `
+		<!DOCTYPE html>
+		<html lang="${data.locale?.split('_')[0] || 'en'}" ${raw(attrsToString(data.htmlAttributes))}>
+			<head ${raw(attrsToString(data.headAttributes))}>
+				<meta charset="UTF-8" />
+				<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+				${data.csp ? html `<meta http-equiv="Content-Security-Policy" content="${data.csp}" />` : ''}
+				<title>${data.title}</title>
+				${data.description ? html `<meta name="description" content="${data.description}" />` : ''}
+
+				<!-- Open Graph / Facebook -->
+				<meta prefix="og: http://ogp.me/ns#" />
+				<meta property="og:title" content="${data.title}" />
+				${data.description ? html `<meta property="og:description" content="${data.description}" />` : ''}
+				${data.image ? html `<meta property="og:image" content="${data.image}" />` : ''}
+				${data.url ? html `<meta property="og:url" content="${data.url}" />` : ''}
+				${data.locale ? html `<meta property="og:locale" content="${data.locale}" />` : ''}
+				${data.type ? html `<meta property="og:type" content="${data.type}" />` : ''}
+				${data.siteName ? html `<meta property="og:site_name" content="${data.siteName}" />` : ''}
+
+				<!-- Twitter -->
+				<meta
+					name="twitter:card"
+					content="${data.twitterCard || (data.image ? 'summary_large_image' : 'summary')}"
+				/>
+				<meta name="twitter:title" content="${data.title}" />
+				${data.description ? html `<meta name="twitter:description" content="${data.description}" />` : ''}
+				${data.image ? html `<meta name="twitter:image" content="${data.image}" />` : ''}
+
+				<!-- Custom Meta Tags -->
+				${data.customMeta
+        ? data.customMeta.map((meta) => {
+            const nameAttr = meta.name ? `name="${meta.name}"` : '';
+            const propertyAttr = meta.property ? `property="${meta.property}"` : '';
+            return html `<meta ${nameAttr} ${propertyAttr} content="${meta.content}" />`;
+        })
+        : ''}
+
+				<!-- Favicon -->
+				${data.favicon ? html `<link rel="icon" href="${data.favicon}" />` : ''}
+
+				<!-- Stylesheets -->
+				${data.stylesheets
+        ? data.stylesheets.map((href) => html `<link rel="stylesheet" href="${href}" />`)
+        : ''}
+
+				<!-- Scripts -->
+				${data.scripts
+        ? data.scripts.map((script) => {
+            if (typeof script === 'string') {
+                return html `<script src="${script}"></script>`;
+            }
+            const { src, async, defer } = script;
+            if (async && defer) {
+                return html `<script src="${src}" async defer></script>`;
+            }
+            if (async) {
+                return html `<script src="${src}" async></script>`;
+            }
+            if (defer) {
+                return html `<script src="${src}" defer></script>`;
+            }
+            return html `<script src="${src}"></script>`;
+        })
+        : ''}
+			</head>
+			<body ${raw(attrsToString(data.bodyAttributes))}>
+				${data.children}
+			</body>
+		</html>
+	`;
+};

package/dist/constants/index.d.ts

@@ -0,0 +1,2 @@
+export * from './version.constants';
+export * from './pipeline.constants';

package/dist/constants/index.js

@@ -0,0 +1,2 @@
+export * from './version.constants';
+export * from './pipeline.constants';

package/dist/constants/pipeline.constants.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Internal request-context keys used by the Honest runtime pipeline.
+ */
+export declare const HONEST_PIPELINE_CONTROLLER_KEY = "__honest_controllerClass";
+export declare const HONEST_PIPELINE_HANDLER_KEY = "__honest_handlerName";
+export declare const HONEST_PIPELINE_BODY_CACHE_KEY = "__honest.body.cache";

package/dist/constants/pipeline.constants.js

@@ -0,0 +1,6 @@
+/**
+ * Internal request-context keys used by the Honest runtime pipeline.
+ */
+export const HONEST_PIPELINE_CONTROLLER_KEY = '__honest_controllerClass';
+export const HONEST_PIPELINE_HANDLER_KEY = '__honest_handlerName';
+export const HONEST_PIPELINE_BODY_CACHE_KEY = '__honest.body.cache';

package/dist/constants/version.constants.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Symbol to use when marking a route as version-neutral
+ * Version-neutral routes are accessible both with and without version prefix
+ */
+export declare const VERSION_NEUTRAL: unique symbol;

package/dist/constants/version.constants.js

@@ -0,0 +1,5 @@
+/**
+ * Symbol to use when marking a route as version-neutral
+ * Version-neutral routes are accessible both with and without version prefix
+ */
+export const VERSION_NEUTRAL = Symbol('VERSION_NEUTRAL');

package/dist/decorators/controller.decorator.d.ts

@@ -0,0 +1,9 @@
+import type { ControllerOptions } from '../interfaces';
+/**
+ * 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
+ */
+export declare function Controller(route?: string, options?: ControllerOptions): ClassDecorator;

package/dist/decorators/controller.decorator.js

@@ -0,0 +1,16 @@
+import { MetadataRegistry } from '../registries';
+/**
+ * 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
+ */
+export function Controller(route = '', options = {}) {
+    return (target) => {
+        // Store the prefix in the registry
+        MetadataRegistry.setControllerPath(target, route);
+        // Store the controller options in the registry
+        MetadataRegistry.setControllerOptions(target, options);
+    };
+}

package/dist/decorators/http-method.decorator.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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
+ */
+export declare const Get: (path?: string, options?: import("..").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
+ */
+export declare const Post: (path?: string, options?: import("..").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
+ */
+export declare const Put: (path?: string, options?: import("..").HttpMethodOptions) => MethodDecorator;
+/**
+ * DELETE method decorator
+ * The DELETE method deletes the specified resource.
+ * @param path - The route path
+ */
+export declare const Delete: (path?: string, options?: import("..").HttpMethodOptions) => MethodDecorator;
+/**
+ * PATCH method decorator
+ * The PATCH method applies partial modifications to a resource.
+ * @param path - The route path
+ */
+export declare const Patch: (path?: string, options?: import("..").HttpMethodOptions) => MethodDecorator;
+/**
+ * OPTIONS method decorator
+ * The OPTIONS method describes the communication options for the target resource.
+ * @param path - The route path
+ */
+export declare const Options: (path?: string, options?: import("..").HttpMethodOptions) => MethodDecorator;
+/**
+ * ALL method decorator (matches all HTTP methods)
+ * @param path - The route path
+ */
+export declare const All: (path?: string, options?: import("..").HttpMethodOptions) => MethodDecorator;

package/dist/decorators/http-method.decorator.js

@@ -0,0 +1,44 @@
+import { createHttpMethodDecorator } from '../helpers';
+/**
+ * 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
+ */
+export const Get = createHttpMethodDecorator('get');
+/**
+ * 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
+ */
+export const Post = createHttpMethodDecorator('post');
+/**
+ * PUT method decorator
+ * The PUT method replaces all current representations of the target resource with the request content.
+ * @param path - The route path
+ */
+export const Put = createHttpMethodDecorator('put');
+/**
+ * DELETE method decorator
+ * The DELETE method deletes the specified resource.
+ * @param path - The route path
+ */
+export const Delete = createHttpMethodDecorator('delete');
+/**
+ * PATCH method decorator
+ * The PATCH method applies partial modifications to a resource.
+ * @param path - The route path
+ */
+export const Patch = createHttpMethodDecorator('patch');
+/**
+ * OPTIONS method decorator
+ * The OPTIONS method describes the communication options for the target resource.
+ * @param path - The route path
+ */
+export const Options = createHttpMethodDecorator('options');
+/**
+ * ALL method decorator (matches all HTTP methods)
+ * @param path - The route path
+ */
+export const All = createHttpMethodDecorator('all');

package/dist/decorators/index.d.ts

@@ -0,0 +1,11 @@
+export * from './controller.decorator';
+export * from './http-method.decorator';
+export * from './module.decorator';
+export * from './mvc.decorator';
+export * from './parameter.decorator';
+export * from './service.decorator';
+export * from './use-component.decorator';
+export * from './use-filters.decorator';
+export * from './use-guards.decorator';
+export * from './use-middleware.decorator';
+export * from './use-pipes.decorator';

package/dist/decorators/index.js

@@ -0,0 +1,11 @@
+export * from './controller.decorator';
+export * from './http-method.decorator';
+export * from './module.decorator';
+export * from './mvc.decorator';
+export * from './parameter.decorator';
+export * from './service.decorator';
+export * from './use-component.decorator';
+export * from './use-filters.decorator';
+export * from './use-guards.decorator';
+export * from './use-middleware.decorator';
+export * from './use-pipes.decorator';

package/dist/decorators/module.decorator.d.ts

@@ -0,0 +1,8 @@
+import type { ModuleOptions } from '../interfaces';
+/**
+ * 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
+ */
+export declare function Module(options?: ModuleOptions): ClassDecorator;

package/dist/decorators/module.decorator.js

@@ -0,0 +1,12 @@
+import { MetadataRegistry } from '../registries';
+/**
+ * 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
+ */
+export function Module(options = {}) {
+    return (target) => {
+        MetadataRegistry.setModuleOptions(target, options);
+    };
+}

package/dist/decorators/mvc.decorator.d.ts

@@ -0,0 +1,26 @@
+import type { ControllerOptions, ModuleOptions } from '../interfaces';
+import type { Constructor } from '../types';
+/**
+ * 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
+ */
+export 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
+ */
+export declare const Page: (path?: string, options?: import("..").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
+ */
+export declare function MvcModule(options?: ModuleOptions & {
+    views?: Constructor[];
+}): ClassDecorator;

package/dist/decorators/mvc.decorator.js

@@ -0,0 +1,36 @@
+import { Controller } from './controller.decorator';
+import { Get } from './http-method.decorator';
+import { Module } from './module.decorator';
+/**
+ * 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
+ */
+export function View(route = '', options = {
+    prefix: null,
+    version: null
+}) {
+    return Controller(route, options);
+}
+/**
+ * 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
+ */
+export const Page = Get;
+/**
+ * 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
+ */
+export function MvcModule(options = {}) {
+    return Module({
+        imports: options.imports,
+        services: options.services,
+        controllers: (options.views || []).concat(options.controllers || [])
+    });
+}

package/dist/decorators/parameter.decorator.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Decorator that binds the request body to a parameter
+ * @param data - Optional property name to extract from the body
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export declare const Header: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * Decorator that binds the request object to a parameter
+ */
+export declare const Req: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare const Request: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * Decorator that binds the response object to a parameter
+ */
+export declare const Res: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare const Response: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * Decorator that binds the context object to a parameter
+ */
+export declare const Ctx: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+export 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
+ */
+export declare const Var: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;
+export declare const Variable: (data?: unknown) => (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;