veloce-ts 0.1.0

package/dist/types/adapters/base.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Base adapter interface for runtime-agnostic server implementations
+ * Adapters allow FastAPI-TS to run on different runtimes (Bun, Node.js, Deno, Workers)
+ * and integrate with different frameworks (Hono, Express)
+ */
+export interface Adapter {
+    /**
+     * Name of the adapter (e.g., 'hono', 'express', 'native')
+     */
+    name: string;
+    /**
+     * Start the server and listen on the specified port
+     * @param port - Port number to listen on
+     * @param callback - Optional callback to execute when server starts
+     * @returns Server instance (type varies by runtime)
+     */
+    listen(port: number, callback?: () => void): any;
+    /**
+     * Get the native handler for the underlying framework/runtime
+     * @returns Handler function (e.g., Hono's fetch, Express app)
+     */
+    getHandler(): any;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/types/adapters/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/adapters/base.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,OAAO;IACtB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;OAKG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,IAAI,GAAG,GAAG,CAAC;IAEjD;;;OAGG;IACH,UAAU,IAAI,GAAG,CAAC;CACnB"}

package/dist/types/adapters/express.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Express adapter for FastAPI-TS
+ * Bridges FastAPI-TS routes to Express.js framework
+ * Allows integration with existing Express applications
+ */
+import type { Adapter } from './base';
+import type { VeloceTS } from '../core/application';
+/**
+ * ExpressAdapter - Bridges FastAPI-TS to Express.js
+ * Converts Express req/res to Hono Context format
+ */
+export declare class ExpressAdapter implements Adapter {
+    private app;
+    name: string;
+    private express;
+    constructor(app: VeloceTS);
+    /**
+     * Set up the bridge between FastAPI-TS and Express
+     * Converts all FastAPI-TS routes to Express routes
+     */
+    private setupBridge;
+    /**
+     * Convert Express request to Web Standard Request
+     */
+    private createWebRequest;
+    /**
+     * Convert Web Standard Response to Express response
+     */
+    private sendExpressResponse;
+    /**
+     * Start the Express server on the specified port
+     */
+    listen(port: number, callback?: () => void): any;
+    /**
+     * Get the Express app instance
+     * This allows users to add additional Express middleware or routes
+     */
+    getHandler(): any;
+    /**
+     * Get the underlying Express app for advanced customization
+     */
+    getExpressApp(): any;
+}
+//# sourceMappingURL=express.d.ts.map

package/dist/types/adapters/express.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"express.d.ts","sourceRoot":"","sources":["../../../src/adapters/express.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAKpD;;;GAGG;AACH,qBAAa,cAAe,YAAW,OAAO;IAIhC,OAAO,CAAC,GAAG;IAHvB,IAAI,SAAa;IACjB,OAAO,CAAC,OAAO,CAAM;gBAED,GAAG,EAAE,QAAQ;IAajC;;;OAGG;IACH,OAAO,CAAC,WAAW;IAyBnB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAkCxB;;OAEG;YACW,mBAAmB;IA8BjC;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,IAAI,GAAG,GAAG;IAIhD;;;OAGG;IACH,UAAU,IAAI,GAAG;IAIjB;;OAEG;IACH,aAAa,IAAI,GAAG;CAGrB"}

package/dist/types/adapters/hono.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Hono adapter for runtime-agnostic server deployment
+ * Supports Bun, Node.js, Deno, and Cloudflare Workers
+ */
+import type { Hono } from 'hono';
+import type { Adapter } from './base';
+/**
+ * HonoAdapter - Adapts Hono.js to work across multiple runtimes
+ * Automatically detects the runtime and uses the appropriate server implementation
+ */
+export declare class HonoAdapter implements Adapter {
+    private hono;
+    name: string;
+    private runtime;
+    constructor(hono: Hono);
+    /**
+     * Start the server on the specified port
+     * Automatically uses the appropriate server for the detected runtime
+     */
+    listen(port: number, callback?: () => void): any;
+    /**
+     * Get the Hono fetch handler
+     * This can be used directly in serverless environments or for custom server setups
+     */
+    getHandler(): (request: Request, Env?: unknown, executionCtx?: import("hono").ExecutionContext) => Response | Promise<Response>;
+    /**
+     * Get the detected runtime
+     */
+    getRuntime(): string;
+    /**
+     * Start server using Bun's native server
+     */
+    private listenBun;
+    /**
+     * Start server using Deno's native server
+     */
+    private listenDeno;
+    /**
+     * Start server using Node.js adapter
+     * Requires @hono/node-server package
+     */
+    private listenNode;
+}
+//# sourceMappingURL=hono.d.ts.map

package/dist/types/adapters/hono.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hono.d.ts","sourceRoot":"","sources":["../../../src/adapters/hono.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AACjC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAiCtC;;;GAGG;AACH,qBAAa,WAAY,YAAW,OAAO;IAI7B,OAAO,CAAC,IAAI;IAHxB,IAAI,SAAU;IACd,OAAO,CAAC,OAAO,CAAmC;gBAE9B,IAAI,EAAE,IAAI;IAI9B;;;OAGG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,IAAI,GAAG,GAAG;IAuBhD;;;OAGG;IACH,UAAU;IAIV;;OAEG;IACH,UAAU,IAAI,MAAM;IAIpB;;OAEG;IACH,OAAO,CAAC,SAAS;IAajB;;OAEG;IACH,OAAO,CAAC,UAAU;IAoBlB;;;OAGG;IACH,OAAO,CAAC,UAAU;CAmBnB"}

package/dist/types/cli/commands/build.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerBuildCommand(program: Command): void;
+//# sourceMappingURL=build.d.ts.map

package/dist/types/cli/commands/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/build.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAYpC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAW3D"}

package/dist/types/cli/commands/dev.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerDevCommand(program: Command): void;
+//# sourceMappingURL=dev.d.ts.map

package/dist/types/cli/commands/dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/dev.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAUpC,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CASzD"}

package/dist/types/cli/commands/generate.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerGenerateCommand(program: Command): void;
+//# sourceMappingURL=generate.d.ts.map

package/dist/types/cli/commands/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/generate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAwB9D"}

package/dist/types/cli/commands/new.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerNewCommand(program: Command): void;
+//# sourceMappingURL=new.d.ts.map

package/dist/types/cli/commands/new.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"new.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/new.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAWpC,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CASzD"}

