import type * as P from "@principia/prelude";
import type * as HKT from "@principia/prelude/HKT";
import type { Option } from "../Option";
import type { InputOf, KleisliDecoder, TypeOf } from "./model";
export declare function mapLeftWithInput_<M extends HKT.URIS, C>(
   M: P.Bifunctor<M, C>
): <I, E, A>(decoder: KleisliDecoder<M, C, I, E, A>, f: (i: I, e: E) => E) => KleisliDecoder<M, C, I, E, A>;
export declare function mapLeftWithInput<M extends HKT.URIS, C>(
   M: P.Bifunctor<M, C>
): <I, E>(f: (i: I, e: E) => E) => <A>(decoder: KleisliDecoder<M, C, I, E, A>) => KleisliDecoder<M, C, I, E, A>;
export declare function compose_<E, M extends HKT.URIS, C>(
   M: P.Monad<M, C & HKT.Fix<"E", E>>
): <I, A, B>(ia: KleisliDecoder<M, C, I, E, A>, ab: KleisliDecoder<M, C, A, E, B>) => KleisliDecoder<M, C, I, E, B>;
export declare function compose<E, M extends HKT.URIS, C>(
   M: P.Monad<M, C & HKT.Fix<"E", E>>
): <A, B>(
   ab: KleisliDecoder<M, C, A, E, B>
) => <I, A, B>(ia: KleisliDecoder<M, C, I, E, A>) => KleisliDecoder<M, C, I, E, B>;
export declare function refine_<E, M extends HKT.URIS, C>(
   M: P.MonadFail<M, C & HKT.Fix<"E", E>>
): <I, A, B extends A>(
   from: KleisliDecoder<M, C, I, E, A>,
   refinement: (a: A) => a is B,
   onError: (a: A) => E
) => KleisliDecoder<M, C, I, E, B>;
export declare function refine<E, M extends HKT.URIS, C>(
   M: P.MonadFail<M, C & HKT.Fix<"E", E>>
): <A, B extends A>(
   refinement: (a: A) => a is B,
   onError: (a: A) => E
) => <I>(from: KleisliDecoder<M, C, I, E, A>) => KleisliDecoder<M, C, I, E, B>;
export declare function parse_<E, M extends HKT.URIS, C>(
   M: P.Monad<M, C & HKT.Fix<"E", E>>
): <I, A, B>(
   from: KleisliDecoder<M, C, I, E, A>,
   decode: (
      a: A
   ) => HKT.Kind<
      M,
      C,
      HKT.Initial<C, "N">,
      HKT.Initial<C, "K">,
      HKT.Initial<C, "Q">,
      HKT.Initial<C, "W">,
      HKT.Initial<C, "X">,
      HKT.Initial<C, "I">,
      HKT.Initial<C, "S">,
      HKT.Initial<C, "R">,
      E,
      B
   >
) => KleisliDecoder<M, C, I, E, B>;
export declare function parse<E, M extends HKT.URIS, C>(
   M: P.Monad<M, C & HKT.Fix<"E", E>>
): <A, B>(
   decode: (
      a: A
   ) => HKT.Kind<
      M,
      C,
      HKT.Initial<C, "N">,
      HKT.Initial<C, "K">,
      HKT.Initial<C, "Q">,
      HKT.Initial<C, "W">,
      HKT.Initial<C, "X">,
      HKT.Initial<C, "I">,
      HKT.Initial<C, "S">,
      HKT.Initial<C, "R">,
      E,
      B
   >
) => <I>(from: KleisliDecoder<M, C, I, E, A>) => KleisliDecoder<M, C, I, E, B>;
export declare function nullable_<E, M extends HKT.URIS, C>(
   M: P.Applicative<M, C & HKT.Fix<"E", E>> & P.Bifunctor<M, HKT.Unfix<C, "E">>
): <I, A>(
   or: KleisliDecoder<M, C, I, E, A>,
   onError: (i: I, e: E) => E
) => KleisliDecoder<M, C, I | null | undefined, E, A | null>;
export declare function nullable<E, M extends HKT.URIS, C>(
   M: P.Applicative<M, C & HKT.Fix<"E", E>> & P.Bifunctor<M, HKT.Unfix<C, "E">>
): <I>(
   onError: (i: I, e: E) => E
) => <A>(or: KleisliDecoder<M, C, I, E, A>) => KleisliDecoder<M, C, I | null | undefined, E, A | null>;
export declare function optional_<E, M extends HKT.URIS, C>(
   M: P.Applicative<M, C & HKT.Fix<"E", E>> & P.Bifunctor<M, HKT.Unfix<C, "E">>
): <I, A>(
   or: KleisliDecoder<M, C, I, E, A>,
   onError: (i: I, e: E) => E
) => KleisliDecoder<M, C, I | null | undefined, E, Option<A>>;
export declare function optional<E, M extends HKT.URIS, C>(
   M: P.Applicative<M, C & HKT.Fix<"E", E>> & P.Bifunctor<M, HKT.Unfix<C, "E">>
): <I>(
   onError: (i: I, e: E) => E
) => <A>(or: KleisliDecoder<M, C, I, E, A>) => KleisliDecoder<M, C, I | null | undefined, E, Option<A>>;
export declare function fromType_<E, M extends HKT.URIS, C>(
   M: P.Applicative<M, C & HKT.Fix<"E", E>> & P.Bifunctor<M, HKT.Unfix<C, "E">>
): <P extends Record<string, KleisliDecoder<M, C, any, E, any>>>(
   properties: P,
   onPropertyError: (key: string, e: E) => E
) => KleisliDecoder<
   M,
   C,
   {
      [K in keyof P]: InputOf<M, P[K]>;
   },
   E,
   {
      [K in keyof P]: TypeOf<M, P[K]>;
   }
