@vritti/api-sdk 0.0.7 → 0.0.9

package/dist/index.js

@@ -1876,7 +1876,7 @@ HttpModule = _ts_decorate12([
   })
 ], HttpModule);
 
-// src/http/filters/http-exception.filter.ts
+// src/filters/http-exception.filter.ts
 import { Catch, HttpException, HttpStatus, Logger as Logger9 } from "@nestjs/common";
 function _ts_decorate13(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -1885,140 +1885,26 @@ function _ts_decorate13(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate13, "_ts_decorate");
-var HttpExceptionFilter = class _HttpExceptionFilter {
-  static {
-    __name(this, "HttpExceptionFilter");
-  }
-  logger = new Logger9(_HttpExceptionFilter.name);
-  catch(exception, host) {
-    const ctx = host.switchToHttp();
-    const reply = ctx.getResponse();
-    const request = ctx.getRequest();
-    let status = HttpStatus.INTERNAL_SERVER_ERROR;
-    let errors = [];
-    let message;
-    if (exception instanceof HttpException) {
-      status = exception.getStatus();
-      const exceptionResponse = exception.getResponse();
-      if (typeof exceptionResponse === "object" && exceptionResponse !== null) {
-        const responseObj = exceptionResponse;
-        if (Array.isArray(responseObj.message)) {
-          errors = this.parseValidationErrors(responseObj.message);
-          message = "Validation failed";
-        } else if (responseObj.message) {
-          errors = [
-            {
-              field: "general",
-              message: responseObj.message
-            }
-          ];
-          message = responseObj.message;
-        }
-      } else if (typeof exceptionResponse === "string") {
-        errors = [
-          {
-            field: "general",
-            message: exceptionResponse
-          }
-        ];
-        message = exceptionResponse;
-      }
-    } else if (exception instanceof Error) {
-      this.logger.error(`Unhandled error: ${exception.message}`, exception.stack);
-      errors = [
-        {
-          field: "general",
-          message: "Internal server error"
-        }
-      ];
-      message = "An unexpected error occurred";
-    } else {
-      this.logger.error("Unknown exception type", exception);
-      errors = [
-        {
-          field: "general",
-          message: "Internal server error"
-        }
-      ];
-      message = "An unexpected error occurred";
-    }
-    const errorResponse = {
-      errors,
-      message,
-      statusCode: status,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      path: request.url
-    };
-    if (status >= 500) {
-      this.logger.error(`HTTP ${status} Error: ${JSON.stringify(errorResponse)}`, exception instanceof Error ? exception.stack : void 0);
-    } else {
-      this.logger.warn(`HTTP ${status} Error: ${JSON.stringify(errorResponse)}`);
-    }
-    reply.status(status).send(errorResponse);
-  }
-  /**
-  * Parse class-validator error messages into field-specific errors
-  */
-  parseValidationErrors(messages) {
-    const errors = [];
-    for (const msg of messages) {
-      if (typeof msg === "string") {
-        errors.push({
-          field: "general",
-          message: msg
-        });
-      } else if (typeof msg === "object" && msg.property && msg.constraints) {
-        const field = msg.property;
-        const constraintMessages = Object.values(msg.constraints);
-        for (const constraintMsg of constraintMessages) {
-          errors.push({
-            field,
-            message: constraintMsg
-          });
-        }
-      }
-    }
-    return errors.length > 0 ? errors : [
-      {
-        field: "general",
-        message: "Validation failed"
-      }
-    ];
-  }
-};
-HttpExceptionFilter = _ts_decorate13([
-  Catch()
-], HttpExceptionFilter);
-
-// src/filters/http-exception.filter.ts
-import { Catch as Catch2, HttpException as HttpException2, HttpStatus as HttpStatus2, Logger as Logger10 } from "@nestjs/common";
-function _ts_decorate14(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate14, "_ts_decorate");
 function getHttpStatusTitle(status) {
-  const enumKey = Object.entries(HttpStatus2).find(([key, value]) => value === status && isNaN(Number(key)))?.[0];
+  const enumKey = Object.entries(HttpStatus).find(([key, value]) => value === status && isNaN(Number(key)))?.[0];
   if (!enumKey) {
     return "Error";
   }
   return enumKey.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
 }
 __name(getHttpStatusTitle, "getHttpStatusTitle");
-var HttpExceptionFilter2 = class _HttpExceptionFilter {
+var HttpExceptionFilter = class _HttpExceptionFilter {
   static {
     __name(this, "HttpExceptionFilter");
   }
-  logger = new Logger10(_HttpExceptionFilter.name);
+  logger = new Logger9(_HttpExceptionFilter.name);
   catch(exception, host) {
     const ctx = host.switchToHttp();
     const response = ctx.getResponse();
-    let status = HttpStatus2.INTERNAL_SERVER_ERROR;
+    let status = HttpStatus.INTERNAL_SERVER_ERROR;
     let errors = [];
     let detail = "Internal server error";
-    if (exception instanceof HttpException2) {
+    if (exception instanceof HttpException) {
       status = exception.getStatus();
       const exceptionResponse = exception.getResponse();
       if (typeof exceptionResponse === "object" && exceptionResponse !== null) {
@@ -2056,7 +1942,9 @@ var HttpExceptionFilter2 = class _HttpExceptionFilter {
         detail = exceptionResponse;
       }
     } else {
-      this.logger.error("Unexpected error:", exception);
+      const errorMessage = exception instanceof Error ? exception.message : "Unknown error";
+      const stack = exception instanceof Error ? exception.stack : void 0;
+      this.logger.error(`Unexpected error: ${errorMessage}`, stack);
       errors = [
         {
           message: "An unexpected error occurred"
@@ -2072,13 +1960,13 @@ var HttpExceptionFilter2 = class _HttpExceptionFilter {
     response.status(status).send(problemDetails);
   }
 };
-HttpExceptionFilter2 = _ts_decorate14([
-  Catch2()
-], HttpExceptionFilter2);
+HttpExceptionFilter = _ts_decorate13([
+  Catch()
+], HttpExceptionFilter);
 
 // src/exceptions/base-field.exception.ts
-import { HttpException as HttpException3, HttpStatus as HttpStatus3 } from "@nestjs/common";
-var BaseFieldException = class extends HttpException3 {
+import { HttpException as HttpException2, HttpStatus as HttpStatus2 } from "@nestjs/common";
+var BaseFieldException = class extends HttpException2 {
   static {
     __name(this, "BaseFieldException");
   }
@@ -2088,7 +1976,7 @@ var BaseFieldException = class extends HttpException3 {
     let finalDetail;
     if (Array.isArray(statusOrMessageOrErrors)) {
       errors = statusOrMessageOrErrors;
-      httpStatus = messageOrStatus || HttpStatus3.BAD_REQUEST;
+      httpStatus = messageOrStatus || HttpStatus2.BAD_REQUEST;
       finalDetail = typeof statusOrDetail === "string" ? statusOrDetail : void 0;
     } else if (typeof statusOrMessageOrErrors === "string" && typeof messageOrStatus === "string") {
       errors = [
@@ -2127,351 +2015,1235 @@ var BaseFieldException = class extends HttpException3 {
 };
 
 // src/exceptions/bad-request.exception.ts
-import { HttpStatus as HttpStatus4 } from "@nestjs/common";
+import { HttpStatus as HttpStatus3 } from "@nestjs/common";
 var BadRequestException = class extends BaseFieldException {
   static {
     __name(this, "BadRequestException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus4.BAD_REQUEST, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus3.BAD_REQUEST, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus4.BAD_REQUEST, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus3.BAD_REQUEST, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus4.BAD_REQUEST);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus3.BAD_REQUEST);
     } else {
-      super(messageOrField, HttpStatus4.BAD_REQUEST);
+      super(messageOrField, HttpStatus3.BAD_REQUEST);
     }
   }
 };
 
 // src/exceptions/unauthorized.exception.ts
-import { HttpStatus as HttpStatus5 } from "@nestjs/common";
+import { HttpStatus as HttpStatus4 } from "@nestjs/common";
 var UnauthorizedException4 = class extends BaseFieldException {
   static {
     __name(this, "UnauthorizedException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus5.UNAUTHORIZED, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus4.UNAUTHORIZED, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus5.UNAUTHORIZED, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus4.UNAUTHORIZED, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus5.UNAUTHORIZED);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus4.UNAUTHORIZED);
     } else {
-      super(messageOrField, HttpStatus5.UNAUTHORIZED);
+      super(messageOrField, HttpStatus4.UNAUTHORIZED);
     }
   }
 };
 
 // src/exceptions/forbidden.exception.ts
-import { HttpStatus as HttpStatus6 } from "@nestjs/common";
+import { HttpStatus as HttpStatus5 } from "@nestjs/common";
 var ForbiddenException2 = class extends BaseFieldException {
   static {
     __name(this, "ForbiddenException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus6.FORBIDDEN, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus5.FORBIDDEN, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus6.FORBIDDEN, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus5.FORBIDDEN, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus6.FORBIDDEN);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus5.FORBIDDEN);
     } else {
-      super(messageOrField, HttpStatus6.FORBIDDEN);
+      super(messageOrField, HttpStatus5.FORBIDDEN);
     }
   }
 };
 
 // src/exceptions/not-found.exception.ts
-import { HttpStatus as HttpStatus7 } from "@nestjs/common";
+import { HttpStatus as HttpStatus6 } from "@nestjs/common";
 var NotFoundException = class extends BaseFieldException {
   static {
     __name(this, "NotFoundException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus7.NOT_FOUND, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus6.NOT_FOUND, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus7.NOT_FOUND, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus6.NOT_FOUND, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus7.NOT_FOUND);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus6.NOT_FOUND);
     } else {
-      super(messageOrField, HttpStatus7.NOT_FOUND);
+      super(messageOrField, HttpStatus6.NOT_FOUND);
     }
   }
 };
 
 // src/exceptions/conflict.exception.ts
-import { HttpStatus as HttpStatus8 } from "@nestjs/common";
+import { HttpStatus as HttpStatus7 } from "@nestjs/common";
 var ConflictException = class extends BaseFieldException {
   static {
     __name(this, "ConflictException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus8.CONFLICT, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus7.CONFLICT, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus8.CONFLICT, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus7.CONFLICT, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus8.CONFLICT);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus7.CONFLICT);
     } else {
-      super(messageOrField, HttpStatus8.CONFLICT);
+      super(messageOrField, HttpStatus7.CONFLICT);
     }
   }
 };
 
 // src/exceptions/internal-server-error.exception.ts
-import { HttpStatus as HttpStatus9 } from "@nestjs/common";
+import { HttpStatus as HttpStatus8 } from "@nestjs/common";
 var InternalServerErrorException3 = class extends BaseFieldException {
   static {
     __name(this, "InternalServerErrorException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus9.INTERNAL_SERVER_ERROR, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus8.INTERNAL_SERVER_ERROR, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus9.INTERNAL_SERVER_ERROR, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus8.INTERNAL_SERVER_ERROR, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus9.INTERNAL_SERVER_ERROR);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus8.INTERNAL_SERVER_ERROR);
     } else {
-      super(messageOrField, HttpStatus9.INTERNAL_SERVER_ERROR);
+      super(messageOrField, HttpStatus8.INTERNAL_SERVER_ERROR);
     }
   }
 };
 
 // src/exceptions/validation.exception.ts
-import { HttpStatus as HttpStatus10 } from "@nestjs/common";
+import { HttpStatus as HttpStatus9 } from "@nestjs/common";
 var ValidationException = class extends BaseFieldException {
   static {
     __name(this, "ValidationException");
   }
   constructor(errors, detail) {
-    super(errors, HttpStatus10.BAD_REQUEST, detail);
+    super(errors, HttpStatus9.BAD_REQUEST, detail);
   }
 };
 
 // src/exceptions/unprocessable-entity.exception.ts
-import { HttpStatus as HttpStatus11 } from "@nestjs/common";
+import { HttpStatus as HttpStatus10 } from "@nestjs/common";
 var UnprocessableEntityException = class extends BaseFieldException {
   static {
     __name(this, "UnprocessableEntityException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus11.UNPROCESSABLE_ENTITY, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus10.UNPROCESSABLE_ENTITY, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus11.UNPROCESSABLE_ENTITY, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus10.UNPROCESSABLE_ENTITY, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus11.UNPROCESSABLE_ENTITY);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus10.UNPROCESSABLE_ENTITY);
     } else {
-      super(messageOrField, HttpStatus11.UNPROCESSABLE_ENTITY);
+      super(messageOrField, HttpStatus10.UNPROCESSABLE_ENTITY);
     }
   }
 };
 
 // src/exceptions/too-many-requests.exception.ts
-import { HttpStatus as HttpStatus12 } from "@nestjs/common";
+import { HttpStatus as HttpStatus11 } from "@nestjs/common";
 var TooManyRequestsException = class extends BaseFieldException {
   static {
     __name(this, "TooManyRequestsException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus12.TOO_MANY_REQUESTS, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus11.TOO_MANY_REQUESTS, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus12.TOO_MANY_REQUESTS, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus11.TOO_MANY_REQUESTS, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus12.TOO_MANY_REQUESTS);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus11.TOO_MANY_REQUESTS);
     } else {
-      super(messageOrField, HttpStatus12.TOO_MANY_REQUESTS);
+      super(messageOrField, HttpStatus11.TOO_MANY_REQUESTS);
     }
   }
 };
 
 // src/exceptions/service-unavailable.exception.ts
-import { HttpStatus as HttpStatus13 } from "@nestjs/common";
+import { HttpStatus as HttpStatus12 } from "@nestjs/common";
 var ServiceUnavailableException = class extends BaseFieldException {
   static {
     __name(this, "ServiceUnavailableException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus13.SERVICE_UNAVAILABLE, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus12.SERVICE_UNAVAILABLE, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus13.SERVICE_UNAVAILABLE, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus12.SERVICE_UNAVAILABLE, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus13.SERVICE_UNAVAILABLE);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus12.SERVICE_UNAVAILABLE);
     } else {
-      super(messageOrField, HttpStatus13.SERVICE_UNAVAILABLE);
+      super(messageOrField, HttpStatus12.SERVICE_UNAVAILABLE);
     }
   }
 };
 
 // src/exceptions/method-not-allowed.exception.ts
-import { HttpStatus as HttpStatus14 } from "@nestjs/common";
+import { HttpStatus as HttpStatus13 } from "@nestjs/common";
 var MethodNotAllowedException = class extends BaseFieldException {
   static {
     __name(this, "MethodNotAllowedException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus14.METHOD_NOT_ALLOWED, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus13.METHOD_NOT_ALLOWED, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus14.METHOD_NOT_ALLOWED, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus13.METHOD_NOT_ALLOWED, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus14.METHOD_NOT_ALLOWED);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus13.METHOD_NOT_ALLOWED);
     } else {
-      super(messageOrField, HttpStatus14.METHOD_NOT_ALLOWED);
+      super(messageOrField, HttpStatus13.METHOD_NOT_ALLOWED);
     }
   }
 };
 
 // src/exceptions/gone.exception.ts
-import { HttpStatus as HttpStatus15 } from "@nestjs/common";
+import { HttpStatus as HttpStatus14 } from "@nestjs/common";
 var GoneException = class extends BaseFieldException {
   static {
     __name(this, "GoneException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus15.GONE, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus14.GONE, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus15.GONE, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus14.GONE, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus15.GONE);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus14.GONE);
     } else {
-      super(messageOrField, HttpStatus15.GONE);
+      super(messageOrField, HttpStatus14.GONE);
     }
   }
 };
 
 // src/exceptions/not-acceptable.exception.ts
-import { HttpStatus as HttpStatus16 } from "@nestjs/common";
+import { HttpStatus as HttpStatus15 } from "@nestjs/common";
 var NotAcceptableException = class extends BaseFieldException {
   static {
     __name(this, "NotAcceptableException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus16.NOT_ACCEPTABLE, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus15.NOT_ACCEPTABLE, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus16.NOT_ACCEPTABLE, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus15.NOT_ACCEPTABLE, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus16.NOT_ACCEPTABLE);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus15.NOT_ACCEPTABLE);
     } else {
-      super(messageOrField, HttpStatus16.NOT_ACCEPTABLE);
+      super(messageOrField, HttpStatus15.NOT_ACCEPTABLE);
     }
   }
 };
 
 // src/exceptions/request-timeout.exception.ts
-import { HttpStatus as HttpStatus17 } from "@nestjs/common";
+import { HttpStatus as HttpStatus16 } from "@nestjs/common";
 var RequestTimeoutException = class extends BaseFieldException {
   static {
     __name(this, "RequestTimeoutException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus17.REQUEST_TIMEOUT, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus16.REQUEST_TIMEOUT, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus17.REQUEST_TIMEOUT, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus16.REQUEST_TIMEOUT, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus17.REQUEST_TIMEOUT);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus16.REQUEST_TIMEOUT);
     } else {
-      super(messageOrField, HttpStatus17.REQUEST_TIMEOUT);
+      super(messageOrField, HttpStatus16.REQUEST_TIMEOUT);
     }
   }
 };
 
 // src/exceptions/payload-too-large.exception.ts
-import { HttpStatus as HttpStatus18 } from "@nestjs/common";
+import { HttpStatus as HttpStatus17 } from "@nestjs/common";
 var PayloadTooLargeException = class extends BaseFieldException {
   static {
     __name(this, "PayloadTooLargeException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus18.PAYLOAD_TOO_LARGE, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus17.PAYLOAD_TOO_LARGE, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus18.PAYLOAD_TOO_LARGE, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus17.PAYLOAD_TOO_LARGE, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus18.PAYLOAD_TOO_LARGE);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus17.PAYLOAD_TOO_LARGE);
     } else {
-      super(messageOrField, HttpStatus18.PAYLOAD_TOO_LARGE);
+      super(messageOrField, HttpStatus17.PAYLOAD_TOO_LARGE);
     }
   }
 };
 
 // src/exceptions/unsupported-media-type.exception.ts
-import { HttpStatus as HttpStatus19 } from "@nestjs/common";
+import { HttpStatus as HttpStatus18 } from "@nestjs/common";
 var UnsupportedMediaTypeException = class extends BaseFieldException {
   static {
     __name(this, "UnsupportedMediaTypeException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus19.UNSUPPORTED_MEDIA_TYPE, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus18.UNSUPPORTED_MEDIA_TYPE, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus19.UNSUPPORTED_MEDIA_TYPE, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus18.UNSUPPORTED_MEDIA_TYPE, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus19.UNSUPPORTED_MEDIA_TYPE);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus18.UNSUPPORTED_MEDIA_TYPE);
     } else {
-      super(messageOrField, HttpStatus19.UNSUPPORTED_MEDIA_TYPE);
+      super(messageOrField, HttpStatus18.UNSUPPORTED_MEDIA_TYPE);
     }
   }
 };
 
 // src/exceptions/not-implemented.exception.ts
-import { HttpStatus as HttpStatus20 } from "@nestjs/common";
+import { HttpStatus as HttpStatus19 } from "@nestjs/common";
 var NotImplementedException = class extends BaseFieldException {
   static {
     __name(this, "NotImplementedException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus20.NOT_IMPLEMENTED, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus19.NOT_IMPLEMENTED, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus20.NOT_IMPLEMENTED, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus19.NOT_IMPLEMENTED, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus20.NOT_IMPLEMENTED);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus19.NOT_IMPLEMENTED);
     } else {
-      super(messageOrField, HttpStatus20.NOT_IMPLEMENTED);
+      super(messageOrField, HttpStatus19.NOT_IMPLEMENTED);
     }
   }
 };
 
 // src/exceptions/bad-gateway.exception.ts
-import { HttpStatus as HttpStatus21 } from "@nestjs/common";
+import { HttpStatus as HttpStatus20 } from "@nestjs/common";
 var BadGatewayException = class extends BaseFieldException {
   static {
     __name(this, "BadGatewayException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus21.BAD_GATEWAY, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus20.BAD_GATEWAY, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus21.BAD_GATEWAY, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus20.BAD_GATEWAY, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus21.BAD_GATEWAY);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus20.BAD_GATEWAY);
+    } else {
+      super(messageOrField, HttpStatus20.BAD_GATEWAY);
+    }
+  }
+};
+
+// src/logger/logger.module.ts
+import { Global as Global4, Module as Module5, Logger as Logger11 } from "@nestjs/common";
+
+// src/logger/services/logger.service.ts
+import { Injectable as Injectable9, Logger as Logger10, Optional } from "@nestjs/common";
+import { createLogger, format, transports } from "winston";
+import DailyRotateFile from "winston-daily-rotate-file";
+
+// src/logger/utils/index.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { randomUUID } from "crypto";
+var correlationStorage = new AsyncLocalStorage();
+function getCorrelationContext() {
+  return correlationStorage.getStore();
+}
+__name(getCorrelationContext, "getCorrelationContext");
+function runWithCorrelationContext(context, callback) {
+  return correlationStorage.run(context, callback);
+}
+__name(runWithCorrelationContext, "runWithCorrelationContext");
+function updateCorrelationContext(updates) {
+  const context = correlationStorage.getStore();
+  if (context) {
+    Object.assign(context, updates);
+  }
+}
+__name(updateCorrelationContext, "updateCorrelationContext");
+var DEFAULT_CORRELATION_HEADER = "x-correlation-id";
+function generateCorrelationId() {
+  return randomUUID();
+}
+__name(generateCorrelationId, "generateCorrelationId");
+function addCorrelationIdToResponse(reply, correlationId, headerName = DEFAULT_CORRELATION_HEADER) {
+  if (typeof reply.header === "function") {
+    reply.header(headerName, correlationId);
+  } else if (reply.raw && typeof reply.raw.setHeader === "function") {
+    reply.raw.setHeader(headerName, correlationId);
+  }
+}
+__name(addCorrelationIdToResponse, "addCorrelationIdToResponse");
+
+// src/logger/services/logger.service.ts
+function _ts_decorate14(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate14, "_ts_decorate");
+function _ts_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata8, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+var LoggerService2 = class _LoggerService {
+  static {
+    __name(this, "LoggerService");
+  }
+  defaultLogger;
+  activeLogger;
+  options;
+  context;
+  constructor(options = {}, defaultLogger) {
+    this.defaultLogger = defaultLogger;
+    this.options = options;
+    const provider = options.provider ?? "winston";
+    if (provider === "default") {
+      if (!this.defaultLogger) {
+        throw new Error("LoggerService: Default Logger not provided");
+      }
+      this.activeLogger = this.defaultLogger;
+    } else {
+      this.activeLogger = this.createWinstonLogger(options);
+    }
+  }
+  /**
+  * Creates a Winston logger instance with inline configuration.
+  * Consolidates winston-config.factory.ts logic.
+  */
+  createWinstonLogger(opts) {
+    const level = opts.level ?? "debug";
+    const logFormat = opts.format ?? "text";
+    const baseFormatters = [
+      format.timestamp({
+        format: "YYYY-MM-DDTHH:mm:ss.SSSZ"
+      }),
+      format.errors({
+        stack: true
+      })
+    ];
+    const consoleTransport = logFormat === "json" ? new transports.Console({
+      level,
+      format: format.combine(...baseFormatters, format.json())
+    }) : new transports.Console({
+      level,
+      format: format.combine(...baseFormatters, format.printf((info) => {
+        const { timestamp, level: level2, message, context, correlationId, trace } = info;
+        const parts = [
+          timestamp,
+          level2.toUpperCase().padEnd(7),
+          correlationId ? `[${correlationId.toString().slice(-6)}]` : "",
+          context ? `[${context}]` : "",
+          message
+        ].filter(Boolean);
+        let output = parts.join(" ");
+        if (trace) {
+          output += "\n" + trace;
+        }
+        return output;
+      }), format.colorize({
+        all: true
+      }))
+    });
+    const winstonTransports = [
+      consoleTransport
+    ];
+    if (opts.enableFileLogger) {
+      const filePath = opts.filePath ?? "./logs";
+      const maxFiles = opts.maxFiles ?? "14d";
+      winstonTransports.push(new DailyRotateFile({
+        level,
+        filename: `${filePath}/%DATE%-combined.log`,
+        datePattern: "YYYY-MM-DD",
+        maxSize: "20m",
+        maxFiles,
+        format: format.combine(format.timestamp(), format.json())
+      }), new DailyRotateFile({
+        level: "error",
+        filename: `${filePath}/%DATE%-error.log`,
+        datePattern: "YYYY-MM-DD",
+        maxSize: "20m",
+        maxFiles,
+        format: format.combine(format.timestamp(), format.json())
+      }));
+    }
+    const config = {
+      level,
+      transports: winstonTransports,
+      exitOnError: false
+    };
+    if (opts.defaultMeta || opts.appName) {
+      config.defaultMeta = {
+        ...opts.defaultMeta,
+        appName: opts.appName,
+        environment: opts.environment
+      };
+    }
+    return createLogger(config);
+  }
+  // NestJS LoggerService interface methods
+  log(message, context) {
+    this._log("log", message, context);
+  }
+  error(message, trace, context) {
+    this._log("error", message, context, trace);
+  }
+  warn(message, context) {
+    this._log("warn", message, context);
+  }
+  debug(message, context) {
+    this._log("debug", message, context);
+  }
+  verbose(message, context) {
+    this._log("verbose", message, context);
+  }
+  setContext(context) {
+    this.context = context;
+  }
+  /**
+  * Unified internal logging method that handles both Winston and NestJS Logger.
+  */
+  _log(level, message, context, trace) {
+    const ctx = context ?? this.context;
+    if ("format" in this.activeLogger && "transports" in this.activeLogger) {
+      const winstonLogger = this.activeLogger;
+      const winstonLevel = level === "log" ? "info" : level;
+      const formattedMessage = this.formatMessage(message);
+      const metadata = this.enrichMetadata({}, ctx, trace);
+      winstonLogger.log({
+        level: winstonLevel,
+        message: formattedMessage,
+        ...metadata
+      });
+    } else {
+      const nestLogger = this.activeLogger;
+      if (level === "error" && trace) {
+        ctx ? nestLogger.error(message, trace, ctx) : nestLogger.error(message, trace);
+      } else if (level === "log") {
+        ctx ? nestLogger.log(message, ctx) : nestLogger.log(message);
+      } else if (level === "warn") {
+        ctx ? nestLogger.warn(message, ctx) : nestLogger.warn(message);
+      } else if (level === "debug" && nestLogger.debug) {
+        ctx ? nestLogger.debug(message, ctx) : nestLogger.debug(message);
+      } else if (level === "verbose" && nestLogger.verbose) {
+        ctx ? nestLogger.verbose(message, ctx) : nestLogger.verbose(message);
+      }
+    }
+  }
+  /**
+  * Logs with custom metadata (Winston only).
+  */
+  logWithMetadata(level, message, metadata, context) {
+    const ctx = context ?? this.context;
+    if ("format" in this.activeLogger && "transports" in this.activeLogger) {
+      const winstonLogger = this.activeLogger;
+      const winstonLevel = level === "log" ? "info" : level;
+      winstonLogger.log({
+        level: winstonLevel,
+        message: this.formatMessage(message),
+        ...metadata
+      });
     } else {
-      super(messageOrField, HttpStatus21.BAD_GATEWAY);
+      const messageWithMeta = metadata ? `${message} ${JSON.stringify(metadata)}` : message;
+      this[level](messageWithMeta, ctx);
+    }
+  }
+  formatMessage(message) {
+    if (message instanceof Error) return message.message;
+    if (typeof message === "object" && message !== null) {
+      try {
+        return JSON.stringify(message);
+      } catch {
+        return String(message);
+      }
+    }
+    return String(message);
+  }
+  /**
+  * Enriches metadata with correlation context from AsyncLocalStorage.
+  * Inline from winston-logger.service.ts
+  */
+  enrichMetadata(metadata = {}, context, trace) {
+    const enriched = {
+      ...metadata
+    };
+    if (context) enriched.context = context;
+    const correlationContext = getCorrelationContext();
+    if (correlationContext) {
+      if (correlationContext.correlationId) enriched.correlationId = correlationContext.correlationId;
+      for (const [key, value] of Object.entries(correlationContext)) {
+        if (key !== "correlationId") {
+          enriched[key] = value;
+        }
+      }
+    }
+    if (trace) enriched.trace = trace;
+    return enriched;
+  }
+  child(context) {
+    const childLogger = new _LoggerService(this.options, this.defaultLogger);
+    childLogger.setContext(context);
+    return childLogger;
+  }
+};
+LoggerService2 = _ts_decorate14([
+  Injectable9(),
+  _ts_param4(0, Optional()),
+  _ts_param4(1, Optional()),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof LoggerModuleOptions === "undefined" ? Object : LoggerModuleOptions,
+    typeof Logger10 === "undefined" ? Object : Logger10
+  ])
+], LoggerService2);
+
+// src/logger/middleware/correlation-id.middleware.ts
+import { Injectable as Injectable10 } from "@nestjs/common";
+function _ts_decorate15(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate15, "_ts_decorate");
+function _ts_metadata9(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata9, "_ts_metadata");
+var CorrelationIdMiddleware = class {
+  static {
+    __name(this, "CorrelationIdMiddleware");
+  }
+  includeInResponse;
+  responseHeader;
+  constructor(options = {}) {
+    this.includeInResponse = options.includeInResponse ?? true;
+    this.responseHeader = options.responseHeader ?? DEFAULT_CORRELATION_HEADER;
+  }
+  /**
+  * Middleware handler for processing requests.
+  */
+  use(req, reply, next) {
+    const correlationId = generateCorrelationId();
+    if (this.includeInResponse) {
+      addCorrelationIdToResponse(reply, correlationId, this.responseHeader);
+    }
+    runWithCorrelationContext({
+      correlationId
+    }, () => {
+      next();
+    });
+  }
+  /**
+  * Fastify hook handler for onRequest.
+  * This is an async function that returns a Promise, ensuring the AsyncLocalStorage
+  * context persists throughout the entire request lifecycle.
+  */
+  async onRequest(req, reply) {
+    const correlationId = generateCorrelationId();
+    if (this.includeInResponse) {
+      addCorrelationIdToResponse(reply, correlationId, this.responseHeader);
+    }
+    const store = correlationStorage.getStore();
+    if (!store) {
+      correlationStorage.enterWith({
+        correlationId
+      });
+    }
+  }
+};
+CorrelationIdMiddleware = _ts_decorate15([
+  Injectable10(),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
+    typeof CorrelationIdMiddlewareOptions === "undefined" ? Object : CorrelationIdMiddlewareOptions
+  ])
+], CorrelationIdMiddleware);
+
+// src/logger/interceptors/http-logger.interceptor.ts
+import { Injectable as Injectable11, Optional as Optional2 } from "@nestjs/common";
+import { tap as tap2, catchError } from "rxjs/operators";
+function _ts_decorate16(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate16, "_ts_decorate");
+function _ts_metadata10(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata10, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param5, "_ts_param");
+var HttpLoggerInterceptor = class {
+  static {
+    __name(this, "HttpLoggerInterceptor");
+  }
+  logger;
+  enableRequestLog;
+  enableResponseLog;
+  slowRequestThreshold;
+  constructor(logger, options) {
+    this.logger = logger;
+    this.enableRequestLog = options?.enableRequestLog ?? true;
+    this.enableResponseLog = options?.enableResponseLog ?? true;
+    this.slowRequestThreshold = options?.slowRequestThreshold ?? 3e3;
+  }
+  intercept(context, next) {
+    if (context.getType() !== "http") {
+      return next.handle();
+    }
+    const httpContext = context.switchToHttp();
+    const request = httpContext.getRequest();
+    const response = httpContext.getResponse();
+    const startTime = Date.now();
+    if (this.enableRequestLog) {
+      this.logRequest(request);
+    }
+    return next.handle().pipe(tap2(() => {
+      if (this.enableResponseLog) {
+        const duration = Date.now() - startTime;
+        this.logResponse(request, response, duration);
+      }
+    }), catchError((error) => {
+      const duration = Date.now() - startTime;
+      this.logError(request, response, duration, error);
+      throw error;
+    }));
+  }
+  logRequest(request) {
+    try {
+      const correlationContext = getCorrelationContext();
+      const metadata = {
+        type: "http_request",
+        method: request.method,
+        url: request.url,
+        correlationId: correlationContext?.correlationId,
+        ip: request.ip,
+        userAgent: request.headers["user-agent"]
+      };
+      this.logger.logWithMetadata("log", `Incoming ${request.method} ${request.url}`, metadata);
+    } catch (error) {
+      this.logger.error("Failed to log HTTP request", error.stack);
+    }
+  }
+  logResponse(request, response, duration) {
+    try {
+      const correlationContext = getCorrelationContext();
+      const statusCode = response.statusCode;
+      const logLevel = statusCode >= 500 ? "error" : statusCode >= 400 ? "warn" : "log";
+      const metadata = {
+        type: "http_response",
+        method: request.method,
+        url: request.url,
+        statusCode,
+        duration,
+        correlationId: correlationContext?.correlationId
+      };
+      if (duration > this.slowRequestThreshold) {
+        metadata.slowRequest = true;
+      }
+      const message = metadata.slowRequest ? `SLOW ${request.method} ${request.url} ${statusCode} - ${duration}ms` : `${request.method} ${request.url} ${statusCode} - ${duration}ms`;
+      this.logger.logWithMetadata(logLevel, message, metadata);
+    } catch (error) {
+      this.logger.error("Failed to log HTTP response", error.stack);
+    }
+  }
+  logError(request, response, duration, error) {
+    try {
+      const correlationContext = getCorrelationContext();
+      const statusCode = response.statusCode || 500;
+      const metadata = {
+        type: "http_error",
+        method: request.method,
+        url: request.url,
+        statusCode,
+        duration,
+        correlationId: correlationContext?.correlationId,
+        errorName: error?.name || "Error",
+        errorMessage: error?.message || "Unknown error"
+      };
+      if (error?.stack) {
+        metadata.trace = error.stack;
+      }
+      if (error?.response) {
+        metadata.errorDetails = error.response;
+      }
+      const message = `ERROR ${request.method} ${request.url} ${statusCode} - ${error?.message || "Unknown error"}`;
+      this.logger.logWithMetadata("error", message, metadata);
+    } catch (loggingError) {
+      this.logger.error("Failed to log HTTP error", loggingError.stack);
+    }
+  }
+};
+HttpLoggerInterceptor = _ts_decorate16([
+  Injectable11(),
+  _ts_param5(1, Optional2()),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
+    typeof LoggerService === "undefined" ? Object : LoggerService,
+    typeof HttpLoggerOptions === "undefined" ? Object : HttpLoggerOptions
+  ])
+], HttpLoggerInterceptor);
+
+// src/logger/logger.module.ts
+function _ts_decorate17(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate17, "_ts_decorate");
+var LOGGER_MODULE_OPTIONS = Symbol("LOGGER_MODULE_OPTIONS");
+var DEFAULT_LOGGER_OPTIONS = {
+  provider: "winston",
+  enableCorrelationId: true,
+  enableHttpLogger: true,
+  filePath: "./logs",
+  maxFiles: "14d"
+};
+var ENVIRONMENT_PRESETS = {
+  /**
+  * Development preset - maximum verbosity for local development
+  */
+  development: {
+    provider: "winston",
+    level: "debug",
+    format: "text",
+    enableFileLogger: false,
+    enableCorrelationId: true,
+    enableHttpLogger: true,
+    httpLogger: {
+      enableRequestLog: true,
+      enableResponseLog: true,
+      slowRequestThreshold: 1e3
+    }
+  },
+  /**
+  * Staging preset - moderate verbosity with file logging
+  */
+  staging: {
+    provider: "winston",
+    level: "log",
+    format: "json",
+    enableFileLogger: true,
+    enableCorrelationId: true,
+    enableHttpLogger: true,
+    httpLogger: {
+      enableRequestLog: true,
+      enableResponseLog: true,
+      slowRequestThreshold: 3e3
+    }
+  },
+  /**
+  * Production preset - minimal verbosity with all safety features enabled
+  */
+  production: {
+    provider: "winston",
+    level: "warn",
+    format: "json",
+    enableFileLogger: true,
+    enableCorrelationId: true,
+    enableHttpLogger: true,
+    httpLogger: {
+      enableRequestLog: false,
+      enableResponseLog: true,
+      slowRequestThreshold: 5e3
+    }
+  },
+  /**
+  * Test preset - errors only, minimal features for faster test execution
+  */
+  test: {
+    provider: "winston",
+    level: "error",
+    format: "json",
+    enableFileLogger: false,
+    enableCorrelationId: false,
+    enableHttpLogger: false
+  }
+};
+function mergeWithDefaults(options = {}) {
+  const preset = options.environment ? ENVIRONMENT_PRESETS[options.environment] ?? ENVIRONMENT_PRESETS.development : ENVIRONMENT_PRESETS.development;
+  const filteredOptions = Object.fromEntries(Object.entries(options).filter(([_, value]) => value !== void 0));
+  if (filteredOptions.httpLogger && preset?.httpLogger) {
+    filteredOptions.httpLogger = {
+      ...preset.httpLogger,
+      ...Object.fromEntries(Object.entries(filteredOptions.httpLogger).filter(([_, value]) => value !== void 0))
+    };
+  }
+  const merged = {
+    ...DEFAULT_LOGGER_OPTIONS,
+    ...preset,
+    ...filteredOptions
+  };
+  return merged;
+}
+__name(mergeWithDefaults, "mergeWithDefaults");
+function createDefaultLoggerProvider(options) {
+  return {
+    provide: Logger11,
+    useFactory: /* @__PURE__ */ __name(() => {
+      const logger = new Logger11();
+      if (options.level && typeof logger.setLogLevels === "function") {
+        const levels = getLevelsUpTo(options.level);
+        logger.setLogLevels(levels);
+      }
+      return logger;
+    }, "useFactory")
+  };
+}
+__name(createDefaultLoggerProvider, "createDefaultLoggerProvider");
+function createLoggerProviders(options = {}) {
+  const mergedOptions = mergeWithDefaults(options);
+  const providers = [
+    // Options provider
+    {
+      provide: LOGGER_MODULE_OPTIONS,
+      useValue: mergedOptions
+    }
+  ];
+  if (mergedOptions.provider === "default") {
+    providers.push(createDefaultLoggerProvider(mergedOptions));
+  }
+  providers.push({
+    provide: LoggerService2,
+    useFactory: /* @__PURE__ */ __name((opts, defaultLogger) => {
+      return new LoggerService2(opts, defaultLogger);
+    }, "useFactory"),
+    inject: [
+      LOGGER_MODULE_OPTIONS,
+      {
+        token: Logger11,
+        optional: true
+      }
+    ]
+  });
+  providers.push({
+    provide: CorrelationIdMiddleware,
+    useFactory: /* @__PURE__ */ __name(() => {
+      return new CorrelationIdMiddleware({
+        includeInResponse: true,
+        responseHeader: "x-correlation-id"
+      });
+    }, "useFactory")
+  });
+  providers.push({
+    provide: HttpLoggerInterceptor,
+    useFactory: /* @__PURE__ */ __name((logger, opts) => {
+      const httpLoggerOptions = opts.httpLogger ?? {
+        enableRequestLog: opts.enableHttpLogger,
+        enableResponseLog: opts.enableHttpLogger
+      };
+      return new HttpLoggerInterceptor(logger, httpLoggerOptions);
+    }, "useFactory"),
+    inject: [
+      LoggerService2,
+      LOGGER_MODULE_OPTIONS
+    ]
+  });
+  return providers;
+}
+__name(createLoggerProviders, "createLoggerProviders");
+function getLevelsUpTo(level) {
+  const allLevels = [
+    "error",
+    "warn",
+    "log",
+    "debug",
+    "verbose"
+  ];
+  const levelIndex = allLevels.indexOf(level);
+  if (levelIndex === -1) {
+    return [
+      "error",
+      "warn",
+      "log"
+    ];
+  }
+  return allLevels.slice(0, levelIndex + 1);
+}
+__name(getLevelsUpTo, "getLevelsUpTo");
+var LoggerModule = class _LoggerModule {
+  static {
+    __name(this, "LoggerModule");
+  }
+  /**
+  * Configures the logger module with static options.
+  *
+  * Users must explicitly pass `environment` to select a preset.
+  * All preset values can be overridden by passing explicit options.
+  *
+  * @param options - Logger configuration options
+  * @returns Dynamic module configuration
+  *
+  * @example
+  * ```typescript
+  * // Production preset with app name
+  * LoggerModule.forRoot({
+  *   environment: 'production',
+  *   appName: 'my-service'
+  * })
+  *
+  * // Development preset with custom level
+  * LoggerModule.forRoot({
+  *   environment: 'development',
+  *   level: 'verbose',
+  *   enableFileLogger: true
+  * })
+  *
+  * // Use default NestJS logger
+  * LoggerModule.forRoot({
+  *   provider: 'default',
+  *   environment: 'development'
+  * })
+  * ```
+  */
+  static forRoot(options = {}) {
+    const providers = createLoggerProviders(options);
+    return {
+      module: _LoggerModule,
+      providers,
+      exports: [
+        LoggerService2,
+        CorrelationIdMiddleware,
+        HttpLoggerInterceptor,
+        LOGGER_MODULE_OPTIONS
+      ]
+    };
+  }
+  /**
+  * Configures the logger module with async options.
+  *
+  * Supports dynamic configuration using:
+  * - `useFactory`: Factory function with dependency injection
+  * - `useClass`: Class implementing `LoggerOptionsFactory`
+  * - `useExisting`: Existing provider implementing `LoggerOptionsFactory`
+  *
+  * Options from the factory/class are merged with environment preset defaults.
+  *
+  * @param options - Async configuration options
+  * @returns Dynamic module configuration
+  *
+  * @example
+  * ```typescript
+  * // Factory with ConfigService
+  * LoggerModule.forRootAsync({
+  *   imports: [ConfigModule],
+  *   useFactory: (config: ConfigService) => ({
+  *     environment: config.get('NODE_ENV', 'development'),
+  *     provider: config.get('LOG_PROVIDER', 'winston'),
+  *     level: config.get('LOG_LEVEL'),
+  *     appName: config.get('APP_NAME'),
+  *   }),
+  *   inject: [ConfigService]
+  * })
+  *
+  * // Factory class
+  * @Injectable()
+  * class LoggerConfigService implements LoggerOptionsFactory {
+  *   createLoggerOptions(): LoggerModuleOptions {
+  *     return {
+  *       environment: 'production',
+  *       appName: 'my-service'
+  *     };
+  *   }
+  * }
+  *
+  * LoggerModule.forRootAsync({
+  *   useClass: LoggerConfigService
+  * })
+  * ```
+  */
+  static forRootAsync(options) {
+    const asyncProviders = this.createAsyncProviders(options);
+    return {
+      module: _LoggerModule,
+      imports: options.imports || [],
+      providers: [
+        ...asyncProviders,
+        // Default logger provider
+        {
+          provide: Logger11,
+          useFactory: /* @__PURE__ */ __name((opts) => {
+            if (opts.provider === "default") {
+              const logger = new Logger11();
+              if (opts.level && typeof logger.setLogLevels === "function") {
+                const levels = getLevelsUpTo(opts.level);
+                logger.setLogLevels(levels);
+              }
+              return logger;
+            }
+            return null;
+          }, "useFactory"),
+          inject: [
+            LOGGER_MODULE_OPTIONS
+          ]
+        },
+        // Unified logger service
+        {
+          provide: LoggerService2,
+          useFactory: /* @__PURE__ */ __name((opts, defaultLogger) => {
+            return new LoggerService2(opts, defaultLogger);
+          }, "useFactory"),
+          inject: [
+            LOGGER_MODULE_OPTIONS,
+            {
+              token: Logger11,
+              optional: true
+            }
+          ]
+        },
+        // Correlation ID middleware
+        {
+          provide: CorrelationIdMiddleware,
+          useFactory: /* @__PURE__ */ __name(() => {
+            return new CorrelationIdMiddleware({
+              includeInResponse: true,
+              responseHeader: "x-correlation-id"
+            });
+          }, "useFactory")
+        },
+        // HTTP logger interceptor
+        {
+          provide: HttpLoggerInterceptor,
+          useFactory: /* @__PURE__ */ __name((logger, opts) => {
+            const httpLoggerOptions = opts.httpLogger ?? {
+              enableRequestLog: opts.enableHttpLogger,
+              enableResponseLog: opts.enableHttpLogger
+            };
+            return new HttpLoggerInterceptor(logger, httpLoggerOptions);
+          }, "useFactory"),
+          inject: [
+            LoggerService2,
+            LOGGER_MODULE_OPTIONS
+          ]
+        }
+      ],
+      exports: [
+        LoggerService2,
+        CorrelationIdMiddleware,
+        HttpLoggerInterceptor,
+        LOGGER_MODULE_OPTIONS
+      ]
+    };
+  }
+  /**
+  * Configures middleware for the module.
+  * Middleware is registered globally in main.ts using Fastify hooks.
+  */
+  configure(consumer) {
+  }
+  /**
+  * Creates async providers for dynamic module configuration.
+  */
+  static createAsyncProviders(options) {
+    if (options.useFactory) {
+      return [
+        this.createAsyncOptionsProvider(options)
+      ];
+    }
+    const providers = [
+      this.createAsyncOptionsProvider(options)
+    ];
+    if (options.useClass) {
+      providers.push({
+        provide: options.useClass,
+        useClass: options.useClass
+      });
+    }
+    return providers;
+  }
+  /**
+  * Creates the async options provider.
+  */
+  static createAsyncOptionsProvider(options) {
+    if (options.useFactory) {
+      return {
+        provide: LOGGER_MODULE_OPTIONS,
+        useFactory: /* @__PURE__ */ __name(async (...args) => {
+          const userOptions = await options.useFactory(...args);
+          return mergeWithDefaults(userOptions);
+        }, "useFactory"),
+        inject: options.inject || []
+      };
+    }
+    if (options.useClass) {
+      return {
+        provide: LOGGER_MODULE_OPTIONS,
+        useFactory: /* @__PURE__ */ __name(async (optionsFactory) => {
+          const userOptions = await optionsFactory.createLoggerOptions();
+          return mergeWithDefaults(userOptions);
+        }, "useFactory"),
+        inject: [
+          options.useClass
+        ]
+      };
+    }
+    if (options.useExisting) {
+      return {
+        provide: LOGGER_MODULE_OPTIONS,
+        useFactory: /* @__PURE__ */ __name(async (optionsFactory) => {
+          const userOptions = await optionsFactory.createLoggerOptions();
+          return mergeWithDefaults(userOptions);
+        }, "useFactory"),
+        inject: [
+          options.useExisting
+        ]
+      };
     }
+    throw new Error("LoggerModule.forRootAsync() requires one of: useFactory, useClass, or useExisting");
   }
 };
+LoggerModule = _ts_decorate17([
+  Global4(),
+  Module5({})
+], LoggerModule);
 export {
   AuthConfigModule,
   BadGatewayException,
   BadRequestException,
   BaseFieldException,
   ConflictException,
+  CorrelationIdMiddleware,
   CsrfGuard,
+  DEFAULT_CORRELATION_HEADER,
   DatabaseModule,
   ForbiddenException2 as ForbiddenException,
   GoneException,
   HttpExceptionFilter,
+  HttpLoggerInterceptor,
   HttpModule,
   InternalServerErrorException3 as InternalServerErrorException,
+  LOGGER_MODULE_OPTIONS,
+  LoggerModule,
+  LoggerService2 as LoggerService,
   MethodNotAllowedException,
   NotAcceptableException,
   NotFoundException,
@@ -2493,6 +3265,12 @@ export {
   UnsupportedMediaTypeException,
   ValidationException,
   VrittiAuthGuard,
-  getHttpStatusTitle
+  addCorrelationIdToResponse,
+  correlationStorage,
+  generateCorrelationId,
+  getCorrelationContext,
+  getHttpStatusTitle,
+  runWithCorrelationContext,
+  updateCorrelationContext
 };
 //# sourceMappingURL=index.js.map