@h3ravel/core 1.21.6 → 1.22.0-alpha.1

package/dist/index.d.ts

@@ -1,18 +1,55 @@
 /// <reference path="./app.globals.d.ts" />
-import { Bindings, HttpContext, IApplication, IContainer, IController, IMiddleware, IPathName, IServiceProvider, PathLoader, UseKey } from "@h3ravel/shared";
+import { PathLoader } from "@h3ravel/shared";
 import { H3, H3Event } from "h3";
-import { HttpContext as HttpContext$1 } from "@h3ravel/http";
+import { Bindings, CallableConstructor, ClassConstructor, ConcreteConstructor, ExtractClassMethods, GenericObject, IApplication, IBinding, IBootstraper, IContainer, IController, IHttpContext, IMiddleware, IPathName, IRegisterer, IRouter, IServiceProvider, IUrl, UseKey } from "@h3ravel/contracts";
+import { AppBuilder, Inject, Injectable, MiddlewareHandler, ResponseCodes } from "@h3ravel/foundation";
+import { ServiceProvider } from "@h3ravel/support";
 
-//#region src/Contracts/ServiceProviderConstructor.d.ts
-type ServiceProviderConstructor = (new (app: Application) => ServiceProvider) & IServiceProvider;
-type AServiceProvider = (new (_app: Application) => ServiceProvider) & Partial<ServiceProvider>;
-type OServiceProvider = (new (_app: Application) => Partial<ServiceProvider>) & Partial<ServiceProvider>;
-//#endregion
 //#region src/Container.d.ts
