@h3ravel/support 0.13.0 → 0.14.0

package/dist/index.d.ts

@@ -36,69 +36,37 @@ type TGeneric<V = any, K extends string = string> = Record<K, V>;
 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, wrap };
-}
-/**
- * Splits an array into chunks of a specified size.
- *
- * @template T - Type of elements in the array
- * @param arr - The input array
- * @param size - Size of each chunk (default: 2)
- * @returns An array of chunks (arrays)
- */
-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[]];
+type DotPath<T> = T extends object ? { [K in keyof T & (string | number)]: T[K] extends object ? `${K}` | `${K}.${DotPath<T[K]>}` : `${K}` }[keyof T & (string | number)] : never;
+//#endregion
+//#region src/Contracts/TypeCast.d.ts
+type Arrayable = {
+  [key: string]: any;
+  toArray(): any[];
+};
+type Jsonable = {
+  [key: string]: any;
+  toJSON(): any;
+};
+type JsonSerializable = {
+  [key: string]: any;
+  jsonSerialize(): any;
+};
+//#endregion
+//#region src/Exceptions/InvalidArgumentException.d.ts
 /**
- * Generates an array of sequential numbers.
- *
- * @param size - Number of elements in the range
- * @param startAt - Starting number (default: 0)
- * @returns An array of numbers from startAt to startAt + size - 1
+ * Custom error for invalid type coercion
  */
-declare const range: (size: number, startAt?: number) => number[];
-/** Flatten multi-dimensional arrays into single level. */
-declare const flatten: <T>(arr: T[]) => T[];
+declare class InvalidArgumentException extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/Exceptions/RuntimeException.d.ts
 /**
- * If the given value is not an array and not null, wrap it in one.
- *
- * @param  {Array}  value
- * @return array
+ * Custom error for invalid type coercion
  */
-declare const wrap: <A>(value: A | A[]) => A[];
+declare class RuntimeException extends Error {
+  constructor(message: string);
+}
 declare namespace Crypto_d_exports {
   export { base64Decode, base64Encode, caesarCipher, checksum, hash, hmac, random, randomColor, randomPassword, randomSecure, secureToken, uuid, verifyChecksum, xor };
 }
