import * as _ from "@preserves/core";
import * as _i_schema from "./schema.js";
export declare const $any: symbol;
export declare const $array: symbol;
export declare const $embedded: symbol;
export declare const $map: symbol;
export declare const $rec: symbol;
export declare const $ref: symbol;
export declare const $set: symbol;
export declare const $union: symbol;
export declare const $unit: symbol;
export declare function _schema(): _.Value<_.GenericEmbedded>;
export declare const _imports: {
    schema: typeof _i_schema;
};
export type Definition = (({
    "_variant": "union";
    "variants": Array<Variant>;
} | {
    "_variant": "Simple";
    "value": Simple;
}) & _.Preservable<any> & _.PreserveWritable<any> & {
    __as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>;
});
export type Variant = ({
    "label": symbol;
    "type": Simple;
} & _.Preservable<any> & _.PreserveWritable<any> & {
    __as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>;
});
export type Simple = (({
    "_variant": "Field";
    "value": Field;
} | {
    "_variant": "Record";
    "value": Record;
}) & _.Preservable<any> & _.PreserveWritable<any> & {
    __as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>;
});
export type Record = ({
    "fields": Array<NamedField>;
} & _.Preservable<any> & _.PreserveWritable<any> & {
    __as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>;
});
export type NamedField = ({
    "name": symbol;
    "type": Field;
} & _.Preservable<any> & _.PreserveWritable<any> & {
    __as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>;
});
export type Field = (({
    "_variant": "unit";
} | {
    "_variant": "any";
} | {
    "_variant": "embedded";
} | {
    "_variant": "array";
    "element": Field;
} | {
    "_variant": "set";
    "element": Field;
} | {
    "_variant": "map";
    "key": Field;
    "value": Field;
} | {
    "_variant": "ref";
    "name": _i_schema.Ref;
} | {
    "_variant": "AtomKind";
    "value": _i_schema.AtomKind;
}) & _.Preservable<any> & _.PreserveWritable<any> & {
    __as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>;
});
export declare namespace Definition {
    function union(variants: Array<Variant>): Definition;
    namespace union {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {
                schema: typeof _i_schema;
            };
            definitionName: symbol;
            variant: symbol;
        };
    }
    function Simple(value: Simple): Definition;
    namespace Simple {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {
                schema: typeof _i_schema;
            };
            definitionName: symbol;
            variant: symbol;
        };
    }
}
export declare function Variant({ label, type }: {
    label: symbol;
    type: Simple;
}): Variant;
export declare namespace Variant {
    var schema: () => {
        schema: _.Value<_.GenericEmbedded>;
        imports: {
            schema: typeof _i_schema;
        };
        definitionName: symbol;
    };
    var __from_preserve__: typeof toVariant;
}
export declare namespace Simple {
    function Field(value: Field): Simple;
    namespace Field {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {
                schema: typeof _i_schema;
            };
            definitionName: symbol;
            variant: symbol;
        };
    }
    function Record(value: Record): Simple;
    namespace Record {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {
                schema: typeof _i_schema;
            };
            definitionName: symbol;
            variant: symbol;
        };
    }
}
export declare function Record(fields: Array<NamedField>): Record;
export declare namespace Record {
    var schema: () => {
        schema: _.Value<_.GenericEmbedded>;
        imports: {
            schema: typeof _i_schema;
        };
        definitionName: symbol;
    };
    var __from_preserve__: typeof toRecord;
}
export declare function NamedField({ name, type }: {
    name: symbol;
    type: Field;
}): NamedField;
export declare namespace NamedField {
    var schema: () => {
        schema: _.Value<_.GenericEmbedded>;
        imports: {
            schema: typeof _i_schema;
        };
        definitionName: symbol;
    };
    var __from_preserve__: typeof toNamedField;
}
export declare namespace Field {
    function unit(): Field;
    namespace unit {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {
                schema: typeof _i_schema;
            };
            definitionName: symbol;
            variant: symbol;
        };
    }
    function any(): Field;
    namespace any {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {
                schema: typeof _i_schema;
            };
            definitionName: symbol;
            variant: symbol;
        };
    }
    function embedded(): Field;
    namespace embedded {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {
                schema: typeof _i_schema;
            };
            definitionName: symbol;
            variant: symbol;
        };
    }
    function array(element: Field): Field;
    namespace array {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {
                schema: typeof _i_schema;
            };
            definitionName: symbol;
            variant: symbol;
        };
    }
    function set(element: Field): Field;
    namespace set {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {
                schema: typeof _i_schema;
            };
            definitionName: symbol;
            variant: symbol;
        };
    }
    function map({ key, value }: {
        key: Field;
        value: Field;
    }): Field;
    namespace map {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {
                schema: typeof _i_schema;
            };
            definitionName: symbol;
            variant: symbol;
        };
    }
    function ref(name: _i_schema.Ref): Field;
    namespace ref {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {
                schema: typeof _i_schema;
            };
            definitionName: symbol;
            variant: symbol;
        };
    }
    function AtomKind(value: _i_schema.AtomKind): Field;
    namespace AtomKind {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {
                schema: typeof _i_schema;
            };
            definitionName: symbol;
            variant: symbol;
        };
    }
}
export declare function asDefinition<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Definition;
export declare function toDefinition<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Definition;
export declare namespace Definition {
    const __from_preserve__: typeof toDefinition;
}
export declare function fromDefinition<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Definition): _.Value<_embedded>;
export declare function asVariant<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Variant;
export declare function toVariant<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Variant;
export declare function fromVariant<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Variant): _.Value<_embedded>;
export declare function asSimple<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Simple;
export declare function toSimple<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Simple;
export declare namespace Simple {
    const __from_preserve__: typeof toSimple;
}
export declare function fromSimple<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Simple): _.Value<_embedded>;
export declare function asRecord<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Record;
export declare function toRecord<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Record;
export declare function fromRecord<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Record): _.Value<_embedded>;
export declare function asNamedField<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): NamedField;
export declare function toNamedField<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | NamedField;
export declare function fromNamedField<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: NamedField): _.Value<_embedded>;
export declare function asField<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Field;
export declare function toField<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Field;
export declare namespace Field {
    const __from_preserve__: typeof toField;
}
export declare function fromField<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Field): _.Value<_embedded>;