@h3ravel/support 0.11.0 → 0.13.0

package/dist/index.d.cts

@@ -1,6 +1,7 @@
 /// <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
@@ -17,6 +18,17 @@ type SnakeToCamelCase<S extends string> = S extends `${infer T}_${infer U}` ? `$
  * 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> = boolean | ((instance: T) => boolean);
+type Callback<T> = (instance: T, value: boolean) => T | void | undefined;
+type Fallback<T> = Callback<T> | null;
+interface Function {
+  (...args: any[]): any;
+}
 //#endregion
 //#region src/Contracts/ObjContract.d.ts
 /**
@@ -28,7 +40,7 @@ type XGeneric<V = TGeneric, T = any> = {
   [key: string]: T;
 } & V;
 declare namespace Arr_d_exports {
-  export { alternate, chunk, collapse, combine, find, first, flatten, forget, isEmpty, isNotEmpty, last, pop, prepend, range, reverse, shift, take };
+  export { alternate, chunk, collapse, combine, find, first, flatten, forget, isEmpty, isNotEmpty, last, pop, prepend, range, reverse, shift, take, wrap };
 }
 /**
  * Splits an array into chunks of a specified size.
@@ -83,8 +95,15 @@ declare const shift: <T>(arr: T[]) => [T, T[]];
 declare const range: (size: number, startAt?: number) => number[];
 /** Flatten multi-dimensional arrays into single level. */
 declare const flatten: <T>(arr: T[]) => T[];
+/**
+ * If the given value is not an array and not null, wrap it in one.
+ *
+ * @param  {Array}  value
+ * @return array
+ */
+declare const wrap: <A>(value: A | A[]) => A[];
 declare namespace Crypto_d_exports {
-  export { PasswordOptions, base64Decode, base64Encode, caesarCipher, checksum, hash, hmac, random, randomColor, randomPassword, randomSecure, secureToken, uuid, verifyChecksum, xor };
+  export { base64Decode, base64Encode, caesarCipher, checksum, hash, hmac, random, randomColor, randomPassword, randomSecure, secureToken, uuid, verifyChecksum, xor };
 }
 /**
  * Generate a random UUID string.
@@ -198,6 +217,21 @@ declare const verifyChecksum: (data: string, expectedChecksum: string, algorithm
  * @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 };
 }
@@ -318,268 +352,2366 @@ declare const setNested: (obj: Record<string, any>, key: string, value: any) =>
  * @returns A new object with slugified keys
  */
 declare const slugifyKeys: <T extends object>(obj: T, only?: string[], separator?: string) => KeysToSnakeCase<T>;
-declare namespace Str_d_exports {
-  export { after, afterLast, before, beforeLast, capitalize, chop, esc, firstLines, isInteger, isNumber, lastLines, padString, pluralize, replacePunctuation, rot, singularize, slugify, split, ss, sub, subString, substitute, substr, translate, truncate };
-}
-/**
- * Get the portion of the string after the first occurrence of the given value.
- *
- * @param value
- * @param search
- * @returns
- */
-declare const after: (value: string, search: string) => string;
-/**
- * Get the portion of the string after the last occurrence of the given value.
- *
- * @param value
- * @param search
- * @returns
- */
-declare const afterLast: (value: string, search: string) => string;
-/**
- * Get the portion of the string before the first occurrence of the given value.
- *
- * @param value
- * @param search
- * @returns
- */
-declare const before: (value: string, search: string) => string;
-/**
- * Get the portion of the string before the last occurrence of the given value.
- *
- * @param value
- * @param search
- * @returns
- */
-declare const beforeLast: (value: string, search: string) => string;
-/** Capitalizes the first character of a string. */
-declare function capitalize(str: string): string;
-/**
- * Returns the pluralized form of a word based on the given number.
- */
-declare const pluralize: (word: string, count: number) => string;
-/** Converts a plural English word into its singular form. */
-declare const singularize: (word: string) => string;
-/** Converts a string into a slug format. */
-declare const slugify: (str: string, joiner?: string) => string;
-/** Truncates a string to a specified length and appends an ellipsis if needed. */
-declare const subString: (str: string, len: number, ellipsis?: string) => string;
-/** Substitute placeholders { key } using object with dot notation. */
-declare const substitute: (str: string, data?: Record<string, unknown>, def?: string) => string | undefined;
-/** Truncate string removing HTML tags and append suffix if needed. */
-declare const truncate: (str: string, len?: number, suffix?: string) => string;
-/** Get substring from offset/length similar to PHP substr. */
-declare const substr: (string: string, offset: number, length?: number) => string;
-/** Get substring by start/stop indexes. */
-declare const sub: (string: string, start: number, stop: number) => string;
-/** Escape string for JSON encoding (returns string without quotes). */
-declare const esc: (string: string) => string;
-/** Padding to a fixed size, right by default. */
-declare const padString: (string: string, size: number, padString?: string, padRight?: boolean) => string;
-/** Split by delimiter with edge-case rule. */
-declare const split: (string: string, delimiter: string) => string[];
-/** Returns all the characters except the last. */
-declare const chop: (string: string) => string;
-/** Number checks. */
-declare const isNumber: (string: string) => boolean;
-declare const isInteger: (string: string) => boolean;
-/** ROT-N cipher. */
-declare const rot: (string: string, n?: number) => string;
-/** Replace trailing punctuation with new format. */
-declare const replacePunctuation: (string: string, newFormat: string) => string;
-/** Array/object driven text replacement. */
-declare const translate: (string: string, replacements: Record<string, string> | Array<[string, string]>) => string;
-/** Strip slashes recursively. */
-declare const ss: (string: string) => string;
-/** First and last N lines. */
-declare const firstLines: (string: string, amount?: number) => string;
-declare const lastLines: (string: string, amount?: number) => string;
-declare namespace Time_d_exports {
-  export { TimeFormat, TimeUnit, add, dayOfYear, diff, end, firstDayOfMonth, format, fromNow, fromTimestamp, isBetween, isLeapYear, lastDayOfMonth, now, randomTime, start, subtract, unix };
+//#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;
 }
-type TimeFormat = 'Y-m-d' | 'Y-m-d H:i:s' | 'd-m-Y' | 'd/m/Y' | 'M j, Y' | 'F j, Y' | 'D j M' | 'timestamp' | 'unix';
-type TimeUnit = 'milliseconds' | 'seconds' | 'minutes' | 'hours' | 'days';
-/**
- * Get current timestamp in milliseconds.
- *
- * @returns Current timestamp as number
- */
-declare const now: () => number;
-/**
- * Get current Unix timestamp.
- *
- * @returns Current Unix timestamp
- */
-declare const unix: () => number;
-/**
- * Format a date string according to a specified format (UTC-based for determinism).
- *
- * @param date - Date string or Date object
- * @param format - Format to output (default: 'Y-m-d H:i:s')
- * @returns Formatted date string
- */
-declare const format: (date: string | Date, format?: TimeFormat) => string;
-/**
- * Create a date for a given timestamp.
- *
- * @param timestamp - Unix timestamp
- * @returns Date object
- */
-declare const fromTimestamp: (timestamp: number) => Date;
-/**
- * Return the difference for given date in seconds.
- *
- * @param date - Date to compare
- * @param referenceDate - Reference date (optional, defaults to now)
- * @returns Number of seconds difference
- */
-declare const diff: (date: string | Date, referenceDate?: string | Date) => number;
-/**
- * Subtract time from the given date.
- */
-declare const subtract: (date: string | Date, amount?: number, unit?: TimeUnit) => Date;
-/**
- * Add time to the given date.
- */
-declare const add: (date: string | Date, amount?: number, unit?: TimeUnit) => Date;
-/**
- * Start time of a specific unit.
- */
-declare const start: (date: string | Date, unit?: TimeUnit) => Date;
-/**
- * End time of a specific unit.
- */
-declare const end: (date: string | Date, unit?: TimeUnit) => Date;
-/**
- * Get the difference in days from today.
- */
-declare const fromNow: (date: string | Date) => number;
-/**
- * Get a random time between the specified hour and minute.
- */
-declare const randomTime: (startHour?: number, startMinute?: number, endHour?: number, endMinute?: number) => Date;
-/**
- * Check if the current time is between the specified durations.
- */
-declare const isBetween: (startTime: string, endTime: string) => boolean;
-/** Day of year, first/last day of month, leap year checks. */
-declare const dayOfYear: (date?: string | Date) => number;
-declare const firstDayOfMonth: (date?: string | Date) => Date;
-declare const lastDayOfMonth: (date?: string | Date) => Date;
-declare const isLeapYear: (year?: number) => boolean;
 //#endregion
-//#region src/Helpers/DumpDie.d.ts
+//#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;
+}
 /**
- * Dump something and kill the process for quick debugging. Based on Laravel's dd()
+ * Get a new Stringable object from the given string.
  *
- * @param args
- */
-declare const dd: (...args: unknown[]) => never;
-/**
- * Dump something but keep the process for quick debugging. Based on Laravel's dump()
+ * @param { string } string
  *
- * @param args
+ * @return Stringable
  */
-declare const dump: (...args: unknown[]) => void;
+declare function str(string?: string): Stringable;
 //#endregion
 //#region src/GlobalBootstrap.d.ts
+type CollapseStatics<T extends Record<string, any>> = { [K in keyof T]: T[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' | 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 {
+interface GlobalHelpers extends Omit<CollapseStatics<typeof Arr_d_exports>, Omitables>, Omit<CollapseStatics<TakeString>, Omitables | 'random' | 'uuid'>, Omit<CollapseStatics<TakeTime>, Omitables>, Omit<CollapseStatics<typeof Obj_d_exports>, Omitables>, Omit<CollapseStatics<typeof Crypto_d_exports>, Omitables>, Omit<CollapseStatics<typeof Number_d_exports>, Omitables>, Omit<CollapseStatics<typeof DumpDie_d_exports>, Omitables> {
   Arr: typeof Arr_d_exports;
-  chunk: typeof chunk;
-  collapse: typeof collapse;
-  alternate: typeof alternate;
-  combine: typeof combine;
-  find: typeof find;
-  forget: typeof forget;
-  first: typeof first;
-  last: typeof last;
-  isEmpty: typeof isEmpty;
-  isNotEmpty: typeof isNotEmpty;
-  pop: typeof pop;
-  prepend: typeof prepend;
-  take: typeof take;
-  reverse: typeof reverse;
-  shift: typeof shift;
-  range: typeof range;
-  flatten: typeof flatten;
-  Str: typeof Str_d_exports;
-  after: typeof after;
-  afterLast: typeof afterLast;
-  before: typeof before;
-  beforeLast: typeof beforeLast;
-  capitalize: typeof capitalize;
-  pluralize: typeof pluralize;
-  singularize: typeof singularize;
-  slugify: typeof slugify;
-  subString: typeof subString;
-  substitute: typeof substitute;
-  truncate: typeof truncate;
-  substr: typeof substr;
-  sub: typeof sub;
-  esc: typeof esc;
-  padString: typeof padString;
-  split: typeof split;
-  chop: typeof chop;
-  isNumber: typeof isNumber;
-  isInteger: typeof isInteger;
-  rot: typeof rot;
-  replacePunctuation: typeof replacePunctuation;
-  translate: typeof translate;
-  ss: typeof ss;
-  firstLines: typeof firstLines;
-  lastLines: typeof lastLines;
+  Str: typeof Str;
   Obj: typeof Obj_d_exports;
-  dot: typeof dot;
-  extractProperties: typeof extractProperties;
-  getValue: typeof getValue;
-  modObj: typeof modObj;
-  safeDot: typeof safeDot;
-  setNested: typeof setNested;
-  slugifyKeys: typeof slugifyKeys;
   Crypto: typeof Crypto_d_exports;
-  uuid: typeof uuid;
-  random: typeof random;
-  randomSecure: typeof randomSecure;
-  hash: typeof hash;
-  hmac: typeof hmac;
-  base64Encode: typeof base64Encode;
-  base64Decode: typeof base64Decode;
-  xor: typeof xor;
-  randomColor: typeof randomColor;
-  randomPassword: typeof randomPassword;
-  secureToken: typeof secureToken;
-  checksum: typeof checksum;
-  verifyChecksum: typeof verifyChecksum;
-  caesarCipher: typeof caesarCipher;
-  Time: typeof Time_d_exports;
-  now: typeof now;
-  unix: typeof unix;
-  format: typeof format;
-  fromTimestamp: typeof fromTimestamp;
-  diff: typeof diff;
-  subtract: typeof subtract;
-  add: typeof add;
-  start: typeof start;
-  end: typeof end;
-  fromNow: typeof fromNow;
-  randomTime: typeof randomTime;
-  isBetween: typeof isBetween;
-  dayOfYear: typeof dayOfYear;
-  firstDayOfMonth: typeof firstDayOfMonth;
-  lastDayOfMonth: typeof lastDayOfMonth;
-  isLeapYear: typeof isLeapYear;
   Number: typeof Number_d_exports;
-  abbreviate: typeof abbreviate;
-  humanize: typeof humanize;
-  toBytes: typeof toBytes;
-  toHumanTime: typeof toHumanTime;
-  dump: typeof dump;
-  dd: typeof dd;
+  DumpDie: typeof DumpDie_d_exports;
+  DateTime: typeof DateTime;
 }
 /**
  * Bootstrap the global helpers into the global scope.
@@ -587,10 +2719,10 @@ interface GlobalHelpers {
  *
  * Example usage:
  * ```typescript
