@hono-di/core 0.0.6

package/dist/core.d.cts

@@ -0,0 +1,339 @@
+import { q as IApplication, I as InjectionToken, T as Type, S as Scope, b as ExecutionContext, H as HttpArgumentsHost, E as ExceptionFilter, P as PipeTransform, a as Interceptor, C as CanActivate, k as ForwardReference, m as MiddlewareConsumer, n as MiddlewareConfigProxy, o as RouteInfo, c as ArgumentMetadata, A as ArgumentsHost } from './interfaces-4oTuNIHA.cjs';
+export { B as BeforeApplicationShutdown, d as CallHandler, i as ClassProvider, D as DynamicModule, j as ExistingProvider, F as FactoryProvider, l as HonoDiMiddleware, p as HonoDiModule, M as ModuleOptions, e as OnApplicationBootstrap, g as OnApplicationShutdown, f as OnModuleDestroy, O as OnModuleInit, h as Provider, R as RequestMethod, V as ValueProvider } from './interfaces-4oTuNIHA.cjs';
+import * as hono from 'hono';
+import { Hono } from 'hono';
+import * as hono_utils_http_status from 'hono/utils/http-status';
+import 'rxjs';
+
+declare class HonoDiFactory {
+    private static logger;
+    static create(rootModule: any, appOrOptions?: Hono | {
+        app?: Hono;
+        autoInit?: boolean;
+    }): Promise<IApplication>;
+    private static instantiateProviders;
+    private static callLifecycleHook;
+}
+
+declare class ContextId {
+    private static idCounter;
+    readonly id: number;
+    constructor();
+}
+
+declare class InstanceWrapper<T = any> {
+    readonly id: string;
+    readonly token: InjectionToken;
+    readonly name?: string;
+    metatype?: Type<T> | Function;
+    scope: Scope;
+    host?: Module;
+    inject?: InjectionToken[];
+    isOptional?: boolean[];
+    properties?: {
+        key: string | symbol;
+        token: InjectionToken;
+        isOptional?: boolean;
+    }[];
+    instance?: T;
+    private readonly instancesPerContext;
+    isResolved: boolean;
+    isPending: boolean;
+    isAlias: boolean;
+    useFactory?: Function;
+    useValue?: any;
+    useExisting?: any;
+    constructor(metadata: Partial<InstanceWrapper<T>> & {
+        token: InjectionToken;
+    });
+    getInstanceByContextId(contextId: ContextId): T | undefined;
+    setInstanceByContextId(contextId: ContextId, instance: T): void;
+    addCtorMetadata(index: number, token: InjectionToken): void;
+}
+
+declare class Module {
+    readonly metatype: Type<any>;
+    readonly token: string;
+    private readonly _providers;
+    private readonly _imports;
+    private readonly _exports;
+    private readonly _controllers;
+    constructor(metatype: Type<any>, token: string);
+    get providers(): Map<InjectionToken, InstanceWrapper<any>>;
+    get imports(): Set<Module>;
+    get exports(): Set<InjectionToken>;
+    get controllers(): Map<InjectionToken, InstanceWrapper<any>>;
+    addProvider(provider: InstanceWrapper): void;
+    addController(controller: InstanceWrapper): void;
+    addImport(module: Module): void;
+    addExport(token: InjectionToken): void;
+    hasProvider(token: InjectionToken): boolean;
+    getProvider(token: InjectionToken): InstanceWrapper | undefined;
+}
+
+declare class Container {
+    private readonly modules;
+    private readonly globalModules;
+    addModule(moduleMeta: Type<any>, token: string): Module;
+    addGlobalModule(module: Module): void;
+    getGlobalModules(): Set<Module>;
+    getModuleByToken(token: string): Module | undefined;
+    getModules(): Map<string, Module>;
+}
+
+declare class Injector {
+    private readonly container?;
+    constructor(container?: Container | undefined);
+    resolveConstructorParams<T>(wrapper: InstanceWrapper<T>, module: Module, inject: InjectionToken[], callback: (args: any[]) => void, // not used directly in this async flow but kept for structure if needed
+    contextId?: ContextId, inquire?: InstanceWrapper[], parentInquire?: InstanceWrapper[]): Promise<any[]>;
+    resolveSingleParam<T>(token: InjectionToken, targetModule: Module, contextId: ContextId, inquire: InstanceWrapper[], isOptional?: boolean): Promise<T | undefined>;
+    private lookupProvider;
+    loadInstance<T>(wrapper: InstanceWrapper<T>, contextId: ContextId, inquire?: InstanceWrapper[]): Promise<T>;
+}
+
+declare class HonoDiScanner {
+    private readonly container;
+    constructor(container: Container);
+    private readonly logger;
+    scan(module: Type<any>): Promise<void>;
+    private scanModule;
+    private insertProvider;
+    private insertController;
+    scanDependencies(wrapper: InstanceWrapper): void;
+}
+
+declare abstract class ModuleRef {
+    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol, options?: {
+        strict: boolean;
+    }): TResult;
+    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol, contextId?: ContextId, options?: {
+        strict: boolean;
+    }): Promise<TResult>;
+}
+declare class ModuleRefImpl extends ModuleRef {
+    private readonly container;
+    private readonly injector;
+    private readonly moduleRef;
+    constructor(container: Container, injector: Injector, moduleRef: Module);
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol, options?: {
+        strict: boolean;
+    }): TResult;
+    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol, contextId?: ContextId, options?: {
+        strict: boolean;
+    }): Promise<TResult>;
+}
+
+declare class ExecutionContextHost implements ExecutionContext {
+    private readonly args;
+    private readonly constructorRef;
+    private readonly handler;
+    private readonly context;
+    private readonly next?;
+    constructor(args: any[], constructorRef: Type<any>, handler: Function);
+    getClass<T = any>(): Type<T>;
+    getHandler(): Function;
+    getArgs<T extends Array<any> = any[]>(): T;
+    getType<TContext extends string = 'http'>(): TContext;
+    switchToHttp(): HttpArgumentsHost;
+}
+
+declare class HonoDiApplication implements IApplication {
+    private readonly app;
+    private readonly container;
+    private readonly injector;
+    private globalFilters;
+    private globalPipes;
+    private globalGuards;
+    private globalInterceptors;
+    constructor(app: Hono, container: Container, injector: Injector);
+    useGlobalFilters(...filters: ExceptionFilter[]): this;
+    useGlobalPipes(...pipes: PipeTransform[]): this;
+    useGlobalInterceptors(...interceptors: Interceptor[]): this;
+    useGlobalGuards(...guards: CanActivate[]): this;
+    private globalPrefix;
+    setGlobalPrefix(prefix: string): this;
+    getGlobalPrefix(): string;
+    private readonly logger;
+    private isInitialized;
+    init(): Promise<this>;
+    listen(port: number | string, callback?: () => void): Promise<any>;
+    private callLifecycleHook;
+    private registerControllersFromContainer;
+    private registerControllerRoutes;
+    private handleException;
+    private resolveContextItems;
+    private resolveArgs;
+    private runGuards;
+    private initializeMiddleware;
+    private isRouteMatch;
+    private isRouteExcluded;
+    private combinePaths;
+    getHttpAdapter(): any;
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol, options?: {
+        strict?: boolean;
+    }): TResult;
+    close(): Promise<void>;
+    getGlobalFilters(): ExceptionFilter<any>[];
+    getGlobalPipes(): PipeTransform<any, any>[];
+    getGlobalGuards(): CanActivate[];
+    getGlobalInterceptors(): Interceptor<any, any>[];
+    getContainer(): Container;
+}
+
+declare function forwardRef(fn: () => Type<any>): ForwardReference;
+
+declare class MiddlewareBuilder implements MiddlewareConsumer {
+    private readonly module?;
+    private readonly configs;
+    constructor(module?: Module | undefined);
+    apply(...middleware: (Type<any> | Function)[]): MiddlewareConfigProxy;
+    addConfig(middleware: any[], routes: (string | Type<any> | RouteInfo)[], excludes?: (string | RouteInfo)[]): void;
+    getConfigs(): MiddlewareConfig[];
+}
+interface MiddlewareConfig {
+    middleware: any[];
+    routes: (string | Type<any> | RouteInfo)[];
+    excludes: (string | RouteInfo)[];
+    module?: Module;
+}
+
+declare class Reflector {
+    get<TResult = any, TKey = any>(metadataKey: TKey, target: Type<any> | Function): TResult;
+    getAllAndOverride<TResult = any, TKey = any>(metadataKey: TKey, targets: (Type<any> | Function)[]): TResult;
+    getAllAndMerge<TResult = any[], TKey = any>(metadataKey: TKey, targets: (Type<any> | Function)[]): TResult;
+}
+
+declare class HttpException extends Error {
+    private readonly response;
+    private readonly status;
+    constructor(response: string | object, status: number);
+    getResponse(): string | object;
+    getStatus(): number;
+    static createBody(message: object | string | any, error: string, statusCode: number): any;
+}
+
+declare class BadRequestException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class UnauthorizedException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class NotFoundException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class ForbiddenException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class NotAcceptableException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class RequestTimeoutException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class ConflictException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class GoneException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class PayloadTooLargeException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class UnsupportedMediaTypeException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class UnprocessableEntityException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class InternalServerErrorException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class NotImplementedException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class BadGatewayException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class ServiceUnavailableException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class GatewayTimeoutException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+
+declare class ParseIntPipe implements PipeTransform<string, number> {
+    transform(value: string, metadata: ArgumentMetadata): number;
+}
+declare class ParseFloatPipe implements PipeTransform<string, number> {
+    transform(value: string, metadata: ArgumentMetadata): number;
+}
+declare class ParseBoolPipe implements PipeTransform<string | boolean, boolean> {
+    transform(value: string | boolean, metadata: ArgumentMetadata): boolean;
+}
+declare class ValidationPipe implements PipeTransform<any> {
+    transform(value: any, metadata: ArgumentMetadata): any;
+}
+
+declare class AppError extends Error {
+    statusCode: number;
+    message: string;
+    isOperational: boolean;
+    constructor(statusCode: number, message: string, isOperational?: boolean);
+}
+declare class NotFoundError extends AppError {
+    constructor(message?: string);
+}
+declare class BadRequestError extends AppError {
+    constructor(message?: string);
+}
+declare class UnauthorizedError extends AppError {
+    constructor(message?: string);
+}
+declare class ForbiddenError extends AppError {
+    constructor(message?: string);
+}
+declare class ConflictError extends AppError {
+    constructor(message?: string);
+}
+
+interface ILogger {
+    info(message: string, ...meta: any[]): void;
+    error(message: string, ...meta: any[]): void;
+    warn(message: string, ...meta: any[]): void;
+    debug(message: string, ...meta: any[]): void;
+}
+
+declare class BaseExceptionFilter implements ExceptionFilter {
+    catch(exception: unknown, host: ArgumentsHost): (Response & hono.TypedResponse<string, hono_utils_http_status.ContentfulStatusCode, "json">) | (Response & hono.TypedResponse<{
+        statusCode: number;
+        message: string;
+    }, hono_utils_http_status.ContentfulStatusCode, "json">);
+}
+
+declare const METADATA_KEYS: {
+    MODULE: symbol;
+    GLOBAL: symbol;
+    CONTROLLER: symbol;
+    FLUSH_ROLES: symbol;
+    OPTS: symbol;
+    PARAMS: symbol;
+    ROUTES: symbol;
+    FILTER_CATCH: symbol;
+    FILTER_EXCEPTION: symbol;
+    USE_FILTERS: symbol;
+    USE_PIPES: symbol;
+    USE_GUARDS: symbol;
+    USE_INTERCEPTORS: symbol;
+    ROUTE_ARGS_METADATA: symbol;
+    INJECTIONS: symbol;
+    OPTIONAL: symbol;
+    SCOPE: symbol;
+    METHOD_INJECTIONS: symbol;
+    METHOD_OPTIONAL: symbol;
+    PROPERTY_DEPS: symbol;
+    HTTP_CODE: symbol;
+    HEADERS: symbol;
+    REDIRECT: symbol;
+};
+
+export { AppError, ArgumentMetadata, ArgumentsHost, BadGatewayException, BadRequestError, BadRequestException, BaseExceptionFilter, CanActivate, ConflictError, ConflictException, Container, ExceptionFilter, ExecutionContext, ExecutionContextHost, ForbiddenError, ForbiddenException, ForwardReference, GatewayTimeoutException, GoneException, HonoDiApplication, HonoDiFactory, HonoDiScanner, HttpArgumentsHost, HttpException, IApplication, type ILogger, InjectionToken, Interceptor, InternalServerErrorException, METADATA_KEYS, MiddlewareBuilder, type MiddlewareConfig, MiddlewareConfigProxy, MiddlewareConsumer, ModuleRef, ModuleRefImpl, NotAcceptableException, NotFoundError, NotFoundException, NotImplementedException, ParseBoolPipe, ParseFloatPipe, ParseIntPipe, PayloadTooLargeException, PipeTransform, Reflector, RequestTimeoutException, RouteInfo, ServiceUnavailableException, Type, UnauthorizedError, UnauthorizedException, UnprocessableEntityException, UnsupportedMediaTypeException, ValidationPipe, forwardRef };

