@zairakai/js-utils 1.0.0

package/dist/collections.d.cts

@@ -0,0 +1,353 @@
+/**
+ * Collection utilities for JavaScript arrays and objects
+ * Inspired by Laravel Collections with modern JavaScript features
+ */
+/**
+ * Generic callback type for collection operations.
+ */
+type Callback<T, R> = (item: T, index: number) => R;
+/**
+ * Predicate type for collection filtering and validation.
+ */
+type Predicate<T> = (item: T, index: number) => boolean;
+/**
+ * Enhanced Array class with Laravel Collection-like methods.
+ * Extends the native Array class with additional utility methods for manipulation,
+ * validation, and statistical analysis.
+ */
+declare class EnhancedArray<T> extends Array<T> {
+    protected originalItems: T[];
+    /**
+     * Create a new EnhancedArray instance.
+     *
+     * @param {...T[]} items The items to initialize the collection with
+     */
+    constructor(...items: T[]);
+    /**
+     * Determine if the collection has been modified since initialization or last sync.
+     *
+     * @returns {boolean} True if modified, false otherwise
+     */
+    isDirty(): boolean;
+    /**
+     * Determine if the collection is clean (not modified).
+     *
+     * @returns {boolean} True if not modified, false otherwise
+     */
+    isClean(): boolean;
+    /**
+     * Sync the original items with current items to mark the collection as clean.
+     *
+     * @returns {this} The collection instance
+     */
+    syncOriginal(): this;
+    /**
+     * Compare with another array or collection for equality.
+     *
+     * @param {T[] | EnhancedArray<T>} other The array or collection to compare with
+     * @returns {boolean} True if equivalent, false otherwise
+     */
+    isEquivalent(other: T[] | EnhancedArray<T>): boolean;
+    /**
+     * Create an EnhancedArray from an iterable or array-like object.
+     *
+     * @param {Iterable<T> | ArrayLike<T>} items The items to convert
+     * @returns {EnhancedArray<T>} A new EnhancedArray instance
+     */
+    static from<T>(items: Iterable<T> | ArrayLike<T>): EnhancedArray<T>;
+    /**
+     * Create an EnhancedArray from a variable number of arguments.
+     *
+     * @param {...T[]} items The items to include
+     * @returns {EnhancedArray<T>} A new EnhancedArray instance
+     */
+    static of<T>(...items: T[]): EnhancedArray<T>;
+    /**
+     * Create a new collection instance from the current items.
+     *
+     * @returns {EnhancedArray<T>} A new EnhancedArray instance
+     */
+    collect(): EnhancedArray<T>;
+    /**
+     * Pluck an array of values from an array of objects.
+     *
+     * @param {K} key The key to pluck
+     * @returns {EnhancedArray<T[K]>} A new collection of plucked values
+     */
+    pluck<K extends keyof T>(key: K): EnhancedArray<T[K]>;
+    /**
+     * Group the collection's items by a given key or callback.
+     *
+     * @param {K | Callback<T, string | number>} key The key or callback to group by
+     * @returns {Record<string, EnhancedArray<T>>} A record of grouped collections
+     */
+    groupBy<K extends keyof T>(key: K | Callback<T, string | number>): Record<string, EnhancedArray<T>>;
+    /**
+     * Return only unique items from the collection.
+     *
+     * @param {K} [key] Optional key to determine uniqueness for objects
+     * @returns {EnhancedArray<T>} A new collection of unique items
+     */
+    unique<K extends keyof T>(key?: K): EnhancedArray<T>;
+    /**
+     * Chunk the collection into smaller collections of a given size.
+     *
+     * @param {number} size The size of each chunk
+     * @returns {EnhancedArray<EnhancedArray<T>>} A collection of chunked collections
+     */
+    chunk(size: number): EnhancedArray<EnhancedArray<T>>;
+    /**
+     * Flatten a multi-dimensional collection into a single level.
+     *
+     * @param {number} [depth=Infinity] The depth to flatten to
+     * @returns {EnhancedArray<unknown>} A new flattened collection
+     */
+    deepFlatten(depth?: number): EnhancedArray<unknown>;
+    /**
+     * Rotate the collection by a given number of positions.
+     *
+     * @param {number} [positions=1] The number of positions to rotate
+     * @returns {EnhancedArray<T>} A new rotated collection
+     */
+    rotate(positions?: number): EnhancedArray<T>;
+    /**
+     * Chunk the collection as long as the given predicate returns true.
+     *
+     * @param {Predicate<T>} predicate The predicate to check
+     * @returns {EnhancedArray<EnhancedArray<T>>} A collection of chunked collections
+     */
+    chunkWhile(predicate: Predicate<T>): EnhancedArray<EnhancedArray<T>>;
+    /**
+     * Transpose the collection (swap rows and columns).
+     *
+     * @returns {EnhancedArray<EnhancedArray<unknown>>} A new transposed collection
+     */
+    transpose(): EnhancedArray<EnhancedArray<unknown>>;
+    /**
+     * Check if the collection is sorted.
+     *
+     * @param {Function} [compareFn] Optional comparison function
+     * @returns {boolean} True if sorted, false otherwise
+     */
+    isSorted(compareFn?: (a: T, b: T) => number): boolean;
+    /**
+     * Check if the collection contains duplicate items.
+     *
+     * @param {K} [key] Optional key to check for uniqueness in objects
+     * @returns {boolean} True if duplicates found, false otherwise
+     */
+    hasDuplicates<K extends keyof T>(key?: K): boolean;
+    /**
+     * Calculate the median value of the collection.
+     *
+     * @param {Callback<T, number>} [accessor] Optional accessor for non-numeric items
+     * @returns {number | null} The median value or null if collection is empty
+     */
+    median(accessor?: Callback<T, number>): number | null;
+    /**
+     * Calculate the mode (most frequent values) of the collection.
+     *
+     * @param {Callback<T, unknown>} [accessor] Optional accessor for the values
+     * @returns {EnhancedArray<unknown>} A collection of mode values
+     */
+    mode(accessor?: Callback<T, unknown>): EnhancedArray<unknown>;
+    /**
+     * Calculate the standard deviation of the collection.
+     *
+     * @param {Callback<T, number>} [accessor] Optional accessor for non-numeric items
+     * @returns {number} The standard deviation
+     */
+    standardDeviation(accessor?: Callback<T, number>): number;
+    /**
+     * Calculate a specific percentile of the collection.
+     *
+     * @param {number} percentile The percentile to calculate (0-100)
+     * @param {Callback<T, number>} [accessor] Optional accessor for non-numeric items
+     * @returns {number | null} The percentile value or null if collection is empty
+     */
+    percentile(percentile: number, accessor?: Callback<T, number>): number | null;
+    /**
+     * Calculate the frequencies of items in the collection.
+     *
+     * @param {Callback<T, unknown>} [accessor] Optional accessor for the values
+     * @returns {Record<string, number>} A record of values and their frequencies
+     */
+    frequencies(accessor?: Callback<T, unknown>): Record<string, number>;
+    /**
+     * Calculate the Cartesian product of the collection and other arrays.
+     *
+     * @param {...U[][]} arrays The arrays to calculate the product with
+     * @returns {EnhancedArray<[T, ...U[]]>} A collection of product combinations
+     */
+    cartesian<U>(...arrays: U[][]): EnhancedArray<[T, ...U[]]>;
+    /**
+     * Interleave the collection with other arrays.
+     *
+     * @param {...U[][]} arrays The arrays to interleave with
+     * @returns {EnhancedArray<T | U>} A new interleaved collection
+     */
+    interleave<U>(...arrays: U[][]): EnhancedArray<T | U>;
+    /**
+     * Get a sliding window of items from the collection.
+     *
+     * @param {number} [size=2] The size of the window
+     * @param {number} [step=1] The step between windows
+     * @returns {EnhancedArray<EnhancedArray<T>>} A collection of window collections
+     */
+    sliding(size?: number, step?: number): EnhancedArray<EnhancedArray<T>>;
+    /**
+     * Get the item at the given index.
+     *
+     * @param {number} index The index to retrieve
+     * @returns {T | undefined} The item at the index or undefined
+     */
+    at(index: number): T | undefined;
+    /**
+     * Get the item before the given item.
+     *
+     * @param {T} item The item to search for
+     * @returns {T | undefined} The item before or undefined
+     */
+    before(item: T): T | undefined;
+    /**
+     * Get the item after the given item.
+     *
+     * @param {T} item The item to search for
+     * @returns {T | undefined} The item after or undefined
+     */
+    after(item: T): T | undefined;
+    /**
+     * Chunk the collection by a given key or callback when its value changes.
+     *
+     * @param {K | Callback<T, unknown>} key The key or callback to chunk by
+     * @returns {EnhancedArray<EnhancedArray<T>>} A collection of chunked collections
+     */
+    chunkBy<K extends keyof T>(key: K | Callback<T, unknown>): EnhancedArray<EnhancedArray<T>>;
+    /**
+     * Map and filter the collection simultaneously.
+     * Items for which the callback returns null or undefined are removed.
+     *
+     * @param {Function} callback The callback to map items
+     * @returns {EnhancedArray<U>} A new mapped and filtered collection
+     */
+    filterMap<U>(callback: (item: T, index: number) => U | null | undefined): EnhancedArray<U>;
+    /**
+     * Extract a subset of properties from each item in the collection.
+     *
+     * @param {K[]} keys The keys to extract
+     * @returns {EnhancedArray<Partial<T>>} A new collection of partial items
+     */
+    extract<K extends keyof T>(keys: K[]): EnhancedArray<Partial<T>>;
+    /**
+     * Get the first item or push a default item if the collection is empty.
+     *
+     * @param {T} item The default item to push if empty
+     * @returns {T} The first item or the pushed item
+     */
+    firstOrPush(item: T): T;
+    /**
+     * Get every n-th item from the collection.
+     *
+     * @param {number} n The step size
+     * @returns {EnhancedArray<T>} A new collection of every n-th item
+     */
+    getNth(n: number): EnhancedArray<T>;
+    /**
+     * Get a random item from the collection based on weights.
+     *
+     * @param {number[]} [weights] Optional weights for each item
+     * @returns {T | undefined} A random item or undefined if collection is empty
+     */
+    weightedRandom(weights?: number[]): T | undefined;
+    /**
+     * Paginate the collection items.
+     *
+     * @param {number} perPage Items per page
+     * @param {number} [page=1] Current page number
+     * @returns {Object} Pagination results
+     */
+    paginate(perPage: number, page?: number): {
+        data: EnhancedArray<T>;
+        total: number;
+        perPage: number;
+        currentPage: number;
+        lastPage: number;
+        from: number;
+        to: number;
+    };
+    /**
+     * Recursively convert all nested arrays to EnhancedArray instances.
+     *
+     * @returns {EnhancedArray<unknown>} A new collection with recursive EnhancedArrays
+     */
+    recursive(): EnhancedArray<unknown>;
+}
+/**
+ * Convert a plain object to a Map.
+ *
+ * @param {Record<string, T>} obj The object to convert
+ * @returns {Map<string, T>} A new Map instance
+ */
+declare const objectToMap: <T>(obj: Record<string, T>) => Map<string, T>;
+/**
+ * Convert a Map to a plain object.
+ *
+ * @param {Map<string, T>} map The Map to convert
+ * @returns {Record<string, T>} A new plain object
+ */
+declare const mapToObject: <T>(map: Map<string, T>) => Record<string, T>;
+/**
+ * Enhanced Map class with additional collection-like methods.
+ * Extends the native Map class.
+ */
+declare class EnhancedMap<K, V> extends Map<K, V> {
+    /**
+     * Create an EnhancedMap from a plain object.
+     *
+     * @param {Record<string, V>} obj The object to convert
+     * @returns {EnhancedMap<string, V>} A new EnhancedMap instance
+     */
+    static fromObject<V>(obj: Record<string, V>): EnhancedMap<string, V>;
+    /**
+     * Pluck a property from each value in the map.
+     *
+     * @param {P} key The key to pluck
+     * @returns {EnhancedArray<V[P]>} A new collection of plucked values
+     */
+    pluck<P extends keyof V>(key: P): EnhancedArray<V[P]>;
+    /**
+     * Group the map's entries by a given accessor.
+     *
+     * @param {Function} accessor The accessor to group by
+     * @returns {Record<string, EnhancedArray<[K, V]>>} A record of grouped entries
+     */
+    groupBy(accessor: (value: V, key: K) => string | number): Record<string, EnhancedArray<[K, V]>>;
+    /**
+     * Convert the map to an array of entries.
+     *
+     * @returns {EnhancedArray<[K, V]>} A collection of entries
+     */
+    toArray(): EnhancedArray<[K, V]>;
+    /**
+     * Convert the map to a plain object.
+     *
+     * @returns {Record<string, V>} A plain object representation of the map
+     */
+    toObject(): Record<string, V>;
+}
+/**
+ * Create a new EnhancedArray from an array of items.
+ *
+ * @param {T[]} items The items to collect
+ * @returns {EnhancedArray<T>} A new EnhancedArray instance
+ */
+declare const collect: <T>(items: T[]) => EnhancedArray<T>;
+/**
+ * Create a new EnhancedMap from an iterable of entries.
+ *
+ * @param {Iterable<[K, V]>} [entries] Optional entries to initialize the map
+ * @returns {EnhancedMap<K, V>} A new EnhancedMap instance
+ */
+declare const collectMap: <K, V>(entries?: Iterable<[K, V]>) => EnhancedMap<K, V>;
+
+export { type Callback, EnhancedArray, EnhancedMap, type Predicate, collect, collectMap, mapToObject, objectToMap };