- * import { bootstrap } from '@h3ravel/support'
+ * import { loadHelpers } from '@h3ravel/support'
  *
  * // Make helpers globally available
- * bootstrap()
+ * loadHelpers()
  *
  * // Now you can use:
  * Arr.chunk([1, 2, 3, 4], 2)
@@ -603,14 +2735,14 @@ interface GlobalHelpers {
  *
  * @param target - The target object to attach helpers to (default: globalThis)
  */
-declare function bootstrap(target?: any): void;
+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 cleanBootstrap(target?: any): void;
+declare function cleanHelpers(target?: any): void;
 //#endregion
-export { CamelToSnakeCase, GlobalHelpers, KeysToSnakeCase, PasswordOptions, SnakeToCamelCase, SnakeToTitleCase, TGeneric, TimeFormat, TimeUnit, XGeneric, abbreviate, add, after, afterLast, alternate, base64Decode, base64Encode, before, beforeLast, bootstrap, caesarCipher, capitalize, checksum, chop, chunk, cleanBootstrap, collapse, combine, dayOfYear, dd, diff, dot, dump, end, esc, extractProperties, find, first, firstDayOfMonth, firstLines, flatten, forget, format, fromNow, fromTimestamp, getValue, hash, hmac, humanize, isBetween, isEmpty, isInteger, isLeapYear, isNotEmpty, isNumber, last, lastDayOfMonth, lastLines, modObj, now, padString, pluralize, pop, prepend, random, randomColor, randomPassword, randomSecure, randomTime, range, replacePunctuation, reverse, rot, safeDot, secureToken, setNested, shift, singularize, slugify, slugifyKeys, split, ss, start, sub, subString, substitute, substr, subtract, take, toBytes, toHumanTime, translate, truncate, unix, uuid, verifyChecksum, xor };
+export { Arr_d_exports as Arr, Callback, CamelToSnakeCase, Crypto_d_exports as Crypto, DateTime, DumpDie_d_exports as DumpDie, ExcerptOptions, Fallback, Function, GlobalHelpers, HtmlString, HtmlStringType, KeysToSnakeCase, Mode, Number_d_exports as Number, Obj_d_exports as Obj, SnakeToCamelCase, SnakeToTitleCase, Str, Stringable, TGeneric, Value, XGeneric, abbreviate, alternate, base64Decode, base64Encode, caesarCipher, checksum, chunk, cleanHelpers, collapse, combine, dd, dot, dump, extractProperties, find, first, flatten, forget, format, getValue, hash, hmac, humanize, isEmpty, isNotEmpty, last, loadHelpers, modObj, pop, prepend, random, randomColor, randomPassword, randomSecure, range, reverse, safeDot, secureToken, setNested, shift, slugifyKeys, str, take, toBytes, toHumanTime, uuid, verifyChecksum, wrap, xor };
 //# sourceMappingURL=index.d.cts.map