/**
 * `Witherable` represents data structures which can be _partitioned_ with effects in some `Applicative` functor.
 *
 * Adapted from https://github.com/LiamGoodacre/purescript-filterable/blob/master/src/Data/Witherable.purs
 *
 * @remarks
 * Added in 1.0.0
 * @packageDocumentation
 */
import { type Applicative, type Applicative1, type Applicative2, type Applicative2C, type Applicative3, type Applicative3C } from "./Applicative.js";
import { type Compactable, type Compactable1, type Compactable2, type Compactable2C } from "./Compactable.js";
import { type Either } from "./Either.js";
import { type Filterable, type Filterable1, type Filterable2, type Filterable2C, type Filterable3 } from "./Filterable.js";
import { type HKT, type Kind, type Kind2, type Kind3, type URIS, type URIS2, type URIS3 } from "./HKT.js";
import { type Option } from "./Option.js";
import { type Separated } from "./Separated.js";
import { type Traversable, type Traversable1, type Traversable2, type Traversable2C, type Traversable3 } from "./Traversable.js";
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Category: Model
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface Witherable<T> extends Traversable<T>, Filterable<T> {
    /** Partition a structure with effects */
    readonly wilt: Wilt<T>;
    /** Filter a structure with effects */
    readonly wither: Wither<T>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Category: Model
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface Witherable1<T extends URIS> extends Traversable1<T>, Filterable1<T> {
    readonly wilt: Wilt1<T>;
    readonly wither: Wither1<T>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Category: Model
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface Witherable2<T extends URIS2> extends Traversable2<T>, Filterable2<T> {
    readonly wilt: Wilt2<T>;
    readonly wither: Wither2<T>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Category: Model
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface Witherable2C<T extends URIS2, TL> extends Traversable2C<T, TL>, Filterable2C<T, TL> {
    readonly wilt: Wilt2C<T, TL>;
    readonly wither: Wither2C<T, TL>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Category: Model
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface Witherable3<T extends URIS3> extends Traversable3<T>, Filterable3<T> {
    readonly wilt: Wilt3<T>;
    readonly wither: Wither3<T>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface Wither<W> {
    <F extends URIS3>(F: Applicative3<F>): <A, R, E, B>(ta: HKT<W, A>, f: (a: A) => Kind3<F, R, E, Option<B>>) => Kind3<F, R, E, HKT<W, B>>;
    <F extends URIS3, E>(F: Applicative3C<F, E>): <A, R, B>(ta: HKT<W, A>, f: (a: A) => Kind3<F, R, E, Option<B>>) => Kind3<F, R, E, HKT<W, B>>;
    <F extends URIS2>(F: Applicative2<F>): <A, E, B>(ta: HKT<W, A>, f: (a: A) => Kind2<F, E, Option<B>>) => Kind2<F, E, HKT<W, B>>;
    <F extends URIS2, E>(F: Applicative2C<F, E>): <A, B>(ta: HKT<W, A>, f: (a: A) => Kind2<F, E, Option<B>>) => Kind2<F, E, HKT<W, B>>;
    <F extends URIS>(F: Applicative1<F>): <A, B>(ta: HKT<W, A>, f: (a: A) => Kind<F, Option<B>>) => Kind<F, HKT<W, B>>;
    <F>(F: Applicative<F>): <A, B>(ta: HKT<W, A>, f: (a: A) => HKT<F, Option<B>>) => HKT<F, HKT<W, B>>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface Wither1<W extends URIS> {
    <F extends URIS3>(F: Applicative3<F>): <A, R, E, B>(ta: Kind<W, A>, f: (a: A) => Kind3<F, R, E, Option<B>>) => Kind3<F, R, E, Kind<W, B>>;
    <F extends URIS3, E>(F: Applicative3C<F, E>): <A, R, B>(ta: Kind<W, A>, f: (a: A) => Kind3<F, R, E, Option<B>>) => Kind3<F, R, E, Kind<W, B>>;
    <F extends URIS2>(F: Applicative2<F>): <A, E, B>(ta: Kind<W, A>, f: (a: A) => Kind2<F, E, Option<B>>) => Kind2<F, E, Kind<W, B>>;
    <F extends URIS2, E>(F: Applicative2C<F, E>): <A, B>(ta: Kind<W, A>, f: (a: A) => Kind2<F, E, Option<B>>) => Kind2<F, E, Kind<W, B>>;
    <F extends URIS>(F: Applicative1<F>): <A, B>(ta: Kind<W, A>, f: (a: A) => Kind<F, Option<B>>) => Kind<F, Kind<W, B>>;
    <F>(F: Applicative<F>): <A, B>(ta: Kind<W, A>, f: (a: A) => HKT<F, Option<B>>) => HKT<F, Kind<W, B>>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface Wither2<W extends URIS2> {
    <F extends URIS3>(F: Applicative3<F>): <WE, A, R, FE, B>(ta: Kind2<W, WE, A>, f: (a: A) => Kind3<F, R, FE, Option<B>>) => Kind3<F, R, FE, Kind2<W, WE, B>>;
    <F extends URIS2>(F: Applicative2<F>): <WE, A, FE, B>(ta: Kind2<W, WE, A>, f: (a: A) => Kind2<F, FE, Option<B>>) => Kind2<F, FE, Kind2<W, WE, B>>;
    <F extends URIS2, FE>(F: Applicative2C<F, FE>): <WE, A, B>(ta: Kind2<W, WE, A>, f: (a: A) => Kind2<F, FE, Option<B>>) => Kind2<F, FE, Kind2<W, WE, B>>;
    <F extends URIS>(F: Applicative1<F>): <E, A, B>(ta: Kind2<W, E, A>, f: (a: A) => Kind<F, Option<B>>) => Kind<F, Kind2<W, E, B>>;
    <F>(F: Applicative<F>): <E, A, B>(ta: Kind2<W, E, A>, f: (a: A) => HKT<F, Option<B>>) => HKT<F, Kind2<W, E, B>>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface Wither2C<W extends URIS2, E> {
    <F extends URIS3>(F: Applicative3<F>): <A, R, FE, B>(ta: Kind2<W, E, A>, f: (a: A) => Kind3<F, R, FE, Option<B>>) => Kind3<F, R, FE, Kind2<W, E, B>>;
    <F extends URIS2>(F: Applicative2<F>): <A, FE, B>(ta: Kind2<W, E, A>, f: (a: A) => Kind2<F, FE, Option<B>>) => Kind2<F, FE, Kind2<W, E, B>>;
    <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B>(ta: Kind2<W, E, A>, f: (a: A) => Kind2<F, FE, Option<B>>) => Kind2<F, FE, Kind2<W, E, B>>;
    <F extends URIS>(F: Applicative1<F>): <A, B>(ta: Kind2<W, E, A>, f: (a: A) => Kind<F, Option<B>>) => Kind<F, Kind2<W, E, B>>;
    <F>(F: Applicative<F>): <A, B>(ta: Kind2<W, E, A>, f: (a: A) => HKT<F, Option<B>>) => HKT<F, Kind2<W, E, B>>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface Wither3<W extends URIS3> {
    <F extends URIS3>(F: Applicative3<F>): <WR, WE, A, FR, FE, B>(ta: Kind3<W, WR, WE, A>, f: (a: A) => Kind3<F, FR, FE, Option<B>>) => Kind3<F, FR, FE, Kind3<W, WR, WE, B>>;
    <F extends URIS2>(F: Applicative2<F>): <WR, WE, A, FE, B>(ta: Kind3<W, WR, WE, A>, f: (a: A) => Kind2<F, FE, Option<B>>) => Kind2<F, FE, Kind3<W, WR, WE, B>>;
    <F extends URIS2, FE>(F: Applicative2C<F, FE>): <R, WE, A, B>(ta: Kind3<W, R, WE, A>, f: (a: A) => Kind2<F, FE, Option<B>>) => Kind2<F, FE, Kind3<W, R, WE, B>>;
    <F extends URIS>(F: Applicative1<F>): <R, E, A, B>(ta: Kind3<W, R, E, A>, f: (a: A) => Kind<F, Option<B>>) => Kind<F, Kind3<W, R, E, B>>;
    <F>(F: Applicative<F>): <R, E, A, B>(ta: Kind3<W, R, E, A>, f: (a: A) => HKT<F, Option<B>>) => HKT<F, Kind3<W, R, E, B>>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface Wilt<W> {
    <F extends URIS3>(F: Applicative3<F>): <A, R, E, B, C>(wa: HKT<W, A>, f: (a: A) => Kind3<F, R, E, Either<B, C>>) => Kind3<F, R, E, Separated<HKT<W, B>, HKT<W, C>>>;
    <F extends URIS3, E>(F: Applicative3C<F, E>): <A, R, B, C>(wa: HKT<W, A>, f: (a: A) => Kind3<F, R, E, Either<B, C>>) => Kind3<F, R, E, Separated<HKT<W, B>, HKT<W, C>>>;
    <F extends URIS2>(F: Applicative2<F>): <A, E, B, C>(wa: HKT<W, A>, f: (a: A) => Kind2<F, E, Either<B, C>>) => Kind2<F, E, Separated<HKT<W, B>, HKT<W, C>>>;
    <F extends URIS2, E>(F: Applicative2C<F, E>): <A, B, C>(wa: HKT<W, A>, f: (a: A) => Kind2<F, E, Either<B, C>>) => Kind2<F, E, Separated<HKT<W, B>, HKT<W, C>>>;
    <F extends URIS>(F: Applicative1<F>): <A, B, C>(wa: HKT<W, A>, f: (a: A) => Kind<F, Either<B, C>>) => Kind<F, Separated<HKT<W, B>, HKT<W, C>>>;
    <F>(F: Applicative<F>): <A, B, C>(wa: HKT<W, A>, f: (a: A) => HKT<F, Either<B, C>>) => HKT<F, Separated<HKT<W, B>, HKT<W, C>>>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface Wilt1<W extends URIS> {
    <F extends URIS3>(F: Applicative3<F>): <A, R, E, B, C>(wa: Kind<W, A>, f: (a: A) => Kind3<F, R, E, Either<B, C>>) => Kind3<F, R, E, Separated<Kind<W, B>, Kind<W, C>>>;
    <F extends URIS3, E>(F: Applicative3C<F, E>): <A, R, B, C>(wa: Kind<W, A>, f: (a: A) => Kind3<F, R, E, Either<B, C>>) => Kind3<F, R, E, Separated<Kind<W, B>, Kind<W, C>>>;
    <F extends URIS2>(F: Applicative2<F>): <A, E, B, C>(wa: Kind<W, A>, f: (a: A) => Kind2<F, E, Either<B, C>>) => Kind2<F, E, Separated<Kind<W, B>, Kind<W, C>>>;
    <F extends URIS2, E>(F: Applicative2C<F, E>): <A, B, C>(wa: Kind<W, A>, f: (a: A) => Kind2<F, E, Either<B, C>>) => Kind2<F, E, Separated<Kind<W, B>, Kind<W, C>>>;
    <F extends URIS>(F: Applicative1<F>): <A, B, C>(wa: Kind<W, A>, f: (a: A) => Kind<F, Either<B, C>>) => Kind<F, Separated<Kind<W, B>, Kind<W, C>>>;
    <F>(F: Applicative<F>): <A, B, C>(wa: Kind<W, A>, f: (a: A) => HKT<F, Either<B, C>>) => HKT<F, Separated<Kind<W, B>, Kind<W, C>>>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface Wilt2<W extends URIS2> {
    <F extends URIS3>(F: Applicative3<F>): <WE, A, R, FE, B, C>(wa: Kind2<W, WE, A>, f: (a: A) => Kind3<F, R, FE, Either<B, C>>) => Kind3<F, R, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>;
    <F extends URIS2>(F: Applicative2<F>): <WE, A, FE, B, C>(wa: Kind2<W, WE, A>, f: (a: A) => Kind2<F, FE, Either<B, C>>) => Kind2<F, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>;
    <F extends URIS2, FE>(F: Applicative2C<F, FE>): <WE, A, B, C>(wa: Kind2<W, WE, A>, f: (a: A) => Kind2<F, FE, Either<B, C>>) => Kind2<F, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>;
    <F extends URIS>(F: Applicative1<F>): <E, A, B, C>(wa: Kind2<W, E, A>, f: (a: A) => Kind<F, Either<B, C>>) => Kind<F, Separated<Kind2<W, E, B>, Kind2<W, E, C>>>;
    <F>(F: Applicative<F>): <E, A, B, C>(wa: Kind2<W, E, A>, f: (a: A) => HKT<F, Either<B, C>>) => HKT<F, Separated<Kind2<W, E, B>, Kind2<W, E, C>>>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface Wilt2C<W extends URIS2, E> {
    <F extends URIS3>(F: Applicative3<F>): <A, R, FE, B, C>(wa: Kind2<W, E, A>, f: (a: A) => Kind3<F, R, FE, Either<B, C>>) => Kind3<F, R, FE, Separated<Kind2<W, E, B>, Kind2<W, E, C>>>;
    <F extends URIS2>(F: Applicative2<F>): <A, FE, B, C>(wa: Kind2<W, E, A>, f: (a: A) => Kind2<F, FE, Either<B, C>>) => Kind2<F, FE, Separated<Kind2<W, E, B>, Kind2<W, E, C>>>;
    <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B, C>(wa: Kind2<W, E, A>, f: (a: A) => Kind2<F, FE, Either<B, C>>) => Kind2<F, FE, Separated<Kind2<W, E, B>, Kind2<W, E, C>>>;
    <F extends URIS>(F: Applicative1<F>): <A, B, C>(wa: Kind2<W, E, A>, f: (a: A) => Kind<F, Either<B, C>>) => Kind<F, Separated<Kind2<W, E, B>, Kind2<W, E, C>>>;
    <F>(F: Applicative<F>): <A, B, C>(wa: Kind2<W, E, A>, f: (a: A) => HKT<F, Either<B, C>>) => HKT<F, Separated<Kind2<W, E, B>, Kind2<W, E, C>>>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface Wilt3<W extends URIS3> {
    <F extends URIS3>(F: Applicative3<F>): <WR, WE, A, FR, FE, B, C>(wa: Kind3<W, WR, WE, A>, f: (a: A) => Kind3<F, FR, FE, Either<B, C>>) => Kind3<F, FR, FE, Separated<Kind3<W, WR, WE, B>, Kind3<W, WR, WE, C>>>;
    <F extends URIS2>(F: Applicative2<F>): <R, WE, A, FE, B, C>(wa: Kind3<W, R, WE, A>, f: (a: A) => Kind2<F, FE, Either<B, C>>) => Kind2<F, FE, Separated<Kind3<W, R, WE, B>, Kind3<W, R, WE, C>>>;
    <F extends URIS2, FE>(F: Applicative2C<F, FE>): <R, WE, A, B, C>(wa: Kind3<W, R, WE, A>, f: (a: A) => Kind2<F, FE, Either<B, C>>) => Kind2<F, FE, Separated<Kind3<W, R, WE, B>, Kind3<W, R, WE, C>>>;
    <F extends URIS>(F: Applicative1<F>): <R, E, A, B, C>(wa: Kind3<W, R, E, A>, f: (a: A) => Kind<F, Either<B, C>>) => Kind<F, Separated<Kind3<W, R, E, B>, Kind3<W, R, E, C>>>;
    <F>(F: Applicative<F>): <R, E, A, B, C>(wa: Kind3<W, R, E, A>, f: (a: A) => HKT<F, Either<B, C>>) => HKT<F, Separated<Kind3<W, R, E, B>, Kind3<W, R, E, C>>>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface PipeableWither<W> {
    <F extends URIS3>(F: Applicative3<F>): <A, R, E, B>(f: (a: A) => Kind3<F, R, E, Option<B>>) => (ta: HKT<W, A>) => Kind3<F, R, E, HKT<W, B>>;
    <F extends URIS3, E>(F: Applicative3C<F, E>): <A, R, B>(f: (a: A) => Kind3<F, R, E, Option<B>>) => (ta: HKT<W, A>) => Kind3<F, R, E, HKT<W, B>>;
    <F extends URIS2>(F: Applicative2<F>): <A, E, B>(f: (a: A) => Kind2<F, E, Option<B>>) => (ta: HKT<W, A>) => Kind2<F, E, HKT<W, B>>;
    <F extends URIS2, E>(F: Applicative2C<F, E>): <A, B>(f: (a: A) => Kind2<F, E, Option<B>>) => (ta: HKT<W, A>) => Kind2<F, E, HKT<W, B>>;
    <F extends URIS>(F: Applicative1<F>): <A, B>(f: (a: A) => Kind<F, Option<B>>) => (ta: HKT<W, A>) => Kind<F, HKT<W, B>>;
    <F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, Option<B>>) => (ta: HKT<W, A>) => HKT<F, HKT<W, B>>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface PipeableWither1<W extends URIS> {
    <F extends URIS3>(F: Applicative3<F>): <A, R, E, B>(f: (a: A) => Kind3<F, R, E, Option<B>>) => (ta: Kind<W, A>) => Kind3<F, R, E, Kind<W, B>>;
    <F extends URIS3, E>(F: Applicative3C<F, E>): <A, R, B>(f: (a: A) => Kind3<F, R, E, Option<B>>) => (ta: Kind<W, A>) => Kind3<F, R, E, Kind<W, B>>;
    <F extends URIS2>(F: Applicative2<F>): <A, E, B>(f: (a: A) => Kind2<F, E, Option<B>>) => (ta: Kind<W, A>) => Kind2<F, E, Kind<W, B>>;
    <F extends URIS2, E>(F: Applicative2C<F, E>): <A, B>(f: (a: A) => Kind2<F, E, Option<B>>) => (ta: Kind<W, A>) => Kind2<F, E, Kind<W, B>>;
    <F extends URIS>(F: Applicative1<F>): <A, B>(f: (a: A) => Kind<F, Option<B>>) => (ta: Kind<W, A>) => Kind<F, Kind<W, B>>;
    <F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, Option<B>>) => (ta: Kind<W, A>) => HKT<F, Kind<W, B>>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface PipeableWither2<W extends URIS2> {
    <F extends URIS3>(F: Applicative3<F>): <A, R, FE, B>(f: (a: A) => Kind3<F, R, FE, Option<B>>) => <WE>(ta: Kind2<W, WE, A>) => Kind3<F, R, FE, Kind2<W, WE, B>>;
    <F extends URIS2>(F: Applicative2<F>): <A, FE, B>(f: (a: A) => Kind2<F, FE, Option<B>>) => <WE>(ta: Kind2<W, WE, A>) => Kind2<F, FE, Kind2<W, WE, B>>;
    <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B>(f: (a: A) => Kind2<F, FE, Option<B>>) => <WE>(ta: Kind2<W, WE, A>) => Kind2<F, FE, Kind2<W, WE, B>>;
    <F extends URIS>(F: Applicative1<F>): <A, B>(f: (a: A) => Kind<F, Option<B>>) => <WE>(ta: Kind2<W, WE, A>) => Kind<F, Kind2<W, WE, B>>;
    <F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, Option<B>>) => <WE>(ta: Kind2<W, WE, A>) => HKT<F, Kind2<W, WE, B>>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface PipeableWither2C<W extends URIS2, WE> {
    <F extends URIS3>(F: Applicative3<F>): <A, R, FE, B>(f: (a: A) => Kind3<F, R, FE, Option<B>>) => (ta: Kind2<W, WE, A>) => Kind3<F, R, FE, Kind2<W, WE, B>>;
    <F extends URIS2>(F: Applicative2<F>): <A, FE, B>(f: (a: A) => Kind2<F, FE, Option<B>>) => (ta: Kind2<W, WE, A>) => Kind2<F, FE, Kind2<W, WE, B>>;
    <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B>(f: (a: A) => Kind2<F, FE, Option<B>>) => (ta: Kind2<W, WE, A>) => Kind2<F, FE, Kind2<W, WE, B>>;
    <F extends URIS>(F: Applicative1<F>): <A, B>(f: (a: A) => Kind<F, Option<B>>) => (ta: Kind2<W, WE, A>) => Kind<F, Kind2<W, WE, B>>;
    <F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, Option<B>>) => (ta: Kind2<W, WE, A>) => HKT<F, Kind2<W, WE, B>>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface PipeableWither3<W extends URIS3> {
    <F extends URIS3>(F: Applicative3<F>): <A, FR, FE, B>(f: (a: A) => Kind3<F, FR, FE, Option<B>>) => <WR, WE>(ta: Kind3<W, WR, WE, A>) => Kind3<F, FR, FE, Kind3<W, WR, WE, B>>;
    <F extends URIS2>(F: Applicative2<F>): <A, FE, B>(f: (a: A) => Kind2<F, FE, Option<B>>) => <WR, WE>(ta: Kind3<W, WR, WE, A>) => Kind2<F, FE, Kind3<W, WR, WE, B>>;
    <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B>(f: (a: A) => Kind2<F, FE, Option<B>>) => <WR, WE>(ta: Kind3<W, WR, WE, A>) => Kind2<F, FE, Kind3<W, WR, WE, B>>;
    <F extends URIS>(F: Applicative1<F>): <A, B>(f: (a: A) => Kind<F, Option<B>>) => <WR, WE>(ta: Kind3<W, WR, WE, A>) => Kind<F, Kind3<W, WR, WE, B>>;
    <F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, Option<B>>) => <WR, WE>(ta: Kind3<W, WR, WE, A>) => HKT<F, Kind3<W, WR, WE, B>>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface PipeableWilt<W> {
    <F extends URIS3>(F: Applicative3<F>): <A, R, E, B, C>(f: (a: A) => Kind3<F, R, E, Either<B, C>>) => (wa: HKT<W, A>) => Kind3<F, R, E, Separated<HKT<W, B>, HKT<W, C>>>;
    <F extends URIS3, E>(F: Applicative3C<F, E>): <A, R, B, C>(f: (a: A) => Kind3<F, R, E, Either<B, C>>) => (wa: HKT<W, A>) => Kind3<F, R, E, Separated<HKT<W, B>, HKT<W, C>>>;
    <F extends URIS2>(F: Applicative2<F>): <A, E, B, C>(f: (a: A) => Kind2<F, E, Either<B, C>>) => (wa: HKT<W, A>) => Kind2<F, E, Separated<HKT<W, B>, HKT<W, C>>>;
    <F extends URIS2, E>(F: Applicative2C<F, E>): <A, B, C>(f: (a: A) => Kind2<F, E, Either<B, C>>) => (wa: HKT<W, A>) => Kind2<F, E, Separated<HKT<W, B>, HKT<W, C>>>;
    <F extends URIS>(F: Applicative1<F>): <A, B, C>(f: (a: A) => Kind<F, Either<B, C>>) => (wa: HKT<W, A>) => Kind<F, Separated<HKT<W, B>, HKT<W, C>>>;
    <F>(F: Applicative<F>): <A, B, C>(f: (a: A) => HKT<F, Either<B, C>>) => (wa: HKT<W, A>) => HKT<F, Separated<HKT<W, B>, HKT<W, C>>>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface PipeableWilt1<W extends URIS> {
    <F extends URIS3>(F: Applicative3<F>): <A, R, E, B, C>(f: (a: A) => Kind3<F, R, E, Either<B, C>>) => (wa: Kind<W, A>) => Kind3<F, R, E, Separated<Kind<W, B>, Kind<W, C>>>;
    <F extends URIS3, E>(F: Applicative3C<F, E>): <A, R, B, C>(f: (a: A) => Kind3<F, R, E, Either<B, C>>) => (wa: Kind<W, A>) => Kind3<F, R, E, Separated<Kind<W, B>, Kind<W, C>>>;
    <F extends URIS2>(F: Applicative2<F>): <A, E, B, C>(f: (a: A) => Kind2<F, E, Either<B, C>>) => (wa: Kind<W, A>) => Kind2<F, E, Separated<Kind<W, B>, Kind<W, C>>>;
    <F extends URIS2, E>(F: Applicative2C<F, E>): <A, B, C>(f: (a: A) => Kind2<F, E, Either<B, C>>) => (wa: Kind<W, A>) => Kind2<F, E, Separated<Kind<W, B>, Kind<W, C>>>;
    <F extends URIS>(F: Applicative1<F>): <A, B, C>(f: (a: A) => Kind<F, Either<B, C>>) => (wa: Kind<W, A>) => Kind<F, Separated<Kind<W, B>, Kind<W, C>>>;
    <F>(F: Applicative<F>): <A, B, C>(f: (a: A) => HKT<F, Either<B, C>>) => (wa: Kind<W, A>) => HKT<F, Separated<Kind<W, B>, Kind<W, C>>>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface PipeableWilt2<W extends URIS2> {
    <F extends URIS3>(F: Applicative3<F>): <A, R, FE, B, C>(f: (a: A) => Kind3<F, R, FE, Either<B, C>>) => <WE>(wa: Kind2<W, WE, A>) => Kind3<F, R, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>;
    <F extends URIS2>(F: Applicative2<F>): <A, FE, B, C>(f: (a: A) => Kind2<F, FE, Either<B, C>>) => <WE>(wa: Kind2<W, WE, A>) => Kind2<F, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>;
    <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B, C>(f: (a: A) => Kind2<F, FE, Either<B, C>>) => <WE>(wa: Kind2<W, WE, A>) => Kind2<F, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>;
    <F extends URIS>(F: Applicative1<F>): <A, B, C>(f: (a: A) => Kind<F, Either<B, C>>) => <WE>(wa: Kind2<W, WE, A>) => Kind<F, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>;
    <F>(F: Applicative<F>): <A, B, C>(f: (a: A) => HKT<F, Either<B, C>>) => <WE>(wa: Kind2<W, WE, A>) => HKT<F, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface PipeableWilt2C<W extends URIS2, WE> {
    <F extends URIS3>(F: Applicative3<F>): <A, R, FE, B, C>(f: (a: A) => Kind3<F, R, FE, Either<B, C>>) => (wa: Kind2<W, WE, A>) => Kind3<F, R, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>;
    <F extends URIS2>(F: Applicative2<F>): <A, FE, B, C>(f: (a: A) => Kind2<F, FE, Either<B, C>>) => (wa: Kind2<W, WE, A>) => Kind2<F, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>;
    <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B, C>(f: (a: A) => Kind2<F, FE, Either<B, C>>) => (wa: Kind2<W, WE, A>) => Kind2<F, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>;
    <F extends URIS>(F: Applicative1<F>): <A, B, C>(f: (a: A) => Kind<F, Either<B, C>>) => (wa: Kind2<W, WE, A>) => Kind<F, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>;
    <F>(F: Applicative<F>): <A, B, C>(f: (a: A) => HKT<F, Either<B, C>>) => (wa: Kind2<W, WE, A>) => HKT<F, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>;
}
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface PipeableWilt3<W extends URIS3> {
    <F extends URIS3>(F: Applicative3<F>): <A, FR, FE, B, C>(f: (a: A) => Kind3<F, FR, FE, Either<B, C>>) => <WR, WE>(wa: Kind3<W, WR, WE, A>) => Kind3<F, FR, FE, Separated<Kind3<W, WR, WE, B>, Kind3<W, WR, WE, C>>>;
    <F extends URIS2>(F: Applicative2<F>): <A, FE, B, C>(f: (a: A) => Kind2<F, FE, Either<B, C>>) => <WR, WE>(wa: Kind3<W, WR, WE, A>) => Kind2<F, FE, Separated<Kind3<W, WR, WE, B>, Kind3<W, WR, WE, C>>>;
    <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B, C>(f: (a: A) => Kind2<F, FE, Either<B, C>>) => <WR, WE>(wa: Kind3<W, WR, WE, A>) => Kind2<F, FE, Separated<Kind3<W, WR, WE, B>, Kind3<W, WR, WE, C>>>;
    <F extends URIS>(F: Applicative1<F>): <A, B, C>(f: (a: A) => Kind<F, Either<B, C>>) => <WR, WE>(wa: Kind3<W, WR, WE, A>) => Kind<F, Separated<Kind3<W, WR, WE, B>, Kind3<W, WR, WE, C>>>;
    <F>(F: Applicative<F>): <A, B, C>(f: (a: A) => HKT<F, Either<B, C>>) => <WR, WE>(wa: Kind3<W, WR, WE, A>) => HKT<F, Separated<Kind3<W, WR, WE, B>, Kind3<W, WR, WE, C>>>;
}
/**
 * Return a `wilt` implementation from `Traversable` and `Compactable`.
 *
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Category: Defaults
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export declare function wiltDefault<W extends URIS2, E>(T: Traversable2C<W, E>, C: Compactable2<W>): Witherable2C<W, E>['wilt'];
export declare function wiltDefault<W extends URIS2, E>(T: Traversable2<W>, C: Compactable2C<W, E>): Witherable2C<W, E>['wilt'];
export declare function wiltDefault<W extends URIS>(T: Traversable1<W>, C: Compactable1<W>): Witherable1<W>['wilt'];
export declare function wiltDefault<W>(T: Traversable<W>, C: Compactable<W>): Witherable<W>['wilt'];
/**
 * Return a `wither` implementation from `Traversable` and `Compactable`.
 *
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Category: Defaults
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export declare function witherDefault<W extends URIS2, E>(T: Traversable2C<W, E>, C: Compactable2<W>): Witherable2C<W, E>['wither'];
export declare function witherDefault<W extends URIS2, E>(T: Traversable2<W>, C: Compactable2C<W, E>): Witherable2C<W, E>['wither'];
export declare function witherDefault<W extends URIS>(T: Traversable1<W>, C: Compactable1<W>): Witherable1<W>['wither'];
export declare function witherDefault<W>(T: Traversable<W>, C: Compactable<W>): Witherable<W>['wither'];
/**
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export interface FilterE1<G extends URIS> {
    <F extends URIS3>(F: Applicative3<F>): <A, R, E>(predicate: (a: A) => Kind3<F, R, E, boolean>) => (ga: Kind<G, A>) => Kind3<F, R, E, Kind<G, A>>;
    <F extends URIS3, E>(F: Applicative3C<F, E>): <A, R>(predicate: (a: A) => Kind3<F, R, E, boolean>) => (ga: Kind<G, A>) => Kind3<F, R, E, Kind<G, A>>;
    <F extends URIS2>(F: Applicative2<F>): <A, E>(predicate: (a: A) => Kind2<F, E, boolean>) => (ga: Kind<G, A>) => Kind2<F, E, Kind<G, A>>;
    <F extends URIS2, E>(F: Applicative2C<F, E>): <A>(predicate: (a: A) => Kind2<F, E, boolean>) => (ga: Kind<G, A>) => Kind2<F, E, Kind<G, A>>;
    <F extends URIS>(F: Applicative1<F>): <A>(predicate: (a: A) => Kind<F, boolean>) => (ga: Kind<G, A>) => Kind<F, Kind<G, A>>;
    <F>(F: Applicative<F>): <A>(predicate: (a: A) => HKT<F, boolean>) => (ga: Kind<G, A>) => HKT<F, Kind<G, A>>;
}
/**
 * Filter values inside a `F` context.
 *
 * See `ReadonlyArray`'s `filterE` for an example of usage.
 *
 * @remarks
 * Added in 1.0.0
 * @remarks
 * Original License: MIT – Copyright (c) 2017-present Giulio Canti
 * @public
 */
export declare function filterE<G extends URIS>(W: Witherable1<G>): FilterE1<G>;
export declare function filterE<G>(W: Witherable<G>): <F>(F: Applicative<F>) => <A>(predicate: (a: A) => HKT<F, boolean>) => (ga: HKT<G, A>) => HKT<F, HKT<G, A>>;
//# sourceMappingURL=Witherable.d.ts.map