import type { UnionToIntersection } from "@principia/prelude/Utils";
import type { Either } from "../Either";
import * as FS from "../FreeSemigroup";
import type { Refinement } from "../Function";
import * as K from "../KleisliDecoder";
import type { Option } from "../Option";
import type { ReadonlyRecord } from "../Record";
import type { DecodeError, ErrorInfo } from "./decode-error";
import * as DE from "./DecodeError";
import type { Decoder, InputOf, TypeOf } from "./model";
export declare const compose_: <I, A, B>(from: Decoder<I, A>, to: Decoder<A, B>) => Decoder<I, B>;
export declare const compose: <A, B>(to: Decoder<A, B>) => <I>(from: Decoder<I, A>) => Decoder<I, B>;
export declare const mapLeftWithInput: <I>(
   f: (input: I, e: DecodeError) => DecodeError
) => <A>(decoder: Decoder<I, A>) => Decoder<I, A>;
export declare const mapLeftWithInput_: <I, A>(
   decoder: Decoder<I, A>,
   f: (input: I, e: DecodeError) => DecodeError
) => Decoder<I, A>;
export declare const wrapInfo: <I>(info?: ErrorInfo | undefined) => <A>(decoder: Decoder<I, A>) => Decoder<I, A>;
export declare const withMessage: <I>(
   message: (input: I, e: DecodeError) => string
) => <A>(decoder: Decoder<I, A>) => Decoder<I, A>;
export declare const refine: <A, B extends A>(
   refinement: Refinement<A, B>,
   name: string,
   info?: ErrorInfo | undefined
) => <I>(from: Decoder<I, A>) => Decoder<I, B>;
export declare const parse_: <I, A, B>(
   from: Decoder<I, A>,
   parser: (a: A) => Either<FS.FreeSemigroup<DE.DecodeError<ErrorInfo>>, B>,
   name?: string | undefined
) => Decoder<I, B>;
export declare const parse: <A, B>(
   parser: (a: A) => Either<FS.FreeSemigroup<DE.DecodeError<ErrorInfo>>, B>,
   name?: string | undefined
) => <I>(from: Decoder<I, A>) => Decoder<I, B>;
export declare const nullable: (
   info?: ErrorInfo
) => <I, A>(or: Decoder<I, A>) => Decoder<undefined | null | I, null | A>;
export declare const optional: (
   info?: ErrorInfo | undefined
) => <I, A>(or: Decoder<I, A>) => Decoder<I | null | undefined, Option<A>>;
export declare const fromType: <P extends Record<string, Decoder<any, any>>>(
   properties: P,
   info?: ErrorInfo | undefined
) => Decoder<{ [K in keyof P]: K.InputOf<["Either"], P[K]> }, { [K_1 in keyof P]: K.TypeOf<["Either"], P[K_1]> }>;
export declare const type: <P extends Record<string, Decoder<any, any>>>(
   properties: P,
   info?: ErrorInfo | undefined
) => Decoder<unknown, { [K in keyof P]: K.TypeOf<["Either"], P[K]> }>;
export declare const fromPartial: <P extends Record<string, Decoder<any, any>>>(
   properties: P,
   info?: ErrorInfo | undefined
) => Decoder<
   Partial<{ [K in keyof P]: K.InputOf<["Either"], P[K]> }>,
   Partial<{ [K_1 in keyof P]: K.TypeOf<["Either"], P[K_1]> }>
