import { ArrayType, BlobType, BooleanType, DateTimeType, DictType, EastType, FloatType, IntegerType, NullType, Nullable, SetType, StringType, StructType, VariantType, ValueTypeOf } from './types';
import { JsonDecoder, JsonEncoder } from './json';
import type { Data } from '../utils/variant';
/**
 * Build a type including descriptions.
 *
 * @category Expressions
 */
export declare class TypeBuilder {
    description: string | undefined;
    constructor();
    static from<T extends EastType>(type: T): AbstractTypeBuilder<T>;
    /** Add a human-readable description to the type */
    describe(description: string): this;
    null(): NullTypeBuilder;
    nullable<V extends (value: TypeBuilder) => AbstractTypeBuilder<EastType>>(value: V): NullableTypeBuilder<ReturnType<V>["type"]>;
    boolean(): BooleanTypeBuilder;
    integer(): IntegerTypeBuilder;
    float(): FloatTypeBuilder;
    datetime(): DateTimeTypeBuilder;
    string(): StringTypeBuilder;
    blob(): BlobTypeBuilder;
    array<V extends (values: TypeBuilder) => AbstractTypeBuilder<EastType>>(values: V): ArrayTypeBuilder<ReturnType<V>["type"]>;
    set<K extends (keys: TypeBuilder) => AbstractTypeBuilder<StringType>>(keys: K): SetTypeBuilder<ReturnType<K>["type"]>;
    dict<K extends (keys: TypeBuilder) => AbstractTypeBuilder<StringType>, V extends (values: TypeBuilder) => AbstractTypeBuilder<EastType>>(keys: K, values: V): DictTypeBuilder<ReturnType<K>["type"], ReturnType<V>["type"]>;
    struct<Fields extends (builder: FieldBuilder<{}>) => FieldBuilder<any>>(fields: Fields): StructTypeBuilder<{
        [K in keyof ReturnType<Fields>["fields"]]: ReturnType<Fields>["fields"][K]["type"];
    }>;
    variant<Cases extends (builder: CaseBuilder<{}>) => CaseBuilder<any>>(cases: Cases): VariantTypeBuilder<{
        [K in keyof ReturnType<Cases>["cases"]]: ReturnType<Cases>["cases"][K]["type"];
    }>;
}
/**
 * Build a type including descriptions.
 *
 * @category Expressions
 */
