import { Maker } from './make';
import * as runtime from './runtime';
export type Type = BinaryType | UnknownType | VoidType | BooleanType | IntegerType | NumberType | NullType | UnionType | IntersectionType | StringType | ArrayType | ObjectType | NamedType;
export type NamedTypeDefinitionDeferred<A, Shape = any> = () => NamedTypeDefinition<A, Shape>;
export interface NamedTypeDefinition<A, Shape = any> {
    readonly name: string;
    readonly definition: Type;
    readonly maker: Maker<Shape, A>;
    readonly isA: null | ((value: any) => value is A);
}
export interface BinaryType {
    readonly type: 'binary';
}
export interface UnknownType {
    readonly type: 'unknown';
}
export interface VoidType {
    readonly type: 'void';
}
export interface NullType {
    readonly type: 'null';
}
export interface UnionType {
    readonly type: 'union';
    readonly options: Type[];
}
export interface IntersectionType {
    readonly type: 'intersection';
    readonly options: Type[];
}
export interface StringType {
    readonly type: 'string';
    readonly format?: string;
    readonly pattern?: string;
    readonly minLength?: number;
    readonly maxLength?: number;
    readonly enum?: string[];
}
export interface BooleanType {
    readonly type: 'boolean';
    readonly enum?: boolean[];
}
export interface NumberType {
    readonly type: 'number';
    readonly enum?: number[];
    readonly minimum?: number;
    readonly maximum?: number;
}
export interface IntegerType {
    readonly type: 'integer';
    readonly enum?: number[];
    readonly minimum?: number;
    readonly maximum?: number;
}
export interface ArrayType {
    readonly type: 'array';
    readonly items: Type;
    readonly minItems?: number;
    readonly maxItems?: number;
}
export interface NamedType {
    readonly type: 'named';
    readonly reference: NamedTypeDefinitionDeferred<unknown>;
}
export interface PropType {
    required: boolean;
    value: Type;
    networkName?: string;
}
export interface Props {
    [name: string]: PropType;
}
export type AdditionalProp = boolean | Type;
export interface ObjectType {
    readonly type: 'object';
    readonly additionalProperties: AdditionalProp;
    readonly properties: Props;
}
export declare class Traversal<Root extends runtime.ValueType, Leaf> {
    private readonly root;
    private readonly leaf;
    static compile<Root extends runtime.ValueType, Leaf>(root: NamedTypeDefinition<Root>, leaf: NamedTypeDefinition<Leaf>): runtime.reflection.Traversal<Root, Leaf>;
    private cache;
    private cachedAncestors;
    private constructor();
    private dedupePaths;
    map(value: Root, fn: (leaf: Leaf) => Leaf): Root;
    pmap(value: Root, fn: (leaf: Leaf) => Promise<Leaf>): Promise<Root>;
    private paths;
    private matcher;
    private validateRoot;
    private addAncestor;
    private ancestorNamedObjects;
}