import Maybe from '../../Maybe';
import Either from '../../Either';
import Encode from '../Encode';
import Error from './Error';
import { Path as IPath, OptionalPath as IOptionalPath, Optional as IOptional } from './index';
export declare abstract class Decoder<T> {
    protected static decodeAs<T>(decoder: Decoder<T>, input: unknown, required: boolean): Either<Error, T>;
    map<R>(fn: (value: T) => R): Decoder<R>;
    chain<R>(fn: (value: T) => Decoder<R>): Decoder<R>;
    decodeJSON(json: string): Either<Error, T>;
    decode(input: unknown): Either<Error, T>;
    protected abstract decodeAs(input: unknown, required: boolean): Either<Error, T>;
}
export declare class Path implements IPath {
    private readonly createDecoder;
    static at<T>(path: Array<string | number>, decoder: Decoder<T>): Decoder<T>;
    constructor(createDecoder: <T>(decoder: Decoder<T>) => Decoder<T>);
    of<T>(decoder: Decoder<T>): Decoder<T>;
    readonly string: Decoder<string>;
    readonly boolean: Decoder<boolean>;
    readonly int: Decoder<number>;
    readonly float: Decoder<number>;
    readonly value: Decoder<Encode.Value>;
    shape<T extends {}>(object: {
        [K in keyof T]: Decoder<T[K]>;
    }): Decoder<T>;
    list<T>(decoder: Decoder<T>): Decoder<Array<T>>;
    keyValue<K, T>(...args: [Decoder<T>] | [(key: string) => Either<string, K>, Decoder<T>]): Decoder<Array<[string, T]>> | Decoder<Array<[K, T]>>;
    dict<T>(decoder: Decoder<T>): Decoder<{
        [key: string]: T;
    }>;
    oneOf<T>(decoders: Array<Decoder<T>>): Decoder<T>;
    enums<T>(variants: Array<[string | number | boolean | null, T]>): Decoder<T>;
    lazy<T>(callDecoder: () => Decoder<T>): Decoder<T>;
    field(name: string): IPath;
    index(position: number): IPath;
    at(path: Array<string | number>): IPath;
    readonly optional: IOptional;
}
export declare class OptionalPath implements IOptionalPath {
    private readonly createDecoder;
    static at<T>(path: Array<string | number>, decoder: Decoder<T>): Decoder<Maybe<T>>;
    constructor(createDecoder: <T>(decoder: Decoder<T>) => Decoder<Maybe<T>>);
    of<T>(decoder: Decoder<T>): Decoder<Maybe<T>>;
    readonly string: Decoder<Maybe<string>>;
    readonly boolean: Decoder<Maybe<boolean>>;
    readonly int: Decoder<Maybe<number>>;
    readonly float: Decoder<Maybe<number>>;
    readonly value: Decoder<Maybe<Encode.Value>>;
    shape<T extends {}>(object: {
        [K in keyof T]: Decoder<T[K]>;
    }): Decoder<Maybe<T>>;
    list<T>(decoder: Decoder<T>): Decoder<Maybe<Array<T>>>;
    keyValue<K, T>(...args: [Decoder<T>] | [(key: string) => Either<string, K>, Decoder<T>]): Decoder<Maybe<Array<[string, T]>>> | Decoder<Maybe<Array<[K, T]>>>;
    dict<T>(decoder: Decoder<T>): Decoder<Maybe<{
        [key: string]: T;
    }>>;
    oneOf<T>(decoders: Array<Decoder<T>>): Decoder<Maybe<T>>;
    enums<T>(variants: Array<[string | number | boolean | null, T]>): Decoder<Maybe<T>>;
    lazy<T>(callDecoder: () => Decoder<T>): Decoder<Maybe<T>>;
    field(name: string): IOptionalPath;
    index(position: number): IOptionalPath;
    at(path: Array<string | number>): IOptionalPath;
    readonly optional: IOptional;
}
export declare class Optional implements IOptional {
    private readonly createDecoder;
    constructor(createDecoder: <T>(decoder: Decoder<T>) => Decoder<Maybe<T>>);
    of<T>(decoder: Decoder<T>): Decoder<Maybe<T>>;
    readonly string: Decoder<Maybe<string>>;
    readonly boolean: Decoder<Maybe<boolean>>;
    readonly int: Decoder<Maybe<number>>;
    readonly float: Decoder<Maybe<number>>;
    shape<T extends {}>(object: {
        [K in keyof T]: Decoder<T[K]>;
    }): Decoder<Maybe<T>>;
    list<T>(decoder: Decoder<T>): Decoder<Maybe<Array<T>>>;
    keyValue<K, T>(...args: [Decoder<T>] | [(key: string) => Either<string, K>, Decoder<T>]): Decoder<Maybe<Array<[string, T]>>> | Decoder<Maybe<Array<[K, T]>>>;
    dict<T>(decoder: Decoder<T>): Decoder<Maybe<{
        [key: string]: T;
    }>>;
    oneOf<T>(decoders: Array<Decoder<T>>): Decoder<Maybe<T>>;
    enums<T>(variants: Array<[string | number | boolean | null, T]>): Decoder<Maybe<T>>;
    field(name: string): IOptionalPath;
    index(position: number): IOptionalPath;
    at(path: Array<string | number>): IOptionalPath;
}
export declare class Primitive<T> extends Decoder<T> {
    private readonly prefix;
    private readonly type;
    private readonly check;
    constructor(prefix: string, type: string, check: (input: unknown) => input is T);
    protected decodeAs(input: unknown, required: boolean): Either<Error, T>;
}
export declare class Fail extends Decoder<never> {
    private readonly message;
    constructor(message: string);
    protected decodeAs(input: unknown): Either<Error, never>;
}
export declare class Succeed<T> extends Decoder<T> {
    private readonly value;
    constructor(value: T);
    protected decodeAs(): Either<Error, T>;
}
export declare class Shape<T> extends Decoder<T> {
    private readonly object;
    constructor(object: {
        [K in keyof T]: Decoder<T[K]>;
    });
    protected decodeAs(input: unknown, required: boolean): Either<Error, T>;
}
export declare class OneOf<T> extends Decoder<T> {
    private readonly decoders;
    constructor(decoders: Array<Decoder<T>>);
    protected decodeAs(input: unknown, required: boolean): Either<Error, T>;
}
export declare class Enums<T> extends Decoder<T> {
    private readonly variants;
    constructor(variants: Array<[string | number | boolean | null, T]>);
    protected decodeAs(input: unknown, required: boolean): Either<Error, T>;
}
export declare class List<T> extends Decoder<Array<T>> {
    private readonly decoder;
    constructor(decoder: Decoder<T>);
    protected decodeAs(input: unknown, required: boolean): Either<Error, Array<T>>;
}
export declare class KeyValue<K, T> extends Decoder<Array<[K, T]>> {
    private readonly convertKey;
    private readonly decoder;
    constructor(convertKey: (key: string) => Either<string, K>, decoder: Decoder<T>);
    protected decodeAs(input: unknown, required: boolean): Either<Error, Array<[K, T]>>;
}
export declare abstract class Field<T, R> extends Decoder<R> {
    private readonly name;
    private readonly decoder;
    static required<T>(name: string, decoder: Decoder<T>): Decoder<T>;
    static optional<T>(name: string, decoder: Decoder<T>): Decoder<Maybe<T>>;
    protected static readonly TYPE = "OBJECT";
    protected constructor(name: string, decoder: Decoder<T>);
    protected decodeAs(input: unknown, required: boolean): Either<Error, R>;
    protected abstract decodeNullable(input: unknown, required: boolean): Either<Error, R>;
    protected abstract decodeNotObject(input: unknown, required: boolean): Either<Error, R>;
    protected abstract decodeMissedField(name: string, input: object, required: boolean): Either<Error, R>;
    protected abstract mapSuccess(value: T): R;
}
export declare abstract class Index<T, R> extends Decoder<R> {
    private readonly position;
    private readonly decoder;
    static required<T>(position: number, decoder: Decoder<T>): Decoder<T>;
    static optional<T>(position: number, decoder: Decoder<T>): Decoder<Maybe<T>>;
    protected static readonly TYPE = "ARRAY";
    protected constructor(position: number, decoder: Decoder<T>);
    protected decodeAs(input: unknown, required: boolean): Either<Error, R>;
    protected abstract decodeNullable(input: unknown, required: boolean): Either<Error, R>;
    protected abstract decodeNotArray(input: unknown, required: boolean): Either<Error, R>;
    protected abstract decodeMissedIndex(position: number, input: Array<unknown>, required: boolean): Either<Error, R>;
    protected abstract mapSuccess(value: T): R;
}
export declare class Value extends Decoder<Encode.Value> {
    protected decodeAs(input: unknown): Either<Error, Encode.Value>;
}