export declare abstract class AbstractTypeBuilder<T extends EastType> {
    description: string | undefined;
    constructor(description: string | undefined);
    /** Add a human-readable description to the type */
    describe(description: string): void;
    abstract equal(): (x: any, y: any) => boolean;
    abstract less(): (x: any, y: any) => boolean;
    abstract compare(): (x: any, y: any) => -1 | 0 | 1;
    abstract jsonEncoder(): JsonEncoder<any>;
    abstract jsonDecoder(): JsonDecoder<any>;
    abstract type: T;
    abstract toJsonSchema(): any;
}
/** @internal */
declare class NullTypeBuilder extends AbstractTypeBuilder<NullType> {
    constructor(description: string | undefined);
    get type(): NullType;
    /** Return a binary function that determines if two values of this type are equal */
    equal(): (x: null, y: null) => boolean;
    /** Return a binary function that determines if one value of this type is less than another value of this type, according to Elara's canonical total ordering */
    less(): (x: null, y: null) => boolean;
    /** Return a binary function that compares two values of this type, returing `-1` if the first is lesser, `0` if they are equal, and `+1` if the first is greater. Suitable for use in JavaScript methods like `Array#sort`. */
    compare(): (x: null, y: null) => 0 | 1 | -1;
    /** Return an `JsonEncoder` that can transform an East value of this type into Elara's canonical JSON encoding */
    jsonEncoder(): JsonEncoder<NullType>;
    /** Return an `JsonDecoder` that can transform Elara's canonical JSON encoding into an East value of this type */
    jsonDecoder(): JsonDecoder<NullType>;
    toJsonSchema(): {
        type: string;
        description?: string;
    };
}
/** @internal */
declare class NullableTypeBuilder<V extends EastType> extends AbstractTypeBuilder<NullType & V> {
    private value;
    constructor(description: string | undefined, value: AbstractTypeBuilder<V>);
    get type(): Nullable<V>;
    /** Return a binary function that determines if two values of this type are equal */
    equal(): (x: ValueTypeOf<Nullable<V>>, y: ValueTypeOf<Nullable<V>>) => boolean;
    /** Return a binary function that determines if one value of this type is less than another value of this type, according to Elara's canonical total ordering */
    less(): (x: ValueTypeOf<Nullable<V>>, y: ValueTypeOf<Nullable<V>>) => boolean;
    /** Return a binary function that compares two values of this type, returing `-1` if the first is lesser, `0` if they are equal, and `+1` if the first is greater. Suitable for use in JavaScript methods like `Array#sort`. */
    compare(): (x: ValueTypeOf<Nullable<V>>, y: ValueTypeOf<Nullable<V>>) => 0 | 1 | -1;
    /** Return an `JsonEncoder` that can transform an East value of this type into Elara's canonical JSON encoding */
    jsonEncoder(): JsonEncoder<Nullable<V>>;
    /** Return an `JsonDecoder` that can transform Elara's canonical JSON encoding into an East value of this type */
    jsonDecoder(): JsonDecoder<Nullable<V>>;
    toJsonSchema(): {
        oneOf: any[];
        description?: string;
    };
}
/** @internal */
declare class BooleanTypeBuilder extends AbstractTypeBuilder<BooleanType> {
    constructor(description: string | undefined);
    get type(): BooleanType;
    /** Return a binary function that determines if two values of this type are equal */
    equal(): (x: boolean, y: boolean) => boolean;
    /** Return a binary function that determines if one value of this type is less than another value of this type, according to Elara's canonical total ordering */
    less(): (x: boolean, y: boolean) => boolean;
    /** Return a binary function that compares two values of this type, returing `-1` if the first is lesser, `0` if they are equal, and `+1` if the first is greater. Suitable for use in JavaScript methods like `Array#sort`. */
    compare(): (x: boolean, y: boolean) => 0 | 1 | -1;
    /** Return an `JsonEncoder` that can transform an East value of this type into Elara's canonical JSON encoding */
    jsonEncoder(): JsonEncoder<BooleanType>;
    /** Return an `JsonDecoder` that can transform Elara's canonical JSON encoding into an East value of this type */
    jsonDecoder(): JsonDecoder<BooleanType>;
    toJsonSchema(): {
        type: string;
        description?: string;
    };
}
/** @internal */
declare class IntegerTypeBuilder extends AbstractTypeBuilder<IntegerType> {
    constructor(description: string | undefined);
    get type(): IntegerType;
    /** Return a binary function that determines if two values of this type are equal */
    equal(): (x: bigint, y: bigint) => boolean;
    /** Return a binary function that determines if one value of this type is less than another value of this type, according to Elara's canonical total ordering */
    less(): (x: bigint, y: bigint) => boolean;
    /** Return a binary function that compares two values of this type, returing `-1` if the first is lesser, `0` if they are equal, and `+1` if the first is greater. Suitable for use in JavaScript methods like `Array#sort`. */
    compare(): (x: bigint, y: bigint) => 0 | 1 | -1;
    /** Return an `JsonEncoder` that can transform an East value of this type into Elara's canonical JSON encoding */
    jsonEncoder(): JsonEncoder<IntegerType>;
    /** Return an `JsonDecoder` that can transform Elara's canonical JSON encoding into an East value of this type */
    jsonDecoder(): JsonDecoder<IntegerType>;
    toJsonSchema(): {
        type: string;
        description?: string;
    };
}
/** @internal */
declare class FloatTypeBuilder extends AbstractTypeBuilder<FloatType> {
    constructor(description: string | undefined);
    get type(): FloatType;
    /** Return a binary function that determines if two values of this type are equal */
    equal(): (x: number, y: number) => boolean;
    /** Return a binary function that determines if one value of this type is less than another value of this type, according to Elara's canonical total ordering */
    less(): (x: number, y: number) => boolean;
    /** Return a binary function that compares two values of this type, returing `-1` if the first is lesser, `0` if they are equal, and `+1` if the first is greater. Suitable for use in JavaScript methods like `Array#sort`. */
    compare(): (x: number, y: number) => 0 | 1 | -1;
    /** Return an `JsonEncoder` that can transform an East value of this type into Elara's canonical JSON encoding */
    jsonEncoder(): JsonEncoder<FloatType>;
    /** Return an `JsonDecoder` that can transform Elara's canonical JSON encoding into an East value of this type */
    jsonDecoder(): JsonDecoder<FloatType>;
    toJsonSchema(): {
        type: string;
        description?: string;
    };
}
/** @internal */
declare class DateTimeTypeBuilder extends AbstractTypeBuilder<DateTimeType> {
    constructor(description: string | undefined);
    get type(): DateTimeType;
    /** Return a binary function that determines if two values of this type are equal */
    equal(): (x: Date, y: Date) => boolean;
    /** Return a binary function that determines if one value of this type is less than another value of this type, according to Elara's canonical total ordering */
    less(): (x: Date, y: Date) => boolean;
    /** Return a binary function that compares two values of this type, returing `-1` if the first is lesser, `0` if they are equal, and `+1` if the first is greater. Suitable for use in JavaScript methods like `Array#sort`. */
    compare(): (x: Date, y: Date) => 0 | 1 | -1;
    /** Return an `JsonEncoder` that can transform an East value of this type into Elara's canonical JSON encoding */
    jsonEncoder(): JsonEncoder<DateTimeType>;
    /** Return an `JsonDecoder` that can transform Elara's canonical JSON encoding into an East value of this type */
    jsonDecoder(): JsonDecoder<DateTimeType>;
    toJsonSchema(): {
        type: string;
        pattern: string;
        description?: string;
    };
}
/** @internal */
declare class StringTypeBuilder extends AbstractTypeBuilder<StringType> {
    constructor(description: string | undefined);
    get type(): StringType;
    /** Return a binary function that determines if two values of this type are equal */
    equal(): (x: string, y: string) => boolean;
    /** Return a binary function that determines if one value of this type is less than another value of this type, according to Elara's canonical total ordering */
    less(): (x: string, y: string) => boolean;
    /** Return a binary function that compares two values of this type, returing `-1` if the first is lesser, `0` if they are equal, and `+1` if the first is greater. Suitable for use in JavaScript methods like `Array#sort`. */
    compare(): (x: string, y: string) => 0 | 1 | -1;
    /** Return an `JsonEncoder` that can transform an East value of this type into Elara's canonical JSON encoding */
    jsonEncoder(): JsonEncoder<StringType>;
    /** Return an `JsonDecoder` that can transform Elara's canonical JSON encoding into an East value of this type */
    jsonDecoder(): JsonDecoder<StringType>;
    toJsonSchema(): {
        type: string;
        description?: string;
    };
}
/** @internal */
declare class BlobTypeBuilder extends AbstractTypeBuilder<BlobType> {
    constructor(description: string | undefined);
    get type(): BlobType;
    /** Return a binary function that determines if two values of this type are equal */
    equal(): (x: Uint8Array, y: Uint8Array) => boolean;
    /** Return a binary function that determines if one value of this type is less than another value of this type, according to Elara's canonical total ordering */
    less(): (x: Uint8Array, y: Uint8Array) => boolean;
    /** Return a binary function that compares two values of this type, returing `-1` if the first is lesser, `0` if they are equal, and `+1` if the first is greater. Suitable for use in JavaScript methods like `Array#sort`. */
    compare(): (x: Uint8Array, y: Uint8Array) => 0 | 1 | -1;
    /** Return an `JsonEncoder` that can transform an East value of this type into Elara's canonical JSON encoding */
    jsonEncoder(): JsonEncoder<BlobType>;
    /** Return an `JsonDecoder` that can transform Elara's canonical JSON encoding into an East value of this type */
    jsonDecoder(): JsonDecoder<BlobType>;
    toJsonSchema(): {
        type: string;
        items: {
            type: string;
            minimum: number;
            maximum: number;
        };
        description?: string;
    };
}
/** @internal */
declare class ArrayTypeBuilder<V extends EastType> extends AbstractTypeBuilder<ArrayType<V>> {
    private values;
    constructor(description: string | undefined, values: AbstractTypeBuilder<V>);
    /** Return a binary function that determines if two values of this type are equal */
    equal(): (x: ValueTypeOf<V>[], y: ValueTypeOf<V>[]) => boolean;
    /** Return a binary function that determines if one value of this type is less than another value of this type, according to Elara's canonical total ordering */
    less(): (x: ValueTypeOf<V>[], y: ValueTypeOf<V>[]) => boolean;
    /** Return a binary function that compares two values of this type, returing `-1` if the first is lesser, `0` if they are equal, and `+1` if the first is greater. Suitable for use in JavaScript methods like `Array#sort`. */
    compare(): (x: ValueTypeOf<V>[], y: ValueTypeOf<V>[]) => 0 | 1 | -1;
    /** Return an `JsonEncoder` that can transform an East value of this type into Elara's canonical JSON encoding */
    jsonEncoder(): JsonEncoder<ArrayType<V>>;
    /** Return an `JsonDecoder` that can transform Elara's canonical JSON encoding into an East value of this type */
    jsonDecoder(): JsonDecoder<ArrayType<V>>;
    get type(): ArrayType<V>;
    toJsonSchema(): {
        type: string;
        items: any;
        description?: string;
    };
}
/** @internal */
declare class SetTypeBuilder<T extends StringType> extends AbstractTypeBuilder<SetType<T>> {
    private values;
    constructor(description: string | undefined, values: AbstractTypeBuilder<T>);
    get type(): SetType<T>;
    /** Return a binary function that determines if two values of this type are equal */
    equal(): (x: Set<ValueTypeOf<T>>, y: Set<ValueTypeOf<T>>) => boolean;
    /** Return a binary function that determines if one value of this type is less than another value of this type, according to Elara's canonical total ordering */
    less(): (x: Set<ValueTypeOf<T>>, y: Set<ValueTypeOf<T>>) => boolean;
    /** Return a binary function that compares two values of this type, returing `-1` if the first is lesser, `0` if they are equal, and `+1` if the first is greater. Suitable for use in JavaScript methods like `Array#sort`. */
    compare(): (x: Set<ValueTypeOf<T>>, y: Set<ValueTypeOf<T>>) => 0 | 1 | -1;
    /** Return an `JsonEncoder` that can transform an East value of this type into Elara's canonical JSON encoding */
    jsonEncoder(): JsonEncoder<SetType<T>>;
    /** Return an `JsonDecoder` that can transform Elara's canonical JSON encoding into an East value of this type */
    jsonDecoder(): JsonDecoder<SetType<T>>;
    toJsonSchema(): {
        type: string;
        items: any;
        description?: string;
    };
}
/** @internal */
declare class DictTypeBuilder<K extends StringType, V extends EastType> extends AbstractTypeBuilder<DictType<K, V>> {
    private keys;
    private values;
    constructor(description: string | undefined, keys: AbstractTypeBuilder<K>, values: AbstractTypeBuilder<V>);
    get type(): DictType<K, V>;
    /** Return a binary function that determines if two values of this type are equal */
    equal(): (x: Map<ValueTypeOf<K>, ValueTypeOf<V>>, y: Map<ValueTypeOf<K>, ValueTypeOf<V>>) => boolean;
    /** Return a binary function that determines if one value of this type is less than another value of this type, according to Elara's canonical total ordering */
    less(): (x: Map<ValueTypeOf<K>, ValueTypeOf<V>>, y: Map<ValueTypeOf<K>, ValueTypeOf<V>>) => boolean;
    /** Return a binary function that compares two values of this type, returing `-1` if the first is lesser, `0` if they are equal, and `+1` if the first is greater. Suitable for use in JavaScript methods like `Array#sort`. */
    compare(): (x: Map<ValueTypeOf<K>, ValueTypeOf<V>>, y: Map<ValueTypeOf<K>, ValueTypeOf<V>>) => 0 | 1 | -1;
    /** Return an `JsonEncoder` that can transform an East value of this type into Elara's canonical JSON encoding */
    jsonEncoder(): JsonEncoder<DictType<K, V>>;
    /** Return an `JsonDecoder` that can transform Elara's canonical JSON encoding into an East value of this type */
    jsonDecoder(): JsonDecoder<DictType<K, V>>;
    toJsonSchema(): {
        type: string;
        items: {
            type: string;
            properties: {
                key: any;
                value: any;
            };
            required: string[];
        };
        description?: string;
    };
}
/** @internal */
declare class FieldBuilder<Fields extends Record<string, EastType>> {
    fields: {
        [K in keyof Fields]: AbstractTypeBuilder<Fields[K]>;
    };
    constructor(fields: {
        [K in keyof Fields]: AbstractTypeBuilder<Fields[K]>;
    });
    field<Name extends string, Function extends (builder: TypeBuilder) => AbstractTypeBuilder<EastType>, Field extends AbstractTypeBuilder<EastType> | Function>(name: Name, field: Field): FieldBuilder<Fields & {
        [K in Name]: Field extends AbstractTypeBuilder<EastType> ? Field["type"] : Field extends Function ? ReturnType<Field>["type"] : never;
    }>;
}
/** @internal */
declare class StructTypeBuilder<Fields extends Record<string, EastType>> extends AbstractTypeBuilder<StructType<Fields>> {
    fields: {
        [K in keyof Fields]: AbstractTypeBuilder<Fields[K]>;
    };
    constructor(description: string | undefined, fields: {
        [K in keyof Fields]: AbstractTypeBuilder<Fields[K]>;
    });
    get type(): StructType<Fields>;
    /** Return a binary function that determines if two values of this type are equal */
    equal(): (x: { [K in keyof Fields]: ValueTypeOf<Fields[K]>; }, y: { [K in keyof Fields]: ValueTypeOf<Fields[K]>; }) => boolean;
    /** Return a binary function that determines if one value of this type is less than another value of this type, according to Elara's canonical total ordering */
    less(): (x: { [K in keyof Fields]: ValueTypeOf<Fields[K]>; }, y: { [K in keyof Fields]: ValueTypeOf<Fields[K]>; }) => boolean;
    /** Return a binary function that compares two values of this type, returing `-1` if the first is lesser, `0` if they are equal, and `+1` if the first is greater. Suitable for use in JavaScript methods like `Array#sort`. */
    compare(): (x: { [K in keyof Fields]: ValueTypeOf<Fields[K]>; }, y: { [K in keyof Fields]: ValueTypeOf<Fields[K]>; }) => 0 | 1 | -1;
    /** Return an `JsonEncoder` that can transform an East value of this type into Elara's canonical JSON encoding */
    jsonEncoder(): JsonEncoder<StructType<Fields>>;
    /** Return an `JsonDecoder` that can transform Elara's canonical JSON encoding into an East value of this type */
    jsonDecoder(): JsonDecoder<StructType<Fields>>;
    toJsonSchema(): {
        type: string;
        properties: Record<string, any>;
        required: string[];
        description?: string;
    };
}
/** @internal */
declare class CaseBuilder<Cases extends Record<string, EastType>> {
    cases: {
        [K in keyof Cases]: AbstractTypeBuilder<Cases[K]>;
    };
    constructor(cases: {
        [K in keyof Cases]: AbstractTypeBuilder<Cases[K]>;
    });
    case<Name extends string, Case extends (builder: TypeBuilder) => AbstractTypeBuilder<EastType>>(name: Name, variant_case: Case): CaseBuilder<Cases & {
        [K in Name]: ReturnType<Case>["type"];
    }>;
}
/** @internal */
declare class VariantTypeBuilder<Cases extends Record<string, EastType>> extends AbstractTypeBuilder<VariantType<Cases>> {
    cases: {
        [K in keyof Cases]: AbstractTypeBuilder<Cases[K]>;
    };
    constructor(description: string | undefined, cases: {
        [K in keyof Cases]: AbstractTypeBuilder<Cases[K]>;
    });
    get type(): VariantType<Cases>;
    /** Return a binary function that determines if two values of this type are equal */
    equal(): (x: {
        [K in keyof Cases]: {
            type: K;
            [Data]: ValueTypeOf<Cases[K]>;
        };
    }[keyof Cases], y: {
        [K in keyof Cases]: {
            type: K;
            [Data]: ValueTypeOf<Cases[K]>;
        };
    }[keyof Cases]) => boolean;
    /** Return a binary function that determines if one value of this type is less than another value of this type, according to Elara's canonical total ordering */
    less(): (x: {
        [K in keyof Cases]: {
            type: K;
            [Data]: ValueTypeOf<Cases[K]>;
        };
    }[keyof Cases], y: {
        [K in keyof Cases]: {
            type: K;
            [Data]: ValueTypeOf<Cases[K]>;
        };
    }[keyof Cases]) => boolean;
    /** Return a binary function that compares two values of this type, returing `-1` if the first is lesser, `0` if they are equal, and `+1` if the first is greater. Suitable for use in JavaScript methods like `Array#sort`. */
    compare(): (x: {
        [K in keyof Cases]: {
            type: K;
            [Data]: ValueTypeOf<Cases[K]>;
        };
    }[keyof Cases], y: {
        [K in keyof Cases]: {
            type: K;
            [Data]: ValueTypeOf<Cases[K]>;
        };
    }[keyof Cases]) => -1 | 0 | 1;
    /** Return an `JsonEncoder` that can transform an East value of this type into Elara's canonical JSON encoding */
    jsonEncoder(): JsonEncoder<VariantType<Cases>>;
    /** Return an `JsonDecoder` that can transform Elara's canonical JSON encoding into an East value of this type */
    jsonDecoder(): JsonDecoder<VariantType<Cases>>;
    toJsonSchema(): {
        oneOf: {
            type: string;
            properties: {
                type: {
                    const: string;
                };
                value: any;
            };
            required: string[];
        }[];
        description?: string;
    };
}
export {};