@oscarpalmer/atoms 0.74.1 → 0.76.0

package/types/array/index.d.cts

@@ -1,194 +1,338 @@
 // Generated by dts-bundle-generator v9.5.1
 
+export type KeyedValue<Item, Key extends keyof Item> = Item[Key] extends PropertyKey ? Item[Key] : never;
 export type NestedArrayType<Value> = Value extends Array<infer NestedValue> ? NestedArrayType<NestedValue> : Value;
 export type Key = number | string;
 /**
- * Chunks an array into smaller arrays of a specified size
+ * Chunk an array _(into smaller arrays of a specified size)_
  */
-export declare function chunk<Value>(array: Value[], size?: number): Value[][];
+export declare function chunk<Item>(array: Item[], size?: number): Item[][];
 /**
- * Compacts and returns an array with all falsey values removed
+ * Compact an array _(removing all `null` and `undefined` values)_
  */
-export declare function compact<Value>(array: Value[], strict: true): Exclude<Value, 0 | "" | false | null | undefined>[];
+export declare function compact<Item>(array: Item[]): Exclude<Item, null | undefined>[];
 /**
- * Compacts and returns an array with all `null` and `undefined` values removed
+ * Compact an array _(removing all falsey values)_
  */
-export declare function compact<Value>(array: Value[]): Exclude<Value, null | undefined>[];
-export type ArrayCallback<Value, Returned> = (value: Value, index: number, array: Value[]) => Returned;
-export type BooleanCallback<Value> = ArrayCallback<Value, boolean>;
-export type KeyCallback<Value> = ArrayCallback<Value, Key>;
-export type SortKey<Value> = {
+export declare function compact<Item>(array: Item[], strict: true): Exclude<Item, 0 | "" | false | null | undefined>[];
+export type ArrayCallback<Item, Value> = (item: Item, index: number, array: Item[]) => Value;
+export type BooleanCallback<Item> = ArrayCallback<Item, boolean>;
+export type KeyCallback<Item> = ArrayCallback<Item, Key>;
+export type SortKey<Item> = {
 	direction: "asc" | "desc";
-	value: Key | SortKeyCallback<Value>;
+	value: Key | SortKeyCallback<Item>;
 };
-export type SortKeyCallback<Value> = (value: Value) => Key;
+export type SortKeyCallback<Item> = (item: Item) => unknown;
+export type ValueCallback<Item> = ArrayCallback<Item, unknown>;
 /**
- * Returns the number of items _(count)_ that match the given value
+ * Get the number of items _(count)_ that match the given value
  */
-export declare function count<Model, Value>(array: Model[], value: Value | BooleanCallback<Model>): number;
+export declare function count<Item>(array: Item[], value: Item): number;
 /**
- * - Returns the number of items _(count)_ that match the given value
- * - Use `key` to find a comparison value to match with `value`
+ * Get the number of items _(count)_ that match the given value
+ */
+export declare function count<Item>(array: Item[], matches: BooleanCallback<Item>): number;
+/**
+ * Get the number of items _(count)_ that match the given value
  */
-export declare function count<Model, Value = Model>(array: Model[], value: Value, key: Key | KeyCallback<Model>): number;
+export declare function count<Item, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): number;
+/**
+ * Get the number of items _(count)_ that match the given value
+ */
+export declare function count<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key, value: ReturnType<Key>): number;
 /**
  * Does the value exist in array?
  */
-export declare function exists<Model, Value>(array: Model[], value: Value | BooleanCallback<Model>): boolean;
+export declare function exists<Item>(array: Item[], value: Item): boolean;
+/**
+ * Does the value exist in array?
+ */
+export declare function exists<Item>(array: Item[], matches: BooleanCallback<Item>): boolean;
 /**
  * - Does the value exist in array?
  * - Use `key` to find a comparison value to match with `value`
  */
