@navios/core 0.5.1 → 0.7.0

package/src/exceptions/bad-request.exception.mts

@@ -1,6 +1,27 @@
 import { HttpException } from './http.exception.mjs'
 
+/**
+ * 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')
+ *   }
+ *   // ...
+ * }
+ * ```
+ */
 export class BadRequestException extends HttpException {
+  /**
+   * Creates a new BadRequestException.
+   * 
+   * @param message - Error message or response object
+   */
   constructor(message: string | object) {
     super(400, message)
   }

package/src/exceptions/conflict.exception.d.mts

@@ -0,0 +1,29 @@
+import { HttpException } from './http.exception.mjs';
+/**
+ * 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')
+ *   }
+ *   // ...
+ * }
+ * ```
+ */
+export 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);
+}
+//# sourceMappingURL=conflict.exception.d.mts.map

package/src/exceptions/conflict.exception.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conflict.exception.d.mts","sourceRoot":"","sources":["conflict.exception.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEpD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,iBAAkB,SAAQ,aAAa;IAClD;;;;;OAKG;gBACS,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAGpD"}

package/src/exceptions/conflict.exception.mts

@@ -1,6 +1,30 @@
 import { HttpException } from './http.exception.mjs'
 
+/**
+ * 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')
+ *   }
+ *   // ...
+ * }
+ * ```
+ */
 export 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) {
     super(409, message, error)
   }

package/src/exceptions/forbidden.exception.d.mts

@@ -0,0 +1,28 @@
+import { HttpException } from './http.exception.mjs';
+/**
+ * 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')
+ *   }
+ *   // ...
+ * }
+ * ```
+ */
+export declare class ForbiddenException extends HttpException {
+    /**
+     * Creates a new ForbiddenException.
+     *
+     * @param message - Error message
+     */
+    constructor(message: string);
+}
+//# sourceMappingURL=forbidden.exception.d.mts.map

package/src/exceptions/forbidden.exception.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forbidden.exception.d.mts","sourceRoot":"","sources":["forbidden.exception.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEpD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,kBAAmB,SAAQ,aAAa;IACnD;;;;OAIG;gBACS,OAAO,EAAE,MAAM;CAG5B"}

package/src/exceptions/forbidden.exception.mts

@@ -1,6 +1,29 @@
 import { HttpException } from './http.exception.mjs'
 
+/**
+ * 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')
+ *   }
+ *   // ...
+ * }
+ * ```
+ */
 export class ForbiddenException extends HttpException {
+  /**
+   * Creates a new ForbiddenException.
+   * 
+   * @param message - Error message
+   */
   constructor(message: string) {
     super(403, message)
   }

package/src/exceptions/http.exception.d.mts

@@ -0,0 +1,33 @@
+/**
+ * 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
+ * }
+ * ```
+ */
+export 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);
+}
+//# sourceMappingURL=http.exception.d.mts.map

package/src/exceptions/http.exception.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.exception.d.mts","sourceRoot":"","sources":["http.exception.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,aAAa;aASN,UAAU,EAAE,MAAM;aAClB,QAAQ,EAAE,MAAM,GAAG,MAAM;aACzB,KAAK,CAAC,EAAE,KAAK;IAV/B;;;;;;OAMG;gBAEe,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GAAG,MAAM,EACzB,KAAK,CAAC,EAAE,KAAK,YAAA;CAEhC"}

package/src/exceptions/http.exception.mts

@@ -1,4 +1,30 @@
+/**
+ * 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
+ * }
+ * ```
+ */
 export class HttpException {
+  /**
+   * 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(
     public readonly statusCode: number,
     public readonly response: string | object,

package/src/exceptions/index.d.mts

@@ -0,0 +1,8 @@
+export * from './http.exception.mjs';
+export * from './bad-request.exception.mjs';
+export * from './forbidden.exception.mjs';
+export * from './internal-server-error.exception.mjs';
+export * from './not-found.exception.mjs';
+export * from './unauthorized.exception.mjs';
+export * from './conflict.exception.mjs';
+//# sourceMappingURL=index.d.mts.map

package/src/exceptions/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["index.mts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA;AACpC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,2BAA2B,CAAA;AACzC,cAAc,uCAAuC,CAAA;AACrD,cAAc,2BAA2B,CAAA;AACzC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,0BAA0B,CAAA"}

package/src/exceptions/internal-server-error.exception.d.mts

@@ -0,0 +1,31 @@
+import { HttpException } from './http.exception.mjs';
+/**
+ * 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)
+ *   }
+ * }
+ * ```
+ */
+export 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);
+}
+//# sourceMappingURL=internal-server-error.exception.d.mts.map

