@h3ravel/support 0.15.6 → 0.16.1

package/dist/index.d.ts

@@ -1,10 +1,64 @@
 /// <reference path="./app.globals.d.ts" />
 import "node:module";
+import { CallableConstructor, ClassConstructor, ConcreteConstructor, IApplication, IServiceProvider } from "@h3ravel/contracts";
+import { Collection as Collection$1 } from "@h3ravel/collect.js";
+import * as _h3ravel_shared0 from "@h3ravel/shared";
 import { DotFlatten, DotNestedKeys, DotNestedValue } from "@h3ravel/shared";
-import dayjs, { ConfigType, Dayjs, OpUnitType } from "dayjs";
+import dayjs, { ConfigType, Dayjs, OpUnitType, OptionType } from "dayjs";
 
 //#region rolldown:runtime
 //#endregion
+//#region src/Collection.d.ts
+declare class Collection<Item = any> extends Collection$1<Item> {
+  /**
+   *
+   * @param collection
+   */
+  constructor(collection?: Item[] | Item | Record<string, Item>);
+}
+/**
+ *
+ * @param collection
+ * @returns
+ */
+declare const collect: <T$1>(collection?: T$1 | T$1[] | Record<string, T$1> | undefined) => Collection<T$1>;
+//#endregion
+//#region src/HigherOrderTapProxy.d.ts
+declare class HigherOrderTapProxy<Target extends Record<string, (...args: any[]) => any>> {
+  /**
+   * The target being tapped.
+   */
+  target: Target;
+  /**
+   * Create a new tap proxy instance.
+   */
+  constructor(target: Target);
+  /**
+   * Dynamically pass method calls to the target.
+   *
+   * @param  method
+   * @param  parameters
+   */
+  __call(method: string, parameters: any[]): Target;
+}
+//#endregion
+//#region src/Contracts/Helpers.d.ts
+interface Tap {
+  <X extends Record<string, any>>(value: X): HigherOrderTapProxy<X>;
+  <X extends Record<string, any>>(value: X, callback?: (val: X) => void): X;
+}
+interface OptionalFn {
+  <T$1>(value: Nullable<T$1>): OptionalProxy<T$1>;
+  <T$1, R$1>(value: Nullable<T$1>, callback: (value: T$1) => R$1): R$1 | undefined;
+}
+type Macro = (...args: any[]) => any;
+type MacroMap = Record<string, (...args: any[]) => any>;
+type WithMacros<M extends MacroMap> = { [K in keyof M]: M[K] };
+type Nullable<T$1> = T$1 | null | undefined;
+type OptionalProxy<T$1> = { [K in keyof T$1]: T$1[K] extends ((...args: infer A) => infer R) ? (...args: A) => OptionalProxy<R> : OptionalProxy<T$1[K]> } & {
+  value(): T$1 | undefined;
+};
+//#endregion
 //#region src/Contracts/StrContract.d.ts
 /**
  * Converts CamelCased strings to snake_case
@@ -55,6 +109,12 @@ type JsonSerializable = {
   jsonSerialize(): any;
 };
 //#endregion
+//#region src/Exceptions/BadMethodCallException.d.ts
+/**
+ * Exception thrown if an error with a method call occurs.
+ */
+declare class BadMethodCallException extends Error {}
+//#endregion
 //#region src/Exceptions/InvalidArgumentException.d.ts
 /**
  * Custom error for invalid type coercion
@@ -65,10 +125,10 @@ declare class InvalidArgumentException extends Error {
 //#endregion
 //#region src/Exceptions/RuntimeException.d.ts
 /**
- * Custom error for invalid type coercion
+ * Exception thrown if an error which can only be found on runtime occurs.
  */
 declare class RuntimeException extends Error {
-  constructor(message: string);
+  constructor(message?: string);
 }
 declare namespace Crypto_d_exports {
   export { base64Decode, base64Encode, caesarCipher, checksum, hash, hmac, random, randomColor, randomPassword, randomSecure, secureToken, uuid, verifyChecksum, xor };
@@ -247,7 +307,7 @@ declare namespace Obj_d_exports {
  * with dot-separated keys.
  *
  * Example:
- * doter({
+ * dot({
  *   user: { name: "John", address: { city: "NY" } },
  *   active: true
  * })
@@ -293,9 +353,14 @@ declare const getValue: <T$1 extends Record<string, any>>(key: string | [keyof T
  * @param callback - Function that receives [key, value] and returns [newKey, newValue]
  * @returns A new object with transformed entries
  */
-declare const modObj: <T$1 extends object, R>(obj: T$1, callback: (_entry: [keyof T$1 & string, T$1[keyof T$1]]) => [string, R]) => Record<string, R>;
-declare function safeDot<T$1 extends Record<string, any>>(_data: T$1): T$1;
-declare function safeDot<T$1 extends Record<string, any>, K$1 extends DotNestedKeys<T$1>>(_data: T$1, _key?: K$1): DotNestedValue<T$1, K$1>;
+declare const modObj: <T$1 extends object, R$1>(obj: T$1, callback: (_entry: [keyof T$1 & string, T$1[keyof T$1]]) => [string, R$1]) => Record<string, R$1>;
+/**
+ * Safely convert an object to dot notation
+ *
+ * @param data
+ */
+declare function safeDot<T$1 extends Record<string, any>>(data: T$1): T$1;
+declare function safeDot<T$1 extends Record<string, any>, K$1 extends DotNestedKeys<T$1>>(data: T$1, key?: K$1): DotNestedValue<T$1, K$1>;
 /**
  * Sets a nested property on an object using dot notation.
  *
@@ -327,6 +392,9 @@ declare const slugifyKeys: <T$1 extends object>(obj: T$1, only?: string[], separ
  * - Arrays: included if truthy
  * - Objects: keys included if value is truthy
  * - Strings: included as-is
+ *
+ * @param input
+ * @returns
  */
 declare function toCssClasses<T$1 extends string | Record<string, boolean> | Array<string | false | null | undefined>>(input: T$1): string;
 /**
@@ -334,6 +402,9 @@ declare function toCssClasses<T$1 extends string | Record<string, boolean> | Arr
  *
  * Convert object input into CSS style string.
  * - Only includes truthy values (ignores null/undefined/false)
+ *
+ * @param styles
+ * @returns
  */
 declare function toCssStyles<T$1 extends Record<string, string | number | boolean | null | undefined>>(styles: T$1): string;
 /**
@@ -343,48 +414,76 @@ declare function toCssStyles<T$1 extends Record<string, string | number | boolea
  *
  * Example:
  * undot({ 'a.b': 1, 'c.0': 2 }) -> { a: { b: 1 }, c: [2] }
+ *
+ * @param obj
+ * @returns
  */
 declare function undot(obj: Record<string, any>): Record<string, any>;
 /**
  * data_get
  *
  * Get a value from an object using dot notation.
+ *
+ * @param obj
+ * @param path
+ * @param defaultValue
+ * @returns
  */
 declare function data_get<T$1 extends object, P extends DotPath<T$1> | DotPath<T$1>[], D = undefined>(obj: T$1, path: P, defaultValue?: D): T$1 | any;
 /**
  * data_set
  *
  * Set a value in an object using dot notation. Mutates the object.
+ *
+ * @param obj
+ * @param path
+ * @param value
  */
 declare function data_set<T$1 extends Record<string, any>, P extends string | string[], V>(obj: T$1, path: P, value: V): asserts obj is T$1 & Record<P extends string ? P : P[0], V>;
 /**
  * data_fill
  *
  * Like data_set, but only sets the value if the key does NOT exist.
+ *
+ * @param obj
+ * @param path
+ * @param value
  */
 declare function data_fill(obj: Record<string, any>, path: string | string[], value: any): void;
 /**
  * data_forget
  *
  * Remove a key from an object using dot notation.
+ *
+ * @param obj
+ * @param path
  */
 declare function data_forget(obj: Record<string, any>, path: string | string[]): void;
 /**
  * Checks if a value is a plain object (not array, function, etc.)
  *
  * @param value
+ * @param allowArray
  * @returns
  */
-declare function isPlainObject(value: any): value is Record<string, any>;
+declare function isPlainObject<P = any>(value: P, allowArray?: boolean): value is P;
 declare class Obj {
   /**
    * Check if the value is a non-null object (associative/accessible).
+   *
+   * @param value
+   * @returns
    */
   static accessible(value: unknown): value is Record<string, any>;
   /**
    * Add a key-value pair to an object only if the key does not already exist.
    *
    * Returns a new object (does not mutate original).
+   *
+   * @param obj
+   * @param key
+   * @param value
+   * @returns
    */
   static add<T$1 extends Record<string, any>, K$1 extends string, V>(obj: T$1, key: K$1, value: V): T$1 & Record<K$1, V>;
   /**
@@ -399,10 +498,39 @@ declare class Obj {
   static deepMerge<T$1 extends Record<string, any>>(...objects: (Partial<T$1> | undefined | null)[]): T$1;
   /**
    * Split object into [keys, values]
+   *
+   * @param obj
+   * @returns
    */
   static divide<T$1 extends Record<string, any>>(obj: T$1): [string[], any[]];
+  /**
+   * Flattens a nested object into a single-level object
+   * with dot-separated keys.
+   *
+   * Example:
+   * dot({
+   *   user: { name: "John", address: { city: "NY" } },
+   *   active: true
+   * })
+   *
+   * Output:
+   * {
+   *   "user.name": "John",
+   *   "user.address.city": "NY",
+   *   "active": true
+   * }
+   *
+   * @template T - The type of the input object
+   * @param obj - The nested object to flatten
+   * @returns A flattened object with dotted keys and inferred types
+   */
+  static dot<T$1 extends Record<string, any>>(obj: T$1): DotFlatten<T$1>;
   /**
    * Check if a key exists in the object.
+   *
+   * @param obj
+   * @param key
+   * @returns
    */
   static exists<T$1 extends Record<string, any>>(obj: T$1, key: string | number): boolean;
   /**
@@ -410,26 +538,65 @@ declare class Obj {
    *
    * Example:
    * Obj.get({a:{b:1}}, 'a.b') -> 1
+   *
+   * @param obj
+   * @param path
+   * @param defaultValue
+   * @returns
    */
   static get<T$1 extends object, P extends DotPath<T$1>, D = undefined>(obj: T$1, path: P, defaultValue?: D): any;
   /**
    * Check if the object has a given key or keys (dot notation supported).
+   *
+   * @param obj
+   * @param keys
+   * @returns
    */
   static has<T$1 extends object, P extends DotPath<T$1>>(obj: T$1, keys: P | P[]): boolean;
   /**
    * Check if an object is associative (has at least one non-numeric key).
+   *
+   * @param obj
+   * @returns
    */
   static isAssoc(obj: unknown): obj is Record<string, any>;
+  /**
+   * Checks if a value is a plain object (not array, function, etc.)
+   *
+   * @param value
+   * @param allowArray
+   * @returns
+   */
+  static isPlainObject<P = any>(value: P, allowArray?: boolean): value is P;
   /**
    * Add a prefix to all keys of the object.
+   *
+   * @param obj
+   * @param prefix
+   * @returns
    */
   static prependKeysWith<T$1 extends Record<string, any>>(obj: T$1, prefix: string): Record<string, any>;
   /**
    * Convert an object into a URL query string.
    *
    * Nested objects/arrays are flattened using bracket notation.
+   *
+   * @param obj
+   * @returns
    */
   static query(obj: Record<string, any>): string;
+  /**
+   * undot
+   *
+   * Convert a dot-notated object back into nested structure.
+   *
+   * Example:
+   * undot({ 'a.b': 1, 'c.0': 2 }) -> { a: { b: 1 }, c: [2] }
+   *
+   * @param obj
+   * @returns
+   */
+  undot(obj: Record<string, any>): Record<string, any>;
 }
 //#endregion
 //#region src/Helpers/Arr.d.ts
@@ -448,7 +615,7 @@ declare class Arr {
    * Helper: deep clone for safety (simple).
    * Uses JSON methods — good for typical data shapes (no functions, Dates, Maps).
    */
-  static _clone<A = any>(value: A): A;
+  static _clone<A$1 = any>(value: A$1): A$1;
   /**
    * Retrieve a value using dot notation
    * Throws if value is not an array
@@ -474,7 +641,7 @@ declare class Arr {
    *
    * Accepts any number of array arguments (or single array-of-arrays).
    */
-  static crossJoin<A>(...arrays: A[][]): A[][];
+  static crossJoin<A$1>(...arrays: A$1[][]): A$1[][];
   /**
    * Split an array (or object) into two arrays: [keys, values].
    *
@@ -484,7 +651,7 @@ declare class Arr {
    * Arr.divide(['a','b']) -> [[0,1], ['a','b']]
    * Arr.divide({x:1,y:2}) -> [['x','y'], [1,2]]
    */
-  static divide<A>(input: A[] | Record<string, A>): (A[] | number[])[] | (A[] | string[])[];
+  static divide<A$1>(input: A$1[] | Record<string, A$1>): (number[] | A$1[])[] | (string[] | A$1[])[];
   /**
    * Flatten a nested array/object structure into a single-level object
    * with dot-notated keys.
@@ -494,7 +661,7 @@ declare class Arr {
    *
    * Works for arrays and plain objects.
    */
-  static dot<A>(input: A[] | Record<string, A>, prefix?: string): Record<string, A>;
+  static dot<A$1>(input: A$1[] | Record<string, A$1>, prefix?: string): Record<string, A$1>;
   /**
    * Checks if all elements satisfy the predicate
    */
@@ -509,7 +676,7 @@ declare class Arr {
    * Example:
    * Arr.except([10,20,30], [1]) -> [10,30]
    */
-  static except<A extends any[] | Record<string, any>, X>(input: A, keys: X[]): A;
+  static except<A$1 extends any[] | Record<string, any>, X>(input: A$1, keys: X[]): A$1;
   /**
    * Return the first element of an array that satisfies the predicate,
    * or the first element if no predicate is provided, otherwise the defaultValue.
@@ -524,14 +691,14 @@ declare class Arr {
    *
    * @returns
    */
-  static first<A, P extends (((arg: A) => true) | true)>(array: A[], predicate?: P | undefined, defaultValue?: A | undefined): P extends true ? [A, A[]] : A | undefined;
+  static first<A$1, P extends (((arg: A$1) => true) | true)>(array: A$1[], predicate?: P | undefined, defaultValue?: A$1 | undefined): P extends true ? [A$1, A$1[]] : A$1 | undefined;
   /**
    * Recursively flatten an array up to `depth` levels (default: Infinity).
    *
    * Example:
    * Arr.flatten([1, [2, [3]]], 1) -> [1,2,[3]]
    */
-  static flatten<A>(array: A[], depth?: number): A[];
+  static flatten<A$1>(array: A$1[], depth?: number): A$1[];
   /**
    * Retrieve a value from an array/object using dot notation
    * Throws if value is not a float
@@ -548,7 +715,7 @@ declare class Arr {
    * Arr.forget([1,2,3], 1) -> [1,3]
    * Arr.forget({a:{b:1}}, 'a.b') -> { a: {} }
    */
-  static forget<A extends any[] | Record<string, any>>(input: A, keys: any): A;
+  static forget<A$1 extends any[] | Record<string, any>>(input: A$1, keys: any): A$1;
   /**
    * Converts various input types into a plain array
    * Supports Arrays, Objects, Iterables, Map, WeakMap, and custom toArray/toJSON/jsonSerialize methods
@@ -566,7 +733,7 @@ declare class Arr {
    * Example:
    * Arr.hasAny([1,2,3], [4,2]) -> true
    */
-  static hasAny<A>(array: A[], values: A[] | A): boolean;
+  static hasAny<A$1>(array: A$1[], values: A$1[] | A$1): boolean;
   /**
    * Retrieve a value using dot notation
    * Throws if value is not an integer
@@ -580,7 +747,7 @@ declare class Arr {
    * Arr.isList([1,2,3]) -> true
    * const a = []; a[2] = 5; Arr.isList(a) -> false
    */
-  static isList<A>(value: A[]): boolean;
+  static isList<A$1>(value: A$1[]): boolean;
   /**
    * Join array elements into a string using the given separator.
    *
@@ -721,7 +888,7 @@ declare class Arr {
   /**
    * Filter an array of objects, keeping elements where the given key is not null/undefined.
    */
-  static whereNotNull<T$1>(array: T$1[], key: keyof T$1): T$1[];
+  static whereNotNull<T$1>(array: T$1[], key?: keyof T$1): T$1[];
   /**
    * If the given value is not an array and not null, wrap it in one.
    *
@@ -730,7 +897,7 @@ declare class Arr {
    * @param value
    * @returns
    */
-  static wrap<T$1>(value: T$1 | T$1[] | null | undefined): T$1[];
+  static wrap<T$1 = any>(value: T$1 | T$1[] | null | undefined): T$1[];
   /**
    * Return the first element of an array, undefined if empty.
    */
@@ -810,7 +977,7 @@ declare class Arr {
    * @alias Arr.first()
    * @returns
    */
-  static shift<A, P extends (((arg: A) => true) | true)>(array: A[], predicate?: P | undefined, defaultValue?: A | undefined): P extends true ? [A, A[]] : A | undefined;
+  static shift<A$1, P extends (((arg: A$1) => true) | true)>(array: A$1[], predicate?: P | undefined, defaultValue?: A$1 | undefined): P extends true ? [A$1, A$1[]] : A$1 | undefined;
   /**
    * Generates an array of sequential numbers.
    *
@@ -819,6 +986,13 @@ declare class Arr {
    * @returns An array of numbers from startAt to startAt + size - 1
    */
   static range(size: number, startAt?: number): number[];
+  /**
+   * Filters an array and returns only unique values
+   *
+   * @param items
+   * @returns
+   */
+  static unique<T$1 = any>(items: T$1[]): T$1[];
 }
 //#endregion
 //#region src/Helpers/Time.d.ts
@@ -829,6 +1003,7 @@ declare const TimeClass: {
 declare class DateTime extends TimeClass {
   private instance;
   constructor(config?: ConfigType);
+  constructor(config?: ConfigType, format?: OptionType, locale?: boolean);
   /**
    * Start time of a specific unit.
    *
@@ -1086,6 +1261,22 @@ declare class Str {
    * @return { boolean }
    */
   static containsAll(haystack: string, needles: string[], ignoreCase?: boolean): boolean;
+  /**
+   * Convert the case of a string.
+   *
+   * @param { string } string
+   * @param { Mode | number } mode
+   *
+   * @return { string }
+   */
+  static convertCase(string: string, mode?: Mode | number): string;
+  /**
+   * Detect content type
+   *
+   * @param content
+   * @returns
+   */
+  static detectContentType(content: any): "json" | "xml" | "html" | "text";
   /**
    * Determine if a given string doesn't contain a given substring.
    *
@@ -1096,15 +1287,6 @@ declare class Str {
    * @return { boolean }
    */
   static doesntContain(haystack: string, needles: string | string[], ignoreCase?: boolean): boolean;
-  /**
-   * Convert the case of a string.
-   *
-   * @param { string } string
-   * @param { Mode | number } mode
-   *
-   * @return { string }
-   */
-  static convertCase(string: string, mode?: Mode | number): string;
   /**
    * Replace consecutive instances of a given character with a single character in the given string.
    *
@@ -1293,6 +1475,13 @@ declare class Str {
    * @return { string }
    */
   static lower(value: string): string;
+  /**
+   * Parse a Class[@]method style callback into class and method.
+   *
+   * @param callback
+   * @param defaultValue
+   */
+  static parseCallback(callback: string, defaultValue?: string): (string | undefined)[];
   /**
    * Get substring by start/stop indexes.
    *
@@ -1960,6 +2149,15 @@ declare class Str {
    * @return { string }
    */
   static uuid7(time?: Date | null): string;
+  /**
+   * Validate an IP address
+   *
+   * @param host
+   * @param type
+   *
+   * @return { boolean }
+   */
+  static validateIp(host: string, type?: 'ipv4' | 'ipv6'): boolean;
   /**
    * Generate a time-ordered UUID (version 4).
    *
@@ -2177,6 +2375,14 @@ declare class Stringable {
    * @return { boolean }
    */
   containsAll(needles: string[], ignoreCase?: boolean): boolean;
+  /**
+   * Convert the case of a string.
+   *
+   * @param { Mode | number } mode
+   *
+   * @return { Stringable }
+   */
+  convertCase(mode?: Mode | number): Stringable;
   /**
    * Determine if a given string doesn't contain a given substring.
    *
@@ -2187,13 +2393,12 @@ declare class Stringable {
    */
   doesntContain(needles: string | string[], ignoreCase?: boolean): boolean;
   /**
-   * Convert the case of a string.
-   *
-   * @param { Mode | number } mode
+   * Detect content type
    *
-   * @return { Stringable }
+   * @param content
+   * @returns
    */
-  convertCase(mode?: Mode | number): Stringable;
+  static detectContentType(content: any): "json" | "xml" | "html" | "text";
   /**
    * Replace consecutive instances of a given character with a single character in the given string.
    *
@@ -2808,6 +3013,14 @@ declare class Stringable {
    * @return { this }
    */
   unless(value: Value<this>, callback: Callback<this>, fallback?: Fallback<this>): this;
+  /**
+   * Validate an IP address
+   *
+   * @param host
+   * @param type
+   * @returns
+   */
+  validateIp(type?: 'ipv4' | 'ipv6'): boolean;
   /**
    * Execute the given callback if the string contains a given substring.
    *
@@ -3219,4 +3432,225 @@ declare function loadHelpers(target?: any): void;
  */
 declare function cleanHelpers(target?: any): void;
 //#endregion
-export { Arr, Arrayable, Callback, CamelToSnakeCase, Crypto_d_exports as Crypto, DateTime, DotPath, ExcerptOptions, Fallback, Function, GlobalHelpers, HtmlString, HtmlStringType, InvalidArgumentException, JsonSerializable, Jsonable, KeysToSnakeCase, Mode, Number_d_exports as Number, Obj, RuntimeException, SnakeToCamelCase, SnakeToTitleCase, Str, Stringable, TGeneric, Value, XGeneric, abbreviate, base64Decode, base64Encode, caesarCipher, checksum, cleanHelpers, data_fill, data_forget, data_get, data_set, dd, dot, dump, extractProperties, format, getValue, hash, hmac, humanize, isPlainObject, loadHelpers, modObj, random, randomColor, randomPassword, randomSecure, safeDot, secureToken, setNested, slugifyKeys, str, toBytes, toCssClasses, toCssStyles, toHumanTime, undot, uuid, verifyChecksum, xor };
+//#region src/Helpers.d.ts
+/**
+ * Call the given Closure with the given value then return the value.
+ *
+ * @param  value
+ * @param  callback
+ */
+declare const tap: Tap;
+/**
+ * Optional Proxy factory
+ *
+ * @param value
+ * @returns
+ */
+declare const createOptionalProxy: <T$1>(value: Nullable<T$1>) => OptionalProxy<T$1>;
+/**
+ * Provide access to optional objects.
+ *
+ * @param  value
+ * @param  callback
+ */
+declare const optional: OptionalFn;
+/**
+ * Checks if the givevn value is a class
+ *
+ * @param C
+ */
+declare const isClass: (C: any) => C is new (...args: any[]) => any;
+/**
+ * Checks if the givevn value is an abstract class
+ *
+ * @param C
+ */
+declare const isAbstract: (C: any) => C is new (...args: any[]) => any;
+/**
+ * Checks if the givevn value is callable
+ *
+ * @param C
+ */
+declare const isCallable: (C: any) => C is (...args: any[]) => any;
+//#endregion
+//#region src/Macroable.d.ts
+declare const Macroable: <M extends MacroMap = MacroMap>() => _h3ravel_shared0.Trait<(Base: any) => {
+  new (...args: any[]): this & WithMacros<M>;
+  [x: string]: any;
+  macros: Record<string, Macro>;
+  macro(name: string, macro: Macro): void;
+  hasMacro(name: string): boolean;
+  flushMacros(): void;
+  mixin(mixin: object, replace?: boolean): void;
+  createProxy<T$1 extends /*elided*/any>(this: T$1): T$1;
+  /**
+   * Dynamically handle calls to the class.
+   *
+   * @param  method
+   * @param  parameters
+   *
+   * @throws {BadMethodCallException}
+   */
+  macroCallStatic(method: string, parameters?: any[]): any;
+}, undefined>;
+declare const MacroableClass: {
+  new (...args: any[]): {
+    [x: string]: any;
+    /**
+     * Dynamically handle calls to the class.
+     *
+     * @param  method
+     * @param  parameters
+     *
+     * @throws {BadMethodCallException}
+     */
+    macroCall(method: string, parameters?: any[]): any;
+  };
+  [x: string]: any;
+  macros: Record<string, Macro>;
+  macro(name: string, macro: Macro): void;
+  hasMacro(name: string): boolean;
+  flushMacros(): void;
+  mixin(mixin: object, replace?: boolean): void;
+  createProxy<T$1 extends /*elided*/any>(this: T$1): T$1;
+  /**
+   * Dynamically handle calls to the class.
+   *
+   * @param  method
+   * @param  parameters
+   *
+   * @throws {BadMethodCallException}
+   */
+  macroCallStatic(method: string, parameters?: any[]): any;
+};
+//#endregion
+//#region src/Providers/ServiceProvider.d.ts
+declare abstract class ServiceProvider extends IServiceProvider {
+  /**
+   * The current app instance
+   */
+  protected app: IApplication;
+  /**
+   * Unique Identifier for the service providers
+   */
+  static uid?: number;
+  /**
+   * Sort order
+   */
+  static order?: `before:${string}` | `after:${string}` | string | undefined;
+  /**
+   * Sort priority
+   */
+  static priority: number;
+  /**
+   * Indicate that this service provider only runs in console
+   */
+  static console?: boolean;
+  /**
+   * Indicate that this service provider only runs in console
+   */
+  console?: boolean;
+  /**
+   * Indicate that this service provider only runs in console
+   */
+  runsInConsole: boolean;
+  /**
+   * List of registered console commands
+   */
+  registeredCommands: (new (app: any, kernel: any) => any)[];
+  /**
+   * All of the registered booted callbacks.
+   */
+  protected bootedCallbacks: Array<(...args: any[]) => void>;
+  constructor(app: IApplication);
+  /**
+   * Register a booted callback to be run after the "boot" method is called.
+   *
+   * @param callback
+   */
+  booted(callback: (...args: any[]) => void): void | Promise<void>;
+  /**
+   * Call the registered booted callbacks.
+   */
+  callBootedCallbacks(): Promise<void>;
+  /**
+   * Register the listed service providers.
+   *
+   * @param commands An array of console commands to register.
+   *
+   * @deprecated since version 1.16.0. Will be removed in future versions, use `registerCommands` instead
+   */
+  commands(commands: (new (app: any, kernel: any) => any)[]): void;
+  /**
+   * Register the listed service providers.
+   *
+   * @param commands An array of console commands to register.
+   */
+  registerCommands(commands: (new (app: any, kernel: any) => any)[]): void;
+}
+//#endregion
+//#region src/Providers/AssetsServiceProvider.d.ts
+/**
+ * Handles public assets loading
+ *
+ * Auto-Registered
+ */
+declare class AssetsServiceProvider extends ServiceProvider {
+  static priority: number;
+  register(): void;
+}
+//#endregion
+//#region src/Providers/RouteServiceProvider.d.ts
+/**
+ * Handles routing registration
+ *
+ * Load route files (web.ts, api.ts).
+ * Map controllers to routes.
+ * Register route-related middleware.
+ */
+declare class RouteServiceProvider extends ServiceProvider {
+  static priority: number;
+  /**
+   * The callback that should be used to load the application's routes.
+   */
+  protected loadRoutesUsing?: CallableConstructor;
+  /**
+   * The global callback that should be used to load the application's routes.
+   */
+  protected static alwaysLoadRoutesUsing?: CallableConstructor;
+  register(): Promise<void>;
+  /**
+   * Load routes from src/routes
+   */
+  boot(): Promise<void>;
+  /**
+   * Register the callback that will be used to load the application's routes.
+   *
+   * @param  routesCallback
+   */
+  protected routes(routesCallback: CallableConstructor): this;
+  /**
+   * Register the callback that will be used to load the application's routes.
+   *
+   * @param  routesCallback
+   */
+  static loadRoutesUsing(routesCallback?: CallableConstructor): void;
+  /**
+   * Load the application routes.
+   */
+  protected loadRoutes(): Promise<void>;
+}
+//#endregion
+//#region src/Tappable.d.ts
+declare const Tappable: <X extends ConcreteConstructor<ClassConstructor>>(Base: X) => {
+  new (...args: any[]): {
+    /**
+     * Call the given Closure with this instance then return the instance.
+     *
+     * @param  callback
+     */
+    tap(callback?: CallableConstructor): /*elided*/any;
+  };
+} & X;
+//#endregion
+export { Arr, Arrayable, AssetsServiceProvider, BadMethodCallException, Callback, CamelToSnakeCase, Collection, Crypto_d_exports as Crypto, DateTime, DotPath, ExcerptOptions, Fallback, Function, GlobalHelpers, HigherOrderTapProxy, HtmlString, HtmlStringType, InvalidArgumentException, JsonSerializable, Jsonable, KeysToSnakeCase, Macro, MacroMap, Macroable, MacroableClass, Mode, Nullable, Number_d_exports as Number, Obj, OptionalFn, OptionalProxy, RouteServiceProvider, RuntimeException, ServiceProvider, SnakeToCamelCase, SnakeToTitleCase, Str, Stringable, TGeneric, Tap, Tappable, Value, WithMacros, XGeneric, abbreviate, base64Decode, base64Encode, caesarCipher, checksum, cleanHelpers, collect, createOptionalProxy, data_fill, data_forget, data_get, data_set, dd, dot, dump, extractProperties, format, getValue, hash, hmac, humanize, isAbstract, isCallable, isClass, isPlainObject, loadHelpers, modObj, optional, random, randomColor, randomPassword, randomSecure, safeDot, secureToken, setNested, slugifyKeys, str, tap, toBytes, toCssClasses, toCssStyles, toHumanTime, undot, uuid, verifyChecksum, xor };