/**
 * Copyright 2022 Gravwell, Inc. All rights reserved.
 *
 * Contact: [legal@gravwell.io](mailto:legal@gravwell.io)
 *
 * This software may be modified and distributed under the terms of the MIT
 * license. See the LICENSE file for details.
 */
import { Decoder } from 'decoders';
import { Annotation } from 'decoders/annotate';
import { DecoderType, Scalar } from 'decoders/Decoder';
import { ObjectDecoderType } from 'decoders/lib/objects';
import { DecoderTypes, Values } from 'decoders/lib/unions';
import { Instance, Klass } from 'decoders/lib/utilities';
/**
 * A `Verifier` is a decoder that performs no transforms to the value it
 * inspects.
 *
 * That is, a `Verifier` can tell you if it's possible to decode an unknown
 * value `V` into type `T` without changing the type of `V`. As such, a
 * `Verifier<T>` can work as a `Decoder<T>` AND as a type guard for type `T`.
 */
export interface Verifier<T> extends Decoder<T> {
    /**
     * Returns true if `value` can be decoded to a `T`, otherwise false.
     *
     * Because `guard` asserts that `value` already _is_ a `T` (that is, it can be
     * decoded to a `T` with no type transforms), `guard` can safely be used as a
     * type guard for type `T`.
     */
    guard(value: unknown): value is T;
    /**
     * Adds an extra rejection predicate to the Verifier.
     *
     * @see {@link https://decoders.cc/Decoder.html#reject}
     */
    rejectVerifier(rejectFn: (value: T) => string | Annotation | null): Verifier<T>;
    /**
     * Adds an extra acceptance predicate to the Verifier.
     *
     * @see {@link https://decoders.cc/Decoder.html#refine}
     */
    refineVerifier<N extends T>(predicate: (value: T) => value is N, msg: string): Verifier<N>;
    refineVerifier(predicate: (value: T) => boolean, msg: string): Verifier<T>;
    /**
     * Changes the error message of the Verifier.
     *
     * @see {@link https://decoders.cc/Decoder.html#describe}
     */
    describeVerifier(message: string): Verifier<T>;
}
export declare const string: Verifier<string>;
export declare const regex: (r: RegExp, msg: string) => Verifier<string>;
export declare const iso8601String: Verifier<string>;
export declare const nonEmptyString: Verifier<string>;
export declare const number: Verifier<number>;
export declare const integer: Verifier<number>;
export declare const boolean: Verifier<boolean>;
export declare const null_: Verifier<null>;
export declare const undefined_: Verifier<undefined>;
export declare const unknown: Verifier<unknown>;
export declare const mixed: Verifier<unknown>;
export declare const jsonObject: Verifier<import("decoders").JSONObject>;
export declare const jsonArray: Verifier<import("decoders").JSONArray>;
export declare const json: Verifier<import("decoders").JSONValue>;
export declare const instanceOf: <K extends Klass<any>>(klass: K) => Verifier<Instance<K>>;
export declare const constant: <T extends Scalar>(c: T) => Verifier<T>;
export declare const optional: <T>(g: Verifier<T>) => Verifier<T | undefined>;
export declare const nullable: <T>(g: Verifier<T>) => Verifier<T | null>;
export declare const maybe: <T>(g: Verifier<T>) => Verifier<T | null | undefined>;
export declare const array: <T>(g: Verifier<T>) => Verifier<T[]>;
export declare const nonEmptyArray: <T>(g: Verifier<T>) => Verifier<[T, ...T[]]>;
export declare const tuple1: <A>(a: Verifier<A>) => Verifier<[A]>;
export declare const tuple2: <A, B>(a: Verifier<A>, b: Verifier<B>) => Verifier<[A, B]>;
export declare const tuple3: <A, B, C>(a: Verifier<A>, b: Verifier<B>, c: Verifier<C>) => Verifier<[A, B, C]>;
export declare const tuple4: <A, B, C, D>(a: Verifier<A>, b: Verifier<B>, c: Verifier<C>, d: Verifier<D>) => Verifier<[A, B, C, D]>;
export declare const tuple5: <A, B, C, D, E>(a: Verifier<A>, b: Verifier<B>, c: Verifier<C>, d: Verifier<D>, e: Verifier<E>) => Verifier<[A, B, C, D, E]>;
export declare const exact: <O extends Record<string, Verifier<any>>>(VerifiersByKey: O) => Verifier<ObjectDecoderType<O> extends infer T ? { [K in keyof T]: ObjectDecoderType<O>[K]; } : never>;
export declare const object: <O extends Record<string, Verifier<any>>>(VerifiersByKey: O) => Verifier<ObjectDecoderType<O> extends infer T ? { [K in keyof T]: ObjectDecoderType<O>[K]; } : never>;
export declare const inexact: <O extends Record<string, Verifier<any>>>(VerifiersByKey: O) => Verifier<(ObjectDecoderType<O> extends infer T ? { [K in keyof T]: ObjectDecoderType<O>[K]; } : never) & Record<string, unknown>>;
export declare const dict: <T>(v: Verifier<T>) => Verifier<Record<string, T>>;
export declare const either: <T extends readonly Verifier<any>[]>(...vs: T) => Verifier<DecoderTypes<T>>;
export declare const oneOf: <T extends Scalar>(constants: readonly T[]) => Verifier<T>;
export declare const taggedUnion: <O extends Record<string, Verifier<any>>>(field: string, mapping: O) => Verifier<Values<{ [key in keyof O]: DecoderType<O[key]>; }>>;
export declare const lazy: <T>(decoderFn: () => Verifier<T>) => Verifier<T>;