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