@h3ravel/support 0.10.4 → 0.12.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 /// <reference path="./app.globals.d.ts" />
+import dayjs, { ConfigType, Dayjs, OpUnitType } from "dayjs";
 import { DotFlatten, DotNestedKeys, DotNestedValue } from "@h3ravel/shared";
 
 //#region src/Contracts/StrContract.d.ts
@@ -14,6 +15,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
 /**
@@ -24,8 +36,9 @@ type TGeneric<V = any, K extends string = string> = Record<K, V>;
 type XGeneric<V = TGeneric, T = any> = {
   [key: string]: T;
 } & V;
-//#endregion
-//#region src/Helpers/Arr.d.ts
+declare namespace Arr_d_exports {
+  export { alternate, chunk, collapse, combine, find, first, flatten, forget, isEmpty, isNotEmpty, last, pop, prepend, range, reverse, shift, take };
+}
 /**
  * Splits an array into chunks of a specified size.
  *
@@ -35,6 +48,40 @@ type XGeneric<V = TGeneric, T = any> = {
  * @returns An array of chunks (arrays)
  */
 declare const chunk: <T>(arr: T[], size?: number) => T[][];
+/**
+ * Collapse an array of arrays into a single array.
+ */
+declare const collapse: <T>(arr: (T | T[])[]) => T[];
+/**
+ * Alternates between two arrays, creating a zipped result.
+ */
+declare const alternate: <T>(a: T[], b: T[]) => T[];
+/**
+ * Combine arrays and sum their values element by element.
+ */
+declare const combine: (...arr: number[][]) => number[];
+/** Find the value associated with a given key. */
+declare const find: <T>(key: T, arr: T[]) => T | null;
+/** Returns a new array without the given indices. */
+declare const forget: <T>(arr: T[], keys: number[]) => T[];
+/** Remove the first element and return tuple [el, rest]. */
+declare const first: <T>(arr: T[]) => [T, T[]];
+/** Remove the last element and return tuple [el, rest]. */
+declare const last: <T>(arr: T[]) => [T, T[]];
+/** Check if array is empty. */
+declare const isEmpty: <T>(arr: T[]) => boolean;
+/** Check if array is empty. */
+declare const isNotEmpty: <T>(arr: T[]) => boolean;
+/** Pop the element off the end of array. */
+declare const pop: <T>(arr: T[]) => T[];
+/** Add elements to the beginning of array. */
+declare const prepend: <T>(arr: T[], ...elements: T[]) => T[];
+/** Take first n elements of array. */
+declare const take: <T>(amount: number, arr: T[]) => T[];
+/** Create a new array in reverse order. */
+declare const reverse: <T>(arr: T[]) => T[];
+/** Alias for first element removal. */
+declare const shift: <T>(arr: T[]) => [T, T[]];
 /**
  * Generates an array of sequential numbers.
  *
@@ -43,8 +90,126 @@ declare const chunk: <T>(arr: T[], size?: number) => T[][];
  * @returns An array of numbers from startAt to startAt + size - 1
  */
 declare const range: (size: number, startAt?: number) => number[];
-//#endregion
-//#region src/Helpers/DumpDie.d.ts
+/** Flatten multi-dimensional arrays into single level. */
+declare const flatten: <T>(arr: T[]) => T[];
+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()
  *
@@ -57,8 +222,9 @@ declare const dd: (...args: unknown[]) => never;
  * @param args
  */
 declare const dump: (...args: unknown[]) => void;
-//#endregion
-//#region src/Helpers/Number.d.ts
+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.
@@ -95,8 +261,9 @@ declare const toBytes: (bytes?: number, decimals?: number, bits?: boolean) => st
  * @returns A formatted time string
  */
 declare const toHumanTime: (seconds?: number, worded?: boolean) => string;
-//#endregion
-//#region src/Helpers/Obj.d.ts
+declare namespace Obj_d_exports {
+  export { dot, extractProperties, getValue, modObj, safeDot, setNested, slugifyKeys };
+}
 /**
  * Flattens a nested object into a single-level object
  * with dot-separated keys.
@@ -177,101 +344,2395 @@ declare const setNested: (obj: Record<string, any>, key: string, value: any) =>
 declare const slugifyKeys: <T extends object>(obj: T, only?: string[], separator?: string) => KeysToSnakeCase<T>;
 //#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 the portion of the string after the first occurrence of the given value.
+ * Get a new Stringable object from the given string.
  *
- * @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 { string } string
  *
- * @param value
- * @param search
- * @returns
+ * @return Stringable
  */
