/**
 * This library reifies typescript types so that we can validate them at runtime.
 *
 * The idea was heavily inspired by https://gcanti.github.io/io-ts/
 */
type TOpts = {
    logFailures: boolean;
};
export type Schema<TInner> = (value: unknown, opts?: TOpts) => value is TInner;
type ExtractTypeguard<T> = T extends (v: unknown, o?: TOpts) => v is infer U ? U : never;
export type TypeOf<A extends Schema<unknown>> = ExtractTypeguard<A>;
type OptionalSchemaKeys<TSchemaMap> = {
    [Index in keyof TSchemaMap]: Schema<undefined> extends TSchemaMap[Index] ? Index : never;
}[keyof TSchemaMap];
type NonOptionalSchemaKeys<TSchemaMap> = {
    [Index in keyof TSchemaMap]: Schema<undefined> extends TSchemaMap[Index] ? never : Index;
}[keyof TSchemaMap];
export type UnwrapSchemaMap<TSchemaMap> = keyof TSchemaMap extends never ? Record<string | number | symbol, undefined> : {
    [SchemaMapIndex in OptionalSchemaKeys<TSchemaMap>]?: TSchemaMap[SchemaMapIndex] extends Schema<unknown> ? TypeOf<TSchemaMap[SchemaMapIndex]> : never;
} & {
    [SchemaMapIndex in NonOptionalSchemaKeys<TSchemaMap>]: TSchemaMap[SchemaMapIndex] extends Schema<unknown> ? TypeOf<TSchemaMap[SchemaMapIndex]> : never;
};
export declare const undefinedtype: (value: unknown) => value is undefined;
type Extends<A, B> = [A] extends [B] ? true : false;
type NonGenericExceptBooleans<A> = true extends Extends<string, A> | Extends<number, A> ? never : A;
type NonGeneric<A> = true extends Extends<boolean, A> ? never : NonGenericExceptBooleans<A>;
export declare function literal<TInner>(inner: NonGeneric<TInner>): (value: unknown) => value is NonGeneric<TInner>;
export declare const number: (value: unknown) => value is number;
export declare const string: (value: unknown) => value is string;
export declare const boolean: (value: unknown) => value is boolean;
export declare const nulltype: (value: unknown) => value is null;
/**
 * Note: I'm explicitly excluding dictionaries from this library.
 * I have seen very few legitimate uses of dictionaries in API design
 * and more common than not, the use case is better served by a shape
 * or an array.
 */
/**
 * If we define the below schema and extracted type:
 *
 *     const mySchema = shape({requiredKey: string, optionalKey: optional(string)})
 *     type TMySchema = TypeOf<typeof mySchema>
 *
 * We want the following to work:
 *
 *     const myObject: TMySchema = {requiredKey: 'value'}
 *
 * This doesn't work out of the box with our definition of optional.
 * FixOptionalIndices defined below gives us this.
 */
type OptionalIndices<T> = {
    [Index in keyof T]: undefined extends T[Index] ? Index : never;
}[keyof T];
type RequiredIndices<T> = {
    [Index in keyof T]: undefined extends T[Index] ? never : Index;
}[keyof T];
type FixOptionalIndices<T> = {
    [OIndex in OptionalIndices<T>]?: T[OIndex];
} & {
    [RIndex in RequiredIndices<T>]: T[RIndex];
};
export declare function shape<TDefnSchema extends {
    [key: string]: Schema<unknown>;
}>(schema: TDefnSchema): (value: unknown, opts?: TOpts) => value is FixOptionalIndices<{ [DefnIndex in keyof TDefnSchema]: ExtractTypeguard<TDefnSchema[DefnIndex]>; }>;
/**
 * This validator is equivalent to shape, except that it gives a generated type
 * that requires explicitly setting optional keys to undefined instead of
 * omitting them when they are not present. It exists for certain cases
 * where the typescript compiler is not smart enough to do what we want
 * with inferred types of generics.
 */
export declare function _shapeWithExplicitOptionals<TDefnSchema extends {
    [key: string]: Schema<unknown>;
}>(schema: TDefnSchema): (value: unknown, opts?: TOpts) => value is { [DefnIndex in keyof TDefnSchema]: ExtractTypeguard<TDefnSchema[DefnIndex]>; };
type TDefnSchemasForTags<TTag extends string> = {
    [TagValueLiteral in string]: {
        [key: string]: Schema<unknown>;
    } & {
        [tag in TTag]: Schema<TagValueLiteral>;
    };
};
type TaggedUnionDefn<TTag extends string, TDefnSchemas extends TDefnSchemasForTags<TTag>> = {
    [TagValueLiteral in keyof TDefnSchemas]: FixOptionalIndices<{
        [ShapeItemKey in keyof TDefnSchemas[TagValueLiteral]]: TypeOf<TDefnSchemas[TagValueLiteral][ShapeItemKey]>;
    }>;
}[keyof TDefnSchemas];
export declare function taggedUnion<TTag extends string, TDefnSchemas extends TDefnSchemasForTags<TTag>>(tag: TTag, schemas: TDefnSchemas): (value: unknown, opts?: TOpts) => value is TaggedUnionDefn<TTag, TDefnSchemas>;
export declare function array<TMember>(member: Schema<TMember>): (value: unknown, opts?: TOpts) => value is TMember[];
/**
 * Note: when defining a tuple you should specify the schema array `const`
 *
 *     const tupleSchema = t.tuple([t.string, t.number] as const);
 *
 * If you don't, validation will work, but `t.typeOf` will be too permissive.
 *
 * This is due to a limitation of our current (simple) implementation.
 * We can eventually get to a world where this isn't required.
 */
export declare function tuple<TDefnSchema extends readonly Schema<unknown>[]>(schema: TDefnSchema): (value: unknown, opts?: TOpts) => value is { [DefnIndex in keyof TDefnSchema]: TDefnSchema[DefnIndex] extends Schema<unknown> ? ExtractTypeguard<TDefnSchema[DefnIndex]> : never; } & {
    length: TDefnSchema['length'];
};
export declare function union<TLeft, TRight>(left: Schema<TLeft>, right: Schema<TRight>): (value: unknown, opts?: TOpts) => value is TLeft | TRight;
export declare function intersection<TLeft, TRight>(left: Schema<TLeft>, right: Schema<TRight>): (value: unknown, opts?: TOpts) => value is TLeft & TRight;
export declare function unionMany<TSchema extends Schema<unknown>>(inner: TSchema[]): (value: unknown, opts?: TOpts) => value is ExtractTypeguard<TSchema>;
type TPluralIntersectionType<T> = (T extends Schema<infer U> ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
export declare function intersectMany<TSchema extends Schema<unknown>>(inner: TSchema[]): (value: unknown, opts?: TOpts) => value is TPluralIntersectionType<TSchema>;
export declare function literals<TLiterals>(inners: readonly NonGenericExceptBooleans<TLiterals>[]): (value: unknown, opts?: TOpts | undefined) => value is NonGenericExceptBooleans<TLiterals>;
export declare function optional<TInner>(inner: Schema<TInner>): (value: unknown, opts?: TOpts | undefined) => value is TInner | undefined;
export declare function nullable<TInner>(inner: Schema<TInner>): (value: unknown, opts?: TOpts | undefined) => value is TInner | null;
export {};