@h3ravel/router 1.13.6 → 1.15.0-alpha.2

package/dist/index.d.ts

@@ -1,244 +1,2842 @@
 /// <reference path="./app.globals.d.ts" />
+import * as _h3ravel_contracts0 from "@h3ravel/contracts";
+import { ActionInput, CallableConstructor, ClassConstructor, ConcreteConstructor, GenericObject, IAbstractRouteCollection, IApplication, ICallableDispatcher, IContainer, IController, IControllerDispatcher, IDispatcher, IHttpContext, IMiddleware, IRequest, IResponse, IRoute, IRouteCollection, IRouteUrlGenerator, IRouter, IUrlGenerator, MiddlewareIdentifier, MiddlewareList, ResourceMethod, ResourceOptions, ResponsableType, RouteActions, RouteMethod, RouteParams, UrlRoutable } from "@h3ravel/contracts";
+import { Middleware, Request, Response } from "@h3ravel/http";
+import { H3, Middleware as Middleware$1, MiddlewareOptions } from "h3";
+import * as _h3ravel_support9 from "@h3ravel/support";
+import { Collection, ServiceProvider } from "@h3ravel/support";
+import * as _h3ravel_shared0 from "@h3ravel/shared";
+import { Magic } from "@h3ravel/shared";
 import { Command } from "@h3ravel/musket";
-import { EventHandler, ExtractControllerMethods, HttpContext, IMiddleware, IRouter, RouteEventHandler, RouterEnd } from "@h3ravel/shared";
 import { Model } from "@h3ravel/database";
-import { Application, ServiceProvider } from "@h3ravel/core";
-import { H3, Middleware, MiddlewareOptions } from "h3";
+import { FRoute } from "@h3ravel/support/facades";
 