package/src/exceptions/internal-server-error.exception.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-server-error.exception.d.mts","sourceRoot":"","sources":["internal-server-error.exception.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEpD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,4BAA6B,SAAQ,aAAa;IAC7D;;;;;OAKG;gBACS,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAGpD"}

package/src/exceptions/internal-server-error.exception.mts

@@ -1,6 +1,32 @@
 import { HttpException } from './http.exception.mjs'
 
+/**
+ * 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)
+ *   }
+ * }
+ * ```
+ */
 export 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) {
     super(500, message, error)
   }

package/src/exceptions/not-found.exception.d.mts

@@ -0,0 +1,30 @@
+import { HttpException } from './http.exception.mjs';
+/**
+ * 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
+ * }
+ * ```
+ */
+export 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);
+}
+//# sourceMappingURL=not-found.exception.d.mts.map

package/src/exceptions/not-found.exception.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-found.exception.d.mts","sourceRoot":"","sources":["not-found.exception.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEpD;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,iBAAkB,SAAQ,aAAa;aAQhC,QAAQ,EAAE,MAAM,GAAG,MAAM;aACzB,KAAK,CAAC,EAAE,KAAK;IAR/B;;;;;OAKG;gBAEe,QAAQ,EAAE,MAAM,GAAG,MAAM,EACzB,KAAK,CAAC,EAAE,KAAK,YAAA;CAIhC"}

package/src/exceptions/not-found.exception.mts

@@ -1,6 +1,29 @@
 import { HttpException } from './http.exception.mjs'
 
+/**
+ * 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
+ * }
+ * ```
+ */
 export class NotFoundException extends HttpException {
+  /**
+   * Creates a new NotFoundException.
+   * 
+   * @param response - Error message or response object
+   * @param error - Optional underlying error for logging
+   */
   constructor(
     public readonly response: string | object,
     public readonly error?: Error,

package/src/exceptions/unauthorized.exception.d.mts

@@ -0,0 +1,28 @@
+import { HttpException } from './http.exception.mjs';
+/**
+ * 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')
+ *   }
+ *   // ...
+ * }
+ * ```
+ */
+export 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);
+}
+//# sourceMappingURL=unauthorized.exception.d.mts.map

package/src/exceptions/unauthorized.exception.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unauthorized.exception.d.mts","sourceRoot":"","sources":["unauthorized.exception.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEpD;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,qBAAsB,SAAQ,aAAa;IACtD;;;;;OAKG;gBACS,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAGpD"}

package/src/exceptions/unauthorized.exception.mts

@@ -1,6 +1,29 @@
 import { HttpException } from './http.exception.mjs'
 
+/**
+ * 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')
+ *   }
+ *   // ...
+ * }
+ * ```
+ */
 export 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) {
     super(401, message, error)
   }

package/src/factories/endpoint-adapter.factory.d.mts

@@ -0,0 +1,6 @@
+import type { FactoryContext } from '@navios/di';
+export declare class EndpointAdapterFactory {
+    private readonly environment;
+    create(ctx: FactoryContext): Promise<any>;
+}
+//# sourceMappingURL=endpoint-adapter.factory.d.mts.map

package/src/factories/endpoint-adapter.factory.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint-adapter.factory.d.mts","sourceRoot":"","sources":["endpoint-adapter.factory.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAkB,MAAM,YAAY,CAAA;AAOhE,qBAGa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA4B;IAExD,MAAM,CAAC,GAAG,EAAE,cAAc;CAO3B"}

package/src/factories/http-adapter.factory.d.mts

