@oscarpalmer/atoms 0.200.0 → 0.202.0

package/dist/index.d.mts

@@ -43,7 +43,23 @@ export type GenericCallback = (...args: any[]) => any;
  * A generic key type
  */
 type Key$1 = number | string;
+/**
+ * The `PropertyKey`-safe value of `Item`'s `ItemKey` property
+ */
 export type KeyedValue<Item, ItemKey extends keyof Item> = Item[ItemKey] extends PropertyKey ? Item[ItemKey] : never;
+/**
+ * A key of `Item`, or a callback returning `Return`, used to derive a value from an item
+ */
+export type KeyOrCallback<Item, Return = unknown> = ((item: Item, index: number, array: Item[]) => Return) | (Item extends PlainObject ? keyof Item : never);
+/**
+ * The `PropertyKey`-safe value resolved from a `KeyOrCallback<Item, Key>` argument, for use as a
+ * `Record` or `Map` key
+ */
+export type KeyOrCallbackKey<Item, Arg extends KeyOrCallback<Item, Key$1>> = Arg extends ((item: Item, index: number, array: Item[]) => Key$1) ? ReturnType<Arg> : Arg extends keyof Item ? KeyedValue<Item, Arg> : never;
+/**
+ * The value resolved from a `KeyOrCallback` argument against `Item`
+ */
+export type KeyOrCallbackValue<Item, Arg extends KeyOrCallback<Item>> = Arg extends ((item: Item, index: number, array: Item[]) => unknown) ? ReturnType<Arg> : Arg extends keyof Item ? Item[Arg] : never;
 /**
  * A nested array
  */
@@ -450,13 +466,13 @@ export declare function firstOrDefault<Item>(array: Item[], defaultValue: Item):
 //#endregion
 //#region src/array/group-by.d.ts
 /**
- * Create a record from an array of items using a specific key and value
+ * Create a record from an array of items using a specific key
  *
  * If multiple items have the same key, the latest item's value will be used
  *
  * @param array Array to group
- * @param key Callback to get an item's grouping key
- * @param value Callback to get an item's value
+ * @param key Callback or key to use for grouping
+ * @param value Callback or key to use for value, defaulting to the item itself
  * @returns Record of keyed values
  *
  * @example
@@ -468,74 +484,14 @@ export declare function firstOrDefault<Item>(array: Item[], defaultValue: Item):
  * ); // => {10: {id: 3, value: 10}, 20: {id: 2, value: 20}}
  * ```
  */
