@h3ravel/support 0.14.3 → 0.14.5

package/dist/index.d.cts

@@ -1,3198 +0,0 @@
-/// <reference path="./app.globals.d.ts" />
-import "node:module";
-import { DotFlatten, DotNestedKeys, DotNestedValue } from "@h3ravel/shared";
-import dayjs, { ConfigType, Dayjs, OpUnitType } from "dayjs";
-
-//#region rolldown:runtime
-//#endregion
-//#region src/Contracts/StrContract.d.ts
-/**
- * Converts CamelCased strings to snake_case
- */
-type CamelToSnakeCase<S extends string> = S extends `${infer T}${infer U}` ? U extends Uncapitalize<U> ? `${Uncapitalize<T>}${CamelToSnakeCase<U>}` : `${Uncapitalize<T>}_${CamelToSnakeCase<U>}` : S;
-/**
- * Converts snake_cased strings to camelCase
- */
-type SnakeToCamelCase<S extends string> = S extends `${infer T}_${infer U}` ? `${T}${Capitalize<SnakeToCamelCase<U>>}` : S;
-/**
- * Converts snake_cased strings to TitleCasea
- */
-type SnakeToTitleCase<S extends string> = S extends `${infer First}_${infer Rest}` ? `${Capitalize<Lowercase<First>>}${SnakeToTitleCase<Rest>}` : Capitalize<Lowercase<S>>;
-type HtmlStringType = HTMLElement | Node | string;
-type ExcerptOptions = {
-  radius?: number;
-  omission?: string;
-};
-type Value<T$1> = boolean | ((instance: T$1) => boolean);
-type Callback<T$1> = (instance: T$1, value: boolean) => T$1 | void | undefined;
-type Fallback<T$1> = Callback<T$1> | null;
-interface Function {
-  (...args: any[]): any;
-}
-//#endregion
-//#region src/Contracts/ObjContract.d.ts
-/**
- * Convert CamelCased Object keys to snake_case
- */
-type KeysToSnakeCase<T$1> = { [K in keyof T$1 as CamelToSnakeCase<string & K>]: T$1[K] };
-type TGeneric<V$1 = any, K$1 extends string = string> = Record<K$1, V$1>;
-type XGeneric<V$1 = TGeneric, T$1 = any> = {
-  [key: string]: T$1;
-} & V$1;
-type DotPath<T$1> = T$1 extends object ? { [K in keyof T$1 & (string | number)]: T$1[K] extends object ? `${K}` | `${K}.${DotPath<T$1[K]>}` : `${K}` }[keyof T$1 & (string | number)] : never;
-//#endregion
-//#region src/Contracts/TypeCast.d.ts
-type Arrayable = {
-  [key: string]: any;
-  toArray(): any[];
-};
-type Jsonable = {
-  [key: string]: any;
-  toJSON(): any;
-};
-type JsonSerializable = {
-  [key: string]: any;
-  jsonSerialize(): any;
-};
-//#endregion
-//#region src/Exceptions/InvalidArgumentException.d.ts
-/**
- * Custom error for invalid type coercion
- */
-declare class InvalidArgumentException extends Error {
-  constructor(message: string);
-}
-//#endregion
-//#region src/Exceptions/RuntimeException.d.ts
-/**
- * Custom error for invalid type coercion
- */
-declare class RuntimeException extends Error {
-  constructor(message: string);
-}
-declare namespace Crypto_d_exports {
-  export { base64Decode, base64Encode, caesarCipher, checksum, hash, hmac, random, randomColor, randomPassword, randomSecure, secureToken, uuid, verifyChecksum, xor };
-}
-/**
- * Generate a random UUID string.
- *
- * @returns A random UUID string
- */
-declare const uuid: () => string;
-/**
- * Generate a random string of specified length.
- *
- * @param length - Length of the random string (default: 16)
- * @param charset - Character set to use (default: alphanumeric)
- * @returns A random string
- */
-declare const random: (length?: number, charset?: string) => string;
-/**
- * Secure random string generator that uses crypto.randomBytes.
- *
- * @param length - Length of the random string (default: 32)
- * @returns A cryptographically secure random string
- */
-declare const randomSecure: (length?: number) => string;
-/**
- * Hash a string using the specified algorithm.
- *
- * @param data - Data to hash
- * @param algorithm - Hash algorithm (default: 'sha256')
- * @returns Hexadecimal hash string
- */
-declare const hash: (data: string, algorithm?: string) => string;
-/**
- * Hash a string with salt using HMAC.
- *
- * @param data - Data to hash
- * @param key - Secret key for HMAC
- * @param algorithm - Hash algorithm (default: 'sha256')
- * @returns Hexadecimal hash string
- */
-declare const hmac: (data: string, key: string, algorithm?: string) => string;
-/**
- * Encode data to base64.
- *
- * @param data - Data to encode
- * @returns Base64 encoded string
- */
-declare const base64Encode: (data: string) => string;
-/**
- * Decode base64 data.
- *
- * @param data - Base64 string to decode
- * @returns Decoded string
- */
-declare const base64Decode: (data: string) => string;
-/**
- * Simple XOR encryption/decryption.
- *
- * @param data - Data to encrypt/decrypt
- * @param key - Encryption key
- * @returns Encrypted/decrypted string
- */
-declare const xor: (data: string, key: string) => string;
-/**
- * Generate a random hex color code.
- *
- * @returns A hex color code string (e.g., '#a3b2f3')
- */
-declare const randomColor: () => string;
-/**
- * Generate a secure password using configurable parameters.
- *
- * @param length - Password length (default: 16)
- * @param options - Character options
- * @returns A secure password string
- */
-interface PasswordOptions {
-  useUppercase?: boolean;
-  useLowercase?: boolean;
-  useNumbers?: boolean;
-  useSymbols?: boolean;
-}
-declare const randomPassword: (length?: number, options?: PasswordOptions) => string;
-/**
- * Generate a cryptographically secure token for APIs, sessions, etc.
- *
- * @param strength - Token strength (bytes) (default: 32)
- * @returns A secure token string
- */
-declare const secureToken: (strength?: number) => string;
-/**
- * Create a checksum for data integrity verification.
- *
- * @param data - Data to create checksum for
- * @param algorithm - Hash algorithm (default: 'sha256')
- * @returns SHA256 checksum
- */
-declare const checksum: (data: string, algorithm?: string) => string;
-/**
- * Verify data integrity using checksum.
- *
- * @param data - Data to verify
- * @param expectedChecksum - Expected checksum
- * @param algorithm - Hash algorithm (default: 'sha256')
- * @returns True if checksums match
- */
-declare const verifyChecksum: (data: string, expectedChecksum: string, algorithm?: string) => boolean;
-/**
- * Simple Caesar cipher implementation.
- *
- * @param text - Text to encrypt/decrypt
- * @param shift - Number of positions to shift (default: 13)
- * @returns Encrypted/decrypted text
- */
-declare const caesarCipher: (text: string, shift?: number) => string;
-declare namespace DumpDie_d_exports {
-  export { dd, dump };
-}
-/**
- * Dump something and kill the process for quick debugging. Based on Laravel's dd()
- *
- * @param args
- */
-declare const dd: (...args: unknown[]) => never;
-/**
- * Dump something but keep the process for quick debugging. Based on Laravel's dump()
- *
- * @param args
- */
-declare const dump: (...args: unknown[]) => void;
-declare namespace Number_d_exports {
-  export { abbreviate, humanize, toBytes, toHumanTime };
-}
-/**
- * Abbreviates large numbers using SI symbols (K, M, B...)
- * and formats the output according to the given locale.
- *
- * @param value - The number to abbreviate
- * @param locale - Optional locale string (default: "en-US")
- * @returns A localized, abbreviated number string
- */
-declare const abbreviate: (value?: number, locale?: string) => string;
-/**
- * Concverts a number into human readable string
- *
- * @param num The number to convert
- * @param slugify convert the ouput into a slug using this as a separator
- * @returns
- */
-declare const humanize: (num: number, slugify?: "-" | "_") => string;
-/**
- * Converts a number of bytes into a human-readable string.
- *
- * @param bytes - The size in bytes to convert
- * @param decimals - Number of decimal places to display (default: 2)
- * @param bits - If true, uses 1000-based (SI) units (B, KB, MB...);
- *               otherwise uses 1024-based binary units (Bytes, KiB...)
- * @returns A formatted string with the appropriate unit
- */
-declare const toBytes: (bytes?: number, decimals?: number, bits?: boolean) => string;
-/**
- * Formats a duration (in seconds) into a human-readable string.
- *
- * @param seconds - Duration in seconds
- * @param worded - If true, outputs worded format (e.g., "1hr 2min 3sec"),
- *                 otherwise HH:MM:SS (e.g., "01:02:03")
- * @returns A formatted time string
- */
-declare const toHumanTime: (seconds?: number, worded?: boolean) => string;
-declare namespace Obj_d_exports {
-  export { Obj, data_fill, data_forget, data_get, data_set, dot, extractProperties, getValue, modObj, safeDot, setNested, slugifyKeys, toCssClasses, toCssStyles, undot };
-}
-/**
- * Flattens a nested object into a single-level object
- * with dot-separated keys.
- *
- * Example:
- * doter({
- *   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
- */
-declare const dot: <T extends Record<string, any>>(obj: T) => DotFlatten<T>;
-/**
- * Extracts a subset of properties from an object.
- *
- * @template T - Type of the source object
- * @template K - Keys of T to extract
- * @param obj - The source object
- * @param keys - Array of keys to extract
- * @returns A new object with only the specified keys
- */
-declare const extractProperties: <T extends object, K extends keyof T>(obj: T, keys?: readonly K[]) => Pick<T, K>;
-/**
- * Safely retrieves a value from an object by key or nested keys.
- *
- * @template T - Type of the source object
- * @param key - Single key or tuple [parentKey, childKey]
- * @param item - The source object
- * @returns The found value as a string or the key itself if not found
- */
-declare const getValue: <T extends Record<string, any>>(key: string | [keyof T, keyof T[string]], item: T) => string;
-/**
- * Maps over an object's entries and returns a new object
- * with transformed keys and/or values.
- *
- * @template T - Type of the input object
- * @template R - Type of the new values
- * @param obj - The object to transform
- * @param callback - Function that receives [key, value] and returns [newKey, newValue]
- * @returns A new object with transformed entries
- */
-declare const modObj: <T extends object, R>(obj: T, callback: (_entry: [keyof T & string, T[keyof T]]) => [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>;
-/**
- * Sets a nested property on an object using dot notation.
- *
- * @example
- * const obj = {}
- * setNested(obj, 'app.user.name', 'Legacy')
- * console.log(obj)
- * // Output: { app: { user: { name: 'Legacy' } } }
- *
- * @param obj - The target object to modify.
- * @param key - The dot-separated key (e.g., 'app.user.name').
- * @param value - The value to set at the specified path.
- */
-declare const setNested: (obj: Record<string, any>, key: string, value: any) => void;
-/**
- * Converts object keys to a slugified format (e.g., snake_case).
- *
- * @template T - Type of the input object
- * @param obj - The object whose keys will be slugified
- * @param only - Optional array of keys to slugify (others remain unchanged)
- * @param separator - Separator for slugified keys (default: "_")
- * @returns A new object with slugified keys
- */
-declare const slugifyKeys: <T extends object>(obj: T, only?: string[], separator?: string) => KeysToSnakeCase<T>;
-/**
- * toCssClasses
- *
- * Convert array/object/string input into a CSS class string.
- * - Arrays: included if truthy
- * - Objects: keys included if value is truthy
- * - Strings: included as-is
- */
-declare function toCssClasses<T$1 extends string | Record<string, boolean> | Array<string | false | null | undefined>>(input: T$1): string;
-/**
- * toCssStyles
- *
- * Convert object input into CSS style string.
- * - Only includes truthy values (ignores null/undefined/false)
- */
-declare function toCssStyles<T$1 extends Record<string, string | number | boolean | null | undefined>>(styles: T$1): string;
-/**
- * undot
- *
- * Convert a dot-notated object back into nested structure.
- *
- * Example:
- * undot({ 'a.b': 1, 'c.0': 2 }) -> { a: { b: 1 }, c: [2] }
- */
-declare function undot(obj: Record<string, any>): Record<string, any>;
-/**
- * data_get
- *
- * Get a value from an object using dot notation.
- */
-declare function data_get<T$1 extends object, P$1 extends DotPath<T$1> | DotPath<T$1>[], D$1 = undefined>(obj: T$1, path: P$1, defaultValue?: D$1): T$1 | any;
-/**
- * data_set
- *
- * Set a value in an object using dot notation. Mutates the object.
- */
-declare function data_set<T$1 extends Record<string, any>, P$1 extends string | string[], V$1>(obj: T$1, path: P$1, value: V$1): asserts obj is T$1 & Record<P$1 extends string ? P$1 : P$1[0], V$1>;
-/**
- * data_fill
- *
- * Like data_set, but only sets the value if the key does NOT exist.
- */
-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.
- */
-declare function data_forget(obj: Record<string, any>, path: string | string[]): void;
-declare class Obj {
-  /**
-   * Check if the value is a non-null object (associative/accessible).
-   */
-  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).
-   */
-  static add<T extends Record<string, any>, K extends string, V>(obj: T, key: K, value: V): T & Record<K, V>;
-  /**
-   * Split object into [keys, values]
-   */
-  static divide<T extends Record<string, any>>(obj: T): [string[], any[]];
-  /**
-   * Check if a key exists in the object.
-   */
-  static exists<T extends Record<string, any>>(obj: T, key: string | number): boolean;
-  /**
-   * Get a value from an object using dot notation.
-   *
-   * Example:
-   * Obj.get({a:{b:1}}, 'a.b') -> 1
-   */
-  static get<T extends object, P extends DotPath<T>, D = undefined>(obj: T, path: P, defaultValue?: D): any;
-  /**
-   * Check if the object has a given key or keys (dot notation supported).
-   */
-  static has<T extends object, P extends DotPath<T>>(obj: T, keys: P | P[]): boolean;
-  /**
-   * Check if an object is associative (has at least one non-numeric key).
-   */
-  static isAssoc(obj: unknown): obj is Record<string, any>;
-  /**
-   * Add a prefix to all keys of the object.
-   */
-  static prependKeysWith<T extends Record<string, any>>(obj: T, prefix: string): Record<string, any>;
-  /**
-   * Convert an object into a URL query string.
-   *
-   * Nested objects/arrays are flattened using bracket notation.
-   */
-  static query(obj: Record<string, any>): string;
-}
-//#endregion
-//#region src/Helpers/Arr.d.ts
-/**
- * Arr — Laravel-like array helpers for JavaScript.
- *
- * - Methods aim for clear, predictable JS behavior.
- * - Inputs are validated where useful; functions try not to mutate arguments.
- */
-declare class Arr {
-  /**
-   * Helper: is a value an object (but not null).
-   */
-  static _isObject(value: any): boolean;
-  /**
-   * 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;
-  /**
-   * Retrieve a value using dot notation
-   * Throws if value is not an array
-   */
-  static array(obj: any, path: string, defaultValue?: number): any[];
-  /**
-   * Retrieve a value using dot notation
-   * Throws if value is not a boolean
-   */
-  static boolean(obj: any, path: string, defaultValue?: boolean): boolean;
-  /**
-   * Flatten an array of arrays by one level.
-   *
-   * Example:
-   * Arr.collapse([[1,2], [3], 4]) -> [1,2,3,4]
-   */
-  static collapse<X>(array: X[][] | X[]): X[];
-  /**
-   * Cartesian product of arrays.
-   *
-   * Example:
-   * Arr.crossJoin([1,2], ['a','b']) -> [[1,'a'], [1,'b'], [2,'a'], [2,'b']]
-   *
-   * Accepts any number of array arguments (or single array-of-arrays).
-   */
-  static crossJoin<A>(...arrays: A[][]): A[][];
-  /**
-   * Split an array (or object) into two arrays: [keys, values].
-   *
-   * For arrays, keys are numeric indices. For objects, keys are property names.
-   *
-   * Example:
-   * 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[])[] | (string[] | A[])[];
-  /**
-   * Flatten a nested array/object structure into a single-level object
-   * with dot-notated keys.
-   *
-   * Example:
-   * Arr.dot({ a: { b: 1 }, c: [2,3] }) -> { 'a.b': 1, 'c.0': 2, 'c.1': 3 }
-   *
-   * Works for arrays and plain objects.
-   */
-  static dot<A>(input: A[] | Record<string, A>, prefix?: string): Record<string, A>;
-  /**
-   * Checks if all elements satisfy the predicate
-   */
-  static every<T>(array: T[], predicate: (item: T) => boolean): boolean;
-  /**
-   * Remove items by keys/indices from an array or properties from an object.
-   *
-   * For arrays: keys are numeric indices (single number or array of numbers).
-   *
-   * Returns a shallow-copied result (does not mutate input).
-   *
-   * Example:
-   * Arr.except([10,20,30], [1]) -> [10,30]
-   */
-  static except<A extends any[] | Record<string, any>, X>(input: A, keys: X[]): A;
-  /**
-   * Return the first element of an array that satisfies the predicate,
-   * or the first element if no predicate is provided, otherwise the defaultValue.
-   *
-   * Predicate can be true (boolean), a function or a value to match (strict equality).
-   *
-   * When predicate is true (boolean), the first element will be removed and a tuple will be returned [el, rest].
-   *
-   * @param array
-   * @param predicate
-   * @param defaultValue
-   *
-   * @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;
-  /**
-   * 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[];
-  /**
-   * Retrieve a value from an array/object using dot notation
-   * Throws if value is not a float
-   */
-  static float(obj: any, path: string, defaultValue?: number): number;
-  /**
-   * Remove element(s) by index or dot-notated path from an array/object.
-   *
-   * For arrays: accepts numeric index or array of indices. Returns a new array.
-   *
-   * For objects: supports dot notation to remove nested keys.
-   *
-   * Example:
-   * 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;
-  /**
-   * Converts various input types into a plain array
-   * Supports Arrays, Objects, Iterables, Map, WeakMap, and custom toArray/toJSON/jsonSerialize methods
-   */
-  static from<T>(value: T | Iterable<T> | Arrayable | Jsonable | JsonSerializable | null | undefined): any[];
-  /**
-   * Checks if an object has all the specified keys
-   */
-  static hasAll<T extends object>(obj: T, keys: (keyof T)[]): boolean;
-  /**
-   * For arrays: check if the array contains any of the provided values.
-   *
-   * values can be single value or array of values.
-   *
-   * Example:
-   * Arr.hasAny([1,2,3], [4,2]) -> true
-   */
-  static hasAny<A>(array: A[], values: A[] | A): boolean;
-  /**
-   * Retrieve a value using dot notation
-   * Throws if value is not an integer
-   */
-  static integer(obj: any, path: string, defaultValue?: number): number;
-  /**
-   * Determine if the input is a "list-like" array: an Array with
-   * contiguous numeric indices starting at 0 (no gaps).
-   *
-   * Example:
-   * Arr.isList([1,2,3]) -> true
-   * const a = []; a[2] = 5; Arr.isList(a) -> false
-   */
-  static isList<A>(value: A[]): boolean;
-  /**
-   * Join array elements into a string using the given separator.
-   *
-   * Example:
-   * Arr.join([1,2,3], '-') -> '1-2-3'
-   */
-  static join(array: any[], separator?: string): string;
-  /**
-   * Create an object indexed by a key or callback function.
-   *
-   * Example:
-   * Arr.keyBy([{id:1},{id:2}], 'id') -> { '1': {id:1}, '2': {id:2} }
-   */
-  static keyBy<T>(array: T[], key: keyof T | ((item: T) => string | number)): Record<string, T>;
-  /**
-   * Get the last element of an array, optionally matching a predicate,
-   * or the last element if no predicate is provided, otherwise the defaultValue.
-   *
-   * Predicate can be a true (boolean), a function or a value to match (strict equality).
-   *
-   * When predicate is true (boolean), the last element will be removed and a tuple will be returned [el, rest].
-   *
-   * @param array
-   * @param predicate
-   * @param defaultValue
-   *
-   * @returns
-   */
-  static last<T, P extends ((item: T) => boolean) | true>(array: T[], predicate?: P | T, defaultValue?: T): P extends true ? [T, T[]] : T | undefined;
-  /**
-   * Transform each element in an array using a callback.
-   */
-  static map<T, U>(array: T[], callback: (item: T, index: number) => U): U[];
-  /**
-   * Maps a multi-dimensional array with a spread callback
-   */
-  static mapSpread<T extends any[], U>(array: T[], callback: (...items: T) => U): U[];
-  /**
-   * Map each element to a key-value pair.
-   *
-   * Example:
-   * Arr.mapWithKeys([{id:1, name:'A'}], x => [x.id, x.name])
-   * -> { '1': 'A' }
-   */
-  static mapWithKeys<T, K extends string | number, V>(array: T[], callback: (item: T, index: number) => [K, V]): Record<string, V>;
-  /**
-   * Return only elements at the given indices.
-   *
-   * Example:
-   * Arr.only([10,20,30], [0,2]) -> [10,30]
-   */
-  static only<T>(array: T[], keys: number | number[]): T[];
-  /**
-   * Split an array into two arrays based on a predicate
-   */
-  static partition<T>(array: T[], predicate: (item: T) => boolean): [T[], T[]];
-  /**
-   * Extract a property from each element in an array of objects.
-   *
-   * Example:
-   * Arr.pluck([{name:'A'},{name:'B'}], 'name') -> ['A','B']
-   */
-  static pluck<T, K extends keyof T>(array: T[], key: K): T[K][];
-  /**
-   * Add elements to the beginning of an array and return a new array.
-   *
-   * @param array
-   * @param value
-   * @returns
-   */
-  static prepend<T>(array: T[], ...value: T[]): T[];
-  /**
-   * Remove a value from an array by index and return it.
-   * Returns a tuple: [newArray, removedValue]
-   */
-  static pull<T>(array: T[], key: number): [T[], T | undefined];
-  /**
-   * Append values to an array (mutable)
-   */
-  static push<T>(array: T[], ...values: T[]): T[];
-  /**
-   * Pick one or more random elements from an array.
-   */
-  static random<T>(array: T[], count?: number): T | T[] | undefined;
-  /**
-   * Returns array elements that do NOT satisfy the predicate
-   */
-  static reject<T>(array: T[], predicate: (item: T) => boolean): T[];
-  /**
-   * Pick keys from an array of objects or an object
-   */
-  static select<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
-  /**
-   * Returns the only element that passes a callback, throws if none or multiple
-   */
-  static sole<T>(array: T[], predicate: (item: T) => boolean): T;
-  /**
-   * Checks if at least one element satisfies the predicate
-   */
-  static some<T>(array: T[], predicate: (item: T) => boolean): boolean;
-  /**
-   * Randomly shuffle an array and return a new array.
-   */
-  static shuffle<T>(array: T[]): T[];
-  /**
-   * Sort an array ascending using optional comparator.
-   */
-  static sort<T>(array: T[], comparator?: (a: T, b: T) => number): T[];
-  /**
-   * Sort an array descending using optional comparator.
-   */
-  static sortDesc<T>(array: T[], comparator?: (a: T, b: T) => number): T[];
-  /**
-   * Recursively sort arrays inside an array.
-   */
-  static sortRecursive<T>(array: T[]): T[];
-  /**
-   * Recursively sort arrays inside an array descending.
-   */
-  static sortRecursiveDesc<T>(array: T[]): T[];
-  /**
-   * Retrieve a value using dot notation
-   * Throws if value is not a string
-   */
-  static string(obj: any, path: string, defaultValue?: string): string;
-  /**
-   * Return the first N elements of an array.
-   *
-   * @param array
-   * @param count
-   * @returns
-   */
-  static take<T>(array: T[], count: number): T[];
-  /**
-   * Filter an array based on a predicate function or key-value match.
-   */
-  static where<T>(array: T[], predicate: ((item: T) => boolean) | Partial<T>): T[];
-  /**
-   * Filter an array of objects, keeping elements where the given key is not null/undefined.
-   */
-  static whereNotNull<T>(array: T[], key: keyof T): T[];
-  /**
-   * If the given value is not an array and not null, wrap it in one.
-   *
-   * Non-array values become [value]; null/undefined becomes [].
-   *
-   * @param value
-   * @returns
-   */
-  static wrap<T>(value: T | T[] | null | undefined): T[];
-  /**
-   * Return the first element of an array, undefined if empty.
-   */
-  static head<T>(array: T[]): T | undefined;
-  /**
-   * Splits an array into chunks of a specified size.
-   *
-   * @template T - Type of elements in the array
-   * @param arr - The input array
-   * @param size - Size of each chunk (default: 2)
-   * @returns An array of chunks (arrays)
-   */
-  static chunk: <T>(arr: T[], size?: number) => T[][];
-  /**
-   * Alternates between two arrays, creating a zipped result.
-   *
-   * @param a
-   * @param b
-   * @returns
-   */
-  static alternate<T>(a: T[], b: T[]): T[];
-  /**
-   * Combine arrays and sum their values element by element.
-   *
-   * @param arr
-   * @returns
-   */
-  static combine(...arr: number[][]): number[];
-  /**
-   * Find the value associated with a given key.
-   *
-   * @param key
-   * @param arr
-   * @returns
-   */
-  static find<T>(key: T, arr: T[]): T | null;
-  /**
-   * Check if array is empty.
-   *
-   * @param arr
-   * @returns
-   */
-  static isEmpty<T>(arr: T[]): boolean;
-  /**
-   * Check if array is empty.
-   *
-   * @param arr
-   * @returns
-   */
-  static isNotEmpty<T>(arr: T[]): boolean;
-  /**
-   * Pop the element off the end of array.
-   *
-   * @param arr
-   * @returns
-   */
-  static pop<T>(arr: T[]): T[];
-  /**
-   * Create a new array in reverse order.
-   *
-   * @param arr
-   * @returns
-   */
-  static reverse<T>(arr: T[]): T[];
-  /**
-   * Return the first element of an array that satisfies the predicate,
-   * or the first element if no predicate is provided, otherwise the defaultValue.
-   *
-   * Predicate can be true (boolean), a function or a value to match (strict equality).
-   *
-   * When predicate is true (boolean), the first element will be removed and a tuple will be returned [el, rest].
-   *
-   * @param array
-   * @param predicate
-   * @param defaultValue
-   *
-   * @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;
-  /**
-   * Generates an array of sequential numbers.
-   *
-   * @param size - Number of elements in the range
-   * @param startAt - Starting number (default: 0)
-   * @returns An array of numbers from startAt to startAt + size - 1
-   */
-  static range(size: number, startAt?: number): number[];
-}
-//#endregion
-//#region src/Helpers/Time.d.ts
-declare function format(date: ConfigType, fmt: string): string;
-declare const TimeClass: {
-  new (date?: dayjs.ConfigType): Dayjs;
-} & typeof Dayjs;
-declare class DateTime extends TimeClass {
-  private instance;
-  constructor(config?: ConfigType);
-  /**
-   * Start time of a specific unit.
-   *
-   * @returns
-   */
-  start(unit?: OpUnitType): dayjs.Dayjs;
-  /**
-   * End time of a specific unit.
-   *
-   * @returns
-   */
-  end(unit?: OpUnitType): dayjs.Dayjs;
-  /**
-   * Get the first day of the month of the given date
-   *
-   * @returns
-   */
-  firstDayOfMonth(): DateTime;
-  carbonFormat(template?: string | undefined): string;
-  /**
-   * Get the last day of the month of the given date
-   *
-   * @returns
-   */
-  lastDayOfMonth(): DateTime;
-  /**
-   * Get a random time between the specified hour and minute.
-   *
-   * @param startHour
-   * @param startMinute
-   * @param endHour
-   * @param endMinute
-   * @returns
-   */
-  randomTime(startHour?: number, startMinute?: number, endHour?: number, endMinute?: number): DateTime;
-  /**
-   * Create a date for a given timestamp.
-   *
-   * @param timestamp - Unix timestamp
-   *
-   * @return {Date} object
-   */
-  static fromTimestamp(timestamp: number): Date;
-  /**
-   * Get current time instance.
-   *
-   * @returns Current time
-   */
-  static now(): DateTime;
-  /**
-   * Parse the time
-   *
-   * @param date
-   * @returns
-   */
-  static parse(date: dayjs.ConfigType): DateTime;
-  /**
-   * Get the formatted date according to the string of tokens passed in.
-   *
-   * To escape characters, wrap them in square brackets (e.g. [MM]).
-   *
-   * @param time - current time
-   * @param template - time format
-   */
-  static format(time?: ConfigType, template?: string | undefined): string;
-  /**
-   * Get the difference in days from today.
-   *
-   * @param time
-   * @param startHour
-   * @param startMinute
-   * @param endHour
-   * @param endMinute
-   * @returns
-   */
-  static randomTime(time?: ConfigType, startHour?: number, startMinute?: number, endHour?: number, endMinute?: number): DateTime;
-  /**
-   * Get the first day of the month of the given date
-   *
-   * @param time
-   *
-   * @returns
-   */
-  static firstDayOfMonth(time: ConfigType): DateTime;
-  /**
-   * Get the last day of the month of the given date
-   *
-   * @param time
-   *
-   * @returns
-   */
-  static lastDayOfMonth(time: ConfigType): DateTime;
-}
-//#endregion
-//#region src/Helpers/Str.d.ts
-declare enum Mode {
-  MB_CASE_UPPER = 0,
-  MB_CASE_LOWER = 1,
-  MB_CASE_TITLE = 2,
-  MB_CASE_FOLD = 3,
-  MB_CASE_UPPER_SIMPLE = 4,
-  MB_CASE_LOWER_SIMPLE = 5,
-  MB_CASE_TITLE_SIMPLE = 6,
-  MB_CASE_FOLD_SIMPLE = 7,
-}
-declare class Str {
-  /**
-   * The callback that should be used to generate UUIDs.
-   *
-   * @type { Function | null }
-   */
-  protected static uuidFactory: Function | null;
-  /**
-   * The callback that should be used to generate ULIDs.
-   *
-   * @type { Function | null }
-   */
-  protected static ulidFactory: Function | null;
-  /**
-   * The callback that should be used to generate random strings.
-   *
-   * @type { Function | null }
-   */
-  protected static randomStringFactory: Function | null;
-  /**
-   * Get a new Stringable object from the given string.
-   *
-   * @param { string } string
-   */
-  static of(string: string): Stringable;
-  /**
-   * Return the remainder of a string after the first occurrence of a given value.
-   *
-   * @param { string } subject
-   * @param { string } search
-   *
-   * @return { string }
-   */
-  static after(subject: string, search: string): string;
-  /**
-   * Return the remainder of a string after the last occurrence of a given value.
-   *
-   * @param { string } subject
-   * @param { string } search
-   *
-   * @return { string }
-   */
-  static afterLast(subject: string, search: string): string;
-  /**
-   * Transliterate a UTF-8 value to ASCII.
-   *
-   * @param { string } value
-   *
-   * @return { string }
-   */
-  static ascii(value: string): string;
-  /**
-   * Get the portion of a string before the first occurrence of a given value.
-   *
-   * @param { string } subject
-   * @param { string } search
-   *
-   * @return { string }
-   */
-  static before(subject: string, search: string): string;
-  /**
-   * Get the portion of a string before the last occurrence of a given value.
-   *
-   * @param { string } subject
-   * @param { string } search
-   *
-   * @return { string }
-   */
-  static beforeLast(subject: string, search: string): string;
-  /**
-   * Get the portion of a string between two given values.
-   *
-   * @param { string } subject
-   * @param { string } from
-   * @param { string } to
-   *
-   * @return { string }
-   */
-  static between(subject: string, from: string, to: string): string;
-  /**
-   * Get the smallest possible portion of a string between two given values.
-   *
-   * @param { string } subject
-   * @param { string } from
-   * @param { string } to
-   *
-   * @return { string }
-   */
-  static betweenFirst(subject: string, from: string, to: string): string;
-  /**
-   * Convert a value to camel case.
-   *
-   * @param { string } value
-   *
-   * @return { string }
-   */
-  static camel(value: string): string;
-  /**
-   * Get the character at the specified index.
-   *
-   * @param { string } subject
-   * @param { number } index
-   *
-   * @return { string | false }
-   */
-  static charAt(subject: string, index: number): string | false;
-  /**
-   * Remove the given string(s) if it exists at the start of the haystack.
-   *
-   * @param { string } subject
-   * @param { string | string[] } needle
-   *
-   * @return string
-   */
-  static chopStart(subject: string, needle: string | string[]): string;
-  /**
-   * Remove the given string(s) if it exists at the end of the haystack.
-   *
-   * @param { string } subject
-   * @param { string | string[] } needle
-   *
-   * @return string
-   *
-   */
-  static chopEnd(subject: string, needle: string | string[]): string;
-  /**
-   * Determine if a given string contains a given substring.
-   *
-   * @param { string } haystack
-   * @param { string | string[] } needles
-   * @param { boolean } ignoreCase
-   *
-   * @return { boolean }
-   */
-  static contains(haystack: string, needles: string | string[], ignoreCase?: boolean): boolean;
-  /**
-   * Determine if a given string contains all array values.
-   *
-   * @param { string } haystack
-   * @param { string[] } needles
-   * @param { boolean } ignoreCase
-   *
-   * @return { boolean }
-   */
-  static containsAll(haystack: string, needles: string[], ignoreCase?: boolean): boolean;
-  /**
-   * Determine if a given string doesn't contain a given substring.
-   *
-   * @param { string } haystack
-   * @param { string | string[] } needles
-   * @param { boolean } ignoreCase
-   *
-   * @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.
-   *
-   * @param { string } string
-   * @param { string | string[] } characters
-   *
-   * @return { string }
-   */
-  static deduplicate(string: string, characters?: string | string[]): string;
-  /**
-   * Determine if a given string ends with a given substring.
-   *
-   * @param { string } haystack
-   * @param { string | string[] } needles
-   *
-   * @return { boolean }
-   */
-  static endsWith(haystack: string, needles: string | string[]): boolean;
-  /**
-   * Determine if a given string doesn't end with a given substring.
-   *
-   * @param { string } haystack
-   * @param { string | string[] } needles
-   *
-   * @return { boolean }
-   */
-  static doesntEndWith(haystack: string, needles: string | string[]): boolean;
-  /**
-   * Returns all the characters except the last.
-   *
-   * @param string
-   * @returns
-   */
-  static chop(string: string): string;
-  /**
-   * Escape string for JSON encoding (returns string without quotes).
-   *
-   * @param string
-   * @returns
-   */
-  static esc(string: string): string;
-  /**
-   * Extracts an excerpt from text that matches the first instance of a phrase.
-   *
-   * @param { string } text
-   * @param { string } phrase
-   * @param { ExcerptOptions } options
-   *
-   * @return { string | null }
-   */
-  static excerpt(text: string, phrase?: string, options?: ExcerptOptions): string | null;
-  /**
-   * Explode the string into an array.
-   *
-   * @param { string } string
-   * @param { string } delimiter
-   * @param { number } limit
-   *
-   * @return { string[] }
-   */
-  static explode(string: string, delimiter: string, limit?: number): string[];
-  /**
-   * Cap a string with a single instance of a given value.
-   *
-   * @param { string } value
-   * @param { string } cap
-   *
-   * @return { string }
-   */
-  static finish(value: string, cap: string): string;
-  /**
-   * Wrap the string with the given strings.
-   *
-   * @param { string } value
-   * @param { string } before
-   * @param { string | null } after
-   *
-   * @return string
-   */
-  static wrap(value: string, before: string, after?: string | null): string;
-  /**
-   * Unwrap the string with the given strings.
-   *
-   * @param { string } value
-   * @param { string } before
-   * @param { string | null } after
-   *
-   * @return { string }
-   */
-  static unwrap(value: string, before: string, after?: string | null): string;
-  /**
-   * Determine if a given string matches a given pattern.
-   *
-   * @param { string | string[] } pattern
-   * @param { string } value
-   * @param { boolean } ignoreCase
-   *
-   * @return { boolean }
-   */
-  static is(pattern: string | string[], value: string, ignoreCase?: boolean): boolean;
-  /**
-   * Determine if a given string is 7-bit ASCII.
-   *
-   * @param { string } value
-   *
-   * @return { boolean }
-   */
-  static isAscii(value: string): boolean;
-  /**
-   * Determine if a given string is valid JSON.
-   *
-   * @param { string } value
-   *
-   * @return { boolean }
-   */
-  static isJson(value: string): boolean;
-  /**
-   * Determine if a given value is a valid URL.
-   *
-   * @param { string } value
-   * @param { string[] } protocols
-   *
-   * @return { boolean }
-   */
-  static isUrl(value: string, protocols?: string[]): boolean;
-  /**
-   * Determine if a given string is a valid UUID.
-   *
-   * @param { string } value
-   *
-   * @return { boolean }
-   */
-  static isUuid(value: string): boolean;
-  /**
-   * Determine if a given string is a valid ULID.
-   *
-   * @param { string } value
-   *
-   * @return { boolean }
-   */
-  static isUlid(value: string): boolean;
-  /**
-   * Convert a string to kebab case.
-   *
-   * @param { string } value
-   *
-   * @return { string }
-   */
-  static kebab(value: string): string;
-  /**
-   * Return the length of the given string.
-   *
-   * @param { string } value
-   *
-   * @return { number }
-   */
-  static length(value: string): number;
-  /**
-   * Limit the number of characters in a string.
-   *
-   * @param { string } value
-   * @param { number } limit
-   * @param { string } end
-   * @param { boolean } preserveWords
-   *
-   * @return { string }
-   */
-  static limit(value: string, limit?: number, end?: string, preserveWords?: boolean): string;
-  /**
-   * Limit the number of characters in a string.
-   *
-   * @param { string } value
-   * @param { number } limit
-   * @param { string } end
-   * @param { boolean } preserveWords
-   *
-   * @alias limit
-   * @return { string }
-   */
-  static truncate(value: string, limit?: number, end?: string, preserveWords?: boolean): string;
-  /**
-   * Convert the given string to lower-case.
-   *
-   * @param { string } value
-   *
-   * @return { string }
-   */
-  static lower(value: string): string;
-  /**
-   * Get substring by start/stop indexes.
-   *
-   * @param string
-   * @param start
-   * @param stop
-   * @returns
-   */
-  static sub(string: string, start: number, stop: number): string;
-  /**
-   * Limit the number of words in a string.
-   *
-   * @param { string } value
-   * @param { number } words
-   * @param { string } end
-   *
-   * @return { string }
-   */
-  static words(value: string, words?: number, end?: string): string;
-  /**
-   * Masks a portion of a string with a repeated character.
-   *
-   * @param { string } string
-   * @param { string } character
-   * @param { number } index
-   * @param { number | null } length
-   *
-   * @return { string }
-   */
-  static mask(string: string, character: string, index: number, length?: number | null): string;
-  /**
-   * Get the string matching the given pattern.
-   *
-   * @param { string } pattern
-   * @param { string } subject
-   *
-   * @return { string }
-   */
-  static match(pattern: string, subject: string): string;
-  /**
-   * Determine if a given string matches a given pattern.
-   *
-   * @param { string | string[] } pattern
-   * @param { string } value
-   *
-   * @return { boolean }
-   */
-  static isMatch(pattern: string | string[], value: string): boolean;
-  /**
-   * Get the string matching the given pattern.
-   *
-   * @param { string } pattern
-   * @param { string } subject
-   *
-   * @return { string[] }
-   */
-  static matchAll(pattern: string, subject: string): string[];
-  /**
-   * Remove all non-numeric characters from a string.
-   *
-   * @param { string } value
-   *
-   * @return { string }
-   */
-  static numbers(value: string): string;
-  /**
-   * Pad both sides of a string with another.
-   *
-   * @param { string } value
-   * @param { number } length
-   * @param { string } pad
-   *
-   * @return { string }
-   */
-  static padBoth(value: string, length: number, pad?: string): string;
-  /**
-   * Pad the left side of a string with another.
-   *
-   * @param { string } value
-   * @param { number } length
-   * @param { string } pad
-   *
-   * @return { string }
-   */
-  static padLeft(value: string, length: number, pad?: string): string;
-  /**
-   * Pad the right side of a string with another.
-   *
-   * @param { string } value
-   * @param { number } length
-   * @param { string } pad
-   *
-   * @return { string }
-   */
-  static padRight(value: string, length: number, pad?: string): string;
-  /**
-   * Get the plural form of an English word.
-   *
-   * @param { string } value
-   * @param { number | array } count
-   *
-   * @return { string }
-   */
-  static plural(value: string, count?: number | number[]): string;
-  /**
-   * Get the plural form of an English word.
-   *
-   * @param { string } value
-   * @param { number | array } count
-   *
-   * @alias plural
-   *
-   * @return { string }
-   */
-  static pluralize: (value: string, count?: number | number[]) => string;
-  /**
-   * Pluralize the last word of an English, studly caps case string.
-   *
-   * @param { string } value
-   * @param { number | array } count
-   *
-   * @return { string }
-   */
-  static pluralStudly(value: string, count?: number | number[]): string;
-  /**
-   * Pluralize the last word of an English, Pascal case string.
-   *
-   * @param { string } value
-   * @param { number | array } count
-   *
-   * @return { string }
-   */
-  static pluralPascal(value: string, count?: number | number[]): string;
-  /**
-   * Generate a random, secure password.
-   *
-   * @param { number } length
-   * @param { boolean } letters
-   * @param { boolean } numbers
-   * @param { boolean } symbols
-   * @param { boolean } spaces
-   *
-   * @return { string }
-   */
-  static password(length?: number, letters?: boolean, numbers?: boolean, symbols?: boolean, spaces?: boolean): string;
-  /**
-   * Find the position of the first occurrence of a given substring in a string.
-   *
-   * @param { string } haystack
-   * @param { string } needle
-   * @param { number } offset
-   *
-   * @return { number | false }
-   */
-  static position(haystack: string, needle: string, offset?: number): number | false;
-  /**
-   * Generate a more truly "random" alpha-numeric string.
-   *
-   * @param { number } length
-   *
-   * @return { string }
-   */
-  static random(length?: number): string;
-  /**
-   * Set the callable that will be used to generate random strings.
-   *
-   * @param { ((length: number) => string) | null } factory
-   *
-   * @return { void }
-   */
-  static createRandomStringsUsing(factory?: ((length: number) => string) | null): void;
-  /**
-   * Set the sequence that will be used to generate random strings.
-   *
-   * @param { (string | undefined)[] } sequence
-   * @param { Function | null } whenMissing
-   *
-   * @return { void }
-   */
-  static createRandomStringsUsingSequence(sequence: (string | undefined)[], whenMissing?: Function | null): void;
-  /**
-   * Indicate that random strings should be created normally and not using a custom factory.
-   *
-   * @return { void }
-   */
-  static createRandomStringsNormally(): void;
-  /**
-   * Repeat the given string.
-   *
-   * @param { string } string
-   * @param { number } times
-   *
-   * @return { string }
-   */
-  static repeat(string: string, times?: number): string;
-  /**
-   * Replace a given value in the string sequentially with an array.
-   *
-   * @param { string[] } replace
-   * @param { string } subject
-   * @param { string } search
-   *
-   * @return { string }
-   */
-  static replaceArray(search: string, replace: string[], subject: string): string;
-  /**
-   * Convert the given value to a string or return the given fallback on failure.
-   *
-   * @param { * } value
-   * @param { string } fallback
-   *
-   * @return { string }
-   */
-  static toStringOr(value: any, fallback: string): string;
-  /**
-   * Replace the given value in the given string.
-   *
-   * @param { string | string[] } search
-   * @param { string } replace
-   * @param { string } subject
-   * @param { boolean } caseSensitive
-   *
-   * @return { string }
-   */
-  static replace(search: string | string[], replace: string, subject: string, caseSensitive?: boolean): string;
-  /**
-   * Replace the first occurrence of a given value in the string.
-   *
-   * @param { string } search
-   * @param { string } replace
-   * @param { string } subject
-   *
-   * @return { string }
-   */
-  static replaceFirst(search: string, replace: string, subject: string): string;
-  /**
-   * Replace the first occurrence of the given value if it appears at the start of the string.
-   *
-   * @param { string } search
-   * @param { string } replace
-   * @param { string } subject
-   *
-   * @return { string }
-   */
-  static replaceStart(search: string, replace: string, subject: string): string;
-  /**
-   * Replace the last occurrence of a given value in the string.
-   *
-   * @param { string } search
-   * @param { string } replace
-   * @param { string } subject
-   *
-   * @return { string }
-   */
-  static replaceLast(search: string, replace: string, subject: string): string;
-  /**
-   * Replace the last occurrence of a given value if it appears at the end of the string.
-   *
-   * @param { string } search
-   * @param { string } replace
-   * @param { string } subject
-   *
-   * @return { string }
-   */
-  static replaceEnd(search: string, replace: string, subject: string): string;
-  /**
-   * Replace the patterns matching the given regular expression.
-   *
-   * @param { string } pattern
-   * @param { string | function } replace
-   * @param { string } subject
-   *
-   * @return { string }
-   */
-  static replaceMatches(pattern: string, replace: string | Function, subject: string): string;
-  /**
-   * Remove any occurrence of the given string in the subject.
-   *
-   * @param { string } search
-   * @param { string } subject
-   * @param { boolean } caseSensitive
-   *
-   * @return { string }
-   */
-  static remove(search: string, subject: string, caseSensitive?: boolean): string;
-  /**
-   * Reverse the given string.
-   *
-   * @param { string } value
-   *
-   * @return { string }
-   */
-  static reverse(value: string): string;
-  /**
-   * Begin a string with a single instance of a given value.
-   *
-   * @param { string } value
-   * @param { string } prefix
-   *
-   * @return { string }
-   */
-  static start(value: string, prefix: string): string;
-  /**
-   * Substitute placeholders { key } using object with dot notation.
-   *
-   * @param str
-   * @param data
-   * @param def
-   * @returns
-   */
-  static substitute(str: string, data?: Record<string, unknown>, def?: string): string | undefined;
-  /**
-   * Convert the given string to upper-case.
-   *
-   * @param { string } value
-   *
-   * @return { string }
-   */
-  static upper(value: string): string;
-  /**
-   * Convert the given string to title case.
-   *
-   * @param { string } value
-   *
-   * @return { string }
-   */
-  static title(value: string): string;
-  /**
-   * Convert the given string to title case for each word.
-   *
-   * @param { string } value
-   *
-   * @return { string }
-   */
-  static headline(value: string): string;
-  /**
-   * Convert the given string to APA-style title case.
-   *
-   * @see https://apastyle.apa.org/style-grammar-guidelines/capitalization/title-case
-   *
-   * @param { string } value
-   *
-   * @return { string }
-   */
-  static apa(value: string): string;
-  /**
-   * Get the singular form of an English word.
-   *
-   * @param { string } value
-   *
-   * @return { string }
-   */
-  static singular(value: string): string;
-  /**
-   * Get the singular form of an English word.
-   *
-   * @param { string } value
-   *
-   * @alias singular
-   *
-   * @return { string }
-   */
-  static singularize(value: string): string;
-  /**
-   * Generate a URL friendly "slug" from a given string.
-   *
-   * @param { string } title
-   * @param { string } separator
-   * @param { object } dictionary
-   *
-   * @return { string }
-   */
-  static slug(title: string, separator?: string, dictionary?: {
-    [key: string]: string;
-  }): string;
-  /**
-   * Generate a URL friendly "slug" from a given string.
-   *
-   * @param { string } separator
-   * @param { string } title
-   * @param { object } dictionary
-   *
-   * @alias singular
-   *
-   * @return { string }
-   */
-  static slugify(title: string, separator?: string, dictionary?: {
-    [key: string]: string;
-  }): string;
-  /**
-   * Convert a string to snake case.
-   *
-   * @param { string } value
-   * @param { string } delimiter
-   *
-   * @return { string }
-   */
-  static snake(value: string, delimiter?: string): string;
-  /**
-   * Uppercase the first character of each word in a string
-   *
-   * @param { string } string The input string.
-   * @param { string } separators The optional separators contains the word separator characters.
-  
-   * @return { string } String the modified string.
-   */
-  static capitalize(string: string, separators?: string): string;
-  /**
-   * Uppercase the first character of each word in a string
-   *
-   * @param { string } string The input string.
-   * @param { string } separators The optional separators contains the word separator characters.
-  
-   * @return { string } String the modified string.
-   */
-  static ucwords(string: string, separators?: string): string;
-  /**
-   * Remove all whitespace from both ends of a string.
-   *
-   * @param { string } value
-   * @param { string | null } characters
-   *
-   * @return { string }
-   */
-  static trim(value: string, characters?: string | null): string;
-  /**
-   * Remove all whitespace from the beginning of a string.
-   *
-   * @param { string } value
-   * @param { string | null } characters
-   *
-   * @return { string }
-   */
-  static ltrim(value: string, characters?: string | null): string;
-  /**
-   * Remove all whitespace from the end of a string.
-   *
-   * @param { string } value
-   * @param { string | null } characters
-   *
-   * @return { string }
-   */
-  static rtrim(value: string, characters?: string | null): string;
-  /**
-   * Remove all "extra" blank space from the given string.
-   *
-   * @param { string } value
-   *
-   * @return { string }
-   */
-  static squish(value: string): string;
-  /**
-   * Determine if a given string starts with a given substring.
-   *
-   * @param { string } haystack
-   * @param { string | string[] } needles
-   *
-   * @return { boolean }
-   */
-  static startsWith(haystack: string, needles: string | string[]): boolean;
-  /**
-   * Determine if a given string doesn't start with a given substring.
-   *
-   * @param { string } haystack
-   * @param { string | string[] } needles
-   *
-   * @return { boolean }
-   */
-  static doesntStartWith(haystack: string, needles: string | string[]): boolean;
-  /**
-   * Convert a value to studly caps case.
-   *
-   * @param { string } value
-   *
-   * @return { string }
-   */
-  static studly(value: string): string;
-  /**
-   * Convert a value to Pascal case.
-   *
-   * @param { string } value
-   *
-   * @return { string }
-   */
-  static pascal(value: string): string;
-  /**
-   * Returns the portion of the string specified by the start and length parameters.
-   *
-   * @param { string } string
-   * @param { number } start
-   * @param { number | null } length
-   *
-   * @return { string }
-   */
-  static substr(string: string, start: number, length?: number | null): string;
-  /**
-   * Returns the number of substring occurrences.
-   *
-   * @param { string } haystack
-   * @param { string } needle
-   * @param { number } offset
-   * @param { number | null } length
-   *
-   * @return { number }
-   */
-  static substrCount(haystack: string, needle: string, offset?: number, length?: number | null): number;
-  /**
-   * Replace text within a portion of a string.
-   *
-   * @param { string } string
-   * @param { string } replace
-   * @param { number } offset
-   * @param { number | null } length
-   *
-   * @return { string }
-   */
-  static substrReplace(string: string, replace: string, offset?: number, length?: number | null): string;
-  /**
-   * Swap multiple keywords in a string with other keywords.
-   *
-   * @param { object } map
-   * @param { string } subject
-   *
-   * @return { string }
-   */
-  static swap(map: Record<string, string>, subject: string): string;
-  /**
-   * Take the first or last {limit} characters of a string.
-   *
-   * @param { string } string
-   * @param { number } limit
-   *
-   * @return { string }
-   */
-  static take(string: string, limit: number): string;
-  /**
-   * Convert the given string to Base64 encoding.
-   *
-   * @param { string } string
-   *
-   * @return { string }
-   */
-  static toBase64(string: string): string;
-  /**
-   * Decode the given Base64 encoded string.
-   *
-   * @param { string } string
-   *
-   * @return { string }
-   */
-  static fromBase64(string: string): string;
-  /**
-   * Checks if a string is numeric
-   *
-   * @param string
-   * @returns
-   */
-  static isNumber(string: string): boolean;
-  /**
-   * Checks if a string is an integer
-   *
-   * @param string
-   * @returns
-   */
-  static isInteger(string: string): boolean;
-  /**
-   * ROT-N cipher.
-   *
-   * @param string
-   * @param n
-   * @returns
-   */
-  static rot(string: string, n?: number): string;
-  /**
-   * Replace trailing punctuation with new format.
-   *
-   * @param string
-   * @param newFormat
-   * @returns
-   */
-  static replacePunctuation(string: string, newFormat: string): string;
-  /**
-   * Array/object driven text replacement.
-   *
-   * @param string
-   * @param replacements
-   * @returns
-   */
-  static translate(string: string, replacements: Record<string, string> | Array<[string, string]>): string;
-  /**
-   * Strip slashes recursively.
-   *
-   * @param string
-   * @returns
-   */
-  static ss(string: string): string;
-  /**
-   * First and last N lines.
-   *
-   * @param string
-   * @param amount
-   * @returns
-   */
-  static firstLines(string: string, amount?: number): string;
-  /**
-   * Last and first N lines.
-   *
-   * @param string
-   * @param amount
-   * @returns
-   */
-  static lastLines(string: string, amount?: number): string;
-  /**
-   * Make a string's first character lowercase.
-   *
-   * @param { string } string
-   *
-   * @return { string }
-   */
-  static lcfirst(string: string): string;
-  /**
-   * Make a string's first character uppercase.
-   *
-   * @param { string } string
-   *
-   * @return { string }
-   */
-  static ucfirst(string: string): string;
-  /**
-   * Split a string into pieces by uppercase characters.
-   *
-   * @param { string } string
-   *
-   * @return { string[] }
-   */
-  static ucsplit(string: string): string[];
-  /**
-   * Get the number of words a string contains.
-   *
-   * @param { string } string
-   *
-   * @return { number }
-   */
-  static wordCount(string: string): number;
-  /**
-   * Wrap a string to a given number of characters.
-   *
-   * @param { string } string
-   * @param { number } characters
-   * @param { string } breakStr
-   * @param { boolean } cutLongWords
-   *
-   * @returns { string }
-   */
-  static wordWrap(string: string, characters?: number, breakStr?: string, cutLongWords?: boolean): string;
-  /**
-   * Generate a UUID (version 4).
-   *
-   * @return { string }
-   */
-  static uuid(): string;
-  /**
-   * Generate a UUID (version 7).
-   *
-   * @return { string }
-   */
-  static uuid7(time?: Date | null): string;
-  /**
-   * Generate a time-ordered UUID (version 4).
-   *
-   * @return { string }
-   */
-  static orderedUuid(): string;
-  /**
-   * Set the callable that will be used to generate UUIDs.
-   *
-   * @param { Function | null } factory
-   *
-   * @return { void }
-   */
-  static createUuidsUsing(factory?: Function | null): void;
-  /**
-   * Set the sequence that will be used to generate random strings.
-   *
-   * @param { (string | undefined)[] } sequence
-   * @param { Function | null } whenMissing
-   *
-   * @return { void }
-   */
-  static createUuidsUsingSequence(sequence: (string | undefined)[], whenMissing?: Function | null): void;
-  /**
-   * Always return the same UUID when generating new UUIDs.
-   *
-   * @param { Function | null } callback
-   *
-   * @return { string }
-   */
-  static freezeUuids(callback?: Function | null): string;
-  /**
-   * Indicate that UUIDs should be created normally and not using a custom factory.
-   *
-   * @return { void }
-   */
-  static createUuidsNormally(): void;
-  /**
-   * Generate a ULID.
-   *
-   * @return { string }
-   */
-  static ulid(): string;
-  /**
-   * Set the callable that will be used to generate ULIDs.
-   *
-   * @param { Function | null } factory
-   *
-   * @return { void }
-   */
-  static createUlidsUsing(factory?: Function | null): void;
-  /**
-   * Set the sequence that will be used to generate ULIDs.
-   *
-   * @param { (string | undefined)[] } sequence
-   * @param { Function | null } whenMissing
-   *
-   * @return { void }
-   */
-  static createUlidsUsingSequence(sequence: (string | undefined)[], whenMissing?: Function | null): void;
-  /**
-   * Always return the same UUID when generating new UUIDs.
-   *
-   * @param { Function | null } callback
-   *
-   * @return { string }
-   */
-  static freezeUlids(callback?: Function | null): string;
-  /**
-   * Indicate that ULIDs should be created normally and not using a custom factory.
-   *
-   * @return { void }
-   */
-  static createUlidsNormally(): void;
-}
-declare class Stringable {
-  #private;
-  /**
-   * Create a new instance of the class.
-   *
-   * @param { string } value
-   */
-  constructor(value?: string);
-  /**
-   * Return the remainder of a string after the first occurrence of a given value.
-   *
-   * @param { string } search
-   *
-   * @return { Stringable }
-   */
-  after(search: string): Stringable;
-  /**
-   * Return the remainder of a string after the last occurrence of a given value.
-   *
-   * @param { string } search
-   *
-   * @return { Stringable }
-   */
-  afterLast(search: string): Stringable;
-  /**
-   * Append the given values to the string.
-   *
-   * @param { string | string[] } values
-   *
-   * @return { Stringable }
-   */
-  append(...values: string[]): Stringable;
-  /**
-   * Append a new line to the string.
-   *
-   * @param { number } count
-   *
-   * @return { Stringable }
-   */
-  newLine(count?: number): Stringable;
-  /**
-   * Transliterate a UTF-8 value to ASCII.
-   *
-   * @return { Stringable }
-   */
-  ascii(): Stringable;
-  /**
-   * Get the trailing name component of the path.
-   *
-   * @param { string } suffix
-   *
-   * @return { Stringable }
-   */
-  basename(suffix?: string): Stringable;
-  /**
-   * Get the character at the specified index.
-   *
-   * @param { number } index
-   *
-   * @return { string | false }
-   */
-  charAt(index: number): string | false;
-  /**
-   * Remove the given string if it exists at the start of the current string.
-   *
-   * @param { string | string[] }  needle
-   *
-   * @return { Stringable }
-   */
-  chopStart(needle: string | string[]): Stringable;
-  /**
-   * Remove the given string if it exists at the end of the current string.
-   *
-   * @param { string | string[] }  needle
-   *
-   * @return { Stringable }
-   */
-  chopEnd(needle: string | string[]): Stringable;
-  /**
-   * Get the basename of the class path.
-   *
-   * @return { Stringable }
-   */
-  classBasename(): Stringable;
-  /**
-   * Get the portion of a string before the first occurrence of a given value.
-   *
-   * @param { string } search
-   *
-   * @return { Stringable }
-   */
-  before(search: string): Stringable;
-  /**
-   * Get the portion of a string before the last occurrence of a given value.
-   *
-   * @param { string } search
-   *
-   * @return { Stringable }
-   */
-  beforeLast(search: string): Stringable;
-  /**
-   * Get the portion of a string between two given values.
-   *
-   * @param { string } from
-   * @param { string } to
-   *
-   * @return { Stringable }
-   */
-  between(from: string, to: string): Stringable;
-  /**
-   * Get the smallest possible portion of a string between two given values.
-   *
-   * @param { string } from
-   * @param { string } to
-   *
-   * @return { Stringable }
-   */
-  betweenFirst(from: string, to: string): Stringable;
-  /**
-   * Convert a value to camel case.
-   *
-   * @return { Stringable }
-   */
-  camel(): Stringable;
-  /**
-   * Determine if a given string contains a given substring.
-   *
-   * @param  { string | string[] } needles
-   * @param  { boolean } ignoreCase
-   *
-   * @return { boolean }
-   */
-  contains(needles: string | string[], ignoreCase?: boolean): boolean;
-  /**
-   * Determine if a given string contains all array values.
-   *
-   * @param { string[] } needles
-   * @param { boolean } ignoreCase
-   *
-   * @return { boolean }
-   */
-  containsAll(needles: string[], ignoreCase?: boolean): boolean;
-  /**
-   * Determine if a given string doesn't contain a given substring.
-   *
-   * @param  { string | string[] } needles
-   * @param  { boolean } ignoreCase
-   *
-   * @return { boolean }
-   */
-  doesntContain(needles: string | string[], ignoreCase?: boolean): boolean;
-  /**
-   * Convert the case of a string.
-   *
-   * @param { Mode | number } mode
-   *
-   * @return { Stringable }
-   */
-  convertCase(mode?: Mode | number): Stringable;
-  /**
-   * Replace consecutive instances of a given character with a single character in the given string.
-   *
-   * @param { string | string[] } characters
-   *
-   * @return { string }
-   */
-  deduplicate(characters?: string | string[]): Stringable;
-  /**
-   * Get the parent directory's path.
-   *
-   * @param { number } levels
-   *
-   * @return { Stringable }
-   */
-  dirname(levels?: number): Stringable;
-  /**
-   * Determine if a given string ends with a given substring.
-   *
-   * @param { string | string[] } needles
-   *
-   * @return { boolean }
-   */
-  endsWith(needles: string | string[]): boolean;
-  /**
-   * Determine if a given string doesn't end with a given substring.
-   *
-   * @param { string | string[] } needles
-   *
-   * @return { boolean }
-   */
-  doesntEndWith(needles: string | string[]): boolean;
-  /**
-   * Returns all the characters except the last.
-   *
-   * @returns
-   */
-  chop(): Stringable;
-  /**
-   * Escape string for JSON encoding (returns string without quotes).
-   *
-   * @param string
-   * @returns
-   */
-  esc(): Stringable;
-  /**
-   * Determine if the string is an exact match with the given value.
-   *
-   * @param { Stringable | string } value
-   *
-   * @return { boolean }
-   */
-  exactly(value: Stringable | string): boolean;
-  /**
-   * Extracts an excerpt from text that matches the first instance of a phrase.
-   *
-   * @param { string } phrase
-   * @param { ExcerptOptions } options
-   *
-   * @return { string | null }
-   */
-  excerpt(phrase?: string, options?: ExcerptOptions): string | null;
-  /**
-   * Explode the string into an array.
-   *
-   * @param { string } delimiter
-   * @param { number } limit
-   *
-   * @return { string[] }
-   */
-  explode(delimiter: string, limit?: number): string[];
-  /**
-   * Split a string using a regular expression or by length.
-   *
-   * @param { string } pattern
-   * @param { number } limit
-   *
-   * @return { string[] }
-   */
-  split(pattern: string, limit?: number): string[];
-  /**
-   * Cap a string with a single instance of a given value.
-   *
-   * @param { string } cap
-   *
-   * @return { Stringable }
-   */
-  finish(cap: string): Stringable;
-  /**
-   * Determine if a given string matches a given pattern.
-   *
-   * @param { string | string[] } pattern
-   * @param { boolean } ignoreCase
-   *
-   * @return { boolean }
-   */
-  is(pattern: string | string[], ignoreCase?: boolean): boolean;
-  /**
-   * Determine if a given string is 7-bit ASCII.
-   *
-   * @return { boolean }
-   */
-  isAscii(): boolean;
-  /**
-   * Determine if a given string is valid JSON.
-   *
-   * @return { boolean }
-   */
-  isJson(): boolean;
-  /**
-   * Determine if a given value is a valid URL.
-   *
-   * @return { boolean }
-   */
-  isUrl(): boolean;
-  /**
-   * Determine if a given string is a valid UUID.
-   *
-   * @return { boolean }
-   */
-  isUuid(): boolean;
-  /**
-   * Determine if a given string is a valid ULID.
-   *
-   * @return { boolean }
-   */
-  isUlid(): boolean;
-  /**
-   * Determine if the given string is empty.
-   *
-   * @return { boolean }
-   */
-  isEmpty(): boolean;
-  /**
-   * Determine if the given string is not empty.
-   *
-   * @return { boolean }
-   */
-  isNotEmpty(): boolean;
-  /**
-   * Convert a string to kebab case.
-   *
-   * @return { Stringable }
-   */
-  kebab(): Stringable;
-  /**
-   * Return the length of the given string.
-   *
-   * @return { number }
-   */
-  length(): number;
-  /**
-   * Limit the number of characters in a string.
-   *
-   * @param { number } limit
-   * @param { string } end
-   * @param { boolean } preserveWords
-   *
-   * @return { Stringable }
-   */
-  limit(limit?: number, end?: string, preserveWords?: boolean): Stringable;
-  /**
-   * Get substring by start/stop indexes.
-   *
-   * @param start
-   * @param stop
-   * @returns
-   */
-  sub(start: number, stop: number): Stringable;
-  /**
-   * Limit the number of characters in a string.
-   *
-   * @param { number } limit
-   * @param { string } end
-   * @param { boolean } preserveWords
-   *
-   * @alias limit
-   *
-   * @return { Stringable }
-   */
-  truncate(limit?: number, end?: string, preserveWords?: boolean): Stringable;
-  /**
-   * Convert the given string to lower-case.
-   *
-   * @return { Stringable }
-   */
-  lower(): Stringable;
-  /**
-   * Masks a portion of a string with a repeated character.
-   *
-   * @param { string } character
-   * @param { number } index
-   * @param { number | null }length
-   *
-   * @return { Stringable }
-   */
-  mask(character: string, index: number, length?: number | null): Stringable;
-  /**
-   * Get the string matching the given pattern.
-   *
-   * @param { string } pattern
-   *
-   * @return { Stringable }
-   */
-  match(pattern: string): Stringable;
-  /**
-   * Determine if a given string matches a given pattern.
-   *
-   * @param { string | string[] } pattern
-   *
-   * @return { boolean }
-   */
-  isMatch(...pattern: string[]): boolean;
-  /**
-   * Get the string matching the given pattern.
-   *
-   * @param { string } pattern
-   *
-   * @return { string[] }
-   */
-  matchAll(pattern: string): string[];
-  /**
-   * Determine if the string matches the given pattern.
-   *
-   * @param { string } pattern
-   *
-   * @return { boolean }
-   */
-  test(pattern: string): boolean;
-  /**
-   * Remove all non-numeric characters from a string.
-   *
-   * @return { Stringable }
-   */
-  numbers(): Stringable;
-  /**
-   * Pad both sides of the string with another.
-   *
-   * @param { number } length
-   * @param { string } pad
-   *
-   * @return { Stringable }
-   */
-  padBoth(length: number, pad?: string): Stringable;
-  /**
-   * Pad the left side of the string with another.
-   *
-   * @param { number } length
-   * @param { string } pad
-   *
-   * @return { Stringable }
-   */
-  padLeft(length: number, pad?: string): Stringable;
-  /**
-   * Pad the right side of the string with another.
-   *
-   * @param { number } length
-   * @param { string } pad
-   *
-   * @return { Stringable }
-   */
-  padRight(length: number, pad?: string): Stringable;
-  /**
-   * Call the given callback and return a new string.
-   *
-   * @param { keyof string | ((instance: this) => any) } callback
-   *
-   * @return { Stringable }
-   */
-  pipe(callback: keyof string | ((instance: this) => any)): Stringable;
-  /**
-   * Get the plural form of an English word.
-   *
-   * @param { number } count
-   *
-   * @return { Stringable }
-   */
-  plural(count?: number): Stringable;
-  /**
-   * Pluralize the last word of an English, studly caps case string.
-   *
-   * @param { number } count
-   *
-   * @return { Stringable }
-   */
-  pluralStudly(count?: number): Stringable;
-  /**
-   * Pluralize the last word of an English, Pascal case string.
-   *
-   * @param { number } count
-   *
-   * @return { Stringable }
-   */
-  pluralPascal(count?: number): Stringable;
-  /**
-   * Find the multibyte safe position of the first occurrence of the given substring.
-   *
-   * @param { string } needle
-   * @param { number } offset
-   *
-   * @return { number | false }
-   */
-  position(needle: string, offset?: number): number | false;
-  /**
-   * Prepend the given values to the string.
-   *
-   * @param { string | string[] } values
-   *
-   * @return { Stringable }
-   */
-  prepend(...values: string[]): Stringable;
-  /**
-   * Remove any occurrence of the given string in the subject.
-   *
-   * @param { string } search
-   * @param { boolean } caseSensitive
-   *
-   * @return { Stringable }
-   */
-  remove(search: string, caseSensitive?: boolean): Stringable;
-  /**
-   * Reverse the string.
-   *
-   * @return { Stringable }
-   */
-  reverse(): Stringable;
-  /**
-   * Substitute placeholders { key } using object with dot notation.
-   *
-   * @param data
-   * @param def
-   * @returns
-   */
-  substitute(data?: Record<string, unknown>, def?: string): Stringable;
-  /**
-   * Repeat the string.
-   *
-   * @param { number } times
-   *
-   * @return { Stringable }
-   */
-  repeat(times: number): Stringable;
-  /**
-   * Replace the given value in the given string.
-   *
-   * @param { string | string[] } search
-   * @param { string } replace
-   * @param { boolean } caseSensitive
-   *
-   * @return { Stringable }
-   */
-  replace(search: string | string[], replace: string, caseSensitive?: boolean): Stringable;
-  /**
-   * Replace a given value in the string sequentially with an array.
-   *
-   * @param { string } search
-   * @param { string[] } replace
-   *
-   * @return { Stringable }
-   */
-  replaceArray(search: string, replace: string[]): Stringable;
-  /**
-   * Replace the first occurrence of a given value in the string.
-   *
-   * @param { string } search
-   * @param { string } replace
-   *
-   * @return { Stringable }
-   */
-  replaceFirst(search: string, replace: string): Stringable;
-  /**
-   * Replace the first occurrence of the given value if it appears at the start of the string.
-   *
-   * @param { string } search
-   * @param { string } replace
-   *
-   * @return { Stringable }
-   */
-  replaceStart(search: string, replace: string): Stringable;
-  /**
-   * Replace the last occurrence of a given value in the string.
-   *
-   * @param { string } search
-   * @param { string } replace
-   *
-   * @return { Stringable }
-   */
-  replaceLast(search: string, replace: string): Stringable;
-  /**
-   * Replace the last occurrence of a given value if it appears at the end of the string.
-   *
-   * @param { string } search
-   * @param { string } replace
-   *
-   * @return { Stringable }
-   */
-  replaceEnd(search: string, replace: string): Stringable;
-  /**
-   * Replace the patterns matching the given regular expression.
-   *
-   * @param { string } pattern
-   * @param { string | function } replace
-   *
-   * @return { Stringable }
-   */
-  replaceMatches(pattern: string, replace: string | Function): Stringable;
-  /**
-   * Remove all "extra" blank space from the given string.
-   *
-   * @return { Stringable }
-   */
-  squish(): Stringable;
-  /**
-   * Begin a string with a single instance of a given value.
-   *
-   * @param { string } prefix
-   *
-   * @return { Stringable }
-   */
-  start(prefix: string): Stringable;
-  /**
-   * Convert the given string to upper-case.
-   *
-   * @return { Stringable }
-   */
-  upper(): Stringable;
-  /**
-   * Convert the given string to title case.
-   *
-   * @return { Stringable }
-   */
-  title(): Stringable;
-  /**
-   * Convert the given string to title case for each word.
-   *
-   * @return { Stringable }
-   */
-  headline(): Stringable;
-  /**
-   * Convert the given string to APA-style title case.
-   *
-   * @see https://apastyle.apa.org/style-grammar-guidelines/capitalization/title-case
-   *
-   * @return { Stringable }
-   */
-  apa(): Stringable;
-  /**
-   * Get the singular form of an English word.
-   *
-   * @return { Stringable }
-   */
-  singular(): Stringable;
-  /**
-   * Generate a URL friendly "slug" from a given string.
-   *
-   * @param { string } separator
-   * @param { object } dictionary
-   *
-   * @return { Stringable }
-   */
-  slug(separator?: string, dictionary?: {
-    [key: string]: string;
-  }): Stringable;
-  /**
-   * Convert a string to snake case.
-   *
-   * @param { string } delimiter
-   *
-   * @return { Stringable }
-   */
-  snake(delimiter?: string): Stringable;
-  /**
-   * Determine if a given string starts with a given substring.
-   *
-   * @param { string | string[] } needles
-   *
-   * @return { boolean }
-   */
-  startsWith(needles: string | string[]): boolean;
-  /**
-   * Determine if a given string doesn't start with a given substring.
-   *
-   * @param { string | string[] } needles
-   *
-   * @return { boolean }
-   */
-  doesntStartWith(needles: string | string[]): boolean;
-  /**
-   * Convert a value to studly caps case.
-   *
-   * @return { Stringable }
-   */
-  studly(): Stringable;
-  /**
-   * Convert a value to Pascal case.
-   *
-   * @return { Stringable }
-   */
-  pascal(): Stringable;
-  /**
-   * Returns the portion of the string specified by the start and length parameters.
-   *
-   * @param { number } start
-   * @param { number | null } length
-   *
-   * @return { Stringable }
-   */
-  substr(start: number, length?: number | null): Stringable;
-  /**
-   * Returns the number of substring occurrences.
-   *
-   * @param { string } needle
-   * @param { number } offset
-   * @param { number | null } length
-   *
-   * @return { number }
-   */
-  substrCount(needle: string, offset?: number, length?: number | null): number;
-  /**
-   * Replace text within a portion of a string.
-   *
-   * @param { string } replace
-   * @param { number } offset
-   * @param { number | null } length
-   *
-   * @return { Stringable }
-   */
-  substrReplace(replace: string, offset?: number, length?: number | null): Stringable;
-  /**
-   * Swap multiple keywords in a string with other keywords.
-   *
-   * @param { Record<string, string> } map
-   *
-   * @return { Stringable }
-   */
-  swap(map: Record<string, string>): Stringable;
-  /**
-   * Take the first or last {limit} characters.
-   *
-   * @param { number } limit
-   *
-   * @return { Stringable }
-   */
-  take(limit: number): Stringable;
-  /**
-   * Call the given Closure with this instance then return the instance.
-   *
-   * @param { ((instance: this) => any) } callback
-   *
-   * @return { Stringable }
-   */
-  tap(callback: ((instance: this) => any)): this;
-  /**
-   * Trim the string of the given characters.
-   *
-   * @param { string | null } characters
-   *
-   * @return { Stringable }
-   */
-  trim(characters?: string | null): Stringable;
-  /**
-   * Left trim the string of the given characters.
-   *
-   * @param { string | string[]|null } characters
-   *
-   * @return { Stringable }
-   */
-  ltrim(characters?: string | null): Stringable;
-  /**
-   * Right trim the string of the given characters.
-   *
-   * @param { string | string[]|null } characters
-   *
-   * @return { Stringable }
-   */
-  rtrim(characters?: string | null): Stringable;
-  /**
-   * Make a string's first character lowercase.
-   *
-   * @return { Stringable }
-   */
-  lcfirst(): Stringable;
-  /**
-   * Make a string's first character uppercase.
-   *
-   * @return { Stringable }
-   */
-  ucfirst(): Stringable;
-  /**
-   * Split a string by uppercase characters.
-   *
-   * @return { string[] }
-   */
-  ucsplit(): string[];
-  /**
-   * Apply the callback if the given "value" is (or resolves to) truthy.
-   *
-   * @param { Value<this> } value
-   * @param { Callback<this> } callback
-   * @param { Fallback<this> } fallback
-   *
-   * @return { Stringable }
-   */
-  when(value: Value<this>, callback: Callback<this>, fallback?: Fallback<this>): this;
-  /**
-   * Apply the callback if the given "value" is (or resolves to) falsy.
-   *
-   * @param { Value<this> } value
-   * @param { Callback<this> } callback
-   * @param { Fallback<this> } fallback
-   *
-   * @return { this }
-   */
-  unless(value: Value<this>, callback: Callback<this>, fallback?: Fallback<this>): this;
-  /**
-   * Execute the given callback if the string contains a given substring.
-   *
-   * @param { string | string[] } needles
-   * @param { Callback<this> } callback
-   * @param { Fallback<this> } fallback
-   *
-   * @return { this }
-   */
-  whenContains(needles: string | string[], callback: Callback<this>, fallback?: Fallback<this>): this;
-  /**
-   * Execute the given callback if the string contains all array values.
-   *
-   * @param { string[] } needles
-   * @param { Callback<this> } callback
-   * @param { Fallback<this> } fallback
-   *
-   * @return { this }
-   */
-  whenContainsAll(needles: string[], callback: Callback<this>, fallback?: Fallback<this>): this;
-  /**
-   * Execute the given callback if the string is empty.
-   *
-   * @param { Callback<this> } callback
-   * @param { Fallback<this> } fallback
-   *
-   * @return { this }
-   */
-  whenEmpty(callback: Callback<this>, fallback?: Fallback<this>): this;
-  /**
-   * Execute the given callback if the string is not empty.
-   *
-   * @param { Callback<this> } callback
-   * @param { Fallback<this> } fallback
-   *
-   * @return { this }
-   */
-  whenNotEmpty(callback: Callback<this>, fallback?: Fallback<this>): this;
-  /**
-   * Execute the given callback if the string ends with a given substring.
-   *
-   * @param { string | string[] } needles
-   * @param { Callback<this> } callback
-   * @param { Fallback<this> } fallback
-   *
-   * @return { this }
-   */
-  whenEndsWith(needles: string | string[], callback: Callback<this>, fallback?: Fallback<this>): this;
-  /**
-   * Execute the given callback if the string doesn't end with a given substring.
-   *
-   * @param { string | string[] } needles
-   * @param { Callback<this> } callback
-   * @param { Fallback<this> } fallback
-   *
-   * @return { this }
-   */
-  whenDoesntEndWith(needles: string | string[], callback: Callback<this>, fallback?: Fallback<this>): this;
-  /**
-   * Execute the given callback if the string is an exact match with the given value.
-   *
-   * @param { string } value
-   * @param { Callback<this> } callback
-   * @param { Fallback<this> } fallback
-   *
-   * @return { this }
-   */
-  whenExactly(value: string, callback: Callback<this>, fallback?: Fallback<this>): this;
-  /**
-   * Execute the given callback if the string is not an exact match with the given value.
-   *
-   * @param { string } value
-   * @param { Callback<this> } callback
-   * @param { Fallback<this> } fallback
-   *
-   * @return { this }
-   */
-  whenNotExactly(value: string, callback: Callback<this>, fallback?: Fallback<this>): this;
-  /**
-   * Execute the given callback if the string matches a given pattern.
-   *
-   * @param { string | string[] } pattern
-   * @param { Callback<this> } callback
-   * @param { Fallback<this> } fallback
-   *
-   * @return { this }
-   */
-  whenIs(pattern: string | string[], callback: Callback<this>, fallback?: Fallback<this>): this;
-  /**
-   * Execute the given callback if the string is 7-bit ASCII.
-   *
-   * @param { Callback<this> } callback
-   * @param { Fallback<this> } fallback
-   *
-   * @return { this }
-   */
-  whenIsAscii(callback: Callback<this>, fallback?: Fallback<this>): this;
-  /**
-   * Execute the given callback if the string is a valid UUID.
-   *
-   * @param { Callback<this> } callback
-   * @param { Fallback<this> } fallback
-   *
-   * @return { this }
-   */
-  whenIsUuid(callback: Callback<this>, fallback?: Fallback<this>): this;
-  /**
-   * Execute the given callback if the string is a valid ULID.
-   *
-   * @param { Callback<this> } callback
-   * @param { Fallback<this> } fallback
-   *
-   * @return { this }
-   */
-  whenIsUlid(callback: Callback<this>, fallback?: Fallback<this>): this;
-  /**
-   * Execute the given callback if the string starts with a given substring.
-   *
-   * @param { string | string[] } needles
-   * @param { Callback<this> } callback
-   * @param { Fallback<this> } fallback
-   *
-   * @return { this }
-   */
-  whenStartsWith(needles: string | string[], callback: Callback<this>, fallback?: Fallback<this>): this;
-  /**
-   * Execute the given callback if the string doesn't start with a given substring.
-   *
-   * @param { string | string[] } needles
-   * @param { Callback<this> } callback
-   * @param { Fallback<this> } fallback
-   *
-   * @return { this }
-   */
-  whenDoesntStartWith(needles: string | string[], callback: Callback<this>, fallback?: Fallback<this>): this;
-  /**
-   * Execute the given callback if the string matches the given pattern.
-   *
-   * @param { string } pattern
-   * @param { Callback<this> } callback
-   * @param { Fallback<this> } fallback
-   *
-   * @return { this }
-   */
-  whenTest(pattern: string, callback: Callback<this>, fallback?: Fallback<this>): this;
-  /**
-   * Limit the number of words in a string.
-   *
-   * @param { number } words
-   * @param { string } end
-   *
-   * @return { Stringable }
-   */
-  words(words?: number, end?: string): Stringable;
-  /**
-   * Get the number of words a string contains.
-   *
-   * @return { number }
-   */
-  wordCount(): number;
-  /**
-   * Wrap a string to a given number of characters.
-   *
-   * @param { number } characters
-   * @param { string } breakStr
-   * @param { boolean } cutLongWords
-   *
-   * @returns { this }
-   */
-  wordWrap(characters?: number, breakStr?: string, cutLongWords?: boolean): Stringable;
-  /**
-   * Wrap the string with the given strings.
-   *
-   * @param { string } before
-   * @param { string | null } after
-   *
-   * @return { Stringable }
-   */
-  wrap(before: string, after?: string | null): Stringable;
-  /**
-   * Unwrap the string with the given strings.
-   *
-   * @param { string } before
-   * @param { string | null } after
-   *
-   * @return { Stringable }
-   */
-  unwrap(before: string, after?: string | null): Stringable;
-  /**
-   * Convert the string into a `HtmlString` instance.
-   *
-   * @return { HtmlStringType }
-   */
-  toHtmlString(): HtmlStringType;
-  /**
-   * Convert the string to Base64 encoding.
-   *
-   * @return { Stringable }
-   */
-  toBase64(): Stringable;
-  /**
-   * Decode the Base64 encoded string.
-   *
-   * @return { Stringable }
-   */
-  fromBase64(): Stringable;
-  /**
-   * Checks if a string is numeric
-   *
-   * @return { boolean }
-   */
-  isNumber(): boolean;
-  /**
-   * Checks if a string is an integer
-   *
-   * @return { boolean }
-   */
-  isInteger(): boolean;
-  /**
-   * ROT-N cipher.
-   *
-   * @param n
-   * @returns
-   */
-  rot(n?: number): Stringable;
-  /**
-   * Replace trailing punctuation with new format.
-   *
-   * @param newFormat
-   * @returns
-   */
-  replacePunctuation(newFormat: string): Stringable;
-  /**
-   * Array/object driven text replacement.
-   *
-   * @param replacements
-   * @returns
-   */
-  translate(replacements: Record<string, string> | Array<[string, string]>): Stringable;
-  /**
-   * Strip slashes recursively.
-   *
-   * @returns
-   */
-  ss(): Stringable;
-  /**
-   * First and last N lines.
-   *
-   * @param amount
-   * @returns
-   */
-  firstLines(amount?: number): Stringable;
-  /**
-   * Last and first N lines.
-   *
-   * @param amount
-   * @returns
-   */
-  lastLines(amount?: number): Stringable;
-  /**
-   * Dump the string.
-   *
-   * @return { void }
-   */
-  dump(): void;
-  /**
-   * Dump the string and end the script.
-   *
-   * @return { never }
-   */
-  dd(): never;
-  /**
-   * Get the underlying string value.
-   *
-   * @return { string }
-   */
-  value(): string;
-  /**
-   * Get the raw string value.
-   *
-   * @return { string }
-   */
-  toString(): string;
-  /**
-   * Get the underlying string value as an integer.
-   *
-   * @param { number } base
-   *
-   * @return { number }
-   */
-  toInteger(base?: number): number;
-  /**
-   * Get the underlying string value as a float.
-   *
-   * @return { number }
-   */
-  toFloat(): number;
-  /**
-   * Get the underlying string value as a boolean.
-   *
-   * Returns true when value is "1", "true", "on", and "yes". Otherwise, returns false.
-   *
-   * @return { boolean }
-   */
-  toBoolean(): boolean;
-  /**
-   * Get the underlying string value as a formatted Date string.
-   *
-   * @param { string | null } format
-   * @param { string | null } tz
-   */
-  toDate(format?: string | null, tz?: string | null): string;
-}
-declare class HtmlString {
-  /**
-   * The HTML string.
-   *
-   * @type { string }
-   */
-  private readonly html;
-  /**
-   * Create a new HTML string instance.
-   *
-   * @param { string } html
-   *
-   * @return void
-   */
-  constructor(html?: string);
-  /**
-   * Get the HTML string.
-   *
-   * @return { HtmlStringType }
-   */
-  toHtml(): HtmlStringType;
-  /**
-   * Determine if the given HTML string is empty.
-   *
-   * @return { boolean }
-   */
-  isEmpty(): boolean;
-  /**
-   * Determine if the given HTML string is not empty.
-   *
-   * @return { boolean }
-   */
-  isNotEmpty(): boolean;
-  /**
-   * Get the HTML string.
-   *
-   * @return { string }
-   */
-  toString(): string;
-}
-/**
- * Get a new Stringable object from the given string.
- *
- * @param { string } string
- *
- * @return Stringable
- */
-declare function str(string?: string): Stringable;
-//#endregion
-//#region src/GlobalBootstrap.d.ts
-type CollapseStatics<T$1 extends Record<string, any>> = { [K in keyof T$1]: T$1[K] };
-type Omitables = 'start' | 'take' | 'reverse' | 'chunk' | 'find' | 'pop' | 'end' | 'shift' | 'push' | 'at' | 'prototype' | 'concat' | 'join' | 'slice' | 'sort' | 'splice' | 'includes' | 'indexOf' | 'lastIndexOf' | 'findIndex' | 'every' | 'some' | 'forEach' | 'map' | 'filter' | 'reduce' | 'unshift' | 'flat' | 'flatMap' | 'keys' | 'fill' | 'copyWithin' | 'entries' | 'values' | 'reduceRight' | 'length' | 'of' | '_isObject' | '_clone' | 'crossJoin' | 'divide' | 'wrap' | 'except' | 'hasAny' | 'isList' | 'keyBy' | 'mapWithKeys' | 'only' | 'pluck' | 'pull' | 'shuffle' | 'sortDesc' | 'sortRecursive' | 'sortRecursiveDesc' | 'where' | 'whereNotNull' | 'head' | 'string' | 'boolean' | 'array' | 'float' | 'from' | 'hasAll' | 'integer' | 'mapSpread' | 'partition' | 'reject' | 'select' | 'sole' | 'alternate' | 'combine' | 'isEmpty' | 'isNotEmpty' | 'range' | typeof Symbol.unscopables | typeof Symbol.iterator;
-type TakeTime = Pick<typeof DateTime, 'now' | 'format' | 'fromTimestamp' | 'randomTime' | 'firstDayOfMonth' | 'lastDayOfMonth' | 'parse'>;
-type TakeString = Pick<typeof Str, 'after' | 'afterLast' | 'apa' | 'ascii' | 'before' | 'beforeLast' | 'between' | 'betweenFirst' | 'capitalize' | 'plural' | 'singular' | 'title'>;
-/**
- * Global helpers interface that mirrors Laravel's helpers
- * and provides convenient access to all utility functions
- */
-interface GlobalHelpers extends Omit<CollapseStatics<typeof Arr>, Omitables | 'random' | 'dot'>, Omit<CollapseStatics<TakeString>, Omitables | 'random' | 'uuid'>, Omit<CollapseStatics<TakeTime>, Omitables>, Omit<CollapseStatics<typeof Obj_d_exports>, Omitables | 'Obj'>, Omit<CollapseStatics<typeof Crypto_d_exports>, Omitables>, Omit<CollapseStatics<typeof Number_d_exports>, Omitables>, Omit<CollapseStatics<typeof DumpDie_d_exports>, Omitables> {
-  Arr: typeof Arr;
-  Str: typeof Str;
-  Obj: typeof Obj;
-  Crypto: typeof Crypto_d_exports;
-  Number: typeof Number_d_exports;
-  DumpDie: typeof DumpDie_d_exports;
-  DateTime: typeof DateTime;
-}
-/**
- * Bootstrap the global helpers into the global scope.
- * This enables optional global access to all helper functions.
- *
- * Example usage:
- * ```typescript
- * import { loadHelpers } from '@h3ravel/support'
- *
- * // Make helpers globally available
- * loadHelpers()
- *
- * // Now you can use:
- * Arr.chunk([1, 2, 3, 4], 2)
- * // or directly:
- * chunk([1, 2, 3, 4], 2)
- * Str.capitalize('hello world')
- * // or directly:
- * capitalize('hello world')
- * ```
- *
- * @param target - The target object to attach helpers to (default: globalThis)
- */
-declare function loadHelpers(target?: any): void;
-/**
- * Clean up global helpers by removing them from the global scope.
- * This function removes all global helper attachments.
- *
- * @param target - The target object to clean up (default: globalThis)
- */
-declare function cleanHelpers(target?: any): void;
-//#endregion
-export { Arr, Arrayable, Callback, CamelToSnakeCase, Crypto_d_exports as Crypto, DateTime, DotPath, DumpDie_d_exports as DumpDie, ExcerptOptions, Fallback, Function, GlobalHelpers, HtmlString, HtmlStringType, InvalidArgumentException, JsonSerializable, Jsonable, KeysToSnakeCase, Mode, Number_d_exports as Number, Obj_d_exports as 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, loadHelpers, modObj, random, randomColor, randomPassword, randomSecure, safeDot, secureToken, setNested, slugifyKeys, str, toBytes, toCssClasses, toCssStyles, toHumanTime, undot, uuid, verifyChecksum, xor };