@@ -269,7 +237,7 @@ declare const toBytes: (bytes?: number, decimals?: number, bits?: boolean) => st
  */
 declare const toHumanTime: (seconds?: number, worded?: boolean) => string;
 declare namespace Obj_d_exports {
-  export { dot, extractProperties, getValue, modObj, safeDot, setNested, slugifyKeys };
+  export { Obj, data_fill, data_forget, data_get, data_set, dot, extractProperties, getValue, modObj, safeDot, setNested, slugifyKeys, toCssClasses, toCssStyles, undot };
 }
 /**
  * Flattens a nested object into a single-level object
@@ -349,6 +317,489 @@ 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>;
+/**
+ * toCssClasses
+ *
+ * Convert array/object/string input into a CSS class string.
+ * - Arrays: included if truthy
+ * - Objects: keys included if value is truthy
+ * - Strings: included as-is
+ */
+declare function toCssClasses<T extends string | Record<string, boolean> | Array<string | false | null | undefined>>(input: T): string;
+/**
+ * toCssStyles
+ *
+ * Convert object input into CSS style string.
+ * - Only includes truthy values (ignores null/undefined/false)
+ */
+declare function toCssStyles<T extends Record<string, string | number | boolean | null | undefined>>(styles: T): string;
+/**
+ * undot
+ *
+ * Convert a dot-notated object back into nested structure.
+ *
+ * Example:
+ * undot({ 'a.b': 1, 'c.0': 2 }) -> { a: { b: 1 }, c: [2] }
+ */
+declare function undot(obj: Record<string, any>): Record<string, any>;
+/**
+ * data_get
+ *
+ * Get a value from an object using dot notation.
+ */
+declare function data_get<T extends object, P extends DotPath<T> | DotPath<T>[], D = undefined>(obj: T, path: P, defaultValue?: D): T | any;
+/**
+ * data_set
+ *
+ * Set a value in an object using dot notation. Mutates the object.
+ */
+declare function data_set<T extends Record<string, any>, P extends string | string[], V>(obj: T, path: P, value: V): asserts obj is T & Record<P extends string ? P : P[0], V>;
+/**
+ * data_fill
+ *
+ * Like data_set, but only sets the value if the key does NOT exist.
+ */
+declare function data_fill(obj: Record<string, any>, path: string | string[], value: any): void;
+/**
+ * data_forget
+ *
+ * Remove a key from an object using dot notation.
+ */
+declare function data_forget(obj: Record<string, any>, path: string | string[]): void;
+declare class Obj {
+  /**
+   * Check if the value is a non-null object (associative/accessible).
+   */
+  static accessible(value: unknown): value is Record<string, any>;
+  /**
+   * Add a key-value pair to an object only if the key does not already exist.
+   *
+   * Returns a new object (does not mutate original).
+   */
+  static add<T extends Record<string, any>, K extends string, V>(obj: T, key: K, value: V): T & Record<K, V>;
+  /**
+   * Split object into [keys, values]
+   */
+  static divide<T extends Record<string, any>>(obj: T): [string[], any[]];
+  /**
+   * Check if a key exists in the object.
+   */
+  static exists<T extends Record<string, any>>(obj: T, key: string | number): boolean;
+  /**
+   * Get a value from an object using dot notation.
+   *
+   * Example:
+   * Obj.get({a:{b:1}}, 'a.b') -> 1
+   */
+  static get<T extends object, P extends DotPath<T>, D = undefined>(obj: T, path: P, defaultValue?: D): any;
+  /**
+   * Check if the object has a given key or keys (dot notation supported).
+   */
+  static has<T extends object, P extends DotPath<T>>(obj: T, keys: P | P[]): boolean;
+  /**
+   * Check if an object is associative (has at least one non-numeric key).
+   */
+  static isAssoc(obj: unknown): obj is Record<string, any>;
+  /**
+   * Add a prefix to all keys of the object.
+   */
+  static prependKeysWith<T extends Record<string, any>>(obj: T, prefix: string): Record<string, any>;
+  /**
+   * Convert an object into a URL query string.
+   *
+   * Nested objects/arrays are flattened using bracket notation.
+   */
+  static query(obj: Record<string, any>): string;
+}
+//#endregion
+//#region src/Helpers/Arr.d.ts
+/**
+ * Arr — Laravel-like array helpers for JavaScript.
+ *
+ * - Methods aim for clear, predictable JS behavior.
+ * - Inputs are validated where useful; functions try not to mutate arguments.
+ */
+declare class Arr {
+  /**
+   * Helper: is a value an object (but not null).
+   */
+  static _isObject(value: any): boolean;
+  /**
+   * Helper: deep clone for safety (simple).
+   * Uses JSON methods — good for typical data shapes (no functions, Dates, Maps).
+   */
+  static _clone<A = any>(value: A): A;
+  /**
+   * Retrieve a value using dot notation
+   * Throws if value is not an array
+   */
+  static array(obj: any, path: string, defaultValue?: number): any[];
+  /**
+   * Retrieve a value using dot notation
+   * Throws if value is not a boolean
+   */
+  static boolean(obj: any, path: string, defaultValue?: boolean): boolean;
+  /**
+   * Flatten an array of arrays by one level.
+   *
+   * Example:
+   * Arr.collapse([[1,2], [3], 4]) -> [1,2,3,4]
+   */
+  static collapse<X>(array: X[][] | X[]): X[];
+  /**
+   * Cartesian product of arrays.
+   *
+   * Example:
+   * Arr.crossJoin([1,2], ['a','b']) -> [[1,'a'], [1,'b'], [2,'a'], [2,'b']]
+   *
+   * Accepts any number of array arguments (or single array-of-arrays).
+   */
+  static crossJoin<A>(...arrays: A[][]): A[][];
+  /**
+   * Split an array (or object) into two arrays: [keys, values].
+   *
+   * For arrays, keys are numeric indices. For objects, keys are property names.
+   *
+   * Example:
+   * Arr.divide(['a','b']) -> [[0,1], ['a','b']]
+   * Arr.divide({x:1,y:2}) -> [['x','y'], [1,2]]
+   */
+  static divide<A>(input: A[] | Record<string, A>): (A[] | number[])[] | (A[] | string[])[];
+  /**
+   * Flatten a nested array/object structure into a single-level object
+   * with dot-notated keys.
+   *
+   * Example:
+   * Arr.dot({ a: { b: 1 }, c: [2,3] }) -> { 'a.b': 1, 'c.0': 2, 'c.1': 3 }
+   *
+   * Works for arrays and plain objects.
+   */
+  static dot<A>(input: A[] | Record<string, A>, prefix?: string): Record<string, A>;
+  /**
+   * Checks if all elements satisfy the predicate
+   */
+  static every<T>(array: T[], predicate: (item: T) => boolean): boolean;
+  /**
+   * Remove items by keys/indices from an array or properties from an object.
+   *
+   * For arrays: keys are numeric indices (single number or array of numbers).
+   *
+   * Returns a shallow-copied result (does not mutate input).
+   *
+   * Example:
+   * Arr.except([10,20,30], [1]) -> [10,30]
+   */
+  static except<A extends any[] | Record<string, any>, X>(input: A, keys: X[]): A;
+  /**
+   * Return the first element of an array that satisfies the predicate,
+   * or the first element if no predicate is provided, otherwise the defaultValue.
+   *
+   * Predicate can be true (boolean), a function or a value to match (strict equality).
+   *
+   * When predicate is true (boolean), the first element will be removed and a tuple will be returned [el, rest].
+   *
+   * @param array
+   * @param predicate
+   * @param defaultValue
+   *
+   * @returns
+   */
+  static first<A, P extends (((arg: A) => true) | true)>(array: A[], predicate?: P | undefined, defaultValue?: A | undefined): P extends true ? [A, A[]] : A | undefined;
+  /**
+   * Recursively flatten an array up to `depth` levels (default: Infinity).
+   *
+   * Example:
+   * Arr.flatten([1, [2, [3]]], 1) -> [1,2,[3]]
+   */
+  static flatten<A>(array: A[], depth?: number): A[];
+  /**
+   * Retrieve a value from an array/object using dot notation
+   * Throws if value is not a float
+   */
+  static float(obj: any, path: string, defaultValue?: number): number;
+  /**
+   * Remove element(s) by index or dot-notated path from an array/object.
+   *
+   * For arrays: accepts numeric index or array of indices. Returns a new array.
+   *
+   * For objects: supports dot notation to remove nested keys.
+   *
+   * Example:
+   * Arr.forget([1,2,3], 1) -> [1,3]
+   * Arr.forget({a:{b:1}}, 'a.b') -> { a: {} }
+   */
+  static forget<A extends any[] | Record<string, any>>(input: A, keys: any): A;
+  /**
+   * Converts various input types into a plain array
+   * Supports Arrays, Objects, Iterables, Map, WeakMap, and custom toArray/toJSON/jsonSerialize methods
+   */
+  static from<T>(value: T | Iterable<T> | Arrayable | Jsonable | JsonSerializable | null | undefined): any[];
+  /**
+   * Checks if an object has all the specified keys
+   */
+  static hasAll<T extends object>(obj: T, keys: (keyof T)[]): boolean;
+  /**
+   * For arrays: check if the array contains any of the provided values.
+   *
+   * values can be single value or array of values.
+   *
+   * Example:
+   * Arr.hasAny([1,2,3], [4,2]) -> true
+   */
+  static hasAny<A>(array: A[], values: A[] | A): boolean;
+  /**
+   * Retrieve a value using dot notation
+   * Throws if value is not an integer
+   */
+  static integer(obj: any, path: string, defaultValue?: number): number;
+  /**
+   * Determine if the input is a "list-like" array: an Array with
+   * contiguous numeric indices starting at 0 (no gaps).
+   *
+   * Example:
+   * Arr.isList([1,2,3]) -> true
+   * const a = []; a[2] = 5; Arr.isList(a) -> false
+   */
+  static isList<A>(value: A[]): boolean;
+  /**
+   * Join array elements into a string using the given separator.
+   *
+   * Example:
+   * Arr.join([1,2,3], '-') -> '1-2-3'
+   */
+  static join(array: any[], separator?: string): string;
+  /**
+   * Create an object indexed by a key or callback function.
+   *
+   * Example:
+   * Arr.keyBy([{id:1},{id:2}], 'id') -> { '1': {id:1}, '2': {id:2} }
+   */
+  static keyBy<T>(array: T[], key: keyof T | ((item: T) => string | number)): Record<string, T>;
+  /**
+   * Get the last element of an array, optionally matching a predicate,
+   * or the last element if no predicate is provided, otherwise the defaultValue.
+   *
+   * Predicate can be a true (boolean), a function or a value to match (strict equality).
+   *
+   * When predicate is true (boolean), the last element will be removed and a tuple will be returned [el, rest].
+   *
+   * @param array
+   * @param predicate
+   * @param defaultValue
+   *
+   * @returns
+   */
+  static last<T, P extends ((item: T) => boolean) | true>(array: T[], predicate?: P | T, defaultValue?: T): P extends true ? [T, T[]] : T | undefined;
+  /**
+   * Transform each element in an array using a callback.
+   */
+  static map<T, U>(array: T[], callback: (item: T, index: number) => U): U[];
+  /**
+   * Maps a multi-dimensional array with a spread callback
+   */
+  static mapSpread<T extends any[], U>(array: T[], callback: (...items: T) => U): U[];
+  /**
+   * Map each element to a key-value pair.
+   *
+   * Example:
+   * Arr.mapWithKeys([{id:1, name:'A'}], x => [x.id, x.name])
+   * -> { '1': 'A' }
+   */
+  static mapWithKeys<T, K extends string | number, V>(array: T[], callback: (item: T, index: number) => [K, V]): Record<string, V>;
+  /**
+   * Return only elements at the given indices.
+   *
+   * Example:
+   * Arr.only([10,20,30], [0,2]) -> [10,30]
+   */
+  static only<T>(array: T[], keys: number | number[]): T[];
+  /**
+   * Split an array into two arrays based on a predicate
+   */
+  static partition<T>(array: T[], predicate: (item: T) => boolean): [T[], T[]];
+  /**
+   * Extract a property from each element in an array of objects.
+   *
+   * Example:
+   * Arr.pluck([{name:'A'},{name:'B'}], 'name') -> ['A','B']
+   */
+  static pluck<T, K extends keyof T>(array: T[], key: K): T[K][];
+  /**
+   * Add elements to the beginning of an array and return a new array.
+   *
+   * @param array
+   * @param value
+   * @returns
+   */
+  static prepend<T>(array: T[], ...value: T[]): T[];
+  /**
+   * Remove a value from an array by index and return it.
+   * Returns a tuple: [newArray, removedValue]
+   */
+  static pull<T>(array: T[], key: number): [T[], T | undefined];
+  /**
+   * Append values to an array (mutable)
+   */
+  static push<T>(array: T[], ...values: T[]): T[];
+  /**
+   * Pick one or more random elements from an array.
+   */
+  static random<T>(array: T[], count?: number): T | T[] | undefined;
+  /**
+   * Returns array elements that do NOT satisfy the predicate
+   */
+  static reject<T>(array: T[], predicate: (item: T) => boolean): T[];
+  /**
+   * Pick keys from an array of objects or an object
+   */
+  static select<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+  /**
+   * Returns the only element that passes a callback, throws if none or multiple
+   */
+  static sole<T>(array: T[], predicate: (item: T) => boolean): T;
+  /**
+   * Checks if at least one element satisfies the predicate
+   */
+  static some<T>(array: T[], predicate: (item: T) => boolean): boolean;
+  /**
+   * Randomly shuffle an array and return a new array.
+   */
+  static shuffle<T>(array: T[]): T[];
+  /**
+   * Sort an array ascending using optional comparator.
+   */
+  static sort<T>(array: T[], comparator?: (a: T, b: T) => number): T[];
+  /**
+   * Sort an array descending using optional comparator.
+   */
+  static sortDesc<T>(array: T[], comparator?: (a: T, b: T) => number): T[];
+  /**
+   * Recursively sort arrays inside an array.
+   */
+  static sortRecursive<T>(array: T[]): T[];
+  /**
+   * Recursively sort arrays inside an array descending.
+   */
+  static sortRecursiveDesc<T>(array: T[]): T[];
+  /**
+   * Retrieve a value using dot notation
+   * Throws if value is not a string
+   */
+  static string(obj: any, path: string, defaultValue?: string): string;
+  /**
+   * Return the first N elements of an array.
+   *
+   * @param array
+   * @param count
+   * @returns
+   */
+  static take<T>(array: T[], count: number): T[];
+  /**
+   * Filter an array based on a predicate function or key-value match.
+   */
+  static where<T>(array: T[], predicate: ((item: T) => boolean) | Partial<T>): T[];
+  /**
+   * Filter an array of objects, keeping elements where the given key is not null/undefined.
+   */
+  static whereNotNull<T>(array: T[], key: keyof T): T[];
+  /**
+   * If the given value is not an array and not null, wrap it in one.
+   *
+   * Non-array values become [value]; null/undefined becomes [].
+   *
+   * @param value
+   * @returns
+   */
+  static wrap<T>(value: T | T[] | null | undefined): T[];
+  /**
+   * Return the first element of an array, undefined if empty.
+   */
+  static head<T>(array: T[]): T | undefined;
+  /**
+   * Splits an array into chunks of a specified size.
+   *
+   * @template T - Type of elements in the array
+   * @param arr - The input array
+   * @param size - Size of each chunk (default: 2)
+   * @returns An array of chunks (arrays)
+   */
+  static chunk: <T>(arr: T[], size?: number) => T[][];
+  /**
+   * Alternates between two arrays, creating a zipped result.
+   *
+   * @param a
+   * @param b
+   * @returns
+   */
+  static alternate<T>(a: T[], b: T[]): T[];
+  /**
+   * Combine arrays and sum their values element by element.
+   *
+   * @param arr
+   * @returns
+   */
+  static combine(...arr: number[][]): number[];
+  /**
+   * Find the value associated with a given key.
+   *
+   * @param key
+   * @param arr
+   * @returns
+   */
+  static find<T>(key: T, arr: T[]): T | null;
+  /**
+   * Check if array is empty.
+   *
+   * @param arr
+   * @returns
+   */
+  static isEmpty<T>(arr: T[]): boolean;
+  /**
+   * Check if array is empty.
+   *
+   * @param arr
+   * @returns
+   */
+  static isNotEmpty<T>(arr: T[]): boolean;
+  /**
+   * Pop the element off the end of array.
+   *
+   * @param arr
+   * @returns
+   */
+  static pop<T>(arr: T[]): T[];
+  /**
+   * Create a new array in reverse order.
+   *
+   * @param arr
+   * @returns
+   */
+  static reverse<T>(arr: T[]): T[];
+  /**
+   * Return the first element of an array that satisfies the predicate,
+   * or the first element if no predicate is provided, otherwise the defaultValue.
+   *
+   * Predicate can be true (boolean), a function or a value to match (strict equality).
+   *
+   * When predicate is true (boolean), the first element will be removed and a tuple will be returned [el, rest].
+   *
+   * @param array
+   * @param predicate
+   * @param defaultValue
+   *
+   * @alias Arr.first()
+   * @returns
+   */
+  static shift<A, P extends (((arg: A) => true) | true)>(array: A[], predicate?: P | undefined, defaultValue?: A | undefined): P extends true ? [A, A[]] : A | undefined;
+  /**
+   * Generates an array of sequential numbers.
+   *
+   * @param size - Number of elements in the range
+   * @param startAt - Starting number (default: 0)
+   * @returns An array of numbers from startAt to startAt + size - 1
+   */
+  static range(size: number, startAt?: number): number[];
+}
 //#endregion
 //#region src/Helpers/Time.d.ts
 declare function format(date: ConfigType, fmt: string): string;
