@adonisjs/http-server 7.7.0 → 8.0.0-next.1

package/build/src/helpers.d.ts

@@ -1,23 +1,58 @@
-import { Route } from './router/route.js';
-import { BriskRoute } from './router/brisk.js';
-import { RouteGroup } from './router/group.js';
-import type { RouteJSON } from './types/route.js';
-import { RouteResource } from './router/resource.js';
+import { type CookieOptions } from './types/response.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';
 /**
- * Makes input string consistent by having only the starting
- * slash
+ * This function is similar to the intrinsic function encodeURI. However, it will not encode:
+ *  - The \, ^, or | characters
+ *  - The % character when it's part of a valid sequence
+ *  - [ and ] (for IPv6 hostnames)
+ *  - Replaces raw, unpaired surrogate pairs with the Unicode replacement character
+ *
+ * Some tests
+ * encodeURI('http://localhost/%20snow.html') // http://localhost/%2520snow.html
+ * encodeUrl('http://localhost/%20snow.html') // http://localhost/%20snow.html
+ *
+ * encodeURI('http://[::1]:8080/foo/bar') // http://%5B::1%5D:8080/foo/bar
+ * encodeUrl('http://[::1]:8080/foo/bar') // http://[::1]:8080/foo/bar
  */
-export declare function dropSlash(input: string): string;
+export { default as encodeUrl } from 'encodeurl';
 /**
- * Returns a flat list of routes from the route groups and resources
+ * Re-exports the "https://www.npmjs.com/package/mime-types" package
  */
-export declare function toRoutesJSON(routes: (RouteGroup | Route | RouteResource | BriskRoute)[]): RouteJSON[];
+export { default as mime } from 'mime-types';
 /**
- * Helper to know if the remote address should
- * be trusted.
+ * Parse a route pattern into an array of tokens. These tokes can be used
+ * to match routes, or print them with semantic information.
+ *
+ * Token types
+ *
+ * - 0: (static) segment
+ * - 1: (parameter) segment
+ * - 2: (wildcard) segment
+ * - 3: (optional parameter) segment
+ *
+ * Value (val) refers to the segment value
+ *
+ * end refers to be the suffix or the segment (if any)
  */
-export declare function trustProxy(remoteAddress: string, proxyFn: (addr: string, distance: number) => boolean): boolean;
+export declare function parseRoute(pattern: string, matchers?: RouteMatchers): MatchItRouteToken[];
 /**
- * Parses a range expression to an object filled with the range
+ * Match a given URI with an array of patterns and extract the params
+ * from the URL. Null value is returned in case of no match
  */
-export declare function parseRange<T>(range: string, value: T): Record<number, T>;
+export declare function matchRoute(url: string, patterns: string[]): null | Record<string, string>;
+/**
+ * Serialize the value of a cookie to a string you can send via
+ * set-cookie response header.
+ */
+export declare function serializeCookie(key: string, value: string, options?: Partial<CookieOptions>): string;
+/**
+ * Returns the info about a middleware handler. In case of lazy imports, the method
+ * will return the import path
+ */
+export declare function middlewareInfo(middleware: MiddlewareFn | ParsedGlobalMiddleware | ParsedNamedMiddleware): Promise<MiddlewareHandlerInfo>;
+/**
+ * Returns the info about a route handler. In case of lazy imports, the method
+ * will return the import path.
+ */
+export declare function routeInfo(route: RouteJSON): Promise<RouteHandlerInfo>;

package/build/src/helpers.js

@@ -0,0 +1,18 @@
+import {
+  default as default2,
+  default2 as default3,
+  matchRoute,
+  middlewareInfo,
+  parseRoute,
+  routeInfo,
+  serializeCookie
+} from "../chunk-ASX56VAK.js";
+export {
+  default2 as encodeUrl,
+  matchRoute,
+  middlewareInfo,
+  default3 as mime,
+  parseRoute,
+  routeInfo,
+  serializeCookie
+};

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

@@ -1,5 +1,5 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
-import type { HttpContext } from './main.js';
+import type { HttpContext } from './main.ts';
 /**
  * Async local storage for HTTP context
  */

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