-export declare function groupBy<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Simplify<Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>>>;
-/**
- * Create a record from an array of items using a specific key and value
- *
- * If multiple items have the same key, the latest item's value will be used
- *
- * @param array Array to group
- * @param key Callback to get an item's grouping key
- * @param value Key to use for value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   'id'
- * ); // => {10: 3, 20: 2}
- * ```
- */
-export declare function groupBy<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ItemValue extends keyof Item>(array: Item[], key: KeyCallback, value: ItemValue): Record<ReturnType<KeyCallback>, Item[ItemValue]>;
-/**
- * Create a record from an array of items using a specific key and value
- *
- * If multiple items have the same key, the latest item's value will be used
- *
- * @param array Array to group
- * @param key Key to use for grouping
- * @param value Callback to get an item's value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   item => item,
- * ); // => {10: {id: 3, value: 10}, 20: {id: 2, value: 20}}
- * ```
- */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<ValueCallback>>>;
-/**
- * Create a record from an array of items using a specific key and value
- *
- * If multiple items have the same key, the latest item's value will be used
- *
- * @param array Array to group
- * @param key Key to use for grouping
- * @param value Key to use for value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   'id'
- * ); // => {10: 3, 20: 2}
- * ```
- */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue]>>;
+export declare function groupBy<Item, KeyArg extends KeyOrCallback<Item, Key$1>, ValueArg extends KeyOrCallback<Item>>(array: Item[], key: KeyArg, value: ValueArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, KeyOrCallbackValue<Item, ValueArg>>>;
 /**
  * Create a record from an array of items using a specific key
  *
  * If multiple items have the same key, the latest item will be used
  *
  * @param array Array to group
- * @param callback Callback to get an item's grouping key
+ * @param key Callback or key to use for grouping
  * @returns Record of keyed items
  *
  * @example
@@ -546,25 +502,7 @@ export declare function groupBy<Item extends PlainObject, ItemKey extends keyof
  * ); // => {10: {id: 3, value: 10}, 20: {id: 2, value: 20}}
  * ```
  */
-export declare function groupBy<Item, Callback extends (item: Item, index: number, array: Item[]) => Key$1>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item>;
-/**
- * Create a record from an array of items using a specific key
- *
- * If multiple items have the same key, the latest item will be used
- *
- * @param array Array to group
- * @param key Key to use for grouping
- * @returns Record of keyed items
- *
- * @example
- * ```typescript
- * groupBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- * ); // => {10: {id: 3, value: 10}, 20: {id: 2, value: 20}}
- * ```
- */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item>>;
+export declare function groupBy<Item, KeyArg extends KeyOrCallback<Item, Key$1>>(array: Item[], key: KeyArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, Item>>;
 /**
  * Create a record from an array of items _(using indices as keys)_
  *
@@ -583,36 +521,13 @@ export declare namespace groupBy {
   var arrays: typeof groupArraysBy;
 }
 /**
- * Create a record from an array of items using a specific key and value, grouping values into arrays
- *
- * _Available as `groupArraysBy` and `groupBy.arrays`_
- *
- * @param array Array to group
- * @param key Callback to get an item's grouping key
- * @param value Callback to get an item's value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupArraysBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   item => item,
- * ); // => {
- *    //   10: [{id: 1, value: 10}, {id: 3, value: 10}],
- *    //   20: [{id: 2, value: 20}],
- *    // }
- * ```
- */
-export declare function groupArraysBy<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, Array<ReturnType<ValueCallback>>>;
-/**
- * Create a record from an array of items using a specific key and value, grouping values into arrays
+ * Create a record from an array of items using a specific key, grouping values into arrays
  *
  * _Available as `groupArraysBy` and `groupBy.arrays`_
  *
  * @param array Array to group
- * @param key Callback to get an item's grouping key
- * @param value Key to use for value
+ * @param key Callback or key to use for grouping
+ * @param value Callback or key to use for value, defaulting to the item itself
  * @returns Record of keyed values
  *
  * @example
@@ -620,29 +535,6 @@ export declare function groupArraysBy<Item, KeyCallback extends (item: Item, ind
  * groupArraysBy(
  *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
  *   item => item.value,
- *   'id',
- * ); // => {
- *    //   10: [1, 3],
- *    //   20: [2],
- *    // }
- * ```
- */
-export declare function groupArraysBy<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ItemValue extends keyof Item>(array: Item[], key: KeyCallback, value: ItemValue): Record<ReturnType<KeyCallback>, Item[ItemValue][]>;
-/**
- * Create a record from an array of items using a specific key and value, grouping values into arrays
- *
- * _Available as `groupArraysBy` and `groupBy.arrays`_
- *
- * @param array Array to group
- * @param key Key to use for grouping
- * @param value Callback to get an item's value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupArraysBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
  *   item => item,
  * ); // => {
  *    //   10: [{id: 1, value: 10}, {id: 3, value: 10}],
@@ -650,37 +542,14 @@ export declare function groupArraysBy<Item extends PlainObject, KeyCallback exte
  *    // }
  * ```
  */
-export declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Simplify<Record<KeyedValue<Item, ItemKey>, Array<ReturnType<ValueCallback>>>>;
-/**
- * Create a record from an array of items using a specific key and value, grouping values into arrays
- *
- * _Available as `groupArraysBy` and `groupBy.arrays`_
- *
- * @param array Array to group
- * @param key Key to use for grouping
- * @param value Key to use for value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupArraysBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   'id',
- * ); // => {
- *    //   10: [1, 3],
- *    //   20: [2],
- *    // }
- * ```
- */
-export declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue][]>>;
+export declare function groupArraysBy<Item, KeyArg extends KeyOrCallback<Item, Key$1>, ValueArg extends KeyOrCallback<Item>>(array: Item[], key: KeyArg, value: ValueArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, Array<KeyOrCallbackValue<Item, ValueArg>>>>;
 /**
  * Create a record from an array of items using a specific key, grouping items into arrays
  *
  * _Available as `groupArraysBy` and `groupBy.arrays`_
  *
  * @param array Array to group
- * @param callback Callback to get an item's grouping key
+ * @param key Callback or key to use for grouping
  * @returns Record of keyed items
  *
  * @example
@@ -694,28 +563,7 @@ export declare function groupArraysBy<Item extends PlainObject, ItemKey extends
  *    // }
  * ```
  */
-export declare function groupArraysBy<Item, Callback extends (item: Item, index: number, array: Item[]) => Key$1>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item[]>;
-/**
- * Create a record from an array of items using a specific key, grouping items into arrays
- *
- * _Available as `groupArraysBy` and `groupBy.arrays`_
- *
- * @param array Array to group
- * @param key Key to use for grouping
- * @returns Record of keyed items
- *
- * @example
- * ```typescript
- * groupArraysBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- * ); // => {
- *    //   10: [{id: 1, value: 10}, {id: 3, value: 10}],
- *    //   20: [{id: 2, value: 20}],
- *    // }
- * ```
- */
-export declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
+export declare function groupArraysBy<Item, KeyArg extends KeyOrCallback<Item, Key$1>>(array: Item[], key: KeyArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, Item[]>>;
 //#endregion
 //#region src/internal/array/chunk.d.ts
 /**
@@ -1778,110 +1626,112 @@ export declare function push<Item>(array: Item[], pushed: Item[]): number;
 export declare function reverse<Item>(array: Item[]): Item[];
 //#endregion
 //#region src/array/select.d.ts
+type MapKeyOrCallback<Item> = ((item: Item, index: number, array: Item[]) => unknown) | (Item extends PlainObject ? keyof Item : never);
+type Mapped<Item, Map extends MapKeyOrCallback<Item>> = Map extends ((item: Item, index: number, array: Item[]) => unknown) ? ReturnType<Map> : Map extends keyof Item ? Item[Map] : never;
+type ObjectKeysOf<Item> = { [Key in keyof Item]: Item[Key] extends PlainObject ? Key : never; }[keyof Item];
 /**
- * Get a filtered and mapped array of items
+ * Get a mapped and filtered array of items
  *
  * @param array Array to search in
- * @param filterCallback Callback to get an item's value for matching
+ * @param map Callback or key to map the items
+ * @param filterCallback Callback to get a mapped value's value for matching
  * @param filterValue Value to match against
- * @param mapCallback Callback to map the matched items
- * @returns Filtered and mapped array of items
+ * @returns Mapped and filtered array of items
  *
  * @example
  * ```typescript
- * select(
+ * reverseSelect(
  *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   item => item.id,
- *   2,
  *   item => item.name,
+ *   value => value.length,
+ *   3,
  * ); // => ['Bob']
  * ```
  */
-export declare function select<Item, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, mapCallback: MapCallback): Array<ReturnType<MapCallback>>;
+export declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>, FilterCallback extends (item: Mapped<Item, Map>, index: number, array: Item[]) => unknown>(array: Item[], map: Map, filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>): Array<Mapped<Item, Map>>;
 /**
- * Get a filtered and mapped array of items
+ * Get a mapped and filtered array of items
  *
  * @param array Array to search in
- * @param filterCallback Callback to get an item's value for matching
+ * @param map Callback to map the items
+ * @param filterKey Key to get a mapped value's value for matching
  * @param filterValue Value to match against
- * @param mapKey Key to get an item's value for mapping
- * @returns Filtered and mapped array of items
+ * @returns Mapped and filtered array of items
  *
  * @example
  * ```typescript
- * select(
+ * reverseSelect(
  *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   item => item.id,
- *   2,
- *   'name',
- * ); // => ['Bob']
+ *   item => ({label: item.name}),
+ *   'label',
+ *   'Bob',
+ * ); // => [{label: 'Bob'}]
  * ```
  */
-export declare function select<Item extends PlainObject, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, MapKey extends keyof Item>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, mapKey: MapKey): Array<Item[MapKey]>;
+export declare function reverseSelect<Item, MapCallback extends (item: Item, index: number, array: Item[]) => PlainObject, ItemKey extends keyof ReturnType<MapCallback>>(array: Item[], map: MapCallback, filterKey: ItemKey, filterValue: ReturnType<MapCallback>[ItemKey]): Array<ReturnType<MapCallback>>;
 /**
- * Get a filtered and mapped array of items
+ * Get a mapped and filtered array of items
  *
  * @param array Array to search in
- * @param filterKey Key to get an item's value for matching
+ * @param map Key to map the items
+ * @param filterKey Key to get a mapped value's value for matching
  * @param filterValue Value to match against
- * @param mapCallback Callback to map the matched items
- * @returns Filtered and mapped array of items
+ * @returns Mapped and filtered array of items
  *
  * @example
  * ```typescript
- * select(
- *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   'id',
- *   2,
- *   item => item.name,
- * ); // => ['Bob']
+ * reverseSelect(
+ *   [{meta: {tag: 'a'}}, {meta: {tag: 'b'}}],
+ *   'meta',
+ *   'tag',
+ *   'b',
+ * ); // => [{tag: 'b'}]
  * ```
  */
-export declare function select<Item extends PlainObject, ItemKey extends keyof Item, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], filterKey: ItemKey, filterValue: Item[ItemKey], mapCallback: MapCallback): Array<ReturnType<MapCallback>>;
+export declare function reverseSelect<Item, MapKey extends ObjectKeysOf<Item>, ItemKey extends keyof Item[MapKey]>(array: Item[], map: MapKey, filterKey: ItemKey, filterValue: Item[MapKey][ItemKey]): Array<Item[MapKey]>;
 /**
- * Get a filtered and mapped array of items
+ * Get a mapped and filtered array of items
  *
  * @param array Array to search in
- * @param filterKey Key to get an item's value for matching
- * @param filterValue Value to match against
- * @param mapKey Key to get an item's value for mapping
- * @returns Filtered and mapped array of items
+ * @param map Callback or key to map the items
+ * @param filter Filter callback to match mapped values
+ * @returns Mapped and filtered array of items
  *
  * @example
  * ```typescript
- * select(
+ * reverseSelect(
  *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   'id',
- *   2,
- *   'name',
+ *   item => item.name,
+ *   value => value.startsWith('B'),
  * ); // => ['Bob']
  * ```
  */
