/**
 * A transcoder is a data-type that `decode`s from unknown type of an expected input shape
 * to an output type, and `encode`s from an output type to the expected input shape. Can
 * be represented as printer/parsers, and transformations.
 *
 * Lawful transcoders must be idempotent, and all derivable transcoders exported by
 * schemata (unless otherwise specified) are lawful.
 *
 * @since 2.0.0
 */
import { type Const } from 'fp-ts/Const';
import { type Invariant2 } from 'fp-ts/Invariant';
import type * as RNEA from 'fp-ts/ReadonlyNonEmptyArray';
import { type Either } from 'schemata-ts/internal/either';
import { type Schema } from 'schemata-ts/Schema';
import * as TE from 'schemata-ts/TranscodeError';
/**
 * @since 2.0.0
 * @category Model
 */
export interface Transcoder<I, O> {
    readonly decode: (u: unknown) => Either<Const<TE.TranscodeErrors, I>, O>;
    readonly encode: (o: O) => Either<Const<TE.TranscodeErrors, O>, I>;
}
/**
 * @since 2.0.0
 * @category Constructors
 */
export declare const success: <A>(a: A) => Either<TE.TranscodeErrors, A>;
/**
 * @since 2.0.0
 * @category Constructors
 */
export declare const failure: <A>(e: TE.TranscodeErrors) => Either<TE.TranscodeErrors, A>;
/**
 * A collection of failure cases
 *
 * @since 2.0.0
 * @category Constructors
 */
export declare const transcodeErrors: (...errors: RNEA.ReadonlyNonEmptyArray<TE.TranscodeError>) => TE.TranscodeErrors;
/**
 * A failure case for a value that does not match the expected type
 *
 * @since 2.0.0
 * @category Constructors
 */
export declare const typeMismatch: (...args: ConstructorParameters<typeof TE.TypeMismatch>) => TE.TranscodeError;
/**
 * A failure case for an unexpected value
 *
 * @since 2.0.0
 * @category Constructors
 */
export declare const unexpectedValue: (...errors: ConstructorParameters<typeof TE.UnexpectedValue>) => TE.TranscodeError;
/**
 * A failure case for a serialization or deserialization error
 *
 * @since 2.0.0
 * @category Constructors
 */
export declare const serializationError: (...args: ConstructorParameters<typeof TE.SerializationError>) => TE.TranscodeError;
/**
 * A failure case at a specific index
 *
 * @since 2.0.0
 * @category Constructors
 */
export declare const errorAtIndex: (index: number, ...errors: RNEA.ReadonlyNonEmptyArray<TE.TranscodeError>) => TE.TranscodeError;
/**
 * A failure case at a specific key
 *
 * @since 2.0.0
 * @category Constructors
 */
export declare const errorAtKey: (key: string, ...errors: RNEA.ReadonlyNonEmptyArray<TE.TranscodeError>) => TE.TranscodeError;
/**
 * A failure case for a union member
 *
 * @since 2.0.0
 * @category Constructors
 */
export declare const errorAtUnionMember: (member: string | number, ...errors: RNEA.ReadonlyNonEmptyArray<TE.TranscodeError>) => TE.TranscodeError;
/**
 * @since 2.0.0
 * @category Destructors
 */
export declare const drawErrorTree: (...params: Parameters<typeof TE.drawTree>) => string;
/**
 * Interprets a schema as a decoder
 *
 * @since 2.0.0
 * @category Interpreters
 */
export declare const deriveTranscoder: <I, O>(schema: Schema<I, O>) => Transcoder<I, O>;
/**
 * @since 2.0.0
 * @category URI
 */
export declare const URI = "schemata-ts/Transcoder";
/**
 * @since 2.0.0
 * @category URI
 */
export type URI = typeof URI;
declare module 'fp-ts/lib/HKT' {
    interface URItoKind2<E, A> {
        readonly [URI]: Transcoder<E, A>;
    }
}
/**
 * @since 2.0.0
 * @category Instance Methods
 */
export declare const imap: <A, B>(f: (a: A) => B, g: (b: B) => A) => <I>(fa: Transcoder<I, A>) => Transcoder<I, B>;
/**
 * @since 2.0.0
 * @category Instances
 */
export declare const Invariant: Invariant2<URI>;
//# sourceMappingURL=Transcoder.d.ts.map