-export declare function exists<Model, Value = Model>(array: Model[], value: Value, key: Key | KeyCallback<Model>): boolean;
+export declare function exists<Item, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): boolean;
 /**
- * Returns a filtered array of items matching `value`
+ * - Does the value exist in array?
+ * - Use `key` to find a comparison value to match with `value`
  */
-export declare function filter<Model, Value>(array: Model[], value: Value | BooleanCallback<Model>): Model[];
+export declare function exists<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key, value: ReturnType<Key>): boolean;
 /**
- * - Returns a filtered array of items
+ * Get a filtered array of items matching `value`
+ */
+export declare function filter<Item>(array: Item[], value: Item): Item[];
+/**
+ * Get a filtered array of items matching `value`
+ */
+export declare function filter<Item>(array: Item[], matches: BooleanCallback<Item>): Item[];
+/**
+ * - Get a filtered array of items
+ * - Use `key` to find a comparison value to match with `value`
+ */
+export declare function filter<Item, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): Item[];
+/**
+ * - Get a filtered array of items
  * - Use `key` to find a comparison value to match with `value`
  */
-export declare function filter<Model, Value = Model>(array: Model[], value: Value, key: Key | KeyCallback<Model>): Model[];
+export declare function filter<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key, value: ReturnType<Key>): Item[];
+/**
+ * Get the first item matching `value` _(or `undefined` if no match is found)_
+ */
+export declare function find<Item>(array: Item[], value: Item): Item | undefined;
+/**
+ * Get the first item matching `value` _(or `undefined` if no match is found)_
+ */
+export declare function find<Item>(array: Item[], matches: BooleanCallback<Item>): Item | undefined;
 /**
- * Returns the first item matching `value`, or `undefined` if no match is found
+ * - Get the first matching item _(or `undefined` if no match is found)_
+ * - Use `key` to find a comparison value to match with `value`
  */
-export declare function find<Model, Value>(array: Model[], value: Value | BooleanCallback<Model>): Model | undefined;
+export declare function find<Item, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): Item | undefined;
 /**
- * - Returns the first matching item, or `undefined` if no match is found
+ * - Get the first matching item _(or `undefined` if no match is found)_
  * - Use `key` to find a comparison value to match with `value`
  */
