type Operator = "===" | "==" | "!==" | "!=" | "<>" | ">" | "<" | ">=" | "<="

declare module 'collect.js' {
  export function collect<T>(collection?: T[] | Object): Collection<T>;
  export default function collect<T>(collection?: T[] | Object): Collection<T>;
  export class Collection<Item> {
    constructor(collection?: Item[] | Object);

    /**
     * The all method returns the underlying array represented by the collection.
     */
    all(): Item[];

    /**
     * Alias for the avg() method.
     */
    average<K>(key?: keyof Item | K): number;

    /**
     * The avg method returns the average of all items in the collection.
     */
    avg<K>(key?: keyof Item | K): number;

    /**
     * The chunk method breaks the collection into multiple, smaller collections of a given size.
     */
    chunk(size: number): Collection<Item[]>;

    /**
     * The collapse method collapses a collection of arrays into a single, flat collection.
     */
    collapse(): Collection<Item>;

    /**
     * The combine method combines the keys of the collection with the values of another array or collection.
     */
    combine<T, U>(array: U[]): Collection<T>;

    /**
     * The concat method is used to merge two or more collections/arrays/objects.
     */
    concat<T>(collectionOrArrayOrObject: Collection<T> | T[] | object): any;

    /**
     * The contains method determines whether the collection contains a given item.
     */
    contains<K, V>(key: keyof Item | K | Function, value?: V): boolean;

    /**
     * The count method returns the total number of items in the collection.
     */
    count(): number;

    /**
     * The crossJoin method cross joins the collection with the given array or collection, returning all possible permutations.
     */
    crossJoin<T>(values: T[]): Collection<[Item, T]>;

    /**
     * The dd method will console.log the collection and exit the current process.
     */
    dd(): void;

    /**
     * The diff method compares the collection against another collection or a plain array based on its values.
     * This method will return the values in the original collection that are not present in the given collection.
     */
    diff<T>(values: T[] | Collection<Item>): Collection<Item>;

    /**
     * The diffAssoc method compares the collection against another collection or a plain object based on its keys
     * and values. This method will return the key / value pairs in the original collection that are not present in
     * the given collection:
     */
    diffAssoc<T>(values: T[] | Collection<T>): Collection<Item>;

    /**
     * The diffKeys method compares the collection against another collection or a plain object based on its keys.
     * This method will return the key / value pairs in the original collection that are not present in the given collection.
     */
    diffKeys<K extends keyof Item>(object: object): Collection<K>;

    /**
     * The dump method outputs the results at that moment and then continues processing.
     */
    dump(): this;

    /**
     * The each method iterates over the items in the collection and passes each item to a callback.
     */
    each(fn: (currentItem: Item, key?: string | number, collection?: Item[]) => void): this;

    /**
     * The every method may be used to verify that all elements of a collection pass a given truth test.
     */
    every(fn: (item: Item) => boolean): boolean;

    /**
     * The except method returns all items in the collection except for those with the specified keys.
     */
    except<K>(properties: K[]): Collection<Item>;

    /**
     * The filter method filters the collection using the given callback,
     * keeping only those items that pass a given truth test.
     */
    filter(fn: (item: Item) => boolean): Collection<Item>;
    filter(fn: (item: Item, key?: any) => boolean): Collection<Item>;

    /**
     * The first method returns the first element in the collection that passes a given truth test.
     */
    first<V>(fn?: (item: Item) => boolean, defaultValue?: ((...any: any[]) => V | Item) | V | Item): Item;

    /**
     * The flatMap method iterates through the collection and passes each value to the given callback.
     * The callback is free to modify the item and return it, thus forming a new collection of modified items.
     * Then, the array is flattened by a level.
     */
    flatMap<T>(fn: (item: Item, key: any) => T): Collection<T>;

    /**
     * The flatten method flattens a multi-dimensional collection into a single dimension.
     */
    flatten(depth?: number): Collection<Item>;

    /**
     * The flip method swaps the collection's keys with their corresponding values.
     */
    flip(): Collection<Item>;

    /**
     * The forget method removes an item from the collection by its key.
     */
    forget<K>(key: keyof Item | K): this;

    /**
     * The forPage method returns a new collection containing the items that would be present on a given page number.
     * The method accepts the page number as its first argument
     * and the number of items to show per page as its second argument.
     */
    forPage(page: number, chunk: number): Collection<Item>;

    /**
     * The get method returns the item at a given key. If the key does not exist, null is returned.
     */
    get<K, V>(key: keyof Item | K, defaultValue?: ((...any: any[]) => V | Item) | V | Item): Item | null;

    /**
     * The groupBy method groups the collection's items by a given key.
     *
     */
    groupBy<T, K>(key: ((item: Item, index?: number) => K) | keyof Item | K): Collection<T>;

    /**
     * The has method determines if one or more keys exists in the collection.
     */
    has<K>(key: keyof Item | K | (keyof Item)[]): boolean;