>;
export declare const partial: <A>(
   properties: { [K in keyof A]: Decoder<unknown, A[K]> },
   info?: ErrorInfo | undefined
) => Decoder<unknown, Partial<{ [K_1 in keyof A]: A[K_1] }>>;
export declare const fromArray: <I, A>(
   item: Decoder<I, A>,
   info?: ErrorInfo | undefined
) => Decoder<readonly I[], readonly A[]>;
export declare const array: <A>(
   item: Decoder<unknown, A>,
   info?: ErrorInfo | undefined
) => Decoder<unknown, readonly A[]>;
export declare const fromRecord: <I, A>(
   codomain: Decoder<I, A>,
   info?: ErrorInfo | undefined
) => Decoder<Readonly<Record<string, I>>, Readonly<Record<string, A>>>;
export declare const record: <A>(
   codomain: Decoder<unknown, A>,
   info?: ErrorInfo | undefined
) => Decoder<unknown, Record<string, A>>;
export declare const fromTuple: <C extends readonly Decoder<any, any>[]>(
   ...components: C
) => (
   info?: ErrorInfo | undefined
) => Decoder<
   [...{ [K in keyof C]: K.InputOf<["Either"], C[K]> }],
   [...{ [K_1 in keyof C]: K.TypeOf<["Either"], C[K_1]> }]
>;
export declare const tuple: <A extends readonly unknown[]>(
   ...components: { [K in keyof A]: Decoder<unknown, A[K]> }
) => (info?: ErrorInfo | undefined) => Decoder<unknown, A>;
export declare const union: (
   info?: ErrorInfo | undefined
) => <MS extends readonly [Decoder<any, any>, ...Decoder<any, any>[]]>(
   ...members: MS
) => Decoder<K.InputOf<["Either"], MS[keyof MS]>, K.TypeOf<["Either"], MS[keyof MS]>>;
export declare const intersect_: <IA, A, IB, B>(
   left: Decoder<IA, A>,
   right: Decoder<IB, B>,
   name?: string | undefined
) => Decoder<IA & IB, A & B>;
export declare const intersect: <IB, B>(
   right: Decoder<IB, B>,
   name?: string | undefined
) => <IA, A>(left: Decoder<IA, A>) => Decoder<IA & IB, A & B>;
export declare const intersectAll: <A extends readonly [Decoder<any, any>, Decoder<any, any>, ...Decoder<any, any>[]]>(
   decoders: A,
   name?: string | undefined
) => Decoder<
   UnionToIntersection<{ [K in keyof A]: K.InputOf<["Either"], A[K]> }[keyof A]>,
   UnionToIntersection<{ [K_1 in keyof A]: K.TypeOf<["Either"], A[K_1]> }[keyof A]>
>;
export declare const fromSum_: <T extends string, MS extends Record<string, Decoder<any, any>>>(
   tag: T,
   members: MS
) => Decoder<K.InputOf<["Either"], MS[keyof MS]>, K.TypeOf<["Either"], MS[keyof MS]>>;
export declare const fromSum: <T extends string>(
   tag: T
) => <MS extends Record<string, Decoder<any, any>>>(
   members: MS
) => Decoder<K.InputOf<["Either"], MS[keyof MS]>, K.TypeOf<["Either"], MS[keyof MS]>>;
export declare const sum_: <T extends string, A>(
   tag: T,
   members: { [K in keyof A]: Decoder<unknown, A[K]> },
   info?: ErrorInfo | undefined
) => Decoder<unknown, A[keyof A]>;
export declare const sum: <T extends string>(
   tag: T,
   info?: ErrorInfo | undefined
) => <A>(members: { [K in keyof A]: Decoder<unknown, A[K]> }) => Decoder<unknown, A[keyof A]>;
export declare const lazy: <I, A>(id: string, f: () => Decoder<I, A>, info?: ErrorInfo | undefined) => Decoder<I, A>;
export declare const map_: <I, A, B>(fa: Decoder<I, A>, f: (a: A) => B) => Decoder<I, B>;
export declare const map: <A, B>(f: (a: A) => B) => <I>(fa: Decoder<I, A>) => Decoder<I, B>;
export declare const alt_: <I, A>(me: Decoder<I, A>, that: () => Decoder<I, A>) => Decoder<I, A>;
export declare const alt: <I, A>(that: () => Decoder<I, A>) => (me: Decoder<I, A>) => Decoder<I, A>;
export declare const id: <A>() => Decoder<A, A>;
//# sourceMappingURL=combinators.d.ts.map