-export declare function find<Model, Value = Model>(array: Model[], value: Value, key: Key | KeyCallback<Model>): Model | undefined;
+export declare function find<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key, value: ReturnType<Key>): Item | undefined;
+/**
+ * Create a record from an array of items using a specific key
+ */
+export declare function groupBy<Item, Key extends keyof Item>(array: Item[], key: Key): Record<KeyedValue<Item, Key>, Item>;
+/**
+ * Create a record from an array of items using a specific key, and grouping them into arrays
+ */
+export declare function groupBy<Item, Key extends keyof Item>(array: Item[], key: Key, arrays: true): Record<KeyedValue<Item, Key>, Item[]>;
+/**
+ * Create a record from an array of items using a specific key
+ */
+export declare function groupBy<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key): Record<ReturnType<Key>, Item>;
+/**
+ * Create a record from an array of items using a specific key, and grouping them into arrays
+ */
+export declare function groupBy<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key, arrays: true): Record<ReturnType<Key>, Item[]>;
+/**
+ * Create a record from an array of items using a specific key and value
+ */
+export declare function groupBy<Item, Key extends keyof Item, Value extends keyof Item>(array: Item[], key: Key, value: Value): Record<KeyedValue<Item, Key>, KeyedValue<Item, Value>>;
+/**
+ * Create a record from an array of items using a specific key and value, and grouping them into arrays
+ */
+export declare function groupBy<Item, Key extends keyof Item, Value extends keyof Item>(array: Item[], key: Key, value: Value, arrays: true): Record<KeyedValue<Item, Key>, Array<KeyedValue<Item, Value>>>;
+/**
+ * Create a record from an array of items using a specific key and value
+ */
+export declare function groupBy<Item, Key extends keyof Item, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value): Record<KeyedValue<Item, Key>, ReturnType<Value>>;
+/**
+ * Create a record from an array of items using a specific key and value, and grouping them into arrays
+ */
+export declare function groupBy<Item, Key extends keyof Item, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value, arrays: true): Record<KeyedValue<Item, Key>, Array<ReturnType<Value>>>;
+/**
+ * Create a record from an array of items using a specific key and value
+ */
+export declare function groupBy<Item, Key extends KeyCallback<Item>, Value extends keyof Item>(array: Item[], key: Key, value: Value): Record<ReturnType<Key>, KeyedValue<Item, Value>>;
+/**
+ * Create a record from an array of items using a specific key and value, and grouping them into arrays
+ */
+export declare function groupBy<Item, Key extends KeyCallback<Item>, Value extends keyof Item>(array: Item[], key: Key, value: Value, arrays: true): Record<ReturnType<Key>, Array<KeyedValue<Item, Value>>>;
 /**
- * Groups an array of items using a key or callback
+ * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<Value>(array: Value[], key: Key | KeyCallback<Value>): Record<Key, Value[]>;
+export declare function groupBy<Item, Key extends KeyCallback<Item>, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value): Record<ReturnType<Key>, ReturnType<Value>>;
 /**
- * Returns the index for the first item matching `value`, or `-1` if no match is found
+ * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function indexOf<Model, Value>(array: Model[], value: Value | BooleanCallback<Model>): number;
+export declare function groupBy<Item, Key extends KeyCallback<Item>, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value, arrays: true): Record<ReturnType<Key>, Array<ReturnType<Value>>>;
 /**
- * - Returns the index for the first matching item, or `-1` if no match is found
+ * Get the index for the first item matching `value` _(or `-1` if no match is found)_
+ */
+export declare function indexOf<Item>(array: Item[], value: Item): number;
+/**
+ * Get the index for the first item matching `value` _(or `-1` if no match is found)_
+ */
+export declare function indexOf<Item>(array: Item[], matches: BooleanCallback<Item>): number;
+/**
+ * - Get the index for the first matching item _(or `-1` if no match is found)_
  * - Use `key` to find a comparison value to match with `value`
  */
-export declare function indexOf<Model, Value = Model>(array: Model[], value: Value, key: Key | KeyCallback<Model>): number;
+export declare function indexOf<Item, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): number;
 /**
- * - Inserts values into an array at a specified index
- * - Uses chunking to avoid stack overflow
+ * - Get the index for the first matching item _(or `-1` if no match is found)_
+ * - Use `key` to find a comparison value to match with `value`
  */
-export declare function insert<Value>(array: Value[], index: number, values: Value[]): void;
+export declare function indexOf<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key, value: ReturnType<Key>): number;
 /**
- * Shuffles an array
+ * - Insert values into an array _(at the end)_
+ * - _(Uses chunking to avoid stack overflow_)
  */
-export declare function shuffle<Value>(array: Value[]): Value[];
+export declare function insert<Item>(array: Item[], items: Item[]): void;
 /**
- * Sorts an array of items _(ascending by default)_
+ * - Insert values into an array at a specified index
+ * - _(Uses chunking to avoid stack overflow_)
  */
-export declare function sort<Value>(array: Value[], descending?: boolean): Value[];
+export declare function insert<Item>(array: Item[], index: number, items: Item[]): void;
 /**
- * - Sorts an array of items, using a `key` to sort by a specific value
- * - Ascending by default, but can be changed by setting `descending` to `true`, or using a `SortKey`
+ * Shuffle an array
  */
-export declare function sort<Value>(array: Value[], key: Key | SortKey<Value> | SortKeyCallback<Value>, descending?: boolean): Value[];
+export declare function shuffle<Item>(array: Item[]): Item[];
 /**
- * - Sorts an array of items, using multiple `keys` to sort by specific values
- * - Ascending by default, but can be changed by setting `descending` to `true`, or using `SortKey`
+ * Sort an array of items _(defaults to ascending)_
  */
