@navios/core 0.9.2 → 1.0.0-alpha.1

package/CHANGELOG.md

@@ -5,6 +5,47 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.0-alpha.1] - 2026-01-22
+
+### Added
+
+- **RFC 7807 Problem Details Error Responses**: New standardized error response system using RFC 7807 Problem Details format
+  - `ErrorResponseProducerService` - Central service for producing standardized error responses
+  - `FrameworkError` enum - Explicit error type specification (NotFound, Forbidden, InternalServerError, ValidationError)
+  - Customizable error responders with dependency injection support:
+    - `NotFoundResponderService` - Handles 404 Not Found errors
+    - `ForbiddenResponderService` - Handles 403 Forbidden errors (used by guards)
+    - `InternalServerErrorResponderService` - Handles 500 Internal Server errors
+    - `ValidationErrorResponderService` - Handles 400 Validation errors with structured Zod error details
+  - All responders registered with low priority (-10) for easy override
+  - `ErrorResponder` interface for custom responder implementations
+  - `ProblemDetails` interface following RFC 7807 specification
+  - `ErrorResponse` interface with status code, payload, and headers
+- **Guard Error Handling Enhancement**: `GuardRunnerService` now uses `ErrorResponseProducerService` for standardized error responses
+  - Guard rejections now return RFC 7807 compliant responses
+  - Guard execution errors produce standardized internal server error responses
+
+### Changed
+
+- **Error Response Format**: Error responses now use RFC 7807 Problem Details format instead of simple JSON
+  - Content-Type header set to `application/problem+json`
+  - Responses include `type`, `title`, `status`, and `detail` fields
+  - Validation errors include structured `errors` field with Zod validation details
+  - HttpException responses remain backward compatible (preserved original format)
+
+### Breaking Changes
+
+- **Error Response Format**: Non-HttpException errors now return RFC 7807 Problem Details format
+  - Previous format: `{ message: "..." }`
+  - New format: `{ type: "about:blank", title: "...", status: 404, detail: "..." }`
+  - HttpException responses are unchanged for backward compatibility
+
+## [0.9.3] - 2026-01-05
+
+### Fixed
+
+- **LegacyAttributeFactory Type Fix**: Fixed type definitions for `LegacyClassAttribute` and `LegacyClassSchemaAttribute` to properly support method decorators. Changed from complex function intersection types to simpler `ClassDecorator & MethodDecorator` types that TypeScript can correctly resolve.
+
 ## [0.9.2] - 2026-01-05
 
 ### Added

package/README.md

@@ -30,7 +30,7 @@ The adapter must be provided when creating your Navios application to define the
 - **Build with Navios Builder**: Navios Builder is a powerful HTTP client that simplifies API requests. By combining it with Navios, you can use the same API definition for both the client and server, ensuring consistency and reducing duplication.
 - **Declarative API**: The API is designed to be declarative, allowing you to define your API endpoints and their schemas in a clear and concise manner. This makes it easy to understand and maintain your API client.
 - **Customizable**: The package allows you to customize the behavior of the API client, such as using a custom client.
-- **Error Handling**: The package provides built-in error handling capabilities, allowing you to handle API errors gracefully and provide meaningful feedback to users.
+- **Error Handling**: The package provides built-in error handling capabilities with RFC 7807 Problem Details format for standardized error responses. Includes customizable error responders and comprehensive exception handling.
 
 ## Adapters
 

package/docs/README.md

@@ -200,7 +200,7 @@ Choose the appropriate adapter based on your deployment environment and requirem
 
 ## Error Handling
 
-Both adapters provide consistent error handling through Navios's exception system:
+Both adapters provide consistent error handling through Navios's exception system. Framework-level errors (validation errors, guard rejections, not found routes, unhandled errors) use **RFC 7807 Problem Details** format for standardized, machine-readable error responses. HttpException responses maintain backward compatibility with the original format.
 
 ```ts
 import { BadRequestException, NotFoundException } from '@navios/core'
@@ -225,6 +225,8 @@ export class UserController {
 }
 ```
 
+For more information on error handling, including custom error responders and RFC 7807 Problem Details, see the [Error Handling Guide](../../../apps/docs/docs/server/guides/error-handling.md).
+
 ## Configuration
 
 Both adapters support the same Navios configuration options:

