import { Kind } from '@fp4ts/core';
import { Eq, Monoid } from '@fp4ts/cats-kernel';
import { Applicative } from '../../../applicative';
import { Ior } from '../../ior';
import { Option } from '../../option';
import { Vector } from '../vector';
import { List } from '../list';
declare module './algebra' {
    interface Chain<out A> {
        readonly isEmpty: boolean;
        readonly nonEmpty: boolean;
        readonly size: number;
        readonly head: A;
        readonly headOption: Option<A>;
        readonly tail: Chain<A>;
        readonly last: A;
        readonly lastOption: Option<A>;
        readonly init: Chain<A>;
        readonly popHead: Option<[A, Chain<A>]>;
        readonly uncons: Option<[A, Chain<A>]>;
        readonly popLast: Option<[A, Chain<A>]>;
        readonly toArray: A[];
        readonly toList: List<A>;
        readonly toVector: Vector<A>;
        readonly iterator: Iterator<A>;
        readonly reverseIterator: Iterator<A>;
        [Symbol.iterator](): Iterator<A>;
        readonly reverse: Chain<A>;
        equals<B>(this: Chain<B>, E: Eq<B>, that: Chain<B>): boolean;
        notEquals<B>(this: Chain<B>, E: Eq<B>, that: Chain<B>): boolean;
        prepend<B>(this: Chain<B>, x: B): Chain<B>;
        cons<B>(this: Chain<B>, x: B): Chain<B>;
        '+::'<B>(this: Chain<B>, x: B): Chain<B>;
        append<B>(this: Chain<B>, x: B): Chain<B>;
        snoc<B>(this: Chain<B>, x: B): Chain<B>;
        '::+'<B>(this: Chain<B>, x: B): Chain<B>;
        concat<B>(this: Chain<B>, that: Chain<B>): Chain<B>;
        '+++'<B>(this: Chain<B>, that: Chain<B>): Chain<B>;
        deleteFirst(p: (a: A) => boolean): Option<[A, Chain<A>]>;
        filter(p: (a: A) => boolean): Chain<A>;
        collect<B>(f: (a: A) => Option<B>): Chain<B>;
        collectWhile<B>(f: (a: A) => Option<B>): Chain<B>;
        map<B>(f: (a: A) => B): Chain<B>;
        flatMap<B>(f: (a: A) => Chain<B>): Chain<B>;
        coflatMap<B>(f: (as: Chain<A>) => B): Chain<B>;
        readonly flatten: A extends Chain<infer B> ? Chain<B> : never;
        align<B>(ys: Chain<B>): Chain<Ior<A, B>>;
        zip<B>(ys: Chain<B>): Chain<[A, B]>;
        zipWith<B, C>(that: Chain<B>, f: (a: A, b: B) => C): Chain<C>;
        readonly zipWithIndex: Chain<[A, number]>;
        forEach(f: (a: A) => void): void;
        foldLeft<B>(z: B, f: (b: B, a: A) => B): B;
        foldRight<B>(z: B, f: (a: A, b: B) => B): B;
        foldMap<M>(M: Monoid<M>): (f: (a: A) => M) => M;
        foldMapLeft<M>(M: Monoid<M>): (f: (a: A) => M) => M;
        folding<AA>(this: Chain<AA>, M: Monoid<AA>): AA;
        traverse<G>(G: Applicative<G>): <B>(f: (a: A) => Kind<G, [B]>) => Kind<G, [Chain<B>]>;
        traverseFilter<G>(G: Applicative<G>): <B>(f: (a: A) => Kind<G, [Option<B>]>) => Kind<G, [Chain<B>]>;
    }
}
//# sourceMappingURL=syntax.d.ts.map