-export declare function sort<Value>(array: Value[], keys: Array<Key | SortKey<Value> | SortKeyCallback<Value>>, descending?: boolean): Value[];
+export declare function sort<Item>(array: Item[], descending?: boolean): Item[];
+/**
+ * - Sort an array of items, using a `key` to sort by a specific value
+ * - Defaults to ascending, but can be changed by setting `descending` to `true`, or using a `SortKey`
+ */
+export declare function sort<Item>(array: Item[], key: Key | SortKey<Item> | SortKeyCallback<Item>, descending?: boolean): Item[];
+/**
+ * - Sort an array of items, using multiple `keys` to sort by specific values
+ * - Defaults to ascending, but can be changed by setting `descending` to `true`, or using `SortKey`
+ */
+export declare function sort<Item>(array: Item[], keys: Array<Key | SortKey<Item> | SortKeyCallback<Item>>, descending?: boolean): Item[];
 /**
  * Removes and returns all items from an array starting from a specific index
  */
-export declare function splice<Value>(array: Value[], start: number): Value[];
+export declare function splice<Item>(array: Item[], start: number): Item[];
 /**
  * Removes and returns _(up to)_ a specific amount of items from an array, starting from a specific index
  */
-export declare function splice<Value>(array: Value[], start: number, amount: number): Value[];
+export declare function splice<Item>(array: Item[], start: number, amount: number): Item[];
 /**
  * - Splices values into an array and returns any removed values
  * - Uses chunking to avoid stack overflow
  */
-export declare function splice<Value>(array: Value[], start: number, values: Value[]): Value[];
+export declare function splice<Item>(array: Item[], start: number, added: Item[]): Item[];
 /**
  * - Splices values into an array and returns any removed values
  * - Uses chunking to avoid stack overflow
  */
-export declare function splice<Value>(array: Value[], start: number, amount: number, values: Value[]): Value[];
+export declare function splice<Item>(array: Item[], start: number, amount: number, added: Item[]): Item[];
+/**
+ * Create a map from an array of items _(using their indices as keys)_
+ */
+export declare function toMap<Item>(array: Item[]): Map<number, Item>;
+/**
+ * Create a map from an array of items using a specific key
+ */
+export declare function toMap<Item, Key extends keyof Item>(array: Item[], key: Key): Map<KeyedValue<Item, Key>, Item>;
+/**
+ * Create a map from an array of items using a specific key, and grouping them into arrays
+ */
+export declare function toMap<Item, Key extends keyof Item>(array: Item[], key: Key, arrays: true): Map<KeyedValue<Item, Key>, Item[]>;
+/**
+ * Create a map from an array of items using a specific key
+ */
+export declare function toMap<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key): Map<ReturnType<Key>, Item>;
+/**
+ * Create a map from an array of items using a specific key, and grouping them into arrays
+ */
+export declare function toMap<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key, arrays: true): Map<ReturnType<Key>, Item[]>;
+/**
+ * Create a map from an array of items using a specific key and value
+ */
+export declare function toMap<Item, Key extends keyof Item, Value extends keyof Item>(array: Item[], key: Key, value: Value): Map<KeyedValue<Item, Key>, KeyedValue<Item, Value>>;
+/**
+ * Create a map from an array of items using a specific key and value, and grouping them into arrays
+ */
+export declare function toMap<Item, Key extends keyof Item, Value extends keyof Item>(array: Item[], key: Key, value: Value, arrays: true): Map<KeyedValue<Item, Key>, Array<KeyedValue<Item, Value>>>;
+/**
+ * Create a map from an array of items using a specific key and value
+ */
+export declare function toMap<Item, Key extends keyof Item, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value): Map<KeyedValue<Item, Key>, ReturnType<Value>>;
+/**
+ * Create a map from an array of items using a specific key and value, and grouping them into arrays
+ */
+export declare function toMap<Item, Key extends keyof Item, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value, arrays: true): Map<KeyedValue<Item, Key>, Array<ReturnType<Value>>>;
+/**
+ * Create a map from an array of items using a specific key and value
+ */
+export declare function toMap<Item, Key extends KeyCallback<Item>, Value extends keyof Item>(array: Item[], key: Key, value: Value): Map<ReturnType<Key>, KeyedValue<Item, Value>>;
+/**
+ * Create a map from an array of items using a specific key and value, and grouping them into arrays
+ */
+export declare function toMap<Item, Key extends KeyCallback<Item>, Value extends keyof Item>(array: Item[], key: Key, value: Value, arrays: true): Map<ReturnType<Key>, Array<KeyedValue<Item, Value>>>;
 /**
- * Converts an array into a map, using indices as keys
+ * Create a map from an array of items using a specific key and value
  */
