Codibre/fluent-iterable

import { Mapper } from 'augmentative-iterable';
import { Reducer } from '../base';

export interface ToMapFunction<T> {
  /**
   * Create a Map from the iterable. This is a resolving operation
   * @typeparam K The type of the data the element equality is based on.
   * @param getKey The projection to use to determine element equality. It serves as key of the resulting Map.
   * @param mapper: Maps the first iterated item to the Map value type
   * @param reduceValue reduce the following items to the map value type. If not informed, assumes only the first value
   * @returns The [[FluentIterable]] of the distinct elements.
   */
  <K, V>(
    getKey: Mapper<T, K>,
    mapper: Mapper<T, V>,
    reduceValue?: Reducer<V, T>,
  ): Map<K, V>;
  /**
   * Create a Map from the iterable. This is a resolving operation
   * @typeparam K The type of the data the element equality is based on.
   * @param getKey The key of T for element equality. It serves as key of the resulting Map.
   * @param mapper: Maps the first iterated item to the Map value type
   * @param reduceValue reduce the following items to the map value type. If not informed, assumes only the first value
   * @returns The [[FluentIterable]] of the distinct elements.
   */
  <K extends keyof T, V>(
    getKey: K,
    mapper: Mapper<T, V>,
    reduceValue?: Reducer<V, T>,
  ): Map<T[K], V>;
  /**
   * Create a Map from the iterable. This is a resolving operation
   * @typeparam K The type of the data the element equality is based on.
   * @param getKey The key of T for element equality. It serves as key of the resulting Map.
   * @param getValue: The key to be used as value
   * @param reduceValue reduce the following items to the map value type. If not informed, assumes only the first value
   * @returns The [[FluentIterable]] of the distinct elements.
   */
  <K extends keyof T, V extends keyof T>(
    getKey: K,
    mapper: V,
    reduceValue?: Reducer<T[V], T>,
  ): Map<T[K], T[V]>;
}
export interface AsyncToMapFunction<T> {
  /**
   * Create a Map from the iterable. This is a resolving operation
   * @typeparam K The type of the data the element equality is based on.
   * @param getKey The projection to use to determine element equality. It serves as key of the resulting Map.
   * @param mapper: Maps the first iterated item to the Map value type
   * @param reduceValue reduce the following items to the map value type. If not informed, assumes only the first value
   * @returns The [[FluentIterable]] of the distinct elements.
   */
  <K, V>(
    getKey: Mapper<T, K>,
    mapper: Mapper<T, V>,
    reduceValue: Reducer<V, T>,
  ): Promise<Map<K, V>>;
  /**
   * Create a Map from the iterable. This is a resolving operation
   * @typeparam K The type of the data the element equality is based on.
   * @param getKey The key of T for element equality. It serves as key of the resulting Map.
   * @param mapper: Maps the first iterated item to the Map value type
   * @param reduceValue reduce the following items to the map value type. If not informed, assumes only the first value
   * @returns The [[FluentIterable]] of the distinct elements.
   */
  <K extends keyof T, V>(
    getKey: K,
    mapper: Mapper<T, V>,
    reduceValue: Reducer<V, T>,
  ): Promise<Map<T[K], V>>;
  /**
   * Create a Map from the iterable. This is a resolving operation
   * @typeparam K The type of the data the element equality is based on.
   * @param getKey The key of T for element equality. It serves as key of the resulting Map.
   * @param getValue: The key to be used as value
   * @param reduceValue reduce the following items to the map value type. If not informed, assumes only the first value
   * @returns The [[FluentIterable]] of the distinct elements.
   */
  <K extends keyof T, V extends keyof T>(
    getKey: K,
    mapper: V,
    reduceValue?: Reducer<T[V], T>,
  ): Promise<Map<T[K], T[V]>>;
}