@navios/core 0.1.0 → 0.1.2

package/dist/index.d.mts

@@ -1,22 +1,169 @@
-import { AnyZodObject, z, ZodType } from 'zod';
+import { AnyZodObject, ZodOptional, z, ZodType } from 'zod';
 import { BaseEndpointConfig, EndpointFunctionArgs, HttpMethod } from '@navios/common';
 import * as fastify from 'fastify';
 import { FastifyRequest, FastifyReply, FastifyInstance, FastifyServerOptions, FastifyListenOptions } from 'fastify';
+import { InspectOptions } from 'util';
 import * as http from 'http';
 import * as fastify_types_type_provider_js from 'fastify/types/type-provider.js';
 import { FastifyCorsOptions } from '@fastify/cors';
 
+declare function envInt(key: keyof NodeJS.ProcessEnv, defaultValue: number): number;
+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;
+
+declare const LOG_LEVELS: ["verbose", "debug", "log", "warn", "error", "fatal"];
+/**
+ * @publicApi
+ */
+type LogLevel = (typeof LOG_LEVELS)[number];
+
+/**
+ * @publicApi
+ */
+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;
+}
+
+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;
+}
+
+/**
+ * Evaluates to `true` if `T` is `any`. `false` otherwise.
+ * (c) https://stackoverflow.com/a/68633327/5290447
+ */
+type IsAny<T> = unknown extends T ? [keyof T] extends [never] ? false : true : false;
+type ExcludedParts = 'services' | 'mailer' | 'aws' | 'computedTimeRates' | 'aiModelsRates';
+type ExcludedKeys = 'computedTimeRates' | 'aiModelsRates' | 'aiModel';
+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;
+type PathImpl2<T> = PathImpl<T, keyof T> | keyof T;
+type Path<T> = keyof T extends string ? PathImpl2<T> extends infer P ? P extends string | keyof T ? P : keyof T : keyof T : never;
+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;
+
+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>;
+}
+
 type ClassType = new (...args: any[]) => any;
 type ClassTypeWithInstance<T> = new (...args: any[]) => T;
-declare class InjectionToken<T, S extends AnyZodObject | unknown = unknown> {
+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>(name: T, schema: Schema): InjectionToken<InstanceType<T>, Schema>;
+    static create<T extends ClassType, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(name: T, schema: Schema): InjectionToken<InstanceType<T>, Schema>;
     static create<T>(name: string): InjectionToken<T, undefined>;
-    static create<T, Schema extends AnyZodObject>(name: string, schema: Schema): InjectionToken<T, Schema>;
+    static create<T, Schema extends AnyZodObject | ZodOptional<AnyZodObject>>(name: string, schema: Schema): InjectionToken<T, Schema>;
     toString(): string | symbol | ClassType;
 }
 
