import { Mappable } from './mappable.js';
import { HashMap, HashSet, Option } from './index.js';
import { Filterable } from './util.js';
import { ArrayIterable } from './array-iterable.js';
export declare abstract class ArrayBackedCollection<T, C extends ArrayIterable<T, any>> extends ArrayIterable<T, C> {
    protected abstract readonly items: T[];
    protected checkWithinBounds(lo: number, hi: number): void;
    get reverse(): C;
    get toArray(): T[];
    get(index: number): T;
    get toSet(): HashSet<T>;
    indexOf(item: T): number;
    get distinct(): C;
    distinctBy(key: (item: T) => string | number): C;
    appended(item: T): C;
    appendedAll(other: Iterable<T>): C;
    prepended(item: T): C;
    prependedAll(other: Iterable<T>): C;
    concat(other: Iterable<T>): C;
    slice(from: number, until: number): C;
    sort(param: (a: T, b: T) => number): C;
    sortBy(fieldToNumber: (a: T) => number): C;
    get length(): number;
}
export declare class Collection<T> extends ArrayBackedCollection<T, Collection<T>> implements Mappable<T>, Filterable<T, Collection<T>> {
    protected readonly items: T[];
    constructor(items: T[]);
    static empty: Collection<any>;
    protected fromArray(array: T[]): Collection<T>;
    static of<T>(...items: T[]): Collection<T>;
    static from<T>(elements: Iterable<T>): Collection<T>;
    static fill<A>(len: number): (elem: (idx: number) => A) => Collection<A>;
    map<B>(f: (item: T) => B): Collection<B>;
    flatMap<B>(f: (item: T) => Collection<B>): Collection<B>;
    flatMapOption<B>(f: (item: T) => Option<B>): Collection<B>;
    mapPromise<B>(f: (v: T) => Promise<B>): Promise<Collection<B>>;
    mapPromiseAll<B>(f: (v: T) => Promise<B>): Promise<Collection<B>>;
    flatMapPromise<B>(f: (item: T) => Promise<Collection<B>>): Promise<Collection<B>>;
    flatMapPromiseAll<B>(f: (v: T) => Promise<Collection<B>>): Promise<Collection<B>>;
    flatten<B>(): Collection<B>;
    get toBuffer(): ArrayBuffer<T>;
    toMap<K, V>(mapper: (item: T) => [K, V]): HashMap<K, V>;
    zip<B>(that: Collection<B>): Collection<[T, B]>;
    zipAll<B>(that: Collection<B>, thisElem: T, thatElem: B): Collection<[T, B]>;
}
export declare const Nil: Collection<any>;
export declare class ArrayBuffer<T> extends ArrayBackedCollection<T, ArrayBuffer<T>> implements Mappable<T>, Filterable<T, ArrayBuffer<T>> {
    protected readonly items: T[];
    static get empty(): ArrayBuffer<any>;
    constructor(items?: T[]);
    static of<T>(...elements: T[]): ArrayBuffer<T>;
    static from<T>(elements: Iterable<T>): ArrayBuffer<T>;
    static fill<A>(len: number): (elem: (idx: number) => A) => ArrayBuffer<A>;
    protected fromArray(array: T[]): ArrayBuffer<T>;
    private normalized;
    update(index: number, element: T): void;
    set(index: number, element: T): void;
    clear(): void;
    append(element: T): this;
    appendAll(elements: Iterable<T>): this;
    prepend(element: T): this;
    prependAll(elements: Iterable<T>): this;
    insert(idx: number, element: T): void;
    insertAll(idx: number, elements: Iterable<T>): void;
    remove(index: number, count?: number): void;
    subtractOne(element: T): this;
    subtractAll(elements: Iterable<T>): this;
    sort(compareFn?: (a: T, b: T) => number): this;
    filterInPlace(p: (element: T) => boolean): this;
    dropInPlace(n: number): this;
    dropRightInPlace(n: number): this;
    takeInPlace(n: number): this;
    takeRightInPlace(n: number): this;
    sliceInPlace(start: number, end: number): this;
    get toCollection(): Collection<T>;
    flatMap<B>(f: (item: T) => ArrayBuffer<B>): ArrayBuffer<B>;
    flatMapOption<B>(f: (item: T) => Option<B>): ArrayBuffer<B>;
    flatMapPromise<B>(f: (item: T) => Promise<ArrayBuffer<B>>): Promise<ArrayBuffer<B>>;
    map<B>(f: (item: T) => B): ArrayBuffer<B>;
    mapPromise<B>(f: (v: T) => Promise<B>): Promise<ArrayBuffer<B>>;
    mapPromiseAll<B>(f: (v: T) => Promise<B>): Promise<ArrayBuffer<B>>;
    flatMapPromiseAll<B>(f: (v: T) => Promise<ArrayBuffer<B>>): Promise<ArrayBuffer<B>>;
    flatten<B>(): ArrayBuffer<B>;
    toMap<K, V>(mapper: (item: T) => [K, V]): HashMap<K, V>;
}