package/dist/types/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/types/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cli/index.ts"],"names":[],"mappings":""}

package/dist/types/core/application.d.ts

@@ -0,0 +1,268 @@
+import { Hono } from 'hono';
+import { MetadataRegistry } from './metadata';
+import { DIContainer } from '../dependencies/container';
+import { ErrorHandler, type CustomErrorHandler } from '../errors/handler';
+import { PluginManager, type Plugin } from './plugin';
+import type { VeloceTSConfig, Class, RouteConfig, Middleware, CorsOptions, RateLimitOptions, CompressionOptions } from '../types';
+/**
+ * Main VeloceTS application class
+ *
+ * Provides both decorator-based and functional API for defining routes.
+ * Built on top of Hono.js for maximum performance with support for multiple runtimes.
+ *
+ * @example
+ * ```typescript
+ * // Create a new application
+ * const app = new VeloceTS({
+ *   title: 'My API',
+ *   version: '1.0.0',
+ *   docs: true
+ * });
+ *
+ * // Register a controller
+ * @Controller('/users')
+ * class UserController {
+ *   @Get('/:id')
+ *   getUser(@Param('id') id: string) {
+ *     return { id, name: 'John' };
+ *   }
+ * }
+ * app.include(UserController);
+ *
+ * // Or use functional API
+ * app.get('/users/:id', {
+ *   handler: async (c) => {
+ *     const id = c.req.param('id');
+ *     return { id, name: 'John' };
+ *   }
+ * });
+ *
+ * // Start the server
+ * app.listen(3000, () => {
+ *   console.log('Server running on port 3000');
+ * });
+ * ```
+ */
+export declare class VeloceTS {
+    private hono;
+    private metadata;
+    private container;
+    private validator;
+    private errorHandler;
+    private compiler;
+    private pluginManager;
+    private config;
+    private compiled;
+    private globalMiddleware;
+    private groupPrefix;
+    constructor(config?: VeloceTSConfig);
+    /**
+     * Register a controller class with the application
+     *
+     * Extracts metadata from decorators and stores in registry.
+     * The controller must be decorated with @Controller() and contain
+     * methods decorated with HTTP method decorators (@Get, @Post, etc.)
+     *
+     * @param controller - The controller class to register
+     *
+     * @example
+     * ```typescript
+     * @Controller('/api/users')
+     * class UserController {
+     *   @Get('/')
+     *   async list() {
+     *     return [{ id: 1, name: 'John' }];
+     *   }
+     *
+     *   @Post('/')
+     *   async create(@Body(UserSchema) user: InferSchema<typeof UserSchema>) {
+     *     return { id: 2, ...user };
+     *   }
+     * }
+     *
+     * app.include(UserController);
+     * ```
+     */
+    include(controller: Class): void;
+    /**
+     * Register a GET route using functional API
+     *
+     * @param path - The route path (supports parameters like /users/:id)
+     * @param config - Route configuration including handler, schema, middleware
+     *
+     * @example
+     * ```typescript
+     * const UserSchema = z.object({ name: z.string(), age: z.number() });
+     *
+     * app.get('/users/:id', {
+     *   handler: async (c) => {
+     *     const id = c.req.param('id');
+     *     return { id, name: 'John', age: 30 };
+     *   },
+     *   schema: {
+     *     params: z.object({ id: z.string() })
+     *   },
+     *   docs: {
+     *     summary: 'Get user by ID',
+     *     tags: ['users']
+     *   }
+     * });
+     * ```
+     */
+    get(path: string, config: RouteConfig): void;
+    /**
+     * Register a POST route using functional API
+     *
+     * @param path - The route path
+     * @param config - Route configuration including handler, schema, middleware
+     *
+     * @example
+     * ```typescript
+     * const CreateUserSchema = z.object({
+     *   name: z.string(),
+     *   email: z.string().email()
+     * });
+     *
+     * app.post('/users', {
+     *   handler: async (c) => {
+     *     const body = await c.req.json();
+     *     return { id: 1, ...body };
+     *   },
+     *   schema: {
+     *     body: CreateUserSchema
+     *   }
+     * });
+     * ```
+     */
+    post(path: string, config: RouteConfig): void;
+    /**
+     * Register a PUT route
+     */
+    put(path: string, config: RouteConfig): void;
+    /**
+     * Register a DELETE route
+     */
+    delete(path: string, config: RouteConfig): void;
+    /**
+     * Register a PATCH route
+     */
+    patch(path: string, config: RouteConfig): void;
+    /**
+     * Create a route builder for chaining methods
+     */
+    route(path: string): RouteBuilder;
+    /**
+     * Create a route group with a common prefix
+     */
+    group(prefix: string, callback: () => void): void;
+    /**
+     * Internal method to register functional routes
+     */
+    private registerFunctionalRoute;
+    /**
+     * Extract parameter metadata from schema config
+     * For functional API, parameters start at index 0 since context is passed separately
+     */
+    private extractParametersFromSchema;
+    /**
+     * Add global middleware to the application
+     */
+    use(middleware: Middleware): void;
+    /**
+     * Configure CORS middleware
+     * Supports origin, methods, headers configuration and handles preflight requests
+     */
+    useCors(options?: CorsOptions): void;
+    /**
+     * Configure rate limiting middleware
+     * Tracks requests per IP/key and returns 429 when limit exceeded
+     */
+    useRateLimit(options: RateLimitOptions): void;
+    /**
+     * Configure compression middleware
+     * Compresses responses with gzip/brotli based on configuration
+     */
+    useCompression(options?: CompressionOptions): void;
+    /**
+     * Register a plugin with the application
+     * Plugins are installed during compilation in dependency order
+     * @param plugin - The plugin to register
+     */
+    usePlugin(plugin: Plugin): void;
+    /**
+     * Get the plugin manager instance
+     * @returns The PluginManager instance
+     */
+    getPluginManager(): PluginManager;
+    /**
+     * Set a custom error handler for the application
+     * This allows users to override the default error handling behavior
+     * @param handler - Custom error handling function
+     */
+    onError(handler: CustomErrorHandler): void;
+    /**
+     * Get the error handler instance
+     * @returns The ErrorHandler instance
+     */
+    getErrorHandler(): ErrorHandler;
+    /**
+     * Normalize path by combining segments and ensuring proper format
+     */
+    private normalizePath;
+    /**
+     * Get the underlying Hono instance
+     */
+    getHono(): Hono;
+    /**
+     * Get the metadata registry
+     */
+    getMetadata(): MetadataRegistry;
+    /**
+     * Get the DI container
+     */
+    getContainer(): DIContainer;
+    /**
+     * Get the application configuration
+     */
+    getConfig(): VeloceTSConfig;
+    /**
+     * Check if routes have been compiled
+     */
+    isCompiled(): boolean;
+    /**
+     * Mark routes as compiled
+     */
+    markCompiled(): void;
+    /**
+     * Compile all registered routes into the Hono router
+     * This must be called before the application can handle requests
+     * Installs plugins before compiling routes
+     */
+    compile(): Promise<void>;
+    /**
+     * Start the server and listen on the specified port
+     * Automatically compiles routes if not already compiled
+     * Delegates to the configured adapter for runtime-specific server implementation
+     */
+    listen(port: number, callback?: () => void): Promise<any>;
+    /**
+     * Create the appropriate adapter based on configuration
+     * @private
+     */
+    private createAdapter;
+}
+/**
+ * Route builder for chaining HTTP methods
+ */
+declare class RouteBuilder {
+    private app;
+    private path;
+    constructor(app: VeloceTS, path: string);
+    get(config: RouteConfig): RouteBuilder;
+    post(config: RouteConfig): RouteBuilder;
+    put(config: RouteConfig): RouteBuilder;
+    delete(config: RouteConfig): RouteBuilder;
+    patch(config: RouteConfig): RouteBuilder;
+}
+export {};
+//# sourceMappingURL=application.d.ts.map