>;
export declare function fromType<E, M extends HKT.URIS, C>(
   M: P.Applicative<M, C & HKT.Fix<"E", E>> & P.Bifunctor<M, HKT.Unfix<C, "E">>
): (
   onPropertyError: (key: string, e: E) => E
) => <P extends Record<string, KleisliDecoder<M, C, any, E, any>>>(
   properties: P
) => KleisliDecoder<
   M,
   C,
   {
      [K in keyof P]: InputOf<M, P[K]>;
   },
   E,
   {
      [K in keyof P]: TypeOf<M, P[K]>;
   }
>;
export declare function fromPartial_<E, M extends HKT.URIS, C>(
   M: P.Applicative<M, C & HKT.Fix<"E", E>> & P.Bifunctor<M, HKT.Unfix<C, "E">>
): <P extends Record<string, KleisliDecoder<M, C, any, E, any>>>(
   properties: P,
   onPropertyError: (key: string, e: E) => E
) => KleisliDecoder<
   M,
   C,
   Partial<
      {
         [K in keyof P]: InputOf<M, P[K]>;
      }
   >,
   E,
   Partial<
      {
         [K in keyof P]: TypeOf<M, P[K]>;
      }
   >
>;
export declare function fromPartial<E, M extends HKT.URIS, C>(
   M: P.Applicative<M, C & HKT.Fix<"E", E>> & P.Bifunctor<M, HKT.Unfix<C, "E">>
): (
   onPropertyError: (key: string, e: E) => E
) => <P extends Record<string, KleisliDecoder<M, C, any, E, any>>>(
   properties: P
) => KleisliDecoder<
   M,
   C,
   Partial<
      {
         [K in keyof P]: InputOf<M, P[K]>;
      }
   >,
   E,
   Partial<
      {
         [K in keyof P]: TypeOf<M, P[K]>;
      }
   >
>;
export declare function fromArray_<E, M extends HKT.URIS, C>(
   M: P.Applicative<M, C & HKT.Fix<"E", E>> & P.Bifunctor<M, HKT.Unfix<C, "E">>
): <I, A>(
   item: KleisliDecoder<M, C, I, E, A>,
   onItemError: (index: number, e: E) => E
) => KleisliDecoder<M, C, ReadonlyArray<I>, E, ReadonlyArray<A>>;
export declare function fromArray<E, M extends HKT.URIS, C>(
   M: P.Applicative<M, C & HKT.Fix<"E", E>> & P.Bifunctor<M, HKT.Unfix<C, "E">>
): (
   onItemError: (index: number, e: E) => E
) => <I, A>(item: KleisliDecoder<M, C, I, E, A>) => KleisliDecoder<M, C, ReadonlyArray<I>, E, ReadonlyArray<A>>;
export declare function fromRecord_<E, M extends HKT.URIS, C>(
   M: P.Applicative<M, C & HKT.Fix<"E", E>> & P.Bifunctor<M, HKT.Unfix<C, "E">>
): <I, A>(
   codomain: KleisliDecoder<M, C, I, E, A>,
   onKeyError: (key: string, e: E) => E
) => KleisliDecoder<M, C, Record<string, I>, E, Record<string, A>>;
export declare function fromRecord<E, M extends HKT.URIS, C>(
   M: P.Applicative<M, C & HKT.Fix<"E", E>> & P.Bifunctor<M, HKT.Unfix<C, "E">>
): (
   onKeyError: (key: string, e: E) => E
) => <I, A>(codomain: KleisliDecoder<M, C, I, E, A>) => KleisliDecoder<M, C, Record<string, I>, E, Record<string, A>>;
export declare function fromTuple<E, M extends HKT.URIS, C>(
   M: P.Applicative<M, C & HKT.Fix<"E", E>> & P.Bifunctor<M, C>
): (
   onIndexError: (index: number, e: E) => E
) => <P extends ReadonlyArray<KleisliDecoder<M, C, any, E, any>>>(
   ...components: P
) => KleisliDecoder<
   M,
   C,
   {
      [K in keyof P]: InputOf<M, P[K]>;
   },
   E,
   {
      [K in keyof P]: TypeOf<M, P[K]>;
   }
