@h3ravel/contracts 0.28.1 → 0.29.0-alpha.2

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 /// <reference path="./app.globals.d.ts" />
 import { H3, H3Event, HTTPResponse, Middleware, MiddlewareOptions, serve } from "h3";
+import { EntryConfig } from "@h3ravel/core";
 import { IApplication as IApplication$1 } from "@h3ravel/contracts";
 import { DotNestedKeys as DotNestedKeys$1, DotNestedValue as DotNestedValue$1 } from "@h3ravel/shared";
 import { Edge } from "edge.js";
@@ -440,7 +441,7 @@ declare abstract class IServerBag extends IParamBag {
 }
 //#endregion
 //#region src/Url/Utils.d.ts
-type RouteParams<N = any> = Record<string, N>;
+type RouteParams<N = string | number> = Record<string, N> | N[] | N;
 //#endregion
 //#region src/Url/IUrl.d.ts
 declare abstract class IUrl {
@@ -691,7 +692,7 @@ declare abstract class IHttpRequest {
    * @param server     The SERVER parameters
    * @param content    The raw body data
    */
-  abstract initialize(): Promise<void>;
+  abstract initialize(): void;
   /**
    * Gets a list of content types acceptable by the client browser in preferable order.
    * @returns {string[]}
@@ -1202,31 +1203,31 @@ declare abstract class IRoute {
 }
 //#endregion
 //#region src/Session/FlashBag.d.ts
-declare class FlashBag {
+declare abstract class FlashBag {
   /**
    * Flash a value for the next request
    *
    * @param key Key to store in flash
    * @param value Value to be flashed
    */
-  flash(key: string, value: any): void;
+  abstract flash(key: string, value: any): void;
   /**
    * Store a temporary value for the current request only
    *
    * @param key Key to store
    * @param value Value to store
    */
-  now(key: string, value: any): void;
+  abstract now(key: string, value: any): void;
   /**
    * Reflash all current flash data for another request cycle
    */
-  reflash(): void;
+  abstract reflash(): void;
   /**
    * Keep only specific flash keys for the next request
    *
    * @param keys Keys to keep
    */
-  keep(keys: string[]): void;
+  abstract keep(keys: string[]): void;
   /**
    * Age flash data at the end of the request
    *
@@ -1234,7 +1235,7 @@ declare class FlashBag {
    * - Moves new flash data to old
    * - Clears new flash data
    */
-  ageFlashData(): void;
+  abstract ageFlashData(): void;
   /**
    * Get a flash value
    *
@@ -1242,198 +1243,183 @@ declare class FlashBag {
    * @param defaultValue Default value if key doesn't exist
    * @returns Flash value or default
    */
-  get(key: string, defaultValue?: any): any;
+  abstract get(key: string, defaultValue?: any): any;
   /**
    * Check if a flash key exists
    *
    * @param key Key to check
    * @returns Boolean indicating existence
    */
-  has(key: string): boolean;
+  abstract has(key: string): boolean;
   /**
    * Get all flash data
    *
    * @returns Combined flash data
    */
-  all(): Record<string, any>;
+  abstract all(): Record<string, any>;
   /**
    * Get all flash data keys
    *
    * @returns Combined flash data
    */
-  keys(): string[];
+  abstract keys(): string[];
   /**
    * Get the raww flash data
    *
    * @returns raw flash data
    */
-  raw(): Record<string, any>;
+  abstract raw(): Record<string, any>;
   /**
    * Clear all flash data
    */
-  clear(): void;
+  abstract clear(): void;
 }
 //#endregion
-//#region src/Session/SessionContract.d.ts
+//#region src/Session/ISessionDriver.d.ts
 /**
  * SessionDriver Interface
  *
  * All session drivers must implement these methods to ensure
  * consistency across different storage mechanisms (memory, files, database, redis).
  */
-interface SessionDriver {
-  flashBag: FlashBag;
+declare abstract class ISessionDriver {
+  abstract flashBag: FlashBag;
   /**
    * Retrieve a value from the session by key.
    *
    * @param key
    * @param defaultValue
    */
-  get<T = any>(key: string, defaultValue?: any): T | Promise<T>;
+  abstract get<T = any>(key: string, defaultValue?: any): T | Promise<T>;
   /**
    * Store multiple values in the session.
    *
    * @param key
    * @param defaultValue
    */
-  set(value: Record<string, any>): void | Promise<void>;
+  abstract set(value: Record<string, any>): void | Promise<void>;
   /**
    * Retrieve all data from the session including flash
    *
    * @returns
    */
-  getAll<T extends Record<string, any>>(): Promise<T> | T;
+  abstract getAll<T extends Record<string, any>>(): Promise<T> | T;
   /**
    * Store a value in the session.
    *
    * @param key
    * @param value
    */
-  put(key: string, value: any): void | Promise<void>;
+  abstract put(key: string, value: any): void | Promise<void>;
   /**
    * Append a value to an array key
    *
    * @param key
    * @param value
-   */
-  push(key: string, value: any): Promise<void> | void;
+  */
+  abstract push(key: string, value: any): Promise<void> | void;
   /**
    * Remove a key from the session.
    *
    * @param key
    */
-  forget(key: string): Promise<void> | void;
+  abstract forget(key: string): Promise<void> | void;
   /**
    * Determine if a key is present in the session.
    *
    * @param key
-   */
-  has(key: string): Promise<boolean> | boolean;
+  */
+  abstract has(key: string): Promise<boolean> | boolean;
   /**
    * Determine if a key exists in the session (even if null).
    *
    * @param key
    */
-  exists(key: string): Promise<boolean> | boolean;
+  abstract exists(key: string): Promise<boolean> | boolean;
   /**
    * Get all data from the session.
    */
-  all<T extends Record<string, any>>(): Promise<T> | T;
+  abstract all<T extends Record<string, any>>(): Promise<T> | T;
   /**
    * Get only a subset of session keys.
    *
    * @param keys
    */
-  only<T extends Record<string, any>>(keys: string[]): Promise<T> | T;
+  abstract only<T extends Record<string, any>>(keys: string[]): Promise<T> | T;
   /**
    * Get all session data except the specified keys.
    *
    * @param keys
    */
-  except<T extends Record<string, any>>(keys: string[]): Promise<T> | T;
+  abstract except<T extends Record<string, any>>(keys: string[]): Promise<T> | T;
   /**
    * Get and remove an item from the session.
    *
    * @param key
    * @param defaultValue
    */
-  pull<T = any>(key: string, defaultValue?: any): Promise<T> | T;
+  abstract pull<T = any>(key: string, defaultValue?: any): Promise<T> | T;
   /**
    * Increment a numeric session value.
    *
    * @param key
    * @param amount
    */
-  increment(key: string, amount?: number): Promise<number> | number;
+  abstract increment(key: string, amount?: number): Promise<number> | number;
   /**
    * Decrement a numeric session value.
    *
    * @param key
    * @param amount
    */
-  decrement(key: string, amount?: number): Promise<number> | number;
+  abstract decrement(key: string, amount?: number): Promise<number> | number;
   /**
    * Flash a key/value pair for the next request only.
    *
    * @param key
    * @param value
    */
-  flash(key: string, value: any): Promise<void> | void;
+  abstract flash(key: string, value: any): Promise<void> | void;
   /**
    * Reflash all current flash data for another request cycle.
    */
-  reflash(): Promise<void> | void;
+  abstract reflash(): Promise<void> | void;
   /**
    * Keep only specific flash data for another request.
    *
    * @param keys
    */
-  keep(keys: string[]): Promise<void> | void;
+  abstract keep(keys: string[]): Promise<void> | void;
   /**
    * Store data for the current request only (not persisted).
    *
    * @param key
    * @param value
    */
-  now(key: string, value: any): Promise<void> | void;
+  abstract now(key: string, value: any): Promise<void> | void;
   /**
    * Regenerate the session ID and optionally persist the data.
    */
-  regenerate(): Promise<void> | void;
+  abstract regenerate(): Promise<void> | void;
   /**
    * Invalidate the session completely and regenerate ID.
    */
-  invalidate(): Promise<void> | void;
+  abstract invalidate(): Promise<void> | void;
   /**
    * Determine if an item is not present in the session.
    *
    * @param key
    */
-  missing(key: string): Promise<boolean> | boolean;
+  abstract missing(key: string): Promise<boolean> | boolean;
   /**
    * Flush all session data
    */
-  flush(): Promise<void> | void;
+  abstract flush(): Promise<void> | void;
   /**
    * Age flash data at the end of the request lifecycle.
    */
-  ageFlashData(): Promise<void> | void;
+  abstract ageFlashData(): Promise<void> | void;
 }
-interface DriverOption {
-  cwd?: string;
-  dir?: string;
-  table?: string;
-  prefix?: string;
-  client?: any;
-  sessionId?: string;
-  sessionDir?: string;
-}
-/**
- * A builder function that returns a SessionDriver for a given sessionId.
- *
- * The builder receives the sessionId and a driver-specific options bag.
- */
-type DriverBuilder = (sessionId: string, options?: DriverOption) => SessionDriver;
 //#endregion
 //#region src/Session/ISessionManager.d.ts
 /**
@@ -1442,84 +1428,83 @@ type DriverBuilder = (sessionId: string, options?: DriverOption) => SessionDrive
  * Handles session initialization, ID generation, and encryption.
  * Each request gets a unique session namespace tied to its ID.
  */
-declare class ISessionManager {
+declare abstract class ISessionManager {
+  abstract flashBag: FlashBag;
   /**
-   * @param ctx - incoming request http context
-   * @param driverName - registered driver key ('file' | 'database' | 'memory' | 'redis')
-   * @param driverOptions - optional bag for driver-specific options
+   * Access the current session ID.
    */
-  constructor(ctx: IHttpContext, driverName: 'file' | 'memory' | 'database' | 'redis', driverOptions: DriverOption);
+  abstract id(): string;
   /**
-   * Access the current session ID.
+   * Get the current session driver
    */
-  id(): string;
+  abstract getDriver(): ISessionDriver;
   /**
    * Retrieve a value from the session
    *
    * @param key
    * @returns
    */
-  get(key: string, defaultValue?: any): Promise<any> | any;
+  abstract get(key: string, defaultValue?: any): Promise<any> | any;
   /**
    * Store a value in the session
    *
    * @param key
    * @param value
    */
-  set(value: Record<string, any>): Promise<void> | void;
+  abstract set(value: Record<string, any>): Promise<void> | void;
   /**
    * Store multiple key/value pairs
    *
    * @param values
    */
-  put(key: string, value: any): void | Promise<void>;
+  abstract put(key: string, value: any): void | Promise<void>;
   /**
    * Append a value to an array key
    *
    * @param key
    * @param value
    */
-  push(key: string, value: any): void | Promise<void>;
+  abstract push(key: string, value: any): void | Promise<void>;
   /**
    * Remove a key from the session
    *
    * @param key
    */
-  forget(key: string): void | Promise<void>;
+  abstract forget(key: string): void | Promise<void>;
   /**
    * Retrieve all session data
    *
    * @returns
    */
-  all(): Record<string, any> | Promise<Record<string, any>>;
+  abstract all(): Record<string, any> | Promise<Record<string, any>>;
   /**
    * Determine if a key exists (even if null).
    *
    * @param key
    * @returns
    */
-  exists(key: string): Promise<boolean> | boolean;
+  abstract exists(key: string): Promise<boolean> | boolean;
   /**
    * Determine if a key has a non-null value.
    *
    * @param key
    * @returns
    */
-  has(key: string): Promise<boolean> | boolean;
+  abstract has(key: string): Promise<boolean> | boolean;
   /**
    * Get only specific keys.
    *
    * @param keys
    * @returns
    */
-  only(keys: string[]): Record<string, any> | Promise<Record<string, any>>;
+  abstract only(keys: string[]): Record<string, any> | Promise<Record<string, any>>;
   /**
    * Return all keys except the specified ones.
    *
    * @param keys
    * @returns
    */
-  except(keys: string[]): Record<string, any> | Promise<Record<string, any>>;
+  abstract except(keys: string[]): Record<string, any> | Promise<Record<string, any>>;
   /**
    * Return and delete a key from the session.
    *
@@ -1527,7 +1512,7 @@ declare class ISessionManager {
    * @param defaultValue
    * @returns
    */
-  pull(key: string, defaultValue?: any): any;
+  abstract pull(key: string, defaultValue?: any): any;
   /**
    * Increment a numeric value by amount (default 1).
    *
@@ -1535,7 +1520,7 @@ declare class ISessionManager {
    * @param amount
    * @returns
    */
-  increment(key: string, amount?: number): Promise<number> | number;
+  abstract increment(key: string, amount?: number): Promise<number> | number;
   /**
    * Decrement a numeric value by amount (default 1).
    *
@@ -1543,55 +1528,55 @@ declare class ISessionManager {
    * @param amount
    * @returns
    */
-  decrement(key: string, amount?: number): number | Promise<number>;
+  abstract decrement(key: string, amount?: number): number | Promise<number>;
   /**
    * Flash a value for next request only.
    *
    * @param key
    * @param value
    */
-  flash(key: string, value: any): void | Promise<void>;
+  abstract flash(key: string, value: any): void | Promise<void>;
   /**
    * Reflash all flash data for one more cycle.
    *
    * @returns
    */
-  reflash(): void | Promise<void>;
+  abstract reflash(): void | Promise<void>;
   /**
    * Keep only selected flash data.
    *
    * @param keys
    * @returns
    */
-  keep(keys: string[]): void | Promise<void>;
+  abstract keep(keys: string[]): void | Promise<void>;
   /**
    * Store data only for current request cycle (not persisted).
    *
    * @param key
    * @param value
    */
-  now(key: string, value: any): void | Promise<void>;
+  abstract now(key: string, value: any): void | Promise<void>;
   /**
    * Regenerate session ID and persist data under new ID.
    */
-  regenerate(): void | Promise<void>;
+  abstract regenerate(): void | Promise<void>;
   /**
    * Determine if an item is not present in the session.
    *
    * @param key
    * @returns
    */
-  missing(key: string): Promise<boolean> | boolean;
+  abstract missing(key: string): Promise<boolean> | boolean;
   /**
    * Flush all session data
    */
-  flush(): void | Promise<void>;
+  abstract flush(): void | Promise<void>;
   /**
    * Age flash data at the end of the request lifecycle.
    *
    * @returns
    */
-  ageFlashData(): void | Promise<void>;
+  abstract ageFlashData(): void | Promise<void>;
 }
 //#endregion
 //#region src/Http/IRequest.d.ts
@@ -1649,7 +1634,7 @@ declare abstract class IRequest<D extends Record<string, any> = Record<string, a
    * @param server     The SERVER parameters
    * @param content    The raw body data
    */
-  abstract initialize(): Promise<void>;
+  abstract initialize(): void;
   /**
    * Retrieve all data from the instance (query + body).
    */
@@ -2381,6 +2366,10 @@ declare abstract class IResponse extends IHttpResponse {
    */
   abstract getEvent(): H3Event;
   abstract getEvent<K$1 extends DotNestedKeys$1<H3Event>>(key: K$1): DotNestedValue$1<H3Event, K$1>;
+  /**
+   * Reset the response class to it's defautl
+   */
+  abstract reset(): void;
 }
 declare abstract class IResponsable extends HTTPResponse {
   abstract toResponse(request: IRequest): IResponse;
@@ -2494,12 +2483,324 @@ declare abstract class IDispatcher {
   abstract getRawListeners(): Record<string, any[]>;
 }
 //#endregion
+//#region src/Hashing/IHashManagerContract.d.ts
+type HashAlgorithm = 'bcrypt' | 'argon' | 'argon2id';
+interface HashConfiguration {
+  [key: string]: any;
+  /**
+   * Default Hash Driver
+   * -------------------
+   * This option controls the default hash driver that will be used to hash
+   * passwords for your application. By default, the bcrypt algorithm is
+   * used; however, you remain free to modify this option if you wish.
+   */
+  driver: HashAlgorithm;
+  /**
+   * Bcrypt Options
+   * --------------
+   * Here you may specify the configuration options that should be used when
+   * passwords are hashed using the Bcrypt algorithm. This will allow you
+   * to control the amount of time it takes to hash the given password.
+   */
+  bcrypt: {
+    rounds: number;
+    verify: boolean;
+    limit: number | null;
+  };
+  /**
+   * Argon Options
+   * -------------
+   * Here you may specify the configuration options that should be used when
+   * passwords are hashed using the Argon algorithm. These will allow you
+   * to control the amount of time it takes to hash the given password.
+   */
+  argon: {
+    memory: number;
+    threads: number;
+    time: number;
+    verify: boolean;
+  };
+}
+type HashOptions = Partial<HashConfiguration['bcrypt'] & HashConfiguration['argon']>;
+interface BcryptOptions {
+  cost: number;
+}
+interface Argon2Options {
+  memoryCost: number;
+  timeCost: number;
+  threads: number;
+}
+interface UnknownHashOptions {
+  [key: string]: any;
+}
+interface HashInfo {
+  algo: number;
+  algoName: HashAlgorithm;
+  options: {
+    cost?: number | undefined;
+    memoryCost?: number | undefined;
+    timeCost?: number | undefined;
+    threads?: number | undefined;
+    [key: string]: number | undefined;
+  };
+}
+//#endregion
+//#region src/Hashing/IAbstractHasher.d.ts
+declare abstract class IAbstractHasher {
+  /**
+   * Get information about the given hashed value.
+   *
+   * @param  hashedValue
+   * @returns
+   */
+  abstract info(hashedValue: string): HashInfo;
+}
+//#endregion
+//#region src/Hashing/IArgon2idHasher.d.ts
+declare abstract class IArgon2idHasher extends IAbstractHasher {
+  /**
+   * Hash the given value using Argon2id.
+   */
+  abstract make(value: string, options?: HashConfiguration['argon']): Promise<string>;
+  /**
+   * Check the given plain value against a hash.
+   */
+  abstract check(value: string, hashedValue?: string | null, _options?: HashConfiguration['argon']): Promise<boolean>;
+  /**
+   * Get information about the given hashed value.
+   */
+  abstract info(hashedValue: string): HashInfo;
+  /**
+   * Check if the given hash needs to be rehashed based on current options.
+   */
+  abstract needsRehash(hashedValue: string, options?: HashConfiguration['argon']): boolean;
+  /**
+   * Verify that the hash configuration does not exceed the configured limits.
+   */
+  abstract verifyConfiguration(hashedValue: string): boolean;
+  /**
+   * Verify the hashed value's options.
+   */
+  protected abstract isUsingValidOptions(hashedValue: string): boolean;
+  /**
+   * Verify the hashed value's algorithm.
+   */
+  protected abstract isUsingCorrectAlgorithm(hashedValue: string): boolean;
+  /**
+   * Extract Argon parameters from the hash.
+   */
+  protected abstract parseInfo(hashedValue: string): Record<string, number | undefined>;
+}
+//#endregion
+//#region src/Hashing/IArgonHasher.d.ts
+declare abstract class IArgonHasher extends IAbstractHasher {
+  /**
+   * Hash the given value using Argon2i.
+   */
+  abstract make(value: string, options?: HashConfiguration['argon']): Promise<string>;
+  /**
+   * Check the given plain value against a hash.
+   */
+  abstract check(value: string, hashedValue?: string | null, _options?: HashConfiguration['argon']): Promise<boolean>;
+  /**
+   * Get information about the given hashed value.
+   */
+  abstract info(hashedValue: string): HashInfo;
+  /**
+   * Check if the given hash needs to be rehashed based on current options.
+   */
+  abstract needsRehash(hashedValue: string, options?: HashConfiguration['argon']): boolean;
+  /**
+   * Verify that the hash configuration does not exceed the configured limits.
+   */
+  abstract verifyConfiguration(hashedValue: string): boolean;
+  /**
+   * Verify the hashed value's options.
+   */
+  protected abstract isUsingValidOptions(hashedValue: string): boolean;
+  /**
+   * Verify the hashed value's algorithm.
+   */
+  protected abstract isUsingCorrectAlgorithm(hashedValue: string): boolean;
+  /**
+   * Extract Argon parameters from the hash.
+   */
+  protected abstract parseInfo(hashedValue: string): Record<string, number | undefined>;
+}
+//#endregion
+//#region src/Hashing/IBcryptHasher.d.ts
+declare abstract class IBcryptHasher extends IAbstractHasher {
+  /**
+   * Hash the given value.
+   *
+   * @param  value
+   * @param  options
+   */
+  abstract make(value: string, options?: HashConfiguration['bcrypt']): Promise<string>;
+  /**
+   * Check the given plain value against a hash.
+   *
+   * @param  value
+   * @param  hashedValue
+   * @param  options
+   */
+  abstract check(value: string, hashedValue?: string | null, _options?: HashConfiguration['bcrypt']): Promise<boolean>;
+  /**
+   * Get information about the given hashed value.
+   *
+   * @param  hashedValue
+   */
+  abstract info(hashedValue: string): HashInfo;
+  /**
+   * Check if the given hash has been hashed using the given options.
+   *
+   * @param  hashedValue
+   * @param  options
+   */
+  abstract needsRehash(hashedValue: string, options?: HashConfiguration['bcrypt']): boolean;
+  /**
+   * Verify the hashed value's options.
+   *
+   * @param  hashedValue
+   * @return
+   */
+  protected abstract isUsingValidOptions(hashedValue: string): boolean;
+  /**
+   * Verifies that the configuration is less than or equal to what is configured.
+   *
+   * @private
+   */
+  abstract verifyConfiguration(value: string): boolean;
+  /**
+   * Verify the hashed value's algorithm.
+   *
+   * @param  hashedValue
+   *
+   * @returns
+   */
+  protected abstract isUsingCorrectAlgorithm(hashedValue: string): boolean;
+  /**
+   * Extract the cost value from the options object.
+   *
+   * @param  options
+   * @return int
+   */
+  protected abstract cost(options?: HashConfiguration['bcrypt']): number;
+}
+//#endregion
+//#region src/Hashing/IBaseHashManager.d.ts
+declare abstract class IBaseHashManager {
+  abstract driver(): IBcryptHasher | IArgonHasher | IArgon2idHasher;
+  abstract createBcryptDriver?(): IBcryptHasher;
+  abstract createArgonDriver?(): IArgonHasher;
+  abstract createArgon2idDriver?(): IArgon2idHasher;
+  /**
+   * Get the default driver name.
+   *
+   * @return string
+   */
+  abstract getDefaultDriver(): HashAlgorithm;
+  protected abstract createDriver(driver: HashAlgorithm): IArgonHasher | IArgon2idHasher | IBcryptHasher;
+  /**
+   * Determine if a given string is already hashed.
+   *
+   * @param  value
+   * @returns
+   */
+  abstract isHashed(value: string): boolean;
+  /**
+   * Autoload config and initialize library
+   *
+   * @returns
+   */
+  abstract init(basePath?: string): Promise<this>;
+}
+//#endregion
+//#region src/Hashing/IHashManager.d.ts
+declare abstract class IHashManager extends IBaseHashManager {
+  /**
+   * Create an instance of the Bcrypt hash Driver.
+   *
+   * @return BcryptHasher
+   */
+  abstract createBcryptDriver(): IBcryptHasher;
+  /**
+   * Create an instance of the Argon hash Driver.
+   *
+   * @return ArgonHasher
+   */
+  abstract createArgonDriver(): IArgonHasher;
+  /**
+   * Create an instance of the Argon2id hash Driver.
+   *
+   * @return Argon2idHasher
+   */
+  abstract createArgon2idDriver(): IArgon2idHasher;
+  /**
+   * Hash the given value.
+   *
+   * @param  value
+   * @param options
+   *
+   * @returns
+   */
+  abstract make(value: string, options?: HashOptions): Promise<string>;
+  /**
+   * Get information about the given hashed value.
+   *
+   * @param  hashedValue
+   * @returns
+   */
+  abstract info(hashedValue: string): HashInfo;
+  /**
+   * Check the given plain value against a hash.
+   *
+   * @param  value
+   * @param  hashedValue
+   * @param options
+   * @returns
+   */
+  abstract check(value: string, hashedValue?: string, options?: HashOptions): Promise<boolean>;
+  /**
+   * Check if the given hash has been hashed using the given options.
+   *
+   * @param  hashedValue
+   * @param options
+   * @returns
+   */
+  abstract needsRehash(hashedValue: string, options?: HashOptions): boolean;
+  /**
+   * Determine if a given string is already hashed.
+   *
+   * @param  string  value
+   * @returns
+   */
+  abstract isHashed(value: string): boolean;
+  /**
+   * Verifies that the configuration is less than or equal to what is configured.
+   *
+   * @param  value
+   *
+   * @internal
+   */
+  abstract verifyConfiguration(value: string): boolean;
+  /**
+   * Get a driver instance.
+   *
+   * @param  driver
+   *
+   * @throws {InvalidArgumentException}
+   */
+  abstract driver(driver?: HashAlgorithm): IArgonHasher | IArgon2idHasher | IBcryptHasher;
+}
+//#endregion
 //#region src/Routing/IAbstractRouteCollection.d.ts
 declare abstract class IAbstractRouteCollection {
   static verbs: RouteMethod[];
   abstract get(): IRoute[];
   abstract get(method: string): Record<string, IRoute>;
   abstract getRoutes(): IRoute[];
+  abstract count(): number;
 }
 //#endregion
 //#region src/Routing/IRouteCollection.d.ts
@@ -3025,6 +3326,253 @@ declare abstract class IRouter {
    * @param  callback
    */
   abstract substituteImplicitBindingsUsing(callback: CallableConstructor): this;
+  /**
+   * Count the number of items in the collection.
+   */
+  abstract count(): number;
+}
+//#endregion
+//#region src/Database/IModel.d.ts
+declare abstract class IModel<M = any> {
+  /**
+   * Retrieve the model for a bound value.
+   *
+   * @param value
+   * @param field
+   * @returns
+   */
+  abstract resolveRouteBinding(value: any, field?: undefined | string | null): Promise<M>;
+  /**
+   * Retrieve the model for a bound value.
+   *
+   * @param  query
+   * @param  value
+   * @param  field
+   */
+  abstract resolveRouteBindingQuery(query: any, value: any, field?: undefined | string | null): any;
+  /**
+   * Get the value of the model's route key.
+   */
+  abstract getRouteKey(): any;
+  /**
+   * Get the route key for the model.
+   */
+  abstract getRouteKeyName(): string;
+}
+//#endregion
+//#region src/Routing/Traits/UrlRoutable.d.ts
+declare abstract class UrlRoutable {
+  /**
+   * Get the value of the model's route key.
+   */
+  abstract getRouteKey(): any;
+  /**
+   * Retrieve the model for a bound value.
+   *
+   * @param  value
+   * @param  field
+   */
+  abstract resolveRouteBinding(value: any, field?: string): Promise<IModel<any>>;
+  /**
+   * Retrieve the child model for a bound value.
+   *
+   * @param  childType
+   * @param  value
+   * @param  field
+   */
+  /**
+   * Get the route key for the model.
+   */
+  abstract getRouteKeyName(): string;
+}
+//#endregion
+//#region src/Url/IUrlGenerator.d.ts
+declare abstract class IUrlGenerator {
+  /**
+   * The named parameter defaults.
+   */
+  abstract defaultParameters: GenericObject;
+  /**
+   * Get the full URL for the current request,
+   * including the query string.
+   *
+   * Example:
+   *   https://example.com/users?page=2
+   */
+  abstract full(): string;
+  /**
+   * Get the URL for the current request path
+   * without modifying the query string.
+   */
+  abstract current(): string;
+  /**
+   * Get the URL for the previous request.
+   *
+   * Resolution order:
+   * 1. HTTP Referer header
+   * 2. Session-stored previous URL
+   * 3. Fallback (if provided)
+   * 4. Root "/"
+   *
+   * @param fallback Optional fallback path or URL
+   */
+  abstract previous(fallback?: string | false): string;
+  /**
+   * Generate an absolute URL to the given path.
+   *
+   * - Accepts relative paths or full URLs
+   * - Automatically prefixes scheme + host
+   * - Encodes extra path parameters safely
+   *
+   * @param path Relative or absolute path
+   * @param extra Additional path segments
+   * @param secure Force HTTPS or HTTP
+   */
+  abstract to(path: string, extra?: (string | number)[], secure?: boolean | null): string;
+  /**
+   * Generate a secure (HTTPS) absolute URL.
+   *
+   * @param path
+   * @param parameters
+   * @returns
+   */
+  abstract secure(path: string, parameters?: any[]): string;
+  /**
+   * Generate a URL to a public asset.
+   *
+   * - Skips URL generation if path is already absolute
+   * - Removes index.php from root if present
+   *
+   * @param path Asset path
+   * @param secure Force HTTPS
+   */
+  abstract asset(path: string, secure?: boolean | null): string;
+  /**
+   * Generate a secure (HTTPS) asset URL.
+   *
+   * @param path
+   * @returns
+   */
+  abstract secureAsset(path: string): string;
+  /**
+   * Resolve the URL scheme to use.
+   *
+   * Priority:
+   * 1. Explicit `secure` flag
+   * 2. Forced scheme
+   * 3. Request scheme (cached)
+   *
+   * @param secure
+   */
+  abstract formatScheme(secure?: boolean | null): string;
+  /**
+   * Format the base root URL.
+   *
+   * - Applies forced root if present
+   * - Replaces scheme while preserving host
+   * - Result is cached per request
+   *
+   * @param scheme URL scheme
+   * @param root Optional custom root
+   */
+  abstract formatRoot(scheme: string, root?: string): string;
+  abstract signedRoute(name: string, parameters?: Record<string, any>, expiration?: number, absolute?: boolean): string;
+  abstract hasValidSignature(request: IRequest): boolean;
+  abstract route(name: string, parameters?: RouteParams, absolute?: boolean): string;
+  /**
+   * Get the URL for a given route instance.
+   *
+   * @param  route
+   * @param  parameters
+   * @param  absolute
+   */
+  abstract toRoute(route: IRoute, parameters?: RouteParams, absolute?: boolean): string;
+  /**
+   * Combine root and path into a final URL.
+   *
+   * Allows optional host and path formatters
+   * to modify the output dynamically.
+   *
+   * @param root
+   * @param path
+   * @param route
+   * @returns
+   */
+  abstract format(root: string, path: string, route?: IRoute): string;
+  /**
+   * Format the array of URL parameters.
+   *
+   * @param  parameters
+   */
+  abstract formatParameters(parameters: GenericObject<UrlRoutable> | RouteParams): GenericObject;
+  /**
+   * Determine whether a string is a valid URL.
+   *
+   * Supports:
+   * - Absolute URLs
+   * - Protocol-relative URLs
+   * - Anchors and special schemes
+   *
+   * @param path
+   * @returns
+   */
+  abstract isValidUrl(path: string): boolean;
+  /**
+   * Force HTTPS for all generated URLs.
+   *
+   * @param force
+   */
+  abstract forceHttps(force?: boolean): void;
+  /**
+   * Set the origin (scheme + host) for generated URLs.
+   *
+   * @param root
+   */
+  abstract useOrigin(root?: string): void;
+  abstract useAssetOrigin(root?: string): void;
+  abstract setKeyResolver(resolver: () => string | string[]): void;
+  abstract resolveMissingNamedRoutesUsing(resolver: CallableConstructor): void;
+  abstract formatHostUsing(callback: CallableConstructor): this;
+  abstract formatPathUsing(callback: CallableConstructor): this;
+  /**
+   * Get the request instance.
+   */
+  abstract getRequest(): IRequest;
+  /**
+   * Set the current request instance.
+   *
+   * @param  request
+   */
+  abstract setRequest(request: IRequest): void;
+  /**
+   * Set the route collection.
+   *
+   * @param routes
+   */
+  abstract setRoutes(routes: IRouteCollection): this;
+  /**
+   * Get the route collection.
+   */
+  abstract getRoutes(): IRouteCollection;
+  /**
+   * Set the session resolver for the generator.
+   *
+   * @param   sessionResolver
+   */
+  abstract setSessionResolver(sessionResolver: CallableConstructor): this;
+  /**
+   * Clone a new instance of the URL generator with a different encryption key resolver.
+   *
+   * @param  keyResolver
+   */
+  abstract withKeyResolver(keyResolver: () => string | string[]): void;
+  /**
+   * Set the default named parameters used by the URL generator.
+   *
+   * @param  array  $defaults
+   * @return void
+   */
+  abstract defaults(defaults: GenericObject): void;
 }
 //#endregion
 //#region src/Utilities/PathLoader.d.ts
@@ -3046,6 +3594,12 @@ declare class PathLoader {
    * @param base - The base path to include to the path
    */
   setPath(name: IPathName, path: string, base?: string): void;
+  /**
+   *
+   * @param path
+   * @param skipExt
+   */
+  distPath(path: string, skipExt?: boolean): string;
 }
 //#endregion
 //#region src/Utilities/BindingsContract.d.ts
@@ -3057,25 +3611,31 @@ type Bindings = {
   db: any;
   env(): NodeJS.ProcessEnv;
   env<T extends string>(key: T, def?: any): any;
+  url: IUrlGenerator;
   view(viewPath: string, params?: Record<string, any>): Promise<IResponsable>;
   edge: Edge;
   asset(key: string, def?: string): string;
+  hash: IHashManager;
   router: IRouter;
   events: IDispatcher;
+  routes: IRouteCollection;
   config: {
     get<X extends Record<string, any>>(): X;
-    get<X extends Record<string, any>, T extends Extract<keyof X, string>>(key: T, def?: any): X[T];
+    get<X extends Record<string, any>, T extends Extract<keyof X, string>>(key?: T, def?: any): X[T];
     set<T extends string>(key: T, value: any): void;
     load?(): any;
   };
+  session: ISessionManager;
   'app.events': IDispatcher;
+  'hash.driver': ReturnType<IHashManager['driver']>;
   'http.app': H3;
-  'path.base': string;
-  'load.paths': PathLoader;
   'http.serve': typeof serve;
   'http.context': IHttpContext;
   'http.request': IRequest;
   'http.response': IResponse;
+  'load.paths': PathLoader;
+  'path.base': string;
+  'session.store': ISessionDriver;
 };
 type UseKey<X extends Record<string, any> = Record<string, any>> = keyof RemoveIndexSignature<Bindings & X>;
 type IBinding = UseKey | (new (...args: any[]) => unknown);
@@ -3206,6 +3766,14 @@ declare abstract class IContainer {
    */
   abstract alias(key: [string | ClassConstructor, any][]): this;
   abstract alias(key: string | ClassConstructor, target: any): this;
+  /**
+   * Bind a new callback to an abstract's rebind event.
+   *
+   * @param  abstract
+   * @param  callback
+   */
+  abstract rebinding<T extends UseKey>(key: T | (new (...args: any[]) => Bindings[T]), callback: (app: this, inst: Bindings[T]) => Bindings[T] | void): void;
+  abstract 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.
    *
@@ -3230,6 +3798,16 @@ declare abstract class IContainer {
    * @param abstract
    */
   abstract resolved(abstract: IBinding | string): boolean;
+  /**
+   * "Extend" an abstract type in the container.
+   *
+   * @param  abstract
+   * @param  closure
+   *
+   * @throws {InvalidArgumentException}
+   */
+  abstract extend<T extends UseKey>(key: T | (new (...args: any[]) => Bindings[T]), closure: (inst: Bindings[T], app: this) => Bindings[T]): void;
+  abstract 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.
    *
@@ -3250,8 +3828,8 @@ declare abstract class IContainer {
 //#region src/Core/IApplication.d.ts
 declare abstract class IApplication extends IContainer {
   abstract paths: PathLoader;
-  context?: (event: H3Event) => Promise<IHttpContext>;
-  h3Event?: H3Event;
+  abstract context?: (event: H3Event) => Promise<IHttpContext>;
+  abstract h3Event?: H3Event;
   /**
    * List of registered console commands
    */
@@ -3322,12 +3900,33 @@ declare abstract class IApplication extends IContainer {
    * @param callback
    */
   abstract booted(callback: (app: this) => void): void;
+  /**
+   * Throw an HttpException with the given data.
+   *
+   * @param  code
+   * @param  message
+   * @param  headers
+   *
+   * @throws {HttpException}
+   * @throws {NotFoundHttpException}
+   */
+  abstract abort(code: number, message: string, headers: GenericObject): void;
+  /**
+   * Register a terminating callback with the application.
+   *
+   * @param  callback
+   */
+  abstract terminating(callback: (app: this) => void): this;
+  /**
+   * Terminate the application.
+   */
+  abstract terminate(): void;
   /**
    * Handle the incoming HTTP request and send the response to the browser.
    *
    * @param  request
    */
-  abstract handleRequest(event: H3Event): Promise<void>;
+  abstract handleRequest(config?: EntryConfig): Promise<void>;
   /**
    * Get the URI resolver callback.
    */
@@ -3382,6 +3981,13 @@ declare abstract class IApplication extends IContainer {
    * Determine if the application has been bootstrapped before.
    */
   abstract hasBeenBootstrapped(): boolean;
+  /**
+   * Build the http context
+   *
+   * @param event
+   * @param config
+   */
+  abstract buildContext(event: H3Event, config?: EntryConfig, fresh?: boolean): Promise<IHttpContext>;
   /**
    * Save the curretn H3 instance for possible future use.
    *
@@ -3399,6 +4005,16 @@ declare abstract class IApplication extends IContainer {
    * Get the HttpContext.
    */
   abstract getHttpContext(): IHttpContext | undefined;
+  /**
+   * @param key
+   */
+  abstract getHttpContext<K$1 extends keyof IHttpContext>(key: K$1): IHttpContext[K$1];
+  /**
+   * Get the application namespace.
+   *
+   * @throws {RuntimeException}
+   */
+  abstract getNamespace(): string;
   /**
    * Get the base path of the app
    *
@@ -3446,7 +4062,7 @@ declare abstract class IHttpContext {
 }
 //#endregion
 //#region src/Utilities/Utilities.d.ts
-type IPathName = 'views' | 'routes' | 'assets' | 'base' | 'public' | 'storage' | 'config' | 'database' | 'commands';
+type IPathName = 'app' | 'src' | 'views' | 'routes' | 'assets' | 'base' | 'public' | 'storage' | 'config' | 'database' | 'commands';
 type RouterEnd = 'get' | 'delete' | 'put' | 'post' | 'patch' | 'apiResource' | 'group' | 'route' | 'any';
 type RouteMethod = 'GET' | 'HEAD' | 'PUT' | 'PATCH' | 'POST' | 'DELETE' | 'OPTIONS';
 type RequestMethod = 'HEAD' | 'GET' | 'PUT' | 'DELETE' | 'TRACE' | 'OPTIONS' | 'PURGE' | 'POST' | 'CONNECT' | 'PATCH';
@@ -3586,34 +4202,6 @@ declare abstract class IRegisterer {
   abstract bootRegister(): void;
 }
 //#endregion
-//#region src/Database/IModel.d.ts
-declare abstract class IModel<M = any> {
-  /**
-   * Retrieve the model for a bound value.
-   *
-   * @param value
-   * @param field
-   * @returns
-   */
-  abstract resolveRouteBinding(value: any, field?: undefined | string | null): Promise<M>;
-  /**
-   * Retrieve the model for a bound value.
-   *
-   * @param  query
-   * @param  value
-   * @param  field
-   */
-  abstract resolveRouteBindingQuery(query: any, value: any, field?: undefined | string | null): any;
-  /**
-   * Get the value of the model's route key.
-   */
-  abstract getRouteKey(): any;
-  /**
-   * Get the route key for the model.
-   */
-  abstract getRouteKeyName(): string;
-}
-//#endregion
 //#region src/Exceptions/IExceptionHandler.d.ts
 type ExceptionConstructor<T = any> = new (...args: any[]) => T;
 type ExceptionConditionCallback = (error: any) => boolean;
@@ -4080,7 +4668,16 @@ declare abstract class IJob {
 }
 //#endregion
 //#region src/Routing/ICallableDispatcher.d.ts
-declare abstract class ICallableDispatcher {}
+declare abstract class ICallableDispatcher {
+  /**
+   * Dispatch a request to a given callback.
+   *
+   * @param  route
+   * @param  handler
+   * @param  method
+   */
+  abstract dispatch(route: IRoute, handler: CallableConstructor): Promise<any>;
+}
 //#endregion
 //#region src/Routing/IControllerDispatcher.d.ts
 declare abstract class IControllerDispatcher {
@@ -4115,31 +4712,22 @@ declare abstract class IRouteRegistrar {
   abstract prefix(prefix: string): this;
 }
 //#endregion
-//#region src/Routing/Traits/UrlRoutable.d.ts
-declare abstract class UrlRoutable {
-  /**
-   * Get the value of the model's route key.
-   */
-  abstract getRouteKey(): any;
-  /**
-   * Retrieve the model for a bound value.
-   *
-   * @param  value
-   * @param  field
-   */
-  abstract resolveRouteBinding(value: any, field?: string): Promise<IModel<any>>;
-  /**
-   * Retrieve the child model for a bound value.
-   *
-   * @param  childType
-   * @param  value
-   * @param  field
-   */
-  /**
-   * Get the route key for the model.
-   */
-  abstract getRouteKeyName(): string;
+//#region src/Session/SessionContract.d.ts
+interface SessionDriverOption {
+  cwd?: string;
+  dir?: string;
+  table?: string;
+  prefix?: string;
+  client?: any;
+  sessionId?: string;
+  sessionDir?: string;
 }
+/**
+ * A builder function that returns a SessionDriver for a given sessionId.
+ *
+ * The builder receives the sessionId and a driver-specific options bag.
+ */
+type SessionDriverBuilder = (sessionId: string, options?: SessionDriverOption) => ISessionDriver;
 //#endregion
 //#region src/Url/IRequestAwareUrl.d.ts
 /**
@@ -4168,6 +4756,47 @@ declare abstract class IRequestAwareUrl {
   abstract query(): Record<string, any>;
 }
 //#endregion
+//#region src/Url/IRouteUrlGenerator.d.ts
+declare abstract class IRouteUrlGenerator {
+  /**
+   * The named parameter defaults.
+   */
+  abstract defaultParameters: RouteParams;
+  /**
+   * Characters that should not be URL encoded.
+   */
+  abstract dontEncode: {
+    '%2F': string;
+    '%40': string;
+    '%3A': string;
+    '%3B': string;
+    '%2C': string;
+    '%3D': string;
+    '%2B': string;
+    '%21': string;
+    '%2A': string;
+    '%7C': string;
+    '%3F': string;
+    '%26': string;
+    '%23': string;
+    '%25': string;
+  };
+  /**
+   * Generate a URL for the given route.
+   *
+   * @param  route
+   * @param  parameters
+   * @param  absolute
+   */
+  abstract to(route: IRoute, parameters?: RouteParams, absolute?: boolean): string;
+  /**
+   * Set the default named parameters used by the URL generator.
+   *
+   * @param  $defaults
+   */
+  abstract defaults(defaults: RouteParams): void;
+}
+//#endregion
 //#region src/Url/IUrlHelpers.d.ts
 /**
  * The Url Helper Contract
@@ -4459,4 +5088,4 @@ declare class IValidator<D extends Record<string, any> = any, R extends RulesFor
   getRules(): R;
 }
 //#endregion
-export { AServiceProvider, AbstractConstructor, ActionInput, AppEvent, AppListener, BaseValidationRuleClass, Bindings, CKernel, CacheOptions, CallableConstructor, ClassConstructor, ClassicRouteDefinition, ConcreteConstructor, CustomValidationRules, DotFlatten, DotNestedKeys, DotNestedValue, DotPaths, DriverBuilder, DriverOption, EventHandler, ExceptionConditionCallback, ExceptionConstructor, ExtractClassMethods, ExtractRules, FieldMessages, FlashBag, GenericObject, GenericWithNullableStringValues, IAbstractRouteCollection, IAppBuilder, IApplication, IBinding, IBootstraper, ICallableDispatcher, ICompiledRoute, IContainer, IController, IControllerDispatcher, IDispatcher, IExceptionHandler, IFileBag, IFileInput, IHeaderBag, IHttpContext, IHttpRequest, IHttpResponse, IJob, IKernel, IMessageBag, IMiddleware, IMiddlewareHandler, IModel, IParamBag, IPathName, IPendingResourceRegistration, IPendingSingletonResourceRegistration, IRegisterer, IRequest, IRequestAwareUrl, IResponsable, IResponse, IRoute, IRouteCollection, IRouteRegistrar, IRouter, IServerBag, IServiceProvider, ISessionManager, IUploadedFile, IUrl, IUrlHelpers, IValidationRule, IValidator, InputBag, JobPayload, LimitSpec, ListenerClassConstructor, MergedConstructor, MessagesForRules, MiddlewareIdentifier, MiddlewareList, MixinConstructor, NormalizedAction, OServiceProvider, ParamableValidationRuleName, PathLoader, PlainRuleName, RateLimiterAdapter, RedirectHandler, RenderExceptionCallback, ReportExceptionCallback, RequestMethod, RequestObject, ResourceMethod, ResourceOptions, ResponsableType, ResponseObject, RouteActions, RouteAttributes, RouteEventHandler, RouteMethod, RouteParams, RouterEnd, RulesForData, ServiceProviderConstructor, SessionDriver, TGeneric, ThrottleExceptionCallback, Unlimited, UrlRoutable, UseKey, ValidationMessageProvider, ValidationRuleCallable, ValidationRuleName, ValidationRuleSet };
+export { AServiceProvider, AbstractConstructor, ActionInput, AppEvent, AppListener, Argon2Options, BaseValidationRuleClass, BcryptOptions, Bindings, CKernel, CacheOptions, CallableConstructor, ClassConstructor, ClassicRouteDefinition, ConcreteConstructor, CustomValidationRules, DotFlatten, DotNestedKeys, DotNestedValue, DotPaths, EventHandler, ExceptionConditionCallback, ExceptionConstructor, ExtractClassMethods, ExtractRules, FieldMessages, FlashBag, GenericObject, GenericWithNullableStringValues, HashAlgorithm, HashConfiguration, HashInfo, HashOptions, IAbstractHasher, IAbstractRouteCollection, IAppBuilder, IApplication, IArgon2idHasher, IArgonHasher, IBaseHashManager, IBcryptHasher, IBinding, IBootstraper, ICallableDispatcher, ICompiledRoute, IContainer, IController, IControllerDispatcher, IDispatcher, IExceptionHandler, IFileBag, IFileInput, IHashManager, IHeaderBag, IHttpContext, IHttpRequest, IHttpResponse, IJob, IKernel, IMessageBag, IMiddleware, IMiddlewareHandler, IModel, IParamBag, IPathName, IPendingResourceRegistration, IPendingSingletonResourceRegistration, IRegisterer, IRequest, IRequestAwareUrl, IResponsable, IResponse, IRoute, IRouteCollection, IRouteRegistrar, IRouteUrlGenerator, IRouter, IServerBag, IServiceProvider, ISessionDriver, ISessionManager, IUploadedFile, IUrl, IUrlGenerator, IUrlHelpers, IValidationRule, IValidator, InputBag, JobPayload, LimitSpec, ListenerClassConstructor, MergedConstructor, MessagesForRules, MiddlewareIdentifier, MiddlewareList, MixinConstructor, NormalizedAction, OServiceProvider, ParamableValidationRuleName, PathLoader, PlainRuleName, RateLimiterAdapter, RedirectHandler, RenderExceptionCallback, ReportExceptionCallback, RequestMethod, RequestObject, ResourceMethod, ResourceOptions, ResponsableType, ResponseObject, RouteActions, RouteAttributes, RouteEventHandler, RouteMethod, RouteParams, RouterEnd, RulesForData, ServiceProviderConstructor, SessionDriverBuilder, SessionDriverOption, TGeneric, ThrottleExceptionCallback, UnknownHashOptions, Unlimited, UrlRoutable, UseKey, ValidationMessageProvider, ValidationRuleCallable, ValidationRuleName, ValidationRuleSet };