@@ -2694,17 +3145,17 @@ 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 Omitables = 'start' | 'take' | 'reverse' | 'chunk' | 'find' | 'pop' | 'end' | 'shift' | 'push' | 'at' | 'prototype' | 'concat' | 'join' | 'slice' | 'sort' | 'splice' | 'includes' | 'indexOf' | 'lastIndexOf' | 'findIndex' | 'every' | 'some' | 'forEach' | 'map' | 'filter' | 'reduce' | 'unshift' | 'flat' | 'flatMap' | 'keys' | 'fill' | 'copyWithin' | 'entries' | 'values' | 'reduceRight' | 'length' | 'of' | '_isObject' | '_clone' | 'crossJoin' | 'divide' | 'wrap' | 'except' | 'hasAny' | 'isList' | 'keyBy' | 'mapWithKeys' | 'only' | 'pluck' | 'pull' | 'shuffle' | 'sortDesc' | 'sortRecursive' | 'sortRecursiveDesc' | 'where' | 'whereNotNull' | 'head' | 'string' | 'boolean' | 'array' | 'float' | 'from' | 'hasAll' | 'integer' | 'mapSpread' | 'partition' | 'reject' | 'select' | 'sole' | 'alternate' | 'combine' | 'isEmpty' | 'isNotEmpty' | 'range' | typeof Symbol.unscopables | typeof Symbol.iterator;
 type TakeTime = Pick<typeof DateTime, 'now' | 'format' | 'fromTimestamp' | 'randomTime' | 'firstDayOfMonth' | 'lastDayOfMonth' | 'parse'>;
 type TakeString = Pick<typeof Str, 'after' | 'afterLast' | 'apa' | 'ascii' | 'before' | 'beforeLast' | 'between' | 'betweenFirst' | 'capitalize' | 'plural' | 'singular' | 'title'>;
 /**
  * Global helpers interface that mirrors Laravel's helpers
  * and provides convenient access to all utility functions
  */