@@ -1,9 +1,9 @@
 import Macroable from '@poppinss/macroable';
 import type { Logger } from '@adonisjs/logger';
-import { ContainerResolver } from '@adonisjs/fold';
-import type { Request } from '../request.js';
-import type { Response } from '../response.js';
-import type { StoreRouteNode } from '../types/route.js';
+import { type ContainerResolver } from '@adonisjs/fold';
+import type { Request } from '../request.ts';
+import type { Response } 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.
@@ -37,7 +37,7 @@ export declare class HttpContext extends Macroable {
      * Reference to the current route. Not available inside
      * server middleware
      */
-    route?: StoreRouteNode;
+    route?: RouteJSON;
     /**
      * A unique key for the current route
      */

package/build/src/qs.d.ts

@@ -1,4 +1,4 @@
-import { QSParserConfig } from './types/qs.js';
+import { type QSParserConfig } from './types/qs.ts';
 /**
  * Query string parser used to parse and stringify query
  * strings.
@@ -6,6 +6,6 @@ import { QSParserConfig } from './types/qs.js';
 export declare class Qs {
     #private;
     constructor(config: QSParserConfig);
-    parse(value: string): import("qs").ParsedQs;
-    stringify(value: any): string;
+    parse: (value: string) => import("qs").ParsedQs;
+    stringify: (value: any) => string;
 }

package/build/src/redirect.d.ts

@@ -1,8 +1,8 @@
 import type { IncomingMessage } from 'node:http';
-import type { Qs } from './qs.js';
-import type { Response } from './response.js';
-import type { Router } from './router/main.js';
-import type { MakeUrlOptions } from './types/route.js';
+import type { Qs } from './qs.ts';
+import type { Response } from './response.ts';
+import type { Router } from './router/main.ts';
+import type { RoutesList, URLOptions, GetRoutesForMethod, RouteBuilderArguments } from './types/url_builder.ts';
 /**
  * Exposes the API to construct redirect routes
  */
@@ -33,7 +33,7 @@ export declare class Redirect {
     /**
      * Redirect the request using a route identifier.
      */
-    toRoute(routeIdentifier: string, params?: any[] | Record<string, any>, options?: MakeUrlOptions): void;
+    toRoute<Identifier extends keyof GetRoutesForMethod<'GET'> & string>(...args: RouteBuilderArguments<RoutesList, Identifier, 'GET', URLOptions>): void;
     /**
      * Redirect the request using a path.
      */

package/build/src/request.d.ts

@@ -1,10 +1,9 @@
 import Macroable from '@poppinss/macroable';
-import { UrlWithStringQuery } from 'node:url';
 import type { Encryption } from '@adonisjs/encryption';
-import { ServerResponse, IncomingMessage, IncomingHttpHeaders } from 'node:http';
-import type { Qs } from './qs.js';
-import { RequestConfig } from './types/request.js';
-import type { HttpContext } from './http_context/main.js';
+import { type ServerResponse, type IncomingMessage, type IncomingHttpHeaders } from 'node:http';
+import type { Qs } from './qs.ts';
+import { type RequestConfig } from './types/request.ts';
+import type { HttpContext } from './http_context/main.ts';
 /**
  * HTTP Request class exposes the interface to consistently read values
  * related to a given HTTP request. The class is wrapper over
@@ -19,11 +18,13 @@ export declare class Request extends Macroable {
     request: IncomingMessage;
     response: ServerResponse;
     /**
-     * Parses copy of the URL with query string as a string and not
-     * object. This is done to build URL's with query string without
-     * stringifying the object
+     * Parsed URL with query string stored as a string.
      */
-    parsedUrl: UrlWithStringQuery;
+    parsedUrl: {
+        pathname: string;
+        query: string;
+        shouldDecodeParam: boolean;
+    };
     /**
      * The ctx will be set by the context itself. It creates a circular
      * reference
@@ -532,7 +533,7 @@ export declare class Request extends Macroable {
     serialize(): {
         id: string | undefined;
         url: string;
-        query: string | null;
+        query: string;
         body: Record<string, any>;
         params: Record<string, any>;
         headers: IncomingHttpHeaders;
@@ -549,7 +550,7 @@ export declare class Request extends Macroable {
     toJSON(): {
         id: string | undefined;
         url: string;
-        query: string | null;
+        query: string;
         body: Record<string, any>;
         params: Record<string, any>;
         headers: IncomingHttpHeaders;

package/build/src/response.d.ts

@@ -1,11 +1,11 @@
 import Macroable from '@poppinss/macroable';
 import type { Encryption } from '@adonisjs/encryption';
-import { ServerResponse, IncomingMessage } from 'node:http';
-import type { Qs } from './qs.js';
-import { Redirect } from './redirect.js';
-import type { Router } from './router/main.js';
-import type { HttpContext } from './http_context/main.js';
-import type { CastableHeader, CookieOptions, ResponseConfig, ResponseStream } from './types/response.js';
+import { type ServerResponse, type IncomingMessage } from 'node:http';
+import type { Qs } from './qs.ts';
+import { Redirect } from './redirect.ts';
+import type { Router } from './router/main.ts';
+import type { HttpContext } from './http_context/main.ts';
+import type { CastableHeader, CookieOptions, ResponseConfig, ResponseStream } from './types/response.ts';
 /**
  * The response is a wrapper over [ServerResponse](https://nodejs.org/api/http.html#http_class_http_serverresponse)
  * streamlining the process of writing response body and automatically setting up appropriate headers.

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

@@ -1,8 +1,9 @@
 import Macroable from '@poppinss/macroable';
 import type { Application } from '@adonisjs/application';
-import { Route } from './route.js';
-import type { ParsedGlobalMiddleware } from '../types/middleware.js';
-import type { MakeUrlOptions, RouteFn, RouteMatchers } from '../types/route.js';
+import { Route } from './route.ts';
+import type { RouteFn, RouteMatchers } from '../types/route.ts';
+import type { ParsedGlobalMiddleware } from '../types/middleware.ts';
+import type { RoutesList, URLOptions, GetRoutesForMethod, RouteBuilderArguments } from '../types/url_builder.ts';
 /**
  * Brisk routes exposes the API to configure the route handler by chaining
  * one of the pre-defined methods.
@@ -30,9 +31,9 @@ export declare class BriskRoute extends Macroable {
      * Redirects to a given route. Params from the original request will
      * be used when no custom params are defined.
      */
-    redirect(identifier: string, params?: any[] | Record<string, any>, options?: MakeUrlOptions & {
+    redirect<Identifier extends keyof GetRoutesForMethod<'GET'> & string>(...args: RouteBuilderArguments<RoutesList, Identifier, 'GET', URLOptions & {
         status: number;
-    }): Route;
+    }>): Route;
     /**
      * Redirect request to a fixed URL
      */

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

@@ -1,9 +1,9 @@
 import type { ContainerResolver } from '@adonisjs/fold';
-import type { StoreRouteNode } from '../types/route.js';
-import type { HttpContext } from '../http_context/main.js';
-import type { ServerErrorHandler } from '../types/server.js';
+import type { RouteJSON } from '../types/route.ts';
+import type { HttpContext } from '../http_context/main.ts';
+import type { ServerErrorHandler } from '../types/server.ts';
 /**
  * Executor to execute the route middleware pipeline the route
  * handler
  */
-export declare function execute(route: StoreRouteNode, resolver: ContainerResolver<any>, ctx: HttpContext, errorResponder: ServerErrorHandler['handle']): Promise<void>;
+export declare function execute(route: RouteJSON, resolver: ContainerResolver<any>, ctx: HttpContext, errorResponder: ServerErrorHandler['handle']): Promise<void>;

package/build/src/router/factories/use_return_value.d.ts

@@ -1,4 +1,9 @@
-import type { HttpContext } from '../../http_context/main.js';
+import { type HttpContext } from '../../http_context/main.ts';
+/**
+ * Check if the value can be used to write the response body. Returns
+ * false when the response body has already been set
+ */
+export declare function canWriteResponseBody(value: any, ctx: HttpContext): boolean;
 /**
  * A factory function that uses the return value of the request
  * pipeline as the response

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

@@ -1,10 +1,10 @@
 import Macroable from '@poppinss/macroable';
-import type { RouteMatcher } from '../types/route.js';
-import type { MiddlewareFn, ParsedNamedMiddleware } from '../types/middleware.js';
-import { Route } from './route.js';
-import { BriskRoute } from './brisk.js';
-import { RouteResource } from './resource.js';
-import { OneOrMore } from '../types/base.js';
+import type { OneOrMore } from '@poppinss/utils/types';
+import { type Route } from './route.ts';
+import { BriskRoute } from './brisk.ts';
+import { RouteResource } from './resource.ts';
+import { type RouteMatcher } from '../types/route.ts';
+import type { MiddlewareFn, ParsedNamedMiddleware } from '../types/middleware.ts';
 /**
  * Group class exposes the API to take action on a group of routes.
  * The group routes must be pre-defined using the constructor.

package/build/src/router/{lookup_store → legacy}/url_builder.d.ts

@@ -1,6 +1,4 @@
-import type { Encryption } from '@adonisjs/encryption';
-import type { Qs } from '../../qs.js';
-import type { RouteFinder } from './route_finder.js';
+import { type Router } from '../main.ts';
 /**
  * URL builder class is used to create URIs for pre-registered
  * routes.
@@ -13,37 +11,55 @@ import type { RouteFinder } from './route_finder.js';
  *  .params([category.id])
  *  .make('categories.posts.index')
  * ```
+ *
+ * @deprecated
+ * Instead use "@adonisjs/core/services/url_builder" instead
  */
 export declare class UrlBuilder {
     #private;
-    constructor(encryption: Encryption, routeFinder: RouteFinder, qsParser: Qs);
+    constructor(router: Router, domain?: string);
     /**
      * Prefix a custom base URL to the final URI
+     * @deprecated
+     * Instead use "@adonisjs/core/services/url_builder" instead
      */
     prefixUrl(url: string): this;
     /**
      * Disable route lookup. Calling this method considers
      * the "identifier" as the route pattern
+     * @deprecated
+     * Instead use "@adonisjs/core/services/url_builder" instead
      */
     disableRouteLookup(): this;
     /**
      * Append query string to the final URI
+     * @deprecated
+     * Instead use "@adonisjs/core/services/url_builder" instead
      */
     qs(queryString?: Record<string, any>): this;
     /**
      * Specify params to apply to the route pattern
+     * @deprecated
+     * Instead use "@adonisjs/core/services/url_builder" instead
      */
     params(params?: any[] | Record<string, any>): this;
     /**
      * Generate URL for the given route identifier. The identifier can be the
      * route name, controller.method name or the route pattern
      * itself.
+     *
+     * @deprecated
+     * Instead use "@adonisjs/core/services/url_builder" instead
      */
     make(identifier: string): string;
     /**
      * Generate a signed URL for the given route identifier. The identifier can be the
      * route name, controller.method name or the route pattern
      * itself.
+     *
+     * @deprecated
+     * Instead use "@adonisjs/core/services/url_builder" instead
+     *
      */
     makeSigned(identifier: string, options?: {
         expiresIn?: string | number;

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

@@ -1,15 +1,16 @@
 import type { Encryption } from '@adonisjs/encryption';
 import type { Application } from '@adonisjs/application';
-import type { Qs } from '../qs.js';
-import { Route } from './route.js';
-import { RouteGroup } from './group.js';
-import { BriskRoute } from './brisk.js';
-import { RouteResource } from './resource.js';
-import { LookupStore } from './lookup_store/main.js';
-import { RouteMatchers as Matchers } from './matchers.js';
-import type { Constructor, LazyImport } from '../types/base.js';
-import type { MiddlewareAsClass, ParsedGlobalMiddleware } from '../types/middleware.js';
-import type { RouteFn, MatchedRoute, RouteMatcher, RouteMatchers, MakeUrlOptions, MakeSignedUrlOptions, GetControllerHandlers } from '../types/route.js';
+import type { Constructor, LazyImport } from '@poppinss/utils/types';
+import type { Qs } from '../qs.ts';
+import { Route } from './route.ts';
+import { RouteGroup } from './group.ts';
+import { BriskRoute } from './brisk.ts';
+import { RouteResource } from './resource.ts';
+import { UrlBuilder } from './legacy/url_builder.ts';
+import { RouteMatchers as Matchers } from './matchers.ts';
+import type { MiddlewareAsClass, ParsedGlobalMiddleware } from '../types/middleware.ts';
+import type { RouteFn, RouteJSON, MatchedRoute, RouteMatchers, MakeUrlOptions, MakeSignedUrlOptions, GetControllerHandlers, RouteMatcher } from '../types/route.ts';
+import { type UrlFor, type LookupList, type RoutesList, type SignedURLOptions } from '../types/url_builder.ts';
 /**
  * Router class exposes a unified API to register new routes, group them or
  * create route resources.
@@ -22,13 +23,8 @@ import type { RouteFn, MatchedRoute, RouteMatcher, RouteMatchers, MakeUrlOptions
  * })
  * ```
  */
-export declare class Router extends LookupStore {
+export declare class Router {
     #private;
-    /**
-     * Collection of routes, including route resource and route
-     * group. To get a flat list of routes, call `router.toJSON()`
-     */
-    routes: (Route | RouteResource | RouteGroup | BriskRoute)[];
     /**
      * A flag to know if routes for explicit domains have been registered.
      * The boolean is computed after calling the "commit" method.
@@ -44,11 +40,36 @@ export declare class Router extends LookupStore {
      * have no impact
      */
     get commited(): boolean;
+    /**
+     * Query string parser for making URLs
+     */
+    qs: Qs;
+    /**
+     * The URLBuilder offers a type-safe API for creating URL for pre-registered
+     * routes or the route patterns.
+     *
+     * We recommend using the URLBuilder over the "makeUrl" and "makeSignedUrl"
+     * methods.
+     */
+    urlBuilder: {
+        urlFor: UrlFor<RoutesList extends LookupList ? RoutesList : never>;
+        signedUrlFor: UrlFor<RoutesList extends LookupList ? RoutesList : never, SignedURLOptions>;
+    };
+    /**
+     * List of route references kept for lookup.
+     */
+    protected routes: {
+        [domain: string]: RouteJSON[];
+    };
     constructor(app: Application<any>, encryption: Encryption, qsParser: Qs);
+    /**
+     * Register route JSON payload
+     */
+    protected register(route: RouteJSON): void;
     /**
      * Parses the route pattern
      */
-    parsePattern(pattern: string, matchers?: RouteMatchers): import("../types/route.js").MatchItRouteToken[];
+    parsePattern(pattern: string, matchers?: RouteMatchers): import("../types/route.ts").MatchItRouteToken[];
     /**
      * Define an array of middleware to use on all the routes.
      * Calling this method multiple times pushes to the
@@ -60,8 +81,9 @@ export declare class Router extends LookupStore {
      * not registered anywhere, but instead converted in a new collection
      * of functions you can apply on the routes, or router groups.
      */
-    named<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>>>(collection: NamedMiddleware): { [K in keyof NamedMiddleware]: <Args extends import("../types/middleware.js").GetMiddlewareArgs<import("../types/base.js").UnWrapLazyImport<NamedMiddleware[K]>>>(...args: Args) => {
+    named<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>>>(collection: NamedMiddleware): { [K in keyof NamedMiddleware]: <Args extends import("../types/middleware.ts").GetMiddlewareArgs<import("@poppinss/utils/types").UnWrapLazyImport<NamedMiddleware[K]>>>(...args: Args) => {
         name: K;
+        reference: LazyImport<MiddlewareAsClass> | MiddlewareAsClass;
         args: Args[0];
         handle: ParsedGlobalMiddleware["handle"];
     }; };
@@ -101,11 +123,11 @@ export declare class Router extends LookupStore {
     /**
      * Registers a route resource with conventional set of routes
      */
-    resource(resource: string, controller: string | LazyImport<Constructor<any>> | Constructor<any>): RouteResource<import("../types/route.js").ResourceActionNames>;
+    resource(resource: string, controller: string | LazyImport<Constructor<any>> | Constructor<any>): RouteResource<import("../types/route.ts").ResourceActionNames>;
     /**
      * Register a route resource with shallow nested routes.
      */
-    shallowResource(resource: string, controller: string | LazyImport<Constructor<any>> | Constructor<any>): RouteResource<import("../types/route.js").ResourceActionNames>;
+    shallowResource(resource: string, controller: string | LazyImport<Constructor<any>> | Constructor<any>): RouteResource<import("../types/route.ts").ResourceActionNames>;
     /**
      * Returns a brisk route instance for a given URL pattern
      */
@@ -120,16 +142,90 @@ export declare class Router extends LookupStore {
      * commit method is called.
      */
     commit(): void;
+    /**
+     * The lookup strategies to follow when generating URL builder
+     * types and client
+     */
+    lookupStrategies: ('name' | 'pattern' | 'controller')[];
+    /**
+     * Define the lookup strategies to follow when generating URL builder
+     * types and client.
+     */
+    updateLookupStrategies(strategies: ('name' | 'pattern' | 'controller')[]): this;
+    /**
+     * Finds a route by its identifier. The identifier can be the
+     * route name, controller.method name or the route pattern
+     * itself.
+     *
+     * When "followLookupStrategy" is enabled, the lookup will be performed
+     * on the basis of the lookup strategy enabled via the "lookupStrategies"
+     * method. The default lookupStrategy is "name" and "pattern".
+     */
+    find(routeIdentifier: string, domain?: string, method?: string, followLookupStrategy?: boolean): RouteJSON | null;
+    /**
+     * Finds a route by its identifier. The identifier can be the
+     * route name, controller.method name or the route pattern
+     * itself.
+     *
+     * An error is raised when unable to find the route.
+     *
+     * When "followLookupStrategy" is enabled, the lookup will be performed
+     * on the basis of the lookup strategy enabled via the "lookupStrategies"
+     * method. The default lookupStrategy is "name" and "pattern".
+     */
+    findOrFail(routeIdentifier: string, domain?: string, method?: string, followLookupStrategy?: boolean): RouteJSON;
+    /**
+     * Check if a route exists. The identifier can be the
+     * route name, controller.method name or the route pattern
+     * itself.
+     *
+     * When "followLookupStrategy" is enabled, the lookup will be performed
+     * on the basis of the lookup strategy enabled via the "lookupStrategies"
+     * method. The default lookupStrategy is "name" and "pattern".
+     */
+    has(routeIdentifier: string, domain?: string, method?: string, followLookupStrategy?: boolean): boolean;
+    /**
+     * Returns a list of routes grouped by their domain names
+     */
+    toJSON(): {
+        [domain: string]: RouteJSON[];
+    };
+    /**
+     * Generates types for the URL builder. These types must
+     * be written inside a file for the URL builder to
+     * pick them up.
+     */
+    generateTypes(indentation?: number): string;
     /**
      * Find route for a given URL, method and optionally domain
      */
-    match(url: string, method: string, hostname?: string | null): null | MatchedRoute;
+    match(uri: string, method: string, shouldDecodeParam: boolean, hostname?: string | null): null | MatchedRoute;
+    /**
+     * Create URL builder instance.
+     * @deprecated
+     *
+     * Instead use "@adonisjs/core/services/url_builder" instead
+     */
+    builder(): UrlBuilder;
+    /**
+     * Create URL builder instance for a given domain.
+     * @deprecated
+     *
+     * Instead use "@adonisjs/core/services/url_builder"
+     */
+    builderForDomain(domain: string): UrlBuilder;
     /**
      * Make URL to a pre-registered route
+     *
+     * @deprecated
+     * Instead use "@adonisjs/core/services/url_builder"
      */
     makeUrl(routeIdentifier: string, params?: any[] | Record<string, any>, options?: MakeUrlOptions): string;
     /**
      * Makes a signed URL to a pre-registered route.
+     *
+     * @deprecated
+     * Instead use "@adonisjs/core/services/url_builder"
      */
     makeSignedUrl(routeIdentifier: string, params?: any[] | Record<string, any>, options?: MakeSignedUrlOptions): string;
 }

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

@@ -1,9 +1,9 @@
 import Macroable from '@poppinss/macroable';
 import type { Application } from '@adonisjs/application';
-import { Route } from './route.js';
-import type { Constructor, LazyImport, OneOrMore } from '../types/base.js';
-import type { MiddlewareFn, ParsedGlobalMiddleware, ParsedNamedMiddleware } from '../types/middleware.js';
-import type { ResourceActionNames, RouteMatcher, RouteMatchers } from '../types/route.js';
+import type { Constructor, LazyImport, OneOrMore } from '@poppinss/utils/types';
+import { Route } from './route.ts';
+import type { ResourceActionNames, RouteMatcher, RouteMatchers } from '../types/route.ts';
+import type { MiddlewareFn, ParsedNamedMiddleware, ParsedGlobalMiddleware } from '../types/middleware.ts';
 /**
  * Route resource exposes the API to register multiple routes for a resource.
  */

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

@@ -1,8 +1,8 @@
 import Macroable from '@poppinss/macroable';
 import type { Application } from '@adonisjs/application';
-import type { Constructor, LazyImport, OneOrMore } from '../types/base.js';
-import type { MiddlewareFn, ParsedNamedMiddleware, ParsedGlobalMiddleware } from '../types/middleware.js';
-import type { GetControllerHandlers, RouteFn, RouteJSON, RouteMatcher, RouteMatchers, StoreRouteMiddleware } from '../types/route.js';
+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';
 /**
  * The route class exposes the APIs for constructing a route using the
  * fluent API.

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

@@ -0,0 +1,15 @@
+import type { Encryption } from '@adonisjs/encryption';
+import { type Router } from './main.ts';
+import { type MatchItRouteToken } from '../types/route.ts';
+import { type UrlFor, type LookupList, type SignedURLOptions } from '../types/url_builder.ts';
+/**
+ * Makes signed URL for a given route pattern. The route pattern could be an
+ * identifier or an array of tokens.
+ */
+export declare function createSignedURL(identifier: string, tokens: MatchItRouteToken[], searchParamsStringifier: (qs: Record<string, any>) => string, encryption: Encryption, params?: any[] | {
+    [param: string]: any;
+}, options?: SignedURLOptions): string;
+/**
+ * Creates the URLBuilder helper for making signed URLs
+ */
+export declare function createSignedUrlBuilder<Routes extends LookupList>(router: Router, encryption: Encryption, searchParamsStringifier: (qs: Record<string, any>) => string): UrlFor<Routes, SignedURLOptions>;

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

@@ -1,4 +1,4 @@
-import type { RouteJSON, MatchedRoute, StoreRoutesTree, MatchItRouteToken } from '../types/route.js';
+import type { RouteJSON, MatchedRoute, StoreRoutesTree, MatchItRouteToken } from '../types/route.ts';
 /**
  * Store class is used to store a list of routes, along side with their tokens
  * to match the URLs.
@@ -55,7 +55,7 @@ export declare class RoutesStore {
      * qualified runtime domain. You must call `matchDomain` first to fetch
      * the pattern for qualified domain
      */
-    match(url: string, method: string, domain?: {
+    match(url: string, method: string, shouldDecodeParam: boolean, domain?: {
         tokens: MatchItRouteToken[];
         hostname: string;
     }): null | MatchedRoute;

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

@@ -0,0 +1,14 @@
+import { type Router } from './main.ts';
+import { type MatchItRouteToken } from '../types/route.ts';
+import { type UrlFor, type LookupList, type URLOptions } from '../types/url_builder.ts';
+/**
+ * Makes URL for a given route pattern. The route pattern could be an
+ * identifier or an array of tokens.
+ */
+export declare function createURL(identifier: string, tokens: Pick<MatchItRouteToken, 'val' | 'type' | 'end'>[], searchParamsStringifier: (qs: Record<string, any>) => string, params?: any[] | {
+    [param: string]: any;
+}, options?: URLOptions): string;
+/**
+ * Creates the URLBuilder helper
+ */
+export declare function createUrlBuilder<Routes extends LookupList>(router: Router, searchParamsStringifier: (qs: Record<string, any>) => string): UrlFor<Routes>;