@riktajs/core 0.10.1 → 0.10.3

package/dist/index.d.cts

@@ -0,0 +1,770 @@
+import { FastifyInstance, FastifyRequest, FastifyReply, FastifyError } from 'fastify';
+export { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
+import * as zod from 'zod';
+import { ZodType, ZodError, z, ZodSchema } from 'zod';
+export { ZodError, infer as ZodInfer, input as ZodInput, ZodIssue, output as ZodOutput, z } from 'zod';
+
+declare class InjectionToken<T = unknown> {
+    readonly description: string;
+    readonly options?: {
+        factory?: () => T;
+    } | undefined;
+    constructor(description: string, options?: {
+        factory?: () => T;
+    } | undefined);
+    toString(): string;
+}
+type Token<T = unknown> = (new (...args: unknown[]) => T) | InjectionToken<T> | string | symbol;
+interface ClassProvider<T = unknown> {
+    provide: Token<T>;
+    useClass: new (...args: unknown[]) => T;
+}
+interface ValueProvider<T = unknown> {
+    provide: Token<T>;
+    useValue: T;
+}
+interface FactoryProvider<T = unknown> {
+    provide: Token<T>;
+    useFactory: (...args: unknown[]) => T | Promise<T>;
+    inject?: Token[];
+}
+interface ExistingProvider<T = unknown> {
+    provide: Token<T>;
+    useExisting: Token<T>;
+}
+type ProviderDefinition<T = unknown> = ClassProvider<T> | ValueProvider<T> | FactoryProvider<T> | ExistingProvider<T> | (new (...args: unknown[]) => T);
+
+declare class Container {
+    private static instance;
+    private singletons;
+    private providers;
+    private resolutionStack;
+    private constructor();
+    static getInstance(): Container;
+    static reset(): void;
+    register<T>(target: Constructor$1<T>, options?: InjectableOptions): void;
+    registerProvider<T>(provider: ProviderDefinition<T>): void;
+    registerValue<T>(token: Token<T>, value: T): void;
+    registerFactory<T>(token: Token<T>, factory: () => T, inject?: Token[]): void;
+    has(token: Token): boolean;
+    resolve<T>(token: Token<T>): T;
+    resolveOptional<T>(token: Token<T>): T | undefined;
+    private resolveToken;
+    private resolveAbstractClass;
+    private resolveProvider;
+    private resolveClass;
+    private injectProperties;
+    private resolveWithName;
+    private resolveWithNameOptional;
+    registerInstance<T>(target: Constructor$1<T>, instance: T): void;
+    getProviders(): Token[];
+    clearSingletons(): void;
+    private isPrimitive;
+    private getTokenName;
+}
+declare const container: Container;
+
+declare class Router {
+    private readonly server;
+    private readonly container;
+    private readonly globalPrefix;
+    private readonly guardCache;
+    private readonly middlewareCache;
+    private readonly interceptorCache;
+    constructor(server: FastifyInstance, container: Container, globalPrefix?: string);
+    clearGuardCache(): void;
+    clearMiddlewareCache(): void;
+    clearInterceptorCache(): void;
+    clearAllCaches(): void;
+    getGuardCacheSize(): number;
+    getMiddlewareCacheSize(): number;
+    getInterceptorCacheSize(): number;
+    registerController(controllerClass: Constructor$1, silent?: boolean): void;
+    private registerRoute;
+    private compileParamResolvers;
+    private createParamExtractor;
+    private resolveAllParams;
+    private resolveGuardInstances;
+    private executeGuardsOptimized;
+    private resolveMiddlewareInstances;
+    private executeMiddlewareChain;
+    private resolveInterceptorInstances;
+    private executeInterceptorChain;
+    private buildPath;
+}
+
+interface EventPayload {
+    'app:discovery': {
+        files: string[];
+    };
+    'app:providers': {
+        count: number;
+    };
+    'provider:init': {
+        provider: Constructor$1;
+        name: string;
+        priority: number;
+    };
+    'app:routes': {
+        count: number;
+    };
+    'app:bootstrap': {
+        providerCount: number;
+    };
+    'app:listen': {
+        address: string;
+        port: number;
+    };
+    'app:shutdown': {
+        signal?: string;
+    };
+    'provider:destroy': {
+        provider: Constructor$1;
+        name: string;
+    };
+    'app:destroy': {
+        uptime: number;
+    };
+}
+type LifecycleEvent = keyof EventPayload;
+type Listener<E extends LifecycleEvent> = (payload: EventPayload[E]) => void | Promise<void>;
+declare class EventBus {
+    private listeners;
+    private onceListeners;
+    private ownerUnsubscribers;
+    on<E extends LifecycleEvent>(event: E, listener: Listener<E>, owner?: string): () => void;
+    on<T = unknown>(event: string, listener: (payload: T) => void | Promise<void>, owner?: string): () => void;
+    once<E extends LifecycleEvent>(event: E, listener: Listener<E>, owner?: string): void;
+    once<T = unknown>(event: string, listener: (payload: T) => void | Promise<void>, owner?: string): void;
+    emit<E extends LifecycleEvent>(event: E, payload: EventPayload[E]): Promise<void>;
+    emit<T = unknown>(event: string, payload: T): Promise<void>;
+    waitFor<E extends LifecycleEvent>(event: E): Promise<EventPayload[E]>;
+    waitFor<T = unknown>(event: string): Promise<T>;
+    off(event: string): void;
+    removeByOwner(owner: string): void;
+    clear(): void;
+    listenerCount(event: string): number;
+    totalListenerCount(): number;
+    listenerCountByOwner(owner: string): number;
+    getOwners(): string[];
+}
+
+type Constructor$1<T = any> = new (...args: any[]) => T;
+type AbstractConstructor<T = any> = abstract new (...args: any[]) => T;
+type AnyConstructor<T = any> = Constructor$1<T> | AbstractConstructor<T>;
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD';
+interface RouteContext {
+    request: FastifyRequest;
+    reply: FastifyReply;
+    params: Record<string, string>;
+    query: Record<string, unknown>;
+    body: unknown;
+}
+interface RouteDefinition {
+    method: HttpMethod;
+    path: string;
+    handlerName: string | symbol;
+    statusCode?: number;
+}
+interface ControllerMetadata {
+    prefix: string;
+    routes: RouteDefinition[];
+}
+type ProviderScope = 'singleton' | 'transient' | 'request';
+interface InjectableOptions {
+    scope?: ProviderScope;
+    priority?: number;
+}
+interface ExceptionFilterConfig {
+    includeStack?: boolean;
+    logErrors?: boolean;
+}
+interface RiktaConfig {
+    port?: number;
+    host?: string;
+    logger?: boolean | object;
+    silent?: boolean;
+    prefix?: string;
+    autowired?: string[] | false;
+    strictDiscovery?: boolean;
+    onDiscoveryError?: (filePath: string, error: Error) => void;
+    controllers?: Constructor$1[];
+    providers?: Constructor$1[];
+    exceptionFilter?: ExceptionFilterConfig;
+    exceptionFilters?: Constructor$1[];
+}
+type MiddlewareFunction = (request: FastifyRequest, reply: FastifyReply, next: () => Promise<void>) => Promise<void> | void;
+interface Guard {
+    canActivate(context: RouteContext): boolean | Promise<boolean>;
+}
+
+interface RiktaApplication {
+    readonly server: FastifyInstance;
+    listen(): Promise<string>;
+    close(): Promise<void>;
+    getUrl(): string;
+    getContainer(): Container;
+    getRouter(): Router;
+    getEventBus(): EventBus;
+    clearRouterCaches(): void;
+}
+
+declare const CONTROLLER_METADATA: unique symbol;
+declare const ROUTES_METADATA: unique symbol;
+declare const INJECTABLE_METADATA: unique symbol;
+declare const PARAM_METADATA: unique symbol;
+declare const GUARDS_METADATA: unique symbol;
+declare const INTERCEPTORS_METADATA: unique symbol;
+declare const MIDDLEWARE_METADATA: unique symbol;
+declare const HTTP_CODE_METADATA: unique symbol;
+declare const HEADERS_METADATA: unique symbol;
+declare const INJECT_METADATA: unique symbol;
+declare const ZOD_SCHEMA_METADATA: unique symbol;
+declare const AUTOWIRED_METADATA: unique symbol;
+declare const PROVIDER_METADATA: unique symbol;
+declare const CONFIG_PROVIDER_METADATA: unique symbol;
+declare const CONFIG_PROPERTY_METADATA: unique symbol;
+declare enum ParamType {
+    BODY = "body",
+    QUERY = "query",
+    PARAM = "param",
+    HEADERS = "headers",
+    REQUEST = "request",
+    REPLY = "reply",
+    CONTEXT = "context"
+}
+declare const DEFAULT_CONFIG: {
+    readonly port: 3000;
+    readonly host: "0.0.0.0";
+    readonly logger: true;
+    readonly prefix: "";
+};
+
+declare const IMPLEMENTS_METADATA: unique symbol;
+declare const PRIMARY_METADATA: unique symbol;
+declare function isAbstractClass(target: unknown): target is Constructor$1;
+declare function extendsFrom(derived: Constructor$1, base: Constructor$1): boolean;
+declare function getImplementedAbstract(target: Constructor$1): Constructor$1 | undefined;
+declare function isPrimaryImplementation(target: Constructor$1): boolean;
+declare function setImplementsMetadata(target: Constructor$1, abstractClass: Constructor$1): void;
+declare function setPrimaryMetadata(target: Constructor$1): void;
+declare function markAsAbstract(target: Constructor$1): void;
+
+declare function Implements<T extends AnyConstructor>(abstractClass: T): ClassDecorator;
+declare function Primary(): ClassDecorator;
+declare function Named(name: string): ClassDecorator;
+declare function AbstractClass(): ClassDecorator;
+
+declare class RequestScopeStorage {
+    private static instance;
+    private readonly asyncLocalStorage;
+    private constructor();
+    static getInstance(): RequestScopeStorage;
+    static reset(): void;
+    run<T>(fn: () => T): T;
+    runAsync<T>(fn: () => Promise<T>): Promise<T>;
+    isInRequestScope(): boolean;
+    get<T>(token: Token<T>): T | undefined;
+    set<T>(token: Token<T>, instance: T): void;
+    has(token: Token): boolean;
+    getStore(): Map<Token, unknown> | undefined;
+}
+declare const requestScopeStorage: RequestScopeStorage;
+
+interface ConfigProviderRegistration {
+    token: string;
+    providerClass: Constructor$1;
+}
+interface AbstractImplementation {
+    implementation: Constructor$1;
+    isPrimary: boolean;
+    name?: string;
+}
+declare class Registry {
+    private static instance;
+    private controllers;
+    private providers;
+    private customProviders;
+    private configProviderMap;
+    private abstractImplementations;
+    private constructor();
+    static getInstance(): Registry;
+    static reset(): void;
+    registerController(target: Constructor$1): void;
+    registerProvider(target: Constructor$1): void;
+    getControllers(): Constructor$1[];
+    getProviders(): Constructor$1[];
+    hasController(target: Constructor$1): boolean;
+    hasProvider(target: Constructor$1): boolean;
+    registerCustomProvider(target: Constructor$1): void;
+    getCustomProviders(): Constructor$1[];
+    hasCustomProvider(target: Constructor$1): boolean;
+    registerConfigProvider(token: string, providerClass: Constructor$1): void;
+    getConfigProviderRegistrations(): ConfigProviderRegistration[];
+    clearConfigProviders(): void;
+    registerAbstractImplementation(abstractClass: Constructor$1, implementation: Constructor$1, name?: string): void;
+    setImplementationName(abstractClass: Constructor$1, implementation: Constructor$1, name: string): void;
+    setPrimaryImplementation(abstractClass: Constructor$1, implementation: Constructor$1): void;
+    getImplementations(abstractClass: Constructor$1): AbstractImplementation[];
+    hasImplementation(abstractClass: Constructor$1): boolean;
+    clearAbstractImplementations(): void;
+}
+declare const registry: Registry;
+
+declare class DiscoveryException extends Error {
+    readonly filePath: string;
+    readonly originalError: Error;
+    readonly failedImports: DiscoveryFailure[];
+    constructor(filePath: string, originalError: Error);
+    constructor(failures: DiscoveryFailure[]);
+    getReport(): string;
+}
+interface DiscoveryFailure {
+    filePath: string;
+    error: Error;
+}
+interface DiscoveryOptions {
+    patterns?: string[];
+    cwd?: string;
+    strict?: boolean;
+    onImportError?: (filePath: string, error: Error) => void;
+}
+
+declare function discoverModules(optionsOrPatterns?: DiscoveryOptions | string[], cwd?: string): Promise<string[]>;
+declare function getCallerDirectory(): string;
+
+declare const ON_EVENT_METADATA: unique symbol;
+interface OnEventMetadata {
+    event: string;
+    methodName: string;
+    priority: number;
+}
+declare function On(event: LifecycleEvent | string, options?: {
+    priority?: number;
+}): MethodDecorator;
+
+interface OnProviderInit {
+    onProviderInit(): Promise<void> | void;
+}
+interface OnProviderDestroy {
+    onProviderDestroy(): Promise<void> | void;
+}
+interface OnApplicationBootstrap {
+    onApplicationBootstrap(): Promise<void> | void;
+}
+interface OnApplicationListen {
+    onApplicationListen(address: string): Promise<void> | void;
+}
+interface OnApplicationShutdown {
+    onApplicationShutdown(signal?: string): Promise<void> | void;
+}
+
+declare class RiktaFactory {
+    static create(config?: RiktaConfig): Promise<RiktaApplication>;
+}
+
+declare function Injectable(options?: InjectableOptions): ClassDecorator;
+
+interface ControllerOptions {
+    prefix?: string;
+}
+declare function Controller(prefixOrOptions?: string | ControllerOptions): ClassDecorator;
+
+declare const Get: (path?: string) => MethodDecorator;
+declare const Post: (path?: string) => MethodDecorator;
+declare const Put: (path?: string) => MethodDecorator;
+declare const Patch: (path?: string) => MethodDecorator;
+declare const Delete: (path?: string) => MethodDecorator;
+declare const Options: (path?: string) => MethodDecorator;
+declare const Head: (path?: string) => MethodDecorator;
+declare function HttpCode(statusCode: number): MethodDecorator;
+
+interface ParamMetadata {
+    index: number;
+    type: ParamType;
+    key?: string;
+    zodSchema?: ZodType<unknown>;
+}
+declare const Body: {
+    (): ParameterDecorator;
+    (key: string): ParameterDecorator;
+    <T>(schema: ZodType<T>): ParameterDecorator;
+};
+declare const Query: {
+    (): ParameterDecorator;
+    (key: string): ParameterDecorator;
+    <T>(schema: ZodType<T>): ParameterDecorator;
+};
+declare const Param: {
+    (): ParameterDecorator;
+    (key: string): ParameterDecorator;
+    <T>(schema: ZodType<T>): ParameterDecorator;
+};
+declare const Headers: {
+    (): ParameterDecorator;
+    (key: string): ParameterDecorator;
+    <T>(schema: ZodType<T>): ParameterDecorator;
+};
+declare const Req: {
+    (): ParameterDecorator;
+    (key: string): ParameterDecorator;
+    <T>(schema: ZodType<T>): ParameterDecorator;
+};
+declare const Request: {
+    (): ParameterDecorator;
+    (key: string): ParameterDecorator;
+    <T>(schema: ZodType<T>): ParameterDecorator;
+};
+declare const Res: {
+    (): ParameterDecorator;
+    (key: string): ParameterDecorator;
+    <T>(schema: ZodType<T>): ParameterDecorator;
+};
+declare const Reply: {
+    (): ParameterDecorator;
+    (key: string): ParameterDecorator;
+    <T>(schema: ZodType<T>): ParameterDecorator;
+};
+declare const Ctx: {
+    (): ParameterDecorator;
+    (key: string): ParameterDecorator;
+    <T>(schema: ZodType<T>): ParameterDecorator;
+};
+declare const Context: {
+    (): ParameterDecorator;
+    (key: string): ParameterDecorator;
+    <T>(schema: ZodType<T>): ParameterDecorator;
+};
+
+interface AutowiredMetadata {
+    token: Token;
+    index?: number;
+    propertyKey?: string;
+    optional?: boolean;
+    name?: string;
+}
+declare function Autowired(token?: Token, name?: string): ParameterDecorator & PropertyDecorator;
+declare function Optional(): ParameterDecorator & PropertyDecorator;
+
+interface ProviderMetadata {
+    token: Token;
+}
+interface ConfigProviderMetadata {
+    token: string;
+}
+declare function Provider(token?: Token): ClassDecorator;
+declare function getConfigProviderMetadata(target: Constructor$1): ConfigProviderMetadata | undefined;
+declare function isConfigProvider(target: Constructor$1): boolean;
+
+interface ConfigPropertyMapping {
+    propertyKey: string;
+    envKey: string;
+}
+declare function ConfigProperty(envKey?: string): PropertyDecorator;
+declare function getConfigPropertyMappings(target: Function): ConfigPropertyMapping[];
+declare function hasConfigProperties(target: Function): boolean;
+declare function clearPropertyNameCache(): void;
+
+interface HttpArgumentsHost {
+    getRequest<T = FastifyRequest>(): T;
+    getResponse<T = FastifyReply>(): T;
+}
+interface ExecutionContext {
+    switchToHttp(): HttpArgumentsHost;
+    getRequest<T = FastifyRequest>(): T;
+    getReply<T = FastifyReply>(): T;
+    getClass(): Constructor$1;
+    getHandler(): string | symbol;
+    getMetadata<T = unknown>(key: string | symbol): T | undefined;
+}
+declare class ExecutionContextImpl implements ExecutionContext {
+    private readonly request;
+    private readonly reply;
+    private readonly controllerClass;
+    private readonly handlerName;
+    private readonly httpHost;
+    constructor(request: FastifyRequest, reply: FastifyReply, controllerClass: Constructor$1, handlerName: string | symbol);
+    switchToHttp(): HttpArgumentsHost;
+    getRequest<T = FastifyRequest>(): T;
+    getReply<T = FastifyReply>(): T;
+    getClass(): Constructor$1;
+    getHandler(): string | symbol;
+    getMetadata<T = unknown>(key: string | symbol): T | undefined;
+}
+
+declare const CUSTOM_PARAM_METADATA: unique symbol;
+interface CustomParamMetadata<T = unknown> {
+    index: number;
+    factory: CustomParamFactory<T, unknown>;
+    data?: T;
+}
+type CustomParamFactory<TData = unknown, TResult = unknown> = (data: TData, ctx: ExecutionContext) => TResult | Promise<TResult>;
+declare function createParamDecorator<TData = unknown, TResult = unknown>(factory: CustomParamFactory<TData, TResult>): (data?: TData) => ParameterDecorator;
+declare function getCustomParamMetadata<T = unknown>(target: Function, propertyKey: string | symbol): CustomParamMetadata<T>[];
+
+type ClassDecorator$1 = <TFunction extends Function>(target: TFunction) => TFunction | void;
+type MethodDecorator$1 = <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void;
+type PropertyDecorator$1 = (target: Object, propertyKey: string | symbol) => void;
+type AnyDecorator = ClassDecorator$1 | MethodDecorator$1 | PropertyDecorator$1;
+declare function applyDecorators(...decorators: AnyDecorator[]): MethodDecorator$1 & ClassDecorator$1 & PropertyDecorator$1;
+declare function SetMetadata<T = unknown>(key: string | symbol, value: T): MethodDecorator$1 & ClassDecorator$1;
+
+declare class HttpException extends Error {
+    readonly statusCode: number;
+    readonly response: HttpExceptionResponse;
+    readonly timestamp: string;
+    constructor(response: string | HttpExceptionBody, statusCode?: number);
+    getResponse(): HttpExceptionResponse;
+    getStatus(): number;
+    private getDefaultError;
+}
+interface HttpExceptionBody {
+    message: string;
+    error?: string;
+    details?: unknown;
+    code?: string;
+}
+interface HttpExceptionResponse {
+    statusCode: number;
+    message: string;
+    error: string;
+    timestamp: string;
+    details?: unknown;
+    code?: string;
+    path?: string;
+}
+
+interface ValidationErrorDetails {
+    path: (string | number)[];
+    message: string;
+    code: string;
+    expected?: string;
+    received?: string;
+}
+declare class ValidationException extends HttpException {
+    readonly zodError: ZodError;
+    readonly errors: ValidationErrorDetails[];
+    constructor(zodError: ZodError, message?: string);
+    getValidationErrors(): ValidationErrorDetails[];
+    getFlattenedErrors(): zod.ZodFlattenedError<unknown, string>;
+    getFormattedErrors(): zod.ZodFormattedError<unknown, string>;
+}
+
+declare class BadRequestException extends HttpException {
+    constructor(response?: string | HttpExceptionBody);
+}
+declare class UnauthorizedException extends HttpException {
+    constructor(response?: string | HttpExceptionBody);
+}
+declare class ForbiddenException extends HttpException {
+    constructor(response?: string | HttpExceptionBody);
+}
+declare class NotFoundException extends HttpException {
+    constructor(response?: string | HttpExceptionBody);
+}
+declare class MethodNotAllowedException extends HttpException {
+    constructor(response?: string | HttpExceptionBody);
+}
+declare class NotAcceptableException extends HttpException {
+    constructor(response?: string | HttpExceptionBody);
+}
+declare class RequestTimeoutException extends HttpException {
+    constructor(response?: string | HttpExceptionBody);
+}
+declare class ConflictException extends HttpException {
+    constructor(response?: string | HttpExceptionBody);
+}
+declare class GoneException extends HttpException {
+    constructor(response?: string | HttpExceptionBody);
+}
+declare class PayloadTooLargeException extends HttpException {
+    constructor(response?: string | HttpExceptionBody);
+}
+declare class UnsupportedMediaTypeException extends HttpException {
+    constructor(response?: string | HttpExceptionBody);
+}
+declare class UnprocessableEntityException extends HttpException {
+    constructor(response?: string | HttpExceptionBody);
+}
+declare class TooManyRequestsException extends HttpException {
+    constructor(response?: string | HttpExceptionBody);
+}
+declare class InternalServerErrorException extends HttpException {
+    constructor(response?: string | HttpExceptionBody);
+}
+declare class NotImplementedException extends HttpException {
+    constructor(response?: string | HttpExceptionBody);
+}
+declare class BadGatewayException extends HttpException {
+    constructor(response?: string | HttpExceptionBody);
+}
+declare class ServiceUnavailableException extends HttpException {
+    constructor(response?: string | HttpExceptionBody);
+}
+declare class GatewayTimeoutException extends HttpException {
+    constructor(response?: string | HttpExceptionBody);
+}
+
+interface ExceptionContext {
+    exception: Error;
+    request: FastifyRequest;
+    reply: FastifyReply;
+    path: string;
+    method: string;
+    requestId?: string;
+}
+interface ExceptionFilter<T extends Error = Error> {
+    catch(exception: T, context: ExceptionContext): void | Promise<void>;
+}
+interface ErrorResponse {
+    statusCode: number;
+    message: string;
+    error: string;
+    timestamp: string;
+    path: string;
+    requestId?: string;
+    details?: unknown;
+    code?: string;
+    stack?: string;
+}
+declare class GlobalExceptionFilter implements ExceptionFilter {
+    private readonly includeStack;
+    private readonly logErrors;
+    constructor(options?: GlobalExceptionFilterOptions);
+    catch(exception: Error, context: ExceptionContext): void;
+    private buildResponse;
+    private isFastifyValidationError;
+    private isFastifyError;
+    private logError;
+}
+interface GlobalExceptionFilterOptions {
+    includeStack?: boolean;
+    logErrors?: boolean;
+}
+declare function createExceptionHandler(filter: ExceptionFilter, customFilters?: Map<Function, ExceptionFilter>): (error: FastifyError | Error, request: FastifyRequest, reply: FastifyReply) => Promise<void>;
+
+declare const CATCH_METADATA: unique symbol;
+interface CatchMetadata {
+    exceptions: Constructor$1<Error>[];
+}
+declare function Catch(...exceptions: Constructor$1<Error>[]): ClassDecorator;
+declare function getCatchMetadata(target: Constructor$1): CatchMetadata | undefined;
+
+declare class ConfigProviderAlreadyRegisteredException extends Error {
+    constructor(token: string, existingClass: string, newClass: string);
+}
+declare class ConfigProviderNotFoundException extends Error {
+    constructor(token: string, availableTokens?: string[]);
+}
+declare class ConfigProviderInstantiationException extends Error {
+    constructor(token: string, className: string, cause: Error);
+}
+
+interface CanActivate {
+    canActivate(context: ExecutionContext): boolean | Promise<boolean>;
+}
+
+type GuardClass = Constructor$1<CanActivate>;
+declare function UseGuards(...guards: GuardClass[]): ClassDecorator & MethodDecorator;
+declare function getGuardsMetadata(target: Constructor$1, propertyKey?: string | symbol): GuardClass[];
+
+declare function Middleware(): ClassDecorator;
+
+type NextFunction = () => void | Promise<void>;
+interface RiktaMiddleware {
+    use(req: FastifyRequest, res: FastifyReply, next: NextFunction): void | Promise<void>;
+}
+
+type MiddlewareClass = Constructor$1<RiktaMiddleware>;
+declare function UseMiddleware(...middleware: MiddlewareClass[]): ClassDecorator & MethodDecorator;
+declare function getMiddlewareMetadata(target: Constructor$1, propertyKey?: string | symbol): MiddlewareClass[];
+
+interface Interceptor {
+    intercept(context: ExecutionContext, next: CallHandler): Promise<unknown>;
+}
+interface CallHandler {
+    handle(): Promise<unknown>;
+}
+
+type InterceptorClass = Constructor$1<Interceptor>;
+declare function UseInterceptors(...interceptors: InterceptorClass[]): ClassDecorator & MethodDecorator;
+declare function getInterceptorsMetadata(controllerClass: Constructor$1, methodName: string | symbol): InterceptorClass[];
+
+declare class ConfigValidationException extends Error {
+    readonly errors: z.ZodError;
+    constructor(errors: z.ZodError, providerName: string);
+}
+declare abstract class AbstractConfigProvider {
+    private _cache?;
+    protected abstract schema(): ZodSchema;
+    constructor();
+    private validateAndCache;
+    protected populate(): void;
+    protected getConfig(): Readonly<Record<string, unknown>>;
+    protected get<T = unknown>(key: string): T | undefined;
+}
+
+declare function loadEnvFiles(): void;
+declare function isEnvLoaded(): boolean;
+declare function resetEnvLoaded(): void;
+
+type Constructor<T = unknown> = new (...args: any[]) => T;
+declare function getControllerMetadata(target: Constructor): ControllerMetadata | undefined;
+declare function isController(target: Constructor): boolean;
+declare function getControllerPath(target: Constructor): string;
+declare function getRoutes(target: Constructor): RouteDefinition[];
+declare function hasRoutes(target: Constructor): boolean;
+declare function getParamMetadata(target: Constructor, methodName: string | symbol): ParamMetadata[];
+declare function getParamMetadataByIndex(target: Constructor, methodName: string | symbol, paramIndex: number): ParamMetadata | undefined;
+declare function getHttpCode(target: Constructor, methodName: string | symbol): number | undefined;
+declare function getGuards(target: Constructor, methodName?: string | symbol): Function[];
+declare function getZodSchema(target: Constructor, methodName: string | symbol): unknown;
+declare function getClassMetadata<T = unknown>(metadataKey: symbol, target: Constructor): T | undefined;
+declare function getMethodMetadata<T = unknown>(metadataKey: symbol, target: Constructor, methodName: string | symbol): T | undefined;
+declare function hasClassMetadata(metadataKey: symbol, target: Constructor): boolean;
+declare function hasMethodMetadata(metadataKey: symbol, target: Constructor, methodName: string | symbol): boolean;
+declare function getMethodsWithMetadata(metadataKey: symbol, target: Constructor): (string | symbol)[];
+
+interface PerformanceMetric {
+    name: string;
+    duration: number;
+    startTime: number;
+    metadata?: Record<string, unknown>;
+}
+interface RouteMetric extends PerformanceMetric {
+    method: string;
+    path: string;
+    statusCode: number;
+}
+interface BootstrapMetrics {
+    total: number;
+    discovery: number;
+    containerInit: number;
+    routeRegistration: number;
+    lifecycleHooks: number;
+}
+declare class PerformanceProfiler {
+    private enabled;
+    private eventBus?;
+    private listeners;
+    private bootstrapMetrics;
+    constructor(options?: {
+        enabled?: boolean;
+        eventBus?: EventBus;
+    });
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    startTimer(name: string): (metadata?: Record<string, unknown>) => PerformanceMetric | null;
+    measure<T>(name: string, fn: () => T | Promise<T>): Promise<T>;
+    recordRouteMetric(metric: RouteMetric): void;
+    recordBootstrapPhase(phase: keyof BootstrapMetrics, duration: number): void;
+    getBootstrapMetrics(): Partial<BootstrapMetrics>;
+    onMetric(listener: (metric: PerformanceMetric) => void): () => void;
+    private emitMetric;
+    createConsoleTimer(prefix?: string): (name: string) => (metadata?: Record<string, unknown>) => void;
+}
+declare let profiler: PerformanceProfiler;
+declare function setGlobalProfiler(newProfiler: PerformanceProfiler): void;
+declare function getGlobalProfiler(): PerformanceProfiler;
+
+export { AUTOWIRED_METADATA, AbstractClass, AbstractConfigProvider, type AbstractConstructor, type AnyConstructor, Autowired, type AutowiredMetadata, BadGatewayException, BadRequestException, Body, type BootstrapMetrics, CATCH_METADATA, CONFIG_PROPERTY_METADATA, CONFIG_PROVIDER_METADATA, CONTROLLER_METADATA, CUSTOM_PARAM_METADATA, type CallHandler, type CanActivate, Catch, type CatchMetadata, type ClassProvider, ConfigProperty, type ConfigPropertyMapping, ConfigProviderAlreadyRegisteredException, ConfigProviderInstantiationException, type ConfigProviderMetadata, ConfigProviderNotFoundException, ConfigValidationException, ConflictException, type Constructor$1 as Constructor, Container, Context, Controller, type ControllerMetadata, type ControllerOptions, Ctx, type CustomParamFactory, type CustomParamMetadata, DEFAULT_CONFIG, Delete, DiscoveryException, type DiscoveryFailure, type DiscoveryOptions, type ErrorResponse, EventBus, type EventPayload, type ExceptionContext, type ExceptionFilter, type ExceptionFilterConfig, type ExecutionContext, ExecutionContextImpl, type ExistingProvider, type FactoryProvider, ForbiddenException, GUARDS_METADATA, GatewayTimeoutException, Get, GlobalExceptionFilter, type GlobalExceptionFilterOptions, GoneException, type Guard, HEADERS_METADATA, HTTP_CODE_METADATA, Head, Headers, HttpCode, HttpException, type HttpExceptionBody, type HttpExceptionResponse, type HttpMethod, IMPLEMENTS_METADATA, INJECTABLE_METADATA, INJECT_METADATA, INTERCEPTORS_METADATA, Implements, Injectable, type InjectableOptions, InjectionToken, type Interceptor, type InterceptorClass, InternalServerErrorException, type LifecycleEvent, MIDDLEWARE_METADATA, MethodNotAllowedException, Middleware, type MiddlewareClass, type MiddlewareFunction, Named, type NextFunction, NotAcceptableException, NotFoundException, NotImplementedException, ON_EVENT_METADATA, On, type OnApplicationBootstrap, type OnApplicationListen, type OnApplicationShutdown, type OnEventMetadata, type OnProviderDestroy, type OnProviderInit, Optional, Options, PARAM_METADATA, PRIMARY_METADATA, PROVIDER_METADATA, Param, type ParamMetadata, ParamType, Patch, PayloadTooLargeException, type PerformanceMetric, PerformanceProfiler, Post, Primary, Provider, type ProviderDefinition, type ProviderMetadata, type ProviderScope, Put, Query, ROUTES_METADATA, Registry, Reply, Req, Request, RequestScopeStorage, RequestTimeoutException, Res, RiktaFactory as Rikta, type RiktaApplication, type RiktaConfig, RiktaFactory, type RiktaMiddleware, type RouteContext, type RouteDefinition, type RouteMetric, Router, ServiceUnavailableException, SetMetadata, type Token, TooManyRequestsException, UnauthorizedException, UnprocessableEntityException, UnsupportedMediaTypeException, UseGuards, UseInterceptors, UseMiddleware, type ValidationErrorDetails, ValidationException, type ValueProvider, ZOD_SCHEMA_METADATA, applyDecorators, clearPropertyNameCache, container, createExceptionHandler, createParamDecorator, RiktaFactory as default, discoverModules, extendsFrom, getCallerDirectory, getCatchMetadata, getClassMetadata, getConfigPropertyMappings, getConfigProviderMetadata, getControllerMetadata, getControllerPath, getCustomParamMetadata, getGlobalProfiler, getGuards, getGuardsMetadata, getHttpCode, getImplementedAbstract, getInterceptorsMetadata, getMethodMetadata, getMethodsWithMetadata, getMiddlewareMetadata, getMiddlewareMetadata as getMiddlewaresMetadata, getParamMetadata, getParamMetadataByIndex, getRoutes, getZodSchema, hasClassMetadata, hasConfigProperties, hasMethodMetadata, hasRoutes, isAbstractClass, isConfigProvider, isController, isEnvLoaded, isPrimaryImplementation, loadEnvFiles, markAsAbstract, profiler, registry, requestScopeStorage, resetEnvLoaded, setGlobalProfiler, setImplementsMetadata, setPrimaryMetadata };