import Maybe from '../../Maybe';
import Either from '../../Either';
import Encode from '../Encode';
import _Error from './Error';
import * as _ from './Decoder';
interface RequiredKeyValue {
    <T>(decoder: _.Decoder<T>): _.Decoder<Array<[string, T]>>;
    <K, T>(convertKey: (key: string) => Either<string, K>, decoder: _.Decoder<T>): _.Decoder<Array<[K, T]>>;
}
interface OptionalKeyValue {
    <T>(decoder: _.Decoder<T>): _.Decoder<Maybe<Array<[string, T]>>>;
    <K, T>(convertKey: (key: string) => Either<string, K>, decoder: _.Decoder<T>): _.Decoder<Maybe<Array<[K, T]>>>;
}
interface RequiredDict {
    <T>(decoder: _.Decoder<T>): _.Decoder<{
        [key: string]: T;
    }>;
}
interface OptionalDict {
    <T>(decoder: _.Decoder<T>): _.Decoder<Maybe<{
        [key: string]: T;
    }>>;
}
interface RequiredList {
    <T>(decoder: _.Decoder<T>): _.Decoder<Array<T>>;
}
interface OptionaldList {
    <T>(decoder: _.Decoder<T>): _.Decoder<Maybe<Array<T>>>;
}
interface RequiredShape {
    <T extends {}>(object: {
        [K in keyof T]: _.Decoder<T[K]>;
    }): _.Decoder<T>;
}
interface OptionalShape {
    <T extends {}>(object: {
        [K in keyof T]: _.Decoder<T[K]>;
    }): _.Decoder<Maybe<T>>;
}
interface RequiredOf {
    <T>(decoder: _.Decoder<T>): _.Decoder<T>;
}
interface OptionalOf {
    <T>(decoder: _.Decoder<T>): _.Decoder<Maybe<T>>;
}
interface RequiredOneOf {
    <T>(decoders: Array<_.Decoder<T>>): _.Decoder<T>;
}
interface OptionalOneOf {
    <T>(decoders: Array<_.Decoder<T>>): _.Decoder<Maybe<T>>;
}
interface RequiredEnums {
    <T>(variants: Array<[string | number | boolean | null, T]>): _.Decoder<T>;
}
interface OptionalEnums {
    <T>(variants: Array<[string | number | boolean | null, T]>): _.Decoder<Maybe<T>>;
}
interface RequiredLazy {
    <T>(callDecoder: () => _.Decoder<T>): _.Decoder<T>;
}
interface OptionalLazy {
    <T>(callDecoder: () => _.Decoder<T>): _.Decoder<Maybe<T>>;
}
interface Common {
    string: unknown;
    boolean: unknown;
    int: unknown;
    float: unknown;
    keyValue: unknown;
    shape: unknown;
    list: unknown;
    dict: unknown;
    of: unknown;
    oneOf: unknown;
    enums: unknown;
    field(key: string): unknown;
    index(position: number): unknown;
    at(path: Array<string | number>): unknown;
}
interface WithOptional extends Common {
    optional: Decode.Optional;
    value: unknown;
    lazy: unknown;
}
export declare namespace Decode {
    interface Error extends _Error {
    }
    const Error: typeof _Error;
    namespace Error {
        type Pattern<R> = _Error.Pattern<R>;
    }
    interface Value extends Encode.Value {
    }
    abstract class Decoder<T> extends _.Decoder<T> {
    }
    interface Optional extends Common {
        string: _.Decoder<Maybe<string>>;
        boolean: _.Decoder<Maybe<boolean>>;
        int: _.Decoder<Maybe<number>>;
        float: _.Decoder<Maybe<number>>;
        shape: OptionalShape;
        list: OptionaldList;
        keyValue: OptionalKeyValue;
        dict: OptionalDict;
        of: OptionalOf;
        oneOf: OptionalOneOf;
        enums: OptionalEnums;
        field(name: string): OptionalPath;
        index(position: number): OptionalPath;
        at(path: Array<string | number>): OptionalPath;
    }
    interface Path extends WithOptional {
        optional: Optional;
        string: _.Decoder<string>;
        boolean: _.Decoder<boolean>;
        int: _.Decoder<number>;
        float: _.Decoder<number>;
        value: _.Decoder<Encode.Value>;
        shape: RequiredShape;
        list: RequiredList;
        keyValue: RequiredKeyValue;
        dict: RequiredDict;
        of: RequiredOf;
        oneOf: RequiredOneOf;
        enums: RequiredEnums;
        lazy: RequiredLazy;
        field(name: string): Path;
        index(position: number): Path;
        at(path: Array<string | number>): Path;
    }
    interface OptionalPath extends WithOptional {
        optional: Optional;
        string: _.Decoder<Maybe<string>>;
        boolean: _.Decoder<Maybe<boolean>>;
        int: _.Decoder<Maybe<number>>;
        float: _.Decoder<Maybe<number>>;
        value: _.Decoder<Maybe<Encode.Value>>;
        shape: OptionalShape;
        list: OptionaldList;
        keyValue: OptionalKeyValue;
        dict: OptionalDict;
        of: OptionalOf;
        oneOf: OptionalOneOf;
        enums: OptionalEnums;
        lazy: OptionalLazy;
        field(name: string): OptionalPath;
        index(position: number): OptionalPath;
        at(path: Array<string | number>): OptionalPath;
    }
    const value: _.Value;
    const string: Decoder<string>;
    const boolean: Decoder<boolean>;
    const int: Decoder<number>;
    const float: Decoder<number>;
    const fail: (message: string) => Decoder<never>;
    const succeed: <T>(value: T) => Decoder<T>;
    const shape: RequiredShape;
    const list: RequiredList;
    const keyValue: RequiredKeyValue;
    const dict: <T>(decoder: Decoder<T>) => Decoder<{
        [key: string]: T;
    }>;
    const oneOf: RequiredOneOf;
    const enums: RequiredEnums;
    const lazy: RequiredLazy;
    const field: (name: string) => Path;
    const index: (position: number) => Path;
    const at: (path: (string | number)[]) => Path;
    const optional: Optional;
    const fromEither: <T>(either: Either<string, T>) => Decoder<T>;
    const fromMaybe: <T>(message: string, maybe: Maybe<T>) => Decoder<T>;
}
export { Error } from './Error';
export { Value } from '../Encode';
export { Decoder } from './Decoder';
export interface Path extends Decode.Path {
}
export interface OptionalPath extends Decode.OptionalPath {
}
export interface Optional extends Decode.Optional {
}
export declare const value: _.Value;
export declare const string: Decode.Decoder<string>;
export declare const boolean: Decode.Decoder<boolean>;
export declare const int: Decode.Decoder<number>;
export declare const float: Decode.Decoder<number>;
export declare const fail: (message: string) => Decode.Decoder<never>;
export declare const succeed: <T>(value: T) => Decode.Decoder<T>;
export declare const shape: RequiredShape;
export declare const list: RequiredList;
export declare const keyValue: RequiredKeyValue;
export declare const dict: <T>(decoder: Decode.Decoder<T>) => Decode.Decoder<{
    [key: string]: T;
}>;
export declare const oneOf: RequiredOneOf;
export declare const enums: RequiredEnums;
export declare const lazy: RequiredLazy;
export declare const field: (name: string) => Decode.Path;
export declare const index: (position: number) => Decode.Path;
export declare const at: (path: (string | number)[]) => Decode.Path;
export declare const optional: Decode.Optional;
export declare const fromEither: <T>(either: Either<string, T>) => Decode.Decoder<T>;
export declare const fromMaybe: <T>(message: string, maybe: Maybe<T>) => Decode.Decoder<T>;
export default Decode;