-export declare function toMap<Value>(array: Value[]): Map<number, Value>;
+export declare function toMap<Item, Key extends KeyCallback<Item>, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value): Map<ReturnType<Key>, ReturnType<Value>>;
 /**
- * Converts an array into a map, using indices as keys and grouping values into arrays
+ * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toMap<Value>(array: Value[], arrays: true): Map<number, Value[]>;
+export declare function toMap<Item, Key extends KeyCallback<Item>, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value, arrays: true): Map<ReturnType<Key>, Array<ReturnType<Value>>>;
 /**
- * - Converts an array into a map
- * - Uses `key` to find an identifcation value to use as keys
+ * Create a record from an array of items _(using their indices as keys)_
  */
-export declare function toMap<Value>(array: Value[], key: Key): Map<Key, Value>;
+export declare function toRecord<Item>(array: Item[]): Record<number, Item>;
 /**
- * - Converts an array into a map
- * - Uses `key` to find an identifcation value to use as keys
- * - Groups values into arrays
+ * Create a record from an array of items using a specific key
  */
-export declare function toMap<Value>(array: Value[], key: Key, arrays: true): Map<Key, Value[]>;
+export declare function toRecord<Item, Key extends keyof Item>(array: Item[], key: Key): Record<KeyedValue<Item, Key>, Item>;
 /**
- * - Converts an array into a map
- * - Uses `key` to find an identifcation value to use as keys
+ * Create a record from an array of items using a specific key, and grouping them into arrays
  */
-export declare function toMap<Value>(array: Value[], key: KeyCallback<Value>): Map<Key, Value>;
+export declare function toRecord<Item, Key extends keyof Item>(array: Item[], key: Key, arrays: true): Record<KeyedValue<Item, Key>, Item[]>;
 /**
- * - Converts an array into a map
- * - Uses `key` to find an identifcation value to use as keys
- * - Groups values into arrays
+ * Create a record from an array of items using a specific key
  */
-export declare function toMap<Value>(array: Value[], key: KeyCallback<Value>, arrays: true): Map<Key, Value[]>;
+export declare function toRecord<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key): Record<ReturnType<Key>, Item>;
 /**
- * Converts an array into a record, using indices as keys
+ * Create a record from an array of items using a specific key, and grouping them into arrays
  */
-export declare function toRecord<Value>(array: Value[]): Record<number, Value>;
+export declare function toRecord<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key, arrays: true): Record<ReturnType<Key>, Item[]>;
 /**
- * Converts an array into a record, using indices as keys and grouping values into arrays
+ * Create a record from an array of items using a specific key and value
  */
