import { Eval, Base, Kind, Lazy } from '@fp4ts/core';
import { CommutativeMonoid, Monoid } from '@fp4ts/cats-kernel';
import { Alternative } from '../alternative';
import { Applicative } from '../applicative';
import { ApplicativeError } from '../applicative-error';
import { Apply } from '../apply';
import { Contravariant } from '../contravariant';
import { FlatMap } from '../flat-map';
import { Foldable } from '../foldable';
import { Functor } from '../functor';
import { FunctorFilter } from '../functor-filter';
import { Invariant } from '../invariant';
import { MonadError } from '../monad-error';
import { SemigroupK } from '../semigroup-k';
import { Traversable } from '../traversable';
import { UnorderedFoldable } from '../unordered-foldable';
import { UnorderedTraversable } from '../unordered-traversable';
import { Either } from './either';
import { Option } from './option';
export type SyntaxK<TC extends Base<any>, A> = _SyntaxK<TC, A>;
export declare function SyntaxK<TC extends Base<any>>(TC: TC): TransKPartiallyApplied<TC>;
export declare function SyntaxK<TC extends Base<any>, A>(TC: TC, value: Kind<TC['_F'], [A]>): SyntaxK<TC, A>;
export declare function SyntaxK<TC extends Base<any>, A>(TC: TC, value: Kind<TC['_F'], [A]>): SyntaxK<TC, A>;
interface TransKPartiallyApplied<TC extends Base<any>> {
    <A>(value: Kind<TC['_F'], [A]>): SyntaxK<TC, A>;
}
export declare class _SyntaxK<TC extends Base<any>, A> {
    readonly TC: TC;
    readonly value: Kind<TC['_F'], [A]>;
    constructor(TC: TC, value: Kind<TC['_F'], [A]>);
    imap<B>(this: SyntaxK<TC & Invariant<TC['_F']>, A>, f: (a: A) => B, g: (b: B) => A): SyntaxK<TC, B>;
    map<B>(this: SyntaxK<TC & Functor<TC['_F']>, A>, f: (a: A) => B): SyntaxK<TC, B>;
    tupleLeft<B>(this: SyntaxK<TC & Functor<TC['_F']>, A>, b: B): SyntaxK<TC, [B, A]>;
    tupleRight<B>(this: SyntaxK<TC & Functor<TC['_F']>, A>, b: B): SyntaxK<TC, [A, B]>;
    void(this: SyntaxK<TC & Functor<TC['_F']>, A>): SyntaxK<TC, void>;
    contramap<B>(this: SyntaxK<TC & Contravariant<TC['_F']>, A>, f: (b: B) => A): SyntaxK<TC, B>;
    mapFilter<B>(this: SyntaxK<TC & FunctorFilter<TC['_F']>, A>, f: (a: A) => Option<B>): SyntaxK<TC, B>;
    collect<B>(this: SyntaxK<TC & FunctorFilter<TC['_F']>, A>, f: (a: A) => Option<B>): SyntaxK<TC, B>;
    filter<B extends A>(this: SyntaxK<TC & FunctorFilter<TC['_F']>, A>, f: (a: A) => a is B): SyntaxK<TC, B>;
    filter(this: SyntaxK<TC & FunctorFilter<TC['_F']>, A>, f: (a: A) => boolean): SyntaxK<TC, A>;
    filterNot(this: SyntaxK<TC & FunctorFilter<TC['_F']>, A>, f: (a: A) => boolean): SyntaxK<TC, A>;
    apF<A, B>(this: SyntaxK<TC & Apply<TC['_F']>, (a: A) => B>, ff: Kind<TC['_F'], [A]>): SyntaxK<TC, B>;
    ap<A, B>(this: SyntaxK<TC & Apply<TC['_F']>, (a: A) => B>, ff: SyntaxK<TC, A>): SyntaxK<TC, B>;
    '<*>'<A, B>(this: SyntaxK<TC & Apply<TC['_F']>, (a: A) => B>, ff: SyntaxK<TC & Apply<TC['_F']>, A> | Kind<TC['_F'], [A]>): SyntaxK<TC, B>;
    map2F<A, B, C>(this: SyntaxK<TC & Apply<TC['_F']>, A>, that: Kind<TC['_F'], [B]>, f: (a: A, b: B) => C): SyntaxK<TC, C>;
    map2<A, B, C>(this: SyntaxK<TC & Apply<TC['_F']>, A>, that: SyntaxK<TC & Apply<TC['_F']>, B>, f: (a: A, b: B) => C): SyntaxK<TC, C>;
    map2EvalF<A, B, C>(this: SyntaxK<TC & Apply<TC['_F']>, A>, that: Eval<Kind<TC['_F'], [B]>>, f: (a: A, b: B) => C): Eval<SyntaxK<TC, C>>;
    map2Eval<A, B, C>(this: SyntaxK<TC & Apply<TC['_F']>, A>, that: Eval<SyntaxK<TC & Apply<TC['_F']>, B>>, f: (a: A, b: B) => C): Eval<SyntaxK<TC, C>>;
    productF<A, B>(this: SyntaxK<TC & Apply<TC['_F']>, A>, that: Kind<TC['_F'], [B]>): SyntaxK<TC, [A, B]>;
    product<A, B>(this: SyntaxK<TC & Apply<TC['_F']>, A>, that: SyntaxK<TC & Apply<TC['_F']>, B>): SyntaxK<TC, [A, B]>;
    productLF<A, B>(this: SyntaxK<TC & Apply<TC['_F']>, A>, that: Kind<TC['_F'], [B]>): SyntaxK<TC, A>;
    productL<A, B>(this: SyntaxK<TC & Apply<TC['_F']>, A>, that: SyntaxK<TC & Apply<TC['_F']>, B>): SyntaxK<TC, A>;
    '<*'<A, B>(this: SyntaxK<TC & Apply<TC['_F']>, A>, that: SyntaxK<TC & Apply<TC['_F']>, B> | Kind<TC['_F'], [B]>): SyntaxK<TC, A>;
    productRF<A, B>(this: SyntaxK<TC & Apply<TC['_F']>, A>, that: Kind<TC['_F'], [B]>): SyntaxK<TC, B>;
    productR<A, B>(this: SyntaxK<TC & Apply<TC['_F']>, A>, that: SyntaxK<TC & Apply<TC['_F']>, B>): SyntaxK<TC, B>;
    '*>'<A, B>(this: SyntaxK<TC & Apply<TC['_F']>, A>, that: SyntaxK<TC & Apply<TC['_F']>, B> | Kind<TC['_F'], [B]>): SyntaxK<TC, B>;
    flatMapF<B>(this: SyntaxK<TC & FlatMap<TC['_F']>, A>, f: (a: A) => Kind<TC['_F'], [B]>): SyntaxK<TC, B>;
    flatMap<B>(this: SyntaxK<TC & FlatMap<TC['_F']>, A>, f: (a: A) => SyntaxK<TC & FlatMap<TC['_F']>, B>): SyntaxK<TC, B>;
    '>>='<B>(this: SyntaxK<TC & FlatMap<TC['_F']>, A>, f: (a: A) => SyntaxK<TC & FlatMap<TC['_F']>, B> | Kind<TC['_F'], [B]>): SyntaxK<TC, B>;
    handleError<TC extends ApplicativeError<any, any>>(this: SyntaxK<TC, A>, f: (e: TC['_E']) => A): SyntaxK<TC, A>;
    handleErrorWithF<TC extends ApplicativeError<any, any>>(this: SyntaxK<TC, A>, f: (e: TC['_E']) => Kind<TC['_F'], [A]>): SyntaxK<TC, A>;
    handleErrorWith<TC extends ApplicativeError<any, any>>(this: SyntaxK<TC, A>, f: (e: TC['_E']) => SyntaxK<TC, A>): SyntaxK<TC, A>;
    attempt<TC extends ApplicativeError<any, any>>(this: SyntaxK<TC, A>): SyntaxK<TC, Either<TC['_E'], A>>;
    redeem<B, TC extends ApplicativeError<any, any>>(this: SyntaxK<TC, A>, h: (e: TC['_E']) => B, f: (a: A) => B): SyntaxK<TC, B>;
    onErrorF<TC extends ApplicativeError<any, any>>(this: SyntaxK<TC, A>, h: (e: TC['_E']) => Kind<TC['_F'], [void]>): SyntaxK<TC, A>;
    onError<TC extends ApplicativeError<any, any>>(this: SyntaxK<TC, A>, h: (e: TC['_E']) => SyntaxK<TC, void>): SyntaxK<TC, A>;
    redeemWithF<B, TC extends MonadError<any, any>>(this: SyntaxK<TC, A>, h: (e: TC['_E']) => Kind<TC['_F'], [B]>, f: (a: A) => Kind<TC['_F'], [B]>): SyntaxK<TC, B>;
    redeemWith<B, TC extends MonadError<any, any>>(this: SyntaxK<TC, A>, h: (e: TC['_E']) => SyntaxK<TC, B>, f: (a: A) => SyntaxK<TC, B>): SyntaxK<TC, B>;
    rethrow<TC extends MonadError<any, any>>(this: SyntaxK<TC, Either<TC['_E'], A>>): SyntaxK<TC, A>;
    combineKF<TC extends SemigroupK<any>>(this: SyntaxK<TC, A>, that: Lazy<Kind<TC['_F'], [A]>>): SyntaxK<TC, A>;
    combineK<TC extends SemigroupK<any>>(this: SyntaxK<TC, A>, that: Lazy<SyntaxK<TC, A>>): SyntaxK<TC, A>;
    orElseF<TC extends Alternative<any>>(this: SyntaxK<TC, A>, that: Lazy<Kind<TC['_F'], [A]>>): SyntaxK<TC, A>;
    orElse<TC extends Alternative<any>>(this: SyntaxK<TC, A>, that: Lazy<SyntaxK<TC, A>>): SyntaxK<TC, A>;
    unorderedFoldMap<M, TC extends UnorderedFoldable<any>>(this: SyntaxK<TC, A>, M: CommutativeMonoid<M>): (f: (a: A) => M) => M;
    unorderedFold<TC extends UnorderedFoldable<any>>(this: SyntaxK<TC, A>, M: CommutativeMonoid<A>): A;
    isEmpty<TC extends UnorderedFoldable<any>>(this: SyntaxK<TC, A>): boolean;
    nonEmpty<TC extends UnorderedFoldable<any>>(this: SyntaxK<TC, A>): boolean;
    all<TC extends UnorderedFoldable<any>>(this: SyntaxK<TC, A>, p: (a: A) => boolean): boolean;
    any<TC extends UnorderedFoldable<any>>(this: SyntaxK<TC, A>, p: (a: A) => boolean): boolean;
    count<TC extends UnorderedFoldable<any>>(this: SyntaxK<TC, A>, p: (a: A) => boolean): number;
    size<TC extends UnorderedFoldable<any>>(this: SyntaxK<TC, A>, p: (a: A) => boolean): number;
    foldMap<M, TC extends Foldable<any>>(this: SyntaxK<TC, A>, M: Monoid<M>): (f: (a: A) => M) => M;
    foldLeft<B, TC extends Foldable<any>>(this: SyntaxK<TC, A>, z: B, f: (b: B, a: A) => B): B;
    foldRight<B, TC extends Foldable<any>>(this: SyntaxK<TC, A>, ez: Eval<B>, f: (a: A, eb: Eval<B>) => Eval<B>): Eval<B>;
    elem<TC extends Foldable<any>>(this: SyntaxK<TC, A>, idx: number): Option<A>;
    unorderedTraverse<G, TC extends UnorderedTraversable<any>>(this: SyntaxK<TC, A>, G: Applicative<G>): <B>(f: (a: A) => Kind<G, [B]>) => Kind<G, [Kind<TC['_F'], [B]>]>;
    traverse<G, TC extends Traversable<any>>(this: SyntaxK<TC, A>, G: Applicative<G>): <B>(f: (a: A) => Kind<G, [B]>) => Kind<G, [Kind<TC['_F'], [B]>]>;
}
export {};
//# sourceMappingURL=syntax-k.d.ts.map