+//#region src/RouteParameter.d.ts
+declare class RouteParameter {
+  private name;
+  private type;
+  constructor(name: string, type: any);
+  /**
+   * Ge the route parameter name
+   */
+  getName(): string;
+  /**
+   * Ge the route parameter type
+   */
+  getType(): any;
+}
+//#endregion
+//#region src/Contracts/Utilities.d.ts
+type Pipe = string | (abstract new (...args: any[]) => any) | ((...args: any[]) => any) | IMiddleware;
+type CompiledRouteToken = ['variable', string, string, string, boolean] | ['text', string];
+interface RouteActionConditions {
+  [key: string]: any;
+  subClass: ConcreteConstructor<UrlRoutable>;
+}
+//#endregion
+//#region src/CompiledRoute.d.ts
+declare class CompiledRoute {
+  private path;
+  private tokens;
+  private variables;
+  private paramNames;
+  private optionalParams;
+  private regex;
+  private hostPattern?;
+  private hostRegex?;
+  constructor(path: string, optionalParams: Record<string, null>, hostPattern?: string);
+  /**
+   * Get the compiled path regex
+   */
+  getRegex(): RegExp;
+  /**
+   * Get the compiled host regex (if any)
+   */
+  getHostRegex(): RegExp | undefined;
+  /**
+   * Returns list of all param names (including optional)
+   */
+  getParamNames(): string[];
+  /**
+   * Returns list of all path variables
+   */
+  getVariables(): string[];
+  /**
+   * Returns list of all compiled tokens
+   */
+  getTokens(): CompiledRouteToken;
+  /**
+   * Returns optional params record
+   */
+  getOptionalParams(): Record<string, null>;
+  /**
+   * Build the route params
+   *
+   * @returns
+   */
+  private buildParams;
+  /**
+   * Build a regex from a path pattern
+   *
+   * @param path
+   * @param paramNames
+   * @param optionalParams
+   * @returns
+   */
+  private buildRegex;
+  /**
+   * Tokenize the the path
+   *
+   * @param optionalParams
+   * @returns
+   */
+  private tokenizePath;
+}
+//#endregion
+//#region src/Traits/FiltersControllerMiddleware.d.ts
+declare class FiltersControllerMiddleware {
+  /**
+   * Determine if the given options exclude a particular method.
+   *
+   * @param  method
+   * @param  options
+   */
+  static methodExcludedByOptions(method: RouteMethod, options: IMiddleware['options']): boolean;
+}
+//#endregion
+//#region src/Traits/RouteDependencyResolver.d.ts
+declare class RouteDependencyResolver {
+  protected container: IApplication;
+  constructor(container: IApplication);
+  /**
+   * Resolve the object method's type-hinted dependencies.
+   *
+   * @param  parameters
+   * @param  instance
+   * @param  method
+   */
+  resolveClassMethodDependencies(parameters: Record<string, any>, instance: IController, method: ResourceMethod): Promise<Record<string, any>>;
+  /**
+   * Resolve the given method's type-hinted dependencies.
+   *
+   * @param  parameters
+   */
+  resolveMethodDependencies(parameters: Record<string, any>): Record<string, any>;
+}
+//#endregion
+//#region src/ControllerDispatcher.d.ts
+declare const ControllerDispatcher_base: typeof RouteDependencyResolver & typeof IControllerDispatcher & typeof FiltersControllerMiddleware & (new (...args: any[]) => RouteDependencyResolver & IControllerDispatcher & FiltersControllerMiddleware);
+declare class ControllerDispatcher extends ControllerDispatcher_base {
+  protected container: IApplication;
+  /**
+   *
+   * @param container The container instance.
+   */
+  constructor(container: IApplication);
+  /**
+   * Dispatch a request to a given controller and method.
+   *
+   * @param  route
+   * @param  controller
+   * @param  method
+   */
+  dispatch(route: Route, controller: Required<IController>, method: ResourceMethod): Promise<any>;
+  /**
+   * Resolve the parameters for the controller.
+   *
+   * @param  route
+   * @param  controller
+   * @param  method
+   */
+  protected resolveParameters(route: Route, controller: IController, method: ResourceMethod): Promise<Record<string, any>>;
+  /**
+   * Get the middleware for the controller instance.
+   *
+   * @param  controller
+   * @param  method
+   */
+  getMiddleware(controller: IController, method: RouteMethod): never[];
+}
+//#endregion
+//#region src/Contracts/IRouteValidator.d.ts
+declare abstract class IRouteValidator {
+  abstract matches(route: IRoute, request: IRequest): boolean | undefined;
+}
+//#endregion
+//#region src/Matchers/HostValidator.d.ts
+declare class HostValidator extends IRouteValidator {
+  /**
+   * Validate a given rule against a route and request.
+   *
+   * @param  route
+   * @param  request
+   */
+  matches(route: Route, request: Request): boolean;
+}
+//#endregion
+//#region src/Matchers/MethodValidator.d.ts
+declare class MethodValidator extends IRouteValidator {
+  /**
+   * Validate a given rule against a route and request.
+   *
+   * @param  route
+   * @param  request
+   */
+  matches(route: Route, request: Request): boolean;
+}
+//#endregion
+//#region src/RouteCollection.d.ts
+declare class RouteCollection extends AbstractRouteCollection implements IRouteCollection {
+  /**
+   * An array of the routes keyed by method.
+   */
+  protected routes: Record<string, Record<string, Route>>;
+  /**
+   * A flattened array of all of the routes.
+   */
+  protected allRoutes: Record<string, Route>;
+  /**
+   * A look-up table of routes by their names.
+   */
+  protected nameList: Record<string, Route>;
+  /**
+   * A look-up table of routes by controller action.
+   */
+  protected actionList: Record<string, Route>;
+  /**
+   * Add a Route instance to the collection.
+   */
+  add(route: Route): Route;
+  /**
+   * Add the given route to the arrays of routes.
+   */
+  protected addToCollections(route: Route): void;
+  /**
+   * Add the route to any look-up tables if necessary.
+   */
+  protected addLookups(route: Route): void;
+  /**
+   * Add a route to the controller action dictionary.
+   */
+  protected addToActionList(action: RouteActions, route: Route): void;
+  /**
+   * Determine if the given controller is in the action lookup table.
+   */
+  protected inActionLookup(controller: string): boolean;
+  /**
+   * Determine if the given name is in the name lookup table.
+   */
+  protected inNameLookup(name: string): boolean;
+  /**
+   * Refresh the name look-up table.
+   *
+   * This is done in case any names are fluently defined or if routes are overwritten.
+   */
+  refreshNameLookups(): void;
+  /**
+   * Refresh the action look-up table.
+   *
+   * This is done in case any actions are overwritten with new controllers.
+   */
+  refreshActionLookups(): void;
+  /**
+   * Find the first route matching a given request.
+   *
+   * May throw framework-specific exceptions (MethodNotAllowed / NotFound).
+   */
+  match(request: Request): Route;
+  /**
+   * Get routes from the collection by method.
+   */
+  get(): Route[];
+  get(method: string): Record<string, Route>;
+  /**
+   * Determine if the route collection contains a given named route.
+   */
+  hasNamedRoute(name: string): boolean;
+  /**
+   * Get a route instance by its name.
+   */
+  getByName(name: string): Route | undefined;
+  /**
+   * Get a route instance by its controller action.
+   */
+  getByAction(action: string): Route | undefined;
+  /**
+   * Get all of the routes in the collection.
+   */
+  getRoutes(): Route[];
+  /**
+   * Get all of the routes keyed by their HTTP verb / method.
+   */
+  getRoutesByMethod(): Record<string, Record<string, Route>>;
+  /**
+   * Get all of the routes keyed by their name.
+   */
+  getRoutesByName(): Record<string, Route>;
+}
+//#endregion
+//#region src/ResourceRegistrar.d.ts
+declare class ResourceRegistrar {
+  /**
+   * The router instance.
+   */
+  protected router: Router;
+  /**
+   * The default actions for a resourceful controller.
+   */
+  protected resourceDefaults: ResourceMethod[];
+  /**
+   * The default actions for a singleton resource controller.
+   */
+  protected singletonResourceDefaults: ResourceMethod[];
+  /**
+   * The parameters set for this resource instance.
+   */
+  protected parameters?: string | GenericObject<string>;
+  /**
+   * The global parameter mapping.
+   */
+  protected static parameterMap: GenericObject;
+  /**
+   * Singular global parameters.
+   */
+  protected static _singularParameters: boolean;
+  /**
+   * The verbs used in the resource URIs.
+   */
+  protected static _verbs: {
+    create: string;
+    edit: string;
+  };
+  /**
+   * Create a new resource registrar instance.
+   *
+   * @param  router
+   */
+  constructor(router: Router);
+  /**
+   * Route a resource to a controller.
+   *
+   * @param  name
+   * @param  controller
+   * @param  options
+   */
+  register<C extends typeof IController>(name: string, controller: C, options?: ResourceOptions): RouteCollection | undefined;
+  /**
+   * Route a singleton resource to a controller.
+   *
+   * @param  name
+   * @param  controller
+   * @param  options
+   */
+  singleton<C extends typeof IController>(name: string, controller: C, options?: ResourceOptions): RouteCollection | undefined;
+  /**
+   * Build a set of prefixed resource routes.
+   *
+   * @param  name
+   * @param  controller
+   * @param  options
+   */
+  protected prefixedResource<C extends typeof IController>(name: string, controller: C, options: ResourceOptions): Router;
+  /**
+   * Build a set of prefixed singleton routes.
+   *
+   * @param  name
+   * @param  controller
+   * @param  options
+   */
+  protected prefixedSingleton<C extends typeof IController>(name: string, controller: C, options: ResourceOptions): Router;
+  /**
+   * Extract the resource and prefix from a resource name.
+   *
+   * @param  name
+   *
+   */
+  protected getResourcePrefix(name: string): string[];
+  /**
+   * Get the applicable resource methods.
+   *
+   * @param  defaults
+   * @param  options
+   *
+   */
+  protected getResourceMethods(defaults: ResourceMethod[], options: ResourceOptions): ResourceMethod[];
+  /**
+   * Add the index method for a resourceful route.
+   *
+   * @param  name
+   * @param  base
+   * @param  controller
+   * @param  options
+   */
+  protected addResourceIndex<C extends typeof IController>(name: string, _base: string, controller: C, options: ResourceOptions): Route;
+  /**
+   * Add the create method for a resourceful route.
+   *
+   * @param  name
+   * @param  base
+   * @param  controller
+   * @param  options
+   */
+  protected addResourceCreate<C extends typeof IController>(name: string, base: string, controller: C, options: ResourceOptions): Route;
+  /**
+   * Add the store method for a resourceful route.
+   *
+   * @param  name
+   * @param  base
+   * @param  controller
+   * @param  options
+   */
+  protected addResourceStore<C extends typeof IController>(name: string, base: string, controller: C, options: ResourceOptions): Route;
+  /**
+   * Add the show method for a resourceful route.
+   *
+   * @param  name
+   * @param  base
+   * @param  controller
+   * @param  options
+   */
+  protected addResourceShow<C extends typeof IController>(name: string, base: string, controller: C, options: ResourceOptions): Route;
+  /**
+   * Add the edit method for a resourceful route.
+   *
+   * @param  name
+   * @param  base
+   * @param  controller
+   * @param  options
+   */
+  protected addResourceEdit<C extends typeof IController>(name: string, base: string, controller: C, options: ResourceOptions): Route;
+  /**
+   * Add the update method for a resourceful route.
+   *
+   * @param  name
+   * @param  base
+   * @param  controller
+   * @param  options
+   */
+  protected addResourceUpdate<C extends typeof IController>(name: string, base: string, controller: C, options: ResourceOptions): Route;
+  /**
+   * Add the destroy method for a resourceful route.
+   *
+   * @param  name
+   * @param  base
+   * @param  controller
+   * @param  options
+   */
+  protected addResourceDestroy<C extends typeof IController>(name: string, base: string, controller: C, options: ResourceOptions): Route;
+  /**
+   * Add the create method for a singleton route.
+   *
+   * @param  name
+   * @param  controller
+   * @param  options
+   */
+  protected addSingletonCreate<C extends typeof IController>(name: string, controller: C, options: ResourceOptions): Route;
+  /**
+   * Add the store method for a singleton route.
+   *
+   * @param  name
+   * @param  controller
+   * @param  options
+   */
+  protected addSingletonStore<C extends typeof IController>(name: string, controller: C, options: ResourceOptions): Route;
+  /**
+   * Add the show method for a singleton route.
+   *
+   * @param  name
+   * @param  controller
+   * @param  options
+   */
+  protected addSingletonShow<C extends typeof IController>(name: string, controller: C, options: ResourceOptions): Route;
+  /**
+   * Add the edit method for a singleton route.
+   *
+   * @param  name
+   * @param  controller
+   * @param  options
+   */
+  protected addSingletonEdit<C extends typeof IController>(name: string, controller: C, options: ResourceOptions): Route;
+  /**
+   * Add the update method for a singleton route.
+   *
+   * @param  name
+   * @param  controller
+   * @param  options
+   */
+  protected addSingletonUpdate<C extends typeof IController>(name: string, controller: C, options: ResourceOptions): Route;
+  /**
+   * Add the destroy method for a singleton route.
+   *
+   * @param  name
+   * @param  controller
+   * @param  options
+   */
+  protected addSingletonDestroy<C extends typeof IController>(name: string, controller: C, options: ResourceOptions): Route;
+  /**
+   * Get the name for a given resource with shallowness applied when applicable.
+   *
+   * @param  name
+   * @param  options
+   *
+   */
+  protected getShallowName(name: string, options: ResourceOptions): string;
+  /**
+   * Set the route's binding fields if the resource is scoped.
+   *
+   * @param  \Illuminate\Routing\Route  route
+   * @param  bindingFields
+   *
+   */
+  protected setResourceBindingFields(route: Route, bindingFields: Record<string, any>): void;
+  /**
+   * Get the base resource URI for a given resource.
+   *
+   * @param  resource
+   *
+   */
+  getResourceUri(resource: string): string;
+  /**
+   * Get the URI for a nested resource segment array.
+   *
+   * @param  segments
+   */
+  protected getNestedResourceUri(segments: string[]): string;
+  /**
+   * Format a resource parameter for usage.
+   *
+   * @param  value
+   */
+  getResourceWildcard(value: string): string;
+  /**
+   * Get the action array for a resource route.
+   *
+   * @param  resource
+   * @param  controller
+   * @param  method
+   * @param  options
+   *
+   */
+  protected getResourceAction<C extends typeof IController>(resource: string, controller: C, method: string, options: ResourceOptions): RouteActions;
+  /**
+   * Get the name for a given resource.
+   *
+   * @param  resource
+   * @param  method
+   * @param  options
+   *
+   */
+  protected getResourceRouteName(resource: string, method: string, options: ResourceOptions): string;
+  /**
+   * Set or unset the unmapped global parameters to singular.
+   *
+   * @param  singular
+   */
+  static singularParameters(singular?: boolean): void;
+  /**
+   * Get the global parameter map.
+   */
+  static getParameters(): GenericObject;
+  /**
+   * Set the global parameter mapping.
+   *
+   * @param  $parameters
+   *
+   */
+  static setParameters(parameters?: never[]): void;
+  /**
+   * Get or set the action verbs used in the resource URIs.
+   *
+   * @param  verbs
+   *
+   */
+  static verbs(verbs?: GenericObject): {
+    create: string;
+    edit: string;
+  } | undefined;
+}
+//#endregion
+//#region src/PendingSingletonResourceRegistration.d.ts
+declare const PendingSingletonResourceRegistration_base: (new () => {
+  [x: string]: any;
+} & {
+  [x: string]: any;
+  where(_wheres: any): /*elided*/any;
+  whereAlpha(parameters: string | string[]): /*elided*/any;
+  whereAlphaNumeric(parameters: string | string[]): /*elided*/any;
+  whereNumber(parameters: string | string[]): /*elided*/any;
+  whereUlid(parameters: string | string[]): /*elided*/any;
+  whereUuid(parameters: string | string[]): /*elided*/any;
+  whereIn(parameters: string | string[], values: any[]): /*elided*/any;
+  assignExpressionToParameters(parameters: string | string[], expression: string): /*elided*/any;
+} & {
+  [x: string]: any;
+  macroCall(method: string, parameters?: any[]): any;
+}) & {
+  [x: string]: any;
+  prototype: {
+    [x: string]: any;
+  };
+} & {
+  [x: string]: any;
+  prototype: {
+    [x: string]: any;
+    where(_wheres: any): /*elided*/any;
+    whereAlpha(parameters: string | string[]): /*elided*/any;
+    whereAlphaNumeric(parameters: string | string[]): /*elided*/any;
+    whereNumber(parameters: string | string[]): /*elided*/any;
+    whereUlid(parameters: string | string[]): /*elided*/any;
+    whereUuid(parameters: string | string[]): /*elided*/any;
+    whereIn(parameters: string | string[], values: any[]): /*elided*/any;
+    assignExpressionToParameters(parameters: string | string[], expression: string): /*elided*/any;
+  };
+} & {
+  [x: string]: any;
+  prototype: {
+    [x: string]: any;
+    macroCall(method: string, parameters?: any[]): any;
+  };
+  macros: Record<string, _h3ravel_support9.Macro>;
+  macro: (name: string, macro: _h3ravel_support9.Macro) => void;
+  hasMacro: (name: string) => boolean;
+  flushMacros: () => void;
+  mixin: (mixin: object, replace?: boolean) => void;
+  createProxy: <T extends {
+    new (...args: any[]): {
+      [x: string]: any;
+      macroCall(method: string, parameters?: any[]): any;
+    };
+    [x: string]: any;
+    macros: Record<string, _h3ravel_support9.Macro>;
+    macro(name: string, macro: _h3ravel_support9.Macro): void;
+    hasMacro(name: string): boolean;
+    flushMacros(): void;
+    mixin(mixin: object, replace?: boolean): void;
+    createProxy<T extends /*elided*/any>(this: T): T;
+    macroCallStatic(method: string, parameters?: any[]): any;
+  }>(this: T) => T;
+  macroCallStatic: (method: string, parameters?: any[]) => any;
+};
+declare class PendingSingletonResourceRegistration extends PendingSingletonResourceRegistration_base {
+  /**
+   * The resource registrar.
+   */
+  protected registrar: ResourceRegistrar;
+  /**
+   * The resource name.
+   */
+  protected name: string;
+  /**
+   * The resource controller.
+   */
+  protected controller: typeof IController;
+  /**
+   * The resource options.
+   */
+  protected options: ResourceOptions;
+  /**
+   * The resource's registration status.
+   */
+  protected registered: boolean;
+  /**
+   * Create a new pending singleton resource registration instance.
+   *
+   * @param  registrar
+   * @param  name
+   * @param  controller
+   * @param  options
+   */
+  constructor(registrar: ResourceRegistrar, name: string, controller: typeof IController, options: ResourceOptions);
+  /**
+   * Set the methods the controller should apply to.
+   *
+   * @param  methods
+   */
+  only(...methods: ResourceMethod[]): this;
+  /**
+   * Set the methods the controller should exclude.
+   *
+   * @param  methods
+   */
+  except(...methods: ResourceMethod[]): this;
+  /**
+   * Indicate that the resource should have creation and storage routes.
+   *
+   * @return  this
+   */
+  creatable(): this;
+  /**
+   * Indicate that the resource should have a deletion route.
+   *
+   * @return  this
+   */
+  destroyable(): this;
+  /**
+   * Set the route names for controller actions.
+   *
+   * @param  names
+   */
+  names(names: Record<string, string>): this;
+  /**
+   * Set the route name for a controller action.
+   *
+   * @param  method
+   * @param  name
+   */
+  setName(method: string, name: string): this;
+  /**
+   * Override the route parameter names.
+   *
+   * @param  parameters
+   */
+  parameters(parameters: any): this;
+  /**
+   * Override a route parameter's name.
+   *
+   * @param  previous
+   * @param  newValue
+   */
+  parameter(previous: string, newValue: any): this;
+  /**
+   * Add middleware to the resource routes.
+   *
+   * @param  middleware
+   */
+  middleware(middleware: MiddlewareList | MiddlewareIdentifier): this;
+  /**
+   * Specify middleware that should be added to the specified resource routes.
+   *
+   * @param  methods
+   * @param  middleware
+   */
+  middlewareFor(methods: ResourceMethod[], middleware: MiddlewareList | MiddlewareIdentifier): this;
+  /**
+   * Specify middleware that should be removed from the resource routes.
+   *
+   * @param  middleware
+   */
+  withoutMiddleware(middleware: MiddlewareList | MiddlewareIdentifier): this;
+  /**
+   * Specify middleware that should be removed from the specified resource routes.
+   *
+   * @param  methods
+   * @param  middleware
+   */
+  withoutMiddlewareFor(methods: ResourceMethod[], middleware: MiddlewareList | MiddlewareIdentifier): this;
+  /**
+   * Add "where" constraints to the resource routes.
+   *
+   * @param  wheres
+   */
+  where(wheres: any): this;
+  /**
+   * Register the singleton resource route.
+   */
+  register(): RouteCollection | undefined;
+  $finalize(e?: this): this;
+}
+//#endregion
+//#region src/PendingResourceRegistration.d.ts
+declare const PendingResourceRegistration_base: (new (...args: any[]) => {
+  [x: string]: any;
+  where(_wheres: any): /*elided*/any;
+  whereAlpha(parameters: string | string[]): /*elided*/any;
+  whereAlphaNumeric(parameters: string | string[]): /*elided*/any;
+  whereNumber(parameters: string | string[]): /*elided*/any;
+  whereUlid(parameters: string | string[]): /*elided*/any;
+  whereUuid(parameters: string | string[]): /*elided*/any;
+  whereIn(parameters: string | string[], values: any[]): /*elided*/any;
+  assignExpressionToParameters(parameters: string | string[], expression: string): /*elided*/any;
+} & {
+  [x: string]: any;
+  macroCall(method: string, parameters?: any[]): any;
+}) & {
+  [x: string]: any;
+  prototype: {
+    [x: string]: any;
+    where(_wheres: any): /*elided*/any;
+    whereAlpha(parameters: string | string[]): /*elided*/any;
+    whereAlphaNumeric(parameters: string | string[]): /*elided*/any;
+    whereNumber(parameters: string | string[]): /*elided*/any;
+    whereUlid(parameters: string | string[]): /*elided*/any;
+    whereUuid(parameters: string | string[]): /*elided*/any;
+    whereIn(parameters: string | string[], values: any[]): /*elided*/any;
+    assignExpressionToParameters(parameters: string | string[], expression: string): /*elided*/any;
+  };
+} & {
+  [x: string]: any;
+  prototype: {
+    [x: string]: any;
+    macroCall(method: string, parameters?: any[]): any;
+  };
+  macros: Record<string, _h3ravel_support9.Macro>;
+  macro: (name: string, macro: _h3ravel_support9.Macro) => void;
+  hasMacro: (name: string) => boolean;
+  flushMacros: () => void;
+  mixin: (mixin: object, replace?: boolean) => void;
+  createProxy: <T extends {
+    new (...args: any[]): {
+      [x: string]: any;
+      macroCall(method: string, parameters?: any[]): any;
+    };
+    [x: string]: any;
+    macros: Record<string, _h3ravel_support9.Macro>;
+    macro(name: string, macro: _h3ravel_support9.Macro): void;
+    hasMacro(name: string): boolean;
+    flushMacros(): void;
+    mixin(mixin: object, replace?: boolean): void;
+    createProxy<T extends /*elided*/any>(this: T): T;
+    macroCallStatic(method: string, parameters?: any[]): any;
+  }>(this: T) => T;
+  macroCallStatic: (method: string, parameters?: any[]) => any;
+};
+declare class PendingResourceRegistration extends PendingResourceRegistration_base {
+  /**
+   * The resource registrar.
+   */
+  protected registrar: ResourceRegistrar;
+  /**
+   * The resource name.
+   */
+  protected name: string;
+  /**
+   * The resource controller.
+   */
+  protected controller: typeof IController;
+  /**
+   * The resource options.
+   */
+  protected options: ResourceOptions;
+  /**
+   * The resource's registration status.
+   */
+  protected registered: boolean;
+  /**
+   * Create a new pending resource registration instance.
+   *
+   * @param  registrar
+   * @param  name
+   * @param  controller
+   * @param  options
+   */
+  constructor(registrar: ResourceRegistrar, name: string, controller: typeof IController, options: ResourceOptions);
+  /**
+   * Set the methods the controller should apply to.
+   *
+   * @param  methods
+   */
+  only(...methods: ResourceMethod[]): this;
+  /**
+   * Set the methods the controller should exclude.
+   *
+   * @param  methods
+   */
+  except(...methods: ResourceMethod[]): this;
+  /**
+   * Set the route names for controller actions.
+   *
+   * @param  names
+   */
+  names(names: Record<string, string>): this;
+  /**
+   * Set the route name for a controller action.
+   *
+   * @param  method
+   * @param  name
+   */
+  setName(method: string, name: string): this;
+  /**
+   * Override the route parameter names.
+   *
+   * @param  parameters
+   */
+  parameters(parameters: any): this;
+  /**
+   * Override a route parameter's name.
+   *
+   * @param  previous
+   * @param  newValue
+   */
+  parameter(previous: string, newValue: any): this;
+  /**
+   * Add middleware to the resource routes.
+   *
+   * @param  middleware
+   */
+  middleware(middleware: MiddlewareList | MiddlewareIdentifier): this;
+  /**
+   * Specify middleware that should be added to the specified resource routes.
+   *
+   * @param  methods
+   * @param  middleware
+   */
+  middlewareFor(methods: ResourceMethod[], middleware: MiddlewareList | MiddlewareIdentifier): this;
+  /**
+   * Specify middleware that should be removed from the resource routes.
+   *
+   * @param  middleware
+   */
+  withoutMiddleware(middleware: MiddlewareList | MiddlewareIdentifier): this;
+  /**
+   * Specify middleware that should be removed from the specified resource routes.
+   *
+   * @param  methods
+   * @param  middleware
+   */
+  withoutMiddlewareFor(methods: ResourceMethod[], middleware: MiddlewareList | MiddlewareIdentifier): this;
+  /**
+   * Add "where" constraints to the resource routes.
+   *
+   * @param  wheres
+   */
+  where(wheres: any): this;
+  /**
+   * Indicate that the resource routes should have "shallow" nesting.
+   *
+   * @param shallow
+   */
+  shallow(shallow?: boolean): this;
+  /**
+   * Define the callable that should be invoked on a missing model exception.
+   *
+   * @param  callback
+   */
+  missing(callback: string): this;
+  /**
+   * Indicate that the resource routes should be scoped using the given binding fields.
+   *
+   * @param  fields
+   */
+  scoped(fields?: string[]): this;
+  /**
+   * Define which routes should allow "trashed" models to be retrieved when resolving implicit model bindings.
+   *
+   * @param  array  methods
+   */
+  withTrashed(methods?: never[]): this;
+  /**
+   * Register the singleton resource route.
+   */
+  register(): RouteCollection | undefined;
+  $finalize(e?: this): this;
+}
+//#endregion
+//#region src/Router.d.ts
+declare const Router_base: typeof IRouter & {
+  new (...args: any[]): {
+    [x: string]: any;
+    macroCall(method: string, parameters?: any[]): any;
+  };
+  [x: string]: any;
+  macros: Record<string, _h3ravel_support9.Macro>;
+  macro(name: string, macro: _h3ravel_support9.Macro): void;
+  hasMacro(name: string): boolean;
+  flushMacros(): void;
+  mixin(mixin: object, replace?: boolean): void;
+  createProxy<T extends /*elided*/any>(this: T): T;
+  macroCallStatic(method: string, parameters?: any[]): any;
+} & typeof Magic & (new (...args: any[]) => IRouter & Magic & {
+  [x: string]: any;
+  macroCall(method: string, parameters?: any[]): any;
+});
+declare class Router extends Router_base {
+  protected h3App: H3;
+  private app;
+  private DIST_DIR;
+  private routes;
+  private routeNames;
+  private current?;
+  private currentRequest;
+  private middlewareMap;
+  private groupMiddleware;
+  /**
+   * The registered route value binders.
+   */
+  protected binders: Record<string, any>;
+  /**
+   * All of the short-hand keys for middlewares.
+   */
+  private middlewares;
+  /**
+   * All of the middleware groups.
+   */
+  protected middlewareGroups: GenericObject<MiddlewareList>;
+  /**
+   * The route group attribute stack.
+   */
+  protected groupStack: GenericObject<any>[];
+  /**
+   * The event dispatcher instance.
+   */
+  protected events?: IDispatcher;
+  /**
+   * The priority-sorted list of middleware.
+   *
+   * Forces the listed middleware to always be in the given order.
+   */
+  middlewarePriority: MiddlewareList;
+  /**
+   * The registered custom implicit binding callback.
+   */
+  protected implicitBindingCallback?: (container: IApplication, route: Route, defaultFn: CallableConstructor) => any;
+  /**
+   * All of the verbs supported by the router.
+   */
+  static verbs: RouteMethod[];
+  constructor(h3App: H3, app: IApplication);
+  /**
+   * Add a route to the underlying route collection.
+   *
+   * @param method
+   * @param uri
+   * @param action
+   */
+  addRoute(methods: RouteMethod | RouteMethod[], uri: string, action: ActionInput): Route;
+  /**
+   * Get the currently dispatched route instance.
+   */
+  getCurrentRoute(): Route | undefined;
+  /**
+   * Check if a route with the given name exists.
+   *
+   * @param name
+   */
+  has(...name: string[]): boolean;
+  /**
+   * Get the current route name.
+   */
+  currentRouteName(): string | undefined;
+  /**
+   * Alias for the "currentRouteNamed" method.
+   *
+   * @param  patterns
+   */
+  is(...patterns: string[]): boolean;
+  /**
+   * Determine if the current route matches a pattern.
+   *
+   * @param patterns
+   */
+  currentRouteNamed(...patterns: string[]): boolean;
+  /**
+   * Get the underlying route collection.
+   */
+  getRoutes(): RouteCollection;
+  /**
+   * Determine if the action is routing to a controller.
+   *
+   * @param action
+   */
+  protected actionReferencesController(action: ActionInput): any;
+  /**
+   * Create a new route instance.
+   *
+   * @param  methods
+   * @param  uri
+   * @param  action
+   */
+  protected createRoute(methods: RouteMethod | RouteMethod[], uri: string, action: ActionInput): Route;
+  /**
+   * Create a new Route object.
+   *
+   * @param  methods
+   * @param  uri
+   * @param  action
+   */
+  newRoute(methods: RouteMethod | RouteMethod[], uri: string, action: ActionInput): Route;
+  /**
+   * Dispatch the request to the application.
+   *
+   * @param request
+   */
+  dispatch(request: Request): Promise<IResponse>;
+  /**
+   * Dispatch the request to a route and return the response.
+   *
+   * @param request
+   */
+  dispatchToRoute(request: Request): Promise<IResponse>;
+  /**
+   * Find the route matching a given request.
+   *
+   * @param request
+   */
+  protected findRoute(request: Request): Route;
+  /**
+   * Return the response for the given route.
+   *
+   * @param  request
+   * @param  route
+   */
+  protected runRoute(request: Request, route: Route): Promise<IResponse>;
+  /**
+   * Run the given route within a Stack (onion) instance.
+   *
+   * @param  route
+   * @param  request
+   */
+  protected runRouteWithinStack(route: Route, request: Request): Promise<IResponse>;
+  /**
+   * Get all of the defined middleware short-hand names.
+   */
+  getMiddleware(): GenericObject;
+  /**
+   * Register a short-hand name for a middleware.
+   *
+   * @param  name
+   * @param  class
+   */
+  aliasMiddleware(name: string, cls: IMiddleware): this;
+  /**
+   * Gather the middleware for the given route with resolved class names.
+   *
+   * @param  route
+   */
+  gatherRouteMiddleware(route: Route): MiddlewareList;
+  /**
+   * Resolve a flat array of middleware classes from the provided array.
+   *
+   * @param middleware
+   * @param excluded
+   */
+  resolveMiddleware(middleware: MiddlewareList, excluded?: MiddlewareList): any;
+  /**
+   * Sort the given middleware by priority.
+   *
+   * @param  middlewares
+   */
+  protected sortMiddleware(middlewares: Collection): any;
+  /**
+   * Register a group of middleware.
+   *
+   * @param  name
+   * @param  middleware
+   */
+  middlewareGroup(name: string, middleware: MiddlewareList): this;
+  /**
+   * Create a response instance from the given value.
+   *
+   * @param  request
+   * @param  response
+   */
+  prepareResponse(request: IRequest, response: ResponsableType): Promise<IResponse>;
+  /**
+   * Static version of prepareResponse.
+   *
+   * @param  request
+   * @param  response
+   */
+  static toResponse(request: IRequest, response: ResponsableType<Response>): IResponse;
+  /**
+   * Substitute the route bindings onto the route.
+   *
+   * @param  route
+   *
+   * @throws {ModelNotFoundException<IModel>}
+   */
+  substituteBindings(route: Route): Promise<Route>;
+  /**
+   * Substitute the implicit route bindings for the given route.
+   *
+   * @param  route
+   *
+   * @throws {ModelNotFoundException<IModel>}
+   */
+  substituteImplicitBindings(route: Route): Promise<any | undefined>;
+  /**
+   * Register a callback to run after implicit bindings are substituted.
+   *
+   * @param  callback
+   */
+  substituteImplicitBindingsUsing(callback: CallableConstructor): this;
+  /**
+   * Call the binding callback for the given key.
+   *
+   * @param  key
+   * @param  value
+   * @param  route
+   *
+   * @throws {ModelNotFoundException<IModel>}
+   */
+  protected performBinding(key: string, value: string, route: Route): Promise<any>;
+  /**
+   * Remove any duplicate middleware from the given array.
+   *
+   * @param  middleware
+   */
+  static uniqueMiddleware(middleware: MiddlewareList): MiddlewareIdentifier[];
+  /**
+   * Registers a route that responds to HTTP GET requests.
+   *
+   * @param uri - The route uri.
+   * @param action - The handler function or [controller class, method] array.
+   * @returns
+   */
+  get<C extends typeof IController>(uri: string, action: ActionInput<C>): Route;
+  /**
+   * Registers a route that responds to HTTP HEAD requests.
+   *
+   * @param uri - The route uri.
+   * @param action - The handler function or [controller class, method] array.
+   * @returns
+   */
+  head<C extends typeof IController>(uri: string, action: ActionInput<C>): Route;
+  /**
+   * Registers a route that responds to HTTP POST requests.
+   *
+   * @param uri - The route uri.
+   * @param action - The handler function or [controller class, method] array.
+   * @returns
+   */
+  post<C extends typeof IController>(uri: string, action: ActionInput<C>): Route;
+  /**
+   * Registers a route that responds to HTTP PUT requests.
+   *
+   * @param uri - The route uri.
+   * @param action - The handler function or [controller class, method] array.
+   * @returns
+   */
+  put<C extends typeof IController>(uri: string, action: ActionInput<C>): Route;
+  /**
+   * Registers a route that responds to HTTP PATCH requests.
+   *
+   * @param uri - The route uri.
+   * @param action - The handler function or [controller class, method] array.
+   * @returns
+   */
+  patch<C extends typeof IController>(uri: string, action: ActionInput<C>): Route;
+  /**
+   * Registers a route that responds to HTTP OPTIONS requests.
+   *
+   * @param uri - The route uri.
+   * @param action - The handler function or [controller class, method] array.
+   * @returns
+   */
+  options<C extends typeof IController>(uri: string, action: ActionInput<C>): Route;
+  /**
+   * Registers a route that responds to HTTP DELETE requests.
+   *
+   * @param uri - The route uri.
+   * @param action - The handler function or [controller class, method] array.
+   * @returns
+   */
+  delete<C extends typeof IController>(uri: string, action: ActionInput<C>): Route;
+  /**
+   * Registers a route the matches the provided methods.
+   *
+   * @param methods - The route methods to match.
+   * @param uri - The route uri.
+   * @param action - The handler function or [controller class, method] array.
+   */
+  match<C extends typeof IController>(methods: RouteMethod | RouteMethod[], uri: string, action: ActionInput<C>): Route;
+  /**
+   * Route a resource to a controller.
+   *
+   * @param  name
+   * @param  controller
+   * @param  options
+   */
+  resource<C extends typeof IController>(name: string, controller: C, options?: ResourceOptions): PendingResourceRegistration;
+  /**
+   * Register an array of API resource controllers.
+   *
+   * @param  resources
+   * @param  options
+   */
+  apiResources(resources: GenericObject<typeof IController>, options?: ResourceOptions): void;
+  /**
+   * Route an API resource to a controller.
+   *
+   * @param  name
+   * @param  controller
+   * @param  options
+   */
+  apiResource<C extends typeof IController>(name: string, controller: C, options?: ResourceOptions): PendingResourceRegistration;
+  /**
+   * Register an array of singleton resource controllers.
+   *
+   * @param  singletons
+   * @param  options
+   */
+  singletons(singletons: GenericObject<typeof IController>, options?: ResourceOptions): void;
+  /**
+   * Route a singleton resource to a controller.
+   *
+   * @param  name
+   * @param  controller
+   * @param  options
+   */
+  singleton<C extends typeof IController>(name: string, controller: C, options?: ResourceOptions): PendingSingletonResourceRegistration;
+  /**
+   * Register an array of API singleton resource controllers.
+   *
+   * @param  singletons
+   * @param  options
+   */
+  apiSingletons(singletons: GenericObject<typeof IController>, options?: ResourceOptions): void;
+  /**
+   * Route an API singleton resource to a controller.
+   *
+   * @param  name
+   * @param  controller
+   * @param  options
+   */
+  apiSingleton<C extends typeof IController>(name: string, controller: C, options?: ResourceOptions): PendingSingletonResourceRegistration;
+  /**
+   * Create a route group with shared attributes.
+   *
+   * @param  attributes
+   * @param  routes
+   */
+  group<C extends ((_e: this) => void) | string>(attributes: RouteActions, routes: C | C[]): this;
+  /**
+   * Update the group stack with the given attributes.
+   *
+   * @param  attributes
+   */
+  protected updateGroupStack(attributes: RouteActions): void;
+  /**
+   * Merge the given array with the last group stack.
+   *
+   * @param  newItems
+   * @param  prependExistingPrefix
+   */
+  mergeWithLastGroup(newItems: RouteActions, prependExistingPrefix?: boolean): RouteActions;
+  /**
+   * Load the provided routes.
+   *
+   * @param  routes
+   */
+  protected loadRoutes(routes: string | ((_e: this) => void)): Promise<void>;
+  /**
+   * Get the prefix from the last group on the stack.
+   */
+  getLastGroupPrefix(): any;
+  /**
+   * Merge the group stack with the controller action.
+   *
+   * @param  route
+   */
+  protected mergeGroupAttributesIntoRoute(route: Route): void;
+  /**
+   * Determine if the router currently has a group stack.
+   */
+  hasGroupStack(): boolean;
+  /**
+   * Set the name of the current route
+   *
+   * @param name
+   */
+  name(name: string): this;
+  /**
+   * Prefix the given URI with the last prefix.
+   *
+   * @param  uri
+   */
+  protected prefix(uri: string): string;
+  /**
+   * Registers H3 middleware for a specific path.
+   *
+   * @param path - The middleware or path to apply the middleware.
+   * @param handler - The middleware handler.
+   * @param opts - Optional middleware options.
+   */
+  h3middleware(path: string | IMiddleware[] | Middleware$1, handler?: Middleware$1 | MiddlewareOptions, opts?: MiddlewareOptions): this;
+  /**
+   * Dynamically handle calls into the router instance.
+   *
+   * @param  method
+   * @param  parameters
+   */
+  protected __call(method: string, parameters: any[]): any;
+}
+//#endregion
+//#region src/Matchers/SchemeValidator.d.ts
+declare class SchemeValidator extends IRouteValidator {
+  /**
+   * Validate a given rule against a route and request.
+   *
+   * @param  route
+   * @param  request
+   */
+  matches(route: Route, request: Request): boolean;
+}
+//#endregion
+//#region src/Matchers/UriValidator.d.ts
+declare class UriValidator extends IRouteValidator {
+  /**
+   * Validate a given rule against a route and request.
+   *
+   * @param  route
+   * @param  request
+   */
+  matches(route: Route, request: Request): boolean;
+}
+//#endregion
+//#region src/Route.d.ts
+declare class Route extends IRoute {
+  #private;
+  /**
+   * The default values for the route.
+   */
+  _defaults: Record<string, any>;
+  /**
+   * The router instance used by the route.
+   */
+  protected router: Router;
+  /**
+   * The compiled version of the route.
+   */
+  compiled?: CompiledRoute;
+  /**
+   * The matched parameters object.
+   */
+  parameters?: Record<string, any>;
+  /**
+   * The container instance used by the route.
+   */
+  protected container: IApplication;
+  /**
+   * The fields that implicit binding should use for a given parameter.
+   */
+  protected bindingFields: GenericObject<string>;
+  /**
+   * Indicates "trashed" models can be retrieved when resolving implicit model bindings for this route.
+   */
+  protected withTrashedBindings: boolean;
+  /**
+   * Indicates whether the route is a fallback route.
+   */
+  isFallback: boolean;
+  /**
+   * The route action array.
+   */
+  action: RouteActions;
+  /**
+   * The HTTP methods the route responds to.
+   */
+  methods: RouteMethod[];
+  /**
+   * The route path that can be handled by H3.
+   */
+  path: string;
+  /**
+   * The computed gathered middleware.
+   */
+  computedMiddleware?: MiddlewareList;
+  /**
+   * The controller instance.
+   */
+  controller?: Required<IController>;
+  /**
+   * The validators used by the routes.
+   */
+  static validators: IRouteValidator[];
+  /**
+   *
+   * @param methods The HTTP methods the route responds to.
+   * @param uri The URI pattern the route responds to.
+   */
+  constructor(methods: RouteMethod | RouteMethod[], uri: string, action: ActionInput);
+  /**
+   * Set the router instance on the route.
+   *
+   * @param router
+   */
+  setRouter(router: Router): this;
+  /**
+   * Set the container instance on the route.
+   *
+   * @param container
+   */
+  setContainer(container: IApplication): this;
+  /**
+   * Set the URI that the route responds to.
+   *
+   * @param uri
+   */
+  setUri(uri: string): this;
+  /**
+   * Parse the route URI and normalize / store any implicit binding fields.
+   *
+   * @param uri
+   */
+  protected parseUri(uri: string): string;
+  /**
+   * Get the URI associated with the route.
+   */
+  uri(): string;
+  /**
+   * Add a prefix to the route URI.
+   *
+   * @param prefix
+   */
+  prefix(prefix: string): this;
+  /**
+   * Update the "prefix" attribute on the action array.
+   *
+   * @param prefix
+   */
+  protected updatePrefixOnAction(prefix: string): void;
+  /**
+   * Get the name of the route instance.
+   */
+  getName(): string | undefined;
+  /**
+   * Add or change the route name.
+   *
+   * @param  name
+   *
+   * @throws {InvalidArgumentException}
+   */
+  name(name: string): this;
+  /**
+   * Determine whether the route's name matches the given patterns.
+   *
+   * @param patterns
+   */
+  named(...patterns: string[]): boolean;
+  /**
+   * Get the action name for the route.
+   */
+  getActionName(): any;
+  /**
+   * Get the method name of the route action.
+   *
+   * @return string
+   */
+  getActionMethod(): any;
+  /**
+   * Get the action array or one of its properties for the route.
+   * @param key
+   */
+  getAction(key?: string): any;
+  /**
+   * Mark this route as a fallback route.
+   */
+  fallback(): this;
+  /**
+   * Set the fallback value.
+   *
+   * @param  sFallback
+   */
+  setFallback(isFallback: boolean): this;
+  /**
+   * Get the HTTP verbs the route responds to.
+   */
+  getMethods(): RouteMethod[];
+  /**
+   * Determine if the route only responds to HTTP requests.
+   */
+  httpOnly(): boolean;
+  /**
+   * Determine if the route only responds to HTTPS requests.
+   */
+  httpsOnly(): boolean;
+  /**
+   * Get or set the middlewares attached to the route.
+   *
+   * @param  middleware
+   */
+  middleware(): any[];
+  middleware(middleware?: string | string[]): this;
+  /**
+   * Specify that the "Authorize" / "can" middleware should be applied to the route with the given options.
+   *
+   * @param  ability
+   * @param  models
+   */
+  can(ability: string, models?: string | string[]): this;
+  /**
+   * Set the action array for the route.
+   *
+   * @param action
+   */
+  setAction(action: RouteActions): this;
+  /**
+   * Determine if the route only responds to HTTPS requests.
+   */
+  secure(): boolean;
+  /**
+   * Sync the current route with H3
+   *
+   * @param h3App
+   */
+  sync(h3App: H3): void;
+  /**
+   * Bind the route to a given request for execution.
+   *
+   * @param request
+   */
+  bind(request: Request): this;
+  /**
+   * Get or set the domain for the route.
+   *
+   * @param domain
+   *
+   * @throws {InvalidArgumentException}
+   */
+  domain<D extends string | undefined = undefined>(domain?: D): D extends undefined ? string : this;
+  /**
+   * Parse the route action into a standard array.
+   *
+   * @param action
+   *
+   * @throws {UnexpectedValueException}
+   */
+  protected parseAction(action: ActionInput): RouteActions;
+  /**
+   * Run the route action and return the response.
+   */
+  run(): Promise<ResponsableType>;
+  /**
+   * Get the key / value list of parameters without empty values.
+   */
+  parametersWithoutNulls(): {
+    [k: string]: any;
+  };
+  /**
+   * Get the key / value list of original parameters for the route.
+   *
+   * @throws {LogicException}
+   */
+  originalParameters(): Record<string, any>;
+  /**
+   * Get the matched parameters object.
+   */
+  getParameters(): Record<string, any>;
+  /**
+   * Get a given parameter from the route.
+   *
+   * @param  name
+   * @param  defaultParam
+   */
+  parameter(name: string, defaultParam?: any): any;
+  /**
+   * Get the domain defined for the route.
+   */
+  getDomain(): string | undefined;
+  /**
+   * Get the compiled version of the route.
+   */
+  getCompiled(): CompiledRoute | undefined;
+  /**
+   * Get the binding field for the given parameter.
+   *
+   * @param  parameter
+   */
+  bindingFieldFor(parameter: string | number): string | undefined;
+  /**
+   * Get the binding fields for the route.
+   */
+  getBindingFields(): GenericObject<string>;
+  /**
+   * Set the binding fields for the route.
+   *
+   * @param  bindingFields
+   */
+  setBindingFields(bindingFields: GenericObject<string>): this;
+  /**
+   * Get the parent parameter of the given parameter.
+   *
+   * @param parameter
+   */
+  parentOfParameter(parameter: string): any;
+  /**
+   * Determines if the route allows "trashed" models to be retrieved when resolving implicit model bindings.
+   */
+  allowsTrashedBindings(): boolean;
+  /**
+   * Set a default value for the route.
+   *
+   * @param  key
+   * @param  value
+   */
+  defaults(key: string, value: any): this;
+  /**
+   * Set the default values for the route.
+   *
+   * @param  defaults
+   */
+  setDefaults(defaults: Record<string, any>): this;
+  /**
+   * Get the optional parameter names for the route.
+   */
+  getOptionalParameterNames(): Record<string, null>;
+  /**
+   * Get all of the parameter names for the route.
+   */
+  parameterNames(): string[];
+  /**
+   * Checks whether the route's action is a controller.
+   */
+  protected isControllerAction(): boolean;
+  protected compileParameterNames(): string[];
+  /**
+   * Get the parameters that are listed in the route / controller signature.
+   *
+   * @param  conditions
+   */
+  signatureParameters(conditions: ClassConstructor | RouteActionConditions): RouteParameter[];
+  /**
+   * Compile the route once, cache the result, return compiled data
+   */
+  compileRoute(): CompiledRoute;
+  /**
+   * Set a parameter to the given value.
+   *
+   * @param  name
+   * @param  value
+   */
+  setParameter(name: string, value?: string | GenericObject): void;
+  /**
+   * Unset a parameter on the route if it is set.
+   *
+   * @param  name
+   */
+  forgetParameter(name: string): void;
+  /**
+   * Get the value of the action that should be taken on a missing model exception.
+   */
+  getMissing(): CallableConstructor | undefined;
+  /**
+   * The route path that can be handled by H3.
+   */
+  getPath(): string;
+  /**
+   * Define the callable that should be invoked on a missing model exception.
+   *
+   * @param  missing
+   */
+  missing(missing: CallableConstructor): this;
+  /**
+   * Specify middleware that should be removed from the given route.
+   *
+   * @param  middleware
+   */
+  withoutMiddleware(middleware: any): this;
+  /**
+   * Get the middleware that should be removed from the route.
+   */
+  excludedMiddleware(): MiddlewareList;
+  /**
+   * Get all middleware, including the ones from the controller.
+   */
+  gatherMiddleware(): MiddlewareList;
+  /**
+   * Indicate that the route should enforce scoping of multiple implicit Eloquent bindings.
+   */
+  scopeBindings(): this;
+  /**
+   * Indicate that the route should not enforce scoping of multiple implicit Eloquent bindings.
+   */
+  withoutScopedBindings(): this;
+  /**
+   * Determine if the route should enforce scoping of multiple implicit Eloquent bindings.
+   */
+  enforcesScopedBindings(): boolean;
+  /**
+   * Determine if the route should prevent scoping of multiple implicit Eloquent bindings.
+   */
+  preventsScopedBindings(): boolean;
+  /**
+   * Get the dispatcher for the route's controller.
+   *
+   * @throws {BindingResolutionException}
+   */
+  controllerDispatcher(): ControllerDispatcher | IControllerDispatcher;
+  /**
+   * Get the route validators for the instance.
+   *
+   * @return array
+   */
+  static getValidators(): IRouteValidator[] | (UriValidator | HostValidator | MethodValidator | SchemeValidator)[];
+  /**
+   * Run the route action and return the response.
+   *
+   * @return mixed
+   * @throws  {NotFoundHttpException}
+   */
+  protected runController(): Promise<any>;
+  protected runCallable(): Promise<any>;
+  /**
+   * Get the controller instance for the route.
+   *
+   * @return mixed
+   *
+   * @throws {BindingResolutionException}
+   */
+  getController(): Required<IController> | undefined;
+  /**
+   * Flush the cached container instance on the route.
+   */
+  flushController(): void;
+  /**
+   * Determine if the route matches a given request.
+   *
+   * @param request
+   * @param includingMethod
+   */
+  matches(request: Request, includingMethod?: boolean): boolean;
+  /**
+   * Get the controller class used for the route.
+   */
+  getControllerClass(): any;
+  /**
+   * Get the controller method used for the route.
+   */
+  getControllerMethod(): ResourceMethod;
+  /**
+   * Get the middleware for the route's controller.
+   *
+   * @return array
+   */
+  controllerMiddleware(): never[];
+}
+//#endregion
+//#region src/AbstractRouteCollection.d.ts
+declare abstract class AbstractRouteCollection implements IAbstractRouteCollection {
+  static verbs: RouteMethod[];
+  abstract get(): Route[];
+  abstract get(method: string): Record<string, Route>;
+  abstract getRoutes(): Route[];
+  /**
+   * Match a request against a set of routes belonging to one HTTP verb.
+   *
+   * @param routes
+   * @param req
+   * @param includingMethod
+   * @returns
+   */
+  protected matchAgainstRoutes(routes: Record<string, Route>, req: Request, includingMethod?: boolean): Route | undefined;
+  /**
+   * Final handler for a matched route. Responsible for:
+   * - Throwing for not found
+   * - Throwing for method not allowed
+   * - Attaching params extracted from the match
+   *
+   * @param req
+   * @param route
+   * @returns
+   */
+  protected handleMatchedRoute(req: Request, route?: Route | null): Route;
+  /**
+   * Determine if any routes match on another HTTP verb.
+   *
+   * @param  request
+   */
+  protected checkForAlternateVerbs(request: Request): string[];
+  protected matchDomain(domain: string, host: string): boolean;
+  protected matchUri(route: Route, path: string): boolean;
+  /**
+   * Count the number of items in the collection.
+   */
+  count(): number;
+}
+//#endregion
+//#region src/CallableDispatcher.d.ts
+declare const CallableDispatcher_base: typeof ICallableDispatcher & typeof RouteDependencyResolver & (new (...args: any[]) => ICallableDispatcher & RouteDependencyResolver);
+declare class CallableDispatcher extends CallableDispatcher_base {
+  protected container: IApplication;
+  /**
+   *
+   * @param container The container instance.
+   */
+  constructor(container: IApplication);
+  /**
+   * Dispatch a request to a given callback.
+   *
+   * @param  route
+   * @param  handler
+   * @param  method
+   */
+  dispatch(route: Route, handler: CallableConstructor): Promise<any>;
+  /**
+   * Resolve the parameters for the callable.
+   *
+   * @param  route
+   * @param  handler
+   */
+  protected resolveParameters(route: Route): Record<string, any>;
+}
+//#endregion
 //#region src/Commands/RouteListCommand.d.ts