-export declare function toRecord<Value>(array: Value[], arrays: true): Record<number, Value[]>;
+export declare function toRecord<Item, Key extends keyof Item, Value extends keyof Item>(array: Item[], key: Key, value: Value): Record<KeyedValue<Item, Key>, KeyedValue<Item, Value>>;
 /**
- * - Converts an array into a record
- * - Uses `key` to find an identifcation value to use as keys
+ * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toRecord<Value>(array: Value[], key: Key): Record<Key, Value>;
+export declare function toRecord<Item, Key extends keyof Item, Value extends keyof Item>(array: Item[], key: Key, value: Value, arrays: true): Record<KeyedValue<Item, Key>, Array<KeyedValue<Item, Value>>>;
 /**
- * - Converts an array into a record
- * - Uses `key` to find an identifcation value to use as keys
- * - Groups values into arrays
+ * Create a record from an array of items using a specific key and value
  */
-export declare function toRecord<Value>(array: Value[], key: Key, arrays: true): Record<Key, Value[]>;
+export declare function toRecord<Item, Key extends keyof Item, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value): Record<KeyedValue<Item, Key>, ReturnType<Value>>;
 /**
- * - Converts an array into a record
- * - Uses `key` to find an identifcation value to use as keys
+ * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toRecord<Value>(array: Value[], key: KeyCallback<Value>): Record<Key, Value>;
+export declare function toRecord<Item, Key extends keyof Item, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value, arrays: true): Record<KeyedValue<Item, Key>, Array<ReturnType<Value>>>;
 /**
- * - Converts an array into a record
- * - Uses `key` to find an identifcation value to use as keys
- * - Groups values into arrays
+ * Create a record from an array of items using a specific key and value
  */
-export declare function toRecord<Value>(array: Value[], key: KeyCallback<Value>, arrays: true): Record<Key, Value[]>;
+export declare function toRecord<Item, Key extends KeyCallback<Item>, Value extends keyof Item>(array: Item[], key: Key, value: Value): Record<ReturnType<Key>, KeyedValue<Item, Value>>;
 /**
- * Returns an array of unique items
+ * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function unique<Value>(array: Value[]): Value[];
+export declare function toRecord<Item, Key extends KeyCallback<Item>, Value extends keyof Item>(array: Item[], key: Key, value: Value, arrays: true): Record<ReturnType<Key>, Array<KeyedValue<Item, Value>>>;
 /**
- * - Returns an array of unique items
+ * Create a record from an array of items using a specific key and value
+ */
+export declare function toRecord<Item, Key extends KeyCallback<Item>, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value): Record<ReturnType<Key>, ReturnType<Value>>;
+/**
+ * Create a record from an array of items using a specific key and value, and grouping them into arrays
+ */
+export declare function toRecord<Item, Key extends KeyCallback<Item>, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value, arrays: true): Record<ReturnType<Key>, Array<ReturnType<Value>>>;
+/**
+ * Get an array of unique items
+ */
+export declare function unique<Item>(array: Item[]): Item[];
+/**
+ * - Get an array of unique items
  * - Use `key` to find a comparison value to match with `value`
  */
-export declare function unique<Value>(array: Value[], key: Key | KeyCallback<Value>): Value[];
+export declare function unique<Item, Key extends keyof Item>(array: Item[], key: Key): Item[];
 /**
- * Flattens an array _(using native `flat` and maximum depth)_
+ * - Get an array of unique items
+ * - Use `key` to find a comparison value to match with `value`
  */
-export declare function flatten<Value>(array: Value[]): NestedArrayType<Value>[];
+export declare function unique<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key): Item[];
 /**
- * - Pushes values to the end of an array, returning the new length
- * - Uses chunking to avoid stack overflow
+ * Flatten an array _(using native `flat` and maximum depth)_
+ */
+export declare function flatten<Item>(array: Item[]): NestedArrayType<Item>[];
+/**
+ * - Push values to the end of an array
+ * - Returns the new length
+ * - _(Uses chunking to avoid stack overflow)_
  */
-export declare function push<Value>(array: Value[], values: Value[]): number;
+export declare function push<Item>(array: Item[], pushed: Item[]): number;
 
 export {};

package/types/array/index.d.ts