>;
export declare function union<E, M extends HKT.URIS, C>(
   M: P.Alt<M, C & HKT.Fix<"E", E>> & P.Bifunctor<M, C>
): (
   onMemberError: (index: number, e: E) => E
) => <P extends readonly [KleisliDecoder<M, C, any, E, any>, ...ReadonlyArray<KleisliDecoder<M, C, any, E, any>>]>(
   ...members: P
) => KleisliDecoder<M, C, InputOf<M, P[keyof P]>, E, TypeOf<M, P[keyof P]>>;
export declare function intersect_<E, M extends HKT.URIS, C>(
   M: P.Applicative<M, C & HKT.Fix<"E", E>>
): <IA, A, IB, B>(
   left: KleisliDecoder<M, C, IA, E, A>,
   right: KleisliDecoder<M, C, IB, E, B>
) => KleisliDecoder<M, C, IA & IB, E, A & B>;
export declare function intersect<E, M extends HKT.URIS, C>(
   M: P.Applicative<M, C & HKT.Fix<"E", E>>
): <IB, B>(
   right: KleisliDecoder<M, C, IB, E, B>
) => <IA, A>(left: KleisliDecoder<M, C, IA, E, A>) => KleisliDecoder<M, C, IA & IB, E, A & B>;
export declare function fromSum_<E, M extends HKT.URIS, C>(
   M: P.MonadFail<M, C & HKT.Fix<"E", E>>
): <T extends string, P extends Record<string, KleisliDecoder<M, C, any, E, any>>>(
   tag: T,
   members: P,
   onTagError: (tag: string, vaue: unknown, tags: ReadonlyArray<string>) => E
) => KleisliDecoder<M, C, InputOf<M, P[keyof P]>, E, TypeOf<M, P[keyof P]>>;
export declare function fromSum<E, M extends HKT.URIS, C>(
   M: P.MonadFail<M, C & HKT.Fix<"E", E>>
): (
   onTagError: (tag: string, value: unknown, tags: ReadonlyArray<string>) => E
) => <T extends string>(
   tag: T
) => <P extends Record<string, KleisliDecoder<M, C, any, E, any>>>(
   members: P
) => KleisliDecoder<M, C, InputOf<M, P[keyof P]>, E, TypeOf<M, P[keyof P]>>;
export declare function lazy_<M extends HKT.URIS, C>(
   M: P.Bifunctor<M, C>
): <I, E, A>(
   id: string,
   f: () => KleisliDecoder<M, C & HKT.Fix<"E", E>, I, E, A>,
   onError: (id: string, e: E) => E
) => KleisliDecoder<M, C & HKT.Fix<"E", E>, I, E, A>;
export declare function lazy<M extends HKT.URIS, C>(
   M: P.Bifunctor<M, C>
): <E>(
   onError: (id: string, e: E) => E
) => <I, A>(
   id: string,
   f: () => KleisliDecoder<M, C & HKT.Fix<"E", E>, I, E, A>
) => KleisliDecoder<M, C & HKT.Fix<"E", E>, I, E, A>;
export declare const id: <E, M extends HKT.URIS, C>(
   M: P.Applicative<M, C & HKT.Fix<"E", E>>
) => <A>() => KleisliDecoder<M, C, A, E, A>;
export declare const map_: <E, F extends HKT.URIS, C>(
   F: P.Functor<F, C & HKT.Fix<"E", E>>
) => <I, A, B>(ia: KleisliDecoder<F, C, I, E, A>, f: (a: A) => B) => KleisliDecoder<F, C, I, E, B>;
export declare const map: <E, F extends HKT.URIS, C>(
   F: P.Functor<F, C & HKT.Fix<"E", E>>
) => <A, B>(f: (a: A) => B) => <I>(ia: KleisliDecoder<F, C, I, E, A>) => KleisliDecoder<F, C, I, E, B>;
export declare function alt_<E, F extends HKT.URIS, C>(
   A: P.Alt<F, C & HKT.Fix<"E", E>>
): <I, A>(
   me: KleisliDecoder<F, C, I, E, A>,
   that: () => KleisliDecoder<F, C, I, E, A>
) => KleisliDecoder<F, C, I, E, A>;
export declare function alt<E, F extends HKT.URIS, C>(
   A: P.Alt<F, C & HKT.Fix<"E", E>>
): <I, A>(
   that: () => KleisliDecoder<F, C, I, E, A>
) => (me: KleisliDecoder<F, C, I, E, A>) => KleisliDecoder<F, C, I, E, A>;
//# sourceMappingURL=combinators.d.ts.map