import { Block, Comparator, Dictionary, PairPredicate, Positional, Predicate, Sequence, Transform } from "../types";
import { OmniSequence } from "./omni-sequence";
/**
 * @hidden
 */
export declare type PipeConstructor = {
    new (sequence: Sequence<any>): OmniSequence<any>;
};
/**
 * @hidden
 */
export declare function injectPipeConstructor(constructor: PipeConstructor): void;
/**
 * An omni-sequence that is iterable more than once and supports random access.
 */
export declare class Span<T> implements OmniSequence<T> {
    constructor(positional: Positional<T>);
    constructor(positional: Positional<T>, start: number);
    constructor(positional: Positional<T>, start: number, end: number);
    /**
     * The underlying array or string of the span.
     */
    private _array;
    /**
     * The underlying array or string of the span.
     */
    readonly array: Positional<T>;
    /**
     * The start index of the span.
     */
    private _start;
    /**
     * The start index of the span.
     */
    readonly start: number;
    /**
     * The non-inclusive end index of the span.
     */
    private _end;
    /**
     * The non-inclusive end index of the span.
     */
    readonly end: number;
    [Symbol.iterator](): Iterator<T>;
    toString(): string;
    all(predicate: Predicate<T>): boolean;
    as<O extends T>(this: Span<T>): OmniSequence<O>;
    concat(elements: Sequence<T>): OmniSequence<T>;
    append(...elements: T[]): OmniSequence<T>;
    associate<K>(transform: Transform<T, K>): OmniSequence<[K, T]>;
    at(index: number): T;
    cleave(index: number): [T[], T[]];
    count(): number;
    count(predicate: Predicate<T>): number;
    cut(index: number): OmniSequence<T>;
    cut(index: number, count: number): OmniSequence<T>;
    chunk(count: number): OmniSequence<T[]>;
    difference<K>(sequence: Sequence<T>): OmniSequence<T>;
    difference<K>(sequence: Sequence<T>, transform: Transform<T, K>): OmniSequence<T>;
    done(): T[];
    drop(): OmniSequence<T>;
    drop(count: number): OmniSequence<T>;
    drop(predicate: Predicate<T>): OmniSequence<T>;
    dropLast(): OmniSequence<T>;
    dropLast(count: number): OmniSequence<T>;
    dropLast(predicate: Predicate<T>): OmniSequence<T>;
    each(action: (element: T, index: number, end: Block) => void): OmniSequence<T>;
    endsWith(suffix: Positional<T>): boolean;
    endsWith(suffix: Positional<T>, equals: PairPredicate<T>): boolean;
    entries(): OmniSequence<[number, T]>;
    entriesReversed(): OmniSequence<[number, T]>;
    filter(): OmniSequence<T>;
    filter(predicate: Predicate<T>): OmniSequence<T>;
    find(predicate: Predicate<T>): T | null;
    find<O>(predicate: Predicate<T>, instead: O): T | O;
    findLast(predicate: Predicate<T>): T | null;
    findLast<O>(predicate: Predicate<T>, instead: O): T | O;
    first<O>(): T;
    first<O>(instead: O): T | O;
    flat<T>(this: Span<Sequence<T>>): OmniSequence<T>;
    fold<R>(initial: R, reducer: (accumulator: R, current: T) => R): R;
    index(predicate: Predicate<T>): number;
    indices(): OmniSequence<number>;
    indices(predicate: Predicate<T>): OmniSequence<number>;
    indicesReversed(): OmniSequence<number>;
    indicesReversed(predicate: Predicate<T>): OmniSequence<number>;
    inject(index: number, elements: Sequence<T>): OmniSequence<T>;
    intersect<K>(sequence: Sequence<T>): OmniSequence<T>;
    intersect<K>(sequence: Sequence<T>, transform: Transform<T, K>): OmniSequence<T>;
    insert(index: number, ...elements: T[]): OmniSequence<T>;
    invert<K, V>(this: Span<[K, V]>): OmniSequence<[V, K]>;
    join(): string;
    join(separator: string): string;
    last<O>(): T;
    last<O>(instead: O): T | O;
    lastIndex(): number;
    lastIndex(predicate: Predicate<T>): number;
    map<OK, OV>(this: Span<T>, transform: Transform<T, [OK, OV]>): OmniSequence<[OK, OV]>;
    map<O>(this: Span<T>, transform: Transform<T, O>): OmniSequence<O>;
    max(this: Span<number>): number;
    max(transform: Transform<T, number>): T;
    mean(this: Span<number>): number;
    min(this: Span<number>): number;
    min(transform: Transform<T, number>): T;
    none(): boolean;
    none(predicate: Predicate<T>): boolean;
    partition(predicate: Predicate<T>): [T[], T[]];
    permute<T>(): OmniSequence<T[]>;
    prepend(...elements: T[]): OmniSequence<T>;
    rank(transform: Transform<T, number>): OmniSequence<T>;
    remove(predicate: Predicate<T>): OmniSequence<T>;
    remove(predicate: Predicate<T>, count: number): OmniSequence<T>;
    removeLast(predicate: Predicate<T>, count: number): OmniSequence<T>;
    repeat(): OmniSequence<T>;
    repeat(count: number): OmniSequence<T>;
    replace<R>(predicate: Predicate<T>, replacement: R): OmniSequence<T | R>;
    replace<R>(predicate: Predicate<T>, replacement: R, count: number): OmniSequence<T | R>;
    replaceLast<R>(predicate: Predicate<T>, replacement: R, count: number): OmniSequence<T | R>;
    reversed(): OmniSequence<T>;
    set(index: number, element: T): OmniSequence<T>;
    slice(start: number, end: number): OmniSequence<T>;
    solid(): Span<T>;
    some(): boolean;
    some(predicate: Predicate<T>): boolean;
    sort(this: Span<number>): OmniSequence<number>;
    sort(this: Span<number>, descending: boolean): OmniSequence<number>;
    sort(this: Span<string>): OmniSequence<string>;
    sort(this: Span<string>, descending: boolean): OmniSequence<string>;
    sort(comparator: Comparator<T>): OmniSequence<T>;
    startsWith(prefix: Sequence<T>): boolean;
    startsWith(prefix: Sequence<T>, equals: PairPredicate<T>): boolean;
    sum(this: Span<number>): number;
    swap(first: number, second: number): OmniSequence<T>;
    take(): OmniSequence<T>;
    take(count: number): OmniSequence<T>;
    take(predicate: Predicate<T>): OmniSequence<T>;
    takeLast(count: number): OmniSequence<T>;
    takeLast(predicate: Predicate<T>): OmniSequence<T>;
    toArray(): T[];
    toArray(destination: T[]): T[];
    toArray(destination: T[], clear: boolean): T[];
    toMap<K, V>(this: Span<[K, V]>): Map<K, V>;
    toMap<K, V>(this: Span<[K, V]>, destination: Map<K, V>): Map<K, V>;
    toMap<K, V>(this: Span<[K, V]>, destination: Map<K, V>, clear: boolean): Map<K, V>;
    toObject<V>(this: Span<[string, V]>): Dictionary<V>;
    toObject<V>(this: Span<[string, V]>, destination: Dictionary<V>): Dictionary<V>;
    toObject<V>(this: Span<[string, V]>, destination: Dictionary<V>, clear: boolean): Dictionary<V>;
    toSet(): Set<T>;
    toSet(destination: Set<T>): Set<T>;
    toSet(destination: Set<T>, clear: boolean): Set<T>;
    union<K>(sequence: Sequence<T>): OmniSequence<T>;
    union<K>(sequence: Sequence<T>, transform: Transform<T, K>): OmniSequence<T>;
    unique<K>(): OmniSequence<T>;
    unique<K>(transform: Transform<T, K>): OmniSequence<T>;
    use<R>(transform: Transform<Span<T>, R>): R;
    yank(): Span<T>;
    zip<V>(elements: Sequence<V>): OmniSequence<[T, V]>;
    private _index(predicate, reverse?);
    private _indexNot(predicate, reverse?);
    private _iterate(reverse);
    private _after(start);
    private _before(end);
    private _copy();
    private _empty();
    private _sanitizeIndex(index);
    private _sanitizeCount(count);
    private _seat(positional);
    private _slice(start, end);
}