@@ -1,13 +1,14 @@
-import type { NestedArrayType } from '../models';
+import type { NestedArrayType } from '~/models';
 /**
- * Flattens an array _(using native `flat` and maximum depth)_
+ * Flatten an array _(using native `flat` and maximum depth)_
  */
-export declare function flatten<Value>(array: Value[]): NestedArrayType<Value>[];
+export declare function flatten<Item>(array: Item[]): NestedArrayType<Item>[];
 /**
- * - Pushes values to the end of an array, returning the new length
- * - Uses chunking to avoid stack overflow
+ * - Push values to the end of an array
+ * - Returns the new length
+ * - _(Uses chunking to avoid stack overflow)_
  */
-export declare function push<Value>(array: Value[], values: Value[]): number;
+export declare function push<Item>(array: Item[], pushed: Item[]): number;
 export * from './chunk';
 export * from './compact';
 export * from './count';

package/types/array/insert.d.cts

@@ -0,0 +1,16 @@
+// Generated by dts-bundle-generator v9.5.1
+
+export type InsertType = "push" | "splice";
+/**
+ * - Insert values into an array _(at the end)_
+ * - _(Uses chunking to avoid stack overflow_)
+ */
+export declare function insert<Item>(array: Item[], items: Item[]): void;
+/**
+ * - Insert values into an array at a specified index
+ * - _(Uses chunking to avoid stack overflow_)
+ */
+export declare function insert<Item>(array: Item[], index: number, items: Item[]): void;
+export declare function insertValues<Item>(type: InsertType, array: Item[], items: Item[], start: number, deleteCount: number): unknown;
+
+export {};

package/types/array/insert.d.ts

@@ -1,7 +1,12 @@
-import type { InsertType } from './models';
+import type { InsertType } from '~/array/models';
 /**
- * - Inserts values into an array at a specified index
- * - Uses chunking to avoid stack overflow
+ * - Insert values into an array _(at the end)_
+ * - _(Uses chunking to avoid stack overflow_)
  */
-export declare function insert<Value>(array: Value[], index: number, values: Value[]): void;
-export declare function insertValues<Value>(type: InsertType, array: Value[], values: Value[], start: number, deleteCount: number): unknown;
+export declare function insert<Item>(array: Item[], items: Item[]): void;
+/**
+ * - Insert values into an array at a specified index
+ * - _(Uses chunking to avoid stack overflow_)
+ */
+export declare function insert<Item>(array: Item[], index: number, items: Item[]): void;
+export declare function insertValues<Item>(type: InsertType, array: Item[], items: Item[], start: number, deleteCount: number): unknown;

package/types/array/models.d.cts

@@ -1,23 +1,26 @@
 // Generated by dts-bundle-generator v9.5.1
 
+export type GenericCallback = (...args: any[]) => any;
 export type Key = number | string;
