import { $type, Eval, HKT, Kind, TyK, TyVar } from '@fp4ts/core';
import { Eq, Monoid } from '@fp4ts/cats-kernel';
import { Functor } from '../../functor';
import { SemigroupK } from '../../semigroup-k';
import { CoflatMap } from '../../coflat-map';
import { MonoidK } from '../../monoid-k';
import { Monad } from '../../monad';
import { Foldable } from '../../foldable';
import { Applicative } from '../../applicative';
import { Traversable } from '../../traversable';
import { Align } from '../../align';
import { EqK } from '../../eq-k';
import { Option } from '../option';
import { Either } from '../either';
import { Ior } from '../ior';
import { List } from './list';
import { Vector } from './vector';
import { View } from './view';
export type NonEmptyList<A> = _NonEmptyList<A>;
export declare const NonEmptyList: NonEmptyListObj;
declare class _NonEmptyList<out A> {
    readonly head: A;
    readonly tail: List<A>;
    constructor(head: A, tail: List<A>);
    get init(): List<A>;
    get last(): A;
    get uncons(): [A, List<A>];
    get popLast(): [A, List<A>];
    get size(): number;
    get iterator(): Iterator<A>;
    [Symbol.iterator](): Iterator<A>;
    get reverseIterator(): Iterator<A>;
    get reverse(): NonEmptyList<A>;
    get toArray(): A[];
    get toList(): List<A>;
    get view(): View<A>;
    get toVector(): Vector<A>;
    prepend<B>(this: NonEmptyList<B>, that: B): NonEmptyList<B>;
    cons<B>(this: NonEmptyList<B>, that: B): NonEmptyList<B>;
    '+::'<B>(this: NonEmptyList<B>, that: B): NonEmptyList<B>;
    append<B>(this: NonEmptyList<B>, that: B): NonEmptyList<B>;
    snoc<B>(this: NonEmptyList<B>, that: B): NonEmptyList<B>;
    '::+'<B>(this: NonEmptyList<B>, that: B): NonEmptyList<B>;
    concat<B>(this: NonEmptyList<B>, that: List<B>): NonEmptyList<B>;
    '+++'<B>(this: NonEmptyList<B>, that: List<B>): NonEmptyList<B>;
    concatNel<B>(this: NonEmptyList<B>, that: NonEmptyList<B>): NonEmptyList<B>;
    elem(idx: number): A;
    '!!'(idx: number): A;
    elemOption(idx: number): Option<A>;
    '!?'(idx: number): Option<A>;
    all(p: (a: A) => boolean): boolean;
    any(p: (a: A) => boolean): boolean;
    count(p: (a: A) => boolean): number;
    take(n: number): List<A>;
    takeWhile<B extends A>(p: (a: A) => a is B): List<B>;
    takeWhile(p: (a: A) => boolean): List<A>;
    takeRight(n: number): List<A>;
    drop(n: number): List<A>;
    dropWhile(p: (a: A) => boolean): List<A>;
    dropRight(n: number): List<A>;
    slice(from: number, to: number): List<A>;
    splitAt(idx: number): [List<A>, List<A>];
    filter(p: (a: A) => boolean): List<A>;
    collect<B>(f: (a: A) => Option<B>): List<B>;
    collectWhile<B>(f: (a: A) => Option<B>): List<B>;
    map<B>(f: (a: A) => B): NonEmptyList<B>;
    flatMap<B>(f: (a: A) => NonEmptyList<B>): NonEmptyList<B>;
    coflatMap<B>(f: (as: NonEmptyList<A>) => B): NonEmptyList<B>;
    flatten<B>(this: NonEmptyList<NonEmptyList<B>>): NonEmptyList<B>;
    align<B>(that: NonEmptyList<B>): NonEmptyList<Ior<A, B>>;
    zip<B>(that: NonEmptyList<B>): NonEmptyList<[A, B]>;
    zipWith<B, C>(that: NonEmptyList<B>, f: (a: A, b: B) => C): NonEmptyList<C>;
    get zipWithIndex(): NonEmptyList<[A, number]>;
    zipAll<AA, B>(this: NonEmptyList<AA>, that: NonEmptyList<B>, defaultL: () => AA, defaultR: () => B): NonEmptyList<[AA, B]>;
    zipAllWith<AA, B, C>(this: NonEmptyList<AA>, that: NonEmptyList<B>, defaultL: () => AA, defaultR: () => B, f: (a: AA, b: B) => C): NonEmptyList<C>;
    forEach(f: (a: A) => void): void;
    partition(f: (a: A) => boolean): [List<A>, List<A>];
    partitionWith<L, R>(f: (a: A) => Either<L, R>): [List<L>, List<R>];
    foldLeft<B>(z: B, f: (b: B, a: A) => B): B;
    foldLeft1<B>(this: NonEmptyList<B>, f: (x: B, y: B) => B): B;
    foldRight<B>(ez: Eval<B>, f: (a: A, eb: Eval<B>) => Eval<B>): Eval<B>;
    foldRight1<B>(this: NonEmptyList<B>, f: (x: B, ey: Eval<B>) => Eval<B>): Eval<B>;
    foldRight_<B>(z: B, f: (a: A, b: B) => B): B;
    foldRight1_<B>(this: NonEmptyList<B>, f: (x: B, y: B) => B): B;
    foldMap<M>(M: Monoid<M>): (f: (a: A) => M) => M;
    foldMapLeft<M>(M: Monoid<M>): (f: (a: A) => M) => M;
    foldMapK<F>(F: MonoidK<F>): <B>(f: (a: A) => Kind<F, [B]>) => Kind<F, [B]>;
    traverse<G>(G: Applicative<G>): <B>(f: (a: A) => Kind<G, [B]>) => Kind<G, [NonEmptyList<B>]>;
    equals<B>(this: NonEmptyList<B>, E: Eq<B>, that: NonEmptyList<B>): boolean;
    notEquals<B>(this: NonEmptyList<B>, E: Eq<B>, that: NonEmptyList<B>): boolean;
}
interface NonEmptyListObj {
    <A>(h: A, tl: List<A>): NonEmptyList<A>;
    pure<A>(a: A): NonEmptyList<A>;
    of<A>(h: A, ...tl: A[]): NonEmptyList<A>;
    fromList<A>(xs: List<A>): Option<NonEmptyList<A>>;
    unsafeFromList<A>(xs: List<A>): NonEmptyList<A>;
    fromVector<A>(xs: Vector<A>): Option<NonEmptyList<A>>;
    fromArray<A>(xs: A[]): Option<NonEmptyList<A>>;
    fromIterator<A>(it: Iterator<A>): Option<NonEmptyList<A>>;
    EqK: EqK<NonEmptyListF>;
    SemigroupK: SemigroupK<NonEmptyListF>;
    Functor: Functor<NonEmptyListF>;
    Align: Align<NonEmptyListF>;
    CoflatMap: CoflatMap<NonEmptyListF>;
    Monad: Monad<NonEmptyListF>;
    Foldable: Foldable<NonEmptyListF>;
    Traversable: Traversable<NonEmptyListF>;
}
interface _NonEmptyList<A> extends HKT<NonEmptyListF, [A]> {
}
/**
 * @category Type Constructor
 * @category Collection
 */
export interface NonEmptyListF extends TyK<[unknown]> {
    [$type]: NonEmptyList<TyVar<this, 0>>;
}
export {};
//# sourceMappingURL=non-empty-list.d.ts.map