@@ -109,6 +256,7 @@ declare class EventEmitter<Events extends EventsConfig = {}> implements EventEmi
 
 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>;
 
 declare class ServiceLocatorEventBus {
@@ -141,15 +289,15 @@ declare class ServiceLocator {
     getEventBus(): ServiceLocatorEventBus;
     registerInstance<Instance>(token: InjectionToken<Instance, undefined>, instance: Instance): void;
     removeInstance<Instance>(token: InjectionToken<Instance, undefined>): Promise<any>;
-    registerAbstractFactory<Instance, Schema extends AnyZodObject | undefined>(token: InjectionToken<Instance, Schema>, factory: (ctx: ServiceLocatorAbstractFactoryContext, values: Schema extends AnyZodObject ? z.output<Schema> : undefined) => Promise<Instance>, type?: InjectableScope): void;
-    getInstanceIdentifier<Instance, Schema extends AnyZodObject | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : undefined): string;
-    getInstance<Instance, Schema extends AnyZodObject | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : undefined): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]>;
-    getOrThrowInstance<Instance, Schema extends AnyZodObject | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : undefined): Promise<Instance>;
+    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;
+    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 | undefined>(token: InjectionToken<Instance, Schema>, args: Schema extends AnyZodObject ? z.input<Schema> : undefined): Instance | null;
+    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;
@@ -231,9 +379,323 @@ declare class ServiceLocatorManager {
 declare let promiseCollector: null | ((promise: Promise<any>) => void);
 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;
 declare function setPromiseCollector(collector: null | ((promise: Promise<any>) => void)): typeof promiseCollector;
 
+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;
+};
+declare const yellow: (text: string) => string;
+
+/**
+ * @publicApi
+ */
+declare function filterLogLevels(parseableString?: string): LogLevel[];
+
+/**
+ * @publicApi
+ */
+declare function isLogLevel(maybeLogLevel: any): maybeLogLevel is LogLevel;
+
+/**
+ * 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;
+
+declare const isUndefined: (obj: any) => obj is undefined;
+declare const isObject: (fn: any) => fn is object;
+declare const isPlainObject: (fn: any) => fn is object;
+declare const addLeadingSlash: (path?: string) => string;
+declare const normalizePath: (path?: string) => string;
+declare const stripEndSlash: (path: string) => string;
+declare const isFunction: (val: any) => val is Function;
+declare const isString: (val: any) => val is string;
+declare const isNumber: (val: any) => val is number;
+declare const isConstructor: (val: any) => boolean;
+declare const isNil: (val: any) => val is null | undefined;
+declare const isEmpty: (array: any) => boolean;
+declare const isSymbol: (val: any) => val is symbol;
+
+/**
+ * @publicApi
+ */
+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;
+}
+/**
+ * @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;
+}
+
+declare const LoggerInjectionToken = "LoggerInjectionToken";
+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;
+}>>;
+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;
+}>>>;
+declare class LoggerFactory {
+    create(ctx: any, args: z.infer<typeof LoggerOptions>): LoggerInstance;
+}
+
+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(message: any, ...optionalParams: any[]): void;
+    debug(message: any, ...optionalParams: any[]): void;
+    trace(message: any, ...optionalParams: any[]): void;
+    silent(message: any, ...optionalParams: any[]): void;
+    child(options: any): PinoWrapper;
+    get level(): any;
+}
+
+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>;
+}
+
+declare const ConfigProviderInjectionToken = "ConfigProvider";
+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;
+}>;
+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;
+}>>;
+declare class ConfigProviderFactory {
+    logger: Promise<LoggerInstance>;
+    create(ctx: any, args: z.infer<typeof ConfigProviderOptions>): Promise<ConfigServiceInstance<unknown>>;
+}
+declare function makeConfigToken<Config extends Record<string, unknown>>(options: z.input<typeof ConfigProviderOptions>): InjectionToken<ConfigService<Config>>;
+
 interface ControllerOptions {
     guards?: ClassType[] | Set<ClassType>;
 }
@@ -315,10 +777,12 @@ declare class GuardRunnerService {
 
 declare class ControllerAdapterService {
     guardRunner: GuardRunnerService;
+    private logger;
     setupController(controller: ClassType, instance: FastifyInstance, moduleMetadata: ModuleMetadata): void;
 }
 
 declare class ModuleLoaderService {
+    private logger;
     private modulesMetadata;
     private loadedModules;
     private initialized;
@@ -400,11 +864,18 @@ declare class AttributeFactory {
     static has<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | EndpointMetadata): boolean;
 }
 
-interface NaviosApplicationOptions extends FastifyServerOptions {
+interface NaviosApplicationContextOptions {
+    /**
+     * Specifies the logger to use.  Pass `false` to turn off logging.
+     */
+    logger?: LoggerService | LogLevel[] | false;
+}
+interface NaviosApplicationOptions extends Omit<FastifyServerOptions, 'logger'>, NaviosApplicationContextOptions {
 }
 declare class NaviosApplication {
     private moduleLoader;
     private controllerAdapter;
+    private logger;
     private server;
     private corsOptions;
     private globalPrefix;
@@ -412,6 +883,8 @@ declare class NaviosApplication {
     private options;
     setup(appModule: ClassTypeWithInstance<NaviosModule>, options?: NaviosApplicationOptions): void;
     init(): Promise<void>;
+    private getFastifyInstance;
+    private initModules;
     enableCors(options: FastifyCorsOptions): void;
     setGlobalPrefix(prefix: string): void;
     getServer(): FastifyInstance;
@@ -420,6 +893,7 @@ declare class NaviosApplication {
 
 declare class NaviosFactory {
     static create(appModule: ClassTypeWithInstance<NaviosModule>, options?: NaviosApplicationOptions): Promise<NaviosApplication>;
+    private static registerLoggerConfiguration;
 }
 
-export { Application, AttributeFactory, BadRequestException, type CanActivate, type ChannelEmitter, type ClassAttribute, type ClassSchemaAttribute, type ClassType, type ClassTypeWithInstance, ConflictException, Controller, ControllerAdapterService, type ControllerMetadata, ControllerMetadataKey, type ControllerOptions, Endpoint, type EndpointMetadata, EndpointMetadataKey, type EndpointParams, ErrorsEnum, EventEmitter, type EventEmitterInterface, type EventsArgs, type EventsConfig, type EventsNames, ExecutionContext, ExecutionContextInjectionToken, ExecutionContextToken, FactoryNotFound, ForbiddenException, GuardRunnerService, HttpException, Injectable, type InjectableMetadata, type InjectableOptions, InjectableScope, InjectableTokenMeta, InjectableType, InjectionToken, InstanceDestroying, InstanceExpired, InstanceNotFound, InternalServerErrorException, Module, ModuleLoaderService, type ModuleMetadata, ModuleMetadataKey, type ModuleOptions, NaviosApplication, type NaviosApplicationOptions, NaviosFactory, type NaviosModule, NotFoundException, Reply, Request, ServiceLocator, type ServiceLocatorAbstractFactoryContext, ServiceLocatorEventBus, type ServiceLocatorInstanceDestroyListener, type ServiceLocatorInstanceEffect, type ServiceLocatorInstanceHolder, type ServiceLocatorInstanceHolderCreated, type ServiceLocatorInstanceHolderCreating, type ServiceLocatorInstanceHolderDestroying, ServiceLocatorInstanceHolderKind, ServiceLocatorInstanceHolderStatus, ServiceLocatorManager, UnauthorizedException, UnknownError, UseGuards, extractControllerMetadata, extractModuleMetadata, getAllEndpointMetadata, getControllerMetadata, getEndpointMetadata, getInjectableToken, getModuleMetadata, getServiceLocator, hasControllerMetadata, hasModuleMetadata, inject, override, provideServiceLocator, setPromiseCollector, syncInject };
+export { Application, AttributeFactory, BadRequestException, type CanActivate, type ChannelEmitter, type ClassAttribute, type ClassSchemaAttribute, type ClassType, type ClassTypeWithInstance, ConfigProvider, ConfigProviderFactory, ConfigProviderInjectionToken, ConfigProviderOptions, type ConfigService, ConfigServiceInstance, ConflictException, ConsoleLogger, type ConsoleLoggerOptions, Controller, ControllerAdapterService, type ControllerMetadata, ControllerMetadataKey, type ControllerOptions, Endpoint, type EndpointMetadata, EndpointMetadataKey, type EndpointParams, ErrorsEnum, EventEmitter, type EventEmitterInterface, type EventsArgs, type EventsConfig, type EventsNames, ExecutionContext, ExecutionContextInjectionToken, ExecutionContextToken, FactoryNotFound, ForbiddenException, GuardRunnerService, HttpException, Injectable, type InjectableMetadata, type InjectableOptions, InjectableScope, InjectableTokenMeta, InjectableType, InjectionToken, InstanceDestroying, InstanceExpired, InstanceNotFound, InternalServerErrorException, LOG_LEVELS, type LogLevel, Logger, LoggerFactory, LoggerInjectionToken, LoggerInstance, LoggerOptions, type LoggerService, Module, ModuleLoaderService, type ModuleMetadata, ModuleMetadataKey, type ModuleOptions, NaviosApplication, type NaviosApplicationContextOptions, type NaviosApplicationOptions, NaviosFactory, type NaviosModule, NotFoundException, type Path, type PathImpl, type PathImpl2, type PathValue, PinoWrapper, Reply, Request, ServiceLocator, type ServiceLocatorAbstractFactoryContext, ServiceLocatorEventBus, type ServiceLocatorInstanceDestroyListener, type ServiceLocatorInstanceEffect, type ServiceLocatorInstanceHolder, type ServiceLocatorInstanceHolderCreated, type ServiceLocatorInstanceHolderCreating, type ServiceLocatorInstanceHolderDestroying, ServiceLocatorInstanceHolderKind, ServiceLocatorInstanceHolderStatus, ServiceLocatorManager, UnauthorizedException, UnknownError, UseGuards, addLeadingSlash, clc, envInt, envString, extractControllerMetadata, extractModuleMetadata, filterLogLevels, getAllEndpointMetadata, getControllerMetadata, getEndpointMetadata, getInjectableToken, getModuleMetadata, getServiceLocator, hasControllerMetadata, hasModuleMetadata, inject, isConstructor, isEmpty, isFunction, isLogLevel, isLogLevelEnabled, isNil, isNumber, isObject, isPlainObject, isString, isSymbol, isUndefined, makeConfigToken, normalizePath, override, provideServiceLocator, setPromiseCollector, stripEndSlash, syncInject, yellow };