-export declare function select<Item extends PlainObject, ItemKey extends keyof Item, MapKey extends keyof Item>(array: Item[], filterKey: ItemKey, filterValue: Item[ItemKey], mapKey: MapKey): Array<Item[MapKey]>;
+export declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, filter: (item: Mapped<Item, Map>, index: number, array: Item[]) => boolean): Array<Mapped<Item, Map>>;
 /**
- * Get a filtered and mapped array of items
+ * Get a mapped and filtered array of items
  *
  * @param array Array to search in
- * @param filterCallback Filter callback to match items
- * @param mapCallback Callback to map the matched items
- * @returns Filtered and mapped array of items
+ * @param map Callback or key to map the items
+ * @param value Mapped value to match against
+ * @returns Mapped and filtered array of items
  *
  * @example
  * ```typescript
- * select(
- *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   item => item.id === 2,
- *   item => item.name,
- * ); // => ['Bob']
+ * reverseSelect(
+ *   [1, 2, 3, 2, 1],
+ *   value => value ** 2,
+ *   4,
+ * ); // => [4, 4]
  * ```
  */
-export declare function select<Item, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, mapCallback: MapCallback): Array<ReturnType<MapCallback>>;
+export declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, value: Mapped<Item, Map>): Array<Mapped<Item, Map>>;
 /**
  * Get a filtered and mapped array of items
  *
  * @param array Array to search in
- * @param filterCallback Filter callback to match items
- * @param mapKey Key to get an item's value for mapping
+ * @param filterCallback Callback to get an item's value for matching
+ * @param filterValue Value to match against
+ * @param map Callback or key to map the matched items
  * @returns Filtered and mapped array of items
  *
  * @example
@@ -1890,35 +1740,37 @@ export declare function select<Item, FilterCallback extends (item: Item, index:
  *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
  *   item => item.id,
  *   2,
- *   'name'
+ *   item => item.name,
  * ); // => ['Bob']
  * ```
  */
