@h3ravel/core 1.29.0-alpha.13 → 1.29.0-alpha.14

package/dist/index.d.ts

@@ -1 +1,841 @@
 /// <reference path="./app.globals.d.ts" />
+import { PathLoader } from "@h3ravel/shared";
+import { H3, H3Event } from "h3";
+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/Container.d.ts
+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
+   *
+   * @param target
+   * @returns
+   */
+  static hasAnyDecorator<C extends abstract new (...args: any[]) => any>(target: C): boolean;
+  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
+   */
+  invoke<X extends InstanceType<ClassConstructor>, M extends ExtractClassMethods<X>>(instance: X, method: M, defaultArgs?: any[], handler?: CallableConstructor): Promise<any>;
+  /**
+   * 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<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;
+  /**
+   * Determine if the given abstract type has been resolved.
+   *
+   * @param abstract
+   */
+  resolved(abstract: IBinding | string): boolean;
+  /**
+   * "Extend" an abstract type in the container.
+   *
+   * @param  abstract
+   * @param  closure
+   *
+   * @throws {InvalidArgumentException}
+   */
+  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;
+  /**
+   * Register an existing instance as shared in the container.
+   *
+   * @param  abstract
+   * @param  instance
+   */
+  instance<X = any>(key: string, instance: X): X;
+  instance<K extends abstract new (...args: any[]) => any, X = any>(abstract: K, instance: X): X;
+  /**
+   * Call the given method and inject its dependencies.
+   *
+   * @param  callback
+   */
+  call<C extends abstract new (...args: any[]) => any>(callback: C): any | Promise<any>;
+  call<F extends (...args: any[]) => any>(callback: F): any | Promise<any>;
+  /**
+   * Fire the "rebound" callbacks for the given abstract type.
+   *
+   * @param abstract
+   */
+  protected rebound(abstract: any): void;
+  /**
+   * Get the rebound callbacks for a given type.
+   *
+   * @param abstract
+   */
+  protected getReboundCallbacks(abstract: any): ((...args: any[]) => any)[];
+  /**
+   * Remove an alias from the contextual binding alias cache.
+   *
+   * @param  searched
+   */
+  protected removeAbstractAlias(searched: string): void;
+  /**
+   * Get the globally available instance of the container.
+   */
+  static getInstance(): Application;
+  /**
+   * Set the shared instance of the container.
+   *
+   * @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.
+   *
+   * @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[];
+  /**
+   * 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<IHttpContext>;
+  h3Event?: H3Event;
+  private tries;
+  private basePath;
+  private versions;
+  private namespace?;
+  private static versions;
+  private h3App?;
+  private providers;
+  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)[];
+  /**
+   * 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
+   */
+  protected registerBaseBindings(): void;
+  protected loadOptions(): Promise<void>;
+  /**
+   * Get all registered providers
+   */
+  getRegisteredProviders(): IServiceProvider[];
+  /**
+   * Load default and optional providers dynamically
+   *
+   * Auto-Registration Behavior
+   *
+   * 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<ConcreteConstructor<IServiceProvider, false>[]>;
+  protected getAllProviders(): Promise<Array<ConcreteConstructor<IServiceProvider, false>>>;
+  /**
+   * 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
+   */
+  initialize(providers: Array<ConcreteConstructor<IServiceProvider, false>>, filtered?: string[], autoRegisterProviders?: boolean): this;
+  /**
+   * Dynamically register all configured providers
+   */
+  registerConfiguredProviders(): Promise<void>;
+  /**
+   * Register service providers
+   *
+   * @param providers
+   * @param filtered
+   */
+  registerProviders(providers: Array<ConcreteConstructor<IServiceProvider, false>>, filtered?: string[]): void;
+  /**
+   * Register a provider
+   */
+  register(provider: IServiceProvider): Promise<void>;
+  /**
+   * Register the listed service providers.
+   *
+   * @param commands An array of console commands to register.
+   */
+  withCommands(commands: (new (app: any, kernel: any) => any)[]): this;
+  /**
+   * 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
+   *
+   * Port will be auto assigned if provided one is not available
+   *
+   * @alias serve
+   */
+  fire(): Promise<this>;
+  /**
+   *
+   * @param h3App The current H3 app instance
+   * @param preferedPort If provided, this will overide the port set in the evironment
+   */
+  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 current H3 app instance for possible future use.
+   *
+   * @param h3App The current H3 app instance
+   * @returns
+   */
+  setH3App(h3App?: H3): this;
+  /**
+   * Get the current H3 app instance.
+   *
+   * @returns
+   */
+  getH3App(): H3 | undefined;
+  /**
+   * 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
+   *
+   * @returns
+   */
+  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
+   */
+  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
+   */
+  setPath(name: IPathName, path: string): void;
+  /**
+   * Returns the installed version of the system core and typescript.
+   *
+   * @returns
+   */
+  getVersion(key: string): string;
+  /**
+   * Returns the installed version of the system core and typescript.
+   *
+   * @returns
+   */
+  static getVersion(key: string): string;
+}
+//#endregion
+//#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 extends IController {
+  protected app: Application;
+  constructor(app?: Application);
+}
+//#endregion
+//#region src/H3ravel.d.ts
+/**
+ * Simple global entry point for H3ravel applications
+ *
+ * @param providers
+ * @param basePath
+ * @param callback
+ */
+declare const h3ravel: (
+/**
+ * List of intial service providers to register with your app
+ */
+
+providers?: Exclude<OServiceProvider, "app" | "commands">[],
+/**
+ * Entry path of your app
+ */
+
+basePath?: string,
+/**
+ * Configuration option to pass to the initializer
+ */
+
+config?: EntryConfig) => Promise<Application>;
+//#endregion
+//#region src/Http/Kernel.d.ts
+/**
+ * Kernel class handles middleware execution and response transformations.
+ * It acts as the core middleware pipeline for HTTP requests.
+ */
+declare class Kernel {
+  app: Application;
+  middleware: IMiddleware[];
+  /**
+   * 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(app: Application, middleware?: IMiddleware[]);
+  /**
+   * Handles an incoming request and passes it through middleware before invoking the next handler.
+   *
+   * @param event - The raw H3 event object.
+   * @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: IHttpContext) => Promise<unknown>): Promise<unknown>;
+  /**
+   * Resolve the provided callback using the current H3 event instance
+   */
+  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
+declare class ProviderRegistry {
+  private static providers;
+  private static priorityMap;
+  private static filteredProviders;
+  private static sortable;
+  /**
+   * Set wether providers should be sorted or not.
+   *
+   * @returns
+   */
+  static setSortable(sort?: boolean): void;
+  /**
+   * Get a unique identifier for the Provider.
+   *
+   * @param provider
+   * @returns
+   */
+  private static getKey;
+  /**
+   * Register one or more providers.
+   * Duplicate constructors will be ignored.
+   *
+   * @param providers
+   * @returns
+   */
+  static register(...providers: ConcreteConstructor<IServiceProvider, false>[]): void;
+  /**
+   * Bulk register providers from an array.
+   *
+   * @param providers
+   * @returns
+   */
+  static registerMany(providers: ConcreteConstructor<IServiceProvider, false>[]): void;
+  /**
+   * Set the filtered providers.
+   *
+   * @returns
+   */
+  static setFiltered(filtered: string[]): void;
+  /**
+   * Resolve (instantiate) all providers with the given application or Service Container.
+   *
+   * @param app
+   * @returns
+   */
+  static resolve(app: Application, useServiceContainer?: boolean): Promise<IServiceProvider[]>;
+  /**
+   * Sort the service providers
+   *
+   * @param providers
+   * @returns
+   */
+  static sort(providers: ConcreteConstructor<IServiceProvider, false>[]): ConcreteConstructor<IServiceProvider, false>[];
+  /**
+   * Sort service providers
+   */
+  static doSort(): void;
+  /**
+   * Log the service providers in a table
+   *
+   * @param priorityMap
+   */
+  static log<P extends IServiceProvider>(providers?: Array<P> | Map<string, P>, enabled?: boolean): void;
+  /**
+   * Get all registered providers as an array.
+   *
+   * @returns
+   */
+  static all(): ConcreteConstructor<IServiceProvider, false>[];
+  /**
+   * Check if a provider is already registered.
+   *
+   * @param provider
+   * @returns
+   */
+  static has(provider: ConcreteConstructor<IServiceProvider, false>): boolean;
+  /**
+   * Automatically search for and discover service providers in packages.
+   *
+   * @param autoRegister
+   * @returns
+   */
+  static discoverProviders(autoRegister?: boolean): Promise<ConcreteConstructor<IServiceProvider, false>[]>;
+  /**
+   * Get the content of the package.json file
+   *
+   * @param manifestPath
+   * @returns
+   */
+  private static getManifest;
+}
+//#endregion
+//#region src/Providers/CoreServiceProvider.d.ts
+/**
+ * Bootstraps core services and bindings.
+ *
+ * Bind essential services to the container (logger, config repository).
+ * Register app-level singletons.
+ * Set up exception handling.
+ *
+ * Auto-Registered
+ */
+declare class CoreServiceProvider extends ServiceProvider {
+  static priority: number;
+  register(): void;
+  boot(): void | Promise<void>;
+}
+//#endregion
+//#region src/Registerer.d.ts
+declare class Registerer extends IRegisterer {
+  private app;
+  constructor(app: Application);
+  static register(app: Application): void;
+  bootRegister(): void;
+  private appPath;
+  private basePath;
+  private publicPath;
+  private storagePath;
+  private databasePath;
+}
+//#endregion
+export { AServiceProvider, Application, Container, ContainerResolver, Controller, CoreServiceProvider, EntryConfig, Inject, Injectable, Kernel, OServiceProvider, ProviderRegistry, Registerer, ServiceProvider, ServiceProviderConstructor, h3ravel };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h3ravel/core",
-  "version": "1.29.0-alpha.13",
+  "version": "1.29.0-alpha.14",
   "description": "Core application container, lifecycle management and service providers for H3ravel.",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -43,9 +43,9 @@
     "laravel"
   ],
   "dependencies": {
-    "@h3ravel/shared": "^1.29.0-alpha.13",
-    "@h3ravel/support": "^1.29.0-alpha.13",
-    "@h3ravel/foundation": "^1.29.0-alpha.13",
+    "@h3ravel/shared": "^1.29.0-alpha.14",
+    "@h3ravel/support": "^1.29.0-alpha.14",
+    "@h3ravel/foundation": "^1.29.0-alpha.14",
     "chalk": "^5.6.2",
     "commander": "^14.0.1",
     "detect-port": "^2.1.0",
@@ -59,7 +59,7 @@
     "tslib": "^2.8.1"
   },
   "devDependencies": {
-    "@h3ravel/contracts": "^1.29.0-alpha.13",
+    "@h3ravel/contracts": "^1.29.0-alpha.14",
     "@types/semver": "^7.7.1",
     "typescript": "^6.0.0"
   },