package/dist/core.d.ts

@@ -0,0 +1,339 @@
+import { q as IApplication, I as InjectionToken, T as Type, S as Scope, b as ExecutionContext, H as HttpArgumentsHost, E as ExceptionFilter, P as PipeTransform, a as Interceptor, C as CanActivate, k as ForwardReference, m as MiddlewareConsumer, n as MiddlewareConfigProxy, o as RouteInfo, c as ArgumentMetadata, A as ArgumentsHost } from './interfaces-4oTuNIHA.js';
+export { B as BeforeApplicationShutdown, d as CallHandler, i as ClassProvider, D as DynamicModule, j as ExistingProvider, F as FactoryProvider, l as HonoDiMiddleware, p as HonoDiModule, M as ModuleOptions, e as OnApplicationBootstrap, g as OnApplicationShutdown, f as OnModuleDestroy, O as OnModuleInit, h as Provider, R as RequestMethod, V as ValueProvider } from './interfaces-4oTuNIHA.js';
+import * as hono from 'hono';
+import { Hono } from 'hono';
+import * as hono_utils_http_status from 'hono/utils/http-status';
+import 'rxjs';
+
+declare class HonoDiFactory {
+    private static logger;
+    static create(rootModule: any, appOrOptions?: Hono | {
+        app?: Hono;
+        autoInit?: boolean;
+    }): Promise<IApplication>;
+    private static instantiateProviders;
+    private static callLifecycleHook;
+}
+
+declare class ContextId {
+    private static idCounter;
+    readonly id: number;
+    constructor();
+}
+
+declare class InstanceWrapper<T = any> {
+    readonly id: string;
+    readonly token: InjectionToken;
+    readonly name?: string;
+    metatype?: Type<T> | Function;
+    scope: Scope;
+    host?: Module;
+    inject?: InjectionToken[];
+    isOptional?: boolean[];
+    properties?: {
+        key: string | symbol;
+        token: InjectionToken;
+        isOptional?: boolean;
+    }[];
+    instance?: T;
+    private readonly instancesPerContext;
+    isResolved: boolean;
+    isPending: boolean;
+    isAlias: boolean;
+    useFactory?: Function;
+    useValue?: any;
+    useExisting?: any;
+    constructor(metadata: Partial<InstanceWrapper<T>> & {
+        token: InjectionToken;
+    });
+    getInstanceByContextId(contextId: ContextId): T | undefined;
+    setInstanceByContextId(contextId: ContextId, instance: T): void;
+    addCtorMetadata(index: number, token: InjectionToken): void;
+}
+
+declare class Module {
+    readonly metatype: Type<any>;
+    readonly token: string;
+    private readonly _providers;
+    private readonly _imports;
+    private readonly _exports;
+    private readonly _controllers;
+    constructor(metatype: Type<any>, token: string);
+    get providers(): Map<InjectionToken, InstanceWrapper<any>>;
+    get imports(): Set<Module>;
+    get exports(): Set<InjectionToken>;
+    get controllers(): Map<InjectionToken, InstanceWrapper<any>>;
+    addProvider(provider: InstanceWrapper): void;
+    addController(controller: InstanceWrapper): void;
+    addImport(module: Module): void;
+    addExport(token: InjectionToken): void;
+    hasProvider(token: InjectionToken): boolean;
+    getProvider(token: InjectionToken): InstanceWrapper | undefined;
+}
+
+declare class Container {
+    private readonly modules;
+    private readonly globalModules;
+    addModule(moduleMeta: Type<any>, token: string): Module;
+    addGlobalModule(module: Module): void;
+    getGlobalModules(): Set<Module>;
+    getModuleByToken(token: string): Module | undefined;
+    getModules(): Map<string, Module>;
+}
+
+declare class Injector {
+    private readonly container?;
+    constructor(container?: Container | undefined);
+    resolveConstructorParams<T>(wrapper: InstanceWrapper<T>, module: Module, inject: InjectionToken[], callback: (args: any[]) => void, // not used directly in this async flow but kept for structure if needed
+    contextId?: ContextId, inquire?: InstanceWrapper[], parentInquire?: InstanceWrapper[]): Promise<any[]>;
+    resolveSingleParam<T>(token: InjectionToken, targetModule: Module, contextId: ContextId, inquire: InstanceWrapper[], isOptional?: boolean): Promise<T | undefined>;
+    private lookupProvider;
+    loadInstance<T>(wrapper: InstanceWrapper<T>, contextId: ContextId, inquire?: InstanceWrapper[]): Promise<T>;
+}
+
+declare class HonoDiScanner {
+    private readonly container;
+    constructor(container: Container);
+    private readonly logger;
+    scan(module: Type<any>): Promise<void>;
+    private scanModule;
+    private insertProvider;
+    private insertController;
+    scanDependencies(wrapper: InstanceWrapper): void;
+}
+
+declare abstract class ModuleRef {
+    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol, options?: {
+        strict: boolean;
+    }): TResult;
+    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol, contextId?: ContextId, options?: {
+        strict: boolean;
+    }): Promise<TResult>;
+}
+declare class ModuleRefImpl extends ModuleRef {
+    private readonly container;
+    private readonly injector;
+    private readonly moduleRef;
+    constructor(container: Container, injector: Injector, moduleRef: Module);
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol, options?: {
+        strict: boolean;
+    }): TResult;
+    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol, contextId?: ContextId, options?: {
+        strict: boolean;
+    }): Promise<TResult>;
+}
+
+declare class ExecutionContextHost implements ExecutionContext {
+    private readonly args;
+    private readonly constructorRef;
+    private readonly handler;
+    private readonly context;
+    private readonly next?;
+    constructor(args: any[], constructorRef: Type<any>, handler: Function);
+    getClass<T = any>(): Type<T>;
+    getHandler(): Function;
+    getArgs<T extends Array<any> = any[]>(): T;
+    getType<TContext extends string = 'http'>(): TContext;
+    switchToHttp(): HttpArgumentsHost;
+}
+
+declare class HonoDiApplication implements IApplication {
+    private readonly app;
+    private readonly container;
+    private readonly injector;
+    private globalFilters;
+    private globalPipes;
+    private globalGuards;
+    private globalInterceptors;
+    constructor(app: Hono, container: Container, injector: Injector);
+    useGlobalFilters(...filters: ExceptionFilter[]): this;
+    useGlobalPipes(...pipes: PipeTransform[]): this;
+    useGlobalInterceptors(...interceptors: Interceptor[]): this;
+    useGlobalGuards(...guards: CanActivate[]): this;
+    private globalPrefix;
+    setGlobalPrefix(prefix: string): this;
+    getGlobalPrefix(): string;
+    private readonly logger;
+    private isInitialized;
+    init(): Promise<this>;
+    listen(port: number | string, callback?: () => void): Promise<any>;
+    private callLifecycleHook;
+    private registerControllersFromContainer;
+    private registerControllerRoutes;
+    private handleException;
+    private resolveContextItems;
+    private resolveArgs;
+    private runGuards;
+    private initializeMiddleware;
+    private isRouteMatch;
+    private isRouteExcluded;
+    private combinePaths;
+    getHttpAdapter(): any;
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | string | symbol, options?: {
+        strict?: boolean;
+    }): TResult;
+    close(): Promise<void>;
+    getGlobalFilters(): ExceptionFilter<any>[];
+    getGlobalPipes(): PipeTransform<any, any>[];
+    getGlobalGuards(): CanActivate[];
+    getGlobalInterceptors(): Interceptor<any, any>[];
+    getContainer(): Container;
+}
+
+declare function forwardRef(fn: () => Type<any>): ForwardReference;
+
+declare class MiddlewareBuilder implements MiddlewareConsumer {
+    private readonly module?;
+    private readonly configs;
+    constructor(module?: Module | undefined);
+    apply(...middleware: (Type<any> | Function)[]): MiddlewareConfigProxy;
+    addConfig(middleware: any[], routes: (string | Type<any> | RouteInfo)[], excludes?: (string | RouteInfo)[]): void;
+    getConfigs(): MiddlewareConfig[];
+}
+interface MiddlewareConfig {
+    middleware: any[];
+    routes: (string | Type<any> | RouteInfo)[];
+    excludes: (string | RouteInfo)[];
+    module?: Module;
+}
+
+declare class Reflector {
+    get<TResult = any, TKey = any>(metadataKey: TKey, target: Type<any> | Function): TResult;
+    getAllAndOverride<TResult = any, TKey = any>(metadataKey: TKey, targets: (Type<any> | Function)[]): TResult;
+    getAllAndMerge<TResult = any[], TKey = any>(metadataKey: TKey, targets: (Type<any> | Function)[]): TResult;
+}
+
+declare class HttpException extends Error {
+    private readonly response;
+    private readonly status;
+    constructor(response: string | object, status: number);
+    getResponse(): string | object;
+    getStatus(): number;
+    static createBody(message: object | string | any, error: string, statusCode: number): any;
+}
+
+declare class BadRequestException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class UnauthorizedException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class NotFoundException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class ForbiddenException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class NotAcceptableException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class RequestTimeoutException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class ConflictException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class GoneException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class PayloadTooLargeException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class UnsupportedMediaTypeException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class UnprocessableEntityException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class InternalServerErrorException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class NotImplementedException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class BadGatewayException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class ServiceUnavailableException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+declare class GatewayTimeoutException extends HttpException {
+    constructor(message?: string | object | any, error?: string);
+}
+
+declare class ParseIntPipe implements PipeTransform<string, number> {
+    transform(value: string, metadata: ArgumentMetadata): number;
+}
+declare class ParseFloatPipe implements PipeTransform<string, number> {
+    transform(value: string, metadata: ArgumentMetadata): number;
+}
+declare class ParseBoolPipe implements PipeTransform<string | boolean, boolean> {
+    transform(value: string | boolean, metadata: ArgumentMetadata): boolean;
+}
+declare class ValidationPipe implements PipeTransform<any> {
+    transform(value: any, metadata: ArgumentMetadata): any;
+}
+
+declare class AppError extends Error {
+    statusCode: number;
+    message: string;
+    isOperational: boolean;
+    constructor(statusCode: number, message: string, isOperational?: boolean);
+}
+declare class NotFoundError extends AppError {
+    constructor(message?: string);
+}
+declare class BadRequestError extends AppError {
+    constructor(message?: string);
+}
+declare class UnauthorizedError extends AppError {
+    constructor(message?: string);
+}
+declare class ForbiddenError extends AppError {
+    constructor(message?: string);
+}
+declare class ConflictError extends AppError {
+    constructor(message?: string);
+}
+
+interface ILogger {
+    info(message: string, ...meta: any[]): void;
+    error(message: string, ...meta: any[]): void;
+    warn(message: string, ...meta: any[]): void;
+    debug(message: string, ...meta: any[]): void;
+}
+
+declare class BaseExceptionFilter implements ExceptionFilter {
+    catch(exception: unknown, host: ArgumentsHost): (Response & hono.TypedResponse<string, hono_utils_http_status.ContentfulStatusCode, "json">) | (Response & hono.TypedResponse<{
+        statusCode: number;
+        message: string;
+    }, hono_utils_http_status.ContentfulStatusCode, "json">);
+}
+
+declare const METADATA_KEYS: {
+    MODULE: symbol;
+    GLOBAL: symbol;
+    CONTROLLER: symbol;
+    FLUSH_ROLES: symbol;
+    OPTS: symbol;
+    PARAMS: symbol;
+    ROUTES: symbol;
+    FILTER_CATCH: symbol;
+    FILTER_EXCEPTION: symbol;
+    USE_FILTERS: symbol;
+    USE_PIPES: symbol;
+    USE_GUARDS: symbol;
+    USE_INTERCEPTORS: symbol;
+    ROUTE_ARGS_METADATA: symbol;
+    INJECTIONS: symbol;
+    OPTIONAL: symbol;
+    SCOPE: symbol;
+    METHOD_INJECTIONS: symbol;
+    METHOD_OPTIONAL: symbol;
+    PROPERTY_DEPS: symbol;
+    HTTP_CODE: symbol;
+    HEADERS: symbol;
+    REDIRECT: symbol;
+};
+
+export { AppError, ArgumentMetadata, ArgumentsHost, BadGatewayException, BadRequestError, BadRequestException, BaseExceptionFilter, CanActivate, ConflictError, ConflictException, Container, ExceptionFilter, ExecutionContext, ExecutionContextHost, ForbiddenError, ForbiddenException, ForwardReference, GatewayTimeoutException, GoneException, HonoDiApplication, HonoDiFactory, HonoDiScanner, HttpArgumentsHost, HttpException, IApplication, type ILogger, InjectionToken, Interceptor, InternalServerErrorException, METADATA_KEYS, MiddlewareBuilder, type MiddlewareConfig, MiddlewareConfigProxy, MiddlewareConsumer, ModuleRef, ModuleRefImpl, NotAcceptableException, NotFoundError, NotFoundException, NotImplementedException, ParseBoolPipe, ParseFloatPipe, ParseIntPipe, PayloadTooLargeException, PipeTransform, Reflector, RequestTimeoutException, RouteInfo, ServiceUnavailableException, Type, UnauthorizedError, UnauthorizedException, UnprocessableEntityException, UnsupportedMediaTypeException, ValidationPipe, forwardRef };