@h3ravel/foundation 0.1.0-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,1836 @@
+/// <reference path="./app.globals.d.ts" />
+import * as _h3ravel_contracts0 from "@h3ravel/contracts";
+import { CKernel, CacheOptions, CallableConstructor, ConcreteConstructor, ExceptionConditionCallback, ExceptionConstructor, IApplication, IBootstraper, IExceptionHandler, IHttpContext, IKernel, IMiddleware, IMiddlewareHandler, IModel, IRequest, IResponse, IRoute, IRouter, MiddlewareList, RateLimiterAdapter, RedirectHandler, RenderExceptionCallback, ReportExceptionCallback, ThrottleExceptionCallback } from "@h3ravel/contracts";
+import { Collection, DateTime, InvalidArgumentException } from "@h3ravel/support";
+import { Command, Kernel as Kernel$1 } from "@h3ravel/musket";
+import { UserConfig } from "tsdown";
+import * as supertest_lib_agent0 from "supertest/lib/agent";
+import { Application, ServiceProvider } from "@h3ravel/core";
+import { IncomingMessage, ServerResponse } from "node:http";
+import supertest from "supertest";
+import * as execa0 from "execa";
+import { Console } from "@h3ravel/shared";
+
+//#region src/Helpers.d.ts
+declare class Helpers {
+  private static app;
+  private static helpersLoaded;
+  static load(app: IApplication): void;
+  static isLoaded(): boolean;
+  /**
+   * Get the available app instance.
+   *
+   * @param key
+   */
+  private static appInstance;
+  /**
+   * Get an instance of the Request class
+   *
+   * @returns — a global instance of the Request class.
+   */
+  private static request;
+  /**
+   * Get an instance of the Response class
+   *
+   * @returns — a global instance of the Response class.
+   */
+  private static response;
+  /**
+   * Get an instance of the current session manager
+   * @param key
+   * @param defaultValue
+   *
+   * @returns — a global instance of the current session manager.
+   */
+  private static session;
+  /**
+   * Get the flashed input from previous request.
+   *
+   * @param args
+   */
+  private static old;
+  /**
+   * Hash the given value against the bcrypt algorithm.
+   *
+   * @param  value
+   * @param  options
+   */
+  private static bcrypt;
+  /**
+   * Global env variable
+   *
+   * @param path
+   */
+  private static env;
+  private static config;
+  /**
+   * Generate the URL to a named route.
+   *
+   * @param  name
+   * @param  parameters
+   * @param  absolute
+   */
+  private static route;
+  /**
+   * Get the evaluated view contents for the given view.
+   */
+  private static view;
+  /**
+   * Get static asset
+   */
+  private static asset;
+  private static url;
+  /**
+   * Load all global helpers
+   */
+  private static loadHelpers;
+}
+//#endregion
+//#region src/Adapters/InMemoryRateLimiter.d.ts
+/**
+ * Very small in-memory token-bucket / counter limiter.
+ *
+ * Suitable for single-process dev / tests. We will replace with a Redis-backed adapter
+ * implementing `RateLimiterAdapter` in future.
+ */
+declare class InMemoryRateLimiter implements RateLimiterAdapter {
+  protected store: Map<string, {
+    count: number;
+    expiresAt: number;
+  }>;
+  attempt(key: string, maxAttempts: number, allowCallback: () => boolean | Promise<boolean>, decaySeconds: number): Promise<boolean>;
+}
+//#endregion
+//#region src/Bootstrapers/BootProviders.d.ts
+declare class BootProviders extends IBootstraper {
+  /**
+   * Bootstrap the given application.
+   */
+  bootstrap(app: IApplication): Promise<void>;
+}
+//#endregion
+//#region src/Bootstrapers/RegisterFacades.d.ts
+declare class RegisterFacades extends IBootstraper {
+  /**
+   * Bootstrap the given application.
+   */
+  bootstrap(app: IApplication): void;
+}
+//#endregion
+//#region src/Configuration/AppBuilder.d.ts
+declare class AppBuilder {
+  private app;
+  /**
+   * The Folio / page middleware that have been defined by the user.
+   */
+  protected pageMiddleware: MiddlewareList[];
+  /**
+   * Any additional routing callbacks that should be invoked while registering routes.
+   */
+  protected additionalRoutingCallbacks: CallableConstructor[];
+  constructor(app: IApplication);
+  /**
+   * Register the base kernel classes for the application.
+   */
+  withKernels(): this;
+  /**
+   * Register and wire up the application's exception handling layer.
+   *
+   * @param using
+   **/
+  withExceptions(using: (exceptions: Exceptions) => void): this;
+  /**
+   * Register and wire up the application's middleware handling layer.
+   *
+   * @param using
+   **/
+  withMiddleware(callback?: (mw: Middleware) => void): this;
+  /**
+   * Register the routing services for the application.
+   */
+  withRouting({
+    using,
+    web,
+    api,
+    commands,
+    health,
+    channels,
+    apiPrefix,
+    then
+  }?: {
+    using?: CallableConstructor;
+    web?: string | string[];
+    api?: string | string[];
+    commands?: string | Collection<typeof Command<IApplication>>;
+    health?: string;
+    channels?: string;
+    apiPrefix?: string;
+    then?: CallableConstructor;
+  }): this;
+  /**
+   * Create the routing callback for the application.
+   *
+   * @param  web
+   * @param  api
+   * @param  health
+   * @param  apiPrefix
+   * @param  then
+   */
+  protected buildRoutingCallback({
+    web,
+    api,
+    apiPrefix,
+    then
+  }: {
+    web?: string | string[];
+    api?: string | string[];
+    health?: string;
+    apiPrefix: string;
+    then?: CallableConstructor;
+  }): () => void;
+  /**
+   * Register additional Artisan commands with the application.
+   *
+   * @param  commands
+   */
+  withCommands(commands?: typeof Command<IApplication>[] | string[]): this;
+  /**
+   * create
+   */
+  create(): void;
+}
+//#endregion
+//#region src/Configuration/Middleware.d.ts
+/**
+ * Core Middleware configuration container.
+ *
+ * Use this class to programmatically build middleware lists and groups.
+ *
+ * - Middleware entries can either be strings (identifiers) or instances of the middleware class in this core version.
+ * - Callbacks/redirects accept string or () => string.
+ * - Group replace/remove/append/prepend behavior retained.
+ */
+declare class Middleware {
+  private app?;
+  /**
+   * The user defined global middleware stack.
+   */
+  protected global: MiddlewareList;
+  /**
+   * The middleware that should be prepended to the global middleware stack
+   */
+  protected prepends: MiddlewareList;
+  /**
+   * The middleware that should be appended to the global middleware stack.
+   */
+  protected appends: MiddlewareList;
+  /**
+   * The middleware that should be removed from the global middleware stack.
+   */
+  protected removals: MiddlewareList;
+  /**
+   * The middleware that should be replaced in the global middleware stack.
+   */
+  protected replacements: Record<string, string>;
+  protected groups: Record<string, MiddlewareList>;
+  protected groupPrepends: Record<string, MiddlewareList>;
+  protected groupAppends: Record<string, MiddlewareList>;
+  protected groupRemovals: Record<string, MiddlewareList>;
+  protected groupReplacements: Record<string, Record<string, IMiddleware>>;
+  protected pageMiddleware: MiddlewareList[];
+  protected _priority: MiddlewareList;
+  protected _trustHosts: boolean;
+  protected _statefulApi: boolean;
+  protected _throttleWithRedis: boolean;
+  protected apiLimiter: string | null;
+  protected authenticatedSessions: boolean;
+  protected customAliases: Record<string, IMiddleware>;
+  protected prependPriority: Record<string, IMiddleware>;
+  protected appendPriority: Record<string, IMiddleware>;
+  constructor(app?: IApplication | undefined);
+  /**
+   * Prepend middleware to the application's global middleware stack.
+   *
+   * @param middleware
+   * @returns
+   */
+  prepend(middleware: MiddlewareList | IMiddleware): this;
+  /**
+   * Append middleware to the application's global middleware stack.
+   *
+   * @param middleware
+   * @returns
+   */
+  append(middleware: MiddlewareList | IMiddleware): this;
+  /**
+   * Remove middleware from the application's global middleware stack.
+   *
+   * @param middleware
+   * @returns
+   */
+  remove(middleware: MiddlewareList | IMiddleware): this;
+  /**
+   *
+   * Specify a middleware that should be replaced with another middleware.
+   *
+   * @param search
+   * @param replaceWith
+   * @returns
+   */
+  replace(search: string, replaceWith: string): this;
+  /**
+   * Define the global middleware for the application.
+   *
+   * @param middleware
+   * @returns
+   */
+  use(middleware: MiddlewareList): this;
+  /**
+   * Define a middleware group.
+   *
+   * @param groupName
+   * @param middleware
+   * @returns
+   */
+  group(groupName: string, middleware: MiddlewareList): this;
+  /**
+   * Prepend the given middleware to the specified group.
+   *
+   * @param group
+   * @param middleware
+   * @returns
+   */
+  prependToGroup(group: string, middleware: MiddlewareList | IMiddleware): this;
+  /**
+   * Append the given middleware to the specified group.
+   *
+   * @param group
+   * @param middleware
+   * @returns
+   */
+  appendToGroup(group: string, middleware: MiddlewareList | IMiddleware): this;
+  /**
+   * Remove the given middleware from the specified group.
+   *
+   * @param group
+   * @param middleware
+   * @returns
+   */
+  removeFromGroup(group: string, middleware: MiddlewareList | IMiddleware): this;
+  /**
+   * Replace the given middleware in the specified group with another middleware
+   *
+   * @param group
+   * @param search
+   * @param replaceWith
+   * @returns
+   */
+  replaceInGroup(group: string, search: string, replaceWith: IMiddleware): this;
+  /**
+   * Modify the middleware in the "web" group.
+   *
+   * @param append
+   * @param prepend
+   * @param remove
+   * @param replace
+   * @returns
+   */
+  web(append?: MiddlewareList | IMiddleware | [], prepend?: MiddlewareList | IMiddleware | [], remove?: MiddlewareList | IMiddleware | [], replace?: Record<string, IMiddleware>): this;
+  /**
+   * Modify the middleware in the "api" group.
+   *
+   * @param append
+   * @param prepend
+   * @param remove
+   * @param replace
+   * @returns
+   */
+  api(append?: MiddlewareList | IMiddleware | [], prepend?: MiddlewareList | IMiddleware | [], remove?: MiddlewareList | IMiddleware | [], replace?: Record<string, IMiddleware>): this;
+  /**
+   * Modify the middleware in the given group
+   *
+   * @param group
+   * @param append
+   * @param prepend
+   * @param remove
+   * @param replace
+   * @returns
+   */
+  protected modifyGroup(group: string, append: MiddlewareList | IMiddleware | [], prepend: MiddlewareList | IMiddleware | [], remove: MiddlewareList | IMiddleware | [], replace: Record<string, IMiddleware>): this;
+  /**
+   * Register the page middleware for the application.
+   *
+   * @param middleware
+   * @returns
+   */
+  pages(middleware: MiddlewareList[]): this;
+  /**
+   * Register additional middleware aliases.
+   *
+   * @param aliases
+   * @returns
+   */
+  alias(aliases?: Record<string, IMiddleware>): this;
+  /**
+   * Define the middleware priority for the application.
+   *
+   * @param list
+   * @returns
+   */
+  priority(list: MiddlewareList): this;
+  /**
+   * Prepend middleware to the priority middleware.
+   *
+   * @param before
+   * @param prependKey
+   * @returns
+   */
+  prependToPriorityList(before: IMiddleware, prependKey: string): this;
+  /**
+   * Append middleware to the priority middleware
+   *
+   * @param after
+   * @param appendKey
+   * @returns
+   */
+  appendToPriorityList(after: IMiddleware, appendKey: string): this;
+  /**
+   * Get the global middleware list after applying prepends/appends/replacements/removals.
+   *
+   * @param defaults
+   * @returns
+   */
+  getGlobalMiddleware(defaults?: MiddlewareList): MiddlewareList;
+  /**
+   * Build middleware groups with applied group-level replacements, removals, prepends, appends.
+   */
+  getMiddlewareGroups(): Record<string, MiddlewareList>;
+  /**
+   * Configure where guests are redirected by the "auth" middleware
+   *
+   * @param redirect
+   * @returns
+   */
+  redirectGuestsTo(redirect: RedirectHandler): this;
+  /**
+   * Configure where users are redirected by the "guest" middleware
+   *
+   * @param redirect
+   * @returns
+   */
+  redirectUsersTo(redirect: RedirectHandler): this;
+  /**
+   * Register redirect handlers for the authentication and guest middleware.
+   *
+   * @param guests
+   * @param users
+   * @returns
+   */
+  redirectTo(guests?: RedirectHandler, users?: RedirectHandler): this;
+  /**
+   * Configure the cookie encryption middleware.
+   *
+   * @param _
+   * @returns
+   */
+  encryptCookies(_?: MiddlewareList): this;
+  /**
+   * Configure the CSRF token validation middleware.
+   *
+   * @param _
+   * @returns
+   */
+  validateCsrfTokens(_?: MiddlewareList): this;
+  /**
+   * Configure the URL signature validation middleware
+   *
+   * @param _
+   * @returns
+   */
+  validateSignatures(_?: MiddlewareList): this;
+  /**
+   * Configure the empty string conversion middleware.
+   *
+   * @param _
+   * @returns
+   */
+  convertEmptyStringsToNull(_?: MiddlewareList): this;
+  /**
+   * Configure the string trimming middleware.
+   *
+   * @param _
+   * @returns
+   */
+  trimStrings(_?: MiddlewareList): this;
+  /**
+   * Indicate that the trusted host middleware should be enabled
+   *
+   * @param at
+   * @param subdomains
+   * @returns
+   */
+  trustHosts(at?: any, subdomains?: boolean): this;
+  /**
+   * Configure the trusted proxies for the application
+   *
+   * @param _
+   * @param __
+   * @returns
+   */
+  trustProxies(_?: any, __?: number | null): this;
+  /**
+   * Configure the middleware that prevents requests during maintenance mode
+   *
+   * @param _
+   * @returns
+   */
+  preventRequestsDuringMaintenance(_?: MiddlewareList): this;
+  /**
+   * Indicate that Sanctum's frontend state middleware should be enabled
+   *
+   * @returns
+   */
+  statefulApi(): this;
+  /**
+   * Indicate that the API middleware group's throttling middleware should be enabled
+   *
+   * @param limiter
+   * @param redis
+   * @returns
+   */
+  throttleApi(limiter?: string, redis?: boolean): this;
+  /**
+   * Indicate that H3ravel's throttling middleware should use Redis
+   *
+   * @returns
+   */
+  throttleWithRedis(): this;
+  /**
+   * Indicate that sessions should be authenticated for the "web" middleware group
+   *
+   * @returns
+   */
+  authenticateSessions(): this;
+  /**
+   * Get the page middleware for the application
+   *
+   * @returns
+   */
+  getPageMiddleware(): MiddlewareList[];
+  /**
+   * Get the middleware aliases
+   *
+   * @returns
+   */
+  getMiddlewareAliases(): Record<string, IMiddleware>;
+  /**
+   * Get the default middleware aliases
+   *
+   * @returns
+   */
+  defaultAliases(): Record<string, IMiddleware>;
+  /**
+   * Get the middleware priority for the application
+   *
+   * @returns
+   */
+  getMiddlewarePriority(): MiddlewareList;
+  /**
+   * Get the middleware to prepend to the middleware priority definition
+   *
+   * @returns
+   */
+  getMiddlewarePriorityPrepends(): Record<string, IMiddleware>;
+  /**
+   * Get the middleware to append to the middleware priority definition
+   *
+   * @returns
+   */
+  getMiddlewarePriorityAppends(): Record<string, IMiddleware>;
+}
+//#endregion
+//#region src/Console/ConsoleKernel.d.ts
+/**
+ * ConsoleKernel class handles musket execution and transformations.
+ * It acts as the core pipeline for console inputs.
+*/
+declare class ConsoleKernel extends CKernel {
+  #private;
+  protected app: IApplication;
+  protected DIST_DIR: string;
+  /**
+   * The current Musket console instance
+   */
+  protected commands: typeof Command[];
+  /**
+   * The current Musket console instance
+   */
+  protected console?: Kernel$1<IApplication>;
+  /**
+   * When the current command started.
+   */
+  protected commandStartedAt?: DateTime;
+  /**
+   * Indicates if the Closure commands have been loaded.
+   */
+  protected commandsLoaded: boolean;
+  /**
+   * The paths where Musket commands should be automatically discovered.
+   */
+  protected commandPaths: Set<string>;
+  /**
+   * The paths where Musket command routes should be automatically discovered.
+   */
+  protected commandRoutePaths: Set<string>;
+  protected commandLifecycleDurationHandlers: {
+    'threshold': number;
+    'handler': CallableConstructor;
+  }[];
+  /**
+   * Create a new Console kernel instance.
+   *
+   * @param app The current application instance
+   */
+  constructor(app: IApplication);
+  /**
+   * Get the bootstrap classes for the application.
+   *
+   * @return array
+   */
+  protected bootstrappers(): ConcreteConstructor<IBootstraper>[];
+  /**
+   * Report the exception to the exception handler.
+   * @param  e
+   */
+  protected reportException(e: Error): void;
+  /**
+   * Render the given exception.
+   *
+   * @param  e
+   */
+  protected renderException(e: Error): void;
+  /**
+   * Run the console application.
+   */
+  handle(): Promise<number>;
+  /**
+   * Register a given command.
+   *
+   * @param  command
+   */
+  registerCommand(command: typeof Command | typeof Command[]): void;
+  /**
+   * Get all the registered commands.
+   */
+  all(): Promise<{
+    new (app: IApplication, kernel: Kernel$1<IApplication>): Command<IApplication>;
+  }[]>;
+  /**
+   * Bootstrap the application for Musket commands.
+   *
+   * @return void
+   */
+  bootstrap(): Promise<void>;
+  /**
+   * Determine if the kernel should discover commands.
+   */
+  protected shouldDiscoverCommands(): boolean;
+  /**
+   * Register the commands for the application.
+   */
+  protected registerCommands(): void;
+  /**
+   * Discover the commands that should be automatically loaded.
+   */
+  protected discoverCommands(): void;
+  /**
+   * Set the paths that should have their Musket commands automatically discovered.
+   *
+   * @param  paths
+   */
+  addCommandPaths(paths: string[]): this;
+  /**
+   * Set the paths that should have their Artisan "routes" automatically discovered.
+   *
+   * @param  paths
+   */
+  addCommandRoutePaths(paths: string[]): this;
+  /**
+   * Get the Musket application instance.
+   */
+  getConsole(): Kernel$1<IApplication>;
+  /**
+   * Terminate the app.
+   *
+   * @param request
+   */
+  terminate(status: number): void;
+}
+//#endregion
+//#region src/Console/logo.d.ts
+declare const logo: string;
+declare const altLogo: string;
+//#endregion
+//#region src/Console/TsdownConfig.d.ts
+declare const TsDownConfig: UserConfig;
+//#endregion
+//#region src/Container/Decorators.d.ts
+declare function Inject(...dependencies: string[]): (target: any) => void;
+/**
+ * Allows binding dependencies to both class and class methods
+ *
+ * @returns
+ */
+declare function Injectable(): MethodDecorator & ClassDecorator;
+//#endregion
+//#region src/Exceptions/Base/HttpExceptionFactory.d.ts
+/**
+ * Base HttpException
+ */
+declare class HttpExceptionFactory extends Error {
+  protected statusCode: number;
+  message: string;
+  protected previous?: Error | undefined;
+  protected headers: Record<string, string>;
+  code: number;
+  constructor(statusCode: number, message?: string, previous?: Error | undefined, headers?: Record<string, string>, code?: number);
+  getStatusCode(): number;
+  getHeaders(): Record<string, string>;
+  setHeaders(headers: Record<string, string>): void;
+}
+//#endregion
+//#region src/Exceptions/AccessDeniedHttpException.d.ts
+declare class AccessDeniedHttpException extends HttpExceptionFactory {
+  constructor(message?: string, previous?: Error, code?: number, headers?: Record<string, string>);
+}
+//#endregion
+//#region src/Exceptions/BadRequestHttpException.d.ts
+declare class BadRequestHttpException extends HttpExceptionFactory {
+  constructor(message?: string, previous?: Error, code?: number, headers?: Record<string, string>);
+}
+//#endregion
+//#region src/Exceptions/CommandNotFoundException.d.ts
+/**
+ * Exception thrown when an incorrect command name typed in the console.
+ */
+declare class CommandNotFoundException extends InvalidArgumentException {
+  private alternatives;
+  code: number;
+  previous?: Error | undefined;
+  /**
+   * @param  message      Exception message to throw
+   * @param  alternatives List of similar defined names
+   * @param  code         Exception code
+   * @param  previous     Previous exception used for the exception chaining
+   */
+  constructor(message: string, alternatives?: string[], code?: number, previous?: Error | undefined);
+  getAlternatives(): string[];
+}
+//#endregion
+//#region src/Exceptions/ConflictHttpException.d.ts
+declare class ConflictHttpException extends HttpExceptionFactory {
+  constructor(message?: string, previous?: Error, code?: number, headers?: Record<string, string>);
+}
+//#endregion
+//#region src/Exceptions/GoneHttpException.d.ts
+declare class GoneHttpException extends HttpExceptionFactory {
+  constructor(message?: string, previous?: Error, code?: number, headers?: Record<string, string>);
+}
+//#endregion
+//#region src/Exceptions/LengthRequiredHttpException.d.ts
+declare class LengthRequiredHttpException extends HttpExceptionFactory {
+  constructor(message?: string, previous?: Error, code?: number, headers?: Record<string, string>);
+}
+//#endregion
+//#region src/Exceptions/LockedHttpException.d.ts
+declare class LockedHttpException extends HttpExceptionFactory {
+  constructor(message?: string, previous?: Error, code?: number, headers?: Record<string, string>);
+}
+//#endregion
+//#region src/Exceptions/NotAcceptableHttpException.d.ts
+declare class NotAcceptableHttpException extends HttpExceptionFactory {
+  constructor(message?: string, previous?: Error, code?: number, headers?: Record<string, string>);
+}
+//#endregion
+//#region src/Exceptions/NotFoundHttpException.d.ts
+declare class NotFoundHttpException extends HttpExceptionFactory {
+  constructor(message?: string, previous?: Error, code?: number, headers?: Record<string, string>);
+}
+//#endregion
+//#region src/Exceptions/PreconditionFailedHttpException.d.ts
+declare class PreconditionFailedHttpException extends HttpExceptionFactory {
+  constructor(message?: string, previous?: Error, code?: number, headers?: Record<string, string>);
+}
+//#endregion
+//#region src/Exceptions/PreconditionRequiredHttpException.d.ts
+declare class PreconditionRequiredHttpException extends HttpExceptionFactory {
+  constructor(message?: string, previous?: Error, code?: number, headers?: Record<string, string>);
+}
+//#endregion
+//#region src/Exceptions/RouteNotFoundException.d.ts
+/**
+ * Exception thrown when a route does not exist.
+ */
+declare class RouteNotFoundException extends InvalidArgumentException implements Error {}
+//#endregion
+//#region src/Exceptions/ServiceUnavailableHttpException.d.ts
+declare class ServiceUnavailableHttpException extends HttpExceptionFactory {
+  /**
+   *
+   * @param retryAfter The number of seconds or HTTP-date after which the request may be retried
+   * @param message
+   * @param previous
+   * @param code
+   * @param headers
+   */
+  constructor(retryAfter?: number | string, message?: string, previous?: Error, code?: number, headers?: Record<string, string>);
+}
+//#endregion
+//#region src/Exceptions/TooManyRequestsHttpException.d.ts
+declare class TooManyRequestsHttpException extends HttpExceptionFactory {
+  /**
+   *
+   * @param retryAfter The number of seconds or HTTP-date after which the request may be retried
+   * @param message
+   * @param previous
+   * @param code
+   * @param headers
+   */
+  constructor(retryAfter?: number | string, message?: string, previous?: Error, code?: number, headers?: Record<string, string>);
+}
+//#endregion
+//#region src/Exceptions/UnprocessableEntityHttpException.d.ts
+declare class UnprocessableEntityHttpException extends HttpExceptionFactory {
+  constructor(message?: string, previous?: Error, code?: number, headers?: Record<string, string>);
+}
+//#endregion
+//#region src/Exceptions/UnsupportedMediaTypeHttpException.d.ts
+declare class UnsupportedMediaTypeHttpException extends HttpExceptionFactory {
+  constructor(message?: string, previous?: Error, code?: number, headers?: Record<string, string>);
+}
+//#endregion
+//#region src/Exceptions/UrlGenerationException.d.ts
+declare class UrlGenerationException extends Error {
+  constructor(message: string);
+  static forMissingParameters(route: IRoute, parameters?: string[]): UrlGenerationException;
+}
+//#endregion
+//#region src/Http/Kernel.d.ts
+declare const Kernel_base: typeof IKernel & (new () => {
+  [x: string]: any;
+  secondsUntil(delay: DateTime | number): number;
+  availableAt(delay?: DateTime | number): number;
+  parseDateInterval(delay: DateTime | number): DateTime;
+  currentTime(): number;
+  runTimeForHumans(startTime: number, endTime?: number): string;
+}) & {
+  [x: string]: any;
+  prototype: {
+    [x: string]: any;
+    secondsUntil(delay: DateTime | number): number;
+    availableAt(delay?: DateTime | number): number;
+    parseDateInterval(delay: DateTime | number): DateTime;
+    currentTime(): number;
+    runTimeForHumans(startTime: number, endTime?: number): string;
+  };
+} & (new (...args: any[]) => IKernel & {
+  [x: string]: any;
+  secondsUntil(delay: DateTime | number): number;
+  availableAt(delay?: DateTime | number): number;
+  parseDateInterval(delay: DateTime | number): DateTime;
+  currentTime(): number;
+  runTimeForHumans(startTime: number, endTime?: number): string;
+});
+declare class Kernel extends Kernel_base {
+  #private;
+  protected app: IApplication;
+  protected router: IRouter;
+  /**
+   * The application's middleware stack.
+   */
+  protected middleware: MiddlewareList;
+  /**
+   * The application's route middleware groups.
+   */
+  protected middlewareGroups: Record<string, MiddlewareList>;
+  /**
+   * The application's middleware aliases.
+   */
+  protected middlewareAliases: Record<string, IMiddleware>;
+  /**
+   * All of the registered request duration handlers.
+   */
+  protected requestLifecycleDurationHandlers: {
+    threshold?: number;
+    handler?: (...args: any[]) => void;
+  }[];
+  /**
+   * The priority-sorted list of middleware.
+   *
+   * Forces non-global middleware to always be in the given order.
+   */
+  protected middlewarePriority: MiddlewareList;
+  /**
+   * Create a new HTTP kernel instance.
+   *
+   * @param app The current application instance
+   * @param router The current router instance
+   */
+  constructor(app: IApplication, router: IRouter);
+  /**
+   * Handle an incoming HTTP request.
+   *
+   * @param request
+   */
+  handle(request: IRequest): Promise<IResponse>;
+  /**
+   * Send the given request through the middleware / router.
+   *
+   * @param request
+   */
+  protected sendRequestThroughRouter(request: IRequest): Promise<IResponse>;
+  /**
+   * Bootstrap the application for HTTP requests.
+   *
+   * @return void
+   */
+  bootstrap(): Promise<void>;
+  /**
+   * Get the route dispatcher callback.
+   */
+  protected dispatchToRouter(): (request: IRequest) => Promise<IResponse>;
+  /**
+   * Call the terminate method on any terminable middleware.
+   *
+   * @param request
+   * @param  response
+   */
+  terminate(request: IRequest, response: IResponse): void;
+  /**
+   * Call the terminate method on any terminable middleware.
+   *
+   * @param request
+   * @param  response
+   */
+  protected terminateMiddleware(request: IRequest, response: IResponse): void;
+  /**
+   * Register a callback to be invoked when the requests lifecycle duration exceeds a given amount of time.
+   *
+   * @param  threshold
+   * @param  handler
+   */
+  whenRequestLifecycleIsLongerThan(threshold: number | DateTime, handler: (...args: any[]) => any): void;
+  /**
+   * When the request being handled started.
+   */
+  requestStartedAt(): DateTime | undefined;
+  /**
+   * Gather the route middleware for the given request.
+   */
+  protected gatherRouteMiddleware(request: IRequest): any;
+  /**
+   * Parse a middleware string to get the name and parameters.
+   *
+   * @param middleware
+   */
+  protected parseMiddleware(middleware: string): [string, string[]];
+  /**
+   * Determine if the kernel has a given middleware.
+   *
+   * @param middleware
+   */
+  hasMiddleware(middleware: IMiddleware): boolean;
+  /**
+   * Add a new middleware to the beginning of the stack if it does not already exist.
+   *
+   * @param  string  middleware
+   */
+  prependMiddleware(middleware: IMiddleware): this;
+  /**
+   * Add a new middleware to end of the stack if it does not already exist.
+   *
+   * @param  middleware
+   */
+  pushMiddleware(middleware: IMiddleware): this;
+  /**
+   * Prepend the given middleware to the given middleware group.
+   *
+   * @param    group
+   * @param    middleware
+   *
+   * @throws {InvalidArgumentException}
+   */
+  prependMiddlewareToGroup(group: string, middleware: IMiddleware): this;
+  /**
+   * Append the given middleware to the given middleware group.
+   *
+   * @param  group
+   * @param  middleware
+   *
+   * @throws {InvalidArgumentException}
+   */
+  appendMiddlewareToGroup(group: string, middleware: IMiddleware): this;
+  /**
+   * Prepend the given middleware to the middleware priority list.
+   *
+   * @param  middleware
+   */
+  prependToMiddlewarePriority(middleware: IMiddleware): this;
+  /**
+   * Append the given middleware to the middleware priority list.
+   *
+   * @param  string  $middleware
+   * @return $this
+   */
+  appendToMiddlewarePriority(middleware: IMiddleware): this;
+  /**
+   * Add the given middleware to the middleware priority list before other middleware.
+   *
+   * @param  before
+   * @param  string  $middleware
+   * @return $this
+   */
+  addToMiddlewarePriorityBefore(before: IMiddleware | IMiddleware[], middleware: IMiddleware): this;
+  /**
+   * Add the given middleware to the middleware priority list after other middleware.
+   *
+   * @param after
+   * @param middleware
+   */
+  addToMiddlewarePriorityAfter(after: IMiddleware | IMiddleware[], middleware: IMiddleware): this;
+  /**
+   * Add the given middleware to the middleware priority list relative to other middleware.
+   *
+   * @param  string|array  $existing
+   * @param  string  $middleware
+   * @param  bool  $after
+   * @return $this
+   */
+  protected addToMiddlewarePriorityRelative(existing: IMiddleware | IMiddleware[], middleware: IMiddleware, after?: boolean): this;
+  /**
+   * Sync the current state of the middleware to the router.
+   *
+   * @return void
+   */
+  protected syncMiddlewareToRouter(): void;
+  /**
+   * Get the priority-sorted list of middleware.
+   *
+   * @return array
+   */
+  getMiddlewarePriority(): MiddlewareList;
+  /**
+   * Get the bootstrap classes for the application.
+   *
+   * @return array
+   */
+  protected bootstrappers(): ConcreteConstructor<IBootstraper>[];
+  /**
+   * Report the exception to the exception handler.
+   *
+   * @param  e
+   */
+  protected reportException(e: Error): void;
+  /**
+   * Render the exception to a response.
+   *
+   * @param  request
+   * @param  e
+   */
+  protected renderException(request: IRequest, e: Error): Promise<IResponse>;
+  /**
+   * Get the application's global middleware.
+   *
+   * @return array
+   */
+  getGlobalMiddleware(): MiddlewareList;
+  /**
+   * Set the application's global middleware.
+   *
+   * @param middleware
+   * @returns
+   */
+  setGlobalMiddleware(middleware: MiddlewareList): this;
+  /**
+   * Get the application's route middleware groups.
+   *
+   * @return array
+   */
+  getMiddlewareGroups(): Record<string, MiddlewareList>;
+  /**
+   * Set the application's middleware groups.
+   *
+   * @param groups
+   * @returns
+   */
+  setMiddlewareGroups(groups: Record<string, MiddlewareList>): this;
+  /**
+   * Get the application's route middleware aliases.
+   *
+   * @return array
+   */
+  getMiddlewareAliases(): Record<string, IMiddleware>;
+  /**
+   * Set the application's route middleware aliases.
+   *
+   * @param  aliases
+   */
+  setMiddlewareAliases(aliases: Record<string, IMiddleware>): this;
+  /**
+   * Set the application's middleware priority.
+   *
+   * @param priority
+   */
+  setMiddlewarePriority(priority: MiddlewareList): this;
+  /**
+   * Get the Laravel application instance.
+   */
+  getApplication(): IApplication;
+  /**
+   * Set the Laravel application instance.
+   *
+   * @param app
+   */
+  setApplication(app: IApplication): this;
+}
+//#endregion
+//#region src/Http/MiddlewareHandler.d.ts
+declare class MiddlewareHandler implements IMiddlewareHandler {
+  private middleware;
+  private app;
+  constructor(middleware: IMiddleware[] | undefined, app: IApplication);
+  /**
+   * 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/Http/ResponseUtilities.d.ts
+declare enum ResponseCodes {
+  HTTP_CONTINUE = 100,
+  HTTP_SWITCHING_PROTOCOLS = 101,
+  HTTP_PROCESSING = 102,
+  // RFC2518
+  HTTP_EARLY_HINTS = 103,
+  // RFC8297
+  HTTP_OK = 200,
+  HTTP_CREATED = 201,
+  HTTP_ACCEPTED = 202,
+  HTTP_NON_AUTHORITATIVE_INFORMATION = 203,
+  HTTP_NO_CONTENT = 204,
+  HTTP_RESET_CONTENT = 205,
+  HTTP_PARTIAL_CONTENT = 206,
+  HTTP_MULTI_STATUS = 207,
+  // RFC4918
+  HTTP_ALREADY_REPORTED = 208,
+  // RFC5842
+  HTTP_IM_USED = 226,
+  // RFC3229
+  HTTP_MULTIPLE_CHOICES = 300,
+  HTTP_MOVED_PERMANENTLY = 301,
+  HTTP_FOUND = 302,
+  HTTP_SEE_OTHER = 303,
+  HTTP_NOT_MODIFIED = 304,
+  HTTP_USE_PROXY = 305,
+  HTTP_RESERVED = 306,
+  HTTP_TEMPORARY_REDIRECT = 307,
+  HTTP_PERMANENTLY_REDIRECT = 308,
+  // RFC7238
+  HTTP_BAD_REQUEST = 400,
+  HTTP_UNAUTHORIZED = 401,
+  HTTP_PAYMENT_REQUIRED = 402,
+  HTTP_FORBIDDEN = 403,
+  HTTP_NOT_FOUND = 404,
+  HTTP_METHOD_NOT_ALLOWED = 405,
+  HTTP_NOT_ACCEPTABLE = 406,
+  HTTP_PROXY_AUTHENTICATION_REQUIRED = 407,
+  HTTP_REQUEST_TIMEOUT = 408,
+  HTTP_CONFLICT = 409,
+  HTTP_GONE = 410,
+  HTTP_LENGTH_REQUIRED = 411,
+  HTTP_PRECONDITION_FAILED = 412,
+  HTTP_REQUEST_ENTITY_TOO_LARGE = 413,
+  HTTP_REQUEST_URI_TOO_LONG = 414,
+  HTTP_UNSUPPORTED_MEDIA_TYPE = 415,
+  HTTP_REQUESTED_RANGE_NOT_SATISFIABLE = 416,
+  HTTP_EXPECTATION_FAILED = 417,
+  HTTP_I_AM_A_TEAPOT = 418,
+  // RFC2324
+  HTTP_MISDIRECTED_REQUEST = 421,
+  // RFC7540
+  HTTP_UNPROCESSABLE_ENTITY = 422,
+  // RFC4918
+  HTTP_LOCKED = 423,
+  // RFC4918
+  HTTP_FAILED_DEPENDENCY = 424,
+  // RFC4918
+  HTTP_TOO_EARLY = 425,
+  // RFC-ietf-httpbis-replay-04
+  HTTP_UPGRADE_REQUIRED = 426,
+  // RFC2817
+  HTTP_PRECONDITION_REQUIRED = 428,
+  // RFC6585
+  HTTP_TOO_MANY_REQUESTS = 429,
+  // RFC6585
+  HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+  // RFC6585
+  HTTP_UNAVAILABLE_FOR_LEGAL_REASONS = 451,
+  // RFC7725
+  HTTP_INTERNAL_SERVER_ERROR = 500,
+  HTTP_NOT_IMPLEMENTED = 501,
+  HTTP_BAD_GATEWAY = 502,
+  HTTP_SERVICE_UNAVAILABLE = 503,
+  HTTP_GATEWAY_TIMEOUT = 504,
+  HTTP_VERSION_NOT_SUPPORTED = 505,
+  HTTP_VARIANT_ALSO_NEGOTIATES_EXPERIMENTAL = 506,
+  // RFC2295
+  HTTP_INSUFFICIENT_STORAGE = 507,
+  // RFC4918
+  HTTP_LOOP_DETECTED = 508,
+  // RFC5842
+  HTTP_NOT_EXTENDED = 510,
+  // RFC2774
+  HTTP_NETWORK_AUTHENTICATION_REQUIRED = 511,
+}
+declare const HTTP_RESPONSE_CACHE_CONTROL_DIRECTIVES: CacheOptions;
+/**
+ * Status codes translation table.
+ *
+ * The list of codes is complete according to the
+ * @link https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml Hypertext Transfer Protocol (HTTP) Status Code Registry
+ * (last updated 2021-10-01).
+ *
+ * Unless otherwise noted, the status code is defined in RFC2616.
+ */
+declare const statusTexts: {
+  [key: number]: string;
+};
+//#endregion
+//#region src/Testing/supertestAdapter.d.ts
+declare function supertestAdapter(app?: Application, serviceProviders?: ServiceProvider[]): Promise<(req: IncomingMessage, res: ServerResponse) => Promise<any>>;
+declare const testApp: (app?: Application, serviceProviders?: ServiceProvider[]) => Promise<supertest_lib_agent0<supertest.SuperTestStatic.Test>>;
+//#endregion
+//#region src/Console/Commands/BuildCommand.d.ts
+declare class BuildCommand extends Command {
+  /**
+   * The name and signature of the console command.
+   *
+   * @var string
+   */
+  protected signature: string;
+  /**
+   * The console command description.
+   *
+   * @var string
+   */
+  protected description: string;
+  handle(): Promise<void>;
+  protected fire(): Promise<void>;
+  /**
+   * build
+   */
+  static build({
+    debug,
+    minify,
+    mute,
+    verbosity,
+    outDir
+  }?: {
+    mute: boolean;
+    debug: boolean;
+    minify: boolean;
+    verbosity: number;
+    outDir: string;
+  }): Promise<void | execa0.Result<{
+    stdout: "inherit";
+    stderr: "inherit";
+    cwd: string;
+    env: NodeJS.ProcessEnv & {
+      EXTENDED_DEBUG: string;
+      CLI_BUILD: string;
+      NODE_ENV: string;
+      DIST_DIR: string;
+      DIST_MINIFY: boolean;
+      LOG_LEVEL: string;
+    };
+  }>>;
+}
+//#endregion
+//#region src/Console/Commands/KeyGenerateCommand.d.ts
+declare class KeyGenerateCommand extends Command {
+  /**
+   * The name and signature of the console command.
+   *
+   * @var string
+   */
+  protected signature: string;
+  /**
+   * The console command description.
+   *
+   * @var string
+   */
+  protected description: string;
+  handle(): Promise<void>;
+}
+//#endregion
+//#region src/Console/Commands/MakeCommand.d.ts
+declare class MakeCommand extends Command {
+  /**
+   * The name and signature of the console command.
+   *
+   * @var string
+   */
+  protected signature: string;
+  /**
+   * The console command description.
+   *
+   * @var string
+   */
+  protected description: string;
+  handle(this: any): Promise<void>;
+  /**
+   * Create a new controller class.
+   */
+  protected makeController(): Promise<void>;
+  protected makeResource(): void;
+  /**
+   * Create a new Musket command
+   */
+  protected makeCommand(): void;
+  /**
+   * Create a new view.
+   */
+  protected makeView(): Promise<void>;
+}
+//#endregion
+//#region src/Console/Commands/PostinstallCommand.d.ts
+declare class PostinstallCommand extends Command {
+  /**
+   * The name and signature of the console command.
+   *
+   * @var string
+   */
+  protected signature: string;
+  /**
+   * The console command description.
+   *
+   * @var string
+   */
+  protected description: string;
+  handle(): Promise<void>;
+  /**
+   * Create sqlite database if none exist
+   *
+   * @returns
+   */
+  private genEncryptionKey;
+  /**
+   * Create sqlite database if none exist
+   *
+   * @returns
+   */
+  private createSqliteDB;
+}
+//#endregion
+//#region src/Core/Events/Terminating.d.ts
+declare class Terminating {}
+//#endregion
+//#region src/Database/Exceptions/RecordsNotFoundException.d.ts
+declare class RecordsNotFoundException extends NotFoundHttpException {}
+//#endregion
+//#region src/Database/Exceptions/ModelNotFoundException.d.ts
+declare class ModelNotFoundException extends RecordsNotFoundException {
+  /**
+   * Name of the affected Eloquent model.
+   */
+  protected model?: ConcreteConstructor<IModel>;
+  /**
+   * The affected model IDs.
+   */
+  protected ids: (number | string)[];
+  /**
+   * Set the affected Eloquent model and instance ids.
+   *
+   * @param  model
+   * @param  ids
+   */
+  setModel(model: ConcreteConstructor<IModel>, ids?: (number | string)[]): this;
+  /**
+   * Get the affected Eloquent model.
+   */
+  getModel(): ConcreteConstructor<IModel<any>> | undefined;
+  /**
+   * Get the affected Eloquent model IDs.
+   */
+  getIds(): (string | number)[];
+}
+//#endregion
+//#region src/Database/Exceptions/RecordNotFoundException.d.ts
+declare class RecordNotFoundException extends Error {}
+//#endregion
+//#region src/Exceptions/Base/Handler.d.ts
+/**
+ *
+ * Base Exception Handler
+ * .
+ *  - We will use `RateLimiterAdapter` to plug in Redis / cache-backed limiters later.
+ */
+declare abstract class Handler extends IExceptionHandler {
+  /**
+   * List of exception constructors that should not be reported.
+   */
+  protected dontReportList: ExceptionConstructor[];
+  /**
+   * A map of exceptions with their corresponding custom log levels.
+   */
+  protected levels: Map<string | Error, "error" | "debug" | "info" | "warn" | "log">;
+  /**
+   * Internal exceptions that are not reported by default. Subclasses may expand.
+   */
+  protected internalDontReport: ExceptionConstructor[];
+  /**
+   * Callbacks that inspect exceptions to determine if they should NOT be reported.
+   */
+  protected dontReportCallbacks: ExceptionConditionCallback[];
+  /**
+   * Reportable callbacks (can cancel reporting by returning false).
+   */
+  protected reportCallbacks: ReportExceptionCallback[];
+  /**
+   * Render callbacks (can return a Response for a specific exception type).
+   */
+  protected renderCallbacks: RenderExceptionCallback[];
+  /**
+   * Exception mapping: from constructor.mapper function (returns instance or new error).
+   */
+  protected exceptionMap: Map<ExceptionConstructor, (error: any) => any>;
+  /**
+   * Throttle callbacks: return limit spec or Unlimited or null
+   */
+  protected throttleCallbacks: ThrottleExceptionCallback[];
+  /**
+   * Context callbacks for building log context
+   */
+  protected contextCallbacks: Array<(e: any, current?: Record<string, any>) => Record<string, any>>;
+  /**
+   * Determines whether to hash throttle keys (default true)
+   */
+  protected hashThrottleKeys: boolean;
+  /**
+   * Whether to avoid reporting duplicates
+   */
+  protected withoutDuplicates: boolean;
+  /**
+   * Map of already reported exceptions (WeakMap to allow GC)
+   */
+  protected reportedExceptionMap: WeakMap<object, boolean>;
+  /**
+   * Rate limiter adapter — can be replaced by container / DI.
+   */
+  protected rateLimiter: RateLimiterAdapter;
+  /**
+   * The exception handler method
+   *
+   * @param error
+   * @param ctx
+   */
+  handle?(error: Error, ctx: IHttpContext): Promise<any>;
+  /**
+   * Finalize response callback (respondUsing)
+   *
+   * @param response
+   * @param error
+   * @param request
+   */
+  protected finalizeResponseCallback?: (response: IResponse, error: any, request: IRequest) => IResponse | Promise<IResponse>;
+  /**
+   * Callback to determine if JSON should be returned
+   *
+   * @param request
+   * @param error
+   */
+  protected shouldRenderJsonWhenCallback?: (request: IRequest, error: any) => boolean;
+  /**
+   * Register a reportable callback handler
+   *
+   * @param cb
+   * @returns
+   */
+  reportable(cb: ReportExceptionCallback): this;
+  renderable(cb: RenderExceptionCallback): this;
+  dontReport(exceptions: ExceptionConstructor | ExceptionConstructor[]): this;
+  stopIgnoring(exceptions: ExceptionConstructor | ExceptionConstructor[]): this;
+  dontReportWhen(cb: ExceptionConditionCallback): this;
+  dontReportDuplicates(): this;
+  map(from: ExceptionConstructor, mapper: (error: any) => any): this;
+  throttleUsing(cb: ThrottleExceptionCallback): this;
+  buildContextUsing(cb: (e: any, current?: Record<string, any>) => Record<string, any>): this;
+  setRateLimiter(adapter: RateLimiterAdapter): this;
+  respondUsing(cb: (response: IResponse, error: any, request: IRequest) => IResponse | Promise<IResponse>): this;
+  shouldRenderJsonWhen(cb: (request: IRequest, error: any) => boolean): this;
+  /**
+   * Entry point to reporting an exception.
+   *
+   * @param error
+   * @returns
+   */
+  report(error: Error): Promise<void>;
+  /**
+   * Render an exception to the console.
+   *
+   * @param e
+   */
+  renderForConsole(e: Error): void;
+  /**
+   * Internal reporting pipeline.
+   *
+   * @param e
+   * @returns
+   */
+  protected reportThrowable(e: any): Promise<void>;
+  /**
+   * Decide whether an exception should not be reported.
+   *
+   * @param e
+   * @returns
+   */
+  protected shouldntReport(e: any): boolean;
+  /**
+   * Throttle evaluation. Returns true when reporting should be skipped.
+   *
+   * @param e
+   * @returns
+   */
+  protected isThrottled(e: any): Promise<boolean>;
+  /**
+   * Apply mappings and unwrap inner exceptions if present.
+   *
+   * @param error
+   * @returns
+   */
+  protected mapException(error: any): any;
+  /**
+   * Render an exception into an HTTP Response.
+   *
+   * @param ctx
+   * @param error
+   * @returns
+   */
+  render(request: IRequest, error: any): Promise<IResponse>;
+  /**
+   * getResponse
+   */
+  getResponse(request: IRequest, payload: Record<string, any>, e: any): IResponse | Promise<IResponse>;
+  /**
+   * Default non-JSON response (simple string). Subclass to integrate templating.
+   *
+   * @param request
+   * @param e
+   * @returns
+   */
+  protected prepareResponse(request: IRequest, e: any): IResponse | Promise<IResponse>;
+  /**
+   * Finalizes a rendered response using the finalize callback if present.
+   *
+   * @param request
+   * @param response
+   * @param e
+   * @returns
+   */
+  protected finalizeRenderedResponse(request: IRequest, response: IResponse, e: any): Promise<IResponse>;
+  /**
+   * Decide whether to return JSON.
+   *
+   * @param request
+   * @param e
+   * @returns
+   */
+  protected shouldReturnJson(request: IRequest, e: any): boolean;
+  /**
+   * Prepare a Json Response for the exception.
+   *
+   * Subclasses can override convertExceptionToArray for different debug behavior.
+   *
+   * @param _request
+   * @param e
+   * @returns
+   */
+  protected prepareJsonResponse(_request: IRequest, e: any): IResponse;
+  /**
+   * Convert exception into debug-friendly array/object.
+   *
+   * @param e
+   * @returns
+   */
+  protected convertExceptionToArray(e: any): {
+    message?: string;
+    exception?: string;
+    trace?: string[];
+  };
+  /**
+   * Build final exception context for logging.
+   *
+   * @param e
+   * @returns
+   */
+  protected buildExceptionContext(e: any): Record<string, any>;
+  /**
+   * Allow exceptions to supply their own context via `context()` method.
+   *
+   * @param e
+   * @returns
+   */
+  protected exceptionContext(e: any): Record<string, any>;
+  /**
+   * Default contextual info for logs (e.g., user id).
+   *
+   * Subclasses may override. Try/catch to avoid breaking logging flow.
+   */
+  protected context(): Record<string, any>;
+  /**
+   * Check if a method is an instance of any of the listed classes
+   *
+   * @param e
+   * @param list
+   * @returns
+   */
+  protected isInstanceOfAny(e: any, list: ExceptionConstructor[]): boolean;
+  /**
+   * Check if an exxeption is an HTTP execption
+   *
+   * @param e
+   * @returns
+   */
+  protected isHttpException(e: any): e is HttpExceptionFactory;
+  /**
+   * Default mapping — subclasses can override for custom logic
+   *
+   * @param _e
+   */
+  protected mapLogLevel(e: string | Error): Exclude<keyof typeof Console, 'prototype'>;
+  /**
+   * Subclasses should return PSR-like logger (object with methods like error, warn, info or a `log` fn)
+   */
+  protected newLogger(): typeof Console;
+  /**
+   * Hook to read from config/environment. Subclass or container should supply real value.
+   */
+  protected appDebug(): boolean;
+  /**
+   * Lightweight hash to avoid leaking raw keys in shared stores.
+   * In the future, will be replaced with a real hash (xxh128 / sha256) if needed.
+   *
+   * @param key
+   */
+  protected hashKey(key: string): string;
+  /**
+   * Not implemented in core. Subclass can implement and call RequestException helpers.
+   *
+   * @param _length
+   */
+  truncateRequestExceptionsAt(_length: number): this;
+  /**
+   * Set the log level
+   *
+   * @param _attributes
+   */
+  level(type: string | Error, level: Exclude<keyof typeof Console, 'prototype'>): this;
+  /**
+   * Not implemented here; applicable to validation pipeline/UI.
+   *
+   * @param _attributes
+   */
+  dontFlash(_attributes: string | string[]): this;
+}
+//#endregion
+//#region src/Exceptions/Base/ExceptionHandler.d.ts
+declare class ExceptionHandler extends Handler {
+  handle(error: Error, ctx: IHttpContext): Promise<_h3ravel_contracts0.IResponse | _h3ravel_contracts0.IResponsable>;
+}
+//#endregion
+//#region src/Exceptions/Base/RequestException.d.ts
+declare class RequestException {
+  #private;
+  /**
+   * The HTTP status code for this error.
+   */
+  status: number;
+  /**
+   * The response instance.
+   */
+  response: IResponse;
+  /**
+   * Create a new exception instance.
+   */
+  constructor(response: IResponse);
+  /**
+   * Enable truncation of request exception messages.
+   *
+   * @return void
+   */
+  static truncate(): void;
+  /**
+   * Set the truncation length for request exception messages.
+   *
+   * @param  int  $length
+   */
+  static truncateAt(length: number): void;
+  /**
+   * Disable truncation of request exception messages.
+   *
+   * @return void
+   */
+  static dontTruncate(): void;
+  /**
+   * Prepare the exception message.
+   */
+  protected prepareMessage(response: IResponse): string;
+}
+//#endregion
+//#region src/Exceptions/Base/Exceptions.d.ts
+declare class Exceptions {
+  handler: IExceptionHandler;
+  /**
+   * Create a new exception handling configuration instance.
+   */
+  constructor(handler: IExceptionHandler);
+  /**
+   * Register a reportable callback.
+   */
+  report(using: (...args: any[]) => any): IExceptionHandler;
+  /**
+   * Register a reportable callback.
+   */
+  reportable(reportUsing: (...args: any[]) => any): IExceptionHandler;
+  /**
+   * Register a renderable callback.
+   */
+  render(using: (...args: any[]) => any): this;
+  /**
+   * Register a renderable callback.
+   */
+  renderable(renderUsing: (...args: any[]) => any): this;
+  /**
+   * Register a callback to prepare the final rendered exception response.
+   */
+  respond(using: (...args: any[]) => any): this;
+  /**
+   * Specify the callback that should be used to throttle reportable exceptions.
+   */
+  throttle(throttleUsing: (...args: any[]) => any): this;
+  /**
+   * Register a new exception mapping.
+   */
+  map(from: typeof RequestException | ((e: any) => any), to?: typeof RequestException | ((e: any) => any)): this;
+  /**
+   * Set the log level for the given exception type.
+   */
+  level(type: string | Error, level: 'log' | 'debug' | 'warn' | 'info' | 'error'): this;
+  /**
+   * Register a closure that should be used to build exception context data.
+   */
+  context(contextCallback: (...args: any[]) => Record<string, any>): this;
+  /**
+   * Indicate that the given exception type should not be reported.
+   */
+  dontReport(classOrArray: typeof RequestException | typeof RequestException[]): this;
+  /**
+   * Register a callback to determine if an exception should not be reported.
+   */
+  dontReportWhen(dontReportWhen: (error: Error) => boolean): this;
+  /**
+   * Do not report duplicate exceptions.
+   */
+  dontReportDuplicates(): this;
+  /**
+   * Indicate that the given attributes should never be flashed to the session on validation errors.
+   */
+  dontFlash(attributes: string | string[]): this;
+  /**
+   * Register the callable that determines if the exception handler response should be JSON.
+   */
+  shouldRenderJsonWhen(callback: (request: any, error: Error) => boolean): this;
+  /**
+   * Render an exception to the console.
+   *
+   * @param e
+   */
+  renderForConsole(e: Error): void;
+  /**
+   * Indicate that the given exception class should not be ignored.
+   */
+  stopIgnoring(classOrArray: typeof RequestException | typeof RequestException[]): this;
+  /**
+   * Set the truncation length for request exception messages.
+   */
+  truncateRequestExceptionsAt(length: number): this;
+  /**
+   * Disable truncation of request exception messages.
+   */
+  dontTruncateRequestExceptions(): this;
+}
+//#endregion
+//#region src/Exceptions/Base/HttpException.d.ts
+/**
+ * HttpException.
+ */
+declare class HttpException extends Error {
+  protected statusCode: number;
+  message: string;
+  protected previous?: Error | undefined;
+  protected headers: Record<string, string>;
+  code: number;
+  constructor(statusCode: number, message?: string, previous?: Error | undefined, headers?: Record<string, string>, code?: number);
+  static fromStatusCode(statusCode: number, message?: string, previous?: Error, headers?: Record<string, string>, code?: number): AccessDeniedHttpException | BadRequestHttpException | ConflictHttpException | GoneHttpException | LengthRequiredHttpException | LockedHttpException | NotAcceptableHttpException | NotFoundHttpException | PreconditionFailedHttpException | PreconditionRequiredHttpException | ServiceUnavailableHttpException | TooManyRequestsHttpException | UnprocessableEntityHttpException | UnsupportedMediaTypeHttpException | HttpException;
+  getStatusCode(): number;
+  getHeaders(): Record<string, string>;
+  setHeaders(headers: Record<string, string>): void;
+}
+//#endregion
+//#region src/Exceptions/Core/BindingResolutionException.d.ts
+declare class BindingResolutionException extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/Exceptions/Core/ConfigException.d.ts
+declare class ConfigException extends Error {
+  key: string;
+  constructor(key: string, type?: 'any' | 'config' | 'env', cause?: unknown);
+}
+//#endregion
+//#region src/Exceptions/Core/LogicException.d.ts
+declare class LogicException extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/Http/Events/RequestHandled.d.ts
+declare class RequestHandled {
+  /**
+   * The request instance.
+   */
+  request: IRequest;
+  /**
+   * The response instance.
+   */
+  response?: IResponse;
+  /**
+   * Create a new event instance.
+   *
+   * @param  request
+   * @param  response
+   */
+  constructor(request: IRequest, response?: IResponse);
+}
+//#endregion
+export { AccessDeniedHttpException, AppBuilder, BadRequestHttpException, BindingResolutionException, BootProviders, BuildCommand, CommandNotFoundException, ConfigException, ConflictHttpException, ConsoleKernel, ExceptionHandler, Exceptions, GoneHttpException, HTTP_RESPONSE_CACHE_CONTROL_DIRECTIVES, Handler, Helpers, HttpException, HttpExceptionFactory, InMemoryRateLimiter, Inject, Injectable, Kernel, KeyGenerateCommand, LengthRequiredHttpException, LockedHttpException, LogicException, MakeCommand, Middleware, MiddlewareHandler, ModelNotFoundException, NotAcceptableHttpException, NotFoundHttpException, PostinstallCommand, PreconditionFailedHttpException, PreconditionRequiredHttpException, RecordNotFoundException, RecordsNotFoundException, RegisterFacades, RequestException, RequestHandled, ResponseCodes, RouteNotFoundException, ServiceUnavailableHttpException, Terminating, TooManyRequestsHttpException, TsDownConfig, UnprocessableEntityHttpException, UnsupportedMediaTypeHttpException, UrlGenerationException, altLogo, logo, statusTexts, supertestAdapter, testApp };