import { EncodableDictionary, Value, Preservable, PreserveWritable, Embeddable } from '@preserves/core';
import { SchemaDefinition } from './reflection.js';
import * as M from './meta.js';
import * as H from './host.js';
export declare const UNIT: true;
export type Parsed<V extends Embeddable> = Value<V> | Parsed<V>[] | DictOf<V> | Bindings<V>;
export type TopParsed<V extends Embeddable> = Value<V> | Parsed<V>[] | DictOf<V> | TopBindings<V>;
export type Top<V extends Embeddable> = Preservable<V> & PreserveWritable<V> & {
    __as_preserve__(): Value<V>;
};
export type DictOf<V extends Embeddable> = EncodableDictionary<V, Parsed<V>, Parsed<V>>;
export type BindingName = string;
export type Bindings<V extends Embeddable> = {
    [key: BindingName]: Parsed<V>;
};
export type TopBindings<V extends Embeddable> = Bindings<V> & Top<V>;
export type SingleConstructor<V extends Embeddable> = ((input: any) => Parsed<V>) & {
    schema(): SchemaDefinition;
};
export type MultipleConstructors<V extends Embeddable> = {
    [key: string]: SingleConstructor<V>;
};
export type DefinitionConstructors<V extends Embeddable> = SingleConstructor<V> | MultipleConstructors<V>;
export declare namespace Bindings {
    function empty<V extends Embeddable>(): Bindings<V>;
    function single<V extends Embeddable>(k: BindingName, v: Parsed<V>): Bindings<V>;
    function merge<V extends Embeddable>(...vs: Bindings<V>[]): Bindings<V>;
}
export type DynField<V extends Embeddable> = {
    type: 'simple';
    value: Parsed<V>;
} | {
    type: 'compound';
    values: Bindings<V>;
};
export declare namespace DynField {
    function unwrap<V extends Embeddable>(f: DynField<V>): Parsed<V>;
    function unwrap_compound<V extends Embeddable>(f: DynField<V>): Bindings<V>;
    function simple<V extends Embeddable>(value: Parsed<V>): DynField<V>;
    function maybeSimple<V extends Embeddable>(value: Parsed<V> | null): DynField<V>;
    function compound<V extends Embeddable>(values: Bindings<V>): DynField<V>;
    function promote<V extends Embeddable>(f: DynField<V>, key?: symbol): Bindings<V>;
}
export type Unparseable<V extends Embeddable> = TopParsed<V>;
export type Unparser<V extends Embeddable> = (v: Parsed<V>) => Value<V>;
export type UnparserCompound<V extends Embeddable> = (v: Bindings<V>) => Value<V>;
export declare class SchemaInterpreter<V extends Embeddable> {
    env: M.Modules<V>;
    mergeEmbeddeds: (a: V, b: V) => V | undefined;
    activeModule: M.ModulePath;
    unparserCache: {
        [key: string]: [Unparser<V>];
    };
    constructor(env?: M.Modules<V>, mergeEmbeddeds?: (a: V, b: V) => V | undefined);
    _withModule<R>(modulePath: M.ModulePath, f: () => R): R;
    _findModule(modulePath: M.ModulePath): {
        resolved: M.ModulePath;
        schema: M.Schema<V>;
    };
    _lookup<R>(modulePath: M.ModulePath, name: symbol, f: (d: M.Definition<V>, schema: M.Schema<V>) => R): R;
    makeTop(modulePath: M.ModulePath, name: symbol, fields: Bindings<V>): TopBindings<V>;
    buildConstructor(modulePath: M.ModulePath, name: symbol, schema: M.Schema<V>, ty: H.Simple, variant?: symbol): SingleConstructor<V>;
    definitionConstructor(modulePath: M.ModulePath, name: symbol): DefinitionConstructors<V>;
    parse(modulePath: M.ModulePath, name: symbol, input: Value<V>): Unparseable<V>;
    tryParse(modulePath: M.ModulePath, name: symbol, input: Value<V>): Unparseable<V> | undefined;
    parseDefinition(d: M.Definition<V>, input: Value<V>): Parsed<V> | undefined;
    parseNamedAlternative(p: M.NamedAlternative<V>, input: Value<V>): Bindings<V> | undefined;
    parseNamedPattern(p: M.NamedPattern<V>, input: Value<V>): Bindings<V> | undefined;
    parseNamedSimplePattern(p: M.NamedSimplePattern<V>, input: Value<V>): DynField<V> | undefined;
    parseSimplePattern(p: M.SimplePattern<V>, input: Value<V>): Parsed<V> | null | undefined;
    parseCompoundPattern(p: M.CompoundPattern<V>, input: Value<V>): Bindings<V> | undefined;
    parsePattern(p: M.Pattern<V>, input: Value<V>): DynField<V> | undefined;
    unparse(modulePath: M.ModulePath, name: symbol, v: Unparseable<V>): Value<V>;
    unparser(modulePath: M.ModulePath, name: symbol): Unparser<V>;
    _unparser(modulePath: M.ModulePath, name: symbol): [Unparser<V>];
    unparserDefinition(p: M.Definition<V>): Unparser<V>;
    unparserNamedAlternative(p: M.NamedAlternative<V>): [string, UnparserCompound<V>];
    unparserNamedPattern(p: M.NamedPattern<V>): Unparser<V>;
    unparserPattern(p: M.Pattern<V>): Unparser<V>;
    unparserSimplePattern(p: M.SimplePattern<V>): Unparser<V>;
    unparserCompoundPattern(p: M.CompoundPattern<V>): UnparserCompound<V>;
    unparserNamedSimplePattern(p: M.NamedSimplePattern<V>): Unparser<V>;
    moduleFor(modulePath: M.ModulePath): {
        [key: string]: any;
    } | undefined;
    moduleTree(tree?: {
        [key: string]: any;
    }): {
        [key: string]: any;
    };
}