    /**
     * The implode method joins the items in a collection.
     * Its arguments depend on the type of items in the collection.
     *
     * If the collection contains arrays or objects,
     * you should pass the key of the attributes you wish to join,
     * and the "glue" string you wish to place between the values.
     */
    implode<K>(key: keyof Item | K, glue?: string): string;

    /**
     * The intersect method removes any values from the original collection
     * that are not present in the given array or collection.
     * The resulting collection will preserve the original collection's keys.
     */
    intersect(values: Item[] | Collection<Item>): Collection<Item>;

    /**
     * The intersectByKeys method removes any keys from the original collection
     * that are not present in the given array or collection.
     */
    intersectByKeys<K extends keyof Item>(values: Item | Collection<Item>): Collection<K>

    /**
     * The isEmpty method returns true if the collection is empty; otherwise, false is returned.
     */
    isEmpty(): boolean;

    /**
     * The isNotEmpty method returns true if the collection is not empty; otherwise, false is returned.
     */
    isNotEmpty(): boolean;

    /**
     * The keyBy method keys the collection by the given key.
     * If multiple items have the same key, only the last one will appear in the new collection.
     */
    keyBy<T, K>(key: keyof Item | K | Function): Collection<T>;

    /**
     * The keys method returns all of the collection's keys.
     */
    keys(): Collection<string>;

    /**
     * The last method returns the last element in the collection that passes a given truth test.
     */
    last(fn?: (item: Item) => boolean): Item;

    /**
     * The macro method lets you register custom methods.
     */
    macro(name: string, fn: Function): void;

    /**
     * The map method iterates through the collection and passes each value to the given callback.
     * The callback is free to modify the item and return it, thus forming a new collection of modified items.
     */
    map<T>(fn: (item: Item, index: any) => T): Collection<T>;

    /**
     * The mapInto method iterates through the collection and instantiates the given class with each element as a constructor.
     */
    mapInto<T extends Function>(ClassName: T): Collection<T>;

    /**
     * The mapToGroups method iterates through the collection and passes each value to the given callback.
     */
    mapToGroups(fn: Function): Collection<any>;

    /**
     * The mapWithKeys method iterates through the collection and passes each value to the given callback.
     * The callback should return an array where the first element represents the key
     * and the second element represents the value pair.
     */
    mapWithKeys<T>(fn: Function): Collection<T>;

    /**
     * The max method returns the maximum value of a given key.
     */
    max(key?: keyof Item | string): number;

    /**
     * The median method returns the median value of a given key.
     */
    median<K>(key?: keyof Item | K): Item;

    /**
     * The merge method merges the given object into the original collection.
     * If a key in the given object matches a key in the original collection,
     * the given objects value will overwrite the value in the original collection.
     */
    merge<T>(objectOrArray: object | T[]): Collection<T>;

    /**
     * The min method returns the minimum value of a given key.
     */
    min<K>(key?: keyof Item | K): number;

    /**
     * The mode method returns the mode value of a given key.
     */
    mode<K>(key?: keyof Item | K): Collection<Item> | null;

    /**
     * The nth method creates a new collection consisting of every n-th element.
     */
    nth(n: number, offset?: number): Collection<Item>;

    /**
     * The only method returns the items in the collection with the specified keys.
     */
    only<K>(properties: K[]): Collection<Item>;

    /**
     * The partition method may be combined with destructuring to separate elements
     * that pass a given truth test from those that do not.
     */
    partition(fn: (item: Item) => boolean): [Item[], Item[]];

    /**
     * The pipe method passes the collection to the given callback and returns the result.
     */
    pipe<U>(fn: (...any: any[]) => U): U;

    /**
     * The pluck method retrieves all of the values for a given key.
     */
    pluck<T, K, V>(value: keyof Item | V, key?: keyof Item | K): Collection<T>;

    /**
     * The pop method removes and returns the last item from the collection.
     */
    pop(): Item;

    /**
     * The prepend method adds an item to the beginning of the collection.
     */
    prepend<K, V>(value: V, key?: K): this;

    /**
     * The pull method removes and returns an item from the collection by its key.
     */
    pull<K>(key: keyof Item | K): Item | null;

    /**
     * The push method appends an item to the end of the collection.
     */
    push(item: Item): this;

    /**
     * The put method sets the given key and value in the collection.
     */
    put<K, V>(key: K, value: V): this;

    /**
     * The random method returns a random item from the collection.
     */
    random(length?: number): this | Item;

    /**
     * The reduce method reduces the collection to a single value,
     * passing the result of each iteration into the subsequent iteration.
     */
    reduce<T>(fn: (_carry: T | null, item: Item) => T, carry?: T): any;

    /**
     * The reject method filters the collection using the given callback.
     * The callback should return true if the item should be removed from the resulting collection.
     */
    reject(fn: (item: Item) => boolean): Collection<Item>;

    /**
     * The reverse method reverses the order of the collection's items.
     */
    reverse(): Collection<Item>;

