@adonisjs/http-server 8.0.0-next.0 → 8.0.0-next.10

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/brisk.d.ts

@@ -1,9 +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 { RouteBuilderArguments, URLOptions } from '../client/types.ts';
-import type { GetRoutesForMethod, RouteFn, RouteMatchers, RoutesList } 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, LookupList, 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.
@@ -19,23 +19,34 @@ export declare class BriskRoute extends Macroable {
      * Reference to route instance. Set after `setHandler` is called
      */
     route: null | Route;
+    /**
+     * Creates a new BriskRoute instance
+     * @param app - The AdonisJS application instance
+     * @param routerMiddleware - Array of global middleware registered on the router
+     * @param options - Configuration options for the brisk route
+     */
     constructor(app: Application<any>, routerMiddleware: ParsedGlobalMiddleware[], options: {
         pattern: string;
         globalMatchers: RouteMatchers;
     });
     /**
      * Set handler for the brisk route
+     * @param handler - The route handler function
+     * @returns The created route instance
      */
     setHandler(handler: RouteFn): Route;
     /**
      * Redirects to a given route. Params from the original request will
      * be used when no custom params are defined.
+     * @param args - Route identifier, parameters, and options for building the redirect URL
+     * @returns The created route instance
      */
-    redirect<Identifier extends keyof GetRoutesForMethod<'GET'> & string>(...args: RouteBuilderArguments<RoutesList, Identifier, 'GET', URLOptions & {
-        status: number;
-    }>): Route;
+    redirect<Identifier extends keyof GetRoutesForMethod<RoutesList, 'GET'> & string>(...args: RoutesList extends LookupList ? RouteBuilderArguments<Identifier, RoutesList['GET'][Identifier], URLOptions> : []): Route;
     /**
      * Redirect request to a fixed URL
+     * @param url - The URL to redirect to
+     * @param options - Optional redirect options including HTTP status code
+     * @returns The created route instance
      */
     redirectToPath(url: string, options?: {
         status: number;

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

@@ -1,9 +1,13 @@
 import type { ContainerResolver } from '@adonisjs/fold';
-import type { RouteJSON } 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
+ * @param route - The route JSON object containing route information
+ * @param resolver - Container resolver for dependency injection
+ * @param ctx - The HTTP context instance
+ * @param errorResponder - Error handler function for handling errors
  */
 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,11 +1,16 @@
-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
+ * @param value - The value to check
+ * @param ctx - The HTTP context instance
+ * @returns True if value can be used for response body
  */
 export declare function canWriteResponseBody(value: any, ctx: HttpContext): boolean;
 /**
  * A factory function that uses the return value of the request
  * pipeline as the response
+ * @param ctx - The HTTP context instance
+ * @returns Function that handles return values
  */
 export declare function useReturnValue(ctx: HttpContext): (value: any) => void;

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

@@ -1,10 +1,10 @@
 import Macroable from '@poppinss/macroable';
 import type { OneOrMore } from '@poppinss/utils/types';
-import { type Route } from './route.js';
-import { BriskRoute } from './brisk.js';
-import { RouteResource } from './resource.js';
-import type { RouteMatcher } from '../client/types.ts';
-import type { MiddlewareFn, ParsedNamedMiddleware } from '../types/middleware.js';
+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.
@@ -12,6 +12,10 @@ import type { MiddlewareFn, ParsedNamedMiddleware } from '../types/middleware.js
 export declare class RouteGroup extends Macroable {
     #private;
     routes: (Route | RouteGroup | RouteResource | BriskRoute)[];
+    /**
+     * Creates a new RouteGroup instance
+     * @param routes - Array of routes that belong to this group
+     */
     constructor(routes: (Route | RouteGroup | RouteResource | BriskRoute)[]);
     /**
      * Define route param matcher
@@ -20,6 +24,9 @@ export declare class RouteGroup extends Macroable {
      * Route.group(() => {
      * }).where('id', /^[0-9]+/)
      * ```
+     * @param param - The parameter name to match
+     * @param matcher - The matcher pattern (RegExp, string, or RouteMatcher)
+     * @returns Current RouteGroup instance for method chaining
      */
     where(param: string, matcher: RouteMatcher | string | RegExp): this;
     /**
@@ -29,6 +36,8 @@ export declare class RouteGroup extends Macroable {
      * Route.group(() => {
      * }).prefix('v1')
      * ```
+     * @param prefix - The prefix to add to all routes in the group
+     * @returns Current RouteGroup instance for method chaining
      */
     prefix(prefix: string): this;
     /**
@@ -38,6 +47,8 @@ export declare class RouteGroup extends Macroable {
      * Route.group(() => {
      * }).domain(':name.adonisjs.com')
      * ```
+     * @param domain - The domain pattern for all routes in the group
+     * @returns Current RouteGroup instance for method chaining
      */
     domain(domain: string): this;
     /**
@@ -47,6 +58,8 @@ export declare class RouteGroup extends Macroable {
      * Route.group(() => {
      * }).as('version1')
      * ```
+     * @param name - The name to prepend to all route names in the group
+     * @returns Current RouteGroup instance for method chaining
      */
     as(name: string): this;
     /**
@@ -56,10 +69,14 @@ export declare class RouteGroup extends Macroable {
      * Route.group(() => {
      * }).use(middleware.auth())
      * ```
+     * @param middleware - Middleware function(s) to apply to all routes in the group
+     * @returns Current RouteGroup instance for method chaining
      */
     use(middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this;
     /**
-     * @alias use
+     * Alias for {@link RouteGroup.use}
+     * @param middleware - Middleware function(s) to apply to all routes in the group
+     * @returns Current RouteGroup instance for method chaining
      */
     middleware(middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this;
 }

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

@@ -1,4 +1,4 @@
-import { type Router } from '../main.js';
+import { type Router } from '../main.ts';
 /**
  * URL builder class is used to create URIs for pre-registered
  * routes.
@@ -12,35 +12,35 @@ import { type Router } from '../main.js';
  *  .make('categories.posts.index')
  * ```
  *
- * @deprecated
- * Instead use "@adonisjs/core/services/url_builder" instead
+ * @deprecated Instead use "@adonisjs/core/services/url_builder" instead
  */
 export declare class UrlBuilder {
     #private;
+    /**
+     * Creates a new UrlBuilder instance
+     * @param router - The router instance
+     * @param domain - Optional domain for URL generation
+     */
     constructor(router: Router, domain?: string);
     /**
      * Prefix a custom base URL to the final URI
-     * @deprecated
-     * Instead use "@adonisjs/core/services/url_builder" instead
+     * @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
+     * @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
+     * @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
+     * @deprecated Instead use "@adonisjs/core/services/url_builder" instead
      */
     params(params?: any[] | Record<string, any>): this;
     /**
@@ -48,8 +48,9 @@ export declare class UrlBuilder {
      * route name, controller.method name or the route pattern
      * itself.
      *
-     * @deprecated
-     * Instead use "@adonisjs/core/services/url_builder" instead
+     * @deprecated Instead use "@adonisjs/core/services/url_builder" instead
+     * @param identifier - Route identifier to generate URL for
+     * @returns Generated URL string
      */
     make(identifier: string): string;
     /**
@@ -57,8 +58,7 @@ export declare class UrlBuilder {
      * route name, controller.method name or the route pattern
      * itself.
      *
-     * @deprecated
-     * Instead use "@adonisjs/core/services/url_builder" instead
+     * @deprecated Instead use "@adonisjs/core/services/url_builder" instead
      *
      */
     makeSigned(identifier: string, options?: {

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

@@ -1,17 +1,16 @@
 import type { Encryption } from '@adonisjs/encryption';
 import type { Application } from '@adonisjs/application';
 import type { Constructor, LazyImport } from '@poppinss/utils/types';
-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 { RouterClient } from '../client/router.ts';
-import { UrlBuilder } from './legacy/url_builder.js';
-import { RouteMatchers as Matchers } from './matchers.js';
-import type { MiddlewareAsClass, ParsedGlobalMiddleware } from '../types/middleware.js';
-import type { RouteFn, RouteJSON, RoutesList, MatchedRoute, RouteMatchers, MakeUrlOptions, MakeSignedUrlOptions, GetControllerHandlers } from '../types/route.js';
-import { type UrlFor, type LookupList, type SignedURLOptions, type RouteMatcher, type MatchItRouteToken } from '../client/types.ts';
+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, RouteMatcher, RouteMatchers, MakeUrlOptions, MakeSignedUrlOptions, GetControllerHandlers } 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.
@@ -24,7 +23,7 @@ import { type UrlFor, type LookupList, type SignedURLOptions, type RouteMatcher,
  * })
  * ```
  */
-export declare class Router extends RouterClient<RouteJSON> {
+export declare class Router {
     #private;
     /**
      * A flag to know if routes for explicit domains have been registered.
@@ -56,23 +55,45 @@ export declare class Router extends RouterClient<RouteJSON> {
         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[];
+    };
+    /**
+     * Creates a new Router instance
+     * @param app - The AdonisJS application instance
+     * @param encryption - Encryption service for signed URLs
+     * @param qsParser - Query string parser for URL generation
+     */
     constructor(app: Application<any>, encryption: Encryption, qsParser: Qs);
+    /**
+     * Register route JSON payload
+     */
+    protected register(route: RouteJSON): void;
     /**
      * Parses the route pattern
+     * @param pattern - The route pattern to parse
+     * @param matchers - Optional route matchers
      */
-    parsePattern(pattern: string, matchers?: RouteMatchers): 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
      * existing list of middleware
+     * @param middleware - Array of middleware classes to apply globally
+     * @returns Current Router instance for method chaining
      */
     use(middleware: LazyImport<MiddlewareAsClass>[]): this;
     /**
      * Define a collection of named middleware. The defined collection is
      * not registered anywhere, but instead converted in a new collection
      * of functions you can apply on the routes, or router groups.
+     * @param collection - Object mapping middleware names to middleware classes
+     * @returns Named middleware functions
      */
-    named<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>>>(collection: NamedMiddleware): { [K in keyof NamedMiddleware]: <Args extends import("../types/middleware.js").GetMiddlewareArgs<import("@poppinss/utils/types").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];
@@ -80,52 +101,87 @@ export declare class Router extends RouterClient<RouteJSON> {
     }; };
     /**
      * Add route for a given pattern and methods
+     * @param pattern - The route pattern
+     * @param methods - Array of HTTP methods
+     * @param handler - Route handler (function, string, or controller tuple)
+     * @returns The created route instance
      */
     route<T extends Constructor<any>>(pattern: string, methods: string[], handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
     /**
      * Define a route that handles all common HTTP methods
+     * @param pattern - The route pattern
+     * @param handler - Route handler (function, string, or controller tuple)
+     * @returns The created route instance
      */
     any<T extends Constructor<any>>(pattern: string, handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
     /**
      * Define `GET` route
+     * @param pattern - The route pattern
+     * @param handler - Route handler (function, string, or controller tuple)
+     * @returns The created route instance
      */
     get<T extends Constructor<any>>(pattern: string, handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
     /**
      * Define `POST` route
+     * @param pattern - The route pattern
+     * @param handler - Route handler (function, string, or controller tuple)
+     * @returns The created route instance
      */
     post<T extends Constructor<any>>(pattern: string, handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
     /**
      * Define `PUT` route
+     * @param pattern - The route pattern
+     * @param handler - Route handler (function, string, or controller tuple)
+     * @returns The created route instance
      */
     put<T extends Constructor<any>>(pattern: string, handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
     /**
      * Define `PATCH` route
+     * @param pattern - The route pattern
+     * @param handler - Route handler (function, string, or controller tuple)
+     * @returns The created route instance
      */
     patch<T extends Constructor<any>>(pattern: string, handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
     /**
      * Define `DELETE` route
+     * @param pattern - The route pattern
+     * @param handler - Route handler (function, string, or controller tuple)
+     * @returns The created route instance
      */
     delete<T extends Constructor<any>>(pattern: string, handler: string | RouteFn | [LazyImport<T> | T, GetControllerHandlers<T>?]): Route<T>;
     /**
      * Creates a group of routes. A route group can apply transforms
      * to routes in bulk
+     * @param callback - Function that defines routes within the group
+     * @returns The created route group instance
      */
     group(callback: () => void): RouteGroup;
     /**
      * Registers a route resource with conventional set of routes
+     * @param resource - The resource name
+     * @param controller - Controller to handle the resource
+     * @returns The created route resource instance
      */
-    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.
+     * @param resource - The resource name
+     * @param controller - Controller to handle the resource
+     * @returns The created route resource instance
      */
-    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
+     * @param pattern - The route pattern
+     * @returns The created brisk route instance
      */
     on(pattern: string): BriskRoute;
     /**
      * Define matcher for a given param. The global params are applied
      * on all the routes (unless overridden at the route level).
+     * @param param - The parameter name to match
+     * @param matcher - The matcher pattern (RegExp, string, or RouteMatcher)
+     * @returns Current Router instance for method chaining
      */
     where(param: string, matcher: RouteMatcher | string | RegExp): this;
     /**
@@ -133,22 +189,79 @@ export declare class Router extends RouterClient<RouteJSON> {
      * commit method is called.
      */
     commit(): void;
+    /**
+     * Finds a route by its identifier. The identifier can be the
+     * route name, controller.method name or the route pattern
+     * itself.
+     *
+     * When "disableLegacyLookup" is set, the lookup will be performed
+     * only using the route name
+     * @param routeIdentifier - Route name, pattern, or controller reference
+     * @param domain - Optional domain to search within
+     * @param method - Optional HTTP method to filter by
+     * @param disableLegacyLookup - Whether to disable legacy lookup strategies
+     * @returns Found route or null if not found
+     */
+    find(routeIdentifier: string, domain?: string, method?: string, disableLegacyLookup?: 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 "disableLegacyLookup" is set, the lookup will be performed
+     * only using the route name
+     * @param routeIdentifier - Route name, pattern, or controller reference
+     * @param domain - Optional domain to search within
+     * @param method - Optional HTTP method to filter by
+     * @param disableLegacyLookup - Whether to disable legacy lookup strategies
+     * @returns Found route
+     * @throws Error when route is not found
+     */
+    findOrFail(routeIdentifier: string, domain?: string, method?: string, disableLegacyLookup?: 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".
+     * @param routeIdentifier - Route name, pattern, or controller reference
+     * @param domain - Optional domain to search within
+     * @param method - Optional HTTP method to filter by
+     * @param followLookupStrategy - Whether to follow the configured lookup strategy
+     * @returns True if route exists, false otherwise
+     */
+    has(routeIdentifier: string, domain?: string, method?: string, followLookupStrategy?: boolean): boolean;
+    /**
+     * Returns a list of routes grouped by their domain names
+     * @returns Object mapping domain names to route arrays
+     */
+    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.
+     * @param indentation - Indentation level for generated types
+     * @returns Generated TypeScript types as string
      */
     generateTypes(indentation?: number): string;
-    generateClient(): string;
     /**
      * Find route for a given URL, method and optionally domain
+     * @param uri - The URI to match
+     * @param method - HTTP method
+     * @param shouldDecodeParam - Whether to decode parameters
+     * @param hostname - Optional hostname for domain matching
+     * @returns Matched route or null if no match found
      */
     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
+     * @deprecated Instead use "@adonisjs/core/services/url_builder" instead
      */
     builder(): UrlBuilder;
     /**

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

@@ -6,6 +6,7 @@ export declare class RouteMatchers extends Macroable {
     /**
      * Enforce value to be a number and also casts it to number data
      * type
+     * @returns Route matcher configuration for numeric values
      */
     number(): {
         match: RegExp;
@@ -13,6 +14,7 @@ export declare class RouteMatchers extends Macroable {
     };
     /**
      * Enforce value to be formatted as uuid
+     * @returns Route matcher configuration for UUID values
      */
     uuid(): {
         match: RegExp;
@@ -20,6 +22,7 @@ export declare class RouteMatchers extends Macroable {
     };
     /**
      * Enforce value to be formatted as slug
+     * @returns Route matcher configuration for slug values
      */
     slug(): {
         match: RegExp;

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

@@ -1,10 +1,9 @@
 import Macroable from '@poppinss/macroable';
 import type { Application } from '@adonisjs/application';
 import type { Constructor, LazyImport, OneOrMore } from '@poppinss/utils/types';
-import { Route } from './route.js';
-import { type RouteMatcher } from '../client/types.ts';
-import type { ResourceActionNames, RouteMatchers } from '../types/route.js';
-import type { MiddlewareFn, ParsedNamedMiddleware, ParsedGlobalMiddleware } from '../types/middleware.js';
+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.
  */
@@ -14,6 +13,12 @@ export declare class RouteResource<ActionNames extends ResourceActionNames = Res
      * A collection of routes instances that belongs to this resource
      */
     routes: Route[];
+    /**
+     * Creates a new RouteResource instance
+     * @param app - The AdonisJS application instance
+     * @param routerMiddleware - Array of global middleware registered on the router
+     * @param options - Configuration options for the route resource
+     */
     constructor(app: Application<any>, routerMiddleware: ParsedGlobalMiddleware[], options: {
         resource: string;
         controller: string | LazyImport<Constructor<any>> | Constructor<any>;
@@ -22,28 +27,46 @@ export declare class RouteResource<ActionNames extends ResourceActionNames = Res
     });
     /**
      * Register only given routes and remove others
+     * @param names - Array of action names to keep
+     * @returns Current RouteResource instance with filtered actions
      */
     only<Name extends ActionNames>(names: Name[]): RouteResource<Name>;
     /**
      * Register all routes, except the one's defined
+     * @param names - Array of action names to exclude
+     * @returns Current RouteResource instance with filtered actions
      */
     except<Name extends ActionNames>(names: Name[]): RouteResource<Exclude<ActionNames, Name>>;
     /**
      * Register api only routes. The `create` and `edit` routes, which
      * are meant to show forms will not be registered
+     * @returns Current RouteResource instance without create and edit actions
      */
     apiOnly(): RouteResource<Exclude<ActionNames, 'create' | 'edit'>>;
     /**
      * Define matcher for params inside the resource
+     * @param key - The parameter name to match
+     * @param matcher - The matcher pattern (RegExp, string, or RouteMatcher)
+     * @returns Current RouteResource instance for method chaining
      */
     where(key: string, matcher: RouteMatcher | string | RegExp): this;
     /**
      * Tap into multiple routes to configure them by their name
+     * @param callback - Function to configure routes
+     * @returns Current RouteResource instance for method chaining
      */
     tap(callback: (route: Route) => void): this;
+    /**
+     * Tap into multiple routes to configure them by their name
+     * @param actions - Action name(s) to configure
+     * @param callback - Function to configure matching routes
+     * @returns Current RouteResource instance for method chaining
+     */
     tap(actions: ActionNames | ActionNames[], callback: (route: Route) => void): this;
     /**
      * Set the param name for a given resource
+     * @param resources - Object mapping resource names to parameter names
+     * @returns Current RouteResource instance for method chaining
      */
     params(resources: {
         [resource: string]: string;
@@ -54,14 +77,23 @@ export declare class RouteResource<ActionNames extends ResourceActionNames = Res
      *
      * Calling this method multiple times will append middleware
      * to existing list.
+     * @param actions - Action name(s) or '*' for all actions
+     * @param middleware - Middleware function(s) to apply
+     * @returns Current RouteResource instance for method chaining
      */
     use(actions: ActionNames | ActionNames[] | '*', middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this;
     /**
-     * @alias use
+     * Alias for {@link RouteResource.use}
+     * @param actions - Action name(s) or '*' for all actions
+     * @param middleware - Middleware function(s) to apply
+     * @returns Current RouteResource instance for method chaining
      */
     middleware(actions: ActionNames | ActionNames[] | '*', middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this;
     /**
      * Prepend name to all the routes
+     * @param name - The name to prepend to all route names
+     * @param normalizeName - Whether to normalize the name to snake_case
+     * @returns Current RouteResource instance for method chaining
      */
     as(name: string, normalizeName?: boolean): this;
 }