import * as _ from "@preserves/core";
export declare const $1 = 1;
export declare const $Boolean: symbol;
export declare const $ByteString: symbol;
export declare const $Double: symbol;
export declare const $SignedInteger: symbol;
export declare const $String: symbol;
export declare const $Symbol: symbol;
export declare const $and: symbol;
export declare const $any: symbol;
export declare const $atom: symbol;
export declare const $bundle: symbol;
export declare const $definitions: symbol;
export declare const $dict: symbol;
export declare const $dictof: symbol;
export declare const $embedded: symbol;
export declare const $embeddedType: symbol;
export declare const $lit: symbol;
export declare const $named: symbol;
export declare const $or: symbol;
export declare const $rec: symbol;
export declare const $ref: symbol;
export declare const $schema: symbol;
export declare const $seqof: symbol;
export declare const $setof: symbol;
export declare const $tuple: symbol;
export declare const $tuplePrefix: symbol;
export declare const $version: symbol;
export declare const __lit6 = false;
export declare function _schema(): _.Value<_.GenericEmbedded>;
export declare const _imports: {};
export type Bundle<_embedded extends _.Embeddable = _.GenericEmbedded> = ({
    "modules": Modules<_embedded>;
} & _.Preservable<_embedded> & _.PreserveWritable<_embedded> & {
    __as_preserve__(): _.Value<_embedded>;
});
export type Modules<_embedded extends _.Embeddable = _.GenericEmbedded> = _.EncodableDictionary<_embedded, ModulePath, Schema<_embedded>>;
export type Schema<_embedded extends _.Embeddable = _.GenericEmbedded> = ({
    "version": Version;
    "embeddedType": EmbeddedTypeName;
    "definitions": Definitions<_embedded>;
} & _.Preservable<_embedded> & _.PreserveWritable<_embedded> & {
    __as_preserve__(): _.Value<_embedded>;
});
export type Version = ({} & _.Preservable<any> & _.PreserveWritable<any> & {
    __as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>;
});
export type EmbeddedTypeName = (({
    "_variant": "false";
} | {
    "_variant": "Ref";
    "value": Ref;
}) & _.Preservable<any> & _.PreserveWritable<any> & {
    __as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>;
});
export type Definitions<_embedded extends _.Embeddable = _.GenericEmbedded> = _.JsDictionary<Definition<_embedded>>;
export type Definition<_embedded extends _.Embeddable = _.GenericEmbedded> = (({
    "_variant": "or";
    "pattern0": NamedAlternative<_embedded>;
    "pattern1": NamedAlternative<_embedded>;
    "patternN": Array<NamedAlternative<_embedded>>;
} | {
    "_variant": "and";
    "pattern0": NamedPattern<_embedded>;
    "pattern1": NamedPattern<_embedded>;
    "patternN": Array<NamedPattern<_embedded>>;
} | {
    "_variant": "Pattern";
    "value": Pattern<_embedded>;
}) & _.Preservable<_embedded> & _.PreserveWritable<_embedded> & {
    __as_preserve__(): _.Value<_embedded>;
});
export type Pattern<_embedded extends _.Embeddable = _.GenericEmbedded> = (({
    "_variant": "SimplePattern";
    "value": SimplePattern<_embedded>;
} | {
    "_variant": "CompoundPattern";
    "value": CompoundPattern<_embedded>;
}) & _.Preservable<_embedded> & _.PreserveWritable<_embedded> & {
    __as_preserve__(): _.Value<_embedded>;
});
export type SimplePattern<_embedded extends _.Embeddable = _.GenericEmbedded> = (({
    "_variant": "any";
} | {
    "_variant": "atom";
    "atomKind": AtomKind;
} | {
    "_variant": "embedded";
    "interface": SimplePattern<_embedded>;
} | {
    "_variant": "lit";
    "value": _.Value<_embedded>;
} | {
    "_variant": "seqof";
    "pattern": SimplePattern<_embedded>;
} | {
    "_variant": "setof";
    "pattern": SimplePattern<_embedded>;
} | {
    "_variant": "dictof";
    "key": SimplePattern<_embedded>;
    "value": SimplePattern<_embedded>;
} | {
    "_variant": "Ref";
    "value": Ref;
}) & _.Preservable<_embedded> & _.PreserveWritable<_embedded> & {
    __as_preserve__(): _.Value<_embedded>;
});
export type CompoundPattern<_embedded extends _.Embeddable = _.GenericEmbedded> = (({
    "_variant": "rec";
    "label": NamedPattern<_embedded>;
    "fields": NamedPattern<_embedded>;
} | {
    "_variant": "tuple";
    "patterns": Array<NamedPattern<_embedded>>;
} | {
    "_variant": "tuplePrefix";
    "fixed": Array<NamedPattern<_embedded>>;
    "variable": NamedSimplePattern<_embedded>;
} | {
    "_variant": "dict";
    "entries": DictionaryEntries<_embedded>;
}) & _.Preservable<_embedded> & _.PreserveWritable<_embedded> & {
    __as_preserve__(): _.Value<_embedded>;
});
export type DictionaryEntries<_embedded extends _.Embeddable = _.GenericEmbedded> = _.EncodableDictionary<_embedded, _.Value<_embedded>, NamedSimplePattern<_embedded>>;
export type AtomKind = (({
    "_variant": "Boolean";
} | {
    "_variant": "Double";
} | {
    "_variant": "SignedInteger";
} | {
    "_variant": "String";
} | {
    "_variant": "ByteString";
} | {
    "_variant": "Symbol";
}) & _.Preservable<any> & _.PreserveWritable<any> & {
    __as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>;
});
export type NamedAlternative<_embedded extends _.Embeddable = _.GenericEmbedded> = ({
    "variantLabel": string;
    "pattern": Pattern<_embedded>;
} & _.Preservable<_embedded> & _.PreserveWritable<_embedded> & {
    __as_preserve__(): _.Value<_embedded>;
});
export type NamedSimplePattern<_embedded extends _.Embeddable = _.GenericEmbedded> = (({
    "_variant": "named";
    "value": Binding<_embedded>;
} | {
    "_variant": "anonymous";
    "value": SimplePattern<_embedded>;
}) & _.Preservable<_embedded> & _.PreserveWritable<_embedded> & {
    __as_preserve__(): _.Value<_embedded>;
});
export type NamedPattern<_embedded extends _.Embeddable = _.GenericEmbedded> = (({
    "_variant": "named";
    "value": Binding<_embedded>;
} | {
    "_variant": "anonymous";
    "value": Pattern<_embedded>;
}) & _.Preservable<_embedded> & _.PreserveWritable<_embedded> & {
    __as_preserve__(): _.Value<_embedded>;
});
export type Binding<_embedded extends _.Embeddable = _.GenericEmbedded> = ({
    "name": symbol;
    "pattern": SimplePattern<_embedded>;
} & _.Preservable<_embedded> & _.PreserveWritable<_embedded> & {
    __as_preserve__(): _.Value<_embedded>;
});
export type Ref = ({
    "module": ModulePath;
    "name": symbol;
} & _.Preservable<any> & _.PreserveWritable<any> & {
    __as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>;
});
export type ModulePath = Array<symbol>;
export declare function Bundle<_embedded extends _.Embeddable = _.GenericEmbedded>(modules: Modules<_embedded>): Bundle<_embedded>;
export declare namespace Bundle {
    var schema: () => {
        schema: _.Value<_.GenericEmbedded>;
        imports: {};
        definitionName: symbol;
    };
    var __from_preserve__: typeof toBundle;
}
export declare function Modules<_embedded extends _.Embeddable = _.GenericEmbedded>(value: _.EncodableDictionary<_embedded, ModulePath, Schema<_embedded>>): Modules<_embedded>;
export declare namespace Modules {
    var schema: () => {
        schema: _.Value<_.GenericEmbedded>;
        imports: {};
        definitionName: symbol;
    };
    var __from_preserve__: typeof toModules;
}
export declare function Schema<_embedded extends _.Embeddable = _.GenericEmbedded>({ version, embeddedType, definitions }: {
    version: Version;
    embeddedType: EmbeddedTypeName;
    definitions: Definitions<_embedded>;
}): Schema<_embedded>;
export declare namespace Schema {
    var schema: () => {
        schema: _.Value<_.GenericEmbedded>;
        imports: {};
        definitionName: symbol;
    };
    var __from_preserve__: typeof toSchema;
}
export declare function Version(): Version;
export declare namespace Version {
    var schema: () => {
        schema: _.Value<_.GenericEmbedded>;
        imports: {};
        definitionName: symbol;
    };
    var __from_preserve__: typeof toVersion;
}
export declare namespace EmbeddedTypeName {
    function $false(): EmbeddedTypeName;
    namespace $false {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function Ref(value: Ref): EmbeddedTypeName;
    namespace Ref {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
}
export declare function Definitions<_embedded extends _.Embeddable = _.GenericEmbedded>(value: _.JsDictionary<Definition<_embedded>>): Definitions<_embedded>;
export declare namespace Definitions {
    var schema: () => {
        schema: _.Value<_.GenericEmbedded>;
        imports: {};
        definitionName: symbol;
    };
    var __from_preserve__: typeof toDefinitions;
}
export declare namespace Definition {
    function or<_embedded extends _.Embeddable = _.GenericEmbedded>({ pattern0, pattern1, patternN }: {
        pattern0: NamedAlternative<_embedded>;
        pattern1: NamedAlternative<_embedded>;
        patternN: Array<NamedAlternative<_embedded>>;
    }): Definition<_embedded>;
    namespace or {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function and<_embedded extends _.Embeddable = _.GenericEmbedded>({ pattern0, pattern1, patternN }: {
        pattern0: NamedPattern<_embedded>;
        pattern1: NamedPattern<_embedded>;
        patternN: Array<NamedPattern<_embedded>>;
    }): Definition<_embedded>;
    namespace and {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function Pattern<_embedded extends _.Embeddable = _.GenericEmbedded>(value: Pattern<_embedded>): Definition<_embedded>;
    namespace Pattern {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
}
export declare namespace Pattern {
    function SimplePattern<_embedded extends _.Embeddable = _.GenericEmbedded>(value: SimplePattern<_embedded>): Pattern<_embedded>;
    namespace SimplePattern {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function CompoundPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(value: CompoundPattern<_embedded>): Pattern<_embedded>;
    namespace CompoundPattern {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
}
export declare namespace SimplePattern {
    function any<_embedded extends _.Embeddable = _.GenericEmbedded>(): SimplePattern<_embedded>;
    namespace any {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function atom<_embedded extends _.Embeddable = _.GenericEmbedded>(atomKind: AtomKind): SimplePattern<_embedded>;
    namespace atom {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function embedded<_embedded extends _.Embeddable = _.GenericEmbedded>($interface: SimplePattern<_embedded>): SimplePattern<_embedded>;
    namespace embedded {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function lit<_embedded extends _.Embeddable = _.GenericEmbedded>(value: _.Value<_embedded>): SimplePattern<_embedded>;
    namespace lit {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function seqof<_embedded extends _.Embeddable = _.GenericEmbedded>(pattern: SimplePattern<_embedded>): SimplePattern<_embedded>;
    namespace seqof {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function setof<_embedded extends _.Embeddable = _.GenericEmbedded>(pattern: SimplePattern<_embedded>): SimplePattern<_embedded>;
    namespace setof {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function dictof<_embedded extends _.Embeddable = _.GenericEmbedded>({ key, value }: {
        key: SimplePattern<_embedded>;
        value: SimplePattern<_embedded>;
    }): SimplePattern<_embedded>;
    namespace dictof {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function Ref<_embedded extends _.Embeddable = _.GenericEmbedded>(value: Ref): SimplePattern<_embedded>;
    namespace Ref {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
}
export declare namespace CompoundPattern {
    function rec<_embedded extends _.Embeddable = _.GenericEmbedded>({ label, fields }: {
        label: NamedPattern<_embedded>;
        fields: NamedPattern<_embedded>;
    }): CompoundPattern<_embedded>;
    namespace rec {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function tuple<_embedded extends _.Embeddable = _.GenericEmbedded>(patterns: Array<NamedPattern<_embedded>>): CompoundPattern<_embedded>;
    namespace tuple {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function tuplePrefix<_embedded extends _.Embeddable = _.GenericEmbedded>({ fixed, variable }: {
        fixed: Array<NamedPattern<_embedded>>;
        variable: NamedSimplePattern<_embedded>;
    }): CompoundPattern<_embedded>;
    namespace tuplePrefix {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function dict<_embedded extends _.Embeddable = _.GenericEmbedded>(entries: DictionaryEntries<_embedded>): CompoundPattern<_embedded>;
    namespace dict {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
}
export declare function DictionaryEntries<_embedded extends _.Embeddable = _.GenericEmbedded>(value: _.EncodableDictionary<_embedded, _.Value<_embedded>, NamedSimplePattern<_embedded>>): DictionaryEntries<_embedded>;
export declare namespace DictionaryEntries {
    var schema: () => {
        schema: _.Value<_.GenericEmbedded>;
        imports: {};
        definitionName: symbol;
    };
    var __from_preserve__: typeof toDictionaryEntries;
}
export declare namespace AtomKind {
    function Boolean(): AtomKind;
    namespace Boolean {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function Double(): AtomKind;
    namespace Double {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function SignedInteger(): AtomKind;
    namespace SignedInteger {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function String(): AtomKind;
    namespace String {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function ByteString(): AtomKind;
    namespace ByteString {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function Symbol(): AtomKind;
    namespace Symbol {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
}
export declare function NamedAlternative<_embedded extends _.Embeddable = _.GenericEmbedded>({ variantLabel, pattern }: {
    variantLabel: string;
    pattern: Pattern<_embedded>;
}): NamedAlternative<_embedded>;
export declare namespace NamedAlternative {
    var schema: () => {
        schema: _.Value<_.GenericEmbedded>;
        imports: {};
        definitionName: symbol;
    };
    var __from_preserve__: typeof toNamedAlternative;
}
export declare namespace NamedSimplePattern {
    function named<_embedded extends _.Embeddable = _.GenericEmbedded>(value: Binding<_embedded>): NamedSimplePattern<_embedded>;
    namespace named {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function anonymous<_embedded extends _.Embeddable = _.GenericEmbedded>(value: SimplePattern<_embedded>): NamedSimplePattern<_embedded>;
    namespace anonymous {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
}
export declare namespace NamedPattern {
    function named<_embedded extends _.Embeddable = _.GenericEmbedded>(value: Binding<_embedded>): NamedPattern<_embedded>;
    namespace named {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
    function anonymous<_embedded extends _.Embeddable = _.GenericEmbedded>(value: Pattern<_embedded>): NamedPattern<_embedded>;
    namespace anonymous {
        var schema: () => {
            schema: _.Value<_.GenericEmbedded>;
            imports: {};
            definitionName: symbol;
            variant: symbol;
        };
    }
}
export declare function Binding<_embedded extends _.Embeddable = _.GenericEmbedded>({ name, pattern }: {
    name: symbol;
    pattern: SimplePattern<_embedded>;
}): Binding<_embedded>;
export declare namespace Binding {
    var schema: () => {
        schema: _.Value<_.GenericEmbedded>;
        imports: {};
        definitionName: symbol;
    };
    var __from_preserve__: typeof toBinding;
}
export declare function Ref({ module, name }: {
    module: ModulePath;
    name: symbol;
}): Ref;
export declare namespace Ref {
    var schema: () => {
        schema: _.Value<_.GenericEmbedded>;
        imports: {};
        definitionName: symbol;
    };
    var __from_preserve__: typeof toRef;
}
export declare function ModulePath(value: Array<symbol>): ModulePath;
export declare namespace ModulePath {
    var schema: () => {
        schema: _.Value<_.GenericEmbedded>;
        imports: {};
        definitionName: symbol;
    };
    var __from_preserve__: typeof toModulePath;
}
export declare function asBundle<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Bundle<_embedded>;
export declare function toBundle<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Bundle<_embedded>;
export declare function fromBundle<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Bundle<_embedded>): _.Value<_embedded>;
export declare function asModules<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Modules<_embedded>;
export declare function toModules<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Modules<_embedded>;
export declare function fromModules<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Modules<_embedded>): _.Value<_embedded>;
export declare function asSchema<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Schema<_embedded>;
export declare function toSchema<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Schema<_embedded>;
export declare function fromSchema<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Schema<_embedded>): _.Value<_embedded>;
export declare function asVersion<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Version;
export declare function toVersion<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Version;
export declare function fromVersion<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Version): _.Value<_embedded>;
export declare function asEmbeddedTypeName<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): EmbeddedTypeName;
export declare function toEmbeddedTypeName<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | EmbeddedTypeName;
export declare namespace EmbeddedTypeName {
    const __from_preserve__: typeof toEmbeddedTypeName;
}
export declare function fromEmbeddedTypeName<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: EmbeddedTypeName): _.Value<_embedded>;
export declare function asDefinitions<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Definitions<_embedded>;
export declare function toDefinitions<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Definitions<_embedded>;
export declare function fromDefinitions<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Definitions<_embedded>): _.Value<_embedded>;
export declare function asDefinition<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Definition<_embedded>;
export declare function toDefinition<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Definition<_embedded>;
export declare namespace Definition {
    const __from_preserve__: typeof toDefinition;
}
export declare function fromDefinition<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Definition<_embedded>): _.Value<_embedded>;
export declare function asPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Pattern<_embedded>;
export declare function toPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Pattern<_embedded>;
export declare namespace Pattern {
    const __from_preserve__: typeof toPattern;
}
export declare function fromPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Pattern<_embedded>): _.Value<_embedded>;
export declare function asSimplePattern<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): SimplePattern<_embedded>;
export declare function toSimplePattern<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | SimplePattern<_embedded>;
export declare namespace SimplePattern {
    const __from_preserve__: typeof toSimplePattern;
}
export declare function fromSimplePattern<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: SimplePattern<_embedded>): _.Value<_embedded>;
export declare function asCompoundPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): CompoundPattern<_embedded>;
export declare function toCompoundPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | CompoundPattern<_embedded>;
export declare namespace CompoundPattern {
    const __from_preserve__: typeof toCompoundPattern;
}
export declare function fromCompoundPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: CompoundPattern<_embedded>): _.Value<_embedded>;
export declare function asDictionaryEntries<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): DictionaryEntries<_embedded>;
export declare function toDictionaryEntries<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | DictionaryEntries<_embedded>;
export declare function fromDictionaryEntries<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: DictionaryEntries<_embedded>): _.Value<_embedded>;
export declare function asAtomKind<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): AtomKind;
export declare function toAtomKind<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | AtomKind;
export declare namespace AtomKind {
    const __from_preserve__: typeof toAtomKind;
}
export declare function fromAtomKind<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: AtomKind): _.Value<_embedded>;
export declare function asNamedAlternative<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): NamedAlternative<_embedded>;
export declare function toNamedAlternative<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | NamedAlternative<_embedded>;
export declare function fromNamedAlternative<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: NamedAlternative<_embedded>): _.Value<_embedded>;
export declare function asNamedSimplePattern<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): NamedSimplePattern<_embedded>;
export declare function toNamedSimplePattern<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | NamedSimplePattern<_embedded>;
export declare namespace NamedSimplePattern {
    const __from_preserve__: typeof toNamedSimplePattern;
}
export declare function fromNamedSimplePattern<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: NamedSimplePattern<_embedded>): _.Value<_embedded>;
export declare function asNamedPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): NamedPattern<_embedded>;
export declare function toNamedPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | NamedPattern<_embedded>;
export declare namespace NamedPattern {
    const __from_preserve__: typeof toNamedPattern;
}
export declare function fromNamedPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: NamedPattern<_embedded>): _.Value<_embedded>;
export declare function asBinding<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Binding<_embedded>;
export declare function toBinding<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Binding<_embedded>;
export declare function fromBinding<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Binding<_embedded>): _.Value<_embedded>;
export declare function asRef<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Ref;
export declare function toRef<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Ref;
export declare function fromRef<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Ref): _.Value<_embedded>;
export declare function asModulePath<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): ModulePath;
export declare function toModulePath<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | ModulePath;
export declare function fromModulePath<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: ModulePath): _.Value<_embedded>;