import { Kind } from '@fp4ts/core';
import { Foldable } from '../../../foldable';
export declare abstract class Chain<out A> {
    readonly __void: void;
}
export declare const Empty: {
    readonly tag: "empty";
    readonly __void: void;
    readonly isEmpty: boolean;
    readonly nonEmpty: boolean;
    readonly size: number;
    readonly head: never;
    readonly headOption: import("../..").Option<never>;
    readonly tail: Chain<never>;
    readonly last: never;
    readonly lastOption: import("../..").Option<never>;
    readonly init: Chain<never>;
    readonly popHead: import("../..").Option<[never, Chain<never>]>;
    readonly uncons: import("../..").Option<[never, Chain<never>]>;
    readonly popLast: import("../..").Option<[never, Chain<never>]>;
    readonly toArray: never[];
    readonly toList: import("..").List<never>;
    readonly toVector: import("..").Vector<never>;
    readonly iterator: Iterator<never, any, undefined>;
    readonly reverseIterator: Iterator<never, any, undefined>;
    readonly reverse: Chain<never>;
    equals<B>(this: Chain<B>, E: import("@fp4ts/cats-kernel").Eq<B>, that: Chain<B>): boolean;
    notEquals<B_1>(this: Chain<B_1>, E: import("@fp4ts/cats-kernel").Eq<B_1>, that: Chain<B_1>): boolean;
    prepend<B_2>(this: Chain<B_2>, x: B_2): Chain<B_2>;
    cons<B_3>(this: Chain<B_3>, x: B_3): Chain<B_3>;
    '+::'<B_4>(this: Chain<B_4>, x: B_4): Chain<B_4>;
    append<B_5>(this: Chain<B_5>, x: B_5): Chain<B_5>;
    snoc<B_6>(this: Chain<B_6>, x: B_6): Chain<B_6>;
    '::+'<B_7>(this: Chain<B_7>, x: B_7): Chain<B_7>;
    concat<B_8>(this: Chain<B_8>, that: Chain<B_8>): Chain<B_8>;
    '+++'<B_9>(this: Chain<B_9>, that: Chain<B_9>): Chain<B_9>;
    deleteFirst(p: (a: never) => boolean): import("../..").Option<[never, Chain<never>]>;
    filter(p: (a: never) => boolean): Chain<never>;
    collect<B_10>(f: (a: never) => import("../..").Option<B_10>): Chain<B_10>;
    collectWhile<B_11>(f: (a: never) => import("../..").Option<B_11>): Chain<B_11>;
    map<B_12>(f: (a: never) => B_12): Chain<B_12>;
    flatMap<B_13>(f: (a: never) => Chain<B_13>): Chain<B_13>;
    coflatMap<B_14>(f: (as: Chain<never>) => B_14): Chain<B_14>;
    readonly flatten: never;
    align<B_15>(ys: Chain<B_15>): Chain<import("../..").Ior<never, B_15>>;
    zip<B_16>(ys: Chain<B_16>): Chain<[never, B_16]>;
    zipWith<B_17, C>(that: Chain<B_17>, f: (a: never, b: B_17) => C): Chain<C>;
    readonly zipWithIndex: Chain<[never, number]>;
    forEach(f: (a: never) => void): void;
    foldLeft<B_18>(z: B_18, f: (b: B_18, a: never) => B_18): B_18;
    foldRight<B_19>(z: B_19, f: (a: never, b: B_19) => B_19): B_19;
    foldMap<M>(M: import("@fp4ts/cats-kernel").Monoid<M>): (f: (a: never) => M) => M;
    foldMapLeft<M_1>(M: import("@fp4ts/cats-kernel").Monoid<M_1>): (f: (a: never) => M_1) => M_1;
    folding<AA>(this: Chain<AA>, M: import("@fp4ts/cats-kernel").Monoid<AA>): AA;
    traverse<G>(G: import("../../..").Applicative<G>): <B_20>(f: (a: never) => Kind<G, [B_20]>) => Kind<G, [Chain<B_20>]>;
    traverseFilter<G_1>(G: import("../../..").Applicative<G_1>): <B_21>(f: (a: never) => Kind<G_1, [import("../..").Option<B_21>]>) => Kind<G_1, [Chain<B_21>]>;
    [Symbol.iterator](): Iterator<never, any, undefined>;
    readonly F: import("./chain").ChainF;
    readonly Vars: [never];
};
export type Empty = typeof Empty;
export declare class Singleton<A> extends Chain<A> {
    readonly value: A;
    readonly tag = "singleton";
    constructor(value: A);
}
export declare class Concat<A> extends Chain<A> {
    readonly lhs: NonEmpty<A>;
    readonly rhs: NonEmpty<A>;
    readonly tag = "concat";
    constructor(lhs: NonEmpty<A>, rhs: NonEmpty<A>);
}
export declare class Wrap<F, A> extends Chain<A> {
    readonly instance: Foldable<F>;
    readonly values: Kind<F, [A]>;
    readonly tag = "wrap";
    constructor(instance: Foldable<F>, values: Kind<F, [A]>);
}
export type NonEmpty<A> = Singleton<A> | Concat<A> | Wrap<unknown, A>;
export type View<A> = Empty | NonEmpty<A>;
export declare const view: <A>(_: Chain<A>) => View<A>;
//# sourceMappingURL=algebra.d.ts.map