@@ -0,0 +1,6 @@
+import type { FactoryContext } from '@navios/di';
+export declare class HttpAdapterFactory {
+    private readonly environment;
+    create(ctx: FactoryContext): Promise<any>;
+}
+//# sourceMappingURL=http-adapter.factory.d.mts.map

package/src/factories/http-adapter.factory.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-adapter.factory.d.mts","sourceRoot":"","sources":["http-adapter.factory.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAOhD,qBAGa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA4B;IACxD,MAAM,CAAC,GAAG,EAAE,cAAc;CAO3B"}

package/src/factories/index.d.mts

@@ -0,0 +1,8 @@
+export * from './endpoint-adapter.factory.mjs';
+export * from './http-adapter.factory.mjs';
+export * from './multipart-adapter.factory.mjs';
+export * from './request.factory.mjs';
+export * from './reply.factory.mjs';
+export * from './stream-adapter.factory.mjs';
+export * from './xml-stream-adapter.factory.mjs';
+//# sourceMappingURL=index.d.mts.map

package/src/factories/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["index.mts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAA;AAC9C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,kCAAkC,CAAA"}

package/src/factories/index.mts

@@ -4,3 +4,4 @@ export * from './multipart-adapter.factory.mjs'
 export * from './request.factory.mjs'
 export * from './reply.factory.mjs'
 export * from './stream-adapter.factory.mjs'
+export * from './xml-stream-adapter.factory.mjs'

package/src/factories/multipart-adapter.factory.d.mts

@@ -0,0 +1,6 @@
+import type { FactoryContext } from '@navios/di';
+export declare class MultipartAdapterFactory {
+    private readonly environment;
+    create(ctx: FactoryContext): Promise<any>;
+}
+//# sourceMappingURL=multipart-adapter.factory.d.mts.map

package/src/factories/multipart-adapter.factory.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multipart-adapter.factory.d.mts","sourceRoot":"","sources":["multipart-adapter.factory.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAkB,MAAM,YAAY,CAAA;AAOhE,qBAGa,uBAAuB;IAClC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA4B;IAExD,MAAM,CAAC,GAAG,EAAE,cAAc;CAO3B"}

package/src/factories/reply.factory.d.mts

@@ -0,0 +1,6 @@
+import type { FactoryContext } from '@navios/di';
+export declare class ReplyFactory {
+    private readonly environment;
+    create(ctx: FactoryContext): Promise<any>;
+}
+//# sourceMappingURL=reply.factory.d.mts.map

package/src/factories/reply.factory.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reply.factory.d.mts","sourceRoot":"","sources":["reply.factory.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAkB,MAAM,YAAY,CAAA;AAOhE,qBAIa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA4B;IACxD,MAAM,CAAC,GAAG,EAAE,cAAc;CAO3B"}

package/src/factories/request.factory.d.mts

@@ -0,0 +1,6 @@
+import type { FactoryContext } from '@navios/di';
+export declare class RequestFactory {
+    private readonly environment;
+    create(ctx: FactoryContext): Promise<any>;
+}
+//# sourceMappingURL=request.factory.d.mts.map

package/src/factories/request.factory.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.factory.d.mts","sourceRoot":"","sources":["request.factory.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAkB,MAAM,YAAY,CAAA;AAOhE,qBAIa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA4B;IACxD,MAAM,CAAC,GAAG,EAAE,cAAc;CAO3B"}

package/src/factories/stream-adapter.factory.d.mts

@@ -0,0 +1,6 @@
+import type { FactoryContext } from '@navios/di';
+export declare class StreamAdapterFactory {
+    private readonly environment;
+    create(ctx: FactoryContext): Promise<any>;
+}
+//# sourceMappingURL=stream-adapter.factory.d.mts.map

package/src/factories/stream-adapter.factory.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-adapter.factory.d.mts","sourceRoot":"","sources":["stream-adapter.factory.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAkB,MAAM,YAAY,CAAA;AAOhE,qBAGa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA4B;IACxD,MAAM,CAAC,GAAG,EAAE,cAAc;CAO3B"}

package/src/factories/xml-stream-adapter.factory.d.mts

