@h3ravel/contracts 0.28.0

package/dist/index.d.ts

@@ -0,0 +1,4464 @@
+/// <reference path="./app.globals.d.ts" />
+import { H3, H3Event, HTTPResponse, Middleware, MiddlewareOptions, serve } from "h3";
+import { IApplication as IApplication$1 } from "@h3ravel/contracts";
+import { DotNestedKeys as DotNestedKeys$1, DotNestedValue as DotNestedValue$1 } from "@h3ravel/shared";
+import { Edge } from "edge.js";
+import { Builder, Model } from "@h3ravel/arquebus";
+import { IQueryBuilder } from "@h3ravel/arquebus/types";
+import { Command, Kernel } from "@h3ravel/musket";
+import In from "simple-body-validator/lib/cjs/rules/in";
+import NotIn from "simple-body-validator/lib/cjs/rules/notIn";
+import Regex from "simple-body-validator/lib/cjs/rules/regex";
+import RequiredIf from "simple-body-validator/lib/cjs/rules/requiredIf";
+import { Rule as Rule$1 } from "simple-body-validator";
+
+//#region src/Routing/IMiddleware.d.ts
+/**
+ * Defines the contract for all middlewares.
+ * Any middleware implementing this must define these methods.
+ */
+declare abstract class IMiddleware {
+  options: {
+    only?: RouteMethod[];
+    except?: RouteMethod[];
+  };
+  abstract handle(...args: any[]): Promise<any>;
+}
+//#endregion
+//#region src/Core/IController.d.ts
+/**
+ * Defines the contract for all controllers.
+ */
+declare abstract class IController {
+  show?(...ctx: any[]): any;
+  edit?(...ctx: any[]): any;
+  index?(...ctx: any[]): any;
+  store?(...ctx: any[]): any;
+  create?(...ctx: any[]): any;
+  update?(...ctx: any[]): any;
+  destroy?(...ctx: any[]): any;
+  __invoke?(...ctx: any[]): any;
+  callAction?(method: ResourceMethod, parameters: any[]): any;
+  getMiddleware?(): IMiddleware;
+}
+//#endregion
+//#region src/Core/IServiceProvider.d.ts
+declare abstract class IServiceProvider {
+  /**
+   * Unique Identifier for service providers
+   */
+  static uid?: number;
+  /**
+   * Sort order
+   */
+  static order?: `before:${string}` | `after:${string}` | string | undefined;
+  /**
+   * Sort priority
+   */
+  static priority?: number;
+  /**
+   * Indicate that this service provider only runs in console
+   */
+  static runsInConsole?: boolean;
+  /**
+   * Indicate that this service provider only runs in console
+   */
+  static console?: boolean;
+  /**
+   * Indicate that this service provider only runs in console
+   */
+  abstract console?: boolean;
+  /**
+   * Indicate that this service provider only runs in console
+   */
+  abstract runsInConsole: boolean;
+  /**
+   * List of registered console commands
+   */
+  abstract registeredCommands?: (new (app: any, kernel: any) => any)[];
+  /**
+   * An array of console commands to register.
+   */
+  abstract commands?(commands: (new (app: any, kernel: any) => any)[]): void;
+  /**
+   * Register bindings to the container.
+   * Runs before boot().
+   */
+  abstract register(...app: unknown[]): void | Promise<void>;
+  /**
+   * Perform post-registration booting of services.
+   * Runs after all providers have been registered.
+   */
+  boot?(...app: unknown[]): void | Promise<void>;
+  /**
+   * Register a booted callback to be run after the "boot" method is called.
+   *
+   * @param callback
+   */
+  abstract booted(callback: (...args: any[]) => void): void;
+  /**
+   * Call the registered booted callbacks.
+   */
+  abstract callBootedCallbacks(): Promise<void>;
+  /**
+   * Register the listed service providers.
+   *
+   * @param commands An array of console commands to register.
+   */
+  abstract registerCommands(commands: (new (app: any, kernel: any) => any)[]): void;
+}
+//#endregion
+//#region src/Foundation/MiddlewareContract.d.ts
+type RedirectHandler = string | (() => string);
+type MiddlewareIdentifier = string | IMiddleware;
+type MiddlewareList = MiddlewareIdentifier[];
+//#endregion
+//#region src/Foundation/IBootstraper.d.ts
+declare abstract class IBootstraper {
+  /**
+   * Bootstrap the given application.
+   */
+  abstract bootstrap(app: IApplication$1): void | Promise<void>;
+}
+//#endregion
+//#region src/Utilities/ObjContract.d.ts
+/**
+ * Adds a dot prefix to nested keys
+ */
+type DotPrefix<T extends string, U extends string> = T extends '' ? U : `${T}.${U}`;
+/**
+ * Converts a union of objects into a single merged object
+ */
+type MergeUnion<T> = (T extends any ? (k: T) => void : never) extends ((k: infer I) => void) ? { [K in keyof I]: I[K] } : never;
+/**
+ * Flattens nested objects into dotted keys
+ */
+type DotFlatten<T, Prefix extends string = ''> = MergeUnion<{ [K in keyof T & string]: T[K] extends Record<string, any> ? DotFlatten<T[K], DotPrefix<Prefix, K>> : { [P in DotPrefix<Prefix, K>]: T[K] } }[keyof T & string]>;
+/**
+ * Builds "nested.key" paths for autocompletion
+ */
+type DotNestedKeys<T> = { [K in keyof T & string]: T[K] extends object ? `${K}` | `${K}.${DotNestedKeys<T[K]>}` : `${K}` }[keyof T & string];
+/**
+ * Retrieves type at a given dot-path
+ */
+type DotNestedValue<T, Path extends string> = Path extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? DotNestedValue<T[Key], Rest> : never : Path extends keyof T ? T[Path] : never;
+/**
+ * A generic object type that supports nullable string values
+ */
+interface GenericWithNullableStringValues {
+  [name: string]: string | undefined;
+}
+//#endregion
+//#region src/Http/IHeaderBag.d.ts
+/**
+ * HeaderBag — A container for HTTP headers
+ * for H3ravel App.
+ */
+declare abstract class IHeaderBag implements Iterable<[string, (string | null)[]]> {
+  /**
+   * Returns all headers as string (for debugging / toString)
+   *
+   * @returns
+   */
+  abstract toString(): string;
+  /**
+   * Returns all headers or specific header list
+   *
+   * @param key
+   * @returns
+   */
+  abstract all<K$1 extends string | undefined>(key?: K$1): K$1 extends string ? (string | null)[] : Record<string, (string | null)[]>;
+  /**
+   * Returns header keys
+   *
+   * @returns
+   */
+  abstract keys(): string[];
+  /**
+   * Replace all headers with new set
+   *
+   * @param headers
+   */
+  abstract replace(headers?: Record<string, string | string[] | null>): void;
+  /**
+   * Add multiple headers
+   *
+   * @param headers
+   */
+  abstract add(headers: Record<string, string | string[] | null>): void;
+  /**
+   * Returns first header value by name or default
+   *
+   * @param key
+   * @param defaultValue
+   * @returns
+   */
+  abstract get<R = undefined>(key: string, defaultValue?: string | null | undefined): R extends undefined ? string | null | undefined : R;
+  /**
+   * Sets a header by name.
+   *
+   * @param replace Whether to replace existing values (default true)
+   */
+  abstract set(key: string, values: string | string[] | null, replace?: boolean): void;
+  /**
+   * Returns true if header exists
+   *
+   * @param key
+   * @returns
+   */
+  abstract has(key: string): boolean;
+  /**
+   * Returns true if header contains value
+   *
+   * @param key
+   * @param value
+   * @returns
+   */
+  abstract contains(key: string, value: string): boolean;
+  /**
+   * Removes a header
+   *
+   * @param key
+   */
+  abstract remove(key: string): void;
+  /**
+   * Returns parsed date from header
+   *
+   * @param key
+   * @param defaultValue
+   * @returns
+   */
+  abstract getDate(key: string, defaultValue?: Date | null): any;
+  /**
+   * Adds a Cache-Control directive
+   *
+   * @param key
+   * @param value
+   */
+  abstract addCacheControlDirective(key: string, value?: string | boolean): void;
+  /**
+   * Returns true if Cache-Control directive is defined
+   *
+   * @param key
+   * @returns
+   */
+  abstract hasCacheControlDirective(key: string): boolean;
+  /**
+   * Returns a Cache-Control directive value by name
+   *
+   * @param key
+   * @returns
+   */
+  abstract getCacheControlDirective(key: string): string | boolean | null;
+  /**
+   * Removes a Cache-Control directive
+   *
+   * @param key
+   * @returns
+   */
+  abstract removeCacheControlDirective(key: string): void;
+  /**
+   * Number of headers
+   *
+   * @param key
+   * @returns
+   */
+  abstract count(): number;
+  /**
+   * Iterator support
+   * @returns
+   */
+  abstract [Symbol.iterator](): Iterator<[string, (string | null)[]]>;
+}
+//#endregion
+//#region src/Http/IUploadedFile.d.ts
+declare abstract class IUploadedFile {
+  abstract originalName: string;
+  abstract mimeType: string;
+  abstract size: number;
+  abstract content: File;
+  /**
+   * Save to disk (Node environment only)
+   */
+  abstract moveTo(destination: string): Promise<void>;
+}
+//#endregion
+//#region src/Http/Utils.d.ts
+type IFileInput = IUploadedFile | File | null | undefined;
+//#endregion
+//#region src/Http/IParamBag.d.ts
+/**
+ * ParamBag is a container for key/value pairs
+ * for H3ravel App.
+ */
+declare abstract class IParamBag implements Iterable<[string, any]> {
+  /**
+   * The current H3 H3Event instance
+   */
+  abstract readonly event: H3Event;
+  /**
+   * Returns the parameters.
+   * @
+   * @param key The name of the parameter to return or null to get them all
+   *
+   * @throws BadRequestException if the value is not an array
+   */
+  abstract all(key?: string): any;
+  abstract get(key: string, defaultValue?: any): any;
+  abstract set(key: string, value: any): void;
+  /**
+   * Returns true if the parameter is defined.
+   *
+   * @param key
+   */
+  abstract has(key: string): boolean;
+  /**
+   * Removes a parameter.
+   *
+   * @param key
+   */
+  abstract remove(key: string): void;
+  /**
+   *
+   * Returns the parameter as string.
+   *
+   * @param key
+   * @param defaultValue
+   * @throws UnexpectedValueException if the value cannot be converted to string
+   * @returns
+   */
+  abstract getString(key: string, defaultValue?: string): string;
+  /**
+   * Returns the parameter value converted to integer.
+   *
+   * @param key
+   * @param defaultValue
+   * @throws UnexpectedValueException if the value cannot be converted to integer
+   */
+  abstract getInt(key: string, defaultValue?: number): number;
+  /**
+   * Returns the parameter value converted to boolean.
+   *
+   * @param key
+   * @param defaultValue
+   * @throws UnexpectedValueException if the value cannot be converted to a boolean
+   */
+  abstract getBoolean(key: string, defaultValue?: boolean): boolean;
+  /**
+   * Returns the alphabetic characters of the parameter value.
+   *
+   * @param key
+   * @param defaultValue
+   * @throws UnexpectedValueException if the value cannot be converted to string
+   */
+  abstract getAlpha(key: string, defaultValue?: string): string;
+  /**
+   * Returns the alphabetic characters and digits of the parameter value.
+   *
+   * @param key
+   * @param defaultValue
+   * @throws UnexpectedValueException if the value cannot be converted to string
+   */
+  abstract getAlnum(key: string, defaultValue?: string): string;
+  /**
+   * Returns the digits of the parameter value.
+   *
+   * @param key
+   * @param defaultValue
+   * @throws UnexpectedValueException if the value cannot be converted to string
+   * @returns
+   **/
+  abstract getDigits(key: string, defaultValue?: string): string;
+  /**
+   * Returns the parameter keys.
+   */
+  abstract keys(): string[];
+  /**
+   * Replaces the current parameters by a new set.
+   */
+  abstract replace(parameters?: RequestObject): void;
+  /**
+   * Adds parameters.
+   */
+  abstract add(parameters?: RequestObject): void;
+  /**
+   * Returns the number of parameters.
+   */
+  abstract count(): number;
+  /**
+   * Returns an iterator for parameters.
+   *
+   * @returns
+   */
+  abstract [Symbol.iterator](): ArrayIterator<[string, any]>;
+}
+//#endregion
+//#region src/Http/IFileBag.d.ts
+/**
+ * FileBag is a container for uploaded files
+ * for H3ravel App.
+ */
+declare abstract class IFileBag extends IParamBag {
+  /**
+   * Replace all stored files.
+   */
+  abstract replace(files?: Record<string, IFileInput | IFileInput[]>): void;
+  /**
+   * Set a file or array of files.
+   */
+  abstract set(key: string, value: IFileInput | IFileInput[]): void;
+  /**
+   * Add multiple files.
+   */
+  abstract add(files?: Record<string, IFileInput | IFileInput[]>): void;
+  /**
+   * Get all stored files.
+   */
+  abstract all(): Record<string, IUploadedFile | IUploadedFile[] | null>;
+}
+//#endregion
+//#region src/Http/IServerBag.d.ts
+/**
+ * ServerBag — a simplified version of Symfony's ServerBag
+ * for H3ravel App.
+ *
+ * Responsible for extracting and normalizing HTTP headers
+ * from the incoming request.
+ */
+declare abstract class IServerBag extends IParamBag {
+  /**
+   * Returns all request headers, normalized to uppercase with underscores.
+   * Example: content-type → CONTENT_TYPE
+   */
+  abstract getHeaders(): Record<string, string>;
+  /**
+   * Returns a specific header by name, case-insensitive.
+   */
+  abstract get(name: string): string | undefined;
+  /**
+   * Returns true if a header exists.
+   */
+  abstract has(name: string): boolean;
+}
+//#endregion
+//#region src/Url/Utils.d.ts
+type RouteParams<N = any> = Record<string, N>;
+//#endregion
+//#region src/Url/IUrl.d.ts
+declare abstract class IUrl {
+  /**
+   * Create a URL from a full URL string
+   */
+  static of(url: string, app?: IApplication): IUrl;
+  /**
+   * Create a URL from a path relative to the app URL
+   */
+  static to(path: string, app?: IApplication): IUrl;
+  /**
+   * Create a URL from a named route
+   */
+  static route<TName extends string = string, TParams extends RouteParams = RouteParams>(name: TName, params?: TParams, app?: IApplication): IUrl;
+  /**
+   * Create a signed URL from a named route
+   */
+  static signedRoute<TName extends string = string, TParams extends RouteParams = RouteParams>(name: TName, params?: TParams, app?: IApplication): IUrl;
+  /**
+   * Create a temporary signed URL from a named route
+   */
+  static temporarySignedRoute<TName extends string = string, TParams extends RouteParams = RouteParams>(name: TName, params: TParams | undefined, expiration: number, app?: IApplication): IUrl;
+  /**
+   * Create a URL from a controller action
+   */
+  static action<C extends new (...args: any) => any>(controller: string | [C, methodName: ExtractClassMethods<InstanceType<C>>], params?: Record<string, any>, app?: IApplication): IUrl;
+  /**
+   * Set the scheme (protocol) of the URL
+   */
+  abstract withScheme(scheme: string): IUrl;
+  /**
+   * Set the host of the URL
+   */
+  abstract withHost(host: string): IUrl;
+  /**
+   * Set the port of the URL
+   */
+  abstract withPort(port: number): IUrl;
+  /**
+   * Set the path of the URL
+   */
+  abstract withPath(path: string): IUrl;
+  /**
+   * Set the query parameters of the URL
+   */
+  abstract withQuery(query: Record<string, unknown>): IUrl;
+  /**
+   * Merge additional query parameters
+   */
+  abstract withQueryParams(params: Record<string, unknown>): IUrl;
+  /**
+   * Set the fragment (hash) of the URL
+   */
+  abstract withFragment(fragment: string): IUrl;
+  /**
+   * Add a signature to the URL for security
+   */
+  abstract withSignature(app?: IApplication, expiration?: number): IUrl;
+  /**
+   * Verify if a URL signature is valid
+   */
+  abstract hasValidSignature(app?: IApplication): boolean;
+  /**
+   * Convert the URL to its string representation
+   */
+  abstract toString(): string;
+  /**
+   * Get the scheme
+   */
+  abstract getScheme(): string | undefined;
+  /**
+   * Get the host
+   */
+  abstract getHost(): string | undefined;
+  /**
+   * Get the port
+   */
+  abstract getPort(): number | undefined;
+  /**
+   * Get the path
+   */
+  abstract getPath(): string;
+  /**
+   * Get the query parameters
+   */
+  abstract getQuery(): Record<string, unknown>;
+  /**
+   * Get the fragment
+   */
+  abstract getFragment(): string | undefined;
+}
+//#endregion
+//#region src/Http/IInputBag.d.ts
+/**
+ * InputBag is a container for user input values
+ * (e.g., query params, body, cookies)
+ * for H3ravel App.
+ */
+declare abstract class InputBag extends IParamBag {
+  /**
+   * Returns a scalar input value by name.
+   *
+   * @param key
+   * @param defaultValue
+   * @throws BadRequestException if the input contains a non-scalar value
+   * @returns
+   */
+  abstract get<T extends string | number | boolean | null>(key: string, defaultValue?: T | null): T | string | number | boolean | null;
+  /**
+   * Replaces all current input values.
+   *
+   * @param inputs
+   * @returns
+   */
+  abstract replace(inputs?: RequestObject): void;
+  /**
+   * Adds multiple input values.
+   *
+   * @param inputs
+   * @returns
+   */
+  abstract add(inputs?: RequestObject): void;
+  /**
+   * Sets an input by name.
+   *
+   * @param key
+   * @param value
+   * @throws TypeError if value is not scalar or array
+   * @returns
+   */
+  abstract set(key: string, value: any): void;
+  /**
+   * Returns true if a key exists.
+   *
+   * @param key
+   * @returns
+   */
+  abstract has(key: string): boolean;
+  /**
+   * Returns all parameters.
+   *
+   * @returns
+   */
+  abstract all(): RequestObject;
+  /**
+   * Converts a parameter value to string.
+   *
+   * @param key
+   * @param defaultValue
+   * @throws BadRequestException if input contains a non-scalar value
+   * @returns
+   */
+  abstract getString(key: string, defaultValue?: string): string;
+  /**
+   * Filters input value with a predicate.
+   * Mimics PHP’s filter_var() in spirit, but simpler.
+   *
+   * @param key
+   * @param defaultValue
+   * @param filterFn
+   * @throws BadRequestException if validation fails
+   * @returns
+   */
+  abstract filter<T = any>(key: string, defaultValue?: T | null, filterFn?: (value: any) => boolean): T | null;
+  /**
+   * Returns an enum value by key.
+   *
+   * @param key
+   * @param EnumClass
+   * @param defaultValue
+   * @throws BadRequestException if conversion fails
+   * @returns
+   */
+  abstract getEnum<T extends Record<string, string | number>>(key: string, EnumClass: T, defaultValue?: T[keyof T] | null): T[keyof T] | null;
+  /**
+   * Removes a key.
+   *
+   * @param key
+   */
+  abstract remove(key: string): void;
+  /**
+   * Returns all keys.
+   *
+   * @returns
+   */
+  abstract keys(): string[];
+  /**
+   * Returns number of parameters.
+   *
+   * @returns
+   */
+  abstract count(): number;
+}
+//#endregion
+//#region src/Http/IHttpRequest.d.ts
+declare abstract class IHttpRequest {
+  /**
+   * The current app instance
+   */
+  abstract app: IApplication;
+  /**
+   * Parsed request body
+   */
+  abstract body: unknown;
+  /**
+   * Gets route parameters.
+   * @returns An object containing route parameters.
+   */
+  abstract params: NonNullable<H3Event['context']['params']>;
+  /**
+   * Uploaded files (FILES).
+   */
+  abstract files: IFileBag;
+  /**
+   * Query string parameters (GET).
+   */
+  abstract _query: InputBag;
+  /**
+   * Server and execution environment parameters
+   */
+  abstract _server: IServerBag;
+  /**
+   * Cookies
+   */
+  abstract cookies: InputBag;
+  /**
+   * The current Http Context
+   */
+  abstract context: IHttpContext;
+  /**
+   * The request attributes (parameters parsed from the PATH_INFO, ...).
+   */
+  abstract attributes: IParamBag;
+  /**
+   * Gets the request headers.
+   * @returns An object containing request headers.
+   */
+  abstract headers: IHeaderBag;
+  /**
+   * Sets the parameters for this request.
+   *
+   * This method also re-initializes all properties.
+   *
+   * @param attributes
+   * @param cookies    The COOKIE parameters
+   * @param files      The FILES parameters
+   * @param server     The SERVER parameters
+   * @param content    The raw body data
+   */
+  abstract initialize(): Promise<void>;
+  /**
+   * Gets a list of content types acceptable by the client browser in preferable order.
+   * @returns {string[]}
+   */
+  abstract getAcceptableContentTypes(): string[];
+  /**
+   * Get a URI instance for the request.
+   */
+  abstract getUriInstance(): IUrl;
+  /**
+   * Returns the requested URI (path and query string).
+   *
+   * @return {string} The raw URI (i.e. not URI decoded)
+   */
+  abstract getRequestUri(): string;
+  /**
+   * Gets the scheme and HTTP host.
+   *
+   * If the URL was called with basic authentication, the user
+   * and the password are not added to the generated string.
+   */
+  abstract getSchemeAndHttpHost(): string;
+  /**
+   * Returns the HTTP host being requested.
+   *
+   * The port name will be appended to the host if it's non-standard.
+   */
+  abstract getHttpHost(): string;
+  /**
+   * Returns the root path from which this request is executed.
+   *
+   * @returns {string} The raw path (i.e. not urldecoded)
+   */
+  abstract getBasePath(): string;
+  /**
+   * Returns the root URL from which this request is executed.
+   *
+   * The base URL never ends with a /.
+   *
+   * This is similar to getBasePath(), except that it also includes the
+   * script filename (e.g. index.php) if one exists.
+   *
+   * @return string The raw URL (i.e. not urldecoded)
+   */
+  abstract getBaseUrl(): string;
+  /**
+   * Gets the request's scheme.
+   */
+  abstract getScheme(): string;
+  /**
+   * Returns the port on which the request is made.
+   *
+   * This method can read the client port from the "X-Forwarded-Port" header
+   * when trusted proxies were set via "setTrustedProxies()".
+   *
+   * The "X-Forwarded-Port" header must contain the client port.
+   *
+   * @return int|string|null Can be a string if fetched from the server bag
+   */
+  abstract getPort(): number | string | undefined;
+  abstract getHost(): string;
+  /**
+   * Checks whether the request is secure or not.
+   *
+   * This method can read the client protocol from the "X-Forwarded-Proto" header
+   * when trusted proxies were set via "setTrustedProxies()".
+   *
+   * The "X-Forwarded-Proto" header must contain the protocol: "https" or "http".
+   */
+  abstract isSecure(): boolean;
+  /**
+   * Returns the value of the requested header.
+   */
+  abstract getHeader(name: string): string | undefined | null;
+  /**
+   * Checks if the request method is of specified type.
+   *
+   * @param method Uppercase request method (GET, POST etc)
+   */
+  abstract isMethod(method: string): boolean;
+  /**
+   * Checks whether or not the method is safe.
+   *
+   * @see https://tools.ietf.org/html/rfc7231#section-4.2.1
+   */
+  abstract isMethodSafe(): boolean;
+  /**
+   * Checks whether or not the method is idempotent.
+   */
+  abstract isMethodIdempotent(): boolean;
+  /**
+   * Checks whether the method is cacheable or not.
+   *
+   * @see https://tools.ietf.org/html/rfc7231#section-4.2.3
+   */
+  abstract isMethodCacheable(): boolean;
+  /**
+   * Returns true if the request is an XMLHttpRequest (AJAX).
+   */
+  abstract isXmlHttpRequest(): boolean;
+  /**
+   * Gets the request "intended" method.
+   *
+   * If the X-HTTP-Method-Override header is set, and if the method is a POST,
+   * then it is used to determine the "real" intended HTTP method.
+   *
+   * The _method request parameter can also be used to determine the HTTP method,
+   * but only if enableHttpMethodParameterOverride() has been called.
+   *
+   * The method is always an uppercased string.
+   *
+   * @see getRealMethod()
+   */
+  abstract getMethod(): RequestMethod;
+  /**
+   * Gets the preferred format for the response by inspecting, in the following order:
+   *   * the request format set using setRequestFormat;
+   *   * the values of the Accept HTTP header.
+   *
+   * Note that if you use this method, you should send the "Vary: Accept" header
+   * in the response to prevent any issues with intermediary HTTP caches.
+   */
+  abstract getPreferredFormat(defaultValue?: string): string | undefined;
+  /**
+   * Gets the format associated with the mime type.
+   */
+  abstract getFormat(mimeType: string): string | undefined;
+  /**
+   * Gets the request format.
+   *
+   * Here is the process to determine the format:
+   *
+   *  * format defined by the user (with setRequestFormat())
+   *  * _format request attribute
+   *  * $default
+   *
+   * @see getPreferredFormat
+   */
+  abstract getRequestFormat(defaultValue?: string): string | undefined;
+  /**
+   * Sets the request format.
+   */
+  abstract setRequestFormat(format: string): void;
+  /**
+   * Gets the "real" request method.
+   *
+   * @see getMethod()
+   */
+  abstract getRealMethod(): RequestMethod;
+  /**
+   * Gets the mime type associated with the format.
+   */
+  abstract getMimeType(format: string): string | undefined;
+  /**
+   * Returns the request body content.
+   *
+   * @param asStream If true, returns a ReadableStream instead of the parsed string
+   * @return {string | ReadableStream | Promise<string | ReadableStream>}
+   */
+  abstract getContent(asStream?: boolean): string | ReadableStream;
+  /**
+   * Gets a "parameter" value from any bag.
+   *
+   * This method is mainly useful for libraries that want to provide some flexibility. If you don't need the
+   * flexibility in controllers, it is better to explicitly get request parameters from the appropriate
+   * public property instead (attributes, query, request).
+   *
+   * Order of precedence: PATH (routing placeholders or custom attributes), GET, POST
+   *
+   * @internal use explicit input sources instead
+   */
+  abstract get(key: string, defaultValue?: any): any;
+  /**
+   * Indicates whether this request originated from a trusted proxy.
+   *
+   * This can be useful to determine whether or not to trust the
+   * contents of a proxy-specific header.
+   */
+  abstract isFromTrustedProxy(): boolean;
+  /**
+   * Returns the path being requested relative to the executed script.
+   *
+   * The path info always starts with a /.
+   *
+   * @return {string} The raw path (i.e. not urldecoded)
+   */
+  abstract getPathInfo(): string;
+}
+//#endregion
+//#region src/Routing/ICompiledRoute.d.ts
+declare class ICompiledRoute {
+  /**
+   * 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 optional params record
+   */
+  getOptionalParams(): Record<string, null>;
+}
+//#endregion
+//#region src/Routing/IRoute.d.ts
+declare abstract class IRoute {
+  /**
+   * The default values for the route.
+   */
+  abstract _defaults: GenericObject;
+  /**
+   * The compiled version of the route.
+   */
+  abstract compiled?: ICompiledRoute;
+  /**
+   * The array of matched parameters.
+   */
+  abstract parameters?: GenericObject;
+  /**
+   * The route action array.
+   */
+  abstract action: RouteActions;
+  /**
+   * The HTTP methods the route responds to.
+   */
+  abstract methods: RouteMethod[];
+  /**
+   * The route path that can be handled by H3.
+   */
+  abstract path: string;
+  /**
+   * The computed gathered middleware.
+   */
+  abstract computedMiddleware?: MiddlewareList;
+  /**
+   * The controller instance.
+   */
+  abstract controller?: Required<IController>;
+  /**
+   * Set the router instance on the route.
+   *
+   * @param router
+   */
+  abstract setRouter(router: any): this;
+  /**
+   * Set the container instance on the route.
+   *
+   * @param container
+   */
+  abstract setContainer(container: IContainer): this;
+  /**
+   * Set the URI that the route responds to.
+   *
+   * @param uri
+   */
+  abstract setUri(uri: string): this;
+  /**
+   * Get the URI associated with the route.
+   */
+  abstract uri(): string;
+  /**
+   * Add a prefix to the route URI.
+   *
+   * @param prefix
+   */
+  abstract prefix(prefix: string): this;
+  /**
+   * Get the name of the route instance.
+   */
+  abstract getName(): string | undefined;
+  /**
+   * Add or change the route name.
+   *
+   * @param  name
+   *
+   * @throws {InvalidArgumentException}
+   */
+  abstract name(name: string): this;
+  /**
+   * Determine whether the route's name matches the given patterns.
+   *
+   * @param patterns
+   */
+  abstract named(...patterns: string[]): boolean;
+  /**
+   * Get the action name for the route.
+   */
+  abstract getActionName(): any;
+  /**
+   * Get the method name of the route action.
+   *
+   * @return string
+   */
+  abstract getActionMethod(): any;
+  /**
+   * Get the action array or one of its properties for the route.
+   * @param key
+   */
+  abstract getAction(key?: string): any;
+  /**
+   * Mark this route as a fallback route.
+   */
+  abstract fallback(): this;
+  /**
+   * Set the fallback value.
+   *
+   * @param  sFallback
+   */
+  abstract setFallback(isFallback: boolean): this;
+  /**
+   * Get the HTTP verbs the route responds to.
+   */
+  abstract getMethods(): RouteMethod[];
+  /**
+   * Determine if the route only responds to HTTP requests.
+   */
+  abstract httpOnly(): boolean;
+  /**
+   * Determine if the route only responds to HTTPS requests.
+   */
+  abstract httpsOnly(): boolean;
+  /**
+   * Get or set the middlewares attached to the route.
+   *
+   * @param  middleware
+   */
+  abstract middleware(): any[];
+  abstract 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
+   */
+  abstract can(ability: string, models?: string | string[]): any[] | this;
+  /**
+   * Set the action array for the route.
+   *
+   * @param action
+   */
+  abstract setAction(action: RouteActions): this;
+  /**
+   * Determine if the route only responds to HTTPS requests.
+   */
+  abstract secure(): boolean;
+  /**
+   * Bind the route to a given request for execution.
+   *
+   * @param request
+   */
+  abstract bind(request: IRequest): this;
+  /**
+   * Get or set the domain for the route.
+   *
+   * @param domain
+   *
+   * @throws {InvalidArgumentException}
+   */
+  abstract domain<D extends string | undefined = undefined>(domain?: D): D extends undefined ? string : this;
+  /**
+   * Get the key / value list of original parameters for the route.
+   *
+   * @throws {LogicException}
+   */
+  abstract originalParameters(): GenericObject;
+  /**
+   * Get the matched parameters object.
+   */
+  abstract getParameters(): GenericObject;
+  /**
+   * Get a given parameter from the route.
+   *
+   * @param  name
+   * @param  defaultParam
+   */
+  abstract parameter(name: string, defaultParam?: any): any;
+  /**
+   * Get the domain defined for the route.
+   */
+  abstract getDomain(): string | undefined;
+  /**
+   * Get the compiled version of the route.
+   */
+  abstract getCompiled(): ICompiledRoute | undefined;
+  /**
+   * Get the binding field for the given parameter.
+   *
+   * @param  parameter
+   */
+  abstract bindingFieldFor(parameter: string | number): string | undefined;
+  /**
+   * Get the binding fields for the route.
+   */
+  abstract getBindingFields(): GenericObject<string>;
+  /**
+   * Set the binding fields for the route.
+   *
+   * @param  bindingFields
+   */
+  abstract setBindingFields(bindingFields: GenericObject<string>): this;
+  /**
+   * Get the parent parameter of the given parameter.
+   *
+   * @param parameter
+   */
+  abstract parentOfParameter(parameter: string): any;
+  /**
+   * Determines if the route allows "trashed" models to be retrieved when resolving implicit model bindings.
+   */
+  abstract allowsTrashedBindings(): boolean;
+  /**
+   * Set a default value for the route.
+   *
+   * @param  key
+   * @param  value
+   */
+  abstract defaults(key: string, value: any): this;
+  /**
+   * Set the default values for the route.
+   *
+   * @param  defaults
+   */
+  abstract setDefaults(defaults: GenericObject): this;
+  /**
+   * Get the optional parameter names for the route.
+   */
+  abstract getOptionalParameterNames(): GenericObject;
+  /**
+   * Get all of the parameter names for the route.
+   */
+  abstract parameterNames(): string[];
+  /**
+   * Flush the cached container instance on the route.
+   */
+  abstract flushController(): void;
+  /**
+   * Get the parameters that are listed in the route / controller signature.
+   *
+   * @param  conditions
+   */
+  abstract signatureParameters(conditions: ClassConstructor | GenericObject): any[];
+  /**
+   * Compile the route once, cache the result, return compiled data
+   */
+  abstract compileRoute(): ICompiledRoute;
+  /**
+   * Set a parameter to the given value.
+   *
+   * @param  name
+   * @param  value
+   */
+  abstract setParameter(name: string, value?: string | GenericObject): void;
+  /**
+   * Unset a parameter on the route if it is set.
+   *
+   * @param  name
+   */
+  abstract forgetParameter(name: string): void;
+  /**
+   * Get the value of the action that should be taken on a missing model exception.
+   */
+  abstract getMissing(): CallableConstructor | undefined;
+  /**
+   * The route path that can be handled by H3.
+   */
+  abstract getPath(): string;
+  /**
+   * Define the callable that should be invoked on a missing model exception.
+   *
+   * @param  missing
+   */
+  abstract missing(missing: CallableConstructor): this;
+  /**
+   * Specify middleware that should be removed from the given route.
+   *
+   * @param  middleware
+   */
+  abstract withoutMiddleware(middleware: any): this;
+  /**
+   * Get the middleware that should be removed from the route.
+   */
+  abstract excludedMiddleware(): any;
+  /**
+   * Get all middleware, including the ones from the controller.
+   */
+  abstract gatherMiddleware(): GenericObject;
+  /**
+   * Indicate that the route should enforce scoping of multiple implicit Eloquent bindings.
+   */
+  abstract scopeBindings(): this;
+  /**
+   * Indicate that the route should not enforce scoping of multiple implicit Eloquent bindings.
+   */
+  abstract withoutScopedBindings(): this;
+  /**
+   * Determine if the route should enforce scoping of multiple implicit Eloquent bindings.
+   */
+  abstract enforcesScopedBindings(): boolean;
+  /**
+   * Determine if the route should prevent scoping of multiple implicit Eloquent bindings.
+   */
+  abstract preventsScopedBindings(): boolean;
+}
+//#endregion
+//#region src/Session/FlashBag.d.ts
+declare class FlashBag {
+  /**
+   * Flash a value for the next request
+   *
+   * @param key Key to store in flash
+   * @param value Value to be flashed
+   */
+  flash(key: string, value: any): void;
+  /**
+   * Store a temporary value for the current request only
+   *
+   * @param key Key to store
+   * @param value Value to store
+   */
+  now(key: string, value: any): void;
+  /**
+   * Reflash all current flash data for another request cycle
+   */
+  reflash(): void;
+  /**
+   * Keep only specific flash keys for the next request
+   *
+   * @param keys Keys to keep
+   */
+  keep(keys: string[]): void;
+  /**
+   * Age flash data at the end of the request
+   *
+   * - Removes old flash data
+   * - Moves new flash data to old
+   * - Clears new flash data
+   */
+  ageFlashData(): void;
+  /**
+   * Get a flash value
+   *
+   * @param key Key to retrieve
+   * @param defaultValue Default value if key doesn't exist
+   * @returns Flash value or default
+   */
+  get(key: string, defaultValue?: any): any;
+  /**
+   * Check if a flash key exists
+   *
+   * @param key Key to check
+   * @returns Boolean indicating existence
+   */
+  has(key: string): boolean;
+  /**
+   * Get all flash data
+   *
+   * @returns Combined flash data
+   */
+  all(): Record<string, any>;
+  /**
+   * Get all flash data keys
+   *
+   * @returns Combined flash data
+   */
+  keys(): string[];
+  /**
+   * Get the raww flash data
+   *
+   * @returns raw flash data
+   */
+  raw(): Record<string, any>;
+  /**
+   * Clear all flash data
+   */
+  clear(): void;
+}
+//#endregion
+//#region src/Session/SessionContract.d.ts
+/**
+ * SessionDriver Interface
+ *
+ * All session drivers must implement these methods to ensure
+ * consistency across different storage mechanisms (memory, files, database, redis).
+ */
+interface SessionDriver {
+  flashBag: FlashBag;
+  /**
+   * Retrieve a value from the session by key.
+   *
+   * @param key
+   * @param defaultValue
+   */
+  get<T = any>(key: string, defaultValue?: any): T | Promise<T>;
+  /**
+   * Store multiple values in the session.
+   *
+   * @param key
+   * @param defaultValue
+   */
+  set(value: Record<string, any>): void | Promise<void>;
+  /**
+   * Retrieve all data from the session including flash
+   *
+   * @returns
+   */
+  getAll<T extends Record<string, any>>(): Promise<T> | T;
+  /**
+   * Store a value in the session.
+   *
+   * @param key
+   * @param value
+   */
+  put(key: string, value: any): void | Promise<void>;
+  /**
+   * Append a value to an array key
+   *
+   * @param key
+   * @param value
+   */
+  push(key: string, value: any): Promise<void> | void;
+  /**
+   * Remove a key from the session.
+   *
+   * @param key
+   */
+  forget(key: string): Promise<void> | void;
+  /**
+   * Determine if a key is present in the session.
+   *
+   * @param key
+   */
+  has(key: string): Promise<boolean> | boolean;
+  /**
+   * Determine if a key exists in the session (even if null).
+   *
+   * @param key
+   */
+  exists(key: string): Promise<boolean> | boolean;
+  /**
+   * Get all data from the session.
+   */
+  all<T extends Record<string, any>>(): Promise<T> | T;
+  /**
+   * Get only a subset of session keys.
+   *
+   * @param keys
+   */
+  only<T extends Record<string, any>>(keys: string[]): Promise<T> | T;
+  /**
+   * Get all session data except the specified keys.
+   *
+   * @param keys
+   */
+  except<T extends Record<string, any>>(keys: string[]): Promise<T> | T;
+  /**
+   * Get and remove an item from the session.
+   *
+   * @param key
+   * @param defaultValue
+   */
+  pull<T = any>(key: string, defaultValue?: any): Promise<T> | T;
+  /**
+   * Increment a numeric session value.
+   *
+   * @param key
+   * @param amount
+   */
+  increment(key: string, amount?: number): Promise<number> | number;
+  /**
+   * Decrement a numeric session value.
+   *
+   * @param key
+   * @param amount
+   */
+  decrement(key: string, amount?: number): Promise<number> | number;
+  /**
+   * Flash a key/value pair for the next request only.
+   *
+   * @param key
+   * @param value
+   */
+  flash(key: string, value: any): Promise<void> | void;
+  /**
+   * Reflash all current flash data for another request cycle.
+   */
+  reflash(): Promise<void> | void;
+  /**
+   * Keep only specific flash data for another request.
+   *
+   * @param keys
+   */
+  keep(keys: string[]): Promise<void> | void;
+  /**
+   * Store data for the current request only (not persisted).
+   *
+   * @param key
+   * @param value
+   */
+  now(key: string, value: any): Promise<void> | void;
+  /**
+   * Regenerate the session ID and optionally persist the data.
+   */
+  regenerate(): Promise<void> | void;
+  /**
+   * Invalidate the session completely and regenerate ID.
+   */
+  invalidate(): Promise<void> | void;
+  /**
+   * Determine if an item is not present in the session.
+   *
+   * @param key
+   */
+  missing(key: string): Promise<boolean> | boolean;
+  /**
+   * Flush all session data
+   */
+  flush(): Promise<void> | void;
+  /**
+   * Age flash data at the end of the request lifecycle.
+   */
+  ageFlashData(): Promise<void> | void;
+}
+interface DriverOption {
+  cwd?: string;
+  dir?: string;
+  table?: string;
+  prefix?: string;
+  client?: any;
+  sessionId?: string;
+  sessionDir?: string;
+}
+/**
+ * A builder function that returns a SessionDriver for a given sessionId.
+ *
+ * The builder receives the sessionId and a driver-specific options bag.
+ */
+type DriverBuilder = (sessionId: string, options?: DriverOption) => SessionDriver;
+//#endregion
+//#region src/Session/ISessionManager.d.ts
+/**
+ * SessionManager
+ *
+ * Handles session initialization, ID generation, and encryption.
+ * Each request gets a unique session namespace tied to its ID.
+ */
+declare class ISessionManager {
+  /**
+   * @param ctx - incoming request http context
+   * @param driverName - registered driver key ('file' | 'database' | 'memory' | 'redis')
+   * @param driverOptions - optional bag for driver-specific options
+   */
+  constructor(ctx: IHttpContext, driverName: 'file' | 'memory' | 'database' | 'redis', driverOptions: DriverOption);
+  /**
+   * Access the current session ID.
+   */
+  id(): string;
+  /**
+   * Retrieve a value from the session
+   *
+   * @param key
+   * @returns
+   */
+  get(key: string, defaultValue?: any): Promise<any> | any;
+  /**
+   * Store a value in the session
+   *
+   * @param key
+   * @param value
+   */
+  set(value: Record<string, any>): Promise<void> | void;
+  /**
+   * Store multiple key/value pairs
+   *
+   * @param values
+   */
+  put(key: string, value: any): void | Promise<void>;
+  /**
+   * Append a value to an array key
+   *
+   * @param key
+   * @param value
+   */
+  push(key: string, value: any): void | Promise<void>;
+  /**
+   * Remove a key from the session
+   *
+   * @param key
+   */
+  forget(key: string): void | Promise<void>;
+  /**
+   * Retrieve all session data
+   *
+   * @returns
+   */
+  all(): Record<string, any> | Promise<Record<string, any>>;
+  /**
+   * Determine if a key exists (even if null).
+   *
+   * @param key
+   * @returns
+   */
+  exists(key: string): Promise<boolean> | boolean;
+  /**
+   * Determine if a key has a non-null value.
+   *
+   * @param key
+   * @returns
+   */
+  has(key: string): Promise<boolean> | boolean;
+  /**
+   * Get only specific keys.
+   *
+   * @param keys
+   * @returns
+   */
+  only(keys: string[]): Record<string, any> | Promise<Record<string, any>>;
+  /**
+   * Return all keys except the specified ones.
+   *
+   * @param keys
+   * @returns
+   */
+  except(keys: string[]): Record<string, any> | Promise<Record<string, any>>;
+  /**
+   * Return and delete a key from the session.
+   *
+   * @param key
+   * @param defaultValue
+   * @returns
+   */
+  pull(key: string, defaultValue?: any): any;
+  /**
+   * Increment a numeric value by amount (default 1).
+   *
+   * @param key
+   * @param amount
+   * @returns
+   */
+  increment(key: string, amount?: number): Promise<number> | number;
+  /**
+   * Decrement a numeric value by amount (default 1).
+   *
+   * @param key
+   * @param amount
+   * @returns
+   */
+  decrement(key: string, amount?: number): number | Promise<number>;
+  /**
+   * Flash a value for next request only.
+   *
+   * @param key
+   * @param value
+   */
+  flash(key: string, value: any): void | Promise<void>;
+  /**
+   * Reflash all flash data for one more cycle.
+   *
+   * @returns
+   */
+  reflash(): void | Promise<void>;
+  /**
+   * Keep only selected flash data.
+   *
+   * @param keys
+   * @returns
+   */
+  keep(keys: string[]): void | Promise<void>;
+  /**
+   * Store data only for current request cycle (not persisted).
+   *
+   * @param key
+   * @param value
+   */
+  now(key: string, value: any): void | Promise<void>;
+  /**
+   * Regenerate session ID and persist data under new ID.
+   */
+  regenerate(): void | Promise<void>;
+  /**
+   * Determine if an item is not present in the session.
+   *
+   * @param key
+   * @returns
+   */
+  missing(key: string): Promise<boolean> | boolean;
+  /**
+   * Flush all session data
+   */
+  flush(): void | Promise<void>;
+  /**
+   * Age flash data at the end of the request lifecycle.
+   *
+   * @returns
+   */
+  ageFlashData(): void | Promise<void>;
+}
+//#endregion
+//#region src/Http/IRequest.d.ts
+type RequestObject$1 = Record<string, any>;
+/**
+ * Interface for the Request contract, defining methods for handling HTTP request data.
+ */
+declare abstract class IRequest<D extends Record<string, any> = Record<string, any>, R extends Record<string, any> = Record<string, any>, U extends Record<string, any> = Record<string, any>> extends IHttpRequest {
+  /**
+   * The current app instance
+   */
+  abstract app: IApplication;
+  /**
+   * Parsed request body
+   */
+  abstract body: unknown;
+  /**
+   * The current Http Context
+   */
+  abstract context: IHttpContext;
+  /**
+   * Gets route parameters.
+   * @returns An object containing route parameters.
+   */
+  abstract params: NonNullable<H3Event['context']['params']>;
+  /**
+   * The request attributes (parameters parsed from the PATH_INFO, ...).
+   */
+  abstract attributes: IParamBag;
+  /**
+   * Gets the request headers.
+   * @returns An object containing request headers.
+   */
+  abstract headers: IHeaderBag;
+  /**
+   * Factory method to create a Request instance from an H3Event.
+   */
+  static create(
+  /**
+   * The current H3 H3Event instance
+   */
+  event: H3Event,
+  /**
+   * The current app instance
+   */
+  app: IApplication): Promise<IRequest>;
+  /**
+   * Sets the parameters for this request.
+   *
+   * This method also re-initializes all properties.
+   *
+   * @param attributes
+   * @param cookies    The COOKIE parameters
+   * @param files      The FILES parameters
+   * @param server     The SERVER parameters
+   * @param content    The raw body data
+   */
+  abstract initialize(): Promise<void>;
+  /**
+   * Retrieve all data from the instance (query + body).
+   */
+  abstract all<T = Record<string, any>>(keys?: string | string[]): T;
+  /**
+   * Retrieve an input item from the request.
+   *
+   * @param key
+   * @param defaultValue
+   * @returns
+   */
+  abstract input<K$1 extends string | undefined>(key?: K$1, defaultValue?: any): K$1 extends undefined ? RequestObject$1 : any;
+  /**
+   * Retrieve a file from the request.
+   *
+   * By default a single `UploadedFile` instance will always be returned by
+   * the method (first file in property when there are multiple), unless
+   * the `expectArray` parameter is set to true, in which case, the method
+   * returns an `UploadedFile[]` array.
+   *
+   * @param key
+   * @param defaultValue
+   * @param expectArray set to true to return an `UploadedFile[]` array.
+   * @returns
+   */
+  abstract file(): Record<string, IUploadedFile>;
+  abstract file(key?: undefined, defaultValue?: any, expectArray?: true): Record<string, IUploadedFile[]>;
+  abstract file(key: string, defaultValue?: any, expectArray?: false | undefined): IUploadedFile;
+  abstract file(key: string, defaultValue?: any, expectArray?: true): IUploadedFile[];
+  /**
+   * Get the user making the request.
+   *
+   * @param  guard
+   */
+  abstract user(guard?: string): U | undefined;
+  /**
+   * Get the route handling the request.
+   *
+   * @param  param
+   * @param  defaultRoute
+   */
+  abstract route(): IRoute;
+  abstract route(param?: string, defaultParam?: any): any;
+  /**
+   * Determine if the uploaded data contains a file.
+   *
+   * @param  key
+   * @return boolean
+   */
+  abstract hasFile(key: string): boolean;
+  /**
+   * Get an object with all the files on the request.
+   */
+  abstract allFiles(): Record<string, IUploadedFile | IUploadedFile[]>;
+  /**
+     * Extract and convert uploaded files from FormData.
+     */
+  abstract convertUploadedFiles(files: Record<string, IUploadedFile | IUploadedFile[]>): Record<string, IUploadedFile | IUploadedFile[]>;
+  /**
+   * Determine if the data contains a given key.
+   *
+   * @param keys
+   * @returns
+   */
+  abstract has(keys: string[] | string): boolean;
+  /**
+   * Determine if the instance is missing a given key.
+   */
+  abstract missing(key: string | string[]): boolean;
+  /**
+   * Get a subset containing the provided keys with values from the instance data.
+   *
+   * @param keys
+   * @returns
+   */
+  abstract only<T = Record<string, any>>(keys: string[]): T;
+  /**
+   * Get all of the data except for a specified array of items.
+   *
+   * @param keys
+   * @returns
+   */
+  abstract except<T = Record<string, any>>(keys: string[]): T;
+  /**
+   * Merges new input data into the current request's input source.
+   *
+   * @param input - An object containing key-value pairs to merge.
+   * @returns this - For fluent chaining.
+   */
+  abstract merge(input: Record<string, any>): this;
+  /**
+   * Merge new input into the request's input, but only when that key is missing from the request.
+   *
+   * @param input
+   */
+  abstract mergeIfMissing(input: Record<string, any>): this;
+  /**
+   * Get the keys for all of the input and files.
+   */
+  abstract keys(): string[];
+  /**
+   * Get an instance of the current session manager
+   *
+   * @param key
+   * @param defaultValue
+   * @returns an instance of the current session manager.
+   */
+  abstract session<K$1 extends string | Record<string, any> | undefined = undefined>(key?: K$1, defaultValue?: any): K$1 extends undefined ? ISessionManager : K$1 extends string ? any : void | Promise<void>;
+  /**
+   * Determine if the request is sending JSON.
+   *
+   * @return bool
+   */
+  abstract isJson(): boolean;
+  /**
+   * Determine if the current request probably expects a JSON response.
+   *
+   * @returns
+   */
+  abstract expectsJson(): boolean;
+  /**
+   * Determine if the current request is asking for JSON.
+   *
+   * @returns
+   */
+  abstract wantsJson(): boolean;
+  /**
+   * Gets a list of content types acceptable by the client browser in preferable order.
+   * @returns {string[]}
+   */
+  abstract getAcceptableContentTypes(): string[];
+  /**
+   * Determine if the request is the result of a PJAX call.
+   *
+   * @return bool
+   */
+  abstract pjax(): boolean;
+  /**
+   * Returns true if the request is an XMLHttpRequest (AJAX).
+   *
+   * @alias isXmlHttpRequest()
+   * @returns {boolean}
+   */
+  abstract ajax(): boolean;
+  /**
+   * Returns true if the request is an XMLHttpRequest (AJAX).
+   */
+  abstract isXmlHttpRequest(): boolean;
+  /**
+   * Returns the value of the requested header.
+   */
+  abstract getHeader(name: string): string | undefined | null;
+  /**
+   * Checks if the request method is of specified type.
+   *
+   * @param method Uppercase request method (GET, POST etc)
+   */
+  abstract isMethod(method: string): boolean;
+  /**
+   * Checks whether or not the method is safe.
+   *
+   * @see https://tools.ietf.org/html/rfc7231#section-4.2.1
+   */
+  abstract isMethodSafe(): boolean;
+  /**
+   * Checks whether or not the method is idempotent.
+   */
+  abstract isMethodIdempotent(): boolean;
+  /**
+   * Checks whether the method is cacheable or not.
+   *
+   * @see https://tools.ietf.org/html/rfc7231#section-4.2.3
+   */
+  abstract isMethodCacheable(): boolean;
+  /**
+   * Gets the request "intended" method.
+   *
+   * If the X-HTTP-Method-Override header is set, and if the method is a POST,
+   * then it is used to determine the "real" intended HTTP method.
+   *
+   * The _method request parameter can also be used to determine the HTTP method,
+   * but only if enableHttpMethodParameterOverride() has been called.
+   *
+   * The method is always an uppercased string.
+   *
+   * @see getRealMethod()
+   */
+  abstract getMethod(): RequestMethod;
+  /**
+   * Gets the "real" request method.
+   *
+   * @see getMethod()
+   */
+  abstract getRealMethod(): RequestMethod;
+  /**
+   * Get the client IP address.
+   */
+  abstract ip(): string | undefined;
+  /**
+   * Get the flashed input from previous request
+   *
+   * @param key
+   * @param defaultValue
+   * @returns
+   */
+  abstract old(): Promise<Record<string, any>>;
+  abstract old(key: string, defaultValue?: any): Promise<any>;
+  /**
+   * Get a URI instance for the request.
+   */
+  abstract uri(): unknown;
+  /**
+   * Get the root URL for the application.
+   *
+   * @return string
+   */
+  abstract root(): string;
+  /**
+   * Get the URL (no query string) for the request.
+   *
+   * @return string
+   */
+  abstract url(): string;
+  /**
+   * Get the full URL for the request.
+   */
+  abstract fullUrl(): string;
+  /**
+   * Get the current path info for the request.
+   */
+  abstract path(): string;
+  /**
+   * Return the Request instance.
+   */
+  abstract instance(): this;
+  /**
+   * Get the request method.
+   */
+  abstract method(): RequestMethod;
+  /**
+   * Get the JSON payload for the request.
+   *
+   * @param  key
+   * @param  defaultValue
+   * @return {InputBag}
+   */
+  abstract json<K$1 extends string | undefined = undefined>(key?: string, defaultValue?: any): K$1 extends undefined ? IParamBag : any;
+  /**
+   * Get the user resolver callback.
+   */
+  abstract getUserResolver(): (gaurd?: string) => U | undefined;
+  /**
+   * Set the user resolver callback.
+   *
+   * @param  callback
+   */
+  abstract setUserResolver(callback: (gaurd?: string) => U): this;
+  /**
+   * Get the route resolver callback.
+   */
+  abstract getRouteResolver(): () => IRoute | undefined;
+  /**
+   * Set the route resolver callback.
+   *
+   * @param  callback
+   */
+  abstract setRouteResolver(callback: () => IRoute): this;
+  /**
+   * Get the bearer token from the request headers.
+   */
+  abstract bearerToken(): string | undefined;
+  /**
+   * Retrieve a request payload item from the request.
+   *
+   * @param  key
+   * @param  default
+   */
+  abstract post(key?: string, defaultValue?: any): any;
+  /**
+   * Determine if a header is set on the request.
+   *
+   * @param  key
+   */
+  abstract hasHeader(key: string): boolean;
+  /**
+   * Retrieve a header from the request.
+   *
+   * @param  key
+   * @param  default
+   */
+  abstract header(key?: string, defaultValue?: any): any;
+  /**
+   * Determine if a cookie is set on the request.
+   *
+   * @param  string  $key
+   */
+  abstract hasCookie(key: string): boolean;
+  /**
+   * Retrieve a cookie from the request.
+   *
+   * @param  key
+   * @param  default
+   */
+  abstract cookie(key?: string, defaultValue?: any): any;
+  /**
+   * Retrieve a query string item from the request.
+   *
+   * @param  key
+   * @param  default
+   */
+  abstract query(key?: string, defaultValue?: any): any;
+  /**
+   * Retrieve a server variable from the request.
+   *
+   * @param  key
+   * @param  default
+   */
+  abstract server(key?: string, defaultValue?: any): any;
+  /**
+   * Returns the request body content.
+   *
+   * @param asStream If true, returns a ReadableStream instead of the parsed string
+   * @return {string | ReadableStream | Promise<string | ReadableStream>}
+   */
+  abstract getContent(asStream?: boolean): string | ReadableStream;
+  /**
+   * Gets a "parameter" value from any bag.
+   *
+   * This method is mainly useful for libraries that want to provide some flexibility. If you don't need the
+   * flexibility in controllers, it is better to explicitly get request parameters from the appropriate
+   * public property instead (attributes, query, request).
+   *
+   * Order of precedence: PATH (routing placeholders or custom attributes), GET, POST
+   *
+   * @internal use explicit input sources instead
+   */
+  abstract get(key: string, defaultValue?: any): any;
+  /**
+   * Validate the incoming request data
+   *
+   * @param data
+   * @param rules
+   * @param messages
+   */
+  abstract validate(rules: R, messages?: Partial<Record<string, string>>): Promise<D>;
+  /**
+   * Enables support for the _method request parameter to determine the intended HTTP method.
+   *
+   * Be warned that enabling this feature might lead to CSRF issues in your code.
+   * Check that you are using CSRF tokens when required.
+   * If the HTTP method parameter override is enabled, an html-form with method "POST" can be altered
+   * and used to send a "PUT" or "DELETE" request via the _method request parameter.
+   * If these methods are not protected against CSRF, this presents a possible vulnerability.
+   *
+   * The HTTP method can only be overridden when the real HTTP method is POST.
+   */
+  static enableHttpMethodParameterOverride(): void;
+  /**
+   * Checks whether support for the _method request parameter is enabled.
+   */
+  static getHttpMethodParameterOverride(): boolean;
+  /**
+   * Dump the items.
+   *
+   * @param  keys
+   * @return this
+   */
+  abstract dump(...keys: any[]): this;
+  /**
+   * Get the base event
+   */
+  abstract getEvent(): H3Event;
+  abstract getEvent<K$1 extends DotNestedKeys<H3Event>>(key: K$1): DotNestedValue<H3Event, K$1>;
+}
+//#endregion
+//#region src/Http/IHttpResponse.d.ts
+/**
+ * Interface for the Response contract, defining methods for handling HTTP responses.
+ */
+declare abstract class IHttpResponse {
+  /**
+   * Set HTTP status code.
+   */
+  abstract setStatusCode(code: number, text?: string): this;
+  /**
+   * Retrieves the status code for the current web response.
+   */
+  abstract getStatusCode(): number;
+  /**
+   * Sets the response charset.
+   */
+  abstract setCharset(charset: string): this;
+  /**
+   * Retrieves the response charset.
+   */
+  abstract getCharset(): string | undefined;
+  /**
+   * Returns true if the response may safely be kept in a shared (surrogate) cache.
+   *
+   * Responses marked "private" with an explicit Cache-Control directive are
+   * considered uncacheable.
+   *
+   * Responses with neither a freshness lifetime (Expires, max-age) nor cache
+   * validator (Last-Modified, ETag) are considered uncacheable because there is
+   * no way to tell when or how to remove them from the cache.
+   *
+   * Note that RFC 7231 and RFC 7234 possibly allow for a more permissive implementation,
+   * for example "status codes that are defined as cacheable by default [...]
+   * can be reused by a cache with heuristic expiration unless otherwise indicated"
+   * (https://tools.ietf.org/html/rfc7231#section-6.1)
+   *
+   * @final
+   */
+  abstract isCacheable(): boolean;
+  /**
+   * Returns true if the response is "fresh".
+   *
+   * Fresh responses may be served from cache without any interaction with the
+   * origin. A response is considered fresh when it includes a Cache-Control/max-age
+   * indicator or Expires header and the calculated age is less than the freshness lifetime.
+   */
+  abstract isFresh(): boolean;
+  /**
+   * Returns true if the response includes headers that can be used to validate
+   * the response with the origin server using a conditional GET request.
+   */
+  abstract isValidateable(): boolean;
+  /**
+   * Sets the response content.
+   */
+  abstract setContent(content?: any): this;
+  /**
+   * Gets the current response content.
+   */
+  abstract getContent(): any;
+  /**
+   * Set a header.
+   */
+  abstract setHeader(name: string, value: string): this;
+  /**
+   * Sets the HTTP protocol version (1.0 or 1.1).
+   */
+  abstract setProtocolVersion(version: string): this;
+  /**
+   * Gets the HTTP protocol version.
+   */
+  abstract getProtocolVersion(): string;
+  /**
+   * Marks the response as "private".
+   *
+   * It makes the response ineligible for serving other clients.
+   */
+  abstract setPrivate(): this;
+  /**
+   * Marks the response as "public".
+   *
+   * It makes the response eligible for serving other clients.
+   */
+  abstract setPublic(): this;
+  /**
+   * Returns the Date header as a DateTime instance.
+   * @throws {RuntimeException} When the header is not parseable
+   */
+  abstract getDate(): any;
+  /**
+  * Returns the age of the response in seconds.
+  *
+  * @final
+  */
+  abstract getAge(): number;
+  /**
+   * Marks the response stale by setting the Age header to be equal to the maximum age of the response.
+   */
+  abstract expire(): this;
+  /**
+   * Returns the value of the Expires header as a DateTime instance.
+   *
+   * @final
+   */
+  abstract getExpires(): any;
+  /**
+   * Returns the number of seconds after the time specified in the response's Date
+   * header when the response should no longer be considered fresh.
+   *
+   * First, it checks for a s-maxage directive, then a max-age directive, and then it falls
+   * back on an expires header. It returns null when no maximum age can be established.
+   */
+  abstract getMaxAge(): number | undefined;
+  /**
+   * Sets the number of seconds after which the response should no longer be considered fresh.
+   *
+   * This method sets the Cache-Control max-age directive.
+   */
+  abstract setMaxAge(value: number): this;
+  /**
+   * Sets the number of seconds after which the response should no longer be returned by shared caches when backend is down.
+   *
+   * This method sets the Cache-Control stale-if-error directive.
+   */
+  abstract setStaleIfError(value: number): this;
+  /**
+   * Sets the number of seconds after which the response should no longer return stale content by shared caches.
+   *
+   * This method sets the Cache-Control stale-while-revalidate directive.
+   */
+  abstract setStaleWhileRevalidate(value: number): this;
+  /**
+   * Returns the response's time-to-live in seconds.
+   *
+   * It returns null when no freshness information is present in the response.
+   *
+   * When the response's TTL is 0, the response may not be served from cache without first
+   * revalidating with the origin.
+   *
+   * @final
+   */
+  abstract getTtl(): number | undefined;
+  /**
+   * Sets the response's time-to-live for shared caches in seconds.
+   *
+   * This method adjusts the Cache-Control/s-maxage directive.
+   */
+  abstract setTtl(seconds: number): this;
+  /**
+   * Sets the response's time-to-live for private/client caches in seconds.
+   *
+   * This method adjusts the Cache-Control/max-age directive.
+   */
+  abstract setClientTtl(seconds: number): this;
+  /**
+   * Sets the number of seconds after which the response should no longer be considered fresh by shared caches.
+   *
+   * This method sets the Cache-Control s-maxage directive.
+   */
+  abstract setSharedMaxAge(value: number): this;
+  /**
+   * Returns the Last-Modified HTTP header as a DateTime instance.
+   *
+   * @throws \RuntimeException When the HTTP header is not parseable
+   *
+   * @final
+   */
+  abstract getLastModified(): any;
+  /**
+   * Sets the Last-Modified HTTP header with a DateTime instance.
+   *
+   * Passing null as value will remove the header.
+   *
+   * @return $this
+   *
+   * @final
+   */
+  abstract setLastModified(date?: any): this;
+  /**
+   * Returns the literal value of the ETag HTTP header.
+   */
+  abstract getEtag(): string | null;
+  /**
+   * Sets the ETag value.
+   *
+   * @param etag The ETag unique identifier or null to remove the header
+   * @param weak Whether you want a weak ETag or not
+   */
+  abstract setEtag(etag?: string, weak?: boolean): this;
+  /**
+   * Sets the response's cache headers (validation and/or expiration).
+   *
+   * Available options are: must_revalidate, no_cache, no_store, no_transform, public, private, proxy_revalidate, max_age, s_maxage, immutable, last_modified and etag.
+   *
+   * @throws {InvalidArgumentException}
+   */
+  abstract setCache(options: any): this;
+  /**
+   * Modifies the response so that it conforms to the rules defined for a 304 status code.
+   *
+   * This sets the status, removes the body, and discards any headers
+   * that MUST NOT be included in 304 responses.
+   * @see https://tools.ietf.org/html/rfc2616#section-10.3.5
+   */
+  abstract setNotModified(): this;
+  /**
+   * Add an array of headers to the response.
+   *
+   */
+  abstract withHeaders(headers: any): this;
+  /**
+   * Set the exception to attach to the response.
+   */
+  abstract withException(e: Error): this;
+  /**
+   * Throws the response in a HttpResponseException instance.
+   *
+   * @throws {HttpResponseException}
+   */
+  abstract throwResponse(): void;
+  /**
+   * Is response invalid?
+   *
+   * @see https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
+   */
+  abstract isInvalid(): boolean;
+  /**
+   * Is response informative?
+   */
+  abstract isInformational(): boolean;
+  /**
+   * Is response successful?
+   */
+  abstract isSuccessful(): boolean;
+  /**
+   * Is the response a redirect?
+   */
+  abstract isRedirection(): boolean;
+  /**
+   * Is there a client error?
+   */
+  abstract isClientError(): boolean;
+  /**
+   * Was there a server side error?
+   */
+  abstract isServerError(): boolean;
+  /**
+   * Is the response OK?
+   */
+  abstract isOk(): boolean;
+  /**
+   * Is the response forbidden?
+   */
+  abstract isForbidden(): boolean;
+  /**
+   * Is the response a not found error?
+   */
+  abstract isNotFound(): boolean;
+  /**
+   * Is the response a redirect of some form?
+   */
+  abstract isRedirect(location?: string | null): boolean;
+  /**
+   * Is the response empty?
+   */
+  abstract isEmpty(): boolean;
+  /**
+   * Apply headers before sending response.
+   */
+  abstract sendHeaders(statusCode?: number): this;
+  /**
+   * Prepares the Response before it is sent to the client.
+   *
+   * This method tweaks the Response to ensure that it is
+   * compliant with RFC 2616. Most of the changes are based on
+   * the Request that is "associated" with this Response.
+   **/
+  abstract prepare(request: IRequest): this;
+}
+//#endregion
+//#region src/Http/IResponse.d.ts
+/**
+ * Interface for the Response contract, defining methods for handling HTTP responses.
+ */
+declare abstract class IResponse extends IHttpResponse {
+  /**
+   * The current app instance
+   */
+  abstract app: IApplication;
+  /**
+   * The current Http Context
+   */
+  abstract context: IHttpContext;
+  /**
+   * Sends content for the current web response.
+   */
+  abstract sendContent(type?: 'html' | 'json' | 'text' | 'xml', parse?: boolean): IResponsable;
+  /**
+   * Sends content for the current web response.
+   */
+  abstract send(type?: 'html' | 'json' | 'text' | 'xml'): IResponsable;
+  /**
+   * Use an edge view as content
+   *
+   * @param viewPath The path to the view file
+   * @param send if set to true, the content will be returned, instead of the Response instance
+   * @returns
+   */
+  abstract view(viewPath: string, data?: Record<string, any> | undefined): Promise<this>;
+  abstract view(viewPath: string, data: Record<string, any> | undefined, parse: boolean): Promise<IResponsable>;
+  /**
+   *
+   * Parse content as edge view
+   *
+   * @param content The content to serve
+   * @param send if set to true, the content will be returned, instead of the Response instance
+   * @returns
+   */
+  abstract viewTemplate(content: string, data?: Record<string, any> | undefined): Promise<this>;
+  abstract viewTemplate(content: string, data: Record<string, any> | undefined, parse: boolean): Promise<IResponsable>;
+  /**
+   *
+   * @param content The content to serve
+   * @param send if set to true, the content will be returned, instead of the Response instance
+   * @returns
+   */
+  abstract html(content?: string): this;
+  abstract html(content: string, parse: boolean): IResponsable;
+  /**
+   * Send a JSON response.
+   */
+  abstract json<T = unknown>(data?: T): this;
+  abstract json<T = unknown>(data: T, parse: boolean): T;
+  /**
+   * Send plain text.
+   */
+  abstract text(content?: string): this;
+  abstract text(content: string, parse: boolean): IResponsable;
+  /**
+   * Send plain xml.
+   */
+  abstract xml(data?: string): this;
+  abstract xml(data: string, parse: boolean): IResponsable;
+  /**
+   * Redirect to another URL.
+   */
+  abstract redirect(location: string, status?: number, statusText?: string | undefined): this;
+  /**
+   * Dump the response.
+   */
+  abstract dump(): this;
+  /**
+   * Get the base event
+   */
+  abstract getEvent(): H3Event;
+  abstract getEvent<K$1 extends DotNestedKeys$1<H3Event>>(key: K$1): DotNestedValue$1<H3Event, K$1>;
+}
+declare abstract class IResponsable extends HTTPResponse {
+  abstract toResponse(request: IRequest): IResponse;
+  abstract HTTPResponse(): HTTPResponse;
+}
+type ResponsableType<X = string> = IResponse | IResponsable | ConcreteConstructor<ClassConstructor> | string | X;
+//#endregion
+//#region src/Queue/Utils.d.ts
+interface JobPayload {
+  maxTries?: number;
+  maxExceptions?: number;
+  failOnTimeout?: boolean;
+  timeout?: number;
+  retryUntil?: number;
+  job: string;
+  backoff?: number;
+  delay?: number;
+  data?: any;
+  uuid?: string;
+}
+//#endregion
+//#region src/Events/IDispatcher.d.ts
+declare abstract class IDispatcher {
+  /**
+   * Register an event listener with the dispatcher.
+   *
+   * @param  events
+   * @param listener
+   */
+  abstract listen(events: AppEvent | AppEvent[] | string | string[], listener?: AppListener | AppListener[] | string | string[]): void;
+  /**
+   * Determine if a given event has listeners.
+   *
+   * @param  eventName
+   * @return bool
+   */
+  abstract hasListeners(eventName: string): any[];
+  /**
+   * Determine if the given event has any wildcard listeners.
+   *
+   * @param  eventName
+   */
+  abstract hasWildcardListeners(eventName: string): boolean;
+  /**
+   * Register an event and payload to be fired later.
+   *
+   * @para  event
+   * @param payload
+   * @return void
+   */
+  abstract push(event: string, payload?: Record<string, any> | any[]): void;
+  /**
+   * Flush a set of pushed events.
+   *
+   * @param event
+   */
+  abstract flush(event: string): void;
+  /**
+   * Fire an event until the first non-null response is returned.
+   *
+   * @param event
+   * @param  mixed  payload
+   * @return mixed
+   */
+  abstract until(event: AppEvent, payload?: JobPayload): void;
+  /**
+   * Fire an event and call the listeners.
+   *
+   * @param event
+   * @param payload
+   * @param halt
+   */
+  abstract dispatch(event: Record<string, any> | string, payload?: Record<string, any> | any[], halt?: boolean): void;
+  /**
+   * Remove a set of listeners from the dispatcher.
+   *
+   * @param  event
+   */
+  abstract forget(event: string): void;
+  /**
+   * Forget all of the pushed listeners.
+   *
+   * @return void
+   */
+  abstract forgetPushed(): void;
+  /**
+   * Set the queue resolver implementation.
+   *
+   * @param  callable  $resolver
+   * @return this
+   */
+  abstract setQueueResolver(resolver: (...a: any[]) => any): this;
+  /**
+   * Set the database transaction manager resolver implementation.
+   *
+   * @param resolver
+   */
+  abstract setTransactionManagerResolver(resolver: (...a: any[]) => any): this;
+  /**
+   * Execute the given callback while deferring events, then dispatch all deferred events.
+   *
+   * @param  callback
+   * @param  events
+   */
+  abstract defer(callback: (...a: any[]) => any, events: AppEvent[]): any;
+  /**
+   * Gets the raw, unprepared listeners.
+   *
+   * @return array
+   */
+  abstract getRawListeners(): Record<string, any[]>;
+}
+//#endregion
+//#region src/Routing/IAbstractRouteCollection.d.ts
+declare abstract class IAbstractRouteCollection {
+  static verbs: RouteMethod[];
+  abstract get(): IRoute[];
+  abstract get(method: string): Record<string, IRoute>;
+  abstract getRoutes(): IRoute[];
+}
+//#endregion
+//#region src/Routing/IRouteCollection.d.ts
+declare class IRouteCollection extends IAbstractRouteCollection {
+  /**
+   * Add a IRoute instance to the collection.
+   */
+  add(route: IRoute): IRoute;
+  /**
+   * 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: IRequest): IRoute;
+  /**
+   *
+   * Get routes from the collection by method.
+   *
+   * @param method
+   */
+  get(): IRoute[];
+  get(method: string): Record<string, IRoute>;
+  /**
+   * Determine if the route collection contains a given named route.
+   */
+  hasNamedRoute(name: string): boolean;
+  /**
+   * Get a route instance by its name.
+   */
+  getByName(name: string): IRoute | undefined;
+  /**
+   * Get a route instance by its controller action.
+   */
+  getByAction(action: string): IRoute | undefined;
+  /**
+   * Get all of the routes in the collection.
+   */
+  getRoutes(): IRoute[];
+  /**
+   * Get all of the routes keyed by their HTTP verb / method.
+   */
+  getRoutesByMethod(): Record<string, Record<string, IRoute>>;
+  /**
+   * Get all of the routes keyed by their name.
+   */
+  getRoutesByName(): Record<string, IRoute>;
+}
+//#endregion
+//#region src/Routing/IPendingResourceRegistration.d.ts
+declare abstract class IPendingResourceRegistration {
+  /**
+   * Set the methods the controller should apply to.
+   *
+   * @param  methods
+   */
+  abstract only(...methods: ResourceMethod[]): this;
+  /**
+   * Set the methods the controller should exclude.
+   *
+   * @param  methods
+   */
+  abstract except(...methods: ResourceMethod[]): this;
+  /**
+   * Set the route names for controller actions.
+   *
+   * @param  names
+   */
+  abstract names(names: Record<string, string>): this;
+  /**
+   * Set the route name for a controller action.
+   *
+   * @param  method
+   * @param  name
+   */
+  abstract setName(method: string, name: string): this;
+  /**
+   * Override the route parameter names.
+   *
+   * @param  parameters
+   */
+  abstract parameters(parameters: any): this;
+  /**
+   * Override a route parameter's name.
+   *
+   * @param  previous
+   * @param  newValue
+   */
+  abstract parameter(previous: string, newValue: any): this;
+  /**
+   * Add middleware to the resource routes.
+   *
+   * @param  middleware
+   */
+  abstract middleware(middleware: MiddlewareList | MiddlewareIdentifier): this;
+  /**
+   * Specify middleware that should be added to the specified resource routes.
+   *
+   * @param  methods
+   * @param  middleware
+   */
+  abstract middlewareFor(methods: ResourceMethod[], middleware: MiddlewareList | MiddlewareIdentifier): this;
+  /**
+   * Specify middleware that should be removed from the resource routes.
+   *
+   * @param  middleware
+   */
+  abstract withoutMiddleware(middleware: MiddlewareList | MiddlewareIdentifier): this;
+  /**
+   * Specify middleware that should be removed from the specified resource routes.
+   *
+   * @param  methods
+   * @param  middleware
+   */
+  abstract withoutMiddlewareFor(methods: ResourceMethod[], middleware: MiddlewareList | MiddlewareIdentifier): this;
+  /**
+   * Add "where" constraints to the resource routes.
+   *
+   * @param  wheres
+   */
+  abstract where(wheres: any): this;
+  /**
+   * Indicate that the resource routes should have "shallow" nesting.
+   *
+   * @param shallow
+   */
+  abstract shallow(shallow?: boolean): this;
+  /**
+   * Define the callable that should be invoked on a missing model exception.
+   *
+   * @param  callback
+   */
+  abstract missing(callback: string): this;
+  /**
+   * Indicate that the resource routes should be scoped using the given binding fields.
+   *
+   * @param  fields
+   */
+  abstract scoped(fields?: string[]): this;
+  /**
+   * Define which routes should allow "trashed" models to be retrieved when resolving implicit model bindings.
+   *
+   * @param  array  methods
+   */
+  abstract withTrashed(methods?: never[]): this;
+  /**
+   * Register the singleton resource route.
+   */
+  abstract register(): IRouteCollection | undefined;
+}
+//#endregion
+//#region src/Routing/IPendingSingletonResourceRegistration.d.ts
+declare abstract class IPendingSingletonResourceRegistration {
+  /**
+   * Set the methods the controller should apply to.
+   *
+   * @param  methods
+   */
+  abstract only(...methods: ResourceMethod[]): this;
+  /**
+   * Set the methods the controller should exclude.
+   *
+   * @param  methods
+   */
+  abstract except(...methods: ResourceMethod[]): this;
+  /**
+   * Indicate that the resource should have creation and storage routes.
+   *
+   * @return  this
+   */
+  abstract creatable(): this;
+  /**
+   * Indicate that the resource should have a deletion route.
+   *
+   * @return  this
+   */
+  abstract destroyable(): this;
+  /**
+   * Set the route names for controller actions.
+   *
+   * @param  names
+   */
+  abstract names(names: Record<string, string>): this;
+  /**
+   * Set the route name for a controller action.
+   *
+   * @param  method
+   * @param  name
+   */
+  abstract setName(method: string, name: string): this;
+  /**
+   * Override the route parameter names.
+   *
+   * @param  parameters
+   */
+  abstract parameters(parameters: any): this;
+  /**
+   * Override a route parameter's name.
+   *
+   * @param  previous
+   * @param  newValue
+   */
+  abstract parameter(previous: string, newValue: any): this;
+  /**
+   * Add middleware to the resource routes.
+   *
+   * @param  middleware
+   */
+  abstract middleware(middleware: MiddlewareList | MiddlewareIdentifier): this;
+  /**
+   * Specify middleware that should be added to the specified resource routes.
+   *
+   * @param  methods
+   * @param  middleware
+   */
+  abstract middlewareFor(methods: ResourceMethod[], middleware: MiddlewareList | MiddlewareIdentifier): this;
+  /**
+   * Specify middleware that should be removed from the resource routes.
+   *
+   * @param  middleware
+   */
+  abstract withoutMiddleware(middleware: MiddlewareList | MiddlewareIdentifier): this;
+  /**
+   * Specify middleware that should be removed from the specified resource routes.
+   *
+   * @param  methods
+   * @param  middleware
+   */
+  abstract withoutMiddlewareFor(methods: ResourceMethod[], middleware: MiddlewareList | MiddlewareIdentifier): this;
+  /**
+   * Add "where" constraints to the resource routes.
+   *
+   * @param  wheres
+   */
+  abstract where(wheres: any): this;
+  /**
+   * Register the singleton resource route.
+   */
+  abstract register(): IAbstractRouteCollection | undefined;
+}
+//#endregion
+//#region src/Routing/IRouter.d.ts
+/**
+ * Interface for the Router contract, defining methods for HTTP routing.
+ */
+declare abstract class IRouter {
+  /**
+   * The priority-sorted list of middleware.
+   *
+   * Forces the listed middleware to always be in the given order.
+   */
+  abstract middlewarePriority: MiddlewareList;
+  /**
+   * All of the verbs supported by the router.
+   */
+  static verbs: RouteMethod[];
+  /**
+   * Get the currently dispatched route instance.
+   */
+  abstract getCurrentRoute(): IRoute | undefined;
+  /**
+   * Check if a route with the given name exists.
+   *
+   * @param name
+   */
+  abstract has(...name: string[]): boolean;
+  /**
+   * Get the current route name.
+   */
+  abstract currentRouteName(): string | undefined;
+  /**
+   * Alias for the "currentRouteNamed" method.
+   *
+   * @param  patterns
+   */
+  abstract is(...patterns: string[]): boolean;
+  /**
+   * Determine if the current route matches a pattern.
+   *
+   * @param patterns
+   */
+  abstract currentRouteNamed(...patterns: string[]): boolean;
+  /**
+   * Get the underlying route collection.
+   */
+  abstract getRoutes(): IRouteCollection;
+  /**
+   * Create a new IRoute object.
+   *
+   * @param  methods
+   * @param  uri
+   * @param  action
+   */
+  abstract newRoute(methods: RouteMethod | RouteMethod[], uri: string, action: ActionInput): IRoute;
+  /**
+   * Dispatch the request to the application.
+   *
+   * @param request
+   */
+  abstract dispatch(request: IRequest): Promise<IResponse>;
+  /**
+   * Dispatch the request to a route and return the response.
+   *
+   * @param request
+   */
+  abstract dispatchToRoute(request: IRequest): Promise<IResponse>;
+  /**
+   * 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
+   */
+  abstract get<C extends typeof IController>(uri: string, action: ActionInput<C>): IRoute;
+  /**
+   * 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
+   */
+  abstract post<C extends typeof IController>(uri: string, action: ActionInput<C>): IRoute;
+  /**
+   * 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
+   */
+  abstract put<C extends typeof IController>(uri: string, action: ActionInput<C>): IRoute;
+  /**
+   * 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
+   */
+  abstract patch<C extends typeof IController>(uri: string, action: ActionInput<C>): IRoute;
+  /**
+   * 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
+   */
+  abstract delete<C extends typeof IController>(uri: string, action: ActionInput<C>): IRoute;
+  /**
+   * 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.
+   */
+  abstract match<C extends typeof IController>(methods: RouteMethod | RouteMethod[], uri: string, action: ActionInput<C>): IRoute;
+  /**
+   * Route a resource to a controller.
+   *
+   * @param  name
+   * @param  controller
+   * @param  options
+   */
+  abstract resource<C extends typeof IController>(name: string, controller: C, options: ResourceOptions): IPendingResourceRegistration;
+  /**
+   * Register an array of API resource controllers.
+   *
+   * @param  resources
+   * @param  options
+   */
+  abstract apiResources(resources: GenericObject<typeof IController>, options: ResourceOptions): void;
+  /**
+   * API Resource support
+   *
+   * @param path
+   * @param controller
+   */
+  abstract apiResource<C extends typeof IController>(name: string, controller: C, options: ResourceOptions): IPendingResourceRegistration;
+  /**
+   * Register an array of singleton resource controllers.
+   *
+   * @param  singletons
+   * @param  options
+   */
+  abstract singletons(singletons: GenericObject<typeof IController>, options: ResourceOptions): void;
+  /**
+   * Route a singleton resource to a controller.
+   *
+   * @param  name
+   * @param  controller
+   * @param  options
+   */
+  abstract singleton<C extends typeof IController>(name: string, controller: C, options: ResourceOptions): IPendingSingletonResourceRegistration;
+  /**
+   * Register an array of API singleton resource controllers.
+   *
+   * @param  singletons
+   * @param  options
+   */
+  abstract apiSingletons(singletons: GenericObject<typeof IController>, options: ResourceOptions): void;
+  /**
+   * Route an API singleton resource to a controller.
+   *
+   * @param  name
+   * @param  controller
+   * @param  options
+   */
+  abstract apiSingleton<C extends typeof IController>(name: string, controller: C, options: ResourceOptions): IPendingSingletonResourceRegistration;
+  /**
+   * Grouping
+   *
+   * @param options
+   * @param callback
+   */
+  /**
+   * Create a route group with shared attributes.
+   *
+   * @param  attributes
+   * @param  routes
+   */
+  abstract group<C extends ((_e: this) => void) | string>(attributes: RouteActions, routes: C | C[]): this;
+  /**
+   * Merge the given array with the last group stack.
+   *
+   * @param  newItems
+   * @param  prependExistingPrefix
+   */
+  abstract mergeWithLastGroup(newItems: RouteActions, prependExistingPrefix?: boolean): RouteActions;
+  /**
+   * Get the prefix from the last group on the stack.
+   */
+  abstract getLastGroupPrefix(): any;
+  /**
+   * Determine if the router currently has a group stack.
+   */
+  abstract hasGroupStack(): boolean;
+  /**
+   * Set the name of the current route
+   *
+   * @param name
+   */
+  abstract name(name: string): this;
+  /**
+   * Registers middleware for a specific path.
+   * @param path - The path to apply the middleware.
+   * @param handler - The middleware handler.
+   * @param opts - Optional middleware options.
+   */
+  abstract h3middleware(path: string | IMiddleware[] | Middleware, handler?: Middleware | MiddlewareOptions, opts?: MiddlewareOptions): this;
+  /**
+   * Get all of the defined middleware short-hand names.
+   */
+  abstract getMiddleware(): GenericObject;
+  /**
+   * Register a short-hand name for a middleware.
+   *
+   * @param  name
+   * @param  class
+   */
+  abstract aliasMiddleware(name: string, cls: IMiddleware): this;
+  /**
+   * Gather the middleware for the given route with resolved class names.
+   *
+   * @param  route
+   */
+  abstract gatherRouteMiddleware(route: IRoute): any;
+  /**
+   * Resolve a flat array of middleware classes from the provided array.
+   *
+   * @param middleware
+   * @param excluded
+   */
+  abstract resolveMiddleware(middleware: MiddlewareList, excluded: MiddlewareList): any;
+  /**
+   * Register a group of middleware.
+   *
+   * @param  name
+   * @param  middleware
+   */
+  abstract middlewareGroup(name: string, middleware: MiddlewareList): this;
+  /**
+   * Register a group of middleware.
+   *
+   * @param  name
+   * @param  middleware
+   */
+  abstract middlewareGroup(name: string, middleware: MiddlewareList): this;
+  /**
+   * Create a response instance from the given value.
+   *
+   * @param  request
+   * @param  response
+   */
+  abstract prepareResponse(request: IRequest, response: ResponsableType): Promise<IResponse>;
+  /**
+   * Substitute the route bindings onto the route.
+   *
+   * @param  route
+   *
+   * @throws {ModelNotFoundException<IModel>}
+   */
+  abstract substituteBindings(route: IRoute): Promise<IRoute>;
+  /**
+   * Substitute the implicit route bindings for the given route.
+   *
+   * @param  route
+   *
+   * @throws {ModelNotFoundException<IModel>}
+   */
+  abstract substituteImplicitBindings(route: IRoute): Promise<any | undefined>;
+  /**
+   * Register a callback to run after implicit bindings are substituted.
+   *
+   * @param  callback
+   */
+  abstract substituteImplicitBindingsUsing(callback: CallableConstructor): this;
+}
+//#endregion
+//#region src/Utilities/PathLoader.d.ts
+declare class PathLoader {
+  /**
+   * Dynamically retrieves a path property from the class.
+   * Any property ending with "Path" is accessible automatically.
+   *
+   * @param name - The base name of the path property
+   * @param prefix - The base path to prefix to the path
+   * @returns
+   */
+  getPath(name: IPathName, prefix?: string): string;
+  /**
+   * Programatically set the paths.
+   *
+   * @param name - The base name of the path property
+   * @param path - The new path
+   * @param base - The base path to include to the path
+   */
+  setPath(name: IPathName, path: string, base?: string): void;
+}
+//#endregion
+//#region src/Utilities/BindingsContract.d.ts
+type RemoveIndexSignature<T> = { [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K] };
+type Bindings = {
+  [key: string]: any;
+  [key: `app.${string}`]: any;
+  [key: `middleware.${string}`]: any;
+  db: any;
+  env(): NodeJS.ProcessEnv;
+  env<T extends string>(key: T, def?: any): any;
+  view(viewPath: string, params?: Record<string, any>): Promise<IResponsable>;
+  edge: Edge;
+  asset(key: string, def?: string): string;
+  router: IRouter;
+  events: IDispatcher;
+  config: {
+    get<X extends Record<string, any>>(): X;
+    get<X extends Record<string, any>, T extends Extract<keyof X, string>>(key: T, def?: any): X[T];
+    set<T extends string>(key: T, value: any): void;
+    load?(): any;
+  };
+  'app.events': IDispatcher;
+  'http.app': H3;
+  'path.base': string;
+  'load.paths': PathLoader;
+  'http.serve': typeof serve;
+  'http.context': IHttpContext;
+  'http.request': IRequest;
+  'http.response': IResponse;
+};
+type UseKey<X extends Record<string, any> = Record<string, any>> = keyof RemoveIndexSignature<Bindings & X>;
+type IBinding = UseKey | (new (...args: any[]) => unknown);
+//#endregion
+//#region src/Routing/IMiddlewareHandler.d.ts
+declare class IMiddlewareHandler {
+  /**
+   * Registers a middleware instance.
+   *
+   * @param mw
+   */
+  register(mw: IMiddleware | IMiddleware[]): this;
+  /**
+   * Runs the middleware chain for a given HttpContext.
+   * Each middleware must call next() to continue the chain.
+   *
+   * @param context - The current HttpContext.
+   * @param next - Callback to execute when middleware completes.
+   * @returns A promise resolving to the final handler's result.
+   */
+  run(context: IHttpContext, next: (ctx: IHttpContext) => Promise<any>): Promise<any>;
+}
+//#endregion
+//#region src/Core/IContainer.d.ts
+/**
+ * Interface for the Container contract, defining methods for dependency injection and service resolution.
+ */
+declare abstract class IContainer {
+  abstract middlewareHandler?: IMiddlewareHandler;
+  /**
+   * Check if the target has any decorators
+   *
+   * @param target
+   * @returns
+   */
+  static hasAnyDecorator<C extends abstract new (...args: any[]) => any>(target: C): boolean;
+  /**
+   * Bind a transient service to the container
+   *
+   * @param key
+   * @param factory
+   */
+  abstract bind<T>(key: new (...args: any[]) => T, factory: () => T): void;
+  abstract bind<T extends UseKey>(key: T, factory: () => Bindings[T]): void;
+  /**
+   * Bind unregistered middlewares to the service container so we can use them later
+   *
+   * @param key
+   * @param middleware
+   */
+  abstract bindMiddleware(key: IMiddleware | string, middleware: ConcreteConstructor<IMiddleware>): void;
+  /**
+   * Get all bound and unregistered middlewares in the service container
+   *
+   * @param key
+   * @param middleware
+   */
+  abstract boundMiddlewares(): MapIterator<[string | IMiddleware, IMiddleware]>;
+  abstract boundMiddlewares(key: IMiddleware | string): IMiddleware;
+  /**
+   * Remove one or more transient services from the container
+   *
+   * @param key
+   */
+  abstract unbind<T extends UseKey>(key: T | T[]): void;
+  /**
+   * Bind a singleton service to the container
+   *
+   * @param key
+   * @param factory
+   */
+  abstract singleton<T extends UseKey>(key: T | (new (...args: any[]) => Bindings[T]), factory: (app: this) => Bindings[T]): void;
+  abstract singleton<T extends UseKey>(key: T | (abstract new (...args: any[]) => Bindings[T]), factory: (app: this) => Bindings[T]): void;
+  abstract singleton<T extends UseKey>(key: T | (new (...args: any[]) => Bindings[T]), factory: abstract new (...args: any[]) => any): void;
+  abstract singleton<T extends UseKey>(key: T | (abstract new (...args: any[]) => Bindings[T]), factory: abstract new (...args: any[]) => any): void;
+  /**
+   * Read reflected param types, resolve dependencies from the container and
+   * optionally transform them, finally invoke the specified method on a class instance
+   *
+   * @param instance
+   * @param method
+   * @param defaultArgs
+   * @param handler
+   * @returns
+   */
+  abstract invoke<X extends InstanceType<ClassConstructor>, M extends ExtractClassMethods<X>>(instance: X, method: M, defaultArgs?: any[], handler?: CallableConstructor): Promise<any>;
+  /**
+   * Resolve a service from the container
+   *
+   * @param key
+   */
+  abstract make<T extends UseKey>(key: T): Bindings[T];
+  abstract make<C extends abstract new (...args: any[]) => any>(key: C): InstanceType<C>;
+  abstract make<F extends (...args: any[]) => any>(key: F): ReturnType<F>;
+  /**
+   * Register a callback to be executed after a service is resolved
+   *
+   * @param key
+   * @param callback
+   */
+  abstract afterResolving<T extends UseKey>(key: T, callback: (resolved: Bindings[T], app: this) => void): void;
+  abstract afterResolving<T extends abstract new (...args: any[]) => any>(key: T, callback: (resolved: InstanceType<T>, app: this) => void): void;
+  /**
+   * Register a new before resolving callback for all types.
+   *
+   * @param  key
+   * @param  callback
+   */
+  abstract beforeResolving<T extends UseKey>(key: T, callback: (app: this) => void): void;
+  abstract beforeResolving<T extends abstract new (...args: any[]) => any>(key: T, callback: (app: this) => void): void;
+  /**
+   * Determine if a given string is an alias.
+   *
+   * @param name
+   */
+  abstract isAlias(name: IBinding): boolean;
+  /**
+   * Get the alias for an abstract if available.
+   *
+   * @param  abstract
+   */
+  abstract getAlias(abstract: any): any;
+  /**
+   * Set the alias for an abstract.
+   *
+   * @param token
+   * @param target
+   */
+  abstract alias(key: [string | ClassConstructor, any][]): this;
+  abstract alias(key: string | ClassConstructor, target: any): this;
+  /**
+   * Determine if the given abstract type has been bound.
+   *
+   * @param  string  $abstract
+   * @returns
+   */
+  abstract bound<T extends UseKey>(abstract: T): boolean;
+  abstract bound<C extends abstract new (...args: any[]) => any>(abstract: C): boolean;
+  abstract bound<F extends (...args: any[]) => any>(abstract: F): boolean;
+  /**
+   * Check if a service is registered
+   *
+   * @param key
+   * @returns
+   */
+  abstract has<T extends UseKey>(key: T): boolean;
+  abstract has<C extends abstract new (...args: any[]) => any>(key: C): boolean;
+  abstract has<F extends (...args: any[]) => any>(key: F): boolean;
+  /**
+   * Determine if the given abstract type has been resolved.
+   *
+   * @param abstract
+   */
+  abstract resolved(abstract: IBinding | string): boolean;
+  /**
+   * Register an existing instance as shared in the container.
+   *
+   * @param  abstract
+   * @param  instance
+   */
+  abstract instance<X = any>(key: string, instance: X): X;
+  abstract instance<K$1 extends abstract new (...args: any[]) => any, X = any>(abstract: K$1, instance: X): X;
+  /**
+   * Call the given method and inject its dependencies.
+   *
+   * @param  callback
+   */
+  abstract call<C extends abstract new (...args: any[]) => any>(callback: C): void | Promise<void>;
+  abstract call<F extends (...args: any[]) => any>(callback: F): void | Promise<void>;
+}
+//#endregion
+//#region src/Core/IApplication.d.ts
+declare abstract class IApplication extends IContainer {
+  abstract paths: PathLoader;
+  context?: (event: H3Event) => Promise<IHttpContext>;
+  h3Event?: H3Event;
+  /**
+   * List of registered console commands
+   */
+  abstract registeredCommands: (new (app: any, kernel: any) => any)[];
+  /**
+   * Get all registered providers
+   */
+  abstract getRegisteredProviders(): IServiceProvider[];
+  /**
+   * Configure and Dynamically register all configured service providers, then boot the app.
+   *
+   * @param providers All regitererable service providers
+   * @param filtered A list of service provider name strings we do not want to register at all cost
+   * @param autoRegisterProviders If set to false, service providers will not be auto discovered and registered.
+   *
+   * @returns
+   */
+  abstract initialize(providers: Array<ConcreteConstructor<IServiceProvider, false>>, filtered?: string[], autoRegisterProviders?: boolean): this;
+  /**
+   * Dynamically register all configured providers
+   *
+   * @param autoRegister If set to false, service providers will not be auto discovered and registered.
+   */
+  abstract registerConfiguredProviders(autoRegister?: boolean): Promise<void>;
+  /**
+   * Register service providers
+   *
+   * @param providers
+   * @param filtered
+   */
+  abstract registerProviders(providers: Array<ConcreteConstructor<IServiceProvider, false>>, filtered?: string[]): void;
+  /**
+   * Register a provider
+   */
+  abstract register(provider: IServiceProvider): Promise<void>;
+  /**
+   * Register the listed service providers.
+   *
+   * @param commands An array of console commands to register.
+   */
+  abstract withCommands(commands: (new (app: any, kernel: any) => any)[]): this;
+  /**
+   * checks if the application is running in CLI
+   */
+  abstract runningInConsole(): boolean;
+  /**
+   * checks if the application is running in Unit Test
+   */
+  abstract runningUnitTests(): boolean;
+  abstract getRuntimeEnv(): 'browser' | 'node' | 'unknown';
+  /**
+   * Determine if the application has booted.
+   */
+  abstract isBooted(): boolean;
+  /**
+   * Boot all service providers after registration
+   */
+  abstract boot(): Promise<this>;
+  /**
+   * Register a new boot listener.
+   *
+   * @param  callable  $callback
+   */
+  abstract booting(callback: (app: this) => void): void;
+  /**
+   * Register a new "booted" listener.
+   *
+   * @param callback
+   */
+  abstract booted(callback: (app: this) => void): void;
+  /**
+   * Handle the incoming HTTP request and send the response to the browser.
+   *
+   * @param  request
+   */
+  abstract handleRequest(event: H3Event): Promise<void>;
+  /**
+   * Get the URI resolver callback.
+   */
+  abstract getUriResolver(): () => typeof IUrl | undefined;
+  /**
+   * Set the URI resolver callback.
+   *
+   * @param  callback
+   */
+  abstract setUriResolver(callback: () => typeof IUrl): this;
+  /**
+   * Determine if middleware has been disabled for the application.
+   */
+  abstract shouldSkipMiddleware(): boolean;
+  /**
+   * Provide safe overides for the app
+   */
+  abstract configure(): IAppBuilder;
+  /**
+   * Check if the current application environment matches the one provided
+   *
+   * @param env
+   */
+  abstract environment<E = string | undefined>(env: E): E extends undefined ? string : boolean;
+  /**
+   * Fire up the developement server using the user provided arguments
+   *
+   * Port will be auto assigned if provided one is not available
+   *
+   * @param h3App The current H3 app instance
+   * @param preferedPort If provided, this will overide the port set in the evironment
+   * @alias serve
+   */
+  abstract fire(): Promise<this>;
+  abstract fire(h3App: H3, preferredPort?: number): Promise<this>;
+  /**
+   * Fire up the developement server using the user provided arguments
+   *
+   * Port will be auto assigned if provided one is not available
+   *
+   * @param h3App The current H3 app instance
+   * @param preferedPort If provided, this will overide the port set in the evironment
+   */
+  abstract serve(h3App?: H3, preferredPort?: number): Promise<this>;
+  /**
+   * Run the given array of bootstrap classes.
+   *
+   * @param bootstrappers
+   */
+  abstract bootstrapWith(bootstrappers: ConcreteConstructor<IBootstraper>[]): void | Promise<void>;
+  /**
+   * Determine if the application has been bootstrapped before.
+   */
+  abstract hasBeenBootstrapped(): boolean;
+  /**
+   * Save the curretn H3 instance for possible future use.
+   *
+   * @param h3App The current H3 app instance
+   * @returns
+   */
+  abstract setH3App(h3App?: H3): this;
+  /**
+   * Set the HttpContext.
+   *
+   * @param  ctx
+   */
+  abstract setHttpContext(ctx: IHttpContext): this;
+  /**
+   * Get the HttpContext.
+   */
+  abstract getHttpContext(): IHttpContext | undefined;
+  /**
+   * Get the base path of the app
+   *
+   * @returns
+   */
+  abstract getBasePath(): string;
+  /**
+   * Dynamically retrieves a path property from the class.
+   * Any property ending with "Path" is accessible automatically.
+   *
+   * @param name - The base name of the path property
+   * @returns
+   */
+  abstract getPath(name: IPathName, suffix?: string): string;
+  /**
+   * Programatically set the paths.
+   *
+   * @param name - The base name of the path property
+   * @param path - The new path
+   * @returns
+   */
+  abstract setPath(name: IPathName, path: string): void;
+  /**
+   * Returns the installed version of the system core and typescript.
+   *
+   * @returns
+   */
+  abstract getVersion(key: string): string;
+}
+//#endregion
+//#region src/Http/IHttpContext.d.ts
+declare abstract class IHttpContext {
+  abstract app: IApplication;
+  abstract event: H3Event;
+  abstract request: IRequest;
+  abstract response: IResponse;
+  /**
+   * Retrieve an existing HttpContext instance for an event, if any.
+   */
+  static get(event: unknown): IHttpContext | undefined;
+  /**
+   * Delete the cached context for a given event (optional cleanup).
+   */
+  static forget(event: unknown): void;
+}
+//#endregion
+//#region src/Utilities/Utilities.d.ts
+type IPathName = 'views' | 'routes' | 'assets' | 'base' | 'public' | 'storage' | 'config' | 'database' | 'commands';
+type RouterEnd = 'get' | 'delete' | 'put' | 'post' | 'patch' | 'apiResource' | 'group' | 'route' | 'any';
+type RouteMethod = 'GET' | 'HEAD' | 'PUT' | 'PATCH' | 'POST' | 'DELETE' | 'OPTIONS';
+type RequestMethod = 'HEAD' | 'GET' | 'PUT' | 'DELETE' | 'TRACE' | 'OPTIONS' | 'PURGE' | 'POST' | 'CONNECT' | 'PATCH';
+type ResourceMethod = 'index' | 'create' | 'store' | 'show' | 'edit' | 'update' | 'destroy';
+type GenericObject<X = any> = Record<string, X>;
+type RequestObject = Record<string, any>;
+type ResponseObject = Record<string, any>;
+type ExtractClassMethods<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => any) ? K : never }[keyof T];
+/**
+ * Type for EventHandler, representing a function that handles an H3 event.
+ */
+type EventHandler = (ctx: IHttpContext) => any;
+type TGeneric<V = any, K$1 extends string = string> = Record<K$1, V>;
+type ClassConstructor<T = any> = abstract new (...args: any[]) => T;
+type MixinConstructor<T = TGeneric> = ClassConstructor<T>;
+type RouteEventHandler = (ctx: IHttpContext, ...args: any[]) => any;
+type MergedConstructor<T = any> = (new (...args: any[]) => T) & Record<string, T>;
+type AbstractConstructor<T = any> = ClassConstructor<T> & Record<string, T>;
+type CallableConstructor<X = any, Y = any> = (...args: Y[]) => X;
+type AppEvent = CallableConstructor;
+type AppListener = CallableConstructor;
+type ConcreteConstructor<T = any, RA extends boolean = true> = new (...args: any[]) => RA extends true ? Required<T> : T;
+interface RouteActions {
+  [key: string]: any;
+  can?: [string, string][];
+  where?: Record<string, RouteEventHandler>;
+  domain?: string;
+  path?: string;
+  prefix?: string;
+  as?: string;
+  name?: string;
+  controller?: RouteEventHandler | IController | string;
+  missing?: any;
+  uses?: any;
+  http?: boolean;
+  https?: boolean;
+  middleware?: MiddlewareList;
+  namespace?: string;
+  excluded_middleware?: any;
+  scopeBindings?: boolean;
+  scope_bindings?: boolean;
+  withoutMiddleware?: any;
+  withoutScopedBindings?: any;
+}
+interface ResourceOptions {
+  as?: string;
+  missing?: string;
+  prefix?: string;
+  names?: Record<string, string>;
+  middleware?: MiddlewareList;
+  shallow?: any;
+  only?: ResourceMethod[];
+  except?: ResourceMethod[];
+  parameters?: any;
+  wheres?: any;
+  trashed?: ResourceMethod[];
+  creatable?: any;
+  destroyable?: any;
+  bindingFields?: string[];
+  middleware_for?: GenericObject;
+  excluded_middleware?: MiddlewareList;
+  excluded_middleware_for?: GenericObject<MiddlewareList>;
+}
+interface ClassicRouteDefinition {
+  method: Lowercase<RouteMethod>;
+  path: string;
+  name?: string | undefined;
+  handler: EventHandler;
+  signature: [string, string | undefined];
+}
+interface RouteAttributes {
+  action: RouteActions;
+}
+type ActionInput<C extends typeof IController = any> = null | undefined | RouteEventHandler | IController | [C, methodName: ExtractClassMethods<InstanceType<C>>] | RouteActions;
+interface NormalizedAction {
+  uses: RouteEventHandler | IController | string;
+  controller?: RouteEventHandler | IController;
+  methodName?: string;
+}
+type AServiceProvider = (new (app: any) => IServiceProvider) & Partial<IServiceProvider>;
+type OServiceProvider = (new (app: any) => Partial<IServiceProvider>) & Partial<IServiceProvider>;
+type ServiceProviderConstructor = (new (app: any) => IServiceProvider) & IServiceProvider;
+type ListenerClassConstructor = (new (...args: any) => any) & {
+  subscribe?(...args: any[]): any;
+};
+//#endregion
+//#region src/Configuration/IAppBuilder.d.ts
+declare abstract class IAppBuilder {
+  /**
+   * Register the base kernel classes for the application.
+   */
+  abstract withKernels(): this;
+  /**
+   * Register and wire up the application's exception handling layer.
+   *
+   * @param using
+   **/
+  abstract withExceptions(using: (exceptions: any) => void): this;
+  /**
+   * Register and wire up the application's middleware handling layer.
+   *
+   * @param using
+   **/
+  abstract withMiddleware(callback?: (mw: any) => void): this;
+  /**
+   * Register the routing services for the application.
+   */
+  abstract withRouting({
+    using,
+    web,
+    api,
+    commands,
+    health,
+    channels,
+    pages,
+    apiPrefix,
+    then
+  }?: {
+    using?: CallableConstructor;
+    web?: string | string[];
+    api?: string | string[];
+    commands?: string;
+    health?: string;
+    channels?: string;
+    pages?: string;
+    apiPrefix?: string;
+    then?: CallableConstructor;
+  }): this;
+  /**
+   * create
+   */
+  abstract create(): void;
+}
+//#endregion
+//#region src/Core/IRegisterer.d.ts
+declare abstract class IRegisterer {
+  abstract bootRegister(): void;
+}
+//#endregion
+//#region src/Database/IModel.d.ts
+declare abstract class IModel<M extends Model = any> extends Model {
+  /**
+   * Retrieve the model for a bound value.
+   *
+   * @param value
+   * @param field
+   * @returns
+   */
+  abstract resolveRouteBinding(value: any, field?: undefined | string | null): Promise<M>;
+  /**
+   * Retrieve the model for a bound value.
+   *
+   * @param  query
+   * @param  value
+   * @param  field
+   */
+  abstract resolveRouteBindingQuery(query: Builder, value: any, field?: undefined | string | null): IQueryBuilder<M>;
+  /**
+   * Get the value of the model's route key.
+   */
+  abstract getRouteKey(): any;
+  /**
+   * Get the route key for the model.
+   */
+  abstract getRouteKeyName(): string;
+}
+//#endregion
+//#region src/Exceptions/IExceptionHandler.d.ts
+type ExceptionConstructor<T = any> = new (...args: any[]) => T;
+type ExceptionConditionCallback = (error: any) => boolean;
+type RenderExceptionCallback = (error: any, request: IRequest) => IResponse | Promise<IResponse> | undefined | null;
+type ReportExceptionCallback = (error: any) => boolean | void | Promise<boolean | void>;
+type ThrottleExceptionCallback = (error: any) => LimitSpec | Unlimited | null | undefined;
+declare abstract class IExceptionHandler {
+  /**
+   * The exception handler method
+   *
+   * @param error
+   * @param ctx
+   */
+  abstract handle?(error: Error, ctx: IHttpContext): Promise<any>;
+  /**
+   * Register a reportable callback handler
+   *
+   * @param cb
+   * @returns
+   */
+  abstract reportable(cb: ReportExceptionCallback): this;
+  abstract renderable(cb: RenderExceptionCallback): this;
+  abstract dontReport(exceptions: ExceptionConstructor | ExceptionConstructor[]): this;
+  abstract stopIgnoring(exceptions: ExceptionConstructor | ExceptionConstructor[]): this;
+  abstract dontReportWhen(cb: ExceptionConditionCallback): this;
+  abstract dontReportDuplicates(): this;
+  abstract map(from: ExceptionConstructor, mapper: (error: any) => any): this;
+  abstract throttleUsing(cb: ThrottleExceptionCallback): this;
+  abstract buildContextUsing(cb: (e: any, current?: Record<string, any>) => Record<string, any>): this;
+  abstract setRateLimiter(adapter: RateLimiterAdapter): this;
+  abstract respondUsing(cb: (response: IResponse, error: any, request: IRequest) => IResponse | Promise<IResponse>): this;
+  abstract shouldRenderJsonWhen(cb: (request: IRequest, error: any) => boolean): this;
+  /**
+   * Entry point to reporting an exception.
+   *
+   * @param error
+   * @returns
+   */
+  abstract report(error: any): Promise<void>;
+  /**
+   * Render an exception to the console.
+   *
+   * @param e
+   */
+  abstract renderForConsole(e: Error): void;
+  /**
+   * Render an exception into an HTTP Response.
+   *
+   * @param ctx
+   * @param error
+   * @returns
+   */
+  abstract render(request: IRequest, error: any): Promise<IResponse>;
+  /**
+   * getResponse
+   */
+  abstract getResponse(request: IRequest, payload: Record<string, any>, e: any): IResponse | Promise<IResponse>;
+  /**
+   * Not implemented in core. Subclass can implement and call RequestException helpers.
+   *
+   * @param _length
+   */
+  abstract truncateRequestExceptionsAt(_length: number): this;
+  /**
+   * Set the log level
+   *
+   * @param _attributes
+   */
+  abstract level(type: string | Error, level: 'log' | 'debug' | 'warn' | 'info' | 'error'): this;
+  /**
+   * Not implemented here; applicable to validation pipeline/UI.
+   *
+   * @param _attributes
+   */
+  abstract dontFlash(_attributes: string | string[]): this;
+}
+//#endregion
+//#region src/Foundation/CKernel.d.ts
+declare abstract class CKernel {
+  /**
+   * Run the console application.
+   */
+  abstract handle(): Promise<number>;
+  /**
+   * Register a given command.
+   *
+   * @param  command
+   */
+  abstract registerCommand(command: any): void;
+  /**
+   * Get all the registered commands.
+   */
+  abstract all(): Promise<{
+    new (app: IApplication, kernel: Kernel<IApplication>): Command<IApplication>;
+  }[]>;
+  /**
+   * Bootstrap the application for Musket commands.
+   *
+   * @return void
+   */
+  abstract bootstrap(): Promise<void>;
+  /**
+   * Set the paths that should have their Musket commands automatically discovered.
+   *
+   * @param  paths
+   */
+  abstract addCommandPaths(paths: string[]): this;
+  /**
+   * Set the paths that should have their Artisan "routes" automatically discovered.
+   *
+   * @param  paths
+   */
+  abstract addCommandRoutePaths(paths: string[]): this;
+  /**
+   * Get the Musket application instance.
+   */
+  abstract getConsole(): Kernel<IApplication>;
+  /**
+   * Terminate the app.
+   *
+   * @param request
+   */
+  abstract terminate(status: number): void;
+}
+//#endregion
+//#region src/Foundation/IKernel.d.ts
+declare abstract class IKernel {
+  /**
+   * Handle an incoming HTTP request.
+   *
+   * @param request
+   */
+  abstract handle(request: IRequest): Promise<IResponse | undefined>;
+  /**
+   * Bootstrap the application for HTTP requests.
+   *
+   * @return void
+   */
+  abstract bootstrap(): void;
+  /**
+   * Call the terminate method on any terminable middleware.
+   *
+   * @param request
+   * @param  response
+   */
+  abstract terminate(request: IRequest, response: IResponse): void;
+  /**
+   * Register a callback to be invoked when the requests lifecycle duration exceeds a given amount of time.
+   *
+   * @param {number | DateTime} threshold
+   * @param  handler
+   */
+  abstract whenRequestLifecycleIsLongerThan(threshold: any, handler: (...args: any[]) => any): void;
+  /**
+   * When the request being handled started.
+   *
+   * @returns {DateTime}
+   */
+  abstract requestStartedAt(): any;
+  /**
+   * Determine if the kernel has a given middleware.
+   *
+   * @param middleware
+   */
+  abstract hasMiddleware(middleware: IMiddleware): boolean;
+  /**
+   * Add a new middleware to the beginning of the stack if it does not already exist.
+   *
+   * @param  string  middleware
+   */
+  abstract prependMiddleware(middleware: IMiddleware): this;
+  /**
+   * Add a new middleware to end of the stack if it does not already exist.
+   *
+   * @param  middleware
+   */
+  abstract pushMiddleware(middleware: IMiddleware): this;
+  /**
+   * Prepend the given middleware to the given middleware group.
+   *
+   * @param    group
+   * @param    middleware
+   *
+   * @throws {InvalidArgumentException}
+   */
+  abstract prependMiddlewareToGroup(group: string, middleware: IMiddleware): this;
+  /**
+   * Append the given middleware to the given middleware group.
+   *
+   * @param  group
+   * @param  middleware
+   *
+   * @throws {InvalidArgumentException}
+   */
+  abstract appendMiddlewareToGroup(group: string, middleware: IMiddleware): this;
+  /**
+   * Prepend the given middleware to the middleware priority list.
+   *
+   * @param  middleware
+   */
+  abstract prependToMiddlewarePriority(middleware: IMiddleware): this;
+  /**
+   * Append the given middleware to the middleware priority list.
+   *
+   * @param  string  $middleware
+   * @return $this
+   */
+  abstract appendToMiddlewarePriority(middleware: IMiddleware): this;
+  /**
+   * Add the given middleware to the middleware priority list before other middleware.
+   *
+   * @param  before
+   * @param  string  $middleware
+   * @return $this
+   */
+  abstract addToMiddlewarePriorityBefore(before: IMiddleware | IMiddleware[], middleware: IMiddleware): this;
+  /**
+   * Add the given middleware to the middleware priority list after other middleware.
+   *
+   * @param after
+   * @param middleware
+   */
+  abstract addToMiddlewarePriorityAfter(after: IMiddleware | IMiddleware[], middleware: IMiddleware): this;
+  /**
+   * Get the priority-sorted list of middleware.
+   *
+   * @return array
+   */
+  abstract getMiddlewarePriority(): MiddlewareList;
+  /**
+   * Get the application's global middleware.
+   *
+   * @return array
+   */
+  abstract getGlobalMiddleware(): MiddlewareList;
+  /**
+   * Set the application's global middleware.
+   *
+   * @param middleware
+   * @returns
+   */
+  abstract setGlobalMiddleware(middleware: MiddlewareList): this;
+  /**
+   * Get the application's route middleware groups.
+   *
+   * @return array
+   */
+  abstract getMiddlewareGroups(): Record<string, MiddlewareList>;
+  /**
+   * Set the application's middleware groups.
+   *
+   * @param groups
+   * @returns
+   */
+  abstract setMiddlewareGroups(groups: Record<string, MiddlewareList>): this;
+  /**
+   * Get the application's route middleware aliases.
+   *
+   * @return array
+   */
+  abstract getMiddlewareAliases(): Record<string, IMiddleware>;
+  /**
+   * Set the application's route middleware aliases.
+   *
+   * @param  aliases
+   */
+  abstract setMiddlewareAliases(aliases: Record<string, IMiddleware>): this;
+  /**
+   * Set the application's middleware priority.
+   *
+   * @param priority
+   */
+  abstract setMiddlewarePriority(priority: MiddlewareList): this;
+  /**
+   * Get the Laravel application instance.
+   */
+  abstract getApplication(): IApplication;
+  /**
+   * Set the Laravel application instance.
+   *
+   * @param app
+   */
+  abstract setApplication(app: IApplication): this;
+}
+//#endregion
+//#region src/Foundation/RateLimiterAdapter.d.ts
+type LimitSpec = {
+  key?: string;
+  maxAttempts: number;
+  decaySeconds: number;
+};
+type Unlimited = {
+  unlimited: true;
+};
+/**
+ * Rate Limiter Adapter Interface
+ */
+interface RateLimiterAdapter {
+  /**
+   * Attempt a key with a maxAttempts and decaySeconds.
+   *
+   * Return true if this is allowed (i.e., *not* throttled),
+   * false if the limit is reached.
+   */
+  attempt(key: string, maxAttempts: number, allowCallback: () => boolean | Promise<boolean>, decaySeconds: number): Promise<boolean>;
+}
+//#endregion
+//#region src/Http/HttpContract.d.ts
+type CacheOptions = Partial<{
+  must_revalidate: boolean;
+  no_cache: boolean;
+  no_store: boolean;
+  no_transform: boolean;
+  public: boolean;
+  private: boolean;
+  proxy_revalidate: boolean;
+  max_age: number;
+  s_maxage: number;
+  immutable: boolean;
+  stale_while_revalidate: number;
+  stale_if_error: number;
+  last_modified: string | Date;
+  etag: string;
+}>;
+//#endregion
+//#region src/Queue/IJob.d.ts
+declare abstract class IJob {
+  /**
+   * Get the job identifier.
+   */
+  abstract getJobId(): string | number | undefined;
+  /**
+   * Get the raw body of the job.
+   */
+  abstract getRawBody(): string;
+  /**
+   * Get the UUID of the job.
+   *
+   * @return string|null
+   */
+  abstract uuid(): string | null;
+  /**
+   * Fire the job.
+   *
+   * @return void
+   */
+  abstract fire(): void;
+  /**
+   * Delete the job from the queue.
+   */
+  abstract delete(): void;
+  /**
+   * Determine if the job has been deleted.
+   */
+  abstract isDeleted(): boolean;
+  /**
+   * Release the job back into the queue after (n) seconds.
+   *
+   * @param delay
+   */
+  abstract release(delay?: number): void;
+  /**
+   * Determine if the job was released back into the queue.
+   *
+   * @return bool
+   */
+  abstract isReleased(): boolean;
+  /**
+   * Determine if the job has been deleted or released.
+   */
+  abstract isDeletedOrReleased(): boolean;
+  /**
+   * Determine if the job has been marked as a failure.
+   */
+  abstract hasFailed(): boolean;
+  /**
+   * Mark the job as "failed".
+   */
+  abstract markAsFailed(): void;
+  /**
+   * Delete the job, call the "failed" method, and raise the failed job event.
+   *
+   * @param e
+   */
+  abstract fail(e: Error): void;
+  /**
+   * Get the resolved job handler instance.
+   *
+   * @return mixed
+   */
+  abstract getResolvedJob(): IJob;
+  /**
+   * Get the decoded body of the job.
+   */
+  abstract payload(): JobPayload;
+  /**
+   * Get the number of times to attempt a job.
+   *
+   * @return int|null
+   */
+  abstract maxTries(): number | null;
+  /**
+   * Get the number of times to attempt a job after an exception.
+   *
+   * @return int|null
+   */
+  abstract maxExceptions(): number | null;
+  /**
+   * Determine if the job should fail when it timeouts.
+   *
+   * @return bool
+   */
+  abstract shouldFailOnTimeout(): boolean;
+  /**
+   * The number of seconds to wait before retrying a job that encountered an uncaught exception.
+   *
+   * @return int|int[]|null
+   */
+  abstract backoff(): number | null;
+  /**
+   * Get the number of seconds the job can run.
+   *
+   * @return int|null
+   */
+  abstract timeout(): number | null;
+  /**
+   * Get the timestamp indicating when the job should timeout.
+   *
+   * @return int|null
+   */
+  abstract retryUntil(): number | null;
+  /**
+   * Get the name of the queued job class.
+   *
+   * @return string
+   */
+  abstract getName(): string;
+  /**
+   * Get the resolved display name of the queued job class.
+   *
+   * Resolves the name of "wrapped" jobs such as class-based handlers.
+   */
+  abstract resolveName(): any;
+  /**
+   * Get the class of the queued job.
+   *
+   * Resolves the class of "wrapped" jobs such as class-based handlers.
+   *
+   * @return string
+   */
+  abstract resolveQueuedJobClass(): any;
+  /**
+   * Get the name of the connection the job belongs to.
+   */
+  abstract getConnectionName(): string;
+  /**
+   * Get the name of the queue the job belongs to.
+   */
+  abstract getQueue(): string | undefined;
+  /**
+   * Get the service container instance.
+   */
+  abstract getContainer(): IContainer;
+}
+//#endregion
+//#region src/Routing/ICallableDispatcher.d.ts
+declare abstract class ICallableDispatcher {}
+//#endregion
+//#region src/Routing/IControllerDispatcher.d.ts
+declare abstract class IControllerDispatcher {
+  /**
+   * Dispatch a request to a given controller and method.
+   *
+   * @param  route
+   * @param  controller
+   * @param  method
+   */
+  abstract dispatch(route: IRoute, controller: IController, method: ResourceMethod): Promise<any>;
+  /**
+   * Get the middleware for the controller instance.
+   *
+   * @param  controller
+   * @param  method
+   */
+  abstract getMiddleware(controller: IController, method: RouteMethod): IMiddleware[];
+}
+//#endregion
+//#region src/Routing/IRouteRegistrar.d.ts
+declare abstract class IRouteRegistrar {
+  abstract attribute(key: string, value: any): this;
+  abstract resource<C extends typeof IController>(name: string, controller: C, options?: ResourceOptions): IPendingResourceRegistration;
+  abstract apiResource<C extends typeof IController>(name: string, controller: C, options?: ResourceOptions): IPendingResourceRegistration;
+  abstract singleton<C extends typeof IController>(name: string, controller: C, options?: ResourceOptions): IPendingSingletonResourceRegistration;
+  abstract apiSingleton<C extends typeof IController>(name: string, controller: C, options?: ResourceOptions): IPendingSingletonResourceRegistration;
+  abstract group(callback: CallableConstructor | any[] | string): this;
+  abstract match(methods: RouteMethod | RouteMethod[], uri: string, action?: RouteActions): IRoute;
+  abstract middleware(): any[];
+  abstract middleware(middleware?: string | string[]): this;
+  abstract prefix(prefix: string): this;
+}
+//#endregion
+//#region src/Routing/Traits/UrlRoutable.d.ts
+declare abstract class UrlRoutable {
+  /**
+   * Get the value of the model's route key.
+   */
+  abstract getRouteKey(): any;
+  /**
+   * Retrieve the model for a bound value.
+   *
+   * @param  value
+   * @param  field
+   */
+  abstract resolveRouteBinding(value: any, field?: string): Promise<IModel<any>>;
+  /**
+   * Retrieve the child model for a bound value.
+   *
+   * @param  childType
+   * @param  value
+   * @param  field
+   */
+  /**
+   * Get the route key for the model.
+   */
+  abstract getRouteKeyName(): string;
+}
+//#endregion
+//#region src/Url/IRequestAwareUrl.d.ts
+/**
+ * Contract for request-aware URL helpers
+ */
+declare abstract class IRequestAwareUrl {
+  /**
+   * Get the current request URL
+   */
+  abstract current(): string;
+  /**
+   * Get the full current URL with query string
+   */
+  abstract full(): string;
+  /**
+   * Get the previous request URL
+   */
+  abstract previous(): string;
+  /**
+   * Get the previous request path (without query string)
+   */
+  abstract previousPath(): string;
+  /**
+   * Get the current query parameters
+   */
+  abstract query(): Record<string, any>;
+}
+//#endregion
+//#region src/Url/IUrlHelpers.d.ts
+/**
+ * The Url Helper Contract
+ */
+declare abstract class IUrlHelpers {
+  /**
+   * Create a URL from a path relative to the app URL
+   */
+  abstract to: (path: string) => IUrl;
+  /**
+   * Create a URL from a named route
+   */
+  abstract route: (name: string, params?: Record<string, any>) => string;
+  /**
+   * Create a signed URL from a named route
+   *
+   * @param name
+   * @param params
+   * @returns
+   */
+  abstract signedRoute: (name: string, params?: Record<string, any>) => IUrl;
+  /**
+   * Create a temporary signed URL from a named route
+   *
+   * @param name
+   * @param params
+   * @param expiration
+   * @returns
+   */
+  abstract temporarySignedRoute: (name: string, params: Record<string, any> | undefined, expiration: number) => IUrl;
+  /**
+   * Create a URL from a controller action
+   */
+  abstract action: <C extends new (...args: any) => any>(controller: string | [C, methodName: ExtractClassMethods<InstanceType<C>>], params?: Record<string, any>) => string;
+  /**
+   * Get request-aware URL helpers
+   */
+  abstract url: {
+    (): IUrlHelpers;
+    (path: string): string;
+  };
+}
+//#endregion
+//#region src/Validation/IMessageBag.d.ts
+declare class ValidationMessageProvider {
+  getMessageBag(): IMessageBag;
+}
+declare class IMessageBag implements ValidationMessageProvider {
+  /**
+   * Create a new message bag instance.
+   */
+  constructor(messages: Record<string, string[] | string>);
+  getMessageBag(): IMessageBag;
+  /**
+   * Get all message keys.
+   */
+  keys(): string[];
+  /**
+   * Add a message.
+   */
+  add(key: string, message: string): this;
+  /**
+   * Add a message conditionally.
+   */
+  addIf(condition: boolean, key: string, message: string): this;
+  /**
+   * Merge another message source into this one.
+   */
+  merge(messages: Record<string, string[]> | ValidationMessageProvider): this;
+  /**
+   * Determine if messages exist for all given keys.
+   */
+  has(key?: string | string[] | null): boolean;
+  /**
+   * Determine if messages exist for any given key.
+   */
+  hasAny(keys: string | string[]): boolean;
+  /**
+   * Determine if messages don't exist for given keys.
+   */
+  missing(key: string | string[]): boolean;
+  /**
+   * Get the first message for a given key.
+   */
+  first(key?: string | null, format?: string | null): string;
+  /**
+   * Get all messages for a given key.
+   */
+  get(key: string, format?: string | null): string[] | Record<string, string[]>;
+  /**
+   * Get all messages.
+   */
+  all(format?: string): string[];
+  /**
+   * Get unique messages.
+   */
+  unique(format?: string | null): string[];
+  /**
+   * Remove messages for a key.
+   */
+  forget(key: string): this;
+  /**
+   * Get raw messages.
+   */
+  messagesRaw(): Record<string, string[]>;
+  /**
+   * Alias for messagesRaw().
+   */
+  getMessages(): Record<string, string[]>;
+  /**
+   * Return message bag instance.
+   */
+  getMessageBag(): IMessageBag;
+  /**
+   * Get format string.
+   */
+  getFormat(): string;
+  /**
+   * Set default message format.
+   */
+  setFormat(format: string): this;
+  /**
+   * Empty checks.
+   */
+  isEmpty(): boolean;
+  isNotEmpty(): boolean;
+  any(): boolean;
+  /**
+   * Count total messages.
+   */
+  count(): number;
+  /**
+   * Array & JSON conversions.
+   */
+  toArray(): Record<string, string[]>;
+  jsonSerialize(): any;
+  toJson(options: number): string;
+  toPrettyJson(): string;
+  /**
+   * String representation.
+   */
+  toString(): string;
+}
+//#endregion
+//#region src/Validation/RuleBuilder.d.ts
+interface ValidationRuleCallable {
+  name: string;
+  validator: (value: any, parameters?: string[], attribute?: string) => boolean | Promise<boolean>;
+  message?: string;
+}
+type CustomValidationRules = IValidationRule | ValidationRuleCallable;
+declare class BaseValidationRuleClass {}
+//#endregion
+//#region src/Validation/IValidationRule.d.ts
+declare abstract class IValidationRule {
+  rules: ValidationRuleCallable[];
+  /**
+   * Run the validation rule.
+   */
+  abstract validate(attribute: string, value: any, fail: (msg: string) => any): void;
+  /**
+   * Set the current validator.
+   */
+  /**
+   * Set the data under validation.
+   */
+  setData(_data: Record<string, any>): this;
+  passes(value: any, attribute: string): boolean | Promise<boolean>;
+}
+//#endregion
+//#region src/Validation/ValidationRuleName.d.ts
+type ParamableValidationRuleName = 'accepted_if' | 'after' | 'after_or_equal' | 'before' | 'before_or_equal' | 'between' | 'date_equals' | 'datetime' | 'declined_if' | 'digits_between' | 'different' | 'exists' | 'ends_with' | 'gt' | 'gte' | 'in' | 'includes' | 'lt' | 'lte' | 'max' | 'min' | 'not_in' | 'not_includes' | 'required_if' | 'required_unless' | 'required_with' | 'required_with_all' | 'required_without' | 'required_without_all' | 'same' | 'size' | 'starts_with' | 'unique';
+type PlainRuleName = 'accepted' | 'alpha' | 'alpha_dash' | 'alpha_num' | 'array' | 'array_unique' | 'bail' | 'boolean' | 'confirmed' | 'date' | 'declined' | 'digits' | 'email' | 'integer' | 'json' | 'not_regex' | 'nullable' | 'numeric' | 'object' | 'present' | 'regex' | 'required' | 'sometimes' | 'string' | 'url' | 'hex' | 'uuid';
+type ValidationRuleName = ParamableValidationRuleName | PlainRuleName;
+type MethodRules = Regex | In | NotIn | RequiredIf;
+/**
+ * Single rule value (supports autocomplete + arbitrary strings + Rule instances)
+ */
+type RuleName = ValidationRuleName | `${ParamableValidationRuleName}:${string}` | Rule$1 | MethodRules;
+type ValidationRuleSet = RuleName | RuleName[] | `${ValidationRuleName}${string & `|${string}`}`;
+//#endregion
+//#region src/Validation/ValidatorContracts.d.ts
+/**
+ * Parse rule names from rule string or string[] definitions
+ */
+type ExtractRules<R> = R extends string ? R extends `${infer Head}|${infer Tail}` ? Head extends `${infer Rule}:${string}` ? Rule | ExtractRules<Tail> : Head | ExtractRules<Tail> : R extends `${infer Rule}:${string}` ? Rule : R : R extends string[] ? ExtractRules<R[number]> : never;
+/**
+ * Flatten data structure into dot-notation keys
+ * including wildcards (*) for arrays.
+ */
+type DotPaths<T, Prefix extends string = ''> = { [K in keyof T & string]: T[K] extends (infer A)[] ? `${Prefix}${K}` | `${Prefix}${K}.*` | (A extends Record<string, any> ? `${Prefix}${K}.*.${DotPaths<A>}` : never) : T[K] extends Record<string, any> ? `${Prefix}${K}` | `${Prefix}${K}.${DotPaths<T[K]>}` : `${Prefix}${K}` }[keyof T & string];
+/**
+* Builds message keys only for rules used on that field
+*/
+type FieldMessages<Field extends string, R> = `${Field}` | `${Field}.${ExtractRules<R> & ValidationRuleName}`;
+/**
+* Build all valid message keys for a given rules object
+*/
+type MessagesForRules<Rules extends Record<string, any>> = { [K in keyof Rules & string]: FieldMessages<K, Rules[K]> }[keyof Rules & string];
+/**
+ * Make rules align with keys in the data object
+ */
+type RulesForData<D extends Record<string, any>> = Partial<Record<DotPaths<D>, ValidationRuleSet>>;
+//#endregion
+//#region src/Validation/IValidator.d.ts
+declare class IValidator<D extends Record<string, any> = any, R extends RulesForData<D> = RulesForData<D>> {
+  constructor(data: D, rules: R, messages: Partial<Record<MessagesForRules<R>, string>>);
+  /**
+   * Validate the data and return the instance
+   */
+  static make<D extends Record<string, any>, R extends RulesForData<D>>(data: D, rules: R, messages: Partial<Record<MessagesForRules<R>, string>>): IValidator<D, R>;
+  /**
+   * Run the validator and store results.
+   */
+  passes(): Promise<boolean>;
+  /**
+   * Opposite of passes()
+   */
+  fails(): Promise<boolean>;
+  /**
+   * Throw if validation fails, else return executed data
+   *
+   * @throws ValidationException if validation fails
+   */
+  validate(): Promise<Record<string, any>>;
+  /**
+   * Run the validator's rules against its data.
+   * @param bagName
+   * @returns
+   */
+  validateWithBag(bagName: string): Promise<Record<string, any>>;
+  /**
+   * Stop validation on first failure.
+   */
+  stopOnFirstFailure(): this;
+  /**
+   * Get the data that passed validation.
+   */
+  validatedData(): Record<string, any>;
+  /**
+   * Return all validated input.
+   */
+  validated(): Partial<D>;
+  /**
+   * Return a portion of validated input
+   */
+  safe(): {
+    only: (keys: string[]) => Partial<D>;
+    except: (keys: string[]) => Partial<D>;
+  };
+  /**
+   * Get the message container for the validator.
+   */
+  messages(): Promise<Partial<Record<MessagesForRules<R>, string>>>;
+  /**
+   * Add an after validation callback.
+   *
+   * @param  callback
+   */
+  after<C extends ((validator: IValidator<D, R>) => void) | BaseValidationRuleClass>(callback: C | C[]): this;
+  /**
+   * Get all errors.
+   */
+  errors(): IMessageBag;
+  errorBag(): string;
+  /**
+   * Reset validator with new data.
+   */
+  setData(data: D): this;
+  /**
+   * Set validation rules.
+   */
+  setRules(rules: R): this;
+  /**
+   * Add a single rule to existing rules.
+   */
+  addRule(key: DotPaths<D>, rule: ValidationRuleSet): this;
+  /**
+   * Merge additional rules.
+   */
+  mergeRules(rules: Record<string, string>): this;
+  /**
+   * Get current data.
+   */
+  getData(): Record<string, any>;
+  /**
+   * Get current rules.
+   */
+  getRules(): R;
+}
+//#endregion
+export { AServiceProvider, AbstractConstructor, ActionInput, AppEvent, AppListener, BaseValidationRuleClass, Bindings, CKernel, CacheOptions, CallableConstructor, ClassConstructor, ClassicRouteDefinition, ConcreteConstructor, CustomValidationRules, DotFlatten, DotNestedKeys, DotNestedValue, DotPaths, DriverBuilder, DriverOption, EventHandler, ExceptionConditionCallback, ExceptionConstructor, ExtractClassMethods, ExtractRules, FieldMessages, FlashBag, GenericObject, GenericWithNullableStringValues, IAbstractRouteCollection, IAppBuilder, IApplication, IBinding, IBootstraper, ICallableDispatcher, ICompiledRoute, IContainer, IController, IControllerDispatcher, IDispatcher, IExceptionHandler, IFileBag, IFileInput, IHeaderBag, IHttpContext, IHttpRequest, IHttpResponse, IJob, IKernel, IMessageBag, IMiddleware, IMiddlewareHandler, IModel, IParamBag, IPathName, IPendingResourceRegistration, IPendingSingletonResourceRegistration, IRegisterer, IRequest, IRequestAwareUrl, IResponsable, IResponse, IRoute, IRouteCollection, IRouteRegistrar, IRouter, IServerBag, IServiceProvider, ISessionManager, IUploadedFile, IUrl, IUrlHelpers, IValidationRule, IValidator, InputBag, JobPayload, LimitSpec, ListenerClassConstructor, MergedConstructor, MessagesForRules, MiddlewareIdentifier, MiddlewareList, MixinConstructor, NormalizedAction, OServiceProvider, ParamableValidationRuleName, PathLoader, PlainRuleName, RateLimiterAdapter, RedirectHandler, RenderExceptionCallback, ReportExceptionCallback, RequestMethod, RequestObject, ResourceMethod, ResourceOptions, ResponsableType, ResponseObject, RouteActions, RouteAttributes, RouteEventHandler, RouteMethod, RouteParams, RouterEnd, RulesForData, ServiceProviderConstructor, SessionDriver, TGeneric, ThrottleExceptionCallback, Unlimited, UrlRoutable, UseKey, ValidationMessageProvider, ValidationRuleCallable, ValidationRuleName, ValidationRuleSet };