-export type ArrayCallback<Value, Returned> = (value: Value, index: number, array: Value[]) => Returned;
-export type BooleanCallback<Value> = ArrayCallback<Value, boolean>;
-export type Callbacks<Value> = {
-	bool?: BooleanCallback<Value>;
-	key?: KeyCallback<Value>;
+export type ArrayCallback<Item, Value> = (item: Item, index: number, array: Item[]) => Value;
+export type BooleanCallback<Item> = ArrayCallback<Item, boolean>;
+export type Callbacks = {
+	bool?: GenericCallback;
+	key?: GenericCallback;
+	value?: GenericCallback;
 };
 export type FindType = "index" | "value";
 export type InsertType = "push" | "splice";
-export type KeyCallback<Value> = ArrayCallback<Value, Key>;
-export type SortKey<Value> = {
+export type KeyCallback<Item> = ArrayCallback<Item, Key>;
+export type SortKey<Item> = {
 	direction: "asc" | "desc";
-	value: Key | SortKeyCallback<Value>;
+	value: Key | SortKeyCallback<Item>;
 };
-export type SortKeyCallback<Value> = (value: Value) => Key;
-export type SortKeyWithCallback<Value> = {
-	callback: SortKeyCallback<Value>;
+export type SortKeyCallback<Item> = (item: Item) => unknown;
+export type SortKeyWithCallback<Item> = {
+	callback: SortKeyCallback<Item>;
 	direction: "asc" | "desc";
 };
+export type ValueCallback<Item> = ArrayCallback<Item, unknown>;
 
 export {};

package/types/array/models.d.ts

@@ -1,19 +1,21 @@
-import type { Key } from '../models';
-export type ArrayCallback<Value, Returned> = (value: Value, index: number, array: Value[]) => Returned;
-export type BooleanCallback<Value> = ArrayCallback<Value, boolean>;
-export type Callbacks<Value> = {
-    bool?: BooleanCallback<Value>;
-    key?: KeyCallback<Value>;
+import type { GenericCallback, Key } from '~/models';
+export type ArrayCallback<Item, Value> = (item: Item, index: number, array: Item[]) => Value;
+export type BooleanCallback<Item> = ArrayCallback<Item, boolean>;
+export type Callbacks = {
+    bool?: GenericCallback;
+    key?: GenericCallback;
+    value?: GenericCallback;
 };
 export type FindType = 'index' | 'value';
 export type InsertType = 'push' | 'splice';
-export type KeyCallback<Value> = ArrayCallback<Value, Key>;
-export type SortKey<Value> = {
+export type KeyCallback<Item> = ArrayCallback<Item, Key>;
+export type SortKey<Item> = {
     direction: 'asc' | 'desc';
-    value: Key | SortKeyCallback<Value>;
+    value: Key | SortKeyCallback<Item>;
 };
-export type SortKeyCallback<Value> = (value: Value) => Key;
-export type SortKeyWithCallback<Value> = {
-    callback: SortKeyCallback<Value>;
+export type SortKeyCallback<Item> = (item: Item) => unknown;
+export type SortKeyWithCallback<Item> = {
+    callback: SortKeyCallback<Item>;
     direction: 'asc' | 'desc';
 };
+export type ValueCallback<Item> = ArrayCallback<Item, unknown>;

package/types/array/shuffle.d.cts

@@ -0,0 +1,8 @@
+// Generated by dts-bundle-generator v9.5.1
+
+/**
+ * Shuffle an array
+ */
+export declare function shuffle<Item>(array: Item[]): Item[];
+
+export {};

package/types/array/shuffle.d.ts

@@ -1,4 +1,4 @@
 /**
- * Shuffles an array
+ * Shuffle an array
  */
-export declare function shuffle<Value>(array: Value[]): Value[];
+export declare function shuffle<Item>(array: Item[]): Item[];

package/types/array/sort.d.cts

@@ -0,0 +1,24 @@
+// Generated by dts-bundle-generator v9.5.1
+
+export type Key = number | string;
+export type SortKey<Item> = {
+	direction: "asc" | "desc";
+	value: Key | SortKeyCallback<Item>;
+};
+export type SortKeyCallback<Item> = (item: Item) => unknown;
+/**
+ * Sort an array of items _(defaults to ascending)_
+ */
+export declare function sort<Item>(array: Item[], descending?: boolean): Item[];
+/**
+ * - Sort an array of items, using a `key` to sort by a specific value
+ * - Defaults to ascending, but can be changed by setting `descending` to `true`, or using a `SortKey`
+ */
+export declare function sort<Item>(array: Item[], key: Key | SortKey<Item> | SortKeyCallback<Item>, descending?: boolean): Item[];
+/**
+ * - Sort an array of items, using multiple `keys` to sort by specific values
+ * - Defaults to ascending, but can be changed by setting `descending` to `true`, or using `SortKey`
+ */
+export declare function sort<Item>(array: Item[], keys: Array<Key | SortKey<Item> | SortKeyCallback<Item>>, descending?: boolean): Item[];
+
+export {};