-declare class RouteListCommand extends Command {
+declare class RouteListCommand extends Command<IApplication> {
+  /**
+   * The name and signature of the console command.
+   *
+   * @var string
+   */
+  protected signature: string;
+  /**
+   * The console command description.
+   *
+   * @var string
+   */
+  protected description: string;
+  /**
+   * Execute the console command.
+   */
+  handle(): Promise<void>;
+  /**
+   * Compile the routes into a displayable format.
+   */
+  protected getRoutes(): IRoute[];
+  /**
+   * List all registered routes.
+   */
+  protected showRoutes(list: IRoute[]): Promise<void | {
+    methods: RouteMethod[];
+    uri: string;
+    name: string | undefined;
+    action: _h3ravel_contracts0.RouteActions;
+  }[]>;
+  private forCli;
+  private asJson;
+  /**
+   * Get the color
+   *
+   * @param method
+   * @returns
+   */
+  private color;
+  /**
+   * Get the alternate method
+   *
+   * @param method
+   * @returns
+   */
+  private pair;
+}
+//#endregion
+//#region src/Events/PreparingResponse.d.ts
+declare class PreparingResponse {
+  request: IRequest;
+  response: ResponsableType;
+  /**
+   * Create a new event instance.
+   *
+   *
+   * @param $request  The request instance.
+   * @param $response  The response instance.
+   */
+  constructor(request: IRequest, response: ResponsableType);
+}
+//#endregion
+//#region src/Events/ResponsePrepared.d.ts
+declare class ResponsePrepared {
+  request: IRequest;
+  response: ResponsableType;
+  /**
+   * Create a new event instance.
+   *
+   *
+   * @param $request  The request instance.
+   * @param $response  The response instance.
+   */
+  constructor(request: IRequest, response: ResponsableType);
+}
+//#endregion
+//#region src/Events/RouteMatched.d.ts
+declare class RouteMatched {
+  route: Route;
+  request: Request;
+  /**
+   * Create a new event instance.
+   *
+   * @param route  The route instance.
+   * @param request  The request instance.
+   */
+  constructor(route: Route, request: Request);
+}
+//#endregion
+//#region src/Events/Routing.d.ts
+declare class Routing {
+  request: Request;
+  /**
+   * Create a new event instance.
+   *
+   * @param request  The request instance.
+   */
+  constructor(request: Request);
+}
+//#endregion
+//#region src/Helpers.d.ts
+declare class Helpers {
+  /**
+   * Extracts parameter names from a route path string.
+   *
+   * - Looks for segments prefixed with ":" (e.g. "/users/:id")
+   * - Captures only the param name (without the ":")
+   * - Returns all matches in order of appearance
+   *
+   * @param path - The route path string (e.g. "/groups/:group/users/:user")
+   * @returns An array of parameter names (e.g. ["group", "user"])
+   */
+  static extractParams(path: string): string[];
+  /**
+   * Resolves route model binding for a given path, HTTP context, and model.
+   *
+   * - Extracts all route parameters from the given path
+   * - If a parameter matches the model name, it attempts to resolve the model binding
+   *   using the provided value and binding field (defaults to "id" unless specified).
+   * - For non-matching parameters, it simply returns the key-value pair as is.
+   * - If no parameters are found, returns an empty object.
+   *
+   * @param path - The route path (e.g. "/groups/:group/users/:user")
+   * @param ctx - The HTTP context containing the request
+   * @param model - The model instance to resolve bindings against
+   * @returns A resolved model instance or an object containing param values
+   */
+  static resolveRouteModelBinding(path: string, ctx: IHttpContext, model: Model): Promise<any>;
+}
+//#endregion
+//#region src/ImplicitRouteBinding.d.ts
+declare class ImplicitRouteBinding {
+  /**
+   * Resolve the implicit route bindings for the given route.
+   *
+   * @param container
+   * @param route
+   */
+  static resolveForRoute(container: IApplication, route: Route): Promise<void>;
+  /**
+   * Return the parameter name if it exists in the given parameters.
+   *
+   * @param name
+   * @param parameters
+   * @returns
+   */
+  protected static getParameterName(name: string, parameters: GenericObject): string | undefined;
+}
+//#endregion
+//#region src/Middleware/SubstituteBindings.d.ts
+declare class SubstituteBindings extends Middleware {
+  protected app: IApplication;
+  protected router: IRouter;
+  /**
+   *
+   * @param router The router instance.
+   */
+  constructor(app: IApplication, router: IRouter);
+  /**
+   * Handle an incoming request.
+   *
+   * @param  request
+   * @param  next
+   */
+  handle(request: Request, next: (request: Request) => Promise<unknown>): Promise<any>;
+}
+//#endregion
+//#region src/MiddlewareResolver.d.ts
+type MiddlewareMap = Record<string, MiddlewareIdentifier>;
+type MiddlewareGroups = Record<string, MiddlewareIdentifier[]>;
+declare class MiddlewareResolver {
+  static app: IApplication;
+  static setApp(app: IApplication): typeof MiddlewareResolver;
+  /**
+   * Resolve the middleware name to a class name(s) preserving passed parameters.
+   */
+  static resolve(name: MiddlewareIdentifier, map: MiddlewareMap, middlewareGroups: MiddlewareGroups): MiddlewareIdentifier | MiddlewareList;
+  /**
+   * Parse the middleware group and format it for usage.
+   */
+  protected static parseMiddlewareGroup(name: string, map: MiddlewareMap, middlewareGroups: MiddlewareGroups): MiddlewareList;
+}
+//#endregion
+//#region src/Pipeline.d.ts
+declare class Pipeline<XP = any> {
+  /**
+   * The final callback to be executed after the pipeline ends regardless of the outcome.
+   */
+  finally?: (...args: any[]) => any;
+  /**
+   * Indicates whether to wrap the pipeline in a database transaction.
+   */
+  protected withinTransaction?: string | false;
+  /**
+   * The container implementation.
+   */
+  protected container?: IContainer;
+  /**
+   * The object being passed through the pipeline.
+   */
+  private passable;
+  /**
+   * The array of class pipes.
+   */
+  private pipes;
+  /**
+   * The method to call on each pipe.
+   */
+  protected method: string;
+  constructor(app?: IContainer);
+  /**
+   * Set the method to call on the pipes.
+   *
+   * @param method
+   */
+  via(method: string): this;
+  send(passable: XP): this;
+  through(pipes: any[]): this;
   /**
-   * The name and signature of the console command.
+   * Run the pipeline with a final destination callback.
    *
-   * @var string
+   * @param  destination
    */
-  protected signature: string;
+  then<R>(destination: (passable: XP) => Promise<R>): Promise<R>;
   /**
-   * The console command description.
+   * Run the pipeline and return the result.
+   */
+  thenReturn(): Promise<XP>;
+  private carry;
+  private handleCarry;
+  /**
+   * Get the final piece of the Closure onion.
    *
-   * @var string
+   * @param  destination
    */
-  protected description: string;
+  private prepareDestination;
   /**
-   * Execute the console command.
+   * Handle the given exception.
+   *
+   * @param  _passable
+   * @param  e
+   * @throws {Error}
    */
-  handle(this: any): Promise<void>;
+  protected handleException(_passable: any, e: Error): void;
   /**
-   * List all registered routes.
+   * Parse full pipe string to get name and parameters.
+   *
+   * @param  pipe
    */
-  protected list(): Promise<void>;
+  private parsePipeString;
   /**
-   * Get the color
+   * Set the container instance.
    *
-   * @param method
-   * @returns
+   * @param  container
    */
-  private color;
+  setContainer(container: IContainer): this;
   /**
-   * Get the alternate method
+   * Execute each pipeline step within a database transaction.
    *
-   * @param method
-   * @returns
+   * @param  withinTransaction
    */
-  private pair;
+  setWithinTransaction(withinTransaction?: string | false): this;
+  /**
+   * Set a final callback to be executed after the pipeline ends regardless of the outcome.
+   *
+   * @param callback
+   */
+  setFinally(callback: (...args: any[]) => any): this;
+  /**
+   * Get the container instance.
+   */
+  protected getContainer(): IContainer;
 }
 //#endregion
-//#region src/Helpers.d.ts
-declare class Helpers {
+//#region src/Providers/RoutingServiceProvider.d.ts
+declare class RoutingServiceProvider extends ServiceProvider {
+  static order: string;
+  register(): Promise<void>;
   /**
-   * Extracts parameter names from a route path string.
+   * Bind the URL generator service.
    *
-   * - Looks for segments prefixed with ":" (e.g. "/users/:id")
-   * - Captures only the param name (without the ":")
-   * - Returns all matches in order of appearance
+   * @return void
+   */
+  protected bindUrlGenerator(): void;
+}
+//#endregion
+//#region src/RouteAction.d.ts
+declare class RouteAction {
+  /**
+   * The route action array.
+   */
+  private static action;
+  static parse(uri: string, action?: ActionInput): RouteActions;
+  /**
+   * Normalize the "uses" field
+   */
+  private static normalizeUses;
+  /**
+   * Missing action fallback
+   */
+  private static missingAction;
+  /**
+   * Make an action for an invokable controller.
    *
-   * @param path - The route path string (e.g. "/groups/:group/users/:user")
-   * @returns An array of parameter names (e.g. ["group", "user"])
+   * @param action
+   *
+   * @throws {UnexpectedValueException}
    */
-  static extractParams(path: string): string[];
+  protected static makeInvokable(action: IController): (...ctx: any[]) => any;
   /**
-   * Resolves route model binding for a given path, HTTP context, and model.
+   * Detect if a value is a class constructor
+   */
+  private static isClass;
+}
+//#endregion
+//#region src/RouteGroup.d.ts
+declare class RouteGroup {
+  /**
+   * Merge route groups into a new array.
    *
-   * - Extracts all route parameters from the given path
-   * - If a parameter matches the model name, it attempts to resolve the model binding
-   *   using the provided value and binding field (defaults to "id" unless specified).
-   * - For non-matching parameters, it simply returns the key-value pair as is.
-   * - If no parameters are found, returns an empty object.
+   * @param  newAct
+   * @param  old
+   * @param  prependExistingPrefix
+   */
+  static merge(newAct: RouteActions, old: RouteActions, prependExistingPrefix?: boolean): RouteActions;
+  /**
+   * Format the namespace for the new group attributes.
    *
-   * @param path - The route path (e.g. "/groups/:group/users/:user")
-   * @param ctx - The HTTP context containing the request
-   * @param model - The model instance to resolve bindings against
-   * @returns A resolved model instance or an object containing param values
+   * @param  newAct
+   * @param  old
+   */
+  protected static formatNamespace(newAct: RouteActions, old: RouteActions): string | undefined;
+  /**
+   * Format the prefix for the new group attributes.
+   *
+   * @param  newAct
+   * @param  old
+   * @param  prependExistingPrefix
+   */
+  protected static formatPrefix(newAct: RouteActions, old: RouteActions, prependExistingPrefix?: boolean): string;
+  /**
+   * Format the "wheres" for the new group attributes.
+   *
+   * @param  newAct
+   * @param  old
+   */
+  protected static formatWhere(newAct: RouteActions, old: RouteActions): Record<string, _h3ravel_contracts0.RouteEventHandler>;
+  /**
+   * Format the "as" clause of the new group attributes.
+   *
+   * @param  newAct
+   * @param  old
+   * @param  prependExistingPrefix
    */
-  static resolveRouteModelBinding(path: string, ctx: HttpContext, model: Model): Promise<any>;
+  protected static formatAs(newAct: RouteActions, old: RouteActions): RouteActions;
 }
 //#endregion
-//#region src/Providers/AssetsServiceProvider.d.ts
-/**
- * Handles public assets loading
- *
- * Auto-Registered
- */
-declare class AssetsServiceProvider extends ServiceProvider {
-  static priority: number;
-  register(): void;
+//#region src/RouteParameterBinder.d.ts
+declare class RouteParameterBinder {
+  protected route: Route;
+  /**
+   * Create a new Route parameter binder instance.
+   *
+   * @param  route The route instance.
+   */
+  constructor(route: Route);
+  /**
+   * Get the parameters for the route.
+   *
+   * @param request
+   */
+  parameters(request: Request): Record<string, any>;
+  /**
+   * Get the parameter matches for the path portion of the URI.
+   *
+   * @param  request
+   */
+  protected bindPathParameters(request: Request): Record<string, string>;
+  /**
+   * Extract the parameter list from the host part of the request.
+   *
+   * @param  request
+   * @param parameters
+   */
+  protected bindHostParameters(request: Request, parameters: Record<string, any>): Record<string, string>;
+  /**
+   * Combine a set of parameter matches with the route's keys.
+   *
+   * @param   matches
+   */
+  protected matchToKeys(matches: string[]): Record<string, string>;
+  /**
+   * Replace null parameters with their defaults.
+   *
+   * @param parameters
+   * @return array
+   */
+  protected replaceDefaults(parameters: Record<string, any>): Record<string, any>;
 }
 //#endregion
-//#region src/Providers/RouteServiceProvider.d.ts
-/**
- * Handles routing registration
- *
- * Load route files (web.ts, api.ts).
- * Map controllers to routes.
- * Register route-related middleware.
- *
- * Auto-Registered
- */
-declare class RouteServiceProvider extends ServiceProvider {
-  static priority: number;
-  register(): void;
+//#region src/RouteRegisterer.d.ts
+declare const RouteRegistrar_base: (new () => FRoute & {
+  [x: string]: any;
+  where(_wheres: any): /*elided*/any;
+  whereAlpha(parameters: string | string[]): /*elided*/any;
+  whereAlphaNumeric(parameters: string | string[]): /*elided*/any;
+  whereNumber(parameters: string | string[]): /*elided*/any;
+  whereUlid(parameters: string | string[]): /*elided*/any;
+  whereUuid(parameters: string | string[]): /*elided*/any;
+  whereIn(parameters: string | string[], values: any[]): /*elided*/any;
+  assignExpressionToParameters(parameters: string | string[], expression: string): /*elided*/any;
+} & {
+  [x: string]: any;
+  macroCall(method: string, parameters?: any[]): any;
+} & {
+  [x: string]: any;
+}) & {} & {
+  [x: string]: any;
+  prototype: {
+    [x: string]: any;
+    where(_wheres: any): /*elided*/any;
+    whereAlpha(parameters: string | string[]): /*elided*/any;
+    whereAlphaNumeric(parameters: string | string[]): /*elided*/any;
+    whereNumber(parameters: string | string[]): /*elided*/any;
+    whereUlid(parameters: string | string[]): /*elided*/any;
+    whereUuid(parameters: string | string[]): /*elided*/any;
+    whereIn(parameters: string | string[], values: any[]): /*elided*/any;
+    assignExpressionToParameters(parameters: string | string[], expression: string): /*elided*/any;
+  };
+} & {
+  [x: string]: any;
+  prototype: {
+    [x: string]: any;
+    macroCall(method: string, parameters?: any[]): any;
+  };
+  macros: Record<string, _h3ravel_support9.Macro>;
+  macro: (name: string, macro: _h3ravel_support9.Macro) => void;
+  hasMacro: (name: string) => boolean;
+  flushMacros: () => void;
+  mixin: (mixin: object, replace?: boolean) => void;
+  createProxy: <T extends {
+    new (...args: any[]): {
+      [x: string]: any;
+      macroCall(method: string, parameters?: any[]): any;
+    };
+    [x: string]: any;
+    macros: Record<string, _h3ravel_support9.Macro>;
+    macro(name: string, macro: _h3ravel_support9.Macro): void;
+    hasMacro(name: string): boolean;
+    flushMacros(): void;
+    mixin(mixin: object, replace?: boolean): void;
+    createProxy<T extends /*elided*/any>(this: T): T;
+    macroCallStatic(method: string, parameters?: any[]): any;
+  }>(this: T) => T;
+  macroCallStatic: (method: string, parameters?: any[]) => any;
+} & {
+  [x: string]: any;
+  prototype: {
+    [x: string]: any;
+  };
+};
+declare class RouteRegistrar extends RouteRegistrar_base {
+  protected router: Router;
+  protected attributes: RouteActions;
+  protected passthru: string[];
+  protected allowedAttributes: (keyof RouteActions)[];
+  protected aliases: Record<keyof RouteActions, string>;
+  constructor(router: Router);
+  attribute(key: string, value: any): this;
+  resource<C extends typeof IController>(name: string, controller: C, options?: ResourceOptions): PendingResourceRegistration;
+  apiResource<C extends typeof IController>(name: string, controller: C, options?: ResourceOptions): PendingResourceRegistration;
+  singleton<C extends typeof IController>(name: string, controller: C, options?: ResourceOptions): PendingSingletonResourceRegistration;
+  apiSingleton<C extends typeof IController>(name: string, controller: C, options?: ResourceOptions): PendingSingletonResourceRegistration;
+  group(callback: CallableConstructor | any[] | string): this;
+  match(methods: RouteMethod | RouteMethod[], uri: string, action?: RouteActions): Route;
+  protected registerRoute(method: Lowercase<RouteMethod>, uri: string, action?: RouteActions): Route;
+  protected compileAction(action?: RouteActions): ResourceOptions;
   /**
-   * Load routes from src/routes
+   * PHP __call equivalent
+   * Handled via Proxy in Magic
    */
-  boot(): Promise<void>;
+  __call(method: string, parameters: any[]): any;
 }
 //#endregion
-//#region src/Route.d.ts
-declare class Router implements IRouter {
-  protected h3App: H3;
-  private app;
-  private routes;
-  private nameMap;
-  private groupPrefix;
-  private middlewareMap;
-  private groupMiddleware;
-  constructor(h3App: H3, app: Application);
+//#region src/RouteSignatureParameters.d.ts
+declare class RouteSignatureParameters {
+  private static app;
+  private static route;
   /**
-   * Route Resolver
+   * set the current Application and Route instances
    *
-   * @param handler
-   * @param middleware
-   * @returns
+   * @param app
    */
-  private resolveHandler;
+  static setRequirements(app: IApplication, route: Route): typeof RouteSignatureParameters;
   /**
-   * Add a route to the stack
+   * Extract the route action's signature parameters.
    *
-   * @param method
-   * @param path
-   * @param handler
-   * @param name
-   * @param middleware
+   * @param action
+   * @param conditions
+   * @returns
    */
-  private addRoute;
+  static fromAction(action: RouteActions, conditions?: RouteActionConditions): RouteParameter[];
   /**
-   * Resolves a route handler definition into an executable EventHandler.
+   * Get the controller method used for the route.
    *
-   * A handler can be:
-   *   - A function matching the EventHandler signature
-   *   - A controller class (optionally decorated for IoC resolution)
+   * @param action
+   * @returns
+   */
+  private static getControllerMethod;
+}
+//#endregion
+//#region src/RouteUri.d.ts
+declare class RouteUri {
+  /**
+   * The route URI.
+   */
+  uri: string;
+  /**
+   * The fields that should be used when resolving bindings.
+   */
+  bindingFields: Record<string, string>;
+  /**
+   * Create a new route URI instance.
    *
-   * If it’s a controller class, this method will:
-   *   - Instantiate it (via IoC or manually)
-   *   - Call the specified method (defaults to `index`)
+   * @param uri  The route URI.
+   * @param bindingFields  The fields that should be used when resolving bindings.
+   */
+  constructor(uri: string, bindingFields?: Record<string, string>);
+  /**
+   * Parse the given URI.
    *
-   * @param handler     Event handler function OR controller class
-   * @param methodName  Method to invoke on the controller (defaults to 'index')
+   * @param  uri  The route URI.
+   */
+  static parse(uri: string): RouteUri;
+}
+//#endregion
+//#region src/UrlGenerator.d.ts
+declare class UrlGenerator extends IUrlGenerator {
+  #private;
+  private routes;
+  private request;
+  protected assetRoot?: string;
+  protected forcedRoot?: string;
+  protected forceScheme?: string;
+  protected cachedRoot?: string;
+  protected cachedScheme?: string;
+  protected keyResolver?: () => string | string[];
+  protected missingNamedRouteResolver?: CallableConstructor;
+  /**
+   * The session resolver callable.
    */
-  private resolveControllerOrHandler;
+  protected sessionResolver?: CallableConstructor;
   /**
-   * Registers a route that responds to HTTP GET requests.
+   * The route URL generator instance.
+   */
+  protected routeGenerator?: RouteUrlGenerator;
+  /**
+   * The named parameter defaults.
+   */
+  defaultParameters: GenericObject;
+  constructor(routes: IRouteCollection, request: IRequest, assetRoot?: string);
+  /**
+   * Get the full URL for the current request,
+   * including the query string.
    *
-   * @param path        The URL pattern to match (can include parameters, e.g., '/users/:id').
-   * @param definition  Either:
-   *                      - An EventHandler function
-   *                      - A tuple: [ControllerClass, methodName]
-   * @param name        Optional route name (for URL generation or referencing).
-   * @param middleware  Optional array of middleware functions to execute before the handler.
+   * Example:
+   *   https://example.com/users?page=2
    */
-  get<C extends new (...args: any) => any>(path: string, definition: RouteEventHandler | [C, methodName: ExtractControllerMethods<InstanceType<C>>], name?: string, middleware?: IMiddleware[]): Omit<this, RouterEnd>;
+  full(): string;
   /**
-   * Registers a route that responds to HTTP POST requests.
+   * Get the URL for the current request path
+   * without modifying the query string.
+   */
+  current(): string;
+  /**
+   * Get the URL for the previous request.
+   *
+   * Resolution order:
+   * 1. HTTP Referer header
+   * 2. Session-stored previous URL
+   * 3. Fallback (if provided)
+   * 4. Root "/"
    *
-   * @param path        The URL pattern to match (can include parameters, e.g., '/users').
-   * @param definition  Either:
-   *                      - An EventHandler function
-   *                      - A tuple: [ControllerClass, methodName]
-   * @param name        Optional route name (for URL generation or referencing).
-   * @param middleware  Optional array of middleware functions to execute before the handler.
+   * @param fallback Optional fallback path or URL
    */
-  post<C extends new (...args: any) => any>(path: string, definition: RouteEventHandler | [C, methodName: ExtractControllerMethods<InstanceType<C>>], name?: string, middleware?: IMiddleware[]): Omit<this, RouterEnd>;
+  previous(fallback?: string | false): string;
   /**
-   * Registers a route that responds to HTTP PUT requests.
+   * Generate an absolute URL to the given path.
+   *
+   * - Accepts relative paths or full URLs
+   * - Automatically prefixes scheme + host
+   * - Encodes extra path parameters safely
    *
-   * @param path        The URL pattern to match (can include parameters, e.g., '/users/:id').
-   * @param definition  Either:
-   *                      - An EventHandler function
-   *                      - A tuple: [ControllerClass, methodName]
-   * @param name        Optional route name (for URL generation or referencing).
-   * @param middleware  Optional array of middleware functions to execute before the handler.
+   * @param path Relative or absolute path
+   * @param extra Additional path segments
+   * @param secure Force HTTPS or HTTP
    */
-  put<C extends new (...args: any) => any>(path: string, definition: RouteEventHandler | [C, methodName: ExtractControllerMethods<InstanceType<C>>], name?: string, middleware?: IMiddleware[]): Omit<this, RouterEnd>;
+  to(path: string, extra?: (string | number)[], secure?: boolean | null): string;
   /**
-   * Registers a route that responds to HTTP PATCH requests.
+   * Generate a secure (HTTPS) absolute URL.
    *
-   * @param path        The URL pattern to match (can include parameters, e.g., '/users/:id').
-   * @param definition  Either:
-   *                      - An EventHandler function
-   *                      - A tuple: [ControllerClass, methodName]
-   * @param name        Optional route name (for URL generation or referencing).
-   * @param middleware  Optional array of middleware functions to execute before the handler.
+   * @param path
+   * @param parameters
+   * @returns
    */
-  patch<C extends new (...args: any) => any>(path: string, definition: RouteEventHandler | [C, methodName: ExtractControllerMethods<InstanceType<C>>], name?: string, middleware?: IMiddleware[]): Omit<this, RouterEnd>;
+  secure(path: string, parameters?: any[]): string;
   /**
-   * Registers a route that responds to HTTP DELETE requests.
+   * Generate a URL to a public asset.
    *
-   * @param path        The URL pattern to match (can include parameters, e.g., '/users/:id').
-   * @param definition  Either:
-   *                      - An EventHandler function
-   *                      - A tuple: [ControllerClass, methodName]
-   * @param name        Optional route name (for URL generation or referencing).
-   * @param middleware  Optional array of middleware functions to execute before the handler.
+   * - Skips URL generation if path is already absolute
+   * - Removes index.php from root if present
+   *
+   * @param path Asset path
+   * @param secure Force HTTPS
    */
-  delete<C extends new (...args: any) => any>(path: string, definition: RouteEventHandler | [C, methodName: ExtractControllerMethods<InstanceType<C>>], name?: string, middleware?: IMiddleware[]): Omit<this, RouterEnd>;
+  asset(path: string, secure?: boolean | null): string;
   /**
-   * API Resource support
+   * Generate a secure (HTTPS) asset URL.
    *
    * @param path
-   * @param controller
+   * @returns
+   */
+  secureAsset(path: string): string;
+  /**
+   * Resolve the URL scheme to use.
+   *
+   * Priority:
+   * 1. Explicit `secure` flag
+   * 2. Forced scheme
+   * 3. Request scheme (cached)
+   *
+   * @param secure
+   */
+  formatScheme(secure?: boolean | null): string;
+  /**
+   * Format the base root URL.
+   *
+   * - Applies forced root if present
+   * - Replaces scheme while preserving host
+   * - Result is cached per request
+   *
+   * @param scheme URL scheme
+   * @param root Optional custom root
    */
-  apiResource<C extends new (...args: any) => any>(path: string, Controller: C, middleware?: IMiddleware[]): Omit<this, RouterEnd | 'name'>;
+  formatRoot(scheme: string, root?: string): string;
   /**
-   * Named route URL generator
+   * Create a signed route URL for a named route.
    *
    * @param name
-   * @param params
+   * @param parameters
+   * @param expiration
+   * @param absolute
    * @returns
    */
-  route(name: string, params?: Record<string, string>): string | undefined;
+  signedRoute(name: string, parameters?: Record<string, any>, expiration?: number, absolute?: boolean): string;
   /**
-   * Grouping
+   * Check if the given request has a valid signature for a relative URL.
    *
-   * @param options
-   * @param callback
+   * @param request
+   * @returns
    */
-  group(options: {
-    prefix?: string;
-    middleware?: EventHandler[];
-  }, callback: (_e: this) => void): this;
+  hasValidSignature(request: IRequest): boolean;
   /**
-   * Set the name of the current route
+   * Get the URL to a named route.
    *
    * @param name
+   * @param parameters
+   * @param absolute
+   * @returns
    */
-  name(name: string): this;
+  route(name: string, parameters?: RouteParams, absolute?: boolean): string;
   /**
-   * Registers middleware for a specific path.
-   * @param path - The path to apply the middleware.
-   * @param handler - The middleware handler.
-   * @param opts - Optional middleware options.
+   * Get the URL for a given route instance.
+   *
+   * @param  route
+   * @param  parameters
+   * @param  absolute
+   */
+  toRoute(route: IRoute, parameters?: RouteParams, absolute?: boolean): string;
+  /**
+   * Combine root and path into a final URL.
+   *
+   * Allows optional host and path formatters
+   * to modify the output dynamically.
+   *
+   * @param root
+   * @param path
+   * @param route
+   * @returns
+   */
+  format(root: string, path: string, route?: IRoute): string;
+  /**
+   * Format the array of URL parameters.
+   *
+   * @param  parameters
+   */
+  formatParameters(parameters: GenericObject<UrlRoutable> | RouteParams): GenericObject;
+  protected extractQueryString(path: string): [string, string];
+  /**
+   * @param  root
+   */
+  protected removeIndex(root: string): string;
+  /**
+   * Determine whether a string is a valid URL.
+   *
+   * Supports:
+   * - Absolute URLs
+   * - Protocol-relative URLs
+   * - Anchors and special schemes
+   *
+   * @param path
+   * @returns
+   */
+  isValidUrl(path: string): boolean;
+  /**
+   * Get the Route URL generator instance.
+   */
+  protected routeUrl(): RouteUrlGenerator;
+  /**
+   * Force HTTPS for all generated URLs.
+   *
+   * @param force
+   */
+  forceHttps(force?: boolean): void;
+  /**
+   * Set the origin (scheme + host) for generated URLs.
+   *
+   * @param root
+   */
+  useOrigin(root?: string): void;
+  useAssetOrigin(root?: string): void;
+  setKeyResolver(resolver: () => string | string[]): void;
+  resolveMissingNamedRoutesUsing(resolver: CallableConstructor): void;
+  formatHostUsing(callback: CallableConstructor): this;
+  formatPathUsing(callback: CallableConstructor): this;
+  /**
+   * Get the request instance.
+   */
+  getRequest(): IRequest;
+  /**
+   * Set the current request instance.
+   *
+   * @param  request
+   */
+  setRequest(request: IRequest): void;
+  /**
+   * Set the route collection.
+   *
+   * @param routes
+   */
+  setRoutes(routes: IRouteCollection): this;
+  /**
+   * Get the route collection.
+   */
+  getRoutes(): IRouteCollection;
+  /**
+   * Get the session implementation from the resolver.
+   */
+  protected getSession(): any;
+  /**
+   * Set the session resolver for the generator.
+   *
+   * @param   sessionResolver
    */
-  middleware(path: string | IMiddleware[] | Middleware, handler: Middleware | MiddlewareOptions, opts?: MiddlewareOptions): this;
+  setSessionResolver(sessionResolver: CallableConstructor): this;
+  /**
+   * Clone a new instance of the URL generator with a different encryption key resolver.
+   *
+   * @param  keyResolver
+   */
+  withKeyResolver(keyResolver: () => string | string[]): void;
+  /**
+   * Set the default named parameters used by the URL generator.
+   *
+   * @param  array  $defaults
+   * @return void
+   */
+  defaults(defaults: GenericObject): void;
+  /**
+   * Get the previous URL from the session if possible.
+   */
+  protected getPreviousUrlFromSession(): string;
+}
+//#endregion
+//#region src/RouteUrlGenerator.d.ts
+declare class RouteUrlGenerator extends IRouteUrlGenerator {
+  /**
+   * The URL generator instance.
+   */
+  protected url: UrlGenerator;
+  /**
+   * The request instance.
+   */
+  protected request: IRequest;
+  /**
+   * The named parameter defaults.
+   */
+  defaultParameters: RouteParams;
+  /**
+   * Characters that should not be URL encoded.
+   */
+  dontEncode: {
+    '%2F': string;
+    '%40': string;
+    '%3A': string;
+    '%3B': string;
+    '%2C': string;
+    '%3D': string;
+    '%2B': string;
+    '%21': string;
+    '%2A': string;
+    '%7C': string;
+    '%3F': string;
+    '%26': string;
+    '%23': string;
+    '%25': string;
+  };
+  /**
+   * Create a new Route URL generator.
+   *
+   * @param  url
+   * @param  request
+   */
+  constructor(url: UrlGenerator, request: IRequest);
+  /**
+   * Generate a URL for the given route.
+   *
+   * @param  route
+   * @param  parameters
+   * @param  absolute
+   */
+  to(route: IRoute, parameters?: RouteParams, absolute?: boolean): string;
+  /**
+   * Get the formatted domain for a given route.
+   *
+   * @param  route
+   * @param  parameters
+   */
+  protected getRouteDomain(route: IRoute, parameters: RouteParams): string | undefined;
+  /**
+   * Format the domain and port for the route and request.
+   *
+   * @param  route
+   * @param  parameters
+   */
+  protected formatDomain(route: IRoute, parameters: RouteParams): string;
+  /**
+   * Get the scheme for the given route.
+   *
+   * @param   route
+   */
+  protected getRouteScheme(route: IRoute): string;
+  /**
+   * Add the port to the domain if necessary.
+   *
+   * @param  domain
+   */
+  protected addPortToDomain(domain: string): string;
+  /**
+   * Format the array of route parameters.
+   *
+   * @param  route
+   * @param  parameters
+   */
+  protected formatParameters(route: IRoute, parameters: RouteParams): _h3ravel_contracts0.GenericObject;
+  /**
+   * Replace the parameters on the root path.
+   *
+   * @param  oute
+   * @param  domain
+   * @param  parameters
+   */
+  protected replaceRootParameters(route: IRoute, domain: string | undefined, parameters: RouteParams): string;
+  /**
+   * Replace all of the wildcard parameters for a route path.
+   *
+   * @param  path
+   * @param  parameters
+   */
+  protected replaceRouteParameters(path: string, parameters: RouteParams): string;
+  /**
+   * Replace all of the named parameters in the path.
+   *
+   * @param  path
+   * @param  parameters
+   */
+  protected replaceNamedParameters(path: string, parameters: RouteParams): string;
+  /**
+   * Add a query string to the URI.
+   *
+   * @param  uri
+   * @param  parameters
+   */
+  protected addQueryString(uri: string, parameters: RouteParams): string;
+  /**
+   * Get the query string for a given route.
+   *
+   * @param  parameters
+   * @return string
+   */
+  protected getRouteQueryString(parameters: RouteParams): "" | "?{query}";
+  /**
+   * Get the string parameters from a given list.
+   *
+   * @param  parameters
+   */
+  protected getStringParameters(parameters: RouteParams): {
+    [k: string]: any;
+  };
+  /**
+   * Get the numeric parameters from a given list.
+   *
+   * @param  parameters
+   */
+  protected getNumericParameters(parameters: RouteParams): {
+    [k: string]: any;
+  };
+  /**
+   * Set the default named parameters used by the URL generator.
+   *
+   * @param  $defaults
+   */
+  defaults(defaults: RouteParams): void;
 }
 //#endregion
-export { AssetsServiceProvider, Helpers, RouteListCommand, RouteServiceProvider, Router };
+//#region src/Traits/CreatesRegularExpressionRouteConstraints.d.ts
+declare const CreatesRegularExpressionRouteConstraints: _h3ravel_shared0.Trait<(Base: any) => {
+  new (): {
+    [x: string]: any;
+    where(_wheres: any): /*elided*/any;
+    /**
+     * Specify that the given route parameters must be alphabetic.
+     *
+     * @param  parameters
+     */
+    whereAlpha(parameters: string | string[]): /*elided*/any;
+    /**
+     * Specify that the given route parameters must be alphanumeric.
+     *
+     * @param  parameters
+     */
+    whereAlphaNumeric(parameters: string | string[]): /*elided*/any;
+    /**
+     * Specify that the given route parameters must be numeric.
+     *
+     * @param  parameters
+     */
+    whereNumber(parameters: string | string[]): /*elided*/any;
+    /**
+     * Specify that the given route parameters must be ULIDs.
+     *
+     * @param  parameters
+     */
+    whereUlid(parameters: string | string[]): /*elided*/any;
+    /**
+     * Specify that the given route parameters must be UUIDs.
+     *
+     * @param  parameters
+     */
+    whereUuid(parameters: string | string[]): /*elided*/any;
+    /**
+     * Specify that the given route parameters must be one of the given values.
+     *
+     * @param  parameters
+     * @param  values
+     */
+    whereIn(parameters: string | string[], values: any[]): /*elided*/any;
+    /**
+     * Apply the given regular expression to the given parameters.
+     *
+     * @param  parameters
+     * @param  expression
+     */
+    assignExpressionToParameters(parameters: string | string[], expression: string): /*elided*/any;
+  };
+  [x: string]: any;
+}, undefined>;
+//#endregion
+export { AbstractRouteCollection, CallableDispatcher, CompiledRoute, CompiledRouteToken, ControllerDispatcher, CreatesRegularExpressionRouteConstraints, FiltersControllerMiddleware, Helpers, HostValidator, IRouteValidator, ImplicitRouteBinding, MethodValidator, MiddlewareResolver, PendingResourceRegistration, PendingSingletonResourceRegistration, Pipe, Pipeline, PreparingResponse, ResourceRegistrar, ResponsePrepared, Route, RouteAction, RouteActionConditions, RouteCollection, RouteDependencyResolver, RouteGroup, RouteListCommand, RouteMatched, RouteParameter, RouteParameterBinder, RouteRegistrar, RouteSignatureParameters, RouteUri, RouteUrlGenerator, Router, Routing, RoutingServiceProvider, SchemeValidator, SubstituteBindings, UriValidator, UrlGenerator };