export type List<I> = Array<I> | Set<I>;
/** Get the first item in the array */
export declare function first<T>(arr: Array<T>): T;
/** Get the last item in the array */
export declare function last<T>(arr: Array<T>): T;
/** Check if the list includes the item */
export declare function has<T>(list: List<T> | undefined, item: T): boolean;
/** Add the items to the list */
export declare function append<T>(list: List<T>, items: List<T>): List<T>;
/** Add the item(s) to the list */
export declare function add<T>(list: List<T>, ...items: Array<T>): List<T>;
/** Add or remove the item within the set based on whether a flag is truthy */
export declare function toggle<T>(list: Set<T>, value: T | Array<T>, flag: any): Set<T>;
/** Get a new array with only truthy and non-duplicates returned */
export declare function unique<T>(list: Array<T>): T[];
/**
 * Get the distinct elements from both the lists.
 * Given two sets A and B, their union is the set consisting of all objects which are elements of A or of B or of both (see axiom of union). It is denoted by A ∪ B.
 * https://en.wikipedia.org/wiki/Naive_set_theory
 * @param list The left subset.
 * @param include The right subset.
 * @returns the superset/combination of both lists, without redundancy.
 */
export declare function union<T>(list: Array<T>, include: Array<T>): T[];
/**
 * Get the elements from the list that only also exist within the other list.
 * The intersection of A and B is the set of all objects which are both in A and in B. It is denoted by A ∩ B.
 * https://en.wikipedia.org/wiki/Naive_set_theory
 * @param list The left set to intersect.
 * @param allowlist The right set to intersect.
 * @returns the intersection, the values that are within both sets
 */
export declare function intersect<T>(list: Array<T>, allowlist: Array<T>): T[];
/**
 * Get the list without elements from the other list.
 * Finally, the relative complement of B relative to A, also known as the set theoretic difference of A and B, is the set of all objects that belong to A but not to B. It is written as A \ B or A − B.
 * https://en.wikipedia.org/wiki/Naive_set_theory
 * @param list The superset.
 * @param blacklist The excluded subset.
 */
export declare function complement<T>(list: Array<T>, blacklist: Array<T>): T[];
/** Flatten the array, merging any nested array no matter the depth, into a single array. */
export declare function flatten<T>(list: Array<T | Array<T>>): Array<T>;
/** Fetch every item in the list, until a particular one. */
export declare function until<T>(list: List<T>, until: T, inclusive?: boolean): Array<T>;
//# sourceMappingURL=index.d.ts.map