@@ -0,0 +1,6 @@
+import type { FactoryContext } from '@navios/di';
+export declare class XmlStreamAdapterFactory {
+    private readonly environment;
+    create(ctx: FactoryContext): Promise<any>;
+}
+//# sourceMappingURL=xml-stream-adapter.factory.d.mts.map

package/src/factories/xml-stream-adapter.factory.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xml-stream-adapter.factory.d.mts","sourceRoot":"","sources":["xml-stream-adapter.factory.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAkB,MAAM,YAAY,CAAA;AAOhE,qBAGa,uBAAuB;IAClC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA4B;IACxD,MAAM,CAAC,GAAG,EAAE,cAAc;CAO3B"}

package/src/factories/xml-stream-adapter.factory.mts

@@ -0,0 +1,20 @@
+import type { FactoryContext, InjectionToken } from '@navios/di'
+
+import { Factory, inject } from '@navios/di'
+
+import { NaviosEnvironment } from '../navios.environment.mjs'
+import { XmlStreamAdapterToken } from '../tokens/index.mjs'
+
+@Factory({
+  token: XmlStreamAdapterToken,
+})
+export class XmlStreamAdapterFactory {
+  private readonly environment = inject(NaviosEnvironment)
+  create(ctx: FactoryContext) {
+    const service = this.environment.getHttpToken(XmlStreamAdapterToken)
+    if (!service) {
+      throw new Error('XmlStreamAdapterToken service not found in environment')
+    }
+    return ctx.inject(service as InjectionToken<any, undefined>)
+  }
+}

package/src/index.d.mts

@@ -0,0 +1,15 @@
+export * from '@navios/di';
+export * from './config/index.mjs';
+export * from './decorators/index.mjs';
+export * from './exceptions/index.mjs';
+export * from './interfaces/index.mjs';
+export * from './logger/index.mjs';
+export * from './metadata/index.mjs';
+export * from './services/index.mjs';
+export * from './stores/index.mjs';
+export * from './tokens/index.mjs';
+export * from './attribute.factory.mjs';
+export * from './factories/index.mjs';
+export * from './navios.application.mjs';
+export * from './navios.factory.mjs';
+//# sourceMappingURL=index.d.mts.map

package/src/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["index.mts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,wBAAwB,CAAA;AACtC,cAAc,wBAAwB,CAAA;AACtC,cAAc,wBAAwB,CAAA;AACtC,cAAc,oBAAoB,CAAA;AAClC,cAAc,sBAAsB,CAAA;AACpC,cAAc,sBAAsB,CAAA;AACpC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,yBAAyB,CAAA;AACvC,cAAc,uBAAuB,CAAA;AACrC,cAAc,0BAA0B,CAAA;AACxC,cAAc,sBAAsB,CAAA"}

package/src/index.mts

@@ -6,6 +6,7 @@ export * from './interfaces/index.mjs'
 export * from './logger/index.mjs'
 export * from './metadata/index.mjs'
 export * from './services/index.mjs'
+export * from './stores/index.mjs'
 export * from './tokens/index.mjs'
 export * from './attribute.factory.mjs'
 export * from './factories/index.mjs'

package/src/interfaces/abstract-execution-context.inteface.d.mts

@@ -0,0 +1,44 @@
+import type { ControllerMetadata, HandlerMetadata, ModuleMetadata } from '../metadata/index.mjs';
+/**
+ * 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
+ *   }
+ * }
+ * ```
+ */
+export 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;
+}
+//# sourceMappingURL=abstract-execution-context.inteface.d.mts.map

package/src/interfaces/abstract-execution-context.inteface.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-execution-context.inteface.d.mts","sourceRoot":"","sources":["abstract-execution-context.inteface.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,eAAe,EACf,cAAc,EACf,MAAM,uBAAuB,CAAA;AAE9B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,wBAAwB;IACvC;;OAEG;IACH,SAAS,IAAI,cAAc,CAAA;IAC3B;;OAEG;IACH,aAAa,IAAI,kBAAkB,CAAA;IACnC;;OAEG;IACH,UAAU,IAAI,eAAe,CAAA;IAC7B;;OAEG;IACH,UAAU,IAAI,GAAG,CAAA;IACjB;;OAEG;IACH,QAAQ,IAAI,GAAG,CAAA;CAChB"}