import { Result } from "./result";
import { RuntimeType } from "./issues/shared";
import type { Kind, TypedKind } from "./kind";
export type Projection<T> = {
    readonly kind: "none";
} | {
    readonly kind: "structural";
    readonly value: T;
} | {
    readonly kind: "opaque";
    readonly value: T;
};
export type ProjectionKind = Projection<any>["kind"];
export declare abstract class Type<T> {
    readonly _type: T;
    abstract check(val: any): Result<T>;
    abstract sliceResult(val: any): Result<T>;
    assert(val: any): T;
    slice(val: any): T;
    /**
     * Use as a type guard.
     *
     * @example
     *   const FooChecker: t.Type<T> = ...
     *   if (FooChecker.guard(val)) {
     *     // in this scope, val has type T
     *   }
     */
    guard(val: any): val is T;
    /**
     * Typescript helper that enforces the correct declaration of a value with no
     * overhead.
     *
     * @example
     * const User = t.subtype({ name: t.str, email: t.str })
     * const myUser = User.({ dog: 'cow' }) // Typescript compile error
     */
    literal(val: T): T;
    and<R>(r: Type<R>): Type<T & R>;
    or<R>(r: Type<R>): Either<T, R>;
    validate(desc: string, fn: Validator<T>): Type<T>;
    comment(comment: string): Comment<T>;
}
export declare abstract class TypeImpl<T> extends Type<T> {
    protected abstract merge<R>(type: TypedKind<R>): TypedKind<T & R> | undefined;
    protected abstract project(val: any): Projection<T>;
    protected projectionOf<R>(type: TypeImpl<R>, val: any): Projection<R>;
    and<R>(r: Type<R>): Type<T & R>;
}
export declare abstract class UnmergeableType<T> extends TypeImpl<T> {
    sliceResult(val: any): Result<T>;
    protected merge<R>(_: TypedKind<R>): TypedKind<T & R> | undefined;
}
export declare abstract class ConstraintType<T> extends UnmergeableType<T> {
    protected project(_: any): Projection<T>;
}
export declare abstract class OpaqueType<T> extends UnmergeableType<T> {
    protected project(val: any): Projection<T>;
}
export declare class Comment<T> extends TypeImpl<T> {
    readonly commentStr: string;
    readonly wrapped: TypedKind<T>;
    constructor(commentStr: string, wrapped: Type<T>);
    check(val: any): Result<T>;
    sliceResult(val: any): Result<T>;
    protected merge<R>(type: TypedKind<R>): TypedKind<T & R>;
    protected project(val: any): Projection<T>;
}
export type Validator<T> = (val: T) => boolean;
export type ValidationIssue = {
    readonly kind: "validation";
    readonly description: string;
    readonly threw: boolean;
    readonly subject: RuntimeType;
};
export declare class Validation<T> extends ConstraintType<T> {
    readonly desc: string;
    readonly validator: Validator<T>;
    constructor(desc: string, fn: Validator<T>);
    check(val: any): Result<T>;
}
export declare class Either<L, R> extends TypeImpl<L | R> {
    readonly l: TypedKind<L>;
    readonly r: TypedKind<R>;
    constructor(l: Type<L>, r: Type<R>);
    check(val: any): Result<L | R>;
    sliceResult(val: any): Result<L | R>;
    protected merge<Incoming>(type: TypedKind<Incoming>): TypedKind<(L | R) & Incoming>;
    protected project(val: any): Projection<L | R>;
}
export declare class Intersection<T> extends TypeImpl<T> {
    readonly operands: ReadonlyArray<Kind>;
    constructor(operands: ReadonlyArray<Kind>);
    check(val: any): Result<T>;
    sliceResult(val: any): Result<T>;
    protected merge<R>(type: TypedKind<R>): TypedKind<T & R>;
    protected project(val: any): Projection<T>;
}