-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.
- *
- * @param str - The input string
- * @returns The string with the first character capitalized
- */
-declare function capitalize(str: string): string;
-/**
- * Returns the pluralized form of a word based on the given number.
- *
- * @param word - The word to pluralize
- * @param count - The number determining pluralization
- * @returns Singular if count === 1, otherwise plural form
- */
-declare const pluralize: (word: string, count: number) => string;
+declare function str(string?: string): Stringable;
+//#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 Time 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(): Time;
+  carbonFormat(template?: string | undefined): string;
+  /**
+   * Get the last day of the month of the given date
+   *
+   * @returns
+   */
+  lastDayOfMonth(): Time;
+  /**
+   * 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): Time;
+  /**
+   * 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(): Time;
+  /**
+   * Parse the time
+   *
+   * @param date
+   * @returns
+   */
+  static parse(date: dayjs.ConfigType): Time;
+  /**
+   * 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): Time;
+  /**
+   * Get the first day of the month of the given date
+   *
+   * @param time
+   *
+   * @returns
+   */
+  static firstDayOfMonth(time: ConfigType): Time;
+  /**
+   * Get the last day of the month of the given date
+   *
+   * @param time
+   *
+   * @returns
+   */
+  static lastDayOfMonth(time: ConfigType): Time;
+}
+//#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 Time, 'now' | 'format' | 'fromTimestamp' | 'randomTime' | 'firstDayOfMonth' | 'lastDayOfMonth' | 'parse'>;
+type TakeString = Pick<typeof Str, 'after' | 'afterLast' | 'apa' | 'ascii' | 'before' | 'beforeLast' | 'between' | 'betweenFirst' | 'capitalize' | 'plural' | 'singular' | 'title'>;
 /**
- * Converts a plural English word into its singular form.
- *
- * @param word - The word to singularize
- * @returns The singular form of the word
+ * Global helpers interface that mirrors Laravel's helpers
+ * and provides convenient access to all utility functions
  */
-declare const singularize: (word: string) => string;
+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;
+  Str: typeof Str;
+  Obj: typeof Obj_d_exports;
+  Crypto: typeof Crypto_d_exports;
+  Time: typeof Time;
+  Number: typeof Number_d_exports;
+  DumpDie: typeof DumpDie_d_exports;
+}
 /**
- * Converts a string into a slug format.
- * Handles camelCase, spaces, and non-alphanumeric characters.
+ * Bootstrap the global helpers into the global scope.
+ * This enables optional global access to all helper functions.
  *
- * @param str - The input string to slugify
- * @param joiner - The character used to join words (default: "_")
- * @returns A slugified string
- */
-declare const slugify: (str: string, joiner?: string) => string;
-/**
- * Truncates a string to a specified length and appends an ellipsis if needed.
+ * Example usage:
+ * ```typescript
+ * import { loadHelpers } from '@h3ravel/support'
  *
- * @param str - The input string
- * @param len - Maximum length of the result (including ellipsis)
- * @param ellipsis - String to append if truncated (default: "...")
- * @returns The truncated string
- */
-declare const subString: (str: string, len: number, ellipsis?: string) => string;
-/**
- * Replaces placeholders in a string with corresponding values from a data object.
+ * // Make helpers globally available
+ * loadHelpers()
  *
- * Example:
- * substitute("Hello { user.name }!", { user: { name: "John" } })
- * // "Hello John!"
+ * // 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 str - The string containing placeholders wrapped in { } braces.
- * @param data - Object containing values to substitute. Supports nested keys via dot notation.
- * @param def - Default value to use if a key is missing. (Optional)
- * @returns The substituted string or undefined if the input string or data is invalid.
+ * @param target - The target object to attach helpers to (default: globalThis)
  */
-declare const substitute: (str: string, data?: Record<string, unknown>, def?: string) => string | undefined;
+declare function loadHelpers(target?: any): void;
 /**
- * Truncates a string to a specified length, removing HTML tags and
- * appending a suffix if the string exceeds the length.
+ * Clean up global helpers by removing them from the global scope.
+ * This function removes all global helper attachments.
  *
- * @param str - The string to truncate
- * @param len - Maximum length (default: 20)
- * @param suffix - Suffix to append if truncated (default: "...")
- * @returns The truncated string
+ * @param target - The target object to clean up (default: globalThis)
  */
-declare const truncate: (str: string, len?: number, suffix?: string) => string;
+declare function cleanHelpers(target?: any): void;
 //#endregion
-export { CamelToSnakeCase, KeysToSnakeCase, SnakeToCamelCase, SnakeToTitleCase, TGeneric, XGeneric, abbreviate, after, afterLast, before, beforeLast, capitalize, chunk, dd, dot, dump, extractProperties, getValue, humanize, modObj, pluralize, range, safeDot, setNested, singularize, slugify, slugifyKeys, subString, substitute, toBytes, toHumanTime, truncate };
+export { Arr_d_exports as Arr, Callback, CamelToSnakeCase, Crypto_d_exports as Crypto, 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, Time, 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, xor };
 //# sourceMappingURL=index.d.ts.map