-export declare function select<Item extends PlainObject, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, MapKey extends keyof Item>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, mapKey: MapKey): Array<Item[MapKey]>;
+export declare function select<Item, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, Map extends MapKeyOrCallback<Item>>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, map: Map): Array<Mapped<Item, Map>>;
 /**
  * Get a filtered and mapped array of items
  *
  * @param array Array to search in
- * @param filter Filter callback to match items
- * @param map Callback to map the matched items
+ * @param filterKey Key to get an item's value for matching
+ * @param filterValue Value to match against
+ * @param map Callback or key to map the matched items
  * @returns Filtered and mapped array of items
  *
  * @example
  * ```typescript
  * select(
  *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   item => item.id === 2,
- *   item => item.name,
+ *   'id',
+ *   2,
+ *   'name',
  * ); // => ['Bob']
  * ```
  */
-export declare function select<Item, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean, map: MapCallback): Array<ReturnType<MapCallback>>;
+export declare function select<Item extends PlainObject, ItemKey extends keyof Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filterKey: ItemKey, filterValue: Item[ItemKey], map: Map): Array<Mapped<Item, Map>>;
 /**
  * Get a filtered and mapped array of items
  *
  * @param array Array to search in
  * @param filter Filter callback to match items
- * @param map Key to get an item's value for mapping
+ * @param map Callback or key to map the matched items
  * @returns Filtered and mapped array of items
  *
  * @example
@@ -1926,17 +1778,17 @@ export declare function select<Item, MapCallback extends (item: Item, index: num
  * select(
  *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
  *   item => item.id === 2,
- *   'name'
+ *   item => item.name,
  * ); // => ['Bob']
  * ```
  */
-export declare function select<Item extends PlainObject, MapKey extends keyof Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean, map: MapKey): Array<Item[MapKey]>;
+export declare function select<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean, map: Map): Array<Mapped<Item, Map>>;
 /**
  * Get a filtered and mapped array of items
  *
  * @param array Array to search in
  * @param item Item to match against
- * @param map Callback to map the matched items
+ * @param map Callback or key to map the matched items
  * @returns Filtered and mapped array of items
  *
  * @example
@@ -1948,7 +1800,10 @@ export declare function select<Item extends PlainObject, MapKey extends keyof It
  * ); // => [9]
  * ```
  */
