@navios/core 0.6.0 → 0.7.1

package/lib/index-DW9EPAE6.d.mts

@@ -0,0 +1,2156 @@
+import * as _navios_di0 from "@navios/di";
+import { AnyInjectableType, ClassType, ClassTypeWithInstance, Container, FactoryContext, FactoryInjectionToken, InjectionToken, ScopedContainer } from "@navios/di";
+import z, { ZodDiscriminatedUnion, ZodObject, ZodType, z as z$1 } from "zod/v4";
+import { BaseEndpointConfig, BaseStreamConfig, EndpointFunctionArgs, HttpMethod, Util_FlatObject } from "@navios/builder";
+import { InspectOptions } from "util";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { OutgoingHttpHeaders } from "http";
+
+//#region src/config/utils/helpers.d.mts
+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;
+//#endregion
+//#region src/config/types.d.mts
+/**
+ * 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$1 extends keyof T> = Key$1 extends string ? Key$1 extends ExcludedKeys ? never : IsAny<T[Key$1]> extends true ? never : T[Key$1] extends string ? never : T[Key$1] extends any[] ? never : T[Key$1] extends Record<string, any> ? Key$1 extends ExcludedParts ? `${Key$1}.${Exclude<keyof T[Key$1], keyof any[]> & string}` : `${Key$1}.${PathImpl<T[Key$1], Exclude<keyof T[Key$1], keyof any[]>> & string}` | `${Key$1}.${Exclude<keyof T[Key$1], 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;
+//#endregion
+//#region src/config/config-service.interface.d.mts
+/**
+ * Interface for configuration service implementations.
+ *
+ * Provides type-safe access to configuration values with support for nested paths.
+ *
+ * @typeParam Config - The configuration object type
+ */
+interface ConfigServiceInterface<Config = Record<string, unknown>> {
+  /**
+   * Gets the entire configuration object.
+   */
+  getConfig: () => Config;
+  /**
+   * Gets a configuration value by key path. Returns `null` if not found.
+   *
+   * @param key - Dot-separated path to the configuration value (e.g., 'database.host')
+   * @returns The configuration value or `null` if not found
+   */
+  get: <Key$1 extends Path<Config>>(key: Key$1) => PathValue<Config, Key$1> | null;
+  /**
+   * Gets a configuration value by key path, or returns a default value if not found.
+   *
+   * @param key - Dot-separated path to the configuration value
+   * @param defaultValue - Default value to return if the key is not found
+   * @returns The configuration value or the default value
+   */
+  getOrDefault: <Key$1 extends Path<Config>>(key: Key$1, defaultValue: PathValue<Config, Key$1>) => PathValue<Config, Key$1>;
+  /**
+   * Gets a configuration value by key path, or throws an error if not found.
+   *
+   * @param key - Dot-separated path to the configuration value
+   * @param errorMessage - Optional custom error message
+   * @returns The configuration value
+   * @throws Error if the key is not found
+   */
+  getOrThrow: <Key$1 extends Path<Config>>(key: Key$1, errorMessage?: string) => PathValue<Config, Key$1>;
+}
+//#endregion
+//#region src/config/config.service.d.mts
+/**
+ * Schema for validating configuration service options.
+ */
+declare const ConfigServiceOptionsSchema: z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>;
+/**
+ * Type for configuration service options.
+ */
+type ConfigServiceOptions = z$1.infer<typeof ConfigServiceOptionsSchema>;
+/**
+ * Injection token for ConfigService.
+ */
+declare const ConfigServiceToken: InjectionToken<ConfigServiceInterface<Record<string, unknown>>, z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>, true>;
+/**
+ * Service for managing application configuration with type-safe access.
+ *
+ * Provides methods to access configuration values using dot-notation paths
+ * with full TypeScript type inference.
+ *
+ * @typeParam Config - The configuration object type
+ *
+ * @example
+ * ```typescript
+ * interface AppConfig {
+ *   database: {
+ *     host: string
+ *     port: number
+ *   }
+ *   api: {
+ *     timeout: number
+ *   }
+ * }
+ *
+ * @Injectable()
+ * export class DatabaseService {
+ *   private config = inject(MyConfigService)
+ *
+ *   connect() {
+ *     const host = this.config.getOrThrow('database.host')
+ *     const port = this.config.getOrDefault('database.port', 5432)
+ *     // host is typed as string, port is typed as number
+ *   }
+ * }
+ * ```
+ */
+declare class ConfigService<Config extends ConfigServiceOptions = Record<string, unknown>> implements ConfigServiceInterface<Config> {
+  private config;
+  private readonly logger;
+  /**
+   * Creates a new ConfigService instance.
+   *
+   * @param config - The configuration object
+   */
+  constructor(config?: Config);
+  /**
+   * Gets the entire configuration object.
+   *
+   * @returns The complete configuration object
+   */
+  getConfig(): Config;
+  /**
+   * Gets a configuration value by key path.
+   *
+   * Returns `null` if the key is not found or if any part of the path is invalid.
+   *
+   * @param key - Dot-separated path to the configuration value (e.g., 'database.host')
+   * @returns The configuration value or `null` if not found
+   *
+   * @example
+   * ```typescript
+   * const host = config.get('database.host') // string | null
+   * const port = config.get('database.port') // number | null
+   * ```
+   */
+  get<Key$1 extends Path<Config>>(key: Key$1): PathValue<Config, Key$1> | null;
+  /**
+   * Gets a configuration value by key path, or returns a default value if not found.
+   *
+   * @param key - Dot-separated path to the configuration value
+   * @param defaultValue - Default value to return if the key is not found
+   * @returns The configuration value or the default value
+   *
+   * @example
+   * ```typescript
+   * const port = config.getOrDefault('database.port', 5432) // number
+   * ```
+   */
+  getOrDefault<Key$1 extends Path<Config>>(key: Key$1, defaultValue: PathValue<Config, Key$1>): PathValue<Config, Key$1>;
+  /**
+   * Gets a configuration value by key path, or throws an error if not found.
+   *
+   * @param key - Dot-separated path to the configuration value
+   * @param errorMessage - Optional custom error message
+   * @returns The configuration value
+   * @throws Error if the key is not found
+   *
+   * @example
+   * ```typescript
+   * const host = config.getOrThrow('database.host') // string (throws if not found)
+   * const apiKey = config.getOrThrow('api.key', 'API key is required') // string
+   * ```
+   */
+  getOrThrow<Key$1 extends Path<Config>>(key: Key$1, errorMessage?: string): PathValue<Config, Key$1>;
+}
+//#endregion
+//#region src/config/config.provider.d.mts
+/**
+ * Schema for configuration provider options.
+ */
+declare const ConfigProviderOptions: z$1.ZodObject<{
+  load: z$1.ZodFunction<z$1.core.$ZodFunctionArgs, z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+}, z$1.core.$strip>;
+/**
+ * Creates a factory injection token for ConfigService that loads configuration asynchronously.
+ *
+ * Use this when you need to load configuration from a file, database, or other async source.
+ *
+ * @param options - Configuration provider options
+ * @param options.load - Async function that loads and returns the configuration object
+ * @returns A factory injection token for ConfigService
+ *
+ * @example
+ * ```typescript
+ * const MyConfigService = provideConfig({
+ *   load: async () => {
+ *     const config = await loadConfigFromFile('config.json')
+ *     return config
+ *   },
+ * })
+ *
+ * // Use in module setup
+ * container.bind(ConfigServiceToken).toFactory(configProvider)
+ * ```
+ */
+declare function provideConfig<ConfigMap extends ConfigServiceOptions>(options: z$1.input<typeof ConfigProviderOptions>): FactoryInjectionToken<ConfigService<ConfigMap>, typeof ConfigServiceOptionsSchema>;
+/**
+ * Pre-configured ConfigService provider that uses environment variables.
+ *
+ * Provides a ConfigService instance bound to `process.env`.
+ *
+ * @example
+ * ```typescript
+ * // Use environment variables as configuration
+ * container.bind(ConfigServiceToken).toValue(EnvConfigProvider)
+ * ```
+ */
+declare const EnvConfigProvider: _navios_di0.BoundInjectionToken<ConfigService<Record<string, string>>, z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+//#endregion
+//#region src/decorators/controller.decorator.d.mts
+/**
+ * Options for configuring a Navios controller.
+ */
+interface ControllerOptions {
+  /**
+   * Guards to apply to all endpoints in this controller.
+   * Guards are executed in reverse order (last guard first).
+   */
+  guards?: ClassType[] | Set<ClassType>;
+}
+/**
+ * Decorator that marks a class as a Navios controller.
+ *
+ * Controllers handle HTTP requests and define endpoints.
+ * They are request-scoped by default, meaning a new instance is created for each request.
+ *
+ * @param options - Controller configuration options
+ * @returns A class decorator
+ *
+ * @example
+ * ```typescript
+ * @Controller({ guards: [AuthGuard] })
+ * export class UserController {
+ *   @Endpoint(getUserEndpoint)
+ *   async getUser(request: EndpointParams<typeof getUserEndpoint>) {
+ *     // Handle request
+ *   }
+ * }
+ * ```
+ */
+declare function Controller({
+  guards
+}?: ControllerOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
+//#endregion
+//#region src/decorators/endpoint.decorator.d.mts
+/**
+ * Extracts the typed parameters for an endpoint handler function.
+ *
+ * This utility type extracts URL parameters, query parameters, and request body
+ * from an endpoint declaration and flattens them into a single object.
+ *
+ * @typeParam EndpointDeclaration - The endpoint declaration from @navios/builder
+ *
+ * @example
+ * ```typescript
+ * const getUserEndpoint = api.declareEndpoint({
+ *   method: 'get',
+ *   url: '/users/$userId',
+ *   querySchema: z.object({ include: z.string().optional() }),
+ *   responseSchema: z.object({ id: z.string(), name: z.string() }),
+ * })
+ *
+ * @Endpoint(getUserEndpoint)
+ * async getUser(request: EndpointParams<typeof getUserEndpoint>) {
+ *   // request.urlParams.userId is typed as string
+ *   // request.query.include is typed as string | undefined
+ * }
+ * ```
+ */
+type EndpointParams<EndpointDeclaration extends {
+  config: BaseEndpointConfig<any, any, any, any, any>;
+}, Url extends string = EndpointDeclaration['config']['url'], QuerySchema = EndpointDeclaration['config']['querySchema']> = QuerySchema extends ZodType ? EndpointDeclaration['config']['requestSchema'] extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, EndpointDeclaration['config']['requestSchema'], true>> : Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, undefined, true>> : EndpointDeclaration['config']['requestSchema'] extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, undefined, EndpointDeclaration['config']['requestSchema'], true>> : Util_FlatObject<EndpointFunctionArgs<Url, undefined, undefined, true>>;
+/**
+ * Extracts the typed return value for an endpoint handler function.
+ *
+ * This utility type extracts the response schema from an endpoint declaration
+ * and returns the appropriate Promise type.
+ *
+ * @typeParam EndpointDeclaration - The endpoint declaration from @navios/builder
+ *
+ * @example
+ * ```typescript
+ * const getUserEndpoint = api.declareEndpoint({
+ *   method: 'get',
+ *   url: '/users/$userId',
+ *   responseSchema: z.object({ id: z.string(), name: z.string() }),
+ * })
+ *
+ * @Endpoint(getUserEndpoint)
+ * async getUser(request: EndpointParams<typeof getUserEndpoint>): EndpointResult<typeof getUserEndpoint> {
+ *   return { id: '1', name: 'John' } // Type-checked against responseSchema
+ * }
+ * ```
+ */
+type EndpointResult<EndpointDeclaration extends {
+  config: BaseEndpointConfig<any, any, any, any, any>;
+}> = EndpointDeclaration['config']['responseSchema'] extends ZodDiscriminatedUnion<infer Options> ? Promise<z$1.input<Options[number]>> : Promise<z$1.input<EndpointDeclaration['config']['responseSchema']>>;
+/**
+ * Decorator that marks a method as an HTTP endpoint.
+ *
+ * The endpoint must be defined using @navios/builder's `declareEndpoint` method.
+ * This ensures type safety and consistency between client and server.
+ *
+ * @param endpoint - The endpoint declaration from @navios/builder
+ * @returns A method decorator
+ *
+ * @example
+ * ```typescript
+ * import { builder } from '@navios/builder'
+ *
+ * const api = builder()
+ * const getUserEndpoint = api.declareEndpoint({
+ *   method: 'get',
+ *   url: '/users/$userId',
+ *   responseSchema: z.object({ id: z.string(), name: z.string() }),
+ * })
+ *
+ * @Controller()
+ * export class UserController {
+ *   @Endpoint(getUserEndpoint)
+ *   async getUser(request: EndpointParams<typeof getUserEndpoint>) {
+ *     const { userId } = request.urlParams
+ *     return { id: userId, name: 'John' }
+ *   }
+ * }
+ * ```
+ */
+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 ZodType ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true> : EndpointFunctionArgs<Url, QuerySchema, undefined, true> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema, true> : EndpointFunctionArgs<Url, undefined, undefined, true>) => Promise<z$1.input<ResponseSchema>>, context: ClassMethodDecoratorContext) => (params: QuerySchema extends ZodType ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true> : EndpointFunctionArgs<Url, QuerySchema, undefined, true> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema, true> : EndpointFunctionArgs<Url, undefined, undefined, true>) => Promise<z$1.input<ResponseSchema>>;
+//#endregion
+//#region src/metadata/handler.metadata.d.mts
+declare const EndpointMetadataKey: unique symbol;
+interface HandlerMetadata<Config = null> {
+  classMethod: string;
+  url: string;
+  successStatusCode: number;
+  adapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined> | ClassTypeWithInstance<AbstractHttpHandlerAdapterInterface> | null;
+  headers: Partial<Record<HttpHeader, number | string | string[] | undefined>>;
+  httpMethod: HttpMethod;
+  config: Config;
+  guards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
+  customAttributes: Map<string | symbol, any>;
+}
+declare function getAllEndpointMetadata(context: ClassMethodDecoratorContext | ClassDecoratorContext): Set<HandlerMetadata<any>>;
+declare function getEndpointMetadata<Config = any>(target: Function, context: ClassMethodDecoratorContext): HandlerMetadata<Config>;
+//#endregion
+//#region src/metadata/controller.metadata.d.mts
+declare const ControllerMetadataKey: unique symbol;
+interface ControllerMetadata {
+  endpoints: Set<HandlerMetadata>;
+  guards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
+  customAttributes: Map<string | symbol, any>;
+}
+declare function getControllerMetadata(target: ClassType, context: ClassDecoratorContext): ControllerMetadata;
+declare function extractControllerMetadata(target: ClassType): ControllerMetadata;
+declare function hasControllerMetadata(target: ClassType): boolean;
+//#endregion
+//#region src/metadata/module.metadata.d.mts
+declare const ModuleMetadataKey: unique symbol;
+interface ModuleMetadata {
+  controllers: Set<ClassType>;
+  imports: Set<ClassType>;
+  guards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
+  customAttributes: Map<string | symbol, any>;
+}
+declare function getModuleMetadata(target: ClassType, context: ClassDecoratorContext): ModuleMetadata;
+declare function extractModuleMetadata(target: ClassType): ModuleMetadata;
+declare function hasModuleMetadata(target: ClassType): boolean;
+//#endregion
+//#region src/interfaces/abstract-execution-context.inteface.d.mts
+/**
+ * Interface providing access to the execution context during request handling.
+ *
+ * The execution context provides access to metadata and request/reply objects
+ * for the current request. It is available in guards and can be injected into
+ * services if needed.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class AuthGuard implements CanActivate {
+ *   async canActivate(context: AbstractExecutionContext): Promise<boolean> {
+ *     const request = context.getRequest()
+ *     const handler = context.getHandler()
+ *     // Access request and handler metadata
+ *     return true
+ *   }
+ * }
+ * ```
+ */
+interface AbstractExecutionContext {
+  /**
+   * Gets the metadata for the module containing the current endpoint.
+   */
+  getModule(): ModuleMetadata;
+  /**
+   * Gets the metadata for the controller containing the current endpoint.
+   */
+  getController(): ControllerMetadata;
+  /**
+   * Gets the metadata for the current endpoint handler.
+   */
+  getHandler(): HandlerMetadata;
+  /**
+   * Gets the HTTP request object (adapter-specific).
+   */
+  getRequest(): any;
+  /**
+   * Gets the HTTP reply object (adapter-specific).
+   */
+  getReply(): any;
+}
+//#endregion
+//#region src/logger/utils/cli-colors.util.d.mts
+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;
+//#endregion
+//#region src/logger/log-levels.d.mts
+/**
+ * Available log levels in order of severity (lowest to highest).
+ */
+declare const LOG_LEVELS: ["verbose", "debug", "log", "warn", "error", "fatal"];
+/**
+ * Log level type.
+ *
+ * Represents the severity level of a log message.
+ * Levels are: 'verbose', 'debug', 'log', 'warn', 'error', 'fatal'
+ *
+ * @publicApi
+ */
+type LogLevel = (typeof LOG_LEVELS)[number];
+//#endregion
+//#region src/logger/utils/filter-log-levelts.util.d.mts
+/**
+ * @publicApi
+ */
+declare function filterLogLevels(parseableString?: string): LogLevel[];
+//#endregion
+//#region src/logger/utils/is-log-level.util.d.mts
+/**
+ * @publicApi
+ */
+declare function isLogLevel(maybeLogLevel: any): maybeLogLevel is LogLevel;
+//#endregion
+//#region src/logger/utils/is-log-level-enabled.d.mts
+/**
+ * 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;
+//#endregion
+//#region src/logger/utils/shared.utils.d.mts
+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;
+//#endregion
+//#region src/logger/logger-service.interface.d.mts
+/**
+ * @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;
+}
+//#endregion
+//#region src/logger/console-logger.service.d.mts
+/**
+ * @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 add a request ID to the log message.
+   */
+  requestId?: boolean;
+  /**
+   * 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 lastTimestampAt?: number;
+  setup(): void;
+  setup(context: string): void;
+  setup(options: ConsoleLoggerOptions): void;
+  setup(context: string, options: ConsoleLoggerOptions): void;
+  /**
+   * 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;
+  /**
+   * Gets the current request ID from the AsyncLocalStorage store.
+   * Only returns a value if the requestId option is enabled.
+   */
+  protected getCurrentRequestId(): string | undefined;
+  protected getTimestamp(): string;
+  protected printMessages(messages: unknown[], context?: string, logLevel?: LogLevel, requestId?: string, writeStreamType?: 'stdout' | 'stderr', errorStack?: unknown): void;
+  protected printAsJson(message: unknown, options: {
+    context: string;
+    logLevel: LogLevel;
+    writeStreamType?: 'stdout' | 'stderr';
+    errorStack?: unknown;
+    requestId?: string;
+  }): 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, requestId?: string): string;
+  protected getRequestId(requestId?: 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;
+}
+//#endregion
+//#region src/logger/logger.service.d.mts
+/**
+ * Logger service instance that can be injected into services and controllers.
+ *
+ * Provides contextualized logging with automatic context injection.
+ * The context is set when the logger is injected using the `inject` function.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class UserService {
+ *   private logger = inject(Logger, { context: UserService.name })
+ *
+ *   async findUser(id: string) {
+ *     this.logger.log(`Finding user ${id}`)
+ *     // Logs with context: [UserService]
+ *   }
+ * }
+ * ```
+ */
+declare class LoggerInstance implements LoggerService {
+  protected localInstance: LoggerService;
+  protected context?: string;
+  constructor(config?: LoggerOptions);
+  /**
+   * 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;
+}
+//#endregion
+//#region src/logger/logger.tokens.d.mts
+/**
+ * Injection token for the logger output service.
+ *
+ * This token is used to provide a custom logger implementation.
+ * By default, it's bound to ConsoleLogger.
+ */
+declare const LoggerOutput: InjectionToken<LoggerService, undefined, false>;
+/**
+ * Schema for logger options.
+ */
+declare const loggerOptionsSchema: z.ZodOptional<z.ZodObject<{
+  context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+/**
+ * Options for creating a logger instance.
+ */
+type LoggerOptions = z.infer<typeof loggerOptionsSchema>;
+/**
+ * Injection token for the Logger service.
+ *
+ * Use this token to inject a contextualized logger instance.
+ *
+ * @example
+ * ```typescript
+ * const logger = inject(Logger, { context: 'MyService' })
+ * logger.log('Hello world') // Logs with context: [MyService]
+ * ```
+ */
+declare const Logger: InjectionToken<LoggerInstance, z.ZodOptional<z.ZodObject<{
+  context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>, false>;
+//#endregion
+//#region src/interfaces/abstract-http-cors-options.interface.d.mts
+interface ArrayOfValueOrArray<T> extends Array<ValueOrArray<T>> {}
+type OriginType = string | boolean | RegExp;
+type ValueOrArray<T> = T | ArrayOfValueOrArray<T>;
+interface AbstractHttpCorsOptions {
+  /**
+   * Configures the Access-Control-Allow-Origin CORS header.
+   */
+  origin?: ValueOrArray<OriginType>;
+  /**
+   * Configures the Access-Control-Allow-Credentials CORS header.
+   * Set to true to pass the header, otherwise it is omitted.
+   */
+  credentials?: boolean;
+  /**
+   * Configures the Access-Control-Expose-Headers CORS header.
+   * Expects a comma-delimited string (ex: 'Content-Range,X-Content-Range')
+   * or an array (ex: ['Content-Range', 'X-Content-Range']).
+   * If not specified, no custom headers are exposed.
+   */
+  exposedHeaders?: string | string[];
+  /**
+   * Configures the Access-Control-Allow-Headers CORS header.
+   * Expects a comma-delimited string (ex: 'Content-Type,Authorization')
+   * or an array (ex: ['Content-Type', 'Authorization']). If not
+   * specified, defaults to reflecting the headers specified in the
+   * request's Access-Control-Request-Headers header.
+   */
+  allowedHeaders?: string | string[];
+  /**
+   * Configures the Access-Control-Allow-Methods CORS header.
+   * Expects a comma-delimited string (ex: 'GET,PUT,POST') or an array (ex: ['GET', 'PUT', 'POST']).
+   */
+  methods?: string | string[];
+  /**
+   * Configures the Access-Control-Max-Age CORS header.
+   * Set to an integer to pass the header, otherwise it is omitted.
+   */
+  maxAge?: number;
+  /**
+   * Configures the Cache-Control header for CORS preflight responses.
+   * Set to an integer to pass the header as `Cache-Control: max-age=${cacheControl}`,
+   * or set to a string to pass the header as `Cache-Control: ${cacheControl}` (fully define
+   * the header value), otherwise the header is omitted.
+   */
+  cacheControl?: number | string;
+  /**
+   * Sets the Fastify log level specifically for the internal OPTIONS route
+   * used to handle CORS preflight requests. For example, setting this to `'silent'`
+   * will prevent these requests from being logged.
+   * Useful for reducing noise in application logs.
+   * Default: inherits Fastify's global log level.
+   */
+  logLevel?: LogLevel;
+}
+//#endregion
+//#region src/interfaces/abstract-http-listen-options.interface.d.mts
+interface AbstractHttpListenOptions {
+  port: number;
+  host?: string;
+}
+//#endregion
+//#region src/interfaces/abstract-http-adapter.interface.d.mts
+/**
+ * Abstract interface for HTTP adapters.
+ *
+ * Adapters implement this interface to provide runtime-specific HTTP server
+ * functionality (Fastify, Bun, etc.).
+ *
+ * @typeParam ServerInstance - The underlying server type (e.g., FastifyInstance)
+ * @typeParam CorsOptions - CORS configuration options type
+ * @typeParam Options - Server setup options type
+ * @typeParam MultipartOptions - Multipart form handling options type
+ */
+interface AbstractHttpAdapterInterface<ServerInstance, CorsOptions = AbstractHttpCorsOptions, Options$1 = {}, MultipartOptions = {}> {
+  /**
+   * Sets up the HTTP server with the provided options.
+   */
+  setupHttpServer(options: Options$1): Promise<void>;
+  /**
+   * Called after all modules are loaded to register routes.
+   */
+  onModulesInit(modules: Map<string, ModuleMetadata>): Promise<void>;
+  /**
+   * Signals that the server is ready to accept requests.
+   */
+  ready(): Promise<void>;
+  /**
+   * Returns the underlying HTTP server instance.
+   */
+  getServer(): ServerInstance;
+  /**
+   * Sets a global prefix for all routes.
+   */
+  setGlobalPrefix(prefix: string): void;
+  /**
+   * Gets the current global prefix.
+   * Returns empty string if no prefix is set.
+   */
+  getGlobalPrefix(): string;
+  /**
+   * Enables CORS with the specified options.
+   */
+  enableCors(options: CorsOptions): void;
+  /**
+   * Enables multipart form data handling.
+   */
+  enableMultipart(options: MultipartOptions): void;
+  /**
+   * Starts the server and listens for incoming requests.
+   */
+  listen(options: AbstractHttpListenOptions): Promise<string>;
+  /**
+   * Disposes of the server and cleans up resources.
+   */
+  dispose(): Promise<void>;
+}
+//#endregion
+//#region src/interfaces/abstract-http-handler-adapter.interface.d.mts
+interface AbstractHttpHandlerAdapterInterface {
+  prepareArguments?: (handlerMetadata: HandlerMetadata<any>) => ((target: Record<string, any>, request: any) => Promise<void> | void)[];
+  provideHandler: (controller: ClassType, handlerMetadata: HandlerMetadata<any>) => (context: ScopedContainer, request: any, reply: any) => Promise<any>;
+}
+//#endregion
+//#region src/interfaces/can-activate.d.mts
+/**
+ * Interface that guards must implement to control access to endpoints.
+ *
+ * Guards are used for authentication, authorization, and request validation.
+ * They are executed before the endpoint handler and can prevent the request
+ * from proceeding by returning `false` or throwing an exception.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class AuthGuard implements CanActivate {
+ *   async canActivate(context: AbstractExecutionContext): Promise<boolean> {
+ *     const request = context.getRequest()
+ *     const token = request.headers.authorization
+ *
+ *     if (!token) {
+ *       throw new UnauthorizedException('Authentication required')
+ *     }
+ *
+ *     // Validate token
+ *     return true
+ *   }
+ * }
+ * ```
+ */
+interface CanActivate {
+  /**
+   * Determines if the current request can proceed to the endpoint handler.
+   *
+   * @param executionContext - The execution context containing request, reply, and metadata
+   * @returns `true` if the request can proceed, `false` otherwise. Can also throw an exception.
+   */
+  canActivate(executionContext: AbstractExecutionContext): Promise<boolean> | boolean;
+}
+//#endregion
+//#region src/interfaces/http-header.d.mts
+type OmitIndexSignature<T> = { [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K] };
+/**
+ * HTTP header strings
+ * Use this type only for input values, not for output values.
+ */
+type HttpHeader = keyof OmitIndexSignature<OutgoingHttpHeaders> | (string & Record<never, never>);
+//#endregion
+//#region src/interfaces/navios-module.d.mts
+/**
+ * Interface that all Navios modules must implement.
+ *
+ * Modules decorated with @Module() should implement this interface to receive
+ * lifecycle hooks.
+ *
+ * @example
+ * ```typescript
+ * @Module({
+ *   controllers: [UserController],
+ * })
+ * export class AppModule implements NaviosModule {
+ *   async onModuleInit() {
+ *     console.log('AppModule initialized')
+ *     // Perform initialization logic
+ *   }
+ * }
+ * ```
+ */
+interface NaviosModule {
+  /**
+   * Optional lifecycle hook called after the module is initialized.
+   *
+   * This is called after all modules are loaded and the HTTP server is set up
+   * (if an adapter is configured), but before the server starts listening.
+   */
+  onModuleInit?: () => Promise<void> | void;
+}
+//#endregion
+//#region src/services/module-loader.service.d.mts
+/**
+ * Extension definition for dynamically adding to the module tree.
+ * Used by plugins to inject controllers or entire modules.
+ */
+interface ModuleExtension {
+  /**
+   * Module class to add. If provided, the module and all its
+   * controllers/imports will be processed.
+   */
+  module?: ClassTypeWithInstance<NaviosModule>;
+  /**
+   * Controllers to add directly without a wrapper module.
+   * Will be registered under a synthetic module named after the plugin.
+   */
+  controllers?: ClassType[];
+  /**
+   * Name for the synthetic module when using controllers directly.
+   * Required if `controllers` is provided without `module`.
+   */
+  moduleName?: string;
+}
+declare class ModuleLoaderService {
+  private logger;
+  protected container: Container;
+  private modulesMetadata;
+  private loadedModules;
+  private initialized;
+  loadModules(appModule: ClassTypeWithInstance<NaviosModule>): Promise<void>;
+  /**
+   * Extends the module tree with additional modules or controllers.
+   *
+   * This method is designed to be called by plugins during registration,
+   * which happens after initial module loading but before route registration.
+   *
+   * @param extensions - Array of module extensions to add
+   * @throws Error if not initialized (loadModules must be called first)
+   *
+   * @example
+   * ```typescript
+   * // In plugin registration
+   * const moduleLoader = await context.container.get(ModuleLoaderService)
+   * await moduleLoader.extendModules([{
+   *   controllers: [OpenApiJsonController, OpenApiYamlController],
+   *   moduleName: 'OpenApiBunModule',
+   * }])
+   * ```
+   */
+  extendModules(extensions: ModuleExtension[]): Promise<void>;
+  /**
+   * Registers controllers under a synthetic module.
+   * Used when plugins want to add controllers without a full module class.
+   */
+  private registerControllers;
+  private traverseModules;
+  private mergeMetadata;
+  getAllModules(): Map<string, ModuleMetadata>;
+  dispose(): void;
+}
+//#endregion
+//#region src/interfaces/plugin.interface.d.mts
+/**
+ * Context provided to plugins during registration.
+ *
+ * This context gives plugins access to the application's modules,
+ * server instance, DI container, and configuration.
+ */
+interface PluginContext {
+  /**
+   * All loaded modules with their metadata.
+   * Keys are module class names, values are their metadata.
+   */
+  modules: Map<string, ModuleMetadata>;
+  /**
+   * The underlying HTTP server instance.
+   * Type depends on the adapter used (Fastify, Bun, etc.)
+   */
+  server: any;
+  /**
+   * The dependency injection container.
+   */
+  container: Container;
+  /**
+   * Global route prefix (e.g., '/api/v1').
+   * Empty string if no prefix is set.
+   */
+  globalPrefix: string;
+  /**
+   * Module loader service for extending the module tree.
+   * Use `moduleLoader.extendModules()` to add controllers dynamically.
+   */
+  moduleLoader: ModuleLoaderService;
+}
+/**
+ * Base interface for Navios plugins.
+ *
+ * Plugins are registered using `app.usePlugin()` and are initialized
+ * after all modules are loaded but before the server starts listening.
+ *
+ * @typeParam TOptions - The type of options the plugin accepts
+ *
+ * @example
+ * ```typescript
+ * const myPlugin: NaviosPlugin<{ enabled: boolean }> = {
+ *   name: 'my-plugin',
+ *   register: async (context, options) => {
+ *     if (options.enabled) {
+ *       // Register routes, services, etc.
+ *     }
+ *   },
+ * }
+ * ```
+ */
+interface NaviosPlugin<TOptions = unknown> {
+  /**
+   * Plugin name for identification and logging.
+   */
+  name: string;
+  /**
+   * Called after modules are loaded but before the server starts listening.
+   *
+   * @param context - The plugin context with access to modules and server
+   * @param options - Plugin-specific configuration options
+   */
+  register(context: PluginContext, options: TOptions): Promise<void> | void;
+}
+/**
+ * Plugin definition combining a plugin with its options.
+ *
+ * This is the type returned by plugin factory functions like `defineOpenApiPlugin()`.
+ *
+ * @typeParam TOptions - The type of options the plugin accepts
+ *
+ * @example
+ * ```typescript
+ * function defineMyPlugin(options: MyPluginOptions): PluginDefinition<MyPluginOptions> {
+ *   return {
+ *     plugin: myPlugin,
+ *     options,
+ *   }
+ * }
+ * ```
+ */
+interface PluginDefinition<TOptions = unknown> {
+  /**
+   * The plugin instance.
+   */
+  plugin: NaviosPlugin<TOptions>;
+  /**
+   * Options to pass to the plugin's register function.
+   */
+  options: TOptions;
+}
+//#endregion
+//#region src/decorators/header.decorator.d.mts
+/**
+ * Decorator that sets a custom HTTP response header for an endpoint.
+ *
+ * @param name - The header name (e.g., 'Content-Type', 'Cache-Control')
+ * @param value - The header value (string, number, or array of strings)
+ * @returns A method decorator
+ *
+ * @example
+ * ```typescript
+ * @Controller()
+ * export class UserController {
+ *   @Endpoint(getUserEndpoint)
+ *   @Header('Cache-Control', 'max-age=3600')
+ *   async getUser() {
+ *     return { id: '1', name: 'John' }
+ *   }
+ * }
+ * ```
+ */
+declare function Header(name: HttpHeader, value: string | number | string[]): <T extends Function>(target: T, context: ClassMethodDecoratorContext) => T;
+//#endregion
+//#region src/decorators/http-code.decorator.d.mts
+/**
+ * Decorator that sets a custom HTTP status code for successful responses.
+ *
+ * By default, endpoints return 200 OK. Use this decorator to return a different status code.
+ *
+ * @param code - The HTTP status code to return (e.g., 201, 204, 202)
+ * @returns A method decorator
+ *
+ * @example
+ * ```typescript
+ * @Controller()
+ * export class UserController {
+ *   @Endpoint(createUserEndpoint)
+ *   @HttpCode(201)
+ *   async createUser() {
+ *     return { id: '1', name: 'John' }
+ *   }
+ * }
+ * ```
+ */
+declare function HttpCode(code: number): <T extends Function>(target: T, context: ClassMethodDecoratorContext) => T;
+//#endregion
+//#region src/decorators/module.decorator.d.mts
+/**
+ * Options for configuring a Navios module.
+ */
+interface ModuleOptions {
+  /**
+   * Controllers to register in this module.
+   * Controllers handle HTTP requests and define endpoints.
+   */
+  controllers?: ClassType[] | Set<ClassType>;
+  /**
+   * Other modules to import into this module.
+   * Imported modules' controllers and services become available.
+   */
+  imports?: ClassType[] | Set<ClassType>;
+  /**
+   * Guards to apply to all controllers in this module.
+   * Guards are executed in reverse order (last guard first).
+   */
+  guards?: ClassType[] | Set<ClassType>;
+}
+/**
+ * Decorator that marks a class as a Navios module.
+ *
+ * Modules are the basic building blocks of a Navios application.
+ * They organize controllers, services, and other modules into logical units.
+ *
+ * @param options - Module configuration options
+ * @returns A class decorator
+ *
+ * @example
+ * ```typescript
+ * @Module({
+ *   controllers: [UserController, AuthController],
+ *   imports: [DatabaseModule],
+ *   guards: [AuthGuard],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare function Module({
+  controllers,
+  imports,
+  guards
+}?: ModuleOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
+//#endregion
+//#region src/decorators/multipart.decorator.d.mts
+/**
+ * Extracts the typed parameters for a multipart endpoint handler function.
+ *
+ * Similar to `EndpointParams`, but specifically for multipart/form-data endpoints.
+ *
+ * @typeParam EndpointDeclaration - The endpoint declaration from @navios/builder
+ */
+type MultipartParams<EndpointDeclaration extends {
+  config: BaseEndpointConfig<any, any, any, any, any>;
+}, Url extends string = EndpointDeclaration['config']['url'], QuerySchema = EndpointDeclaration['config']['querySchema']> = QuerySchema extends ZodObject ? EndpointDeclaration['config']['requestSchema'] extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, EndpointDeclaration['config']['requestSchema'], true>> : Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, undefined, true>> : EndpointDeclaration['config']['requestSchema'] extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, undefined, EndpointDeclaration['config']['requestSchema'], true>> : Util_FlatObject<EndpointFunctionArgs<Url, undefined, undefined, true>>;
+/**
+ * Extracts the typed return value for a multipart endpoint handler function.
+ *
+ * @typeParam EndpointDeclaration - The endpoint declaration from @navios/builder
+ */
+type MultipartResult<EndpointDeclaration extends {
+  config: BaseEndpointConfig<any, any, any, any, any>;
+}> = EndpointDeclaration['config']['responseSchema'] extends ZodDiscriminatedUnion<infer Options> ? Promise<z$1.input<Options[number]>> : Promise<z$1.input<EndpointDeclaration['config']['responseSchema']>>;
+/**
+ * Decorator that marks a method as a multipart/form-data endpoint.
+ *
+ * Use this decorator for endpoints that handle file uploads or form data.
+ * The endpoint must be defined using @navios/builder's `declareMultipart` method.
+ *
+ * @param endpoint - The multipart endpoint declaration from @navios/builder
+ * @returns A method decorator
+ *
+ * @example
+ * ```typescript
+ * const uploadFileEndpoint = api.declareMultipart({
+ *   method: 'post',
+ *   url: '/upload',
+ *   requestSchema: z.object({ file: z.instanceof(File) }),
+ *   responseSchema: z.object({ url: z.string() }),
+ * })
+ *
+ * @Controller()
+ * export class FileController {
+ *   @Multipart(uploadFileEndpoint)
+ *   async uploadFile(request: MultipartParams<typeof uploadFileEndpoint>) {
+ *     const { file } = request.data
+ *     // Handle file upload
+ *     return { url: 'https://example.com/file.jpg' }
+ *   }
+ * }
+ * ```
+ */
+declare function Multipart<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 ZodObject ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema> : EndpointFunctionArgs<Url, QuerySchema, undefined> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema> : EndpointFunctionArgs<Url, undefined, undefined>) => Promise<z$1.input<ResponseSchema>>, context: ClassMethodDecoratorContext) => (params: QuerySchema extends ZodObject ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema> : EndpointFunctionArgs<Url, QuerySchema, undefined> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema> : EndpointFunctionArgs<Url, undefined, undefined>) => Promise<z$1.input<ResponseSchema>>;
+//#endregion
+//#region src/decorators/stream.decorator.d.mts
+/**
+ * Extracts the typed parameters for a stream endpoint handler function.
+ *
+ * Similar to `EndpointParams`, but specifically for streaming endpoints.
+ *
+ * @typeParam EndpointDeclaration - The stream endpoint declaration from @navios/builder
+ */
+type StreamParams<EndpointDeclaration extends {
+  config: BaseStreamConfig<any, any, any, any>;
+}, Url extends string = EndpointDeclaration['config']['url'], QuerySchema = EndpointDeclaration['config']['querySchema']> = QuerySchema extends ZodObject ? EndpointDeclaration['config']['requestSchema'] extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, EndpointDeclaration['config']['requestSchema'], true>> : Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, undefined, true>> : EndpointDeclaration['config']['requestSchema'] extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, undefined, EndpointDeclaration['config']['requestSchema'], true>> : Util_FlatObject<EndpointFunctionArgs<Url, undefined, undefined, true>>;
+/**
+ * Decorator that marks a method as a streaming endpoint.
+ *
+ * Use this decorator for endpoints that stream data (e.g., file downloads, SSE).
+ * The endpoint must be defined using @navios/builder's `declareStream` method.
+ *
+ * @param endpoint - The stream endpoint declaration from @navios/builder
+ * @returns A method decorator
+ *
+ * @example
+ * ```typescript
+ * const downloadFileEndpoint = api.declareStream({
+ *   method: 'get',
+ *   url: '/files/$fileId',
+ * })
+ *
+ * @Controller()
+ * export class FileController {
+ *   @Stream(downloadFileEndpoint)
+ *   async downloadFile(request: StreamParams<typeof downloadFileEndpoint>, reply: any) {
+ *     const { fileId } = request.urlParams
+ *     // Stream file data to reply
+ *   }
+ * }
+ * ```
+ */
+declare function Stream<Method extends HttpMethod = HttpMethod, Url extends string = string, QuerySchema = undefined, RequestSchema = ZodType>(endpoint: {
+  config: BaseStreamConfig<Method, Url, QuerySchema, RequestSchema>;
+}): (target: (params: QuerySchema extends ZodObject ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema> : EndpointFunctionArgs<Url, QuerySchema, undefined> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema> : EndpointFunctionArgs<Url, undefined, undefined>, reply: any) => Promise<void>, context: ClassMethodDecoratorContext) => (params: QuerySchema extends ZodObject ? RequestSchema extends ZodType ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema> : EndpointFunctionArgs<Url, QuerySchema, undefined> : RequestSchema extends ZodType ? EndpointFunctionArgs<Url, undefined, RequestSchema> : EndpointFunctionArgs<Url, undefined, undefined>, reply: any) => Promise<void>;
+//#endregion
+//#region src/decorators/use-guards.decorator.d.mts
+/**
+ * Decorator that applies guards to a controller or endpoint.
+ *
+ * Guards are used for authentication, authorization, and request validation.
+ * They implement the `CanActivate` interface and are executed before the endpoint handler.
+ * Guards can be applied at the module, controller, or endpoint level.
+ *
+ * @param guards - Guard classes or injection tokens to apply
+ * @returns A class or method decorator
+ *
+ * @example
+ * ```typescript
+ * // Apply to a controller
+ * @Controller()
+ * @UseGuards(AuthGuard, RoleGuard)
+ * export class UserController {
+ *   @Endpoint(getUserEndpoint)
+ *   async getUser() { }
+ * }
+ *
+ * // Apply to a specific endpoint
+ * @Controller()
+ * export class UserController {
+ *   @Endpoint(getUserEndpoint)
+ *   @UseGuards(AuthGuard)
+ *   async getUser() { }
+ * }
+ * ```
+ */
+declare function UseGuards(...guards: (ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>)[]): <T extends Function>(target: T, context: ClassMethodDecoratorContext | ClassDecoratorContext) => T;
+//#endregion
+//#region src/exceptions/http.exception.d.mts
+/**
+ * Base exception class for all HTTP exceptions in Navios.
+ *
+ * All HTTP exception classes extend this base class. When thrown from an endpoint handler,
+ * Navios will automatically convert it to an appropriate HTTP response with the specified
+ * status code and response body.
+ *
+ * @example
+ * ```typescript
+ * @Endpoint(getUserEndpoint)
+ * async getUser(request: EndpointParams<typeof getUserEndpoint>) {
+ *   const user = await this.userService.findById(request.urlParams.userId)
+ *   if (!user) {
+ *     throw new HttpException(404, 'User not found')
+ *   }
+ *   return user
+ * }
+ * ```
+ */
+declare class HttpException {
+  readonly statusCode: number;
+  readonly response: string | object;
+  readonly error?: Error | undefined;
+  /**
+   * Creates a new HttpException instance.
+   *
+   * @param statusCode - HTTP status code (e.g., 400, 404, 500)
+   * @param response - Response body (string or object)
+   * @param error - Optional underlying error for logging/debugging
+   */
+  constructor(statusCode: number, response: string | object, error?: Error | undefined);
+}
+//#endregion
+//#region src/exceptions/bad-request.exception.d.mts
+/**
+ * Exception that represents a 400 Bad Request HTTP error.
+ *
+ * Use this exception when the client's request is malformed or invalid.
+ *
+ * @example
+ * ```typescript
+ * @Endpoint(createUserEndpoint)
+ * async createUser(request: EndpointParams<typeof createUserEndpoint>) {
+ *   if (!request.data.email) {
+ *     throw new BadRequestException('Email is required')
+ *   }
+ *   // ...
+ * }
+ * ```
+ */
+declare class BadRequestException extends HttpException {
+  /**
+   * Creates a new BadRequestException.
+   *
+   * @param message - Error message or response object
+   */
+  constructor(message: string | object);
+}
+//#endregion
+//#region src/exceptions/forbidden.exception.d.mts
+/**
+ * Exception that represents a 403 Forbidden HTTP error.
+ *
+ * Use this exception when the client is authenticated but does not have
+ * permission to access the requested resource.
+ *
+ * @example
+ * ```typescript
+ * @Endpoint(deleteUserEndpoint)
+ * @UseGuards(AuthGuard, RoleGuard)
+ * async deleteUser(request: EndpointParams<typeof deleteUserEndpoint>) {
+ *   if (!this.userService.hasPermission(request.user, 'delete')) {
+ *     throw new ForbiddenException('Insufficient permissions')
+ *   }
+ *   // ...
+ * }
+ * ```
+ */
+declare class ForbiddenException extends HttpException {
+  /**
+   * Creates a new ForbiddenException.
+   *
+   * @param message - Error message
+   */
+  constructor(message: string);
+}
+//#endregion
+//#region src/exceptions/internal-server-error.exception.d.mts
+/**
+ * Exception that represents a 500 Internal Server Error HTTP error.
+ *
+ * Use this exception when an unexpected error occurs on the server.
+ * Generally, you should let unhandled errors bubble up rather than catching
+ * and rethrowing as InternalServerErrorException, as Navios will handle them appropriately.
+ *
+ * @example
+ * ```typescript
+ * @Endpoint(processPaymentEndpoint)
+ * async processPayment(request: EndpointParams<typeof processPaymentEndpoint>) {
+ *   try {
+ *     return await this.paymentService.process(request.data)
+ *   } catch (error) {
+ *     this.logger.error('Payment processing failed', error)
+ *     throw new InternalServerErrorException('Payment processing failed', error)
+ *   }
+ * }
+ * ```
+ */
+declare class InternalServerErrorException extends HttpException {
+  /**
+   * Creates a new InternalServerErrorException.
+   *
+   * @param message - Error message or response object
+   * @param error - Optional underlying error for logging
+   */
+  constructor(message: string | object, error?: Error);
+}
+//#endregion
+//#region src/exceptions/not-found.exception.d.mts
+/**
+ * Exception that represents a 404 Not Found HTTP error.
+ *
+ * Use this exception when the requested resource does not exist.
+ *
+ * @example
+ * ```typescript
+ * @Endpoint(getUserEndpoint)
+ * async getUser(request: EndpointParams<typeof getUserEndpoint>) {
+ *   const user = await this.userService.findById(request.urlParams.userId)
+ *   if (!user) {
+ *     throw new NotFoundException('User not found')
+ *   }
+ *   return user
+ * }
+ * ```
+ */
+declare class NotFoundException extends HttpException {
+  readonly response: string | object;
+  readonly error?: Error | undefined;
+  /**
+   * Creates a new NotFoundException.
+   *
+   * @param response - Error message or response object
+   * @param error - Optional underlying error for logging
+   */
+  constructor(response: string | object, error?: Error | undefined);
+}
+//#endregion
+//#region src/exceptions/unauthorized.exception.d.mts
+/**
+ * Exception that represents a 401 Unauthorized HTTP error.
+ *
+ * Use this exception when the client is not authenticated or authentication failed.
+ *
+ * @example
+ * ```typescript
+ * @Endpoint(getUserEndpoint)
+ * @UseGuards(AuthGuard)
+ * async getUser(request: EndpointParams<typeof getUserEndpoint>) {
+ *   if (!request.headers.authorization) {
+ *     throw new UnauthorizedException('Authentication required')
+ *   }
+ *   // ...
+ * }
+ * ```
+ */
+declare class UnauthorizedException extends HttpException {
+  /**
+   * Creates a new UnauthorizedException.
+   *
+   * @param message - Error message or response object
+   * @param error - Optional underlying error for logging
+   */
+  constructor(message: string | object, error?: Error);
+}
+//#endregion
+//#region src/exceptions/conflict.exception.d.mts
+/**
+ * Exception that represents a 409 Conflict HTTP error.
+ *
+ * Use this exception when the request conflicts with the current state of the resource
+ * (e.g., trying to create a resource that already exists).
+ *
+ * @example
+ * ```typescript
+ * @Endpoint(createUserEndpoint)
+ * async createUser(request: EndpointParams<typeof createUserEndpoint>) {
+ *   const existing = await this.userService.findByEmail(request.data.email)
+ *   if (existing) {
+ *     throw new ConflictException('User with this email already exists')
+ *   }
+ *   // ...
+ * }
+ * ```
+ */
+declare class ConflictException extends HttpException {
+  /**
+   * Creates a new ConflictException.
+   *
+   * @param message - Error message or response object
+   * @param error - Optional underlying error for logging
+   */
+  constructor(message: string | object, error?: Error);
+}
+//#endregion
+//#region src/services/guard-runner.service.d.mts
+declare class GuardRunnerService {
+  private readonly logger;
+  runGuards(allGuards: Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>, executionContext: AbstractExecutionContext, context: ScopedContainer): Promise<boolean>;
+  makeContext(moduleMetadata: ModuleMetadata, controllerMetadata: ControllerMetadata, endpoint: HandlerMetadata): Set<ClassTypeWithInstance<CanActivate> | InjectionToken<CanActivate, undefined>>;
+}
+//#endregion
+//#region src/stores/request-id.store.d.mts
+/**
+ * AsyncLocalStorage store for the current request ID.
+ *
+ * This allows logging and other services to access the current request ID
+ * without explicitly passing it through the call stack.
+ *
+ * @example
+ * ```typescript
+ * import { requestIdStore, runWithRequestId, getRequestId } from '@navios/core'
+ *
+ * // Run code with a request ID in context
+ * runWithRequestId('req-123', () => {
+ *   // Inside this callback, getRequestId() returns 'req-123'
+ *   logger.log('Processing request') // Will include request ID if logger is configured
+ * })
+ *
+ * // Get current request ID (returns undefined if not in a request context)
+ * const currentId = getRequestId()
+ * ```
+ */
+declare const requestIdStore: AsyncLocalStorage<string>;
+/**
+ * Runs a function with a request ID in the async local storage context.
+ *
+ * @param requestId - The request ID to set for this context
+ * @param fn - The function to run within this context
+ * @returns The return value of the function
+ */
+declare function runWithRequestId<R>(requestId: string, fn: () => R): R;
+/**
+ * Gets the current request ID from the async local storage context.
+ *
+ * @returns The current request ID, or undefined if not in a request context
+ */
+declare function getRequestId(): string | undefined;
+//#endregion
+//#region src/tokens/endpoint-adapter.token.d.mts
+declare const EndpointAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
+//#endregion
+//#region src/tokens/execution-context.token.d.mts
+declare const ExecutionContextInjectionToken = "ExecutionContextInjectionToken";
+declare const ExecutionContext: InjectionToken<AbstractExecutionContext, undefined, false>;
+//#endregion
+//#region src/tokens/http-adapter.token.d.mts
+declare const HttpAdapterToken: InjectionToken<AbstractHttpAdapterInterface<any, any, any, any>, undefined, false>;
+//#endregion
+//#region src/tokens/multipart-adapter.token.d.mts
+declare const MultipartAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
+//#endregion
+//#region src/tokens/reply.token.d.mts
+declare const Reply: InjectionToken<any, undefined, false>;
+//#endregion
+//#region src/tokens/request.token.d.mts
+declare const Request: InjectionToken<any, undefined, false>;
+//#endregion
+//#region src/tokens/stream-adapter.token.d.mts
+declare const StreamAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
+//#endregion
+//#region src/tokens/xml-stream-adapter.token.d.mts
+declare const XmlStreamAdapterToken: InjectionToken<AbstractHttpHandlerAdapterInterface, undefined, false>;
+//#endregion
+//#region src/attribute.factory.d.mts
+/**
+ * Type for a class attribute decorator without a value.
+ *
+ * Attributes are custom metadata decorators that can be applied to modules,
+ * controllers, and endpoints.
+ */
+type ClassAttribute = (() => <T>(target: T, context: ClassDecoratorContext | ClassMethodDecoratorContext) => T) & {
+  token: symbol;
+};
+/**
+ * Type for a class attribute decorator with a validated value.
+ *
+ * @typeParam T - The Zod schema type for validation
+ */
+type ClassSchemaAttribute<T extends ZodType> = ((value: z$1.input<T>) => <T>(target: T, context: ClassDecoratorContext | ClassMethodDecoratorContext) => T) & {
+  token: symbol;
+  schema: ZodType;
+};
+/**
+ * Factory for creating custom attribute decorators.
+ *
+ * Attributes allow you to add custom metadata to modules, controllers, and endpoints.
+ * This is useful for cross-cutting concerns like rate limiting, caching, API versioning, etc.
+ *
+ * @example
+ * ```typescript
+ * // Create a simple boolean attribute
+ * const Public = AttributeFactory.createAttribute(Symbol.for('Public'))
+ *
+ * // Use it as a decorator
+ * @Controller()
+ * @Public()
+ * export class PublicController { }
+ *
+ * // Check if attribute exists
+ * if (AttributeFactory.has(Public, controllerMetadata)) {
+ *   // Skip authentication
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Create an attribute with a validated value
+ * const RateLimit = AttributeFactory.createAttribute(
+ *   Symbol.for('RateLimit'),
+ *   z.object({ requests: z.number(), window: z.number() })
+ * )
+ *
+ * // Use it with a value
+ * @Endpoint(apiEndpoint)
+ * @RateLimit({ requests: 100, window: 60000 })
+ * async handler() { }
+ *
+ * // Get the value
+ * const limit = AttributeFactory.get(RateLimit, endpointMetadata)
+ * // limit is typed as { requests: number, window: number } | null
+ * ```
+ */
+declare class AttributeFactory {
+  /**
+   * Creates a simple attribute decorator without a value.
+   *
+   * @param token - A unique symbol to identify this attribute
+   * @returns A decorator function that can be applied to classes or methods
+   *
+   * @example
+   * ```typescript
+   * const Public = AttributeFactory.createAttribute(Symbol.for('Public'))
+   *
+   * @Public()
+   * @Controller()
+   * export class PublicController { }
+   * ```
+   */
+  static createAttribute(token: symbol): ClassAttribute;
+  /**
+   * Creates an attribute decorator with a validated value.
+   *
+   * @param token - A unique symbol to identify this attribute
+   * @param schema - A Zod schema to validate the attribute value
+   * @returns A decorator function that accepts a value and can be applied to classes or methods
+   *
+   * @example
+   * ```typescript
+   * const RateLimit = AttributeFactory.createAttribute(
+   *   Symbol.for('RateLimit'),
+   *   z.object({ requests: z.number(), window: z.number() })
+   * )
+   *
+   * @RateLimit({ requests: 100, window: 60000 })
+   * @Endpoint(apiEndpoint)
+   * async handler() { }
+   * ```
+   */
+  static createAttribute<T extends ZodType>(token: symbol, schema: T): ClassSchemaAttribute<T>;
+  /**
+   * Gets the value of an attribute from metadata.
+   *
+   * Returns `null` if the attribute is not present.
+   * For simple attributes (without values), returns `true` if present.
+   *
+   * @param attribute - The attribute decorator
+   * @param target - The metadata object (module, controller, or handler)
+   * @returns The attribute value, `true` for simple attributes, or `null` if not found
+   *
+   * @example
+   * ```typescript
+   * const isPublic = AttributeFactory.get(Public, controllerMetadata)
+   * // isPublic is true | null
+   *
+   * const rateLimit = AttributeFactory.get(RateLimit, endpointMetadata)
+   * // rateLimit is { requests: number, window: number } | null
+   * ```
+   */
+  static get(attribute: ClassAttribute, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): true | null;
+  static get<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): z$1.output<T> | null;
+  /**
+   * Gets all values of an attribute from metadata (useful when an attribute can appear multiple times).
+   *
+   * Returns `null` if the attribute is not present.
+   *
+   * @param attribute - The attribute decorator
+   * @param target - The metadata object (module, controller, or handler)
+   * @returns An array of attribute values, or `null` if not found
+   *
+   * @example
+   * ```typescript
+   * const tags = AttributeFactory.getAll(Tag, endpointMetadata)
+   * // tags is string[] | null
+   * ```
+   */
+  static getAll(attribute: ClassAttribute, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): Array<true> | null;
+  static getAll<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): Array<z$1.output<T>> | null;
+  /**
+   * Gets the last value of an attribute from an array of metadata objects.
+   *
+   * Searches from the end of the array backwards, useful for finding the most
+   * specific attribute value (e.g., endpoint-level overrides module-level).
+   *
+   * @param attribute - The attribute decorator
+   * @param target - An array of metadata objects (typically [module, controller, handler])
+   * @returns The last attribute value found, or `null` if not found
+   *
+   * @example
+   * ```typescript
+   * // Check attribute hierarchy: endpoint -> controller -> module
+   * const rateLimit = AttributeFactory.getLast(RateLimit, [
+   *   moduleMetadata,
+   *   controllerMetadata,
+   *   endpointMetadata
+   * ])
+   * ```
+   */
+  static getLast(attribute: ClassAttribute, target: (ModuleMetadata | ControllerMetadata | HandlerMetadata<any>)[]): true | null;
+  static getLast<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: (ModuleMetadata | ControllerMetadata | HandlerMetadata<any>)[]): z$1.output<T> | null;
+  /**
+   * Checks if an attribute is present on the metadata object.
+   *
+   * @param attribute - The attribute decorator
+   * @param target - The metadata object (module, controller, or handler)
+   * @returns `true` if the attribute is present, `false` otherwise
+   *
+   * @example
+   * ```typescript
+   * if (AttributeFactory.has(Public, controllerMetadata)) {
+   *   // Skip authentication
+   * }
+   * ```
+   */
+  static has(attribute: ClassAttribute, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): boolean;
+  static has<T extends ZodType>(attribute: ClassSchemaAttribute<T>, target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>): boolean;
+}
+//#endregion
+//#region src/factories/endpoint-adapter.factory.d.mts
+declare class EndpointAdapterFactory {
+  private readonly environment;
+  create(ctx: FactoryContext): Promise<any>;
+}
+//#endregion
+//#region src/factories/http-adapter.factory.d.mts
+declare class HttpAdapterFactory {
+  private readonly environment;
+  create(ctx: FactoryContext): Promise<any>;
+}
+//#endregion
+//#region src/factories/multipart-adapter.factory.d.mts
+declare class MultipartAdapterFactory {
+  private readonly environment;
+  create(ctx: FactoryContext): Promise<any>;
+}
+//#endregion
+//#region src/factories/request.factory.d.mts
+declare class RequestFactory {
+  private readonly environment;
+  create(ctx: FactoryContext): Promise<any>;
+}
+//#endregion
+//#region src/factories/reply.factory.d.mts
+declare class ReplyFactory {
+  private readonly environment;
+  create(ctx: FactoryContext): Promise<any>;
+}
+//#endregion
+//#region src/factories/stream-adapter.factory.d.mts
+declare class StreamAdapterFactory {
+  private readonly environment;
+  create(ctx: FactoryContext): Promise<any>;
+}
+//#endregion
+//#region src/factories/xml-stream-adapter.factory.d.mts
+declare class XmlStreamAdapterFactory {
+  private readonly environment;
+  create(ctx: FactoryContext): Promise<any>;
+}
+//#endregion
+//#region src/navios.environment.d.mts
+interface NaviosEnvironmentOptions {
+  httpTokens?: Map<InjectionToken<any, undefined>, AnyInjectableType>;
+}
+//#endregion
+//#region src/navios.application.d.mts
+/**
+ * Options for configuring the Navios application context.
+ * These options control dependency injection and logging behavior.
+ */
+interface NaviosApplicationContextOptions {
+  /**
+   * Specifies the logger to use. Pass `false` to turn off logging.
+   *
+   * - `LoggerService` instance: Use a custom logger implementation
+   * - `LogLevel[]`: Enable specific log levels (e.g., ['error', 'warn', 'log'])
+   * - `false`: Disable logging completely
+   */
+  logger?: LoggerService | LogLevel[] | false;
+  /**
+   * Specifies a custom container to use. Useful for testing.
+   * If not provided, a new Container will be created.
+   */
+  container?: Container;
+}
+/**
+ * Complete options for creating a Navios application.
+ * Extends NaviosApplicationContextOptions with adapter configuration.
+ */
+interface NaviosApplicationOptions extends NaviosApplicationContextOptions {
+  /**
+   * HTTP adapter environment(s) to use for the application.
+   * Can be a single adapter or an array of adapters.
+   *
+   * @example
+   * ```typescript
+   * adapter: defineFastifyEnvironment()
+   * // or
+   * adapter: [defineFastifyEnvironment(), defineBunEnvironment()]
+   * ```
+   */
+  adapter: NaviosEnvironmentOptions | NaviosEnvironmentOptions[];
+}
+/**
+ * Main application class for Navios.
+ *
+ * This class represents a Navios application instance and provides methods
+ * for initializing, configuring, and managing the HTTP server.
+ *
+ * @example
+ * ```typescript
+ * const app = await NaviosFactory.create(AppModule, {
+ *   adapter: defineFastifyEnvironment(),
+ * })
+ *
+ * app.setGlobalPrefix('/api')
+ * app.enableCors({ origin: ['http://localhost:3000'] })
+ * await app.init()
+ * await app.listen({ port: 3000, host: '0.0.0.0' })
+ * ```
+ */
+declare class NaviosApplication {
+  private environment;
+  private moduleLoader;
+  private httpApplication;
+  private logger;
+  protected container: Container;
+  private appModule;
+  private options;
+  private plugins;
+  /**
+   * Indicates whether the application has been initialized.
+   * Set to `true` after `init()` completes successfully.
+   */
+  isInitialized: boolean;
+  /**
+   * Sets up the application with the provided module and options.
+   * This is called automatically by NaviosFactory.create().
+   *
+   * @param appModule - The root application module
+   * @param options - Application configuration options
+   * @internal
+   */
+  setup(appModule: ClassTypeWithInstance<NaviosModule>, options?: NaviosApplicationOptions): Promise<void>;
+  /**
+   * Gets the dependency injection container used by this application.
+   *
+   * @returns The Container instance
+   */
+  getContainer(): Container;
+  /**
+   * Registers a plugin to be initialized after modules are loaded.
+   *
+   * Plugins are initialized in the order they are registered,
+   * after all modules are loaded but before the server starts listening.
+   *
+   * @param definition - Plugin definition with options
+   * @returns this for method chaining
+   *
+   * @example
+   * ```typescript
+   * import { defineOpenApiPlugin } from '@navios/openapi-fastify'
+   *
+   * app.usePlugin(defineOpenApiPlugin({
+   *   info: { title: 'My API', version: '1.0.0' },
+   * }))
+   * ```
+   */
+  usePlugin<TOptions>(definition: PluginDefinition<TOptions>): this;
+  /**
+   * Initializes the application.
+   *
+   * This method:
+   * - Loads all modules and their dependencies
+   * - Sets up the HTTP server if an adapter is configured
+   * - Calls onModuleInit hooks on all modules
+   * - Initializes registered plugins
+   * - Marks the application as initialized
+   *
+   * Must be called before `listen()`.
+   *
+   * @throws Error if app module is not set
+   *
+   * @example
+   * ```typescript
+   * const app = await NaviosFactory.create(AppModule, {
+   *   adapter: defineFastifyEnvironment(),
+   * })
+   * await app.init()
+   * await app.listen({ port: 3000 })
+   * ```
+   */
+  init(): Promise<void>;
+  private initModules;
+  private initPlugins;
+  /**
+   * Enables CORS (Cross-Origin Resource Sharing) for the application.
+   *
+   * @param options - CORS configuration options (adapter-specific)
+   * @throws Error if HTTP application is not set
+   *
+   * @example
+   * ```typescript
+   * app.enableCors({
+   *   origin: ['http://localhost:3000', 'https://example.com'],
+   *   methods: ['GET', 'POST', 'PUT', 'DELETE'],
+   *   credentials: true,
+   * })
+   * ```
+   */
+  enableCors(options: any): void;
+  /**
+   * Enables multipart/form-data support for file uploads.
+   *
+   * @param options - Multipart configuration options (adapter-specific)
+   * @throws Error if HTTP application is not set
+   *
+   * @example
+   * ```typescript
+   * app.enableMultipart({
+   *   limits: {
+   *     fileSize: 1024 * 1024 * 10, // 10MB
+   *   },
+   * })
+   * ```
+   */
+  enableMultipart(options: any): void;
+  /**
+   * Sets a global prefix for all routes.
+   *
+   * @param prefix - The prefix to prepend to all route URLs (e.g., '/api')
+   * @throws Error if HTTP application is not set
+   *
+   * @example
+   * ```typescript
+   * app.setGlobalPrefix('/api/v1')
+   * // All routes will be prefixed with /api/v1
+   * ```
+   */
+  setGlobalPrefix(prefix: string): void;
+  /**
+   * Gets the underlying HTTP server instance.
+   *
+   * The type of the returned server depends on the adapter used:
+   * - Fastify adapter: Returns FastifyInstance
+   * - Bun adapter: Returns Bun.Server
+   *
+   * @returns The HTTP server instance
+   * @throws Error if HTTP application is not set
+   *
+   * @example
+   * ```typescript
+   * const server = app.getServer()
+   * // Use adapter-specific server methods
+   * ```
+   */
+  getServer(): any;
+  /**
+   * Starts the HTTP server and begins listening for requests.
+   *
+   * @param options - Listen options (port, host, etc.)
+   * @throws Error if HTTP application is not set
+   *
+   * @example
+   * ```typescript
+   * await app.listen({ port: 3000, host: '0.0.0.0' })
+   * ```
+   */
+  listen(options: AbstractHttpListenOptions): Promise<void>;
+  /**
+   * Disposes of application resources.
+   *
+   * Cleans up the HTTP server and module loader.
+   * This method is called automatically by `close()`.
+   */
+  dispose(): Promise<void>;
+  /**
+   * Closes the application and cleans up all resources.
+   *
+   * This is an alias for `dispose()`.
+   *
+   * @example
+   * ```typescript
+   * // Graceful shutdown
+   * process.on('SIGTERM', async () => {
+   *   await app.close()
+   *   process.exit(0)
+   * })
+   * ```
+   */
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/navios.factory.d.mts
+/**
+ * Factory class for creating and configuring Navios applications.
+ *
+ * This is the main entry point for bootstrapping a Navios application.
+ * It handles dependency injection container setup, adapter registration,
+ * and logger configuration.
+ *
+ * @example
+ * ```typescript
+ * import { NaviosFactory } from '@navios/core'
+ * import { defineFastifyEnvironment } from '@navios/adapter-fastify'
+ *
+ * const app = await NaviosFactory.create(AppModule, {
+ *   adapter: defineFastifyEnvironment(),
+ *   logger: ['log', 'error', 'warn'],
+ * })
+ *
+ * await app.init()
+ * await app.listen({ port: 3000 })
+ * ```
+ */
+declare class NaviosFactory {
+  /**
+   * Creates a new Navios application instance.
+   *
+   * This method sets up the dependency injection container, registers the HTTP adapter,
+   * configures logging, and initializes the application with the provided module.
+   *
+   * @param appModule - The root application module class decorated with @Module()
+   * @param options - Configuration options for the application
+   * @param options.adapter - HTTP adapter environment (required for HTTP server functionality)
+   * @param options.logger - Logger configuration. Can be:
+   *   - A LoggerService instance for custom logging
+   *   - An array of LogLevel strings to enable specific log levels
+   *   - `false` to disable logging
+   * @param options.container - Optional custom dependency injection container (useful for testing)
+   * @returns A configured NaviosApplication instance ready to be initialized
+   *
+   * @example
+   * ```typescript
+   * // Basic setup with Fastify adapter
+   * const app = await NaviosFactory.create(AppModule, {
+   *   adapter: defineFastifyEnvironment(),
+   * })
+   *
+   * // With custom logger configuration
+   * const app = await NaviosFactory.create(AppModule, {
+   *   adapter: defineFastifyEnvironment(),
+   *   logger: ['error', 'warn', 'log'],
+   * })
+   *
+   * // With custom container for testing
+   * const container = new Container()
+   * const app = await NaviosFactory.create(AppModule, {
+   *   adapter: defineFastifyEnvironment(),
+   *   container,
+   * })
+   * ```
+   */
+  static create(appModule: ClassTypeWithInstance<NaviosModule>, options?: NaviosApplicationOptions): Promise<NaviosApplication>;
+  private static registerEnvironment;
+  private static registerLoggerConfiguration;
+}
+//#endregion
+export { CanActivate as $, EnvConfigProvider as $t, NotFoundException as A, clc as At, MultipartResult as B, extractControllerMetadata as Bt, EndpointAdapterToken as C, normalizePath as Ct, GuardRunnerService as D, filterLogLevels as Dt, runWithRequestId as E, isLogLevel as Et, UseGuards as F, extractModuleMetadata as Ft, NaviosPlugin as G, getAllEndpointMetadata as Gt, ModuleOptions as H, hasControllerMetadata as Ht, Stream as I, getModuleMetadata as It, ModuleExtension as J, EndpointParams as Jt, PluginContext as K, getEndpointMetadata as Kt, StreamParams as L, hasModuleMetadata as Lt, ForbiddenException as M, AbstractExecutionContext as Mt, BadRequestException as N, ModuleMetadata as Nt, ConflictException as O, LOG_LEVELS as Ot, HttpException as P, ModuleMetadataKey as Pt, OmitIndexSignature as Q, ConfigProviderOptions as Qt, Multipart as R, ControllerMetadata as Rt, ExecutionContextInjectionToken as S, isUndefined as St, requestIdStore as T, isLogLevelEnabled as Tt, HttpCode as U, EndpointMetadataKey as Ut, Module as V, getControllerMetadata as Vt, Header as W, HandlerMetadata as Wt, NaviosModule as X, Controller as Xt, ModuleLoaderService as Y, EndpointResult as Yt, HttpHeader as Z, ControllerOptions as Zt, Request as _, isNumber as _t, XmlStreamAdapterFactory as a, ConfigServiceInterface as an, LoggerOptions as at, HttpAdapterToken as b, isString as bt, RequestFactory as c, PathImpl2 as cn, LoggerInstance as ct, EndpointAdapterFactory as d, envString as dn, LoggerService as dt, provideConfig as en, AbstractHttpHandlerAdapterInterface as et, AttributeFactory as f, addLeadingSlash as ft, StreamAdapterToken as g, isNil as gt, XmlStreamAdapterToken as h, isFunction as ht, NaviosApplicationOptions as i, ConfigServiceToken as in, Logger as it, InternalServerErrorException as j, yellow as jt, UnauthorizedException as k, LogLevel as kt, MultipartAdapterFactory as l, PathValue as ln, ConsoleLogger as lt, ClassSchemaAttribute as m, isEmpty as mt, NaviosApplication as n, ConfigServiceOptions as nn, AbstractHttpListenOptions as nt, StreamAdapterFactory as o, Path as on, LoggerOutput as ot, ClassAttribute as p, isConstructor as pt, PluginDefinition as q, Endpoint as qt, NaviosApplicationContextOptions as r, ConfigServiceOptionsSchema as rn, AbstractHttpCorsOptions as rt, ReplyFactory as s, PathImpl as sn, loggerOptionsSchema as st, NaviosFactory as t, ConfigService as tn, AbstractHttpAdapterInterface as tt, HttpAdapterFactory as u, envInt as un, ConsoleLoggerOptions as ut, Reply as v, isObject as vt, getRequestId as w, stripEndSlash as wt, ExecutionContext as x, isSymbol as xt, MultipartAdapterToken as y, isPlainObject as yt, MultipartParams as z, ControllerMetadataKey as zt };
+//# sourceMappingURL=index-DW9EPAE6.d.mts.map