    /**
     * The search method searches the collection for the given value and returns its key if found.
     * If the item is not found, false is returned.
     */
    search(valueOrFunction: Item | ((value: Item, key: number) => boolean), strict?: boolean): any;

    /**
     * The shift method removes and returns the first item from the collection.
     */
    shift(): Item;

    /**
     * The shuffle method randomly shuffles the items in the collection.
     */
    shuffle(): this;

    /**
     * The slice method returns a slice of the collection starting at the given index.
     */
    slice(remove: number, limit?: number): Collection<Item>;

    /**
     * The sort method sorts the collection.
     */
    sort(fn?: (a: Item, b: Item) => number): Collection<Item>;

    /**
     * The sortBy method sorts the collection by the given key.
     * The sorted collection keeps the original array keys.
     */
    sortBy<V>(value: V): Collection<Item>;

    /**
     * The sortBy method sorts the collection by the given callback.
     * The sorted collection keeps the original array keys.
     */
    sortBy(fn: (item: Item) => number): Collection<Item>;

    /**
     * This method has the same signature as the sortBy method,
     * but will sort the collection in the opposite order.
     */
    sortByDesc<V>(value: V): Collection<Item>;

    /**
     * This method has the same signature as the sortBy method,
     * but will sort the collection in the opposite order.
     */
    sortByDesc(fn: (item: Item) => number): Collection<Item>;

    /**
     * The splice method removes and returns a slice of items starting at the specified index.
     * You may pass a second argument to limit the size of the resulting chunk.
     */
    splice(index: number, limit: number, replace?: Item[]): Collection<Item>;

    /**
     * The split method breaks a collection into the given number of groups.
     */
    split(numberOfGroups: number): Item[];

    /**
     * The sum method returns the sum of all items in the collection.
     */
    sum<K>(key?: keyof Item | K | ((item: Item) => number | string)): number | string;

    [Symbol.iterator]: () => Iterator<Item>;

    /**
     * The take method returns a new collection with the specified number of items:
     * You may also pass a negative integer to take the specified amount of items from the end of the collection.
     */
    take(length: number): Collection<Item>;

    /**
     * The tap method passes the collection to the given callback,
     * allowing you to "tap" into the collection at a specific point
     * and do something with the items while not affecting the collection itself.
     */
    tap(fn: (collection: Collection<Item>) => void): this;

    /**
     * The times method creates a new collection by invoking the callback a given amount of times.
     */
    times<T>(times: number, fn: (time: number) => T): T[];

    /**
     * The toArray method converts the collection into a plain array.
     * If the collection is an object, an array containing the values will be returned.
     */
    toArray<T>(): T[];

    /**
     * The toJson method converts the collection into JSON string.
     */
    toJson(): string;

    /**
     * The transform method iterates over the collection and calls the given callback with each item in the collection.
     * The items in the collection will be replaced by the values returned by the callback.
     */
    transform<T>(fn: (item: Item) => T): Collection<T>;

    /**
     * The union method adds the given array to the collection.
     * If the given array contains keys that are already in the original collection,
     * the original collection's values will be preferred.
     */
    union<T>(object: Object): Collection<T>;

    /**
     * The unique method returns all of the unique items in the collection.
     */
    unique<K>(key?: keyof Item | K | Function): Collection<Item>;

    /**
     * The unless method will execute the given callback when the first argument given to the method evaluates to false.
     */
    unless(value: boolean, fn: (this: any) => any, defaultFn: (this: any) => any): void;

    /**
     * The unwrap method will unwrap the given collection.
     */
    unwrap<T>(value: T[] | Collection<T>): T[];

    /**
     * The values method returns a new collection with the keys reset to consecutive integers.
     */
    values<T>(): Collection<T>;

    /**
     * The when method will execute the given callback when the first argument given to the method evaluates to true.
     */
    when(condition: boolean, fn: (this: any) => any, defaultFn: (this: any) => any): void;

    /**
     * The where method filters the collection by a given key / value pair.
     */
    where<K, V>(key: keyof Item | K, value: V): Collection<Item>;

    /**
     * The where method filters the collection by a given key / value pair.
     */
    where<K, V>(key: keyof Item | K, operator: Operator, value: V): Collection<Item>;

    /**
     * The whereIn method filters the collection by a given key / value contained within the given array.
     */
    whereIn<K, V>(key: keyof Item | K, values: V[]): Collection<Item>;

    /**
     * The whereNotIn method filters the collection by a given key / value not contained within the given array.
     */
    whereNotIn<K, V>(key: keyof Item | K, values: V[]): Collection<Item>;

    /**
     * The wrap method will wrap the given value in a collection.
     */
    wrap<T>(value: T | T[] | Collection<T>): Collection<T>;

    /**
     * The zip method merges together the values of the given array with the values
     * of the original collection at the corresponding index.
     */
    zip<T>(array: T[]): Collection<[Item, T]>;

    [macroFn: string]: Function;
  }
}