package/docs/exceptions.md

@@ -168,7 +168,9 @@ export class UserController {
 
 ## Exception Response Format
 
-By default, Navios returns exceptions in this format:
+### HttpException Response Format
+
+`HttpException` and its subclasses (like `NotFoundException`, `BadRequestException`, etc.) maintain backward compatibility and return the original format:
 
 ```json
 {
@@ -197,6 +199,40 @@ For exceptions with additional data:
 }
 ```
 
+### RFC 7807 Problem Details Format
+
+Framework-level errors (validation errors, guard rejections, not found routes, unhandled errors) use **RFC 7807 Problem Details** format for standardized, machine-readable error responses:
+
+```json
+{
+  "type": "about:blank",
+  "title": "Not Found",
+  "status": 404,
+  "detail": "Route [GET] /api/users/999 not found"
+}
+```
+
+Validation errors include structured error details:
+
+```json
+{
+  "type": "about:blank",
+  "title": "Validation Error",
+  "status": 400,
+  "detail": "Request validation failed",
+  "errors": {
+    "email": {
+      "code": "invalid_string",
+      "validation": "email",
+      "message": "Invalid email",
+      "path": ["email"]
+    }
+  }
+}
+```
+
+All Problem Details responses include the `Content-Type: application/problem+json` header. For more information on customizing error responders, see the [Error Handling Guide](../../../apps/docs/docs/server/guides/error-handling.md).
+
 ## Best Practices
 
 ### 1. Use Specific Exceptions

package/lib/{index-B2ulzZIr.d.cts → index-BOBeqs9U.d.cts}

@@ -1660,6 +1660,448 @@ declare class ConflictException extends HttpException {
   constructor(message: string | object, error?: Error);
 }
 //#endregion
+//#region src/responders/enums/framework-error.enum.d.mts
+/**
+ * Enumeration of framework-level error types.
+ * Used to explicitly specify which error responder should handle an error.
+ *
+ * @example
+ * ```typescript
+ * // In adapter error handling
+ * if (error instanceof ZodError) {
+ *   return errorProducer.respond(FrameworkError.ValidationError, error)
+ * }
+ * return errorProducer.handleUnknown(error)
+ * ```
+ */
+declare enum FrameworkError {
+  /**
+   * Resource not found (HTTP 404).
+   * Use when a requested resource does not exist.
+   */
+  NotFound = "NotFound",
+  /**
+   * Forbidden (HTTP 403).
+   * Use when access to a resource is denied (e.g., guard rejection).
+   */
+  Forbidden = "Forbidden",
+  /**
+   * Internal server error (HTTP 500).
+   * Use for unexpected errors that don't fit other categories.
+   */
+  InternalServerError = "InternalServerError",
+  /**
+   * Validation error (HTTP 400).
+   * Use when request data fails validation (e.g., Zod errors).
+   */
+  ValidationError = "ValidationError",
+}
+//#endregion
+//#region src/responders/interfaces/problem-details.interface.d.mts
+/**
+ * RFC 7807 Problem Details for HTTP APIs
+ * @see https://tools.ietf.org/html/rfc7807
+ */
+interface ProblemDetails {
+  /**
+   * A URI reference that identifies the problem type.
+   * When dereferenced, it should provide human-readable documentation.
+   * @default 'about:blank'
+   */
+  type?: string;
+  /**
+   * A short, human-readable summary of the problem type.
+   * It should not change from occurrence to occurrence.
+   */
+  title: string;
+  /**
+   * The HTTP status code for this occurrence of the problem.
+   */
+  status: number;
+  /**
+   * A human-readable explanation specific to this occurrence of the problem.
+   */
+  detail?: string;
+  /**
+   * Additional extension members.
+   * Custom properties can be added to provide more context.
+   */
+  [key: string]: unknown;
+}
+//#endregion
+//#region src/responders/interfaces/error-response.interface.d.mts
+/**
+ * Represents a complete error response that can be sent to the client.
+ * Includes the status code, payload (RFC 7807 Problem Details), and headers.
+ */
+interface ErrorResponse {
+  /**
+   * HTTP status code for the response.
+   */
+  statusCode: number;
+  /**
+   * RFC 7807 Problem Details payload.
+   */
+  payload: ProblemDetails;
+  /**
+   * HTTP headers to include in the response.
+   */
+  headers: Record<string, string>;
+}
+//#endregion
+//#region src/responders/interfaces/error-responder.interface.d.mts
+/**
+ * Interface for error responders that convert errors to HTTP responses.
+ * Each responder handles a specific type of framework error and produces
+ * an RFC 7807 compliant response.
+ *
+ * Implementations are registered with low priority (-10) so they can be
+ * easily overridden by consumers.
+ *
+ * @example
+ * ```typescript
+ * @Injectable({
+ *   token: InternalServerErrorResponderToken,
+ *   priority: 0, // Override default implementation
+ * })
+ * export class CustomInternalErrorResponder implements ErrorResponder {
+ *   getResponse(error: unknown, description?: string): ErrorResponse {
+ *     return {
+ *       statusCode: 500,
+ *       payload: {
+ *         type: 'https://api.myapp.com/errors/server-error',
+ *         title: 'Server Error',
+ *         status: 500,
+ *         detail: description ?? 'An unexpected error occurred',
+ *       },
+ *       headers: { 'Content-Type': 'application/problem+json' },
+ *     }
+ *   }
+ * }
+ * ```
+ */
+interface ErrorResponder {
+  /**
+   * Converts an error to an ErrorResponse with RFC 7807 Problem Details.
+   *
+   * @param error - The original error that was thrown
+   * @param description - Optional custom description to include in the response
+   * @returns ErrorResponse with status code, payload, and headers
+   */
+  getResponse(error: unknown, description?: string): ErrorResponse;
+}
+//#endregion
+//#region src/responders/services/error-response-producer.service.d.mts
+/**
+ * Service for producing standardized error responses.
+ *
+ * This service coordinates error responders to produce RFC 7807 compliant
+ * Problem Details responses. Adapters use this service to convert errors
+ * into standardized HTTP responses.
+ *
+ * The caller explicitly specifies which type of error response to produce
+ * via the FrameworkError enum, giving full control to the adapter.
+ *
+ * @example Usage in an adapter:
+ * ```typescript
+ * @Injectable()
+ * class MyAdapter {
+ *   private errorProducer = inject(ErrorResponseProducerService)
+ *
+ *   handleError(error: unknown): Response {
+ *     if (error instanceof ZodError) {
+ *       const response = this.errorProducer.respond(
+ *         FrameworkError.ValidationError,
+ *         error,
+ *       )
+ *       return new Response(JSON.stringify(response.payload), {
+ *         status: response.statusCode,
+ *         headers: response.headers,
+ *       })
+ *     }
+ *
+ *     // Fallback for unknown errors
+ *     const response = this.errorProducer.handleUnknown(error)
+ *     return new Response(JSON.stringify(response.payload), {
+ *       status: response.statusCode,
+ *       headers: response.headers,
+ *     })
+ *   }
+ * }
+ * ```
+ */
+declare class ErrorResponseProducerService {
+  private readonly forbiddenResponder;
+  private readonly internalServerErrorResponder;
+  private readonly notFoundResponder;
+  private readonly validationErrorResponder;
+  /**
+   * Produces an error response for a specific framework error type.
+   *
+   * @param type - The type of framework error (from FrameworkError enum)
+   * @param error - The original error that was thrown
+   * @param description - Optional custom description to include in the response
+   * @returns ErrorResponse with status code, RFC 7807 payload, and headers
+   */
+  respond(type: FrameworkError, error: unknown, description?: string): ErrorResponse;
+  /**
+   * Handles unknown errors by producing an Internal Server Error response.
+   *
+   * Use this as a fallback when the error type is not known or doesn't
+   * match any specific framework error type.
+   *
+   * @param error - The original error that was thrown
+   * @param description - Optional custom description to include in the response
+   * @returns ErrorResponse with 500 status code
+   */
+  handleUnknown(error: unknown, description?: string): ErrorResponse;
+  /**
+   * Convenience method to produce a Not Found error response.
+   *
+   * @param error - The original error that was thrown
+   * @param description - Optional custom description
+   * @returns ErrorResponse with 404 status code
+   */
+  notFound(error: unknown, description?: string): ErrorResponse;
+  /**
+   * Convenience method to produce a Validation Error response.
+   *
+   * @param error - The original error (typically a ZodError)
+   * @param description - Optional custom description
+   * @returns ErrorResponse with 400 status code
+   */
+  validationError(error: unknown, description?: string): ErrorResponse;
+  /**
+   * Convenience method to produce an Internal Server Error response.
+   *
+   * @param error - The original error
+   * @param description - Optional custom description
+   * @returns ErrorResponse with 500 status code
+   */
+  internalServerError(error: unknown, description?: string): ErrorResponse;
+  /**
+   * Convenience method to produce a Forbidden error response.
+   *
+   * @param error - The original error
+   * @param description - Optional custom description
+   * @returns ErrorResponse with 403 status code
+   */
+  forbidden(error: unknown, description?: string): ErrorResponse;
+}
+//#endregion
+//#region src/responders/services/forbidden-responder.service.d.mts
+/**
+ * Default responder for forbidden errors (HTTP 403).
+ *
+ * Converts errors to RFC 7807 Problem Details format.
+ * Used when access to a resource is denied (e.g., guard rejection).
+ * Registered with low priority (-10) so it can be easily overridden.
+ *
+ * @example Override with custom implementation:
+ * ```typescript
+ * @Injectable({
+ *   token: ForbiddenResponderToken,
+ *   priority: 0,
+ * })
+ * export class CustomForbiddenResponder implements ErrorResponder {
+ *   getResponse(error: unknown, description?: string): ErrorResponse {
+ *     return {
+ *       statusCode: 403,
+ *       payload: {
+ *         type: 'https://api.myapp.com/errors/forbidden',
+ *         title: 'Access Denied',
+ *         status: 403,
+ *         detail: description ?? 'You do not have permission to access this resource',
+ *       },
+ *       headers: { 'Content-Type': 'application/problem+json' },
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare class ForbiddenResponderService implements ErrorResponder {
+  getResponse(error: unknown, description?: string): ErrorResponse;
+  private createResponse;
+}
+//#endregion
+//#region src/responders/services/internal-server-error-responder.service.d.mts
+/**
+ * Default responder for internal server errors (HTTP 500).
+ *
+ * Converts generic errors to RFC 7807 Problem Details format.
+ * Registered with low priority (-10) so it can be easily overridden.
+ *
+ * @example Override with custom implementation:
+ * ```typescript
+ * @Injectable({
+ *   token: InternalServerErrorResponderToken,
+ *   priority: 0,
+ * })
+ * export class CustomInternalErrorResponder implements ErrorResponder {
+ *   getResponse(error: unknown, description?: string): ErrorResponse {
+ *     return {
+ *       statusCode: 500,
+ *       payload: {
+ *         type: 'https://api.myapp.com/errors/server-error',
+ *         title: 'Server Error',
+ *         status: 500,
+ *         detail: description ?? 'An unexpected error occurred',
+ *       },
+ *       headers: { 'Content-Type': 'application/problem+json' },
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare class InternalServerErrorResponderService implements ErrorResponder {
+  getResponse(error: unknown, description?: string): ErrorResponse;
+}
+//#endregion
+//#region src/responders/services/not-found-responder.service.d.mts
+/**
+ * Default responder for not found errors (HTTP 404).
+ *
+ * Converts errors to RFC 7807 Problem Details format.
+ * Registered with low priority (-10) so it can be easily overridden.
+ *
+ * @example Override with custom implementation:
+ * ```typescript
+ * @Injectable({
+ *   token: NotFoundResponderToken,
+ *   priority: 0,
+ * })
+ * export class CustomNotFoundResponder implements ErrorResponder {
+ *   getResponse(error: unknown, description?: string): ErrorResponse {
+ *     return {
+ *       statusCode: 404,
+ *       payload: {
+ *         type: 'https://api.myapp.com/errors/not-found',
+ *         title: 'Resource Not Found',
+ *         status: 404,
+ *         detail: description ?? 'The requested resource was not found',
+ *       },
+ *       headers: { 'Content-Type': 'application/problem+json' },
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare class NotFoundResponderService implements ErrorResponder {
+  getResponse(error: unknown, description?: string): ErrorResponse;
+  private createResponse;
+}
+//#endregion
+//#region src/responders/services/validation-error-responder.service.d.mts
+/**
+ * Default responder for validation errors (HTTP 400).
+ *
+ * Converts Zod validation errors to RFC 7807 Problem Details format.
+ * Includes the structured validation errors from treeifyError.
+ * Registered with low priority (-10) so it can be easily overridden.
+ *
+ * @example Override with custom implementation:
+ * ```typescript
+ * @Injectable({
+ *   token: ValidationErrorResponderToken,
+ *   priority: 0,
+ * })
+ * export class CustomValidationResponder implements ErrorResponder {
+ *   getResponse(error: unknown, description?: string): ErrorResponse {
+ *     const zodError = error as ZodError
+ *     return {
+ *       statusCode: 422, // Use 422 instead of 400
+ *       payload: {
+ *         type: 'https://api.myapp.com/errors/validation',
+ *         title: 'Unprocessable Entity',
+ *         status: 422,
+ *         detail: description ?? 'Validation failed',
+ *         issues: zodError.issues,
+ *       },
+ *       headers: { 'Content-Type': 'application/problem+json' },
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare class ValidationErrorResponderService implements ErrorResponder {
+  getResponse(error: unknown, description?: string): ErrorResponse;
+}
+//#endregion
+//#region src/responders/tokens/responder.tokens.d.mts
+/**
+ * Injection token for the Internal Server Error responder.
+ * Default implementation returns HTTP 500 with RFC 7807 Problem Details.
+ *
+ * @example Override with custom implementation:
+ * ```typescript
+ * @Injectable({
+ *   token: InternalServerErrorResponderToken,
+ *   priority: 0, // Higher than default -10
+ * })
+ * export class CustomInternalErrorResponder implements ErrorResponder {
+ *   getResponse(error: unknown, description?: string): ErrorResponse {
+ *     // Custom implementation
+ *   }
+ * }
+ * ```
+ */
+declare const InternalServerErrorResponderToken: InjectionToken<ErrorResponder, undefined, false>;
+/**
+ * Injection token for the Not Found responder.
+ * Default implementation returns HTTP 404 with RFC 7807 Problem Details.
+ *
+ * @example Override with custom implementation:
+ * ```typescript
+ * @Injectable({
+ *   token: NotFoundResponderToken,
+ *   priority: 0, // Higher than default -10
+ * })
+ * export class CustomNotFoundResponder implements ErrorResponder {
+ *   getResponse(error: unknown, description?: string): ErrorResponse {
+ *     // Custom implementation
+ *   }
+ * }
+ * ```
+ */
+declare const NotFoundResponderToken: InjectionToken<ErrorResponder, undefined, false>;
+/**
+ * Injection token for the Validation Error responder.
+ * Default implementation returns HTTP 400 with RFC 7807 Problem Details
+ * and includes validation errors from ZodError.
+ *
+ * @example Override with custom implementation:
+ * ```typescript
+ * @Injectable({
+ *   token: ValidationErrorResponderToken,
+ *   priority: 0, // Higher than default -10
+ * })
+ * export class CustomValidationResponder implements ErrorResponder {
+ *   getResponse(error: unknown, description?: string): ErrorResponse {
+ *     // Custom implementation
+ *   }
+ * }
+ * ```
+ */
+declare const ValidationErrorResponderToken: InjectionToken<ErrorResponder, undefined, false>;
+/**
+ * Injection token for the Forbidden responder.
+ * Default implementation returns HTTP 403 with RFC 7807 Problem Details.
+ *
+ * @example Override with custom implementation:
+ * ```typescript
+ * @Injectable({
+ *   token: ForbiddenResponderToken,
+ *   priority: 0, // Higher than default -10
+ * })
+ * export class CustomForbiddenResponder implements ErrorResponder {
+ *   getResponse(error: unknown, description?: string): ErrorResponse {
+ *     // Custom implementation
+ *   }
+ * }
+ * ```
+ */
+declare const ForbiddenResponderToken: InjectionToken<ErrorResponder, undefined, false>;
+//#endregion
 //#region src/services/instance-resolver.service.d.mts
 /**
  * Result of instance resolution attempt.
@@ -1769,6 +2211,7 @@ type ControllerResolution<T = any> = InstanceResolution<T>;
 //#endregion
 //#region src/services/guard-runner.service.d.mts
 declare class GuardRunnerService {
+  private readonly errorProducer;
   private readonly logger;
   /**
    * Runs guards that need to be resolved from a scoped container.
@@ -2373,5 +2816,5 @@ declare class NaviosFactory {
   private static registerLoggerConfiguration;
 }
 //#endregion
-export { PluginDefinition as $, extractControllerMetadata as $t, ControllerResolverService as A, isSymbol as At, HttpException as B, yellow as Bt, EndpointAdapterToken as C, envInt as Cn, isEmpty as Ct, setRequestIdEnabled as D, isObject as Dt, runWithRequestId as E, isNumber as Et, UnauthorizedException as F, isLogLevel as Ft, MultipartParams as G, hasManagedMetadata as Gt, Stream as H, ManagedMetadata as Ht, NotFoundException as I, filterLogLevels as It, ModuleOptions as J, extractModuleMetadata as Jt, MultipartResult as K, ModuleMetadata as Kt, InternalServerErrorException as L, LOG_LEVELS as Lt, InstanceResolverService as M, normalizePath as Mt, MultiInstanceResolution as N, stripEndSlash as Nt, GuardRunnerService as O, isPlainObject as Ot, ConflictException as P, isLogLevelEnabled as Pt, PluginContext as Q, ControllerMetadataKey as Qt, ForbiddenException as R, LogLevel as Rt, ExecutionContextInjectionToken as S, PathValue as Sn, isConstructor as St, getRequestId as T, isNil as Tt, StreamParams as U, NaviosManagedMetadataKey as Ut, UseGuards as V, AbstractExecutionContext as Vt, Multipart as W, getManagedMetadata as Wt, Header as X, hasModuleMetadata as Xt, HttpCode as Y, getModuleMetadata as Yt, NaviosPlugin as Z, ControllerMetadata as Zt, NaviosApplication as _, ConfigServiceToken as _n, LoggerInstance as _t, RequestFactory as a, getEndpointMetadata as an, CanActivate as at, HttpAdapterToken as b, PathImpl as bn, LoggerService as bt, EndpointAdapterFactory as c, EndpointResult as cn, HandlerResult as ct, ClassSchemaAttribute as d, ConfigProviderOptions as dn, AbstractHttpListenOptions as dt, getControllerMetadata as en, ModuleExtension as et, XmlStreamAdapterToken as f, EnvConfigProvider as fn, AbstractHttpCorsOptions as ft, NaviosOptionsToken as g, ConfigServiceOptionsSchema as gn, loggerOptionsSchema as gt, Reply as h, ConfigServiceOptions as hn, LoggerOutput as ht, ReplyFactory as i, getAllEndpointMetadata as in, OmitIndexSignature as it, InstanceResolution as j, isUndefined as jt, ControllerResolution as k, isString as kt, AttributeFactory as l, Controller as ln, StaticHandler as lt, Request as m, ConfigService as mn, LoggerOptions as mt, XmlStreamAdapterFactory as n, EndpointMetadataKey as nn, NaviosModule as nt, MultipartAdapterFactory as o, Endpoint as on, AbstractHttpHandlerAdapterInterface as ot, StreamAdapterToken as p, provideConfig as pn, Logger as pt, Module as q, ModuleMetadataKey as qt, StreamAdapterFactory as r, HandlerMetadata as rn, HttpHeader as rt, HttpAdapterFactory as s, EndpointParams as sn, DynamicHandler as st, NaviosFactory as t, hasControllerMetadata as tn, ModuleLoaderService as tt, ClassAttribute as u, ControllerOptions as un, AbstractHttpAdapterInterface as ut, NaviosApplicationOptions as v, ConfigServiceInterface as vn, ConsoleLogger as vt, generateRequestId as w, envString as wn, isFunction as wt, ExecutionContext as x, PathImpl2 as xn, addLeadingSlash as xt, MultipartAdapterToken as y, Path as yn, ConsoleLoggerOptions as yt, BadRequestException as z, clc as zt };
-//# sourceMappingURL=index-B2ulzZIr.d.cts.map
+export { HttpException as $, yellow as $t, ControllerResolverService as A, ConfigServiceToken as An, LoggerInstance as At, InternalServerErrorResponderService as B, isObject as Bt, EndpointAdapterToken as C, ControllerOptions as Cn, AbstractHttpAdapterInterface as Ct, setRequestIdEnabled as D, ConfigService as Dn, LoggerOptions as Dt, runWithRequestId as E, provideConfig as En, Logger as Et, InternalServerErrorResponderToken as F, PathValue as Fn, isConstructor as Ft, ProblemDetails as G, normalizePath as Gt, ErrorResponseProducerService as H, isString as Ht, NotFoundResponderToken as I, envInt as In, isEmpty as It, UnauthorizedException as J, isLogLevel as Jt, FrameworkError as K, stripEndSlash as Kt, ValidationErrorResponderToken as L, envString as Ln, isFunction as Lt, InstanceResolverService as M, Path as Mn, ConsoleLoggerOptions as Mt, MultiInstanceResolution as N, PathImpl as Nn, LoggerService as Nt, GuardRunnerService as O, ConfigServiceOptions as On, LoggerOutput as Ot, ForbiddenResponderToken as P, PathImpl2 as Pn, addLeadingSlash as Pt, BadRequestException as Q, clc as Qt, ValidationErrorResponderService as R, isNil as Rt, ExecutionContextInjectionToken as S, Controller as Sn, StaticHandler as St, getRequestId as T, EnvConfigProvider as Tn, AbstractHttpCorsOptions as Tt, ErrorResponder as U, isSymbol as Ut, ForbiddenResponderService as V, isPlainObject as Vt, ErrorResponse as W, isUndefined as Wt, InternalServerErrorException as X, LOG_LEVELS as Xt, NotFoundException as Y, filterLogLevels as Yt, ForbiddenException as Z, LogLevel as Zt, NaviosApplication as _, getAllEndpointMetadata as _n, OmitIndexSignature as _t, RequestFactory as a, ModuleMetadata as an, MultipartResult as at, HttpAdapterToken as b, EndpointParams as bn, DynamicHandler as bt, EndpointAdapterFactory as c, getModuleMetadata as cn, HttpCode as ct, ClassSchemaAttribute as d, ControllerMetadataKey as dn, PluginContext as dt, AbstractExecutionContext as en, UseGuards as et, XmlStreamAdapterToken as f, extractControllerMetadata as fn, PluginDefinition as ft, NaviosOptionsToken as g, HandlerMetadata as gn, HttpHeader as gt, Reply as h, EndpointMetadataKey as hn, NaviosModule as ht, ReplyFactory as i, hasManagedMetadata as in, MultipartParams as it, InstanceResolution as j, ConfigServiceInterface as jn, ConsoleLogger as jt, ControllerResolution as k, ConfigServiceOptionsSchema as kn, loggerOptionsSchema as kt, AttributeFactory as l, hasModuleMetadata as ln, Header as lt, Request as m, hasControllerMetadata as mn, ModuleLoaderService as mt, XmlStreamAdapterFactory as n, NaviosManagedMetadataKey as nn, StreamParams as nt, MultipartAdapterFactory as o, ModuleMetadataKey as on, Module as ot, StreamAdapterToken as p, getControllerMetadata as pn, ModuleExtension as pt, ConflictException as q, isLogLevelEnabled as qt, StreamAdapterFactory as r, getManagedMetadata as rn, Multipart as rt, HttpAdapterFactory as s, extractModuleMetadata as sn, ModuleOptions as st, NaviosFactory as t, ManagedMetadata as tn, Stream as tt, ClassAttribute as u, ControllerMetadata as un, NaviosPlugin as ut, NaviosApplicationOptions as v, getEndpointMetadata as vn, CanActivate as vt, generateRequestId as w, ConfigProviderOptions as wn, AbstractHttpListenOptions as wt, ExecutionContext as x, EndpointResult as xn, HandlerResult as xt, MultipartAdapterToken as y, Endpoint as yn, AbstractHttpHandlerAdapterInterface as yt, NotFoundResponderService as z, isNumber as zt };
+//# sourceMappingURL=index-BOBeqs9U.d.cts.map