@adonisjs/http-server 8.0.0-next.9 → 8.1.0

package/build/src/exception_handler.d.ts

@@ -3,16 +3,29 @@ import type { Level } from '@adonisjs/logger/types';
 import type { HttpContext } from './http_context/main.ts';
 import type { HttpError, StatusPageRange, StatusPageRenderer } from './types/server.ts';
 /**
- * The base HTTP exception handler one can inherit from to handle
- * HTTP exceptions.
+ * The base HTTP exception handler that provides comprehensive error handling capabilities.
  *
- * The HTTP exception handler has support for
+ * This class can be inherited to create custom exception handlers for your application.
+ * It provides built-in support for:
  *
- * - Ability to render exceptions by calling the render method on the exception.
- * - Rendering status pages
- * - Pretty printing errors during development
- * - Transforming errors to JSON or HTML using content negotiation
- * - Reporting errors
+ * - Self-handling exceptions via their own render/handle methods
+ * - Custom status page rendering for different HTTP error codes
+ * - Debug-friendly error display during development
+ * - Content negotiation for JSON, JSON API, and HTML error responses
+ * - Configurable error reporting and logging
+ * - Validation error handling with field-specific messages
+ *
+ * @example
+ * ```ts
+ * export default class HttpExceptionHandler extends ExceptionHandler {
+ *   protected debug = app.inDev
+ *   protected renderStatusPages = app.inProduction
+ *
+ *   protected statusPages = {
+ *     '404': (error, ctx) => ctx.view.render('errors/404')
+ *   }
+ * }
+ * ```
  */
 export declare class ExceptionHandler extends Macroable {
     #private;
@@ -53,6 +66,13 @@ export declare class ExceptionHandler extends Macroable {
      * Errors with these codes are handled but not logged
      */
     protected ignoreCodes: string[];
+    /**
+     * Normalizes any thrown value into a standardized HttpError object
+     * Ensures the error has required properties like message and status
+     * @param error - Any thrown value (Error, string, object, etc.)
+     * @returns {HttpError} Normalized error object with status and message
+     */
+    protected toHttpError(error: unknown): HttpError;
     /**
      * Provides additional context information for error reporting
      * Includes request ID when available for correlation across logs

package/build/src/helpers.d.ts

@@ -1,9 +1,11 @@
-import { type Encryption } from '@adonisjs/encryption';
+import { type Encryption } from '@boringnode/encryption';
+import { type Qs } from './qs.ts';
+import { createURL } from './client/helpers.ts';
 import { type CookieOptions } from './types/response.ts';
-import { type SignedURLOptions, type URLOptions } from './types/url_builder.ts';
+import { type SignedURLOptions } from './types/url_builder.ts';
 import type { RouteMatchers, RouteJSON, MatchItRouteToken } from './types/route.ts';
 import { type MiddlewareFn, type RouteHandlerInfo, type MiddlewareHandlerInfo, type ParsedGlobalMiddleware, type ParsedNamedMiddleware } from './types/middleware.ts';
-import { type Qs } from './qs.ts';
+export { createURL };
 /**
  * This function is similar to the intrinsic function encodeURI. However, it will not encode:
  *  - The \, ^, or | characters
@@ -43,20 +45,6 @@ export { default as mime } from 'mime-types';
  * @returns {MatchItRouteToken[]} Array of parsed route tokens
  */
 export declare function parseRoute(pattern: string, matchers?: RouteMatchers): MatchItRouteToken[];
-/**
- * Makes URL for a given route pattern using its parsed tokens. The
- * tokens could be generated using the "parseRoute" method.
- *
- * @param pattern - The route pattern
- * @param tokens - Array of parsed route tokens
- * @param searchParamsStringifier - Function to stringify query parameters
- * @param params - Route parameters as array or object
- * @param options - URL options
- * @returns {string} The generated URL
- */
-export declare function createURL(pattern: string, tokens: Pick<MatchItRouteToken, 'val' | 'type' | 'end'>[], searchParamsStringifier: (qs: Record<string, any>) => string, params?: any[] | {
-    [param: string]: any;
-}, options?: URLOptions): string;
 /**
  * Makes signed URL for a given route pattern using its parsed tokens. The
  * tokens could be generated using the "parseRoute" method.

package/build/src/helpers.js

@@ -1,24 +1,4 @@
-import {
-  appendQueryString,
-  createSignedURL,
-  createURL,
-  default as default2,
-  default2 as default3,
-  matchRoute,
-  middlewareInfo,
-  parseRoute,
-  routeInfo,
-  serializeCookie
-} from "../chunk-CVZAIRWJ.js";
-export {
-  appendQueryString,
-  createSignedURL,
-  createURL,
-  default2 as encodeUrl,
-  matchRoute,
-  middlewareInfo,
-  default3 as mime,
-  parseRoute,
-  routeInfo,
-  serializeCookie
-};
+import "../chunk-B2GA45YG.js";
+import { a as middlewareInfo, c as routeInfo, i as matchRoute, l as serializeCookie, n as createSignedURL, o as mime, r as encodeUrl, s as parseRoute, t as appendQueryString } from "../helpers-aa47NQc6.js";
+import { t as createURL } from "../helpers-XD4_pfkD.js";
+export { appendQueryString, createSignedURL, createURL, encodeUrl, matchRoute, middlewareInfo, mime, parseRoute, routeInfo, serializeCookie };

package/build/src/http_context/main.d.ts

@@ -1,36 +1,86 @@
 import Macroable from '@poppinss/macroable';
 import type { Logger } from '@adonisjs/logger';
 import { type ContainerResolver } from '@adonisjs/fold';
-import type { Request } from '../request.ts';
-import type { Response } from '../response.ts';
+import type { HttpRequest } from '../request.ts';
+import type { HttpResponse } from '../response.ts';
 import type { RouteJSON } from '../types/route.ts';
 /**
- * Http context encapsulates properties for a given HTTP request. The
- * context class can be extended using macros and getters.
+ * HTTP context encapsulates all properties and services for a given HTTP request.
+ *
+ * The HttpContext class serves as the central hub for request-specific data and services.
+ * It provides access to the request, response, route information, container resolver,
+ * and logger instances. The context can be extended using macros and getters for
+ * application-specific functionality.
+ *
+ * @example
+ * ```ts
+ * export default class UsersController {
+ *   async show({ request, response, params }: HttpContext) {
+ *     const user = await User.find(params.id)
+ *     return response.json(user)
+ *   }
+ * }
+ * ```
  */
 export declare class HttpContext extends Macroable {
-    request: Request;
-    response: Response;
+    request: HttpRequest;
+    response: HttpResponse;
     logger: Logger;
     containerResolver: ContainerResolver<any>;
     /**
-     * Find if async localstorage is enabled for HTTP requests
-     * or not
+     * Indicates whether async local storage is enabled for HTTP requests.
+     *
+     * When enabled, the HTTP context is automatically available within the
+     * scope of request processing through static methods like get() and getOrFail().
      */
     static get usingAsyncLocalStorage(): boolean;
     /**
-     * Get access to the HTTP context. Available only when
-     * "usingAsyncLocalStorage" is true
+     * Get access to the current HTTP context from async local storage.
+     *
+     * This method is only available when async local storage is enabled.
+     * Returns null if called outside of an HTTP request context.
+     *
+     * @example
+     * ```ts
+     * const ctx = HttpContext.get()
+     * if (ctx) {
+     *   console.log(ctx.request.url())
+     * }
+     * ```
      */
     static get(): HttpContext | null;
     /**
-     * Get the HttpContext instance or raise an exception if not
-     * available
+     * Get the HttpContext instance or raise an exception if not available.
+     *
+     * This method is useful when you need guaranteed access to the HTTP context
+     * and want to fail fast if it's not available.
+     *
+     * @throws RuntimeException when async local storage is disabled or context is unavailable
+     *
+     * @example
+     * ```ts
+     * const ctx = HttpContext.getOrFail()
+     * const userId = ctx.request.input('user_id')
+     * ```
      */
     static getOrFail(): HttpContext;
     /**
-     * Run a method that doesn't have access to HTTP context from
-     * the async local storage.
+     * Run a method outside of the HTTP context scope.
+     *
+     * This method allows you to execute code that should not have access to
+     * the current HTTP context from async local storage. Useful for background
+     * tasks or operations that should be context-independent.
+     *
+     * @param callback - Function to execute outside the context
+     * @param args - Arguments to pass to the callback
+     *
+     * @example
+     * ```ts
+     * HttpContext.runOutsideContext(() => {
+     *   // This code cannot access HttpContext.get()
+     *   performBackgroundTask()
+     * })
+     * ```
      */
     static runOutsideContext<T>(callback: (...args: any[]) => T, ...args: any[]): T;
     /**
@@ -53,12 +103,12 @@ export declare class HttpContext extends Macroable {
     /**
      * Creates a new HttpContext instance
      *
-     * @param {Request} request - The HTTP request instance
-     * @param {Response} response - The HTTP response instance
+     * @param {HttpRequest} request - The HTTP request instance
+     * @param {HttpResponse} response - The HTTP response instance
      * @param {Logger} logger - The logger instance
      * @param {ContainerResolver<any>} containerResolver - The IoC container resolver
      */
-    constructor(request: Request, response: Response, logger: Logger, containerResolver: ContainerResolver<any>);
+    constructor(request: HttpRequest, response: HttpResponse, logger: Logger, containerResolver: ContainerResolver<any>);
     /**
      * A helper to see top level properties on the context object
      */

package/build/src/qs.d.ts

@@ -1,7 +1,21 @@
 import { type QSParserConfig } from './types/qs.ts';
 /**
- * Query string parser used to parse and stringify query
- * strings.
+ * Query string parser that provides methods to parse and stringify query strings.
+ *
+ * This class wraps the popular 'qs' package with configurable options for parsing
+ * and stringifying query parameters. It allows customization of array handling,
+ * depth limits, and encoding behavior.
+ *
+ * @example
+ * ```ts
+ * const qs = new Qs({
+ *   parse: { depth: 5, arrayLimit: 20 },
+ *   stringify: { encode: false, skipNulls: true }
+ * })
+ *
+ * const parsed = qs.parse('users[0][name]=john&users[0][age]=25')
+ * const stringified = qs.stringify({ users: [{ name: 'john', age: 25 }] })
+ * ```
  */
 export declare class Qs {
     #private;
@@ -15,7 +29,7 @@ export declare class Qs {
      * @param value - Query string to parse (e.g., "foo=bar&baz=qux")
      * @returns Parsed object representation of the query string
      */
-    parse: (value: string) => import("qs").ParsedQs;
+    parse: (value: string) => import("@poppinss/qs").ParsedQs;
     /**
      * Converts a JavaScript object into a query string using the configured options
      * @param value - Object to convert to query string

package/build/src/redirect.d.ts

@@ -1,10 +1,29 @@
 import type { IncomingMessage } from 'node:http';
 import type { Qs } from './qs.ts';
-import type { Response } from './response.ts';
 import type { Router } from './router/main.ts';
+import type { HttpResponse } from './response.ts';
 import type { RoutesList, LookupList, URLOptions, GetRoutesForMethod, RouteBuilderArguments } from './types/url_builder.ts';
 /**
- * Exposes the API to construct redirect routes
+ * Provides a fluent API for constructing HTTP redirect responses.
+ *
+ * The Redirect class allows you to build redirects with custom status codes,
+ * query string forwarding, and route-based URL generation. It supports both
+ * direct URL redirects and route-based redirects using registered route names.
+ *
+ * @example
+ * ```ts
+ * // Basic redirect
+ * return response.redirect('https://example.com')
+ *
+ * // Redirect to a route
+ * return response.redirect().toRoute('users.show', { id: 1 })
+ *
+ * // Redirect with status code and query string
+ * return response.redirect()
+ *   .status(301)
+ *   .withQs({ utm_source: 'newsletter' })
+ *   .toPath('/dashboard')
+ * ```
  */
 export declare class Redirect {
     #private;
@@ -15,7 +34,7 @@ export declare class Redirect {
      * @param router - AdonisJS router instance
      * @param qs - Query string parser instance
      */
-    constructor(request: IncomingMessage, response: Response, router: Router, qs: Qs);
+    constructor(request: IncomingMessage, response: HttpResponse, router: Router, qs: Qs);
     /**
      * Sets a custom HTTP status code for the redirect response
      * @param statusCode - HTTP status code to use (e.g., 301, 302, 307)

package/build/src/request.d.ts

@@ -1,5 +1,5 @@
 import Macroable from '@poppinss/macroable';
-import type { Encryption } from '@adonisjs/encryption';
+import type { Encryption } from '@boringnode/encryption';
 import { type ServerResponse, type IncomingMessage, type IncomingHttpHeaders } from 'node:http';
 import type { Qs } from './qs.ts';
 import { type RequestConfig } from './types/request.ts';
@@ -13,7 +13,7 @@ import type { HttpContext } from './http_context/main.ts';
  * You can access the original [IncomingMessage](https://nodejs.org/api/http.html#http_class_http_incomingmessage)
  * using `request.request` property.
  */
-export declare class Request extends Macroable {
+export declare class HttpRequest extends Macroable {
     #private;
     /** Native Node.js incoming message instance */
     request: IncomingMessage;
@@ -48,9 +48,16 @@ export declare class Request extends Macroable {
     /** Native Node.js server response instance */
     response: ServerResponse, encryption: Encryption, config: RequestConfig, qsParser: Qs);
     /**
-     * Returns the request id from the `x-request-id` header. The
-     * header is untouched, if it already exists.
-     * @returns The request ID or undefined if not found/generated
+     * Returns the request ID from the `x-request-id` header.
+     *
+     * If the header doesn't exist and request ID generation is enabled,
+     * a new UUID will be generated and added to the request headers.
+     *
+     * @example
+     * ```ts
+     * const requestId = request.id()
+     * console.log(requestId) // '550e8400-e29b-41d4-a716-446655440000'
+     * ```
      */
     id(): string | undefined;
     /**

package/build/src/response.d.ts

@@ -1,5 +1,5 @@
 import Macroable from '@poppinss/macroable';
-import type { Encryption } from '@adonisjs/encryption';
+import type { Encryption } from '@boringnode/encryption';
 import { type ServerResponse, type IncomingMessage } from 'node:http';
 import type { Qs } from './qs.ts';
 import { Redirect } from './redirect.ts';
@@ -19,7 +19,7 @@ import type { CastableHeader, CookieOptions, ResponseConfig, ResponseStream } fr
  * response.download('/path/to/file.pdf')
  * ```
  */
-export declare class Response extends Macroable {
+export declare class HttpResponse extends Macroable {
     #private;
     request: IncomingMessage;
     response: ServerResponse;
@@ -46,7 +46,7 @@ export declare class Response extends Macroable {
     /**
      * The readable stream instance configured for the response
      */
-    get outgoingStream(): import("stream").Readable | undefined;
+    get outgoingStream(): ResponseStream | undefined;
     /**
      * Configuration for file streaming including path and etag generation flag
      */
@@ -159,14 +159,14 @@ export declare class Response extends Macroable {
      * @param key - Header name
      * @returns The header value
      */
-    getHeader(key: string): import("http").OutgoingHttpHeader | undefined;
+    getHeader(key: string): import("node:http").OutgoingHttpHeader | undefined;
     /**
      * Gets all response headers as an object
      *
      * @returns Object containing all headers
      */
     getHeaders(): {
-        [x: string]: import("http").OutgoingHttpHeader | undefined;
+        [x: string]: import("node:http").OutgoingHttpHeader | undefined;
         accept?: string | string[] | undefined;
         "accept-charset"?: string | string[] | undefined;
         "accept-encoding"?: string | string[] | undefined;

package/build/src/response_status.d.ts

@@ -1,3 +1,17 @@
+/**
+ * Standard HTTP response status codes organized as a constant object.
+ *
+ * This object provides named constants for all standard HTTP status codes,
+ * making code more readable and less error-prone when setting response statuses.
+ * The naming follows PascalCase convention for consistency with TypeScript conventions.
+ *
+ * @example
+ * ```ts
+ * response.status(ResponseStatus.NotFound)
+ * response.status(ResponseStatus.InternalServerError)
+ * response.status(ResponseStatus.Created)
+ * ```
+ */
 export declare const ResponseStatus: {
     readonly Continue: 100;
     readonly SwitchingProtocols: 101;

package/build/src/router/main.d.ts

@@ -1,4 +1,4 @@
-import type { Encryption } from '@adonisjs/encryption';
+import type { Encryption } from '@boringnode/encryption';
 import type { Application } from '@adonisjs/application';
 import type { Constructor, LazyImport } from '@poppinss/utils/types';
 import type { Qs } from '../qs.ts';
@@ -249,7 +249,11 @@ export declare class Router {
      * @param indentation - Indentation level for generated types
      * @returns Generated TypeScript types as string
      */
-    generateTypes(indentation?: number): string;
+    generateTypes(indentation?: number): {
+        imports: never[];
+        types: string[];
+        routes: string;
+    };
     /**
      * Find route for a given URL, method and optionally domain
      * @param uri - The URI to match

package/build/src/router/route.d.ts

@@ -2,10 +2,27 @@ import Macroable from '@poppinss/macroable';
 import type { Application } from '@adonisjs/application';
 import type { Constructor, LazyImport, OneOrMore } from '@poppinss/utils/types';
 import type { MiddlewareFn, ParsedNamedMiddleware, ParsedGlobalMiddleware } from '../types/middleware.ts';
-import type { RouteFn, RouteJSON, RouteMatcher, RouteMatchers, StoreRouteMiddleware, GetControllerHandlers } from '../types/route.ts';
+import type { RouteFn, RouteJSON, RouteMatcher, RouteMatchers, StoreRouteHandler, StoreRouteMiddleware, GetControllerHandlers } from '../types/route.ts';
 /**
- * The route class exposes the APIs for constructing a route using the
- * fluent API.
+ * The Route class provides a fluent API for constructing and configuring HTTP routes.
+ *
+ * Routes define how HTTP requests are handled by mapping URL patterns and HTTP methods
+ * to controller actions or inline handlers. This class supports middleware application,
+ * parameter validation, naming, and various other route-specific configurations.
+ *
+ * @example
+ * ```ts
+ * const route = new Route(app, middleware, {
+ *   pattern: '/users/:id',
+ *   methods: ['GET'],
+ *   handler: 'UsersController.show'
+ * })
+ *
+ * route
+ *   .where('id', /^[0-9]+$/)
+ *   .middleware(['auth'])
+ *   .as('users.show')
+ * ```
  */
 export declare class Route<Controller extends Constructor<any> = any> extends Macroable {
     #private;
@@ -22,79 +39,160 @@ export declare class Route<Controller extends Constructor<any> = any> extends Ma
         globalMatchers: RouteMatchers;
     });
     /**
-     * Define matcher for a given param. If a matcher exists, then we do not
-     * override that, since the routes inside a group will set matchers
-     * before the group, so they should have priority over the group
-     * matchers.
+     * Returns the route's handler configuration object.
+     */
+    getHandler(): StoreRouteHandler;
+    /**
+     * Defines a validation matcher for a route parameter. Route-level matchers
+     * take precedence over group-level matchers to ensure routes can override
+     * group constraints.
+     *
+     * @param param - The name of the route parameter to validate
+     * @param matcher - The validation pattern as a string, RegExp, or RouteMatcher object
      *
+     * @example
      * ```ts
+     * // Validate that 'id' is numeric
+     * route.where('id', /^[0-9]+$/)
+     *
+     * // Using a string pattern
+     * route.where('slug', '[a-z0-9-]+')
+     *
+     * // Route matcher takes precedence over group matcher
      * Route.group(() => {
      *   Route.get('/:id', 'handler').where('id', /^[0-9]$/)
      * }).where('id', /[^a-z$]/)
+     * // The route's /^[0-9]$/ wins over the group's matcher
      * ```
-     *
-     * The `/^[0-9]$/` will win over the matcher defined by the group
      */
     where(param: string, matcher: RouteMatcher | string | RegExp): this;
     /**
-     * Define prefix for the route. Calling this method multiple times
-     * applies multiple prefixes in the reverse order.
-     * @param prefix - The prefix to add to the route
-     * @returns Current Route instance for method chaining
+     * Adds a URL prefix to the route pattern. Multiple calls stack prefixes
+     * which are applied in reverse order during pattern computation.
+     *
+     * @param prefix - The URL prefix to prepend to the route pattern
+     *
+     * @example
+     * ```ts
+     * route.prefix('/api').prefix('/v1')
+     * // Results in pattern: /v1/api/users (for original pattern /users)
+     * ```
      */
     prefix(prefix: string): this;
     /**
-     * Define a custom domain for the route. We do not overwrite the domain
-     * unless `overwrite` flag is set to true.
+     * Assigns a custom domain to the route. By default, routes belong to the
+     * 'root' domain. Once set, the domain is not overwritten unless the
+     * overwrite flag is true.
+     *
+     * @param domain - The domain identifier for this route
+     * @param overwrite - Whether to overwrite an existing non-root domain
+     *
+     * @example
+     * ```ts
+     * route.domain('api.example.com')
+     *
+     * // Overwrite existing domain
+     * route.domain('new.example.com', true)
+     * ```
      */
     domain(domain: string, overwrite?: boolean): this;
     /**
-     * Define one or more middleware to be executed before the route
-     * handler.
+     * Registers one or more middleware to execute before the route handler.
+     * Middleware can be inline functions or named middleware references registered
+     * with the router's middleware store.
+     *
+     * @param middleware - Single middleware or array of middleware to apply
+     *
+     * @example
+     * ```ts
+     * // Single middleware
+     * route.use(async (ctx, next) => {
+     *   console.log('Before handler')
+     *   await next()
+     * })
      *
-     * Named middleware can be referenced using the name registered with
-     * the router middleware store.
+     * // Multiple middleware
+     * route.use(['auth', 'admin'])
+     * ```
      */
     use(middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this;
     /**
-     * Alias for {@link Route.use}
+     * Alias for the {@link Route.use} method.
+     *
+     * @param middleware - Single middleware or array of middleware to apply
      */
     middleware(middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this;
     /**
-     * Give a unique name to the route. Assinging a new unique removes the
-     * existing name of the route.
+     * Assigns a unique name to the route for use in URL generation and route
+     * referencing. Assigning a new name replaces any existing name unless
+     * prepend is true.
      *
-     * Setting prepends to true prefixes the name to the existing name.
+     * @param name - The route name to assign
+     * @param prepend - If true, prepends the name to the existing name with a dot separator
+     *
+     * @example
+     * ```ts
+     * // Set route name
+     * route.as('users.show')
+     *
+     * // Prepend to existing name (typically used by route groups)
+     * route.as('admin', true) // Results in 'admin.users.show'
+     * ```
      */
     as(name: string, prepend?: boolean): this;
     /**
-     * Check if the route was marked to be deleted
+     * Checks whether the route has been marked for deletion. Deleted routes
+     * are excluded from the route store during registration.
      */
     isDeleted(): boolean;
     /**
-     * Mark route as deleted. Deleted routes are not registered
-     * with the route store
+     * Marks the route for deletion. Deleted routes will not be registered
+     * with the route store when Router.commit() is called.
+     *
+     * @example
+     * ```ts
+     * const route = Route.get('/admin', 'handler')
+     * route.markAsDeleted()
+     * // This route will not be registered
+     * ```
      */
     markAsDeleted(): void;
     /**
-     * Get the route name
+     * Returns the unique name assigned to the route, if any.
      */
     getName(): string | undefined;
     /**
-     * Get the route pattern
+     * Returns the route's URL pattern with dynamic parameters.
      */
     getPattern(): string;
     /**
-     * Set the route pattern
+     * Updates the route's URL pattern.
+     *
+     * @param pattern - The new URL pattern to assign to the route
+     *
+     * @example
+     * ```ts
+     * route.setPattern('/users/:id/posts/:postId')
+     * ```
      */
     setPattern(pattern: string): this;
     /**
-     * Returns the stack of middleware registered on the route.
-     * The value is shared by reference.
+     * Returns the multi-dimensional middleware stack registered on this route.
+     * The returned value is shared by reference, not a copy.
      */
     getMiddleware(): StoreRouteMiddleware[][];
     /**
-     * Returns JSON representation of the route
+     * Serializes the route into a JSON representation suitable for storage and
+     * execution. This includes the computed pattern with prefixes, merged matchers,
+     * parsed route tokens, and frozen middleware stack.
+     *
+     * @example
+     * ```ts
+     * const json = route.toJSON()
+     * console.log(json.pattern) // '/api/users/:id'
+     * console.log(json.methods) // ['GET']
+     * console.log(json.name) // 'users.show'
+     * ```
      */
     toJSON(): RouteJSON;
 }

package/build/src/router/signed_url_builder.d.ts

@@ -1,4 +1,4 @@
-import type { Encryption } from '@adonisjs/encryption';
+import type { Encryption } from '@boringnode/encryption';
 import { type Router } from './main.ts';
 import { type UrlFor, type LookupList, type SignedURLOptions } from '../types/url_builder.ts';
 /**