package/dist/types/core/application.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application.d.ts","sourceRoot":"","sources":["../../../src/core/application.ts"],"names":[],"mappings":"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"}

package/dist/types/core/compiled-metadata.d.ts

@@ -0,0 +1,58 @@
+import type { RouteMetadata } from '../types';
+/**
+ * Compiled route metadata with pre-computed values for performance
+ */
+export interface CompiledRouteMetadata extends RouteMetadata {
+    pathRegex?: RegExp;
+    parameterOrder: number[];
+    dependencyOrder: number[];
+    maxArgumentIndex: number;
+    hasBody: boolean;
+    hasQuery: boolean;
+    hasParams: boolean;
+    hasHeaders: boolean;
+    hasCookies: boolean;
+    hasDependencies: boolean;
+}
+/**
+ * MetadataCompiler pre-processes route metadata for optimal runtime performance
+ * This reduces the work needed during request processing
+ */
+export declare class MetadataCompiler {
+    /**
+     * Compile a route metadata object into an optimized version
+     * Pre-computes regex patterns, parameter order, and other expensive operations
+     */
+    static compile(route: RouteMetadata): CompiledRouteMetadata;
+    /**
+     * Compile path pattern into a regex for efficient matching
+     * Converts FastAPI-style {param} to regex capture groups
+     */
+    private static compilePathRegex;
+    /**
+     * Resolve the order of parameters by their indices
+     * Returns sorted array of indices for efficient iteration
+     */
+    private static resolveParameterOrder;
+    /**
+     * Resolve the order of dependencies by their indices
+     * Returns sorted array of indices for efficient iteration
+     */
+    private static resolveDependencyOrder;
+    /**
+     * Calculate the maximum argument index to determine array size
+     * This allows pre-allocation of the arguments array
+     */
+    private static calculateMaxArgumentIndex;
+    /**
+     * Pre-compute flags for parameter types to avoid repeated checks
+     * These flags enable quick conditional logic during request processing
+     */
+    private static computeParameterFlags;
+    /**
+     * Batch compile multiple routes for efficiency
+     * Useful when compiling all routes at application startup
+     */
+    static compileAll(routes: RouteMetadata[]): CompiledRouteMetadata[];
+}
+//# sourceMappingURL=compiled-metadata.d.ts.map