-interface GlobalHelpers extends Omit<CollapseStatics<typeof Arr_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;
+interface GlobalHelpers extends Omit<CollapseStatics<typeof Arr>, Omitables | 'random' | 'dot'>, Omit<CollapseStatics<TakeString>, Omitables | 'random' | 'uuid'>, Omit<CollapseStatics<TakeTime>, Omitables>, Omit<CollapseStatics<typeof Obj_d_exports>, Omitables | 'Obj'>, Omit<CollapseStatics<typeof Crypto_d_exports>, Omitables>, Omit<CollapseStatics<typeof Number_d_exports>, Omitables>, Omit<CollapseStatics<typeof DumpDie_d_exports>, Omitables> {
+  Arr: typeof Arr;
   Str: typeof Str;
-  Obj: typeof Obj_d_exports;
+  Obj: typeof Obj;
   Crypto: typeof Crypto_d_exports;
   Number: typeof Number_d_exports;
   DumpDie: typeof DumpDie_d_exports;
@@ -2741,5 +3192,5 @@ declare function loadHelpers(target?: any): void;
  */
 declare function cleanHelpers(target?: any): void;
 //#endregion
-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 };
+export { Arr, Arrayable, Callback, CamelToSnakeCase, Crypto_d_exports as Crypto, DateTime, DotPath, DumpDie_d_exports as DumpDie, ExcerptOptions, Fallback, Function, GlobalHelpers, HtmlString, HtmlStringType, InvalidArgumentException, JsonSerializable, Jsonable, KeysToSnakeCase, Mode, Number_d_exports as Number, Obj_d_exports as Obj, RuntimeException, SnakeToCamelCase, SnakeToTitleCase, Str, Stringable, TGeneric, Value, XGeneric, abbreviate, base64Decode, base64Encode, caesarCipher, checksum, cleanHelpers, data_fill, data_forget, data_get, data_set, dd, dot, dump, extractProperties, format, getValue, hash, hmac, humanize, loadHelpers, modObj, random, randomColor, randomPassword, randomSecure, safeDot, secureToken, setNested, slugifyKeys, str, toBytes, toCssClasses, toCssStyles, toHumanTime, undot, uuid, verifyChecksum, xor };
 //# sourceMappingURL=index.d.ts.map