@navios/core 0.1.5 → 0.1.7

package/dist/_tsup-dts-rollup.d.mts

@@ -0,0 +1,1485 @@
+import type { AnyZodObject } from 'zod';
+import type { BaseEndpointConfig } from '@navios/common';
+import type { EndpointFunctionArgs } from '@navios/common';
+import { FastifyBaseLogger } from 'fastify';
+import type { FastifyCorsOptions } from '@fastify/cors';
+import type { FastifyInstance } from 'fastify';
+import type { FastifyListenOptions } from 'fastify';
+import type { FastifyReply } from 'fastify';
+import type { FastifyRequest } from 'fastify';
+import { FastifySchema } from 'fastify';
+import type { FastifyServerOptions } from 'fastify';
+import { FastifyTypeProviderDefault } from 'fastify';
+import type { HttpHeader } from 'fastify/types/utils.js';
+import type { HttpMethod } from '@navios/common';
+import { IncomingMessage } from 'http';
+import type { InspectOptions } from 'util';
+import { LoggerInstance as LoggerInstance_2 } from '../logger/logger.service.mjs';
+import type { output } from 'zod';
+import { RawServerDefault } from 'fastify';
+import { ResolveFastifyRequestType } from 'fastify/types/type-provider.js';
+import { RouteGenericInterface } from 'fastify';
+import { ServerResponse } from 'http';
+import { z } from 'zod';
+import { ZodOptional } from 'zod';
+import type { ZodType } from 'zod';
+
+declare const addLeadingSlash: (path?: string) => string;
+export { addLeadingSlash }
+export { addLeadingSlash as addLeadingSlash_alias_1 }
+export { addLeadingSlash as addLeadingSlash_alias_2 }
+export { addLeadingSlash as addLeadingSlash_alias_3 }
+
+declare const Application: InjectionToken<FastifyInstance<RawServerDefault, IncomingMessage, ServerResponse<IncomingMessage>, FastifyBaseLogger, FastifyTypeProviderDefault>, undefined>;
+export { Application }
+export { Application as Application_alias_1 }
+export { Application as Application_alias_2 }
+
+declare class AttributeFactory {
+    static createAttribute(token: symbol): ClassAttribute;
+    static createAttribute<T extends ZodType>(token: symbol, schema: T): ClassSchemaAttribute<T>;
+    static get(attribute: ClassAttribute, target: ModuleMetadata | ControllerMetadata | EndpointMetadata): true | null;
+    static get<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | EndpointMetadata): z.output<T> | null;
+    static getAll(attribute: ClassAttribute, target: ModuleMetadata | ControllerMetadata | EndpointMetadata): Array<true> | null;
+    static getAll<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | EndpointMetadata): Array<z.output<T>> | null;
+    static getLast(attribute: ClassAttribute, target: (ModuleMetadata | ControllerMetadata | EndpointMetadata)[]): true | null;
+    static getLast<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: (ModuleMetadata | ControllerMetadata | EndpointMetadata)[]): z.output<T> | null;
+    static has(attribute: ClassAttribute, target: ModuleMetadata | ControllerMetadata | EndpointMetadata): boolean;
+    static has<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | EndpointMetadata): boolean;
+}
+export { AttributeFactory }
+export { AttributeFactory as AttributeFactory_alias_1 }
+
+declare class BadRequestException extends HttpException {
+    constructor(message: string | object);
+}
+export { BadRequestException }
+export { BadRequestException as BadRequestException_alias_1 }
+export { BadRequestException as BadRequestException_alias_2 }
+
+declare class BoundInjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject>> extends InjectionToken<T, undefined> {
+    readonly token: InjectionToken<T, S>;
+    readonly value: z.input<S>;
+    constructor(token: InjectionToken<T, S>, value: z.input<S>);
+}
+export { BoundInjectionToken }
+export { BoundInjectionToken as BoundInjectionToken_alias_1 }
+export { BoundInjectionToken as BoundInjectionToken_alias_2 }
+
+declare interface CanActivate {
+    canActivate(executionContext: ExecutionContext): Promise<boolean> | boolean;
+}
+export { CanActivate }
+export { CanActivate as CanActivate_alias_1 }
+export { CanActivate as CanActivate_alias_2 }
+
+declare type ChannelEmitter<Events extends EventsConfig, Ns extends string, E extends EventsNames<Events>> = {
+    emit<Args extends EventsArgs<Events, E>>(ns: Ns, event: E, ...args: Args): Promise<any>;
+};
+export { ChannelEmitter }
+export { ChannelEmitter as ChannelEmitter_alias_1 }
+export { ChannelEmitter as ChannelEmitter_alias_2 }
+
+declare type ClassAttribute = (() => <T>(target: T, context: ClassDecoratorContext | ClassMethodDecoratorContext) => T) & {
+    token: symbol;
+};
+export { ClassAttribute }
+export { ClassAttribute as ClassAttribute_alias_1 }
+
+declare type ClassSchemaAttribute<T extends ZodType> = ((value: z.input<T>) => <T extends ClassType>(target: T, context: ClassDecoratorContext | ClassMethodDecoratorContext) => T) & {
+    token: symbol;
+    schema: ZodType;
+};
+export { ClassSchemaAttribute }
+export { ClassSchemaAttribute as ClassSchemaAttribute_alias_1 }
+
+declare type ClassType = new (...args: any[]) => any;
+export { ClassType }
+export { ClassType as ClassType_alias_1 }
+export { ClassType as ClassType_alias_2 }
+
+declare type ClassTypeWithInstance<T> = new (...args: any[]) => T;
+export { ClassTypeWithInstance }
+export { ClassTypeWithInstance as ClassTypeWithInstance_alias_1 }
+export { ClassTypeWithInstance as ClassTypeWithInstance_alias_2 }
+
+declare const clc: {
+    bold: (text: string) => string;
+    green: (text: string) => string;
+    yellow: (text: string) => string;
+    red: (text: string) => string;
+    magentaBright: (text: string) => string;
+    cyanBright: (text: string) => string;
+};
+export { clc }
+export { clc as clc_alias_1 }
+export { clc as clc_alias_2 }
+export { clc as clc_alias_3 }
+
+declare const ConfigProvider: InjectionToken<ConfigService<Record<string, unknown>>, z.ZodObject<{
+    load: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    load: (...args: unknown[]) => unknown;
+}, {
+    load: (...args: unknown[]) => unknown;
+}>>;
+export { ConfigProvider }
+export { ConfigProvider as ConfigProvider_alias_1 }
+export { ConfigProvider as ConfigProvider_alias_2 }
+
+declare class ConfigProviderFactory {
+    logger: LoggerInstance_2;
+    create(ctx: any, args: z.infer<typeof ConfigProviderOptions>): Promise<ConfigServiceInstance<unknown>>;
+}
+export { ConfigProviderFactory }
+export { ConfigProviderFactory as ConfigProviderFactory_alias_1 }
+export { ConfigProviderFactory as ConfigProviderFactory_alias_2 }
+
+declare const ConfigProviderOptions: z.ZodObject<{
+    load: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    load: (...args: unknown[]) => unknown;
+}, {
+    load: (...args: unknown[]) => unknown;
+}>;
+export { ConfigProviderOptions }
+export { ConfigProviderOptions as ConfigProviderOptions_alias_1 }
+export { ConfigProviderOptions as ConfigProviderOptions_alias_2 }
+
+declare interface ConfigService<Config = Record<string, unknown>> {
+    getConfig: () => Config;
+    get: <Key extends Path<Config>>(key: Key) => PathValue<Config, Key> | null;
+    getOrDefault: <Key extends Path<Config>>(key: Key, defaultValue: PathValue<Config, Key>) => PathValue<Config, Key>;
+    getOrThrow: <Key extends Path<Config>>(key: Key, errorMessage?: string) => PathValue<Config, Key>;
+}
+export { ConfigService }
+export { ConfigService as ConfigService_alias_1 }
+export { ConfigService as ConfigService_alias_2 }
+
+declare class ConfigServiceInstance<Config = Record<string, unknown>> implements ConfigService<Config> {
+    private config;
+    private logger;
+    constructor(config: Config | undefined, logger: LoggerService);
+    getConfig(): Config;
+    get<Key extends Path<Config>>(key: Key): PathValue<Config, Key> | null;
+    getOrDefault<Key extends Path<Config>>(key: Key, defaultValue: PathValue<Config, Key>): PathValue<Config, Key>;
+    getOrThrow<Key extends Path<Config>>(key: Key, errorMessage?: string): PathValue<Config, Key>;
+}
+export { ConfigServiceInstance }
+export { ConfigServiceInstance as ConfigServiceInstance_alias_1 }
+export { ConfigServiceInstance as ConfigServiceInstance_alias_2 }
+
+declare class ConflictException extends HttpException {
+    constructor(message: string | object, error?: Error);
+}
+export { ConflictException }
+export { ConflictException as ConflictException_alias_1 }
+export { ConflictException as ConflictException_alias_2 }
+
+/**
+ * @publicApi
+ */
+declare class ConsoleLogger implements LoggerService {
+    /**
+     * The options of the logger.
+     */
+    protected options: ConsoleLoggerOptions;
+    /**
+     * The context of the logger (can be set manually or automatically inferred).
+     */
+    protected context?: string;
+    /**
+     * The original context of the logger (set in the constructor).
+     */
+    protected originalContext?: string;
+    /**
+     * The options used for the "inspect" method.
+     */
+    protected inspectOptions: InspectOptions;
+    /**
+     * The last timestamp at which the log message was printed.
+     */
+    protected static lastTimestampAt?: number;
+    constructor();
+    constructor(context: string);
+    constructor(options: ConsoleLoggerOptions);
+    constructor(context: string, options: ConsoleLoggerOptions);
+    /**
+     * Write a 'log' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    log(message: any, context?: string): void;
+    log(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write an 'error' level log, if the configured level allows for it.
+     * Prints to `stderr` with newline.
+     */
+    error(message: any, stackOrContext?: string): void;
+    error(message: any, stack?: string, context?: string): void;
+    error(message: any, ...optionalParams: [...any, string?, string?]): void;
+    /**
+     * Write a 'warn' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    warn(message: any, context?: string): void;
+    warn(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'debug' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    debug(message: any, context?: string): void;
+    debug(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'verbose' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    verbose(message: any, context?: string): void;
+    verbose(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'fatal' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    fatal(message: any, context?: string): void;
+    fatal(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Set log levels
+     * @param levels log levels
+     */
+    setLogLevels(levels: LogLevel[]): void;
+    /**
+     * Set logger context
+     * @param context context
+     */
+    setContext(context: string): void;
+    /**
+     * Resets the logger context to the value that was passed in the constructor.
+     */
+    resetContext(): void;
+    isLevelEnabled(level: LogLevel): boolean;
+    protected getTimestamp(): string;
+    protected printMessages(messages: unknown[], context?: string, logLevel?: LogLevel, writeStreamType?: 'stdout' | 'stderr', errorStack?: unknown): void;
+    protected printAsJson(message: unknown, options: {
+        context: string;
+        logLevel: LogLevel;
+        writeStreamType?: 'stdout' | 'stderr';
+        errorStack?: unknown;
+    }): void;
+    protected formatPid(pid: number): string;
+    protected formatContext(context: string): string;
+    protected formatMessage(logLevel: LogLevel, message: unknown, pidMessage: string, formattedLogLevel: string, contextMessage: string, timestampDiff: string): string;
+    protected stringifyMessage(message: unknown, logLevel: LogLevel): string;
+    protected colorize(message: string, logLevel: LogLevel): string;
+    protected printStackTrace(stack: string): void;
+    protected updateAndGetTimestampDiff(): string;
+    protected formatTimestampDiff(timestampDiff: number): string;
+    protected getInspectOptions(): InspectOptions;
+    protected stringifyReplacer(key: string, value: unknown): unknown;
+    private getContextAndMessagesToPrint;
+    private getContextAndStackAndMessagesToPrint;
+    private isStackFormat;
+    private getColorByLogLevel;
+}
+export { ConsoleLogger }
+export { ConsoleLogger as ConsoleLogger_alias_1 }
+export { ConsoleLogger as ConsoleLogger_alias_2 }
+
+/**
+ * @publicApi
+ */
+declare interface ConsoleLoggerOptions {
+    /**
+     * Enabled log levels.
+     */
+    logLevels?: LogLevel[];
+    /**
+     * If enabled, will print timestamp (time difference) between current and previous log message.
+     * Note: This option is not used when `json` is enabled.
+     */
+    timestamp?: boolean;
+    /**
+     * A prefix to be used for each log message.
+     * Note: This option is not used when `json` is enabled.
+     */
+    prefix?: string;
+    /**
+     * If enabled, will print the log message in JSON format.
+     */
+    json?: boolean;
+    /**
+     * If enabled, will print the log message in color.
+     * Default true if json is disabled, false otherwise
+     */
+    colors?: boolean;
+    /**
+     * The context of the logger.
+     */
+    context?: string;
+    /**
+     * If enabled, will print the log message in a single line, even if it is an object with multiple properties.
+     * If set to a number, the most n inner elements are united on a single line as long as all properties fit into breakLength. Short array elements are also grouped together.
+     * Default true when `json` is enabled, false otherwise.
+     */
+    compact?: boolean | number;
+    /**
+     * Specifies the maximum number of Array, TypedArray, Map, Set, WeakMap, and WeakSet elements to include when formatting.
+     * Set to null or Infinity to show all elements. Set to 0 or negative to show no elements.
+     * Ignored when `json` is enabled, colors are disabled, and `compact` is set to true as it produces a parseable JSON output.
+     * @default 100
+     */
+    maxArrayLength?: number;
+    /**
+     * Specifies the maximum number of characters to include when formatting.
+     * Set to null or Infinity to show all elements. Set to 0 or negative to show no characters.
+     * Ignored when `json` is enabled, colors are disabled, and `compact` is set to true as it produces a parseable JSON output.
+     * @default 10000.
+     */
+    maxStringLength?: number;
+    /**
+     * If enabled, will sort keys while formatting objects.
+     * Can also be a custom sorting function.
+     * Ignored when `json` is enabled, colors are disabled, and `compact` is set to true as it produces a parseable JSON output.
+     * @default false
+     */
+    sorted?: boolean | ((a: string, b: string) => number);
+    /**
+     * Specifies the number of times to recurse while formatting object. T
+     * This is useful for inspecting large objects. To recurse up to the maximum call stack size pass Infinity or null.
+     * Ignored when `json` is enabled, colors are disabled, and `compact` is set to true as it produces a parseable JSON output.
+     * @default 5
+     */
+    depth?: number;
+    /**
+     * If true, object's non-enumerable symbols and properties are included in the formatted result.
+     * WeakMap and WeakSet entries are also included as well as user defined prototype properties
+     * @default false
+     */
+    showHidden?: boolean;
+    /**
+     * The length at which input values are split across multiple lines. Set to Infinity to format the input as a single line (in combination with "compact" set to true).
+     * Default Infinity when "compact" is true, 80 otherwise.
+     * Ignored when `json` is enabled, colors are disabled, and `compact` is set to true as it produces a parseable JSON output.
+     */
+    breakLength?: number;
+}
+export { ConsoleLoggerOptions }
+export { ConsoleLoggerOptions as ConsoleLoggerOptions_alias_1 }
+export { ConsoleLoggerOptions as ConsoleLoggerOptions_alias_2 }
+
+declare function Controller({ guards }?: ControllerOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
+export { Controller }
+export { Controller as Controller_alias_1 }
+export { Controller as Controller_alias_2 }
+
+declare class ControllerAdapterService {
+    guardRunner: GuardRunnerService;
+    private logger;
+    setupController(controller: ClassType, instance: FastifyInstance, moduleMetadata: ModuleMetadata): void;
+    providePreHandler(executionContext: ExecutionContext): ((request: FastifyRequest, reply: FastifyReply) => Promise<undefined>) | undefined;
+    private provideSchemaForConfig;
+    private provideHandler;
+    private provideHandlerForConfig;
+}
+export { ControllerAdapterService }
+export { ControllerAdapterService as ControllerAdapterService_alias_1 }
+export { ControllerAdapterService as ControllerAdapterService_alias_2 }
+
+declare interface ControllerMetadata {
+    endpoints: Set<EndpointMetadata>;
+    guards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
+    customAttributes: Map<string | symbol, any>;
+}
+export { ControllerMetadata }
+export { ControllerMetadata as ControllerMetadata_alias_1 }
+export { ControllerMetadata as ControllerMetadata_alias_2 }
+
+declare const ControllerMetadataKey: unique symbol;
+export { ControllerMetadataKey }
+export { ControllerMetadataKey as ControllerMetadataKey_alias_1 }
+export { ControllerMetadataKey as ControllerMetadataKey_alias_2 }
+
+declare interface ControllerOptions {
+    guards?: ClassType[] | Set<ClassType>;
+}
+export { ControllerOptions }
+export { ControllerOptions as ControllerOptions_alias_1 }
+export { ControllerOptions as ControllerOptions_alias_2 }
+
+declare function Endpoint<Method extends HttpMethod = HttpMethod, Url extends string = string, QuerySchema = undefined, ResponseSchema extends ZodType = ZodType, RequestSchema = ZodType>(endpoint: {
+    config: BaseEndpointConfig<Method, Url, QuerySchema, ResponseSchema, RequestSchema>;
+}): (target: (params: QuerySchema extends AnyZodObject ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema> : EndpointFunctionArgs<Url, QuerySchema, undefined> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema> : EndpointFunctionArgs<Url, undefined, undefined>) => Promise<z.input<ResponseSchema>>, context: ClassMethodDecoratorContext) => (params: QuerySchema extends AnyZodObject ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema> : EndpointFunctionArgs<Url, QuerySchema, undefined> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema> : EndpointFunctionArgs<Url, undefined, undefined>) => Promise<z.input<ResponseSchema>>;
+export { Endpoint }
+export { Endpoint as Endpoint_alias_1 }
+export { Endpoint as Endpoint_alias_2 }
+
+declare interface EndpointMetadata {
+    classMethod: string;
+    url: string;
+    successStatusCode: number;
+    type: EndpointType;
+    headers: Partial<Record<HttpHeader, number | string | string[] | undefined>>;
+    httpMethod: HttpMethod;
+    config: BaseEndpointConfig | null;
+    guards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
+    customAttributes: Map<string | symbol, any>;
+}
+export { EndpointMetadata }
+export { EndpointMetadata as EndpointMetadata_alias_1 }
+export { EndpointMetadata as EndpointMetadata_alias_2 }
+
+declare const EndpointMetadataKey: unique symbol;
+export { EndpointMetadataKey }
+export { EndpointMetadataKey as EndpointMetadataKey_alias_1 }
+export { EndpointMetadataKey as EndpointMetadataKey_alias_2 }
+
+declare type EndpointParams<EndpointDeclaration extends {
+    config: BaseEndpointConfig<any, any, any, any, any>;
+}, Url extends string = EndpointDeclaration['config']['url'], QuerySchema = EndpointDeclaration['config']['querySchema']> = QuerySchema extends AnyZodObject ? EndpointDeclaration['config']['requestSchema'] extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, EndpointDeclaration['config']['requestSchema']> : EndpointFunctionArgs<Url, QuerySchema, undefined> : EndpointDeclaration['config']['requestSchema'] extends ZodType ? EndpointFunctionArgs<Url, undefined, EndpointDeclaration['config']['requestSchema']> : EndpointFunctionArgs<Url, undefined, undefined>;
+export { EndpointParams }
+export { EndpointParams as EndpointParams_alias_1 }
+export { EndpointParams as EndpointParams_alias_2 }
+
+declare enum EndpointType {
+    Unknown = "unknown",
+    Config = "config",
+    Handler = "handler"
+}
+export { EndpointType }
+export { EndpointType as EndpointType_alias_1 }
+export { EndpointType as EndpointType_alias_2 }
+
+declare function envInt(key: keyof NodeJS.ProcessEnv, defaultValue: number): number;
+export { envInt }
+export { envInt as envInt_alias_1 }
+export { envInt as envInt_alias_2 }
+export { envInt as envInt_alias_3 }
+
+declare function envString<DefaultValue extends string | undefined, Ensured = DefaultValue extends string ? true : false>(key: keyof NodeJS.ProcessEnv, defaultValue?: DefaultValue): Ensured extends true ? string : string | undefined;
+export { envString }
+export { envString as envString_alias_1 }
+export { envString as envString_alias_2 }
+export { envString as envString_alias_3 }
+
+declare enum ErrorsEnum {
+    InstanceExpired = "InstanceExpired",
+    InstanceNotFound = "InstanceNotFound",
+    InstanceDestroying = "InstanceDestroying",
+    UnknownError = "UnknownError",
+    FactoryNotFound = "FactoryNotFound",
+    FactoryTokenNotResolved = "FactoryTokenNotResolved"
+}
+export { ErrorsEnum }
+export { ErrorsEnum as ErrorsEnum_alias_1 }
+export { ErrorsEnum as ErrorsEnum_alias_2 }
+export { ErrorsEnum as ErrorsEnum_alias_3 }
+
+declare class EventEmitter<Events extends EventsConfig = {}> implements EventEmitterInterface<Events> {
+    private listeners;
+    on<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void): () => void;
+    off<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void): void;
+    once<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void): () => void;
+    emit<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, ...args: Args): Promise<any>;
+    addChannel<E extends EventsNames<Events>, Ns extends string, Emitter extends ChannelEmitter<Events, Ns, E>>(ns: Ns, event: E, target: Emitter): () => void;
+}
+export { EventEmitter }
+export { EventEmitter as EventEmitter_alias_1 }
+export { EventEmitter as EventEmitter_alias_2 }
+
+declare interface EventEmitterInterface<Events extends EventsConfig> {
+    on<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, listener: (...args: Args) => void): () => void;
+    emit<E extends EventsNames<Events>, Args extends EventsArgs<Events, E>>(event: E, ...args: Args): void;
+    addChannel<E extends EventsNames<Events>, Ns extends string, Emmiter extends ChannelEmitter<Events, Ns, E>>(ns: Ns, event: E, target: Emmiter): () => void;
+}
+export { EventEmitterInterface }
+export { EventEmitterInterface as EventEmitterInterface_alias_1 }
+export { EventEmitterInterface as EventEmitterInterface_alias_2 }
+
+declare type EventsArgs<Events extends EventsConfig, Name extends EventsNames<Events>> = Events[Name] extends any[] ? Events[Name] : [];
+export { EventsArgs }
+export { EventsArgs as EventsArgs_alias_1 }
+export { EventsArgs as EventsArgs_alias_2 }
+
+declare type EventsConfig = {
+    [event: string]: any[];
+};
+export { EventsConfig }
+export { EventsConfig as EventsConfig_alias_1 }
+export { EventsConfig as EventsConfig_alias_2 }
+
+declare type EventsNames<Events extends EventsConfig> = Exclude<keyof Events, symbol | number>;
+export { EventsNames }
+export { EventsNames as EventsNames_alias_1 }
+export { EventsNames as EventsNames_alias_2 }
+
+declare type ExcludedKeys = 'computedTimeRates' | 'aiModelsRates' | 'aiModel';
+
+declare type ExcludedParts = 'services' | 'mailer' | 'aws' | 'computedTimeRates' | 'aiModelsRates';
+
+declare class ExecutionContext {
+    private readonly module;
+    private readonly controller;
+    private readonly handler;
+    private request;
+    private reply;
+    constructor(module: ModuleMetadata, controller: ControllerMetadata, handler: EndpointMetadata);
+    getModule(): ModuleMetadata;
+    getController(): ControllerMetadata;
+    getHandler(): EndpointMetadata;
+    getRequest(): FastifyRequest;
+    getReply(): FastifyReply;
+    provideRequest(request: FastifyRequest): void;
+    provideReply(reply: FastifyReply): void;
+}
+export { ExecutionContext }
+export { ExecutionContext as ExecutionContext_alias_1 }
+export { ExecutionContext as ExecutionContext_alias_2 }
+
+declare const ExecutionContextInjectionToken = "ExecutionContextInjectionToken";
+export { ExecutionContextInjectionToken }
+export { ExecutionContextInjectionToken as ExecutionContextInjectionToken_alias_1 }
+export { ExecutionContextInjectionToken as ExecutionContextInjectionToken_alias_2 }
+
+declare const ExecutionContextToken: InjectionToken<ExecutionContext, undefined>;
+export { ExecutionContextToken }
+export { ExecutionContextToken as ExecutionContextToken_alias_1 }
+export { ExecutionContextToken as ExecutionContextToken_alias_2 }
+
+declare function extractControllerMetadata(target: ClassType): ControllerMetadata;
+export { extractControllerMetadata }
+export { extractControllerMetadata as extractControllerMetadata_alias_1 }
+export { extractControllerMetadata as extractControllerMetadata_alias_2 }
+
+declare function extractModuleMetadata(target: ClassType): ModuleMetadata;
+export { extractModuleMetadata }
+export { extractModuleMetadata as extractModuleMetadata_alias_1 }
+export { extractModuleMetadata as extractModuleMetadata_alias_2 }
+
+export declare interface Factory<T> {
+    create(ctx: any): Promise<T>;
+}
+
+declare class FactoryInjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject>> extends InjectionToken<T, S> {
+    readonly token: InjectionToken<T, S>;
+    readonly factory: () => Promise<z.input<S>>;
+    value?: z.input<S>;
+    resolved: boolean;
+    constructor(token: InjectionToken<T, S>, factory: () => Promise<z.input<S>>);
+    resolve(): Promise<z.input<S>>;
+}
+export { FactoryInjectionToken }
+export { FactoryInjectionToken as FactoryInjectionToken_alias_1 }
+export { FactoryInjectionToken as FactoryInjectionToken_alias_2 }
+
+declare class FactoryNotFound extends Error {
+    name: string;
+    code: ErrorsEnum;
+    constructor(name: string);
+}
+export { FactoryNotFound }
+export { FactoryNotFound as FactoryNotFound_alias_1 }
+export { FactoryNotFound as FactoryNotFound_alias_2 }
+export { FactoryNotFound as FactoryNotFound_alias_3 }
+
+declare class FactoryTokenNotResolved extends Error {
+    code: ErrorsEnum;
+    constructor(name: string | symbol | ClassType);
+}
+export { FactoryTokenNotResolved }
+export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_1 }
+export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_2 }
+export { FactoryTokenNotResolved as FactoryTokenNotResolved_alias_3 }
+
+/**
+ * @publicApi
+ */
+declare function filterLogLevels(parseableString?: string): LogLevel[];
+export { filterLogLevels }
+export { filterLogLevels as filterLogLevels_alias_1 }
+export { filterLogLevels as filterLogLevels_alias_2 }
+export { filterLogLevels as filterLogLevels_alias_3 }
+
+declare class ForbiddenException extends HttpException {
+    constructor(message: string);
+}
+export { ForbiddenException }
+export { ForbiddenException as ForbiddenException_alias_1 }
+export { ForbiddenException as ForbiddenException_alias_2 }
+
+declare function getAllEndpointMetadata(context: ClassMethodDecoratorContext | ClassDecoratorContext): Set<EndpointMetadata>;
+export { getAllEndpointMetadata }
+export { getAllEndpointMetadata as getAllEndpointMetadata_alias_1 }
+export { getAllEndpointMetadata as getAllEndpointMetadata_alias_2 }
+
+declare function getControllerMetadata(target: ClassType, context: ClassDecoratorContext): ControllerMetadata;
+export { getControllerMetadata }
+export { getControllerMetadata as getControllerMetadata_alias_1 }
+export { getControllerMetadata as getControllerMetadata_alias_2 }
+
+declare function getEndpointMetadata(target: Function, context: ClassMethodDecoratorContext): EndpointMetadata;
+export { getEndpointMetadata }
+export { getEndpointMetadata as getEndpointMetadata_alias_1 }
+export { getEndpointMetadata as getEndpointMetadata_alias_2 }
+
+declare function getInjectableToken<R>(target: ClassType): R extends {
+    create(...args: any[]): infer V;
+} ? InjectionToken<V> : InjectionToken<R>;
+export { getInjectableToken }
+export { getInjectableToken as getInjectableToken_alias_1 }
+export { getInjectableToken as getInjectableToken_alias_2 }
+export { getInjectableToken as getInjectableToken_alias_3 }
+
+declare function getModuleMetadata(target: ClassType, context: ClassDecoratorContext): ModuleMetadata;
+export { getModuleMetadata }
+export { getModuleMetadata as getModuleMetadata_alias_1 }
+export { getModuleMetadata as getModuleMetadata_alias_2 }
+
+declare function getServiceLocator(): ServiceLocator;
+export { getServiceLocator }
+export { getServiceLocator as getServiceLocator_alias_1 }
+export { getServiceLocator as getServiceLocator_alias_2 }
+
+declare class GuardRunnerService {
+    runGuards(allGuards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>, executionContext: ExecutionContext): Promise<boolean>;
+    makeContext(executionContext: ExecutionContext): Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
+}
+export { GuardRunnerService }
+export { GuardRunnerService as GuardRunnerService_alias_1 }
+export { GuardRunnerService as GuardRunnerService_alias_2 }
+
+declare function hasControllerMetadata(target: ClassType): boolean;
+export { hasControllerMetadata }
+export { hasControllerMetadata as hasControllerMetadata_alias_1 }
+export { hasControllerMetadata as hasControllerMetadata_alias_2 }
+
+declare function hasModuleMetadata(target: ClassType): boolean;
+export { hasModuleMetadata }
+export { hasModuleMetadata as hasModuleMetadata_alias_1 }
+export { hasModuleMetadata as hasModuleMetadata_alias_2 }
+
+declare function Header(name: HttpHeader, value: string | number | string[]): <T extends Function>(target: T, context: ClassMethodDecoratorContext) => T;
+export { Header }
+export { Header as Header_alias_1 }
+export { Header as Header_alias_2 }
+
+declare function HttpCode(code: number): <T extends Function>(target: T, context: ClassMethodDecoratorContext) => T;
+export { HttpCode }
+export { HttpCode as HttpCode_alias_1 }
+export { HttpCode as HttpCode_alias_2 }
+
+declare class HttpException {
+    readonly statusCode: number;
+    readonly response: string | object;
+    readonly error?: Error | undefined;
+    constructor(statusCode: number, response: string | object, error?: Error | undefined);
+}
+export { HttpException }
+export { HttpException as HttpException_alias_1 }
+export { HttpException as HttpException_alias_2 }
+
+declare function inject<T extends ClassType>(token: T): Promise<InstanceType<T>>;
+
+declare function inject<T, S extends AnyZodObject>(token: InjectionToken<T, S>, args: z.input<S>): Promise<T>;
+
+declare function inject<T, S extends ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, args?: z.input<S>): Promise<T>;
+
+declare function inject<T>(token: InjectionToken<T, undefined>): Promise<T>;
+export { inject }
+export { inject as inject_alias_1 }
+export { inject as inject_alias_2 }
+
+declare function Injectable({ scope, type, token, }?: InjectableOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
+export { Injectable }
+export { Injectable as Injectable_alias_1 }
+export { Injectable as Injectable_alias_2 }
+export { Injectable as Injectable_alias_3 }
+
+declare interface InjectableMetadata<Instance = any, Schema = any> {
+    type: InjectableType;
+    scope: InjectableScope;
+    token: InjectionToken<Instance, Schema>;
+}
+export { InjectableMetadata }
+export { InjectableMetadata as InjectableMetadata_alias_1 }
+export { InjectableMetadata as InjectableMetadata_alias_2 }
+
+declare interface InjectableOptions {
+    scope?: InjectableScope;
+    type?: InjectableType;
+    token?: InjectionToken<any, any>;
+}
+export { InjectableOptions }
+export { InjectableOptions as InjectableOptions_alias_1 }
+export { InjectableOptions as InjectableOptions_alias_2 }
+export { InjectableOptions as InjectableOptions_alias_3 }
+
+declare enum InjectableScope {
+    /**
+     * Singleton scope: The instance is created once and shared across the application.
+     */
+    Singleton = "Singleton",
+    /**
+     * Instance scope: A new instance is created for each injection.
+     */
+    Instance = "Instance"
+}
+export { InjectableScope }
+export { InjectableScope as InjectableScope_alias_1 }
+export { InjectableScope as InjectableScope_alias_2 }
+export { InjectableScope as InjectableScope_alias_3 }
+
+declare const InjectableTokenMeta: unique symbol;
+export { InjectableTokenMeta }
+export { InjectableTokenMeta as InjectableTokenMeta_alias_1 }
+export { InjectableTokenMeta as InjectableTokenMeta_alias_2 }
+export { InjectableTokenMeta as InjectableTokenMeta_alias_3 }
+
+declare enum InjectableType {
+    Class = "Class",
+    Factory = "Factory"
+}
+export { InjectableType }
+export { InjectableType as InjectableType_alias_1 }
+export { InjectableType as InjectableType_alias_2 }
+export { InjectableType as InjectableType_alias_3 }
+
+declare class InjectionToken<T, S extends AnyZodObject | ZodOptional<AnyZodObject> | unknown = unknown> {
+    readonly name: string | symbol | ClassType;
+    readonly schema: AnyZodObject | undefined;
+    id: `${string}-${string}-${string}-${string}-${string}`;
+    constructor(name: string | symbol | ClassType, schema: AnyZodObject | undefined);
+    static create<T extends ClassType>(name: T): InjectionToken<InstanceType<T>, undefined>;
+    static create<T extends ClassType, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(name: T, schema: Schema): InjectionToken<InstanceType<T>, Schema>;
+    static create<T>(name: string | symbol): InjectionToken<T, undefined>;
+    static create<T, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(name: string | any, schema: Schema): InjectionToken<T, Schema>;
+    static bound<T, S extends AnyZodObject | ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, value: z.input<S>): BoundInjectionToken<T, S>;
+    static factory<T, S extends AnyZodObject | ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, factory: () => Promise<z.input<S>>): FactoryInjectionToken<T, S>;
+    static refineType<T>(token: BoundInjectionToken<any, any>): BoundInjectionToken<T, any>;
+}
+export { InjectionToken }
+export { InjectionToken as InjectionToken_alias_1 }
+export { InjectionToken as InjectionToken_alias_2 }
+
+declare class InstanceDestroying extends Error {
+    name: string;
+    code: ErrorsEnum;
+    constructor(name: string);
+}
+export { InstanceDestroying }
+export { InstanceDestroying as InstanceDestroying_alias_1 }
+export { InstanceDestroying as InstanceDestroying_alias_2 }
+export { InstanceDestroying as InstanceDestroying_alias_3 }
+
+declare class InstanceExpired extends Error {
+    name: string;
+    code: ErrorsEnum;
+    constructor(name: string);
+}
+export { InstanceExpired }
+export { InstanceExpired as InstanceExpired_alias_1 }
+export { InstanceExpired as InstanceExpired_alias_2 }
+export { InstanceExpired as InstanceExpired_alias_3 }
+
+declare class InstanceNotFound extends Error {
+    name: string;
+    code: ErrorsEnum;
+    constructor(name: string);
+}
+export { InstanceNotFound }
+export { InstanceNotFound as InstanceNotFound_alias_1 }
+export { InstanceNotFound as InstanceNotFound_alias_2 }
+export { InstanceNotFound as InstanceNotFound_alias_3 }
+
+declare class InternalServerErrorException extends HttpException {
+    constructor(message: string | object, error?: Error);
+}
+export { InternalServerErrorException }
+export { InternalServerErrorException as InternalServerErrorException_alias_1 }
+export { InternalServerErrorException as InternalServerErrorException_alias_2 }
+
+/**
+ * Evaluates to `true` if `T` is `any`. `false` otherwise.
+ * (c) https://stackoverflow.com/a/68633327/5290447
+ */
+declare type IsAny<T> = unknown extends T ? [keyof T] extends [never] ? false : true : false;
+
+declare const isConstructor: (val: any) => boolean;
+export { isConstructor }
+export { isConstructor as isConstructor_alias_1 }
+export { isConstructor as isConstructor_alias_2 }
+export { isConstructor as isConstructor_alias_3 }
+
+declare const isEmpty: (array: any) => boolean;
+export { isEmpty }
+export { isEmpty as isEmpty_alias_1 }
+export { isEmpty as isEmpty_alias_2 }
+export { isEmpty as isEmpty_alias_3 }
+
+declare const isFunction: (val: any) => val is Function;
+export { isFunction }
+export { isFunction as isFunction_alias_1 }
+export { isFunction as isFunction_alias_2 }
+export { isFunction as isFunction_alias_3 }
+
+/**
+ * @publicApi
+ */
+declare function isLogLevel(maybeLogLevel: any): maybeLogLevel is LogLevel;
+export { isLogLevel }
+export { isLogLevel as isLogLevel_alias_1 }
+export { isLogLevel as isLogLevel_alias_2 }
+export { isLogLevel as isLogLevel_alias_3 }
+
+/**
+ * Checks if target level is enabled.
+ * @param targetLevel target level
+ * @param logLevels array of enabled log levels
+ */
+declare function isLogLevelEnabled(targetLevel: LogLevel, logLevels: LogLevel[] | undefined): boolean;
+export { isLogLevelEnabled }
+export { isLogLevelEnabled as isLogLevelEnabled_alias_1 }
+export { isLogLevelEnabled as isLogLevelEnabled_alias_2 }
+export { isLogLevelEnabled as isLogLevelEnabled_alias_3 }
+
+declare const isNil: (val: any) => val is null | undefined;
+export { isNil }
+export { isNil as isNil_alias_1 }
+export { isNil as isNil_alias_2 }
+export { isNil as isNil_alias_3 }
+
+declare const isNumber: (val: any) => val is number;
+export { isNumber }
+export { isNumber as isNumber_alias_1 }
+export { isNumber as isNumber_alias_2 }
+export { isNumber as isNumber_alias_3 }
+
+declare const isObject: (fn: any) => fn is object;
+export { isObject }
+export { isObject as isObject_alias_1 }
+export { isObject as isObject_alias_2 }
+export { isObject as isObject_alias_3 }
+
+declare const isPlainObject: (fn: any) => fn is object;
+export { isPlainObject }
+export { isPlainObject as isPlainObject_alias_1 }
+export { isPlainObject as isPlainObject_alias_2 }
+export { isPlainObject as isPlainObject_alias_3 }
+
+declare const isString: (val: any) => val is string;
+export { isString }
+export { isString as isString_alias_1 }
+export { isString as isString_alias_2 }
+export { isString as isString_alias_3 }
+
+declare const isSymbol: (val: any) => val is symbol;
+export { isSymbol }
+export { isSymbol as isSymbol_alias_1 }
+export { isSymbol as isSymbol_alias_2 }
+export { isSymbol as isSymbol_alias_3 }
+
+declare const isUndefined: (obj: any) => obj is undefined;
+export { isUndefined }
+export { isUndefined as isUndefined_alias_1 }
+export { isUndefined as isUndefined_alias_2 }
+export { isUndefined as isUndefined_alias_3 }
+
+declare const LOG_LEVELS: ["verbose", "debug", "log", "warn", "error", "fatal"];
+export { LOG_LEVELS }
+export { LOG_LEVELS as LOG_LEVELS_alias_1 }
+export { LOG_LEVELS as LOG_LEVELS_alias_2 }
+
+declare const Logger: InjectionToken<LoggerInstance, z.ZodOptional<z.ZodObject<{
+    context: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodObject<{
+        timestamp: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp?: boolean | undefined;
+    }, {
+        timestamp?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    options?: {
+        timestamp?: boolean | undefined;
+    } | undefined;
+    context?: string | undefined;
+}, {
+    options?: {
+        timestamp?: boolean | undefined;
+    } | undefined;
+    context?: string | undefined;
+}>>>;
+export { Logger }
+export { Logger as Logger_alias_1 }
+export { Logger as Logger_alias_2 }
+
+declare class LoggerFactory {
+    create(ctx: any, args: z.infer<typeof LoggerOptions>): LoggerInstance;
+}
+export { LoggerFactory }
+export { LoggerFactory as LoggerFactory_alias_1 }
+export { LoggerFactory as LoggerFactory_alias_2 }
+
+declare const LoggerInjectionToken = "LoggerInjectionToken";
+export { LoggerInjectionToken }
+export { LoggerInjectionToken as LoggerInjectionToken_alias_1 }
+export { LoggerInjectionToken as LoggerInjectionToken_alias_2 }
+
+declare class LoggerInstance implements LoggerService {
+    protected context?: string | undefined;
+    protected options: {
+        timestamp?: boolean;
+    };
+    protected static staticInstanceRef?: LoggerService;
+    protected static logLevels?: LogLevel[];
+    protected localInstanceRef?: LoggerService;
+    constructor();
+    constructor(context: string);
+    constructor(context: string, options?: {
+        timestamp?: boolean;
+    });
+    get localInstance(): LoggerService;
+    /**
+     * Write an 'error' level log.
+     */
+    error(message: any, stack?: string, context?: string): void;
+    error(message: any, ...optionalParams: [...any, string?, string?]): void;
+    /**
+     * Write a 'log' level log.
+     */
+    log(message: any, context?: string): void;
+    log(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'warn' level log.
+     */
+    warn(message: any, context?: string): void;
+    warn(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'debug' level log.
+     */
+    debug(message: any, context?: string): void;
+    debug(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'verbose' level log.
+     */
+    verbose(message: any, context?: string): void;
+    verbose(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'fatal' level log.
+     */
+    fatal(message: any, context?: string): void;
+    fatal(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write an 'error' level log.
+     */
+    static error(message: any, stackOrContext?: string): void;
+    static error(message: any, context?: string): void;
+    static error(message: any, stack?: string, context?: string): void;
+    static error(message: any, ...optionalParams: [...any, string?, string?]): void;
+    /**
+     * Write a 'log' level log.
+     */
+    static log(message: any, context?: string): void;
+    static log(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'warn' level log.
+     */
+    static warn(message: any, context?: string): void;
+    static warn(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'debug' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    static debug(message: any, context?: string): void;
+    static debug(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'verbose' level log.
+     */
+    static verbose(message: any, context?: string): void;
+    static verbose(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'fatal' level log.
+     */
+    static fatal(message: any, context?: string): void;
+    static fatal(message: any, ...optionalParams: [...any, string?]): void;
+    static getTimestamp(): string;
+    static overrideLogger(logger: LoggerService | LogLevel[] | boolean): any;
+    static isLevelEnabled(level: LogLevel): boolean;
+    private registerLocalInstanceRef;
+}
+export { LoggerInstance }
+export { LoggerInstance as LoggerInstance_alias_1 }
+export { LoggerInstance as LoggerInstance_alias_2 }
+
+declare const LoggerOptions: z.ZodOptional<z.ZodObject<{
+    context: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodObject<{
+        timestamp: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp?: boolean | undefined;
+    }, {
+        timestamp?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    options?: {
+        timestamp?: boolean | undefined;
+    } | undefined;
+    context?: string | undefined;
+}, {
+    options?: {
+        timestamp?: boolean | undefined;
+    } | undefined;
+    context?: string | undefined;
+}>>;
+export { LoggerOptions }
+export { LoggerOptions as LoggerOptions_alias_1 }
+export { LoggerOptions as LoggerOptions_alias_2 }
+
+/**
+ * @publicApi
+ */
+declare interface LoggerService {
+    /**
+     * Write a 'log' level log.
+     */
+    log(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write an 'error' level log.
+     */
+    error(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'warn' level log.
+     */
+    warn(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'debug' level log.
+     */
+    debug?(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'verbose' level log.
+     */
+    verbose?(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'fatal' level log.
+     */
+    fatal?(message: any, ...optionalParams: any[]): any;
+    /**
+     * Set log levels.
+     * @param levels log levels
+     */
+    setLogLevels?(levels: LogLevel[]): any;
+}
+export { LoggerService }
+export { LoggerService as LoggerService_alias_1 }
+export { LoggerService as LoggerService_alias_2 }
+
+/**
+ * @publicApi
+ */
+declare type LogLevel = (typeof LOG_LEVELS)[number];
+export { LogLevel }
+export { LogLevel as LogLevel_alias_1 }
+export { LogLevel as LogLevel_alias_2 }
+
+export declare function makeProxyServiceLocator(serviceLocator: ServiceLocator, ctx: ServiceLocatorAbstractFactoryContext): ServiceLocator;
+
+declare function Module(metadata: ModuleOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
+export { Module }
+export { Module as Module_alias_1 }
+export { Module as Module_alias_2 }
+
+declare class ModuleLoaderService {
+    private logger;
+    private modulesMetadata;
+    private loadedModules;
+    private initialized;
+    loadModules(appModule: ClassTypeWithInstance<NaviosModule>): Promise<void>;
+    private traverseModules;
+    private mergeMetadata;
+    getAllModules(): Map<string, ModuleMetadata>;
+    dispose(): void;
+}
+export { ModuleLoaderService }
+export { ModuleLoaderService as ModuleLoaderService_alias_1 }
+export { ModuleLoaderService as ModuleLoaderService_alias_2 }
+
+declare interface ModuleMetadata {
+    controllers: Set<ClassType>;
+    imports: Set<ClassType>;
+    guards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
+    customAttributes: Map<string | symbol, any>;
+}
+export { ModuleMetadata }
+export { ModuleMetadata as ModuleMetadata_alias_1 }
+export { ModuleMetadata as ModuleMetadata_alias_2 }
+
+declare const ModuleMetadataKey: unique symbol;
+export { ModuleMetadataKey }
+export { ModuleMetadataKey as ModuleMetadataKey_alias_1 }
+export { ModuleMetadataKey as ModuleMetadataKey_alias_2 }
+
+declare interface ModuleOptions {
+    controllers?: ClassType[] | Set<ClassType>;
+    imports?: ClassType[] | Set<ClassType>;
+    guards?: ClassType[] | Set<ClassType>;
+}
+export { ModuleOptions }
+export { ModuleOptions as ModuleOptions_alias_1 }
+export { ModuleOptions as ModuleOptions_alias_2 }
+
+declare class NaviosApplication {
+    private moduleLoader;
+    private controllerAdapter;
+    private logger;
+    private server;
+    private corsOptions;
+    private globalPrefix;
+    private appModule;
+    private options;
+    isInitialized: boolean;
+    setup(appModule: ClassTypeWithInstance<NaviosModule>, options?: NaviosApplicationOptions): void;
+    init(): Promise<void>;
+    private getFastifyInstance;
+    private configureFastifyInstance;
+    private initModules;
+    enableCors(options: FastifyCorsOptions): void;
+    setGlobalPrefix(prefix: string): void;
+    getServer(): FastifyInstance;
+    listen(options: FastifyListenOptions): Promise<void>;
+    dispose(): Promise<void>;
+    close(): Promise<void>;
+}
+export { NaviosApplication }
+export { NaviosApplication as NaviosApplication_alias_1 }
+
+declare interface NaviosApplicationContextOptions {
+    /**
+     * Specifies the logger to use.  Pass `false` to turn off logging.
+     */
+    logger?: LoggerService | LogLevel[] | false;
+}
+export { NaviosApplicationContextOptions }
+export { NaviosApplicationContextOptions as NaviosApplicationContextOptions_alias_1 }
+
+declare interface NaviosApplicationOptions extends Omit<FastifyServerOptions, 'logger'>, NaviosApplicationContextOptions {
+}
+export { NaviosApplicationOptions }
+export { NaviosApplicationOptions as NaviosApplicationOptions_alias_1 }
+
+declare class NaviosFactory {
+    static create(appModule: ClassTypeWithInstance<NaviosModule>, options?: NaviosApplicationOptions): Promise<NaviosApplication>;
+    private static registerLoggerConfiguration;
+}
+export { NaviosFactory }
+export { NaviosFactory as NaviosFactory_alias_1 }
+
+declare interface NaviosModule {
+    onModuleInit?: () => Promise<void> | void;
+}
+export { NaviosModule }
+export { NaviosModule as NaviosModule_alias_1 }
+export { NaviosModule as NaviosModule_alias_2 }
+
+declare const normalizePath: (path?: string) => string;
+export { normalizePath }
+export { normalizePath as normalizePath_alias_1 }
+export { normalizePath as normalizePath_alias_2 }
+export { normalizePath as normalizePath_alias_3 }
+
+declare class NotFoundException extends HttpException {
+    readonly response: string | object;
+    readonly error?: Error | undefined;
+    constructor(response: string | object, error?: Error | undefined);
+}
+export { NotFoundException }
+export { NotFoundException as NotFoundException_alias_1 }
+export { NotFoundException as NotFoundException_alias_2 }
+
+/**
+ * Useful for tests or when you want to override a service
+ * with a different implementation.
+ */
+declare function override<T>(token: InjectionToken<T>, target: ClassType): () => void;
+export { override }
+export { override as override_alias_1 }
+export { override as override_alias_2 }
+
+declare type Path<T> = keyof T extends string ? PathImpl2<T> extends infer P ? P extends string | keyof T ? P : keyof T : keyof T : never;
+export { Path }
+export { Path as Path_alias_1 }
+export { Path as Path_alias_2 }
+
+declare type PathImpl<T, Key extends keyof T> = Key extends string ? Key extends ExcludedKeys ? never : IsAny<T[Key]> extends true ? never : T[Key] extends string ? never : T[Key] extends any[] ? never : T[Key] extends Record<string, any> ? Key extends ExcludedParts ? `${Key}.${Exclude<keyof T[Key], keyof any[]> & string}` : `${Key}.${PathImpl<T[Key], Exclude<keyof T[Key], keyof any[]>> & string}` | `${Key}.${Exclude<keyof T[Key], keyof any[]> & string}` : never : never;
+export { PathImpl }
+export { PathImpl as PathImpl_alias_1 }
+export { PathImpl as PathImpl_alias_2 }
+
+declare type PathImpl2<T> = PathImpl<T, keyof T> | keyof T;
+export { PathImpl2 }
+export { PathImpl2 as PathImpl2_alias_1 }
+export { PathImpl2 as PathImpl2_alias_2 }
+
+declare type PathValue<T, P extends Path<T>> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? Rest extends Path<T[Key]> ? PathValue<T[Key], Rest> : never : never : P extends keyof T ? T[P] : never;
+export { PathValue }
+export { PathValue as PathValue_alias_1 }
+export { PathValue as PathValue_alias_2 }
+
+declare class PinoWrapper {
+    protected readonly logger: LoggerService;
+    constructor(logger: LoggerService);
+    fatal(message: any, ...optionalParams: any[]): void;
+    error(message: any, ...optionalParams: any[]): void;
+    warn(message: any, ...optionalParams: any[]): void;
+    info(): void;
+    debug(message: any, ...optionalParams: any[]): void;
+    trace(message: any, ...optionalParams: any[]): void;
+    silent(): void;
+    child(options: any): PinoWrapper;
+    get level(): any;
+}
+export { PinoWrapper }
+export { PinoWrapper as PinoWrapper_alias_1 }
+export { PinoWrapper as PinoWrapper_alias_2 }
+
+declare let promiseCollector: null | ((promise: Promise<any>) => void);
+
+declare function provideConfig<ConfigMap extends Record<string, unknown>>(options: z.input<typeof ConfigProviderOptions>): InjectionToken<ConfigServiceInstance<ConfigMap>, undefined>;
+export { provideConfig }
+export { provideConfig as provideConfig_alias_1 }
+export { provideConfig as provideConfig_alias_2 }
+
+declare function provideServiceLocator(locator: ServiceLocator): ServiceLocator;
+export { provideServiceLocator }
+export { provideServiceLocator as provideServiceLocator_alias_1 }
+export { provideServiceLocator as provideServiceLocator_alias_2 }
+
+export declare class ProxyServiceLocator implements ServiceLocator {
+    private readonly serviceLocator;
+    private readonly ctx;
+    constructor(serviceLocator: ServiceLocator, ctx: ServiceLocatorAbstractFactoryContext);
+    get abstractFactories(): Map<InjectionToken<any, any>, (ctx: ServiceLocatorAbstractFactoryContext, args: any) => Promise<any>>;
+    getEventBus(): ServiceLocatorEventBus;
+    registerAbstractFactory<Instance, Schema extends AnyZodObject | undefined>(token: InjectionToken<Instance, Schema>, factory: (ctx: ServiceLocatorAbstractFactoryContext, values: Schema extends AnyZodObject ? output<Schema> : undefined) => Promise<Instance>): void;
+    getInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
+    getOrThrowInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Promise<Instance>;
+    getSyncInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Instance | null;
+    invalidate(service: string, round?: number): Promise<any>;
+    ready(): Promise<null>;
+    makeInstanceName(token: InjectionToken<any, any>, args: any): string;
+}
+
+declare const Reply: InjectionToken<FastifyReply<RouteGenericInterface, RawServerDefault, IncomingMessage, ServerResponse<IncomingMessage>, unknown, FastifySchema, FastifyTypeProviderDefault, unknown>, undefined>;
+export { Reply }
+export { Reply as Reply_alias_1 }
+export { Reply as Reply_alias_2 }
+
+declare const Request_2: InjectionToken<FastifyRequest<RouteGenericInterface, RawServerDefault, IncomingMessage, FastifySchema, FastifyTypeProviderDefault, unknown, FastifyBaseLogger, ResolveFastifyRequestType<FastifyTypeProviderDefault, FastifySchema, RouteGenericInterface>>, undefined>;
+export { Request_2 as Request }
+export { Request_2 as Request_alias_1 }
+export { Request_2 as Request_alias_2 }
+
+declare function resolveService<T extends ClassType>(ctx: ServiceLocatorAbstractFactoryContext, target: T, args?: any[]): Promise<InstanceType<T>>;
+export { resolveService }
+export { resolveService as resolveService_alias_1 }
+export { resolveService as resolveService_alias_2 }
+
+declare class ServiceLocator {
+    private readonly logger;
+    private abstractFactories;
+    private instanceFactories;
+    private readonly eventBus;
+    private readonly manager;
+    constructor(logger?: Console | null);
+    getEventBus(): ServiceLocatorEventBus;
+    registerInstance<Instance>(token: InjectionToken<Instance, undefined>, instance: Instance): void;
+    removeInstance<Instance>(token: InjectionToken<Instance, undefined>): Promise<any>;
+    registerAbstractFactory<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, factory: (ctx: ServiceLocatorAbstractFactoryContext, values: Schema extends AnyZodObject ? z.output<Schema> : undefined) => Promise<Instance>, type?: InjectableScope): void;
+    private resolveTokenArgs;
+    getInstanceIdentifier<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): string;
+    getInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
+    getOrThrowInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Promise<Instance>;
+    private notifyListeners;
+    private createInstance;
+    private createInstanceFromAbstractFactory;
+    private createContextForAbstractFactory;
+    getSyncInstance<Instance, Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : Schema extends ZodOptional<AnyZodObject> ? z.input<Schema> | undefined : undefined): Instance | null;
+    invalidate(service: string, round?: number): Promise<any>;
+    ready(): Promise<null>;
+    makeInstanceName(token: InjectionToken<any, any>, args: any): string;
+}
+export { ServiceLocator }
+export { ServiceLocator as ServiceLocator_alias_1 }
+export { ServiceLocator as ServiceLocator_alias_2 }
+
+declare interface ServiceLocatorAbstractFactoryContext {
+    inject: typeof inject;
+    addDependency: ((token: InjectionToken<any, undefined>) => void) | (<S extends AnyZodObject>(token: InjectionToken<any, S>, args: z.input<S>) => void);
+    on: ServiceLocatorEventBus['on'];
+    getDependencies: () => string[];
+    invalidate: () => void;
+    addEffect: (listener: () => void) => void;
+    getDestroyListeners: () => (() => void)[];
+    setTtl: (ttl: number) => void;
+    getTtl: () => number;
+}
+export { ServiceLocatorAbstractFactoryContext }
+export { ServiceLocatorAbstractFactoryContext as ServiceLocatorAbstractFactoryContext_alias_1 }
+export { ServiceLocatorAbstractFactoryContext as ServiceLocatorAbstractFactoryContext_alias_2 }
+
+declare class ServiceLocatorEventBus {
+    private readonly logger;
+    private listeners;
+    constructor(logger?: Console | null);
+    on<Event extends string | `pre:${string}` | `post:${string}`>(ns: string, event: Event, listener: (event: Event) => void): () => void;
+    emit(key: string, event: string): Promise<PromiseSettledResult<any>[] | undefined>;
+}
+export { ServiceLocatorEventBus }
+export { ServiceLocatorEventBus as ServiceLocatorEventBus_alias_1 }
+export { ServiceLocatorEventBus as ServiceLocatorEventBus_alias_2 }
+
+declare type ServiceLocatorInstanceDestroyListener = () => void | Promise<void>;
+export { ServiceLocatorInstanceDestroyListener }
+export { ServiceLocatorInstanceDestroyListener as ServiceLocatorInstanceDestroyListener_alias_1 }
+export { ServiceLocatorInstanceDestroyListener as ServiceLocatorInstanceDestroyListener_alias_2 }
+
+declare type ServiceLocatorInstanceEffect = () => void;
+export { ServiceLocatorInstanceEffect }
+export { ServiceLocatorInstanceEffect as ServiceLocatorInstanceEffect_alias_1 }
+export { ServiceLocatorInstanceEffect as ServiceLocatorInstanceEffect_alias_2 }
+
+declare type ServiceLocatorInstanceHolder<Instance = unknown> = ServiceLocatorInstanceHolderCreating<Instance> | ServiceLocatorInstanceHolderCreated<Instance> | ServiceLocatorInstanceHolderDestroying<Instance>;
+export { ServiceLocatorInstanceHolder }
+export { ServiceLocatorInstanceHolder as ServiceLocatorInstanceHolder_alias_1 }
+export { ServiceLocatorInstanceHolder as ServiceLocatorInstanceHolder_alias_2 }
+
+declare interface ServiceLocatorInstanceHolderCreated<Instance> {
+    status: ServiceLocatorInstanceHolderStatus.Created;
+    name: string;
+    instance: Instance;
+    creationPromise: null;
+    destroyPromise: null;
+    kind: ServiceLocatorInstanceHolderKind;
+    effects: ServiceLocatorInstanceEffect[];
+    deps: string[];
+    destroyListeners: ServiceLocatorInstanceDestroyListener[];
+    createdAt: number;
+    ttl: number;
+}
+export { ServiceLocatorInstanceHolderCreated }
+export { ServiceLocatorInstanceHolderCreated as ServiceLocatorInstanceHolderCreated_alias_1 }
+export { ServiceLocatorInstanceHolderCreated as ServiceLocatorInstanceHolderCreated_alias_2 }
+
+declare interface ServiceLocatorInstanceHolderCreating<Instance> {
+    status: ServiceLocatorInstanceHolderStatus.Creating;
+    name: string;
+    instance: null;
+    creationPromise: Promise<[undefined, Instance]> | null;
+    destroyPromise: null;
+    kind: ServiceLocatorInstanceHolderKind;
+    effects: ServiceLocatorInstanceEffect[];
+    deps: string[];
+    destroyListeners: ServiceLocatorInstanceDestroyListener[];
+    createdAt: number;
+    ttl: number;
+}
+export { ServiceLocatorInstanceHolderCreating }
+export { ServiceLocatorInstanceHolderCreating as ServiceLocatorInstanceHolderCreating_alias_1 }
+export { ServiceLocatorInstanceHolderCreating as ServiceLocatorInstanceHolderCreating_alias_2 }
+
+declare interface ServiceLocatorInstanceHolderDestroying<Instance> {
+    status: ServiceLocatorInstanceHolderStatus.Destroying;
+    name: string;
+    instance: Instance | null;
+    creationPromise: null;
+    destroyPromise: Promise<void>;
+    kind: ServiceLocatorInstanceHolderKind;
+    effects: ServiceLocatorInstanceEffect[];
+    deps: string[];
+    destroyListeners: ServiceLocatorInstanceDestroyListener[];
+    createdAt: number;
+    ttl: number;
+}
+export { ServiceLocatorInstanceHolderDestroying }
+export { ServiceLocatorInstanceHolderDestroying as ServiceLocatorInstanceHolderDestroying_alias_1 }
+export { ServiceLocatorInstanceHolderDestroying as ServiceLocatorInstanceHolderDestroying_alias_2 }
+
+declare enum ServiceLocatorInstanceHolderKind {
+    Instance = "instance",
+    Factory = "factory",
+    AbstractFactory = "abstractFactory"
+}
+export { ServiceLocatorInstanceHolderKind }
+export { ServiceLocatorInstanceHolderKind as ServiceLocatorInstanceHolderKind_alias_1 }
+export { ServiceLocatorInstanceHolderKind as ServiceLocatorInstanceHolderKind_alias_2 }
+
+declare enum ServiceLocatorInstanceHolderStatus {
+    Created = "created",
+    Creating = "creating",
+    Destroying = "destroying"
+}
+export { ServiceLocatorInstanceHolderStatus }
+export { ServiceLocatorInstanceHolderStatus as ServiceLocatorInstanceHolderStatus_alias_1 }
+export { ServiceLocatorInstanceHolderStatus as ServiceLocatorInstanceHolderStatus_alias_2 }
+
+declare class ServiceLocatorManager {
+    private readonly logger;
+    private readonly instancesHolders;
+    constructor(logger?: Console | null);
+    get(name: string): [InstanceExpired | InstanceDestroying, ServiceLocatorInstanceHolder] | [InstanceNotFound] | [undefined, ServiceLocatorInstanceHolder];
+    set(name: string, holder: ServiceLocatorInstanceHolder): void;
+    has(name: string): [InstanceExpired | InstanceDestroying] | [undefined, boolean];
+    delete(name: string): boolean;
+    filter(predicate: (value: ServiceLocatorInstanceHolder<any>, key: string) => boolean): Map<string, ServiceLocatorInstanceHolder>;
+}
+export { ServiceLocatorManager }
+export { ServiceLocatorManager as ServiceLocatorManager_alias_1 }
+export { ServiceLocatorManager as ServiceLocatorManager_alias_2 }
+
+declare function setPromiseCollector(collector: null | ((promise: Promise<any>) => void)): typeof promiseCollector;
+export { setPromiseCollector }
+export { setPromiseCollector as setPromiseCollector_alias_1 }
+export { setPromiseCollector as setPromiseCollector_alias_2 }
+
+declare const stripEndSlash: (path: string) => string;
+export { stripEndSlash }
+export { stripEndSlash as stripEndSlash_alias_1 }
+export { stripEndSlash as stripEndSlash_alias_2 }
+export { stripEndSlash as stripEndSlash_alias_3 }
+
+declare function syncInject<T extends ClassType>(token: T): InstanceType<T>;
+
+declare function syncInject<T, S extends AnyZodObject>(token: InjectionToken<T, S>, args: z.input<S>): T;
+
+declare function syncInject<T, S extends ZodOptional<AnyZodObject>>(token: InjectionToken<T, S>, args: z.input<S>): T;
+
+declare function syncInject<T>(token: InjectionToken<T, undefined>): T;
+export { syncInject }
+export { syncInject as syncInject_alias_1 }
+export { syncInject as syncInject_alias_2 }
+
+declare class UnauthorizedException extends HttpException {
+    constructor(message: string | object, error?: Error);
+}
+export { UnauthorizedException }
+export { UnauthorizedException as UnauthorizedException_alias_1 }
+export { UnauthorizedException as UnauthorizedException_alias_2 }
+
+declare class UnknownError extends Error {
+    code: ErrorsEnum;
+    parent?: Error;
+    constructor(message: string | Error);
+}
+export { UnknownError }
+export { UnknownError as UnknownError_alias_1 }
+export { UnknownError as UnknownError_alias_2 }
+export { UnknownError as UnknownError_alias_3 }
+
+declare function UseGuards(...guards: (ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>)[]): <T extends Function>(target: T, context: ClassMethodDecoratorContext | ClassDecoratorContext) => T;
+export { UseGuards }
+export { UseGuards as UseGuards_alias_1 }
+export { UseGuards as UseGuards_alias_2 }
+
+declare const yellow: (text: string) => string;
+export { yellow }
+export { yellow as yellow_alias_1 }
+export { yellow as yellow_alias_2 }
+export { yellow as yellow_alias_3 }
+
+export { }