-type IBinding = UseKey | (new (..._args: any[]) => unknown);
-declare class Container implements IContainer {
+declare class Container extends IContainer {
   bindings: Map<IBinding, () => unknown>;
   singletons: Map<IBinding, unknown>;
+  middlewareHandler?: MiddlewareHandler;
+  /**
+   * The current globally available container (if any).
+   */
+  protected static instance?: Application;
+  /**
+   * All of the before resolving callbacks by class type.
+   */
+  private beforeResolvingCallbacks;
+  /**
+   * All of the after resolving callbacks by class type.
+   */
+  private afterResolvingCallbacks;
+  /**
+   * All of the registered rebound callbacks.
+   */
+  protected reboundCallbacks: Map<string | (new (...args: any[]) => unknown), ((...args: any[]) => any)[]>;
+  /**
+   * The container's shared instances.
+   */
+  protected instances: Map<string | (new (...args: any[]) => unknown), new (...args: any[]) => any>;
+  /**
+   * The container's resolved instances.
+   */
+  protected resolvedInstances: Map<string | (new (...args: any[]) => unknown), any>;
+  /**
+   * The registered type alias.
+   */
+  protected aliases: Map<string | ClassConstructor, any>;
+  /**
+   * The registered aliases keyed by the abstract name.
+   */
+  protected abstractAliases: Map<string | ClassConstructor, any[]>;
+  /**
+   * The registered aliases keyed by the abstract name.
+   */
+  protected middlewares: Map<string | IMiddleware, IMiddleware>;
+  /**
+   * The extension closures for services.
+   */
+  protected extenders: Map<string | (new (...args: any[]) => unknown), CallableConstructor[]>;
   /**
    * Check if the target has any decorators
    *
@@ -23,106 +60,317 @@ declare class Container implements IContainer {
   static hasAnyDecorator<F extends (...args: any[]) => any>(target: F): boolean;
   /**
    * Bind a transient service to the container
+   *
+   * @param key
+   * @param factory
    */
   bind<T>(key: new (...args: any[]) => T, factory: () => T): void;
   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
+   */
+  bindMiddleware(key: IMiddleware | string, middleware: ConcreteConstructor<IMiddleware>): void;
+  /**
+   * Get all bound and unregistered middlewares in the service container
+   *
+   * @param key
+   * @param middleware
+   */
+  boundMiddlewares(): MapIterator<[string | IMiddleware, IMiddleware]>;
+  boundMiddlewares(key: IMiddleware | string): IMiddleware;
   /**
    * Remove one or more transient services from the container
+   *
+   * @param key
    */
   unbind<T extends UseKey>(key: T | T[]): void;
   /**
    * Bind a singleton service to the container
+   *
+   * @param key
+   * @param factory
+   */
+  singleton<T extends UseKey>(key: T | (new (...args: any[]) => Bindings[T]), factory: (app: this) => Bindings[T]): void;
+  singleton<T extends UseKey>(key: T | (abstract new (...args: any[]) => Bindings[T]), factory: (app: this) => Bindings[T]): void;
+  singleton<T extends UseKey>(key: T | (new (...args: any[]) => Bindings[T]), factory: abstract new (...args: any[]) => any): void;
+  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
    */
-  singleton<T extends UseKey>(key: T | (new (..._args: any[]) => Bindings[T]), factory: (app: this) => Bindings[T]): void;
+  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
+   * Read reflected param types, resolve dependencies from the container and return the result
+   *
+   * @param instance
+   * @param method
+   */
+  resolveParams<X extends InstanceType<ClassConstructor>, M extends ExtractClassMethods<X>>(instance: X, method: M): any[];
+  /**
+   * Resolve the gevein service from the container
+   *
+   * @param key
    */
   make<T extends UseKey>(key: T): Bindings[T];
   make<C extends abstract new (...args: any[]) => any>(key: C): InstanceType<C>;
   make<F extends (...args: any[]) => any>(key: F): ReturnType<F>;
+  /**
+   * Resolve the gevein service from the container
+   *
+   * @param abstract
+   * @param raiseEvents
+   */
+  resolve(abstract: any, raiseEvents?: boolean): any;
+  /**
+   * Register a callback to be executed after a service is resolved
+   *
+   * @param key
+   * @param callback
+   */
+  afterResolving<T extends UseKey>(key: T, callback: (resolved: Bindings[T], app: this) => void): void;
+  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
+   */
+  beforeResolving<T extends UseKey>(key: T, callback: (app: this) => void): void;
+  beforeResolving<T extends abstract new (...args: any[]) => any>(key: T, callback: (app: this) => void): void;
+  /**
+   * Execute all registered beforeResolving callbacks for a given key
+   *
+   * @param  key
+   * @param resolved
+   */
+  private runBeforeResolvingCallbacks;
+  /**
+   * Execute all registered afterResolving callbacks for a given key
+   *
+   * @param key
+   * @param resolved
+   */
+  private runAfterResolvingCallbacks;
   /**
    * Automatically build a class with constructor dependency injection
+   *
+   * @param ClassType
+   * @returns
    */
   private build;
+  /**
+   * Determine if a given string is an alias.
+   *
+   * @param name
+   */
+  isAlias(name: IBinding | string): boolean;
+  /**
+   * Get the alias for an abstract if available.
+   *
+   * @param  abstract
+   */
+  getAlias(abstract: any): any;
+  /**
+   * Get the extender callbacks for a given type.
+   *
+   * @param  abstract
+   */
+  protected getExtenders(abstract: string | IBinding): CallableConstructor[];
+  /**
+   * Remove all of the extender callbacks for a given type.
+   *
+   * @param  abstract
+   */
+  forgetExtenders(abstract: string | IBinding): void;
+  /**
+   * Set the alias for an abstract.
+   *
+   * @param token
+   * @param target
+   */
+  alias(key: [string | ClassConstructor, any][]): this;
+  alias(key: string | ClassConstructor, target: any): this;
+  /**
+   * Bind a new callback to an abstract's rebind event.
+   *
+   * @param  abstract
+   * @param  callback
+   */
+  rebinding<T extends UseKey>(key: T | (new (...args: any[]) => Bindings[T]), callback: (app: this, inst: Bindings[T]) => Bindings[T] | void): void;
+  rebinding<T extends UseKey>(key: T | (abstract new (...args: any[]) => Bindings[T]), callback: (app: this, inst: Bindings[T]) => Bindings[T] | void): void;
+  /**
+   * Determine if the given abstract type has been bound.
+   *
+   * @param  string  $abstract
+   * @returns
+   */
+  bound<T extends UseKey>(abstract: T): boolean;
+  bound<C extends abstract new (...args: any[]) => any>(abstract: C): boolean;
+  bound<F extends (...args: any[]) => any>(abstract: F): boolean;
   /**
    * Check if a service is registered
+   *
+   * @param key
+   * @returns
    */
-  has(key: UseKey): boolean;
-}
-//#endregion
-//#region src/ServiceProvider.d.ts
-declare const Inference: {
-  new (): IServiceProvider;
-};
-declare abstract class ServiceProvider extends Inference {
+  has<T extends UseKey>(key: T): boolean;
+  has<C extends abstract new (...args: any[]) => any>(key: C): boolean;
+  has<F extends (...args: any[]) => any>(key: F): boolean;
   /**
-   * The current app instance
+   * Determine if the given abstract type has been resolved.
+   *
+   * @param abstract
    */
-  protected app: Application;
+  resolved(abstract: IBinding | string): boolean;
   /**
-   * Unique Identifier for the service providers
+   * "Extend" an abstract type in the container.
+   *
+   * @param  abstract
+   * @param  closure
+   *
+   * @throws {InvalidArgumentException}
    */
-  static uid?: number;
+  extend<T extends UseKey>(key: T | (new (...args: any[]) => Bindings[T]), closure: (inst: Bindings[T], app: this) => Bindings[T]): void;
+  extend<T extends UseKey>(key: T | (abstract new (...args: any[]) => Bindings[T]), closure: (inst: Bindings[T], app: this) => Bindings[T]): void;
   /**
-   * Sort order
+   * Register an existing instance as shared in the container.
+   *
+   * @param  abstract
+   * @param  instance
    */
-  static order?: `before:${string}` | `after:${string}` | string | undefined;
+  instance<X = any>(key: string, instance: X): X;
+  instance<K extends abstract new (...args: any[]) => any, X = any>(abstract: K, instance: X): X;
   /**
-   * Sort priority
+   * Call the given method and inject its dependencies.
+   *
+   * @param  callback
    */
-  static priority: number;
+  call<C extends abstract new (...args: any[]) => any>(callback: C): any | Promise<any>;
+  call<F extends (...args: any[]) => any>(callback: F): any | Promise<any>;
   /**
-   * Indicate that this service provider only runs in console
+   * Fire the "rebound" callbacks for the given abstract type.
+   *
+   * @param abstract
    */
-  static console: boolean;
+  protected rebound(abstract: any): void;
   /**
-   * List of registered console commands
+   * Get the rebound callbacks for a given type.
+   *
+   * @param abstract
    */
-  registeredCommands?: (new (app: any, kernel: any) => any)[];
-  constructor(app: Application);
+  protected getReboundCallbacks(abstract: any): ((...args: any[]) => any)[];
   /**
-   * Register bindings to the container.
-   * Runs before boot().
+   * Remove an alias from the contextual binding alias cache.
+   *
+   * @param  searched
    */
-  abstract register(...app: unknown[]): void | Promise<void>;
+  protected removeAbstractAlias(searched: string): void;
   /**
-   * Perform post-registration booting of services.
-   * Runs after all providers have been registered.
+   * Get the globally available instance of the container.
    */
-  boot?(...app: unknown[]): void | Promise<void>;
+  static getInstance(): Application;
   /**
-   * Register the listed service providers.
+   * Set the shared instance of the container.
    *
-   * @param commands An array of console commands to register.
+   * @param container
+   */
+  static setInstance(container?: Application): Application | undefined;
+}
+//#endregion
+//#region src/Contracts/H3ravelContract.d.ts
+interface EntryConfig {
+  /**
+   * @param h3 You can provide your own `H3` app instance, this is usefull when `@h3ravel/http`
+   * is not installed.
+   */
+  h3?: H3;
+  /**
+   * @param H3Event You can provide your own `H3Event` app instance, this is usefull for testing scenarios.
+   */
+  h3Event?: H3Event;
+  /**
+   * Determines if we should initialize the app on call.
    *
-   * @deprecated since version 1.16.0. Will be removed in future versions, use `registerCommands` instead
+   * @default false
    */
-  commands(commands: (new (app: any, kernel: any) => any)[]): void;
+  initialize?: boolean;
   /**
-   * Register the listed service providers.
+   * Determines if service providers should be auto discovered and registered or not.
    *
-   * @param commands An array of console commands to register.
+   * @default false
+   */
+  autoload?: boolean;
+  /**
+   * A list of service provider name strings we do not want to register at all cost
+   *
+   * @default []
    */
-  registerCommands(commands: (new (app: any, kernel: any) => any)[]): void;
+  filteredProviders?: string[];
+  /**
+   * Overide the defined system path
+   */
+  customPaths?: Partial<Record<'base' | 'views' | 'assets' | 'routes' | 'config' | 'public' | 'storage' | 'database', string>>;
 }
 //#endregion
 //#region src/Application.d.ts
 declare class Application extends Container implements IApplication {
+  #private;
+  protected initializer?: string | undefined;
   paths: PathLoader;
-  context?: (event: H3Event) => Promise<HttpContext>;
+  context?: (event: H3Event) => Promise<IHttpContext>;
+  h3Event?: H3Event;
   private tries;
-  private booted;
   private basePath;
   private versions;
+  private namespace?;
   private static versions;
+  private h3App?;
   private providers;
-  protected externalProviders: Array<AServiceProvider>;
+  protected externalProviders: Array<ConcreteConstructor<IServiceProvider, false>>;
   protected filteredProviders: Array<string>;
+  private autoRegisterProviders;
+  /**
+   * The route resolver callback.
+   */
+  protected uriResolver?: () => typeof IUrl;
   /**
    * List of registered console commands
    */
   registeredCommands: (new (app: any, kernel: any) => any)[];
-  constructor(basePath: string);
+  /**
+   * The array of booted callbacks.
+   */
+  protected bootedCallbacks: Array<(app: this) => void>;
+  /**
+   * The array of booting callbacks.
+   */
+  protected bootingCallbacks: Array<(app: this) => void>;
+  /**
+   * The array of terminating callbacks.
+   */
+  protected terminatingCallbacks: Array<(app: this) => void>;
+  /**
+   * Indicates if the application has been bootstrapped before.
+   */
+  protected bootstrapped: boolean;
+  /**
+   * Controls logging
+   */
+  private logsDisabled;
+  /**
+   * The conrrent HttpContext
+   */
+  private httpContext?;
+  constructor(basePath: string, initializer?: string | undefined);
   /**
    * Register core bindings into the container
    */
@@ -131,7 +379,7 @@ declare class Application extends Container implements IApplication {
   /**
    * Get all registered providers
    */
-  getRegisteredProviders(): ServiceProvider[];
+  getRegisteredProviders(): IServiceProvider[];
   /**
    * Load default and optional providers dynamically
    *
@@ -140,8 +388,8 @@ declare class Application extends Container implements IApplication {
    * Minimal App: Loads only core, config, http, router by default.
    * Full-Stack App: Installs database, mail, queue, cache → they self-register via their providers.
    */
-  protected getConfiguredProviders(): Promise<Array<AServiceProvider>>;
-  protected getAllProviders(): Promise<Array<AServiceProvider>>;
+  protected getConfiguredProviders(): Promise<ConcreteConstructor<IServiceProvider, false>[]>;
+  protected getAllProviders(): Promise<Array<ConcreteConstructor<IServiceProvider, false>>>;
   /**
    * Configure and Dynamically register all configured service providers, then boot the app.
    *
@@ -151,24 +399,22 @@ declare class Application extends Container implements IApplication {
    *
    * @returns
    */
-  quickStartup(providers: Array<AServiceProvider>, filtered?: string[], autoRegisterProviders?: boolean): Promise<this>;
+  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.
    */
-  registerConfiguredProviders(autoRegister?: boolean): Promise<void>;
+  registerConfiguredProviders(): Promise<void>;
   /**
    * Register service providers
    *
    * @param providers
    * @param filtered
    */
-  registerProviders(providers: Array<AServiceProvider>, filtered?: string[]): void;
+  registerProviders(providers: Array<ConcreteConstructor<IServiceProvider, false>>, filtered?: string[]): void;
   /**
    * Register a provider
    */
-  register(provider: ServiceProvider): Promise<void>;
+  register(provider: IServiceProvider): Promise<void>;
   /**
    * Register the listed service providers.
    *
@@ -179,11 +425,103 @@ declare class Application extends Container implements IApplication {
    * checks if the application is running in CLI
    */
   runningInConsole(): boolean;
+  /**
+   * checks if the application is running in Unit Test
+   */
+  runningUnitTests(): boolean;
   getRuntimeEnv(): 'browser' | 'node' | 'unknown';
+  /**
+   * Determine if the application has booted.
+   */
+  isBooted(): boolean;
+  /**
+   * Determine if the application has booted.
+   */
+  logging(logging?: boolean): this;
+  protected logsEnabled(): boolean;
   /**
    * Boot all service providers after registration
    */
   boot(): Promise<this>;
+  /**
+   * Register a new boot listener.
+   *
+   * @param  callable  $callback
+   */
+  booting(callback: (app: this) => void): void;
+  /**
+   * Register a new "booted" listener.
+   *
+   * @param callback
+   */
+  booted(callback: (app: this) => void): void;
+  /**
+   * Throw an HttpException with the given data.
+   *
+   * @param  code
+   * @param  message
+   * @param  headers
+   *
+   * @throws {HttpException}
+   * @throws {NotFoundHttpException}
+   */
+  abort(code: ResponseCodes, message?: string, headers?: GenericObject): void;
+  /**
+   * Register a terminating callback with the application.
+   *
+   * @param  callback
+   */
+  terminating(callback: (app: this) => void): this;
+  /**
+   * Terminate the application.
+   */
+  terminate(): void;
+  /**
+   * Call the booting callbacks for the application.
+   *
+   * @param  callbacks
+   */
+  protected fireAppCallbacks(callbacks: Array<(app: this) => void>): void;
+  /**
+   * Handle the incoming HTTP request and send the response to the browser.
+   *
+   * @param  config  Configuration option to pass to the initializer
+   */
+  handleRequest(config?: EntryConfig): Promise<void>;
+  /**
+   * Build the http context
+   *
+   * @param event
+   * @param config
+   * @returns
+   */
+  buildContext(event: H3Event, config?: EntryConfig, fresh?: boolean): Promise<IHttpContext>;
+  /**
+   * Handle the incoming Artisan command.
+   */
+  handleCommand(): Promise<number>;
+  /**
+   * Get the URI resolver callback.
+   */
+  getUriResolver(): () => typeof IUrl | undefined;
+  /**
+   * Set the URI resolver callback.
+   *
+   * @param  callback
+   */
+  setUriResolver(callback: () => typeof IUrl): this;
+  /**
+   * Determine if middleware has been disabled for the application.
+   */
+  shouldSkipMiddleware(): boolean;
+  /**
+   * Provide safe overides for the app
+   */
+  configure(): AppBuilder;
+  /**
+   * Check if the current application environment matches the one provided
+   */
+  environment<E = string | undefined>(env: E): E extends undefined ? string : boolean;
   /**
    * Fire up the developement server using the user provided arguments
    *
@@ -191,9 +529,62 @@ declare class Application extends Container implements IApplication {
    *
    * @param h3App The current H3 app instance
    * @param preferedPort If provided, this will overide the port set in the evironment
+   * @alias serve
    */
   fire(): Promise<this>;
   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
+   */
+  serve(h3App?: H3, preferredPort?: number): Promise<this>;
+  /**
+   * Run the given array of bootstrap classes.
+   *
+   * @param bootstrappers
+   */
+  bootstrapWith(bootstrappers: ConcreteConstructor<IBootstraper>[]): Promise<void>;
+  /**
+   * Determine if the application has been bootstrapped before.
+   */
+  hasBeenBootstrapped(): boolean;
+  /**
+   * Save the curretn H3 instance for possible future use.
+   *
+   * @param h3App The current H3 app instance
+   * @returns
+   */
+  setH3App(h3App?: H3): this;
+  /**
+   * Set the HttpContext.
+   *
+   * @param  ctx
+   */
+  setHttpContext(ctx: IHttpContext): this;
+  /**
+   * Get the HttpContext.
+   */
+  getHttpContext(): IHttpContext | undefined;
+  /**
+   * @param key
+   */
+  getHttpContext<K extends keyof IHttpContext>(key: K): IHttpContext[K];
+  /**
+   * Get the application namespace.
+   *
+   * @throws {RuntimeException}
+   */
+  getNamespace(): string;
+  /**
+   * Get the path of the app dir
+   *
+   * @returns
+   */
+  path(): string;
   /**
    * Get the base path of the app
    *
@@ -230,68 +621,18 @@ declare class Application extends Container implements IApplication {
   static getVersion(key: string): string;
 }
 //#endregion
-//#region src/Contracts/H3ravelContract.d.ts
-interface EntryConfig {
-  /**
-   * @param h3 You can provide your own `H3` app instance, this is usefull when `@h3ravel/http`
-   * is not installed.
-   */
-  h3?: H3;
-  /**
-   * Determines if we should initialize the app on call.
-   *
-   * @default false
-   */
-  initialize?: boolean;
-  /**
-   * Determines if service providers should be auto discovered and registered or not.
-   *
-   * @default false
-   */
-  autoload?: boolean;
-  /**
-   * A list of service provider name strings we do not want to register at all cost
-   *
-   * @default []
-   */
-  filteredProviders?: string[];
-}
+//#region src/Contracts/ServiceProviderConstructor.d.ts
+type ServiceProviderConstructor = (new (app: Application) => ServiceProvider) & IServiceProvider;
+type AServiceProvider = (new (_app: Application) => ServiceProvider) & Partial<ServiceProvider>;
+type OServiceProvider = (new (_app: Application) => Partial<ServiceProvider>) & Partial<ServiceProvider>;
 //#endregion
 //#region src/Controller.d.ts
 /**
  * Base controller class
  */
-declare abstract class Controller implements IController {
+declare abstract class Controller extends IController {
   protected app: Application;
-  constructor(app: Application);
-  show?(..._ctx: any[]): any;
-  index?(..._ctx: any[]): any;
-  store?(..._ctx: any[]): any;
-  update?(..._ctx: any[]): any;
-  destroy?(..._ctx: any[]): any;
-}
-//#endregion
-//#region src/Di/ContainerResolver.d.ts
-declare class ContainerResolver {
-  private app;
-  constructor(app: Application);
-  resolveMethodParams<I extends Record<string, any>>(instance: I, method: keyof I, ..._default: any[]): Promise<I>;
-  static isClass(C: any): boolean;
-}
-//#endregion
-//#region src/Di/Inject.d.ts
-declare function Inject(...dependencies: string[]): (target: any) => void;
-/**
- * Allows binding dependencies to both class and class methods
- *
- * @returns
- */
-declare function Injectable(): ClassDecorator & MethodDecorator;
-//#endregion
-//#region src/Exceptions/ConfigException.d.ts
-declare class ConfigException extends Error {
-  key: string;
-  constructor(key: string, type?: 'any' | 'config' | 'env', cause?: unknown);
+  constructor(app?: Application);
 }
 //#endregion
 //#region src/H3ravel.d.ts
@@ -314,11 +655,7 @@ basePath?: string,
 /**
  * Configuration option to pass to the initializer
  */
-config?: EntryConfig,
-/**
- * final middleware function to call once the server is fired up
- */
-middleware?: (ctx: HttpContext$1) => Promise<unknown>) => Promise<Application>;
+config?: EntryConfig) => Promise<Application>;
 //#endregion
 //#region src/Http/Kernel.d.ts
 /**
@@ -326,13 +663,22 @@ middleware?: (ctx: HttpContext$1) => Promise<unknown>) => Promise<Application>;
  * It acts as the core middleware pipeline for HTTP requests.
  */
 declare class Kernel {
-  protected context: (event: H3Event) => HttpContext | Promise<HttpContext>;
-  protected middleware: IMiddleware[];
+  app: Application;
+  middleware: IMiddleware[];
   /**
-   * @param context - A factory function that converts an H3Event into an HttpContext.
+   * The router instance.
+   */
+  protected router: IRouter;
+  /**
+   * A factory function that converts an H3Event into an HttpContext.
+   */
+  protected context: (event: H3Event) => IHttpContext | Promise<IHttpContext>;
+  protected applicationContext: IHttpContext;
+  /**
+   * @param app - The current application instance
    * @param middleware - An array of middleware classes that will be executed in sequence.
    */
-  constructor(context: (event: H3Event) => HttpContext | Promise<HttpContext>, middleware?: IMiddleware[]);
+  constructor(app: Application, middleware?: IMiddleware[]);
   /**
    * Handles an incoming request and passes it through middleware before invoking the next handler.
    *
@@ -340,26 +686,25 @@ declare class Kernel {
    * @param next - A callback function that represents the next layer (usually the controller or final handler).
    * @returns A promise resolving to the result of the request pipeline.
    */
-  handle(event: H3Event, next: (ctx: HttpContext) => Promise<unknown>): Promise<unknown>;
+  handle(event: H3Event, next: (ctx: IHttpContext) => Promise<unknown>): Promise<unknown>;
   /**
-   * Sequentially runs middleware in the order they were registered.
-   *
-   * @param context - The standardized HttpContext.
-   * @param next - Callback to execute when middleware completes.
-   * @returns A promise resolving to the final handler's result.
+   * Resolve the provided callback using the current H3 event instance
    */
-  private runMiddleware;
-  /**
-   * Utility function to determine if a value is a plain object or array.
-   *
-   * @param value - The value to check.
-   * @returns True if the value is a plain object or array, otherwise false.
-   */
-  private isPlainObject;
+  resolve(event: H3Event, middleware: IMiddleware | IMiddleware[], handler: (ctx: IHttpContext) => Promise<any>): Promise<any>;
+}
+//#endregion
+//#region src/Manager/ContainerResolver.d.ts
+type Predicate = string | ((...args: any[]) => any) | (abstract new (...args: any[]) => any);
+declare class ContainerResolver {
+  private app;
+  constructor(app: IApplication);
+  resolveMethodParams<I extends Record<string, any>>(instance: I, method: keyof I, ..._default: any[]): Promise<I>;
+  static isClass(C: Predicate): C is new (...args: any[]) => any;
+  static isAbstract(C: Predicate): C is new (...args: any[]) => any;
+  static isCallable(C: Predicate): C is (...args: any[]) => any;
 }
 //#endregion
 //#region src/ProviderRegistry.d.ts
-type ProviderCtor = (new (_app: Application) => ServiceProvider) & Partial<ServiceProvider>;
 declare class ProviderRegistry {
   private static providers;
   private static priorityMap;
@@ -385,14 +730,14 @@ declare class ProviderRegistry {
    * @param providers
    * @returns
    */
-  static register(...providers: ProviderCtor[]): void;
+  static register(...providers: ConcreteConstructor<IServiceProvider, false>[]): void;
   /**
    * Bulk register providers from an array.
    *
    * @param providers
    * @returns
    */
-  static registerMany(providers: ProviderCtor[]): void;
+  static registerMany(providers: ConcreteConstructor<IServiceProvider, false>[]): void;
   /**
    * Set the filtered providers.
    *
@@ -405,14 +750,14 @@ declare class ProviderRegistry {
    * @param app
    * @returns
    */
-  static resolve(app: Application, useServiceContainer?: boolean): Promise<ServiceProvider[]>;
+  static resolve(app: Application, useServiceContainer?: boolean): Promise<IServiceProvider[]>;
   /**
    * Sort the service providers
    *
    * @param providers
    * @returns
    */
-  static sort(providers: ProviderCtor[]): ProviderCtor[];
+  static sort(providers: ConcreteConstructor<IServiceProvider, false>[]): ConcreteConstructor<IServiceProvider, false>[];
   /**
    * Sort service providers
    */
@@ -422,27 +767,27 @@ declare class ProviderRegistry {
    *
    * @param priorityMap
    */
-  static log<P extends ServiceProvider>(providers?: Array<P> | Map<string, P>): void;
+  static log<P extends IServiceProvider>(providers?: Array<P> | Map<string, P>, enabled?: boolean): void;
   /**
    * Get all registered providers as an array.
    *
    * @returns
    */
-  static all(): ProviderCtor[];
+  static all(): ConcreteConstructor<IServiceProvider, false>[];
   /**
    * Check if a provider is already registered.
    *
    * @param provider
    * @returns
    */
-  static has(provider: ProviderCtor): boolean;
+  static has(provider: ConcreteConstructor<IServiceProvider, false>): boolean;
   /**
    * Automatically search for and discover service providers in packages.
    *
    * @param autoRegister
    * @returns
    */
-  static discoverProviders(autoRegister?: boolean): Promise<ProviderCtor[]>;
+  static discoverProviders(autoRegister?: boolean): Promise<ConcreteConstructor<IServiceProvider, false>[]>;
   /**
    * Get the content of the package.json file
    *
@@ -469,7 +814,7 @@ declare class CoreServiceProvider extends ServiceProvider {
 }
 //#endregion
 //#region src/Registerer.d.ts
-declare class Registerer {
+declare class Registerer extends IRegisterer {
   private app;
   constructor(app: Application);
   static register(app: Application): void;
@@ -481,4 +826,4 @@ declare class Registerer {
   private databasePath;
 }
 //#endregion
-export { AServiceProvider, Application, ConfigException, Container, ContainerResolver, Controller, CoreServiceProvider, EntryConfig, Inject, Injectable, Kernel, OServiceProvider, ProviderRegistry, Registerer, ServiceProvider, ServiceProviderConstructor, h3ravel };
+export { AServiceProvider, Application, Container, ContainerResolver, Controller, CoreServiceProvider, EntryConfig, Inject, Injectable, Kernel, OServiceProvider, ProviderRegistry, Registerer, ServiceProvider, ServiceProviderConstructor, h3ravel };