package/dist/types/core/compiled-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiled-metadata.d.ts","sourceRoot":"","sources":["../../../src/core/compiled-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAqB,MAAM,UAAU,CAAC;AAEjE;;GAEG;AACH,MAAM,WAAW,qBAAsB,SAAQ,aAAa;IAE1D,SAAS,CAAC,EAAE,MAAM,CAAC;IAGnB,cAAc,EAAE,MAAM,EAAE,CAAC;IAGzB,eAAe,EAAE,MAAM,EAAE,CAAC;IAG1B,gBAAgB,EAAE,MAAM,CAAC;IAGzB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED;;;GAGG;AACH,qBAAa,gBAAgB;IAC3B;;;OAGG;IACH,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,qBAAqB;IA6B3D;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAgB/B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAYpC;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAYrC;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,yBAAyB;IAmBxC;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IA6BpC;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,qBAAqB,EAAE;CAGpE"}

package/dist/types/core/metadata.d.ts

@@ -0,0 +1,175 @@
+import 'reflect-metadata';
+import type { RouteMetadata, ParameterMetadata, DependencyMetadata, ControllerMetadata, Class, WebSocketMetadata, WebSocketHandlerMetadata, GraphQLResolverMetadata, GraphQLFieldMetadata } from '../types';
+export declare class MetadataRegistry {
+    private routes;
+    private controllers;
+    private routesByController;
+    private websockets;
+    private graphqlResolvers;
+    private graphqlFields;
+    /**
+     * Register a route in the registry
+     */
+    registerRoute(metadata: RouteMetadata): void;
+    /**
+     * Register a controller in the registry
+     */
+    registerController(target: Class, metadata: ControllerMetadata): void;
+    /**
+     * Get all registered routes
+     */
+    getRoutes(): RouteMetadata[];
+    /**
+     * Get a specific route by target and property key
+     */
+    getRoute(target: Class, propertyKey: string): RouteMetadata | undefined;
+    /**
+     * Get all routes for a specific controller
+     */
+    getRoutesByController(target: Class): RouteMetadata[];
+    /**
+     * Get controller metadata
+     */
+    getController(target: Class): ControllerMetadata | undefined;
+    /**
+     * Get all registered controllers
+     */
+    getControllers(): Map<Class, ControllerMetadata>;
+    /**
+     * Register a WebSocket handler in the registry
+     */
+    registerWebSocket(metadata: WebSocketMetadata): void;
+    /**
+     * Get all registered WebSocket handlers
+     */
+    getWebSockets(): WebSocketMetadata[];
+    /**
+     * Get WebSocket metadata for a specific target
+     */
+    getWebSocket(target: Class): WebSocketMetadata | undefined;
+    /**
+     * Register a GraphQL resolver in the registry
+     */
+    registerGraphQLResolver(metadata: GraphQLResolverMetadata): void;
+    /**
+     * Register a GraphQL field in the registry
+     */
+    registerGraphQLField(metadata: GraphQLFieldMetadata): void;
+    /**
+     * Get all registered GraphQL resolvers
+     */
+    getGraphQLResolvers(): GraphQLResolverMetadata[];
+    /**
+     * Get GraphQL resolver metadata for a specific target
+     */
+    getGraphQLResolver(target: Class): GraphQLResolverMetadata | undefined;
+    /**
+     * Get all GraphQL fields
+     */
+    getGraphQLFields(): GraphQLFieldMetadata[];
+    /**
+     * Get GraphQL fields for a specific resolver
+     */
+    getGraphQLFieldsByResolver(target: Class): GraphQLFieldMetadata[];
+    /**
+     * Clear all metadata (useful for testing)
+     */
+    clear(): void;
+    /**
+     * Generate a unique key for a route
+     */
+    private getRouteKey;
+    /**
+     * Define route metadata using reflect-metadata (used by decorators)
+     */
+    static defineRoute(target: any, propertyKey: string, metadata: Partial<RouteMetadata>): void;
+    /**
+     * Define parameter metadata (used by parameter decorators)
+     */
+    static defineParameter(target: any, propertyKey: string, index: number, metadata: ParameterMetadata): void;
+    /**
+     * Define dependency metadata (used by @Depends decorator)
+     */
+    static defineDependency(target: any, propertyKey: string, index: number, metadata: DependencyMetadata): void;
+    /**
+     * Define controller metadata (used by @Controller decorator)
+     */
+    static defineController(target: any, metadata: ControllerMetadata): void;
+    /**
+     * Get route metadata from reflect-metadata
+     */
+    static getRouteMetadata(target: any, propertyKey: string): Partial<RouteMetadata> | undefined;
+    /**
+     * Get parameter metadata from reflect-metadata
+     */
+    static getParameterMetadata(target: any, propertyKey: string): ParameterMetadata[] | undefined;
+    /**
+     * Get dependency metadata from reflect-metadata
+     */
+    static getDependencyMetadata(target: any, propertyKey: string): DependencyMetadata[] | undefined;
+    /**
+     * Get controller metadata from reflect-metadata
+     */
+    static getControllerMetadata(target: any): ControllerMetadata | undefined;
+    /**
+     * Check if a class has controller metadata
+     */
+    static hasControllerMetadata(target: any): boolean;
+    /**
+     * Check if a method has route metadata
+     */
+    static hasRouteMetadata(target: any, propertyKey: string): boolean;
+    /**
+     * Get all route methods from a controller class
+     */
+    static getRouteMethods(target: Class): string[];
+    /**
+     * Define WebSocket metadata (used by @WebSocket decorator)
+     */
+    static defineWebSocket(target: any, metadata: Partial<WebSocketMetadata>): void;
+    /**
+     * Define WebSocket handler metadata (used by @OnConnect, @OnMessage, @OnDisconnect)
+     */
+    static defineWebSocketHandler(target: any, propertyKey: string, metadata: WebSocketHandlerMetadata): void;
+    /**
+     * Get WebSocket metadata from reflect-metadata
+     */
+    static getWebSocketMetadata(target: any): Partial<WebSocketMetadata> | undefined;
+    /**
+     * Get WebSocket handler metadata from reflect-metadata
+     */
+    static getWebSocketHandlerMetadata(target: any, propertyKey: string): WebSocketHandlerMetadata | undefined;
+    /**
+     * Check if a class has WebSocket metadata
+     */
+    static hasWebSocketMetadata(target: any): boolean;
+    /**
+     * Define GraphQL resolver metadata (used by @Resolver decorator)
+     */
+    static defineGraphQLResolver(target: any, metadata: GraphQLResolverMetadata): void;
+    /**
+     * Define GraphQL field metadata (used by @Query, @Mutation, @Subscription decorators)
+     */
+    static defineGraphQLField(target: any, propertyKey: string, metadata: GraphQLFieldMetadata): void;
+    /**
+     * Get GraphQL resolver metadata from reflect-metadata
+     */
+    static getGraphQLResolverMetadata(target: any): GraphQLResolverMetadata | undefined;
+    /**
+     * Get all GraphQL fields metadata from a resolver class
+     */
+    static getGraphQLFieldsMetadata(target: any): GraphQLFieldMetadata[];
+    /**
+     * Get GraphQL field metadata from a specific method
+     */
+    static getGraphQLFieldMetadata(target: any, propertyKey: string): GraphQLFieldMetadata | undefined;
+    /**
+     * Check if a class has GraphQL resolver metadata
+     */
+    static hasGraphQLResolverMetadata(target: any): boolean;
+    /**
+     * Check if a method has GraphQL field metadata
+     */
+    static hasGraphQLFieldMetadata(target: any, propertyKey: string): boolean;
+}
+//# sourceMappingURL=metadata.d.ts.map