package/dist/collections.d.ts

@@ -0,0 +1,353 @@
+/**
+ * Collection utilities for JavaScript arrays and objects
+ * Inspired by Laravel Collections with modern JavaScript features
+ */
+/**
+ * Generic callback type for collection operations.
+ */
+type Callback<T, R> = (item: T, index: number) => R;
+/**
+ * Predicate type for collection filtering and validation.
+ */
+type Predicate<T> = (item: T, index: number) => boolean;
+/**
+ * Enhanced Array class with Laravel Collection-like methods.
+ * Extends the native Array class with additional utility methods for manipulation,
+ * validation, and statistical analysis.
+ */
+declare class EnhancedArray<T> extends Array<T> {
+    protected originalItems: T[];
+    /**
+     * Create a new EnhancedArray instance.
+     *
+     * @param {...T[]} items The items to initialize the collection with
+     */
+    constructor(...items: T[]);
+    /**
+     * Determine if the collection has been modified since initialization or last sync.
+     *
+     * @returns {boolean} True if modified, false otherwise
+     */
+    isDirty(): boolean;
+    /**
+     * Determine if the collection is clean (not modified).
+     *
+     * @returns {boolean} True if not modified, false otherwise
+     */
+    isClean(): boolean;
+    /**
+     * Sync the original items with current items to mark the collection as clean.
+     *
+     * @returns {this} The collection instance
+     */
+    syncOriginal(): this;
+    /**
+     * Compare with another array or collection for equality.
+     *
+     * @param {T[] | EnhancedArray<T>} other The array or collection to compare with
+     * @returns {boolean} True if equivalent, false otherwise
+     */
+    isEquivalent(other: T[] | EnhancedArray<T>): boolean;
+    /**
+     * Create an EnhancedArray from an iterable or array-like object.
+     *
+     * @param {Iterable<T> | ArrayLike<T>} items The items to convert
+     * @returns {EnhancedArray<T>} A new EnhancedArray instance
+     */
+    static from<T>(items: Iterable<T> | ArrayLike<T>): EnhancedArray<T>;
+    /**
+     * Create an EnhancedArray from a variable number of arguments.
+     *
+     * @param {...T[]} items The items to include
+     * @returns {EnhancedArray<T>} A new EnhancedArray instance
+     */
+    static of<T>(...items: T[]): EnhancedArray<T>;
+    /**
+     * Create a new collection instance from the current items.
+     *
+     * @returns {EnhancedArray<T>} A new EnhancedArray instance
+     */
+    collect(): EnhancedArray<T>;
+    /**
+     * Pluck an array of values from an array of objects.
+     *
+     * @param {K} key The key to pluck
+     * @returns {EnhancedArray<T[K]>} A new collection of plucked values
+     */
+    pluck<K extends keyof T>(key: K): EnhancedArray<T[K]>;
+    /**
+     * Group the collection's items by a given key or callback.
+     *
+     * @param {K | Callback<T, string | number>} key The key or callback to group by
+     * @returns {Record<string, EnhancedArray<T>>} A record of grouped collections
+     */
+    groupBy<K extends keyof T>(key: K | Callback<T, string | number>): Record<string, EnhancedArray<T>>;
+    /**
+     * Return only unique items from the collection.
+     *
+     * @param {K} [key] Optional key to determine uniqueness for objects
+     * @returns {EnhancedArray<T>} A new collection of unique items
+     */
+    unique<K extends keyof T>(key?: K): EnhancedArray<T>;
+    /**
+     * Chunk the collection into smaller collections of a given size.
+     *
+     * @param {number} size The size of each chunk
+     * @returns {EnhancedArray<EnhancedArray<T>>} A collection of chunked collections
+     */
+    chunk(size: number): EnhancedArray<EnhancedArray<T>>;
+    /**
+     * Flatten a multi-dimensional collection into a single level.
+     *
+     * @param {number} [depth=Infinity] The depth to flatten to
+     * @returns {EnhancedArray<unknown>} A new flattened collection
+     */
+    deepFlatten(depth?: number): EnhancedArray<unknown>;
+    /**
+     * Rotate the collection by a given number of positions.
+     *
+     * @param {number} [positions=1] The number of positions to rotate
+     * @returns {EnhancedArray<T>} A new rotated collection
+     */
+    rotate(positions?: number): EnhancedArray<T>;
+    /**
+     * Chunk the collection as long as the given predicate returns true.
+     *
+     * @param {Predicate<T>} predicate The predicate to check
+     * @returns {EnhancedArray<EnhancedArray<T>>} A collection of chunked collections
+     */
+    chunkWhile(predicate: Predicate<T>): EnhancedArray<EnhancedArray<T>>;
+    /**
+     * Transpose the collection (swap rows and columns).
+     *
+     * @returns {EnhancedArray<EnhancedArray<unknown>>} A new transposed collection
+     */
+    transpose(): EnhancedArray<EnhancedArray<unknown>>;
+    /**
+     * Check if the collection is sorted.
+     *
+     * @param {Function} [compareFn] Optional comparison function
+     * @returns {boolean} True if sorted, false otherwise
+     */
+    isSorted(compareFn?: (a: T, b: T) => number): boolean;
+    /**
+     * Check if the collection contains duplicate items.
+     *
+     * @param {K} [key] Optional key to check for uniqueness in objects
+     * @returns {boolean} True if duplicates found, false otherwise
+     */
+    hasDuplicates<K extends keyof T>(key?: K): boolean;
+    /**
+     * Calculate the median value of the collection.
+     *
+     * @param {Callback<T, number>} [accessor] Optional accessor for non-numeric items
+     * @returns {number | null} The median value or null if collection is empty
+     */
+    median(accessor?: Callback<T, number>): number | null;
+    /**
+     * Calculate the mode (most frequent values) of the collection.
+     *
+     * @param {Callback<T, unknown>} [accessor] Optional accessor for the values
+     * @returns {EnhancedArray<unknown>} A collection of mode values
+     */
+    mode(accessor?: Callback<T, unknown>): EnhancedArray<unknown>;
+    /**
+     * Calculate the standard deviation of the collection.
+     *
+     * @param {Callback<T, number>} [accessor] Optional accessor for non-numeric items
+     * @returns {number} The standard deviation
+     */
+    standardDeviation(accessor?: Callback<T, number>): number;
+    /**
+     * Calculate a specific percentile of the collection.
+     *
+     * @param {number} percentile The percentile to calculate (0-100)
+     * @param {Callback<T, number>} [accessor] Optional accessor for non-numeric items
+     * @returns {number | null} The percentile value or null if collection is empty
+     */
+    percentile(percentile: number, accessor?: Callback<T, number>): number | null;
+    /**
+     * Calculate the frequencies of items in the collection.
+     *
+     * @param {Callback<T, unknown>} [accessor] Optional accessor for the values
+     * @returns {Record<string, number>} A record of values and their frequencies
+     */
+    frequencies(accessor?: Callback<T, unknown>): Record<string, number>;
+    /**
+     * Calculate the Cartesian product of the collection and other arrays.
+     *
+     * @param {...U[][]} arrays The arrays to calculate the product with
+     * @returns {EnhancedArray<[T, ...U[]]>} A collection of product combinations
+     */
+    cartesian<U>(...arrays: U[][]): EnhancedArray<[T, ...U[]]>;
+    /**
+     * Interleave the collection with other arrays.
+     *
+     * @param {...U[][]} arrays The arrays to interleave with
+     * @returns {EnhancedArray<T | U>} A new interleaved collection
+     */
+    interleave<U>(...arrays: U[][]): EnhancedArray<T | U>;
+    /**
+     * Get a sliding window of items from the collection.
+     *
+     * @param {number} [size=2] The size of the window
+     * @param {number} [step=1] The step between windows
+     * @returns {EnhancedArray<EnhancedArray<T>>} A collection of window collections
+     */
+    sliding(size?: number, step?: number): EnhancedArray<EnhancedArray<T>>;
+    /**
+     * Get the item at the given index.
+     *
+     * @param {number} index The index to retrieve
+     * @returns {T | undefined} The item at the index or undefined
+     */
+    at(index: number): T | undefined;
+    /**
+     * Get the item before the given item.
+     *
+     * @param {T} item The item to search for
+     * @returns {T | undefined} The item before or undefined
+     */
+    before(item: T): T | undefined;
+    /**
+     * Get the item after the given item.
+     *
+     * @param {T} item The item to search for
+     * @returns {T | undefined} The item after or undefined
+     */
+    after(item: T): T | undefined;
+    /**
+     * Chunk the collection by a given key or callback when its value changes.
+     *
+     * @param {K | Callback<T, unknown>} key The key or callback to chunk by
+     * @returns {EnhancedArray<EnhancedArray<T>>} A collection of chunked collections
+     */
+    chunkBy<K extends keyof T>(key: K | Callback<T, unknown>): EnhancedArray<EnhancedArray<T>>;
+    /**
+     * Map and filter the collection simultaneously.
+     * Items for which the callback returns null or undefined are removed.
+     *
+     * @param {Function} callback The callback to map items
+     * @returns {EnhancedArray<U>} A new mapped and filtered collection
+     */
+    filterMap<U>(callback: (item: T, index: number) => U | null | undefined): EnhancedArray<U>;
+    /**
+     * Extract a subset of properties from each item in the collection.
+     *
+     * @param {K[]} keys The keys to extract
+     * @returns {EnhancedArray<Partial<T>>} A new collection of partial items
+     */
+    extract<K extends keyof T>(keys: K[]): EnhancedArray<Partial<T>>;
+    /**
+     * Get the first item or push a default item if the collection is empty.
+     *
+     * @param {T} item The default item to push if empty
+     * @returns {T} The first item or the pushed item
+     */
+    firstOrPush(item: T): T;
+    /**
+     * Get every n-th item from the collection.
+     *
+     * @param {number} n The step size
+     * @returns {EnhancedArray<T>} A new collection of every n-th item
+     */
+    getNth(n: number): EnhancedArray<T>;
+    /**
+     * Get a random item from the collection based on weights.
+     *
+     * @param {number[]} [weights] Optional weights for each item
+     * @returns {T | undefined} A random item or undefined if collection is empty
+     */
+    weightedRandom(weights?: number[]): T | undefined;
+    /**
+     * Paginate the collection items.
+     *
+     * @param {number} perPage Items per page
+     * @param {number} [page=1] Current page number
+     * @returns {Object} Pagination results
+     */
+    paginate(perPage: number, page?: number): {
+        data: EnhancedArray<T>;
+        total: number;
+        perPage: number;
+        currentPage: number;
+        lastPage: number;
+        from: number;
+        to: number;
+    };
+    /**
+     * Recursively convert all nested arrays to EnhancedArray instances.
+     *
+     * @returns {EnhancedArray<unknown>} A new collection with recursive EnhancedArrays
+     */
+    recursive(): EnhancedArray<unknown>;
+}
+/**
+ * Convert a plain object to a Map.
+ *
+ * @param {Record<string, T>} obj The object to convert
+ * @returns {Map<string, T>} A new Map instance
+ */
+declare const objectToMap: <T>(obj: Record<string, T>) => Map<string, T>;
+/**
+ * Convert a Map to a plain object.
+ *
+ * @param {Map<string, T>} map The Map to convert
+ * @returns {Record<string, T>} A new plain object
+ */
+declare const mapToObject: <T>(map: Map<string, T>) => Record<string, T>;
+/**
+ * Enhanced Map class with additional collection-like methods.
+ * Extends the native Map class.
+ */
+declare class EnhancedMap<K, V> extends Map<K, V> {
+    /**
+     * Create an EnhancedMap from a plain object.
+     *
+     * @param {Record<string, V>} obj The object to convert
+     * @returns {EnhancedMap<string, V>} A new EnhancedMap instance
+     */
+    static fromObject<V>(obj: Record<string, V>): EnhancedMap<string, V>;
+    /**
+     * Pluck a property from each value in the map.
+     *
+     * @param {P} key The key to pluck
+     * @returns {EnhancedArray<V[P]>} A new collection of plucked values
+     */
+    pluck<P extends keyof V>(key: P): EnhancedArray<V[P]>;
+    /**
+     * Group the map's entries by a given accessor.
+     *
+     * @param {Function} accessor The accessor to group by
+     * @returns {Record<string, EnhancedArray<[K, V]>>} A record of grouped entries
+     */
+    groupBy(accessor: (value: V, key: K) => string | number): Record<string, EnhancedArray<[K, V]>>;
+    /**
+     * Convert the map to an array of entries.
+     *
+     * @returns {EnhancedArray<[K, V]>} A collection of entries
+     */
+    toArray(): EnhancedArray<[K, V]>;
+    /**
+     * Convert the map to a plain object.
+     *
+     * @returns {Record<string, V>} A plain object representation of the map
+     */
+    toObject(): Record<string, V>;
+}
+/**
+ * Create a new EnhancedArray from an array of items.
+ *
+ * @param {T[]} items The items to collect
+ * @returns {EnhancedArray<T>} A new EnhancedArray instance
+ */
+declare const collect: <T>(items: T[]) => EnhancedArray<T>;
+/**
+ * Create a new EnhancedMap from an iterable of entries.
+ *
+ * @param {Iterable<[K, V]>} [entries] Optional entries to initialize the map
+ * @returns {EnhancedMap<K, V>} A new EnhancedMap instance
+ */
+declare const collectMap: <K, V>(entries?: Iterable<[K, V]>) => EnhancedMap<K, V>;
+
+export { type Callback, EnhancedArray, EnhancedMap, type Predicate, collect, collectMap, mapToObject, objectToMap };