import { Refinement } from 'fp-ts/es6/function';
import * as TE from 'fp-ts/es6/TaskEither';
import * as DE from './DecodeError';
import * as FS from './FreeSemigroup';
import * as K from './Kleisli';
import * as KD from './KleisliDecoder';
import { Literal } from './Schemable';
/**
 * @category model
 * @since 2.2.7
 */
export interface KleisliTaskDecoder<I, A> extends K.Kleisli<TE.URI, I, DecodeError, A> {
}
/**
 * @category DecodeError
 * @since 2.2.7
 */
export declare type DecodeError = KD.DecodeError;
/**
 * @category DecodeError
 * @since 2.2.7
 */
export declare const error: (actual: unknown, message: string) => DecodeError;
/**
 * @category DecodeError
 * @since 2.2.7
 */
export declare const success: <A>(a: A) => TE.TaskEither<DecodeError, A>;
/**
 * @category DecodeError
 * @since 2.2.7
 */
export declare const failure: <A = never>(actual: unknown, message: string) => TE.TaskEither<FS.FreeSemigroup<DE.DecodeError<string>>, A>;
/**
 * @category constructors
 * @since 2.2.7
 */
export declare const fromKleisliDecoder: <I, A>(decoder: KD.KleisliDecoder<I, A>) => KleisliTaskDecoder<I, A>;
/**
 * @category constructors
 * @since 2.2.7
 */
export declare const fromRefinement: <I, A extends I>(refinement: Refinement<I, A>, expected: string) => KleisliTaskDecoder<I, A>;
/**
 * @category constructors
 * @since 2.2.7
 */
export declare const literal: <A extends readonly [Literal, ...Array<Literal>]>(...values: A) => KleisliTaskDecoder<unknown, A[number]>;
/**
 * @category combinators
 * @since 2.2.7
 */
export declare const mapLeftWithInput: <I>(f: (input: I, e: DecodeError) => DecodeError) => <A>(decoder: KleisliTaskDecoder<I, A>) => KleisliTaskDecoder<I, A>;
/**
 * @category combinators
 * @since 2.2.7
 */
export declare const refine: <A, B extends A>(refinement: (a: A) => a is B, id: string) => <I>(from: KleisliTaskDecoder<I, A>) => KleisliTaskDecoder<I, B>;
/**
 * @category combinators
 * @since 2.2.7
 */
export declare const parse: <A, B>(parser: (a: A) => TE.TaskEither<DecodeError, B>) => <I>(from: KleisliTaskDecoder<I, A>) => KleisliTaskDecoder<I, B>;
/**
 * @category combinators
 * @since 2.2.7
 */
export declare const nullable: <I, A>(or: KleisliTaskDecoder<I, A>) => KleisliTaskDecoder<null | I, null | A>;
/**
 * @category combinators
 * @since 2.2.7
 */
export declare const type: <P extends Record<string, KleisliTaskDecoder<any, any>>>(properties: P) => KleisliTaskDecoder<{ [K in keyof P]: K.InputOf<"TaskEither", P[K]>; }, { [K_1 in keyof P]: K.TypeOf<"TaskEither", P[K_1]>; }>;
/**
 * @category combinators
 * @since 2.2.7
 */
export declare const partial: <P extends Record<string, KleisliTaskDecoder<any, any>>>(properties: P) => KleisliTaskDecoder<{ [K in keyof P]: K.InputOf<"TaskEither", P[K]>; }, Partial<{ [K_1 in keyof P]: K.TypeOf<"TaskEither", P[K_1]>; }>>;
/**
 * @category combinators
 * @since 2.2.7
 */
export declare const array: <I, A>(items: KleisliTaskDecoder<I, A>) => KleisliTaskDecoder<I[], A[]>;
/**
 * @category combinators
 * @since 2.2.7
 */
export declare const record: <I, A>(codomain: KleisliTaskDecoder<I, A>) => KleisliTaskDecoder<Record<string, I>, Record<string, A>>;
/**
 * @category combinators
 * @since 2.2.7
 */
export declare const tuple: <C extends readonly KleisliTaskDecoder<any, any>[]>(...components: C) => KleisliTaskDecoder<{ [K in keyof C]: K.InputOf<"TaskEither", C[K]>; }, { [K_1 in keyof C]: K.TypeOf<"TaskEither", C[K_1]>; }>;
/**
 * @category combinators
 * @since 2.2.7
 */
export declare const union: <MS extends readonly [KleisliTaskDecoder<any, any>, ...Array<KleisliTaskDecoder<any, any>>]>(...members: MS) => KleisliTaskDecoder<InputOf<MS[keyof MS]>, TypeOf<MS[keyof MS]>>;
/**
 * @category combinators
 * @since 2.2.7
 */
export declare const intersect: <IB, B>(right: KleisliTaskDecoder<IB, B>) => <IA, A>(left: KleisliTaskDecoder<IA, A>) => KleisliTaskDecoder<IA & IB, A & B>;
/**
 * @category combinators
 * @since 2.2.7
 */
export declare const sum: <T extends string>(tag: T) => <MS extends Record<string, KleisliTaskDecoder<any, any>>>(members: MS) => KleisliTaskDecoder<K.InputOf<"TaskEither", MS[keyof MS]>, K.TypeOf<"TaskEither", MS[keyof MS]>>;
/**
 * @category combinators
 * @since 2.2.7
 */
export declare const lazy: <I, A>(id: string, f: () => KleisliTaskDecoder<I, A>) => KleisliTaskDecoder<I, A>;
/**
 * @category combinators
 * @since 2.2.7
 */
export declare const compose: <A, B>(to: KleisliTaskDecoder<A, B>) => <I>(from: KleisliTaskDecoder<I, A>) => KleisliTaskDecoder<I, B>;
/**
 * @category Functor
 * @since 2.2.7
 */
export declare const map: <A, B>(f: (a: A) => B) => <I>(fa: KleisliTaskDecoder<I, A>) => KleisliTaskDecoder<I, B>;
/**
 * @category Alt
 * @since 2.2.7
 */
export declare const alt: <I, A>(that: () => KleisliTaskDecoder<I, A>) => (me: KleisliTaskDecoder<I, A>) => KleisliTaskDecoder<I, A>;
/**
 * @since 2.2.7
 */
export declare type TypeOf<KTD> = K.TypeOf<TE.URI, KTD>;
/**
 * @since 2.2.7
 */
export declare type InputOf<KTD> = K.InputOf<TE.URI, KTD>;