-export declare function select<Item, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], item: Item, map: MapCallback): Array<ReturnType<MapCallback>>;
+export declare function select<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], item: Item, map: Map): Array<Mapped<Item, Map>>;
+export declare namespace select {
+  var reverse: typeof reverseSelect;
+}
 //#endregion
 //#region src/array/single.d.ts
 /**
@@ -3283,13 +3138,13 @@ declare function swapIndices<Item>(array: Item[], first: number, second: number)
 //#endregion
 //#region src/array/to-map.d.ts
 /**
- * Create a _Map_ from an array of items using callbacks
+ * Create a _Map_ from an array of items using a specific key
  *
  * If multiple items have the same key, the latest item's value will be used
  *
  * @param array Array to convert
- * @param key Callback to get an item's grouping key
- * @param value Callback to get an item's value
+ * @param key Callback or key to use for grouping
+ * @param value Callback or key to use for value, defaulting to the item itself
  * @returns _Map_ of keyed values
  *
  * @example
@@ -3301,74 +3156,14 @@ declare function swapIndices<Item>(array: Item[], first: number, second: number)
  * ); // => Map { 10 => 3, 20 => 2 }
  * ```
  */
-export declare function toMap<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Map<ReturnType<KeyCallback>, ReturnType<ValueCallback>>;
-/**
- * Create a _Map_ from an array of items using a callback and value
- *
- * If multiple items have the same key, the latest item's value will be used
- *
- * @param array Array to convert
- * @param key Callback to get an item's grouping key
- * @param value Key to use for value
- * @returns _Map_ of keyed values
- *
- * @example
- * ```typescript
- * toMap(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   'id',
- * ); // => Map { 10 => 3, 20 => 2 }
- * ```
- */
-export declare function toMap<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ItemValue extends keyof Item>(array: Item[], key: KeyCallback, value: ItemValue): Map<ReturnType<KeyCallback>, Item[ItemValue]>;
+export declare function toMap<Item, KeyArg extends KeyOrCallback<Item, Key$1>, ValueArg extends KeyOrCallback<Item>>(array: Item[], key: KeyArg, value: ValueArg): Map<KeyOrCallbackKey<Item, KeyArg>, KeyOrCallbackValue<Item, ValueArg>>;
 /**
- * Create a _Map_ from an array of items using a key and callback
- *
- * If multiple items have the same key, the latest item's value will be used
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @param value Callback to get an item's value
- * @returns _Map_ of keyed values
- *
- * @example
- * ```typescript
- * toMap(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   item => item.id,
- * ); // => Map { 10 => 3, 20 => 2 }
- * ```
- */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Map<Item[ItemKey], ReturnType<ValueCallback>>;
-/**
- * Create a _Map_ from an array of items using a key and value
- *
- * If multiple items have the same key, the latest item's value will be used
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @param value Key to use for value
- * @returns _Map_ of keyed values
- *
- * @example
- * ```typescript
- * toMap(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   'id',
- * ); // => Map { 10 => 3, 20 => 2 }
- * ```
- */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<Item[ItemKey], Item[ItemValue]>;
-/**
- * Create a _Map_ from an array of items using a callback
+ * Create a _Map_ from an array of items using a specific key
  *
  * If multiple items have the same key, the latest item will be used
  *
  * @param array Array to convert
- * @param callback Callback to get an item's grouping key
+ * @param key Callback or key to use for grouping
  * @returns _Map_ of keyed items
  *
  * @example
@@ -3379,25 +3174,7 @@ export declare function toMap<Item extends PlainObject, ItemKey extends keyof It
  * ); // => Map { 10 => {id: 3, value: 10}, 20 => {id: 2, value: 20} }
  * ```
  */
-export declare function toMap<Item, Callback extends (item: Item, index: number, array: Item[]) => Key$1>(array: Item[], callback: Callback): Map<ReturnType<Callback>, Item>;
-/**
- * Create a _Map_ from an array of items using a key
- *
- * If multiple items have the same key, the latest item will be used
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @returns _Map_ of keyed items
- *
- * @example
- * ```typescript
- * toMap(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- * ); // => Map { 10 => {id: 3, value: 10}, 20 => {id: 2, value: 20} }
- * ```
- */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Map<Item[ItemKey], Item>;
+export declare function toMap<Item, KeyArg extends KeyOrCallback<Item, Key$1>>(array: Item[], key: KeyArg): Map<KeyOrCallbackKey<Item, KeyArg>, Item>;
 /**
  * Create a _Map_ from an array of items _(using indices as keys)_
  *
@@ -3416,13 +3193,13 @@ export declare namespace toMap {
   var arrays: typeof toMapArrays;
 }
 /**
- * Create a _Map_ from an array of items using callbacks, grouping values into arrays
+ * Create a _Map_ from an array of items using a specific key, grouping values into arrays
  *
  * _Available as `toMapArrays` and `toMap.arrays`_
  *
  * @param array Array to convert
- * @param key Callback to get an item's grouping key
- * @param value Callback to get an item's value
+ * @param key Callback or key to use for grouping
+ * @param value Callback or key to use for value, defaulting to the item itself
  * @returns _Map_ of keyed arrays of values
  *
  * @example
@@ -3434,74 +3211,14 @@ export declare namespace toMap {
  * ); // => Map { 10 => [1, 3], 20 => [2] }
  * ```
  */
-export declare function toMapArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Map<ReturnType<KeyCallback>, Array<ReturnType<ValueCallback>>>;
-/**
- * Create a _Map_ from an array of items using a callback and value, grouping values into arrays
- *
- * _Available as `toMapArrays` and `toMap.arrays`_
- *
- * @param array Array to convert
- * @param key Callback to get an item's grouping key
- * @param value Key to use for value
- * @returns _Map_ of keyed arrays of values
- *
- * @example
- * ```typescript
- * toMapArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   'id',
- * ); // => Map { 10 => [1, 3], 20 => [2] }
- * ```
- */
-export declare function toMapArrays<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ItemValue extends keyof Item>(array: Item[], key: KeyCallback, value: ItemValue): Map<ReturnType<KeyCallback>, Item[ItemValue][]>;
+export declare function toMapArrays<Item, KeyArg extends KeyOrCallback<Item, Key$1>, ValueArg extends KeyOrCallback<Item>>(array: Item[], key: KeyArg, value: ValueArg): Map<KeyOrCallbackKey<Item, KeyArg>, Array<KeyOrCallbackValue<Item, ValueArg>>>;
 /**
- * Create a _Map_ from an array of items using a key and callback, grouping values into arrays
+ * Create a _Map_ from an array of items using a specific key, grouping items into arrays
  *
  * _Available as `toMapArrays` and `toMap.arrays`_
  *
  * @param array Array to convert
- * @param key Key to use for grouping
- * @param value Callback to get an item's value
- * @returns _Map_ of keyed arrays of values
- *
- * @example
- * ```typescript
- * toMapArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   item => item.id,
- * ); // => Map { 10 => [1, 3], 20 => [2] }
- * ```
- */
-export declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Map<Item[ItemKey], Array<ReturnType<ValueCallback>>>;
-/**
- * Create a _Map_ from an array of items using a key and value, grouping values into arrays
- *
- * _Available as `toMapArrays` and `toMap.arrays`_
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @param value Key to use for value
- * @returns _Map_ of keyed arrays of values
- *
- * @example
- * ```typescript
- * toMapArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   'id',
- * ); // => Map { 10 => [1, 3], 20 => [2] }
- * ```
- */
-export declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<Item[ItemKey], Item[ItemValue][]>;
-/**
- * Create a _Map_ from an array of items using a callback, grouping items into arrays
- *
- * _Available as `toMapArrays` and `toMap.arrays`_
- *
- * @param array Array to convert
- * @param callback Callback to get an item's grouping key
+ * @param key Callback or key to use for grouping
  * @returns _Map_ of keyed arrays of items
  *
  * @example
@@ -3512,35 +3229,17 @@ export declare function toMapArrays<Item extends PlainObject, ItemKey extends ke
  * ); // => Map { 10 => [{id: 1, value: 10}, {id: 3, value: 10}], 20 => [{id: 2, value: 20}] }
  * ```
  */
-export declare function toMapArrays<Item, Callback extends (item: Item, index: number, array: Item[]) => Key$1>(array: Item[], callback: Callback): Map<ReturnType<Callback>, Item[]>;
-/**
- * Create a _Map_ from an array of items using a key, grouping items into arrays
- *
- * _Available as `toMapArrays` and `toMap.arrays`_
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @returns _Map_ of keyed arrays of items
- *
- * @example
- * ```typescript
- * toMapArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- * ); // => Map { 10 => [{id: 1, value: 10}, {id: 3, value: 10}], 20 => [{id: 2, value: 20}] }
- * ```
- */
-export declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Map<Item[ItemKey], Item[]>;
+export declare function toMapArrays<Item, KeyArg extends KeyOrCallback<Item, Key$1>>(array: Item[], key: KeyArg): Map<KeyOrCallbackKey<Item, KeyArg>, Item[]>;
 //#endregion
 //#region src/array/to-record.d.ts
 /**
- * Create a record from an array of items using callbacks
+ * Create a record from an array of items using a specific key
  *
  * If multiple items have the same key, the latest item will be used
  *
  * @param array Array to convert
- * @param key Callback to get an item's grouping key
- * @param value Callback to get an item's value
+ * @param key Callback or key to use for grouping
+ * @param value Callback or key to use for value, defaulting to the item itself
  * @returns Record of keyed values
  *
  * @example
@@ -3552,74 +3251,14 @@ export declare function toMapArrays<Item extends PlainObject, ItemKey extends ke
  * ); // => { 10: 3, 20: 2 }
  * ```
  */
-export declare function toRecord<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>>;
-/**
- * Create a record from an array of items using a callback and value
- *
- * If multiple items have the same key, the latest item will be used
- *
- * @param array Array to convert
- * @param callback Callback to get an item's grouping key
- * @param value Key to use for value
- * @returns Record with keys
- *
- * @example
- * ```typescript
- * toRecord(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   'id',
- * ); // => { 10: 3, 20: 2 }
- * ```
- */
-export declare function toRecord<Item extends PlainObject, Callback extends (item: Item, index: number, array: Item[]) => Key$1, ItemValue extends keyof Item>(array: Item[], callback: Callback, value: ItemValue): Record<ReturnType<Callback>, Item[ItemValue]>;
+export declare function toRecord<Item, KeyArg extends KeyOrCallback<Item, Key$1>, ValueArg extends KeyOrCallback<Item>>(array: Item[], key: KeyArg, value: ValueArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, KeyOrCallbackValue<Item, ValueArg>>>;
 /**
- * Create a record from an array of items using a key and callback
- *
- * If multiple items have the same key, the latest item will be used
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @param callback Callback to get an item's value
- * @returns Record with keys
- *
- * @example
- * ```typescript
- * toRecord(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   item => item.id,
- * ); // => { 10: 3, 20: 2 }
- * ```
- */
-export declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, callback: Callback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<Callback>>>;
-/**
- * Create a record from an array of items using a key and value
- *
- * If multiple items have the same key, the latest item will be used
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @param value Key to use for value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * toRecord(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   'id',
- * ); // => { 10: 3, 20: 2 }
- * ```
- */
-export declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue]>>;
-/**
- * Create a record from an array of items using a callback
+ * Create a record from an array of items using a specific key
  *
  * If multiple items have the same key, the latest item will be used
  *
  * @param array Array to convert
- * @param callback Callback to get an item's grouping key
+ * @param key Callback or key to use for grouping
  * @returns Record of keyed values
  *
  * @example
@@ -3630,25 +3269,7 @@ export declare function toRecord<Item extends PlainObject, ItemKey extends keyof
  * ); // => { 10: {id: 3, value: 10}, 20: {id: 2, value: 20} }
  * ```
  */
-export declare function toRecord<Item, Callback extends (item: Item, index: number, array: Item[]) => Key$1>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item>;
-/**
- * Create a record from an array of items using a key
- *
- * If multiple items have the same key, the latest item will be used
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * toRecord(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- * ); // => { 10: {id: 3, value: 10}, 20: {id: 2, value: 20} }
- * ```
- */
-export declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item>>;
+export declare function toRecord<Item, KeyArg extends KeyOrCallback<Item, Key$1>>(array: Item[], key: KeyArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, Item>>;
 /**
  * Create a record from an array of items _(using indices as keys)_
  *
@@ -3667,33 +3288,13 @@ export declare namespace toRecord {
   var arrays: typeof toRecordArrays;
 }
 /**
- * Create a record from an array of items using callbacks, grouping values into arrays
- *
- * _Available as `toRecordArrays` and `toRecord.arrays`_
- *
- * @param array Array to convert
- * @param key Callback to get an item's grouping key
- * @param value Callback to get an item's value
- * @returns Record of keyed arrays of values
- *
- * @example
- * ```typescript
- * toRecordArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   item => item.id,
- * ); // => { 10: [1, 3], 20: [2] }
- * ```
- */
-export declare function toRecordArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, Array<ReturnType<ValueCallback>>>;
-/**
- * Create a record from an array of items using a callback and value, grouping values into arrays
+ * Create a record from an array of items using a specific key, grouping values into arrays
  *
  * _Available as `toRecordArrays` and `toRecord.arrays`_
  *
  * @param array Array to convert
- * @param callback Callback to get an item's grouping key
- * @param value Key to use for value
+ * @param key Callback or key to use for grouping
+ * @param value Callback or key to use for value, defaulting to the item itself
  * @returns Record of keyed arrays of values
  *
  * @example
@@ -3701,58 +3302,18 @@ export declare function toRecordArrays<Item, KeyCallback extends (item: Item, in
  * toRecordArrays(
  *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
  *   item => item.value,
- *   'id',
- * ); // => { 10: [1, 3], 20: [2] }
- * ```
- */
-export declare function toRecordArrays<Item extends PlainObject, Callback extends (item: Item, index: number, array: Item[]) => Key$1, ItemValue extends keyof Item>(array: Item[], callback: Callback, value: ItemValue): Record<ReturnType<Callback>, Item[ItemValue][]>;
-/**
- * Create a record from an array of items using a key and callback, grouping values into arrays
- *
- * _Available as `toRecordArrays` and `toRecord.arrays`_
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @param callback Callback to get an item's value
- * @returns Record of keyed arrays of values
- *
- * @example
- * ```typescript
- * toRecordArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
  *   item => item.id,
  * ); // => { 10: [1, 3], 20: [2] }
  * ```
  */
-export declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, callback: Callback): Simplify<Record<KeyedValue<Item, ItemKey>, Array<ReturnType<Callback>>>>;
-/**
- * Create a record from an array of items using a key and value, grouping values into arrays
- *
- * _Available as `toRecordArrays` and `toRecord.arrays`_
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @param value Key to use for value
- * @returns Record of keyed arrays of values
- *
- * @example
- * ```typescript
- * toRecordArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   'id',
- * ); // => { 10: [1, 3], 20: [2] }
- * ```
- */
-export declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue][]>>;
+export declare function toRecordArrays<Item, KeyArg extends KeyOrCallback<Item, Key$1>, ValueArg extends KeyOrCallback<Item>>(array: Item[], key: KeyArg, value: ValueArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, Array<KeyOrCallbackValue<Item, ValueArg>>>>;
 /**
- * Create a record from an array of items using a callback, grouping items into arrays
+ * Create a record from an array of items using a specific key, grouping items into arrays
  *
  * _Available as `toRecordArrays` and `toRecord.arrays`_
  *
  * @param array Array to convert
- * @param callback Callback to get an item's grouping key
+ * @param key Callback or key to use for grouping
  * @returns Record of keyed arrays of items
  *
  * @example
@@ -3763,25 +3324,7 @@ export declare function toRecordArrays<Item extends PlainObject, ItemKey extends
  * ); // => { 10: [{id: 1, value: 10}, {id: 3, value: 10}], 20: [{id: 2, value: 20}] }
  * ```
  */
-export declare function toRecordArrays<Item, Callback extends (item: Item, index: number, array: Item[]) => Key$1>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item[]>;
-/**
- * Create a record from an array of items using a key, grouping items into arrays
- *
- * _Available as `toRecordArrays` and `toRecord.arrays`_
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @returns Record of keyed arrays of items
- *
- * @example
- * ```typescript
- * toRecordArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- * ); // => { 10: [{id: 1, value: 10}, {id: 3, value: 10}], 20: [{id: 2, value: 20}] }
- * ```
- */
-export declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
+export declare function toRecordArrays<Item, KeyArg extends KeyOrCallback<Item, Key$1>>(array: Item[], key: KeyArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, Item[]>>;
 //#endregion
 //#region src/internal/function/misc.d.ts
 /**
@@ -6764,7 +6307,7 @@ type SubscriptionProperty = {
    */
   value: unknown;
 };
-type Subscriptions = {
+type Subscriptions<Value = unknown> = {
   /**
    * Items of the subscriptions store
    *
@@ -6780,7 +6323,7 @@ type Subscriptions = {
    * - `to.any` - Map of subscriptions to values _(for unkeyed subscriptions)_
    * - `to.keyed` - Map of keys to maps of subscriptions to values _(for keyed subscriptions)_
    */
-  readonly values: Readonly<SubscriptionsValues>;
+  readonly values: Readonly<SubscriptionsValues<Value>>;
   /**
    * Clear all subscriptions
    */
@@ -6810,9 +6353,9 @@ type SubscriptionsItems = {
   any: Set<Subscription>;
   keyed?: Map<Key$1, Set<Subscription>>;
 };
-type SubscriptionsValues = {
-  from: SubscriptionsValuesItem<unknown, Subscription>;
-  to: SubscriptionsValuesItem<Subscription, unknown>;
+type SubscriptionsValues<Value = unknown> = {
+  from: SubscriptionsValuesItem<Value, Subscription>;
+  to: SubscriptionsValuesItem<Subscription, Value>;
 };
 type SubscriptionsValuesItem<MapKey, MapValue> = {
   any: Map<MapKey, MapValue>;
@@ -6838,7 +6381,7 @@ export declare function isSubscriptions(value: unknown): value is Subscriptions;
  * @param parameters Store parameters
  * @returns Subscription store
  */
-export declare function subscriptions(parameters?: SubscriptionsParameters): Subscriptions;
+export declare function subscriptions<Value = unknown>(parameters?: SubscriptionsParameters): Subscriptions<Value>;
 //#endregion
 //#region src/beacon.d.ts
 /**