import { Type } from './type';
declare class Case<In, Out> {
    type: Type<In>;
    fn: (x: In) => Out;
    constructor(type: Type<In>, fn: (x: In) => Out);
}
type InOfCase<T extends Case<any, any>> = T extends Case<infer In, any> ? In : never;
type OutOfCase<T extends Case<any, any>> = T extends Case<any, infer Out> ? Out : never;
export declare class CaseSwitch<Cases extends Case<any, any>> {
    cases: Cases[];
    private memoAccept;
    constructor(cases: Cases[]);
    get accept(): Type<InOfCase<Cases>>;
    run(val: InOfCase<Cases>): OutOfCase<Cases>;
    /**
     * Create a new CaseSwitch that also handles the specified case.
     */
    when<In, Out>(type: Type<In>, fn: (v: In) => Out): CaseSwitch<Cases | Case<In, Out>>;
}
/**
 * Create a type switch that can be used with `match()`.
 */
export declare function when<In, Out>(type: Type<In>, fn: (v: In) => Out): CaseSwitch<Case<In, Out>>;
/**
 * Match a value against a type switch created with `when()`.
 *
 * @example
 * const asString = t.match(foo,
 *   t.when(t.array(t.str), xs => xs.join(' and '))
 *    .when(t.str,           s => s)
 *    .when(t.any,           x => '' + x))
 */
export declare function match<Cases extends Case<any, any>>(val: InOfCase<Cases>, sw: CaseSwitch<Cases>): OutOfCase<Cases>;
export {};