cedar-model-typescript-library 0.8.0 → 1.0.1

package/dist/org/metadatacenter/model/cedar/template-instance/InstanceDataAttributeValueField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstanceDataAttributeValueField.d.ts","sourceRoot":"","sources":["../../../../../../src/org/metadatacenter/model/cedar/template-instance/InstanceDataAttributeValueField.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D,qBAAa,+BAA+B;IAC1C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,OAAO,CAA+C;IAC9D,OAAO,CAAC,KAAK,CAA4B;gBAE7B,IAAI,EAAE,MAAM;IAMxB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,oBAAoB;IAIlD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,MAAM,IAAI;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,oBAAoB,CAAA;KAAE,CAElD;IAED,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAI/B,IAAI,IAAI,IAAI;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAElC;CACF"}

package/dist/org/metadatacenter/model/cedar/template-instance/InstanceDataAttributeValueFieldName.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The name of one attribute-value slot, as it sits in the field's list.
+ *
+ * The name is required. It was declared nullable and never could be: the readers
+ * build one only from a value they have already established is a string, and
+ * nothing else constructs one at all.
+ */
+export declare class InstanceDataAttributeValueFieldName {
+    private readonly _name;
+    constructor(name: string);
+    get name(): string;
+}
+//# sourceMappingURL=InstanceDataAttributeValueFieldName.d.ts.map

package/dist/org/metadatacenter/model/cedar/template-instance/InstanceDataAttributeValueFieldName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstanceDataAttributeValueFieldName.d.ts","sourceRoot":"","sources":["../../../../../../src/org/metadatacenter/model/cedar/template-instance/InstanceDataAttributeValueFieldName.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qBAAa,mCAAmC;IAC9C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;gBAEnB,IAAI,EAAE,MAAM;IAIxB,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/dist/org/metadatacenter/model/cedar/template-instance/InstanceDataContainer.d.ts

@@ -0,0 +1,50 @@
+import { InstanceDataAtomType } from './InstanceDataAtomType';
+/**
+ * An element occurrence, or an instance's root: named children and the property
+ * IRI of each.
+ *
+ * The two maps are exposed, and were the only way to change one. A consumer that
+ * had to remove a child — an editor renaming a property, say — reached into
+ * `values` and used `delete`, which is the model failing to hide its own shape:
+ * the container decides what a child is and how it is keyed, and a caller that
+ * has to know both in order to remove one is not using a model, it is editing a
+ * dictionary that happens to live behind a getter.
+ *
+ * So removal is a method, and the getters stay for reading.
+ */
+export declare class InstanceDataContainer {
+    private _id;
+    private _values;
+    private _iris;
+    constructor();
+    setValue(key: string, instanceDataAtom: InstanceDataAtomType): void;
+    /** Whether this container has a child under that key. */
+    hasValue(key: string): boolean;
+    /**
+     * Remove a child, and the property IRI that identifies it.
+     *
+     * Both together, because they are two halves of one property: a name left in
+     * the IRI map with no child under it becomes a `@context` entry pointing at
+     * nothing, which is what happened whenever a caller deleted from `values` and
+     * forgot the other map. `removeIri` is there for the rarer case of dropping
+     * only the identity.
+     */
+    removeValue(key: string): void;
+    get values(): {
+        [p: string]: InstanceDataAtomType;
+    };
+    set values(values: {
+        [key: string]: InstanceDataAtomType;
+    });
+    setIri(key: string, iri: string): void;
+    /** Whether this container records a property IRI under that key. */
+    hasIri(key: string): boolean;
+    /** Forget a property IRI, leaving any child under that key where it is. */
+    removeIri(key: string): void;
+    get iris(): {
+        [p: string]: string;
+    };
+    set id(value: string | null);
+    get id(): string | null;
+}
+//# sourceMappingURL=InstanceDataContainer.d.ts.map

package/dist/org/metadatacenter/model/cedar/template-instance/InstanceDataContainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstanceDataContainer.d.ts","sourceRoot":"","sources":["../../../../../../src/org/metadatacenter/model/cedar/template-instance/InstanceDataContainer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D;;;;;;;;;;;;GAYG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,GAAG,CAAuB;IAClC,OAAO,CAAC,OAAO,CAA0C;IACzD,OAAO,CAAC,KAAK,CAA4B;;IAOzC,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,gBAAgB,EAAE,oBAAoB;IAI5D,yDAAyD;IACzD,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI9B;;;;;;;;OAQG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAK9B,IAAI,MAAM,IAAI;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,oBAAoB,CAAA;KAAE,CAElD;IAED,IAAI,MAAM,CAAC,MAAM,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB,CAAA;KAAE,EAEzD;IAED,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAI/B,oEAAoE;IACpE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI5B,2EAA2E;IAC3E,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAI5B,IAAI,IAAI,IAAI;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAElC;IAED,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAE1B;IAED,IAAI,EAAE,IAAI,MAAM,GAAG,IAAI,CAEtB;CACF"}

package/dist/org/metadatacenter/model/cedar/template-instance/InstanceDataControlledAtom.d.ts

@@ -0,0 +1,30 @@
+import { PARSED_NODE } from './InstanceDataLinkAtom';
+/**
+ * A controlled term: the IRI that identifies it and the label it is shown by.
+ *
+ * Both are required. An IRI with no label is a link, which is
+ * `InstanceDataLinkAtom`; a label with no IRI is a label with nothing to label,
+ * and there is no term in it at all — the reader makes an
+ * `InstanceDataEmptyAtom` of that and carries what was dropped.
+ *
+ * The constructor's parameters were named `(value, type)` and assigned to `_id`
+ * and `_label`, which is `InstanceDataTypedAtom`'s signature: this class was
+ * copied from that one and the names were never changed. Anyone reading the
+ * signature to learn what a controlled atom holds was told the wrong thing.
+ */
+export declare class InstanceDataControlledAtom {
+    private readonly _id;
+    private readonly _label;
+    constructor(id: string, label: string);
+    constructor(id: string | null, label: string | null, parsed: typeof PARSED_NODE);
+    /**
+     * The atom a reader makes of a node carrying a label and a null `@id`.
+     *
+     * Only the readers use this — see `InstanceDataLinkAtom.fromParsedNode` for
+     * why a malformed document is preserved rather than repaired.
+     */
+    static fromParsedNode(id: string | null, label: string | null): InstanceDataControlledAtom;
+    get id(): string | null;
+    get label(): string | null;
+}
+//# sourceMappingURL=InstanceDataControlledAtom.d.ts.map

package/dist/org/metadatacenter/model/cedar/template-instance/InstanceDataControlledAtom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstanceDataControlledAtom.d.ts","sourceRoot":"","sources":["../../../../../../src/org/metadatacenter/model/cedar/template-instance/InstanceDataControlledAtom.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;;;;;;;;;;;GAYG;AACH,qBAAa,0BAA0B;IACrC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAgB;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;gBAE3B,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;gBACzB,EAAE,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,OAAO,WAAW;IAY/E;;;;;OAKG;IACH,MAAM,CAAC,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,0BAA0B;IAI1F,IAAI,EAAE,IAAI,MAAM,GAAG,IAAI,CAEtB;IAED,IAAI,KAAK,IAAI,MAAM,GAAG,IAAI,CAEzB;CACF"}

package/dist/org/metadatacenter/model/cedar/template-instance/InstanceDataEmptyAtom.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A value node the reader could not make a value out of.
+ *
+ * A CEDAR value is a literal (`@value`) or an IRI (`@id`, optionally with an
+ * `rdfs:label`). A node carrying neither has no value in it, whatever else it
+ * holds — `{"rdfs:label": "Some Term"}` is a label with nothing to label, so
+ * there is no term.
+ *
+ * `discarded` is what the node held. The reader used to return a bare empty atom
+ * and the content was simply gone: a host application handing CEDAR a
+ * half-written controlled term got an empty field back with no way to find out
+ * why, and nothing in the parsing result mentioned it. Keeping the node costs
+ * one reference and lets a consumer say what happened, or put it back.
+ */
+export declare class InstanceDataEmptyAtom {
+    private readonly _discarded;
+    constructor(discarded?: object | null);
+    /** What the node held, when it held something that was not a value. */
+    get discarded(): object | null;
+    /** True when something was thrown away to produce this atom. */
+    hasDiscardedContent(): boolean;
+}
+//# sourceMappingURL=InstanceDataEmptyAtom.d.ts.map

package/dist/org/metadatacenter/model/cedar/template-instance/InstanceDataEmptyAtom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstanceDataEmptyAtom.d.ts","sourceRoot":"","sources":["../../../../../../src/org/metadatacenter/model/cedar/template-instance/InstanceDataEmptyAtom.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;gBAE/B,SAAS,GAAE,MAAM,GAAG,IAAW;IAI3C,uEAAuE;IACvE,IAAI,SAAS,IAAI,MAAM,GAAG,IAAI,CAE7B;IAED,gEAAgE;IAChE,mBAAmB,IAAI,OAAO;CAG/B"}

package/dist/org/metadatacenter/model/cedar/template-instance/InstanceDataLinkAtom.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The readers' way past the checks below.
+ *
+ * Not in `index.ts`, which names its exports one at a time, so it is reachable
+ * from inside the library and nowhere else.
+ */
+export declare const PARSED_NODE: unique symbol;
+/**
+ * Shared by the two IRI-bearing atoms.
+ *
+ * Empty string as well as null: `Iri.empty()` exists and is how an unset IRI is
+ * carried elsewhere in the model, so a caller reaching for one here is making
+ * the same mistake in a different spelling.
+ */
+export declare function assertIri(id: string | null, className: string): void;
+/**
+ * A value that is an IRI and nothing else.
+ *
+ * The IRI is required, and the constructor now says so. `{"@id": null}` is not
+ * an unfilled link — an unfilled IRI-valued field is `{}`, which is
+ * `InstanceDataEmptyAtom` — and JSON-LD has no null branch for `@id` any more
+ * than CEDAR's templates do, which declare it `{"type": "string", "format":
+ * "uri"}`. `JsonTemplateInstanceReader.reportNullIri` has said so on the way in
+ * for some time. The way out said nothing, so a consumer could build exactly the
+ * node the reader would go on to complain about.
+ */
+export declare class InstanceDataLinkAtom {
+    private readonly _id;
+    constructor(id: string);
+    constructor(id: string | null, parsed: typeof PARSED_NODE);
+    /**
+     * The atom a reader makes of a node whose `@id` is null.
+     *
+     * Only the readers use this. A document that arrives malformed is preserved as
+     * it came and reported, because fidelity to what a host actually sent is worth
+     * more than a tidy model: a consumer cannot say which field lost what if the
+     * library quietly repaired it on the way through. Refusing at construction is
+     * for code that is composing an instance, where there is still something to
+     * fix.
+     */
+    static fromParsedNode(id: string | null): InstanceDataLinkAtom;
+    get id(): string | null;
+}
+//# sourceMappingURL=InstanceDataLinkAtom.d.ts.map

package/dist/org/metadatacenter/model/cedar/template-instance/InstanceDataLinkAtom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstanceDataLinkAtom.d.ts","sourceRoot":"","sources":["../../../../../../src/org/metadatacenter/model/cedar/template-instance/InstanceDataLinkAtom.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,OAAO,MAA8B,CAAC;AAEhE;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAIpE;AAED;;;;;;;;;;GAUG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAgB;gBAExB,EAAE,EAAE,MAAM;gBACV,EAAE,EAAE,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,OAAO,WAAW;IAQzD;;;;;;;;;OASG;IACH,MAAM,CAAC,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,oBAAoB;IAI9D,IAAI,EAAE,IAAI,MAAM,GAAG,IAAI,CAEtB;CACF"}

package/dist/org/metadatacenter/model/cedar/template-instance/InstanceDataTypedAtom.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A literal that declares its XSD type, as a temporal or numeric field does.
+ *
+ * The value may be null — an unfilled literal is `{"@value": null}`, which CEDAR
+ * declares as `["string", "null"]` — but the type may not. A typed atom with no
+ * type is an `InstanceDataStringAtom`, which is exactly the choice the readers
+ * make when they find no `@type`, so a null here produces a node no reader would
+ * ever have built.
+ */
+export declare class InstanceDataTypedAtom {
+    private readonly _value;
+    private readonly _type;
+    constructor(value: string | null, type: string);
+    get value(): string | null;
+    get type(): string;
+}
+//# sourceMappingURL=InstanceDataTypedAtom.d.ts.map

package/dist/org/metadatacenter/model/cedar/template-instance/InstanceDataTypedAtom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstanceDataTypedAtom.d.ts","sourceRoot":"","sources":["../../../../../../src/org/metadatacenter/model/cedar/template-instance/InstanceDataTypedAtom.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;gBAEnB,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM;IAQ9C,IAAI,KAAK,IAAI,MAAM,GAAG,IAAI,CAEzB;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/dist/org/metadatacenter/model/cedar/template-instance/InstanceInflater.d.ts

@@ -0,0 +1,28 @@
+import { TemplateInstance } from './TemplateInstance';
+import { Template } from '../template/Template';
+/**
+ * Reconstruct a complete instance from a sparse one and its template.
+ *
+ * The YAML serialization is lean: it drops the JSON-LD `@context` (the property
+ * IRIs) and omits fields with no value, and it need not order children the way
+ * the template does. None of that is in the instance to recover — it is template
+ * data. This bridges the two, so an instance read from YAML can be written back
+ * as a valid CEDAR JSON instance:
+ *
+ *  - **`@context` IRIs** — each child's property IRI is copied onto the
+ *    instance's data container (`dataContainer.iris`), which is what the JSON
+ *    instance writer builds the `@context` from. Without them the emitted
+ *    `@context` has no per-property entries and the instance is not valid JSON-LD.
+ *  - **empty slots** — a child the sparse instance omitted is re-added empty, so
+ *    every property the template's JSON Schema requires is present.
+ *  - **child order** — children are placed in the template's declared order.
+ *
+ * Values the sparse instance already carries are preserved untouched. Mirrors the
+ * Java library's `InstanceInflater`.
+ */
+export declare class InstanceInflater {
+    private constructor();
+    static inflate(instance: TemplateInstance, template: Template): TemplateInstance;
+    private static inflateContainer;
+}
+//# sourceMappingURL=InstanceInflater.d.ts.map

package/dist/org/metadatacenter/model/cedar/template-instance/InstanceInflater.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstanceInflater.d.ts","sourceRoot":"","sources":["../../../../../../src/org/metadatacenter/model/cedar/template-instance/InstanceInflater.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAStD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,gBAAgB;IAC3B,OAAO;WAEO,OAAO,CAAC,QAAQ,EAAE,gBAAgB,EAAE,QAAQ,EAAE,QAAQ,GAAG,gBAAgB;IAKvF,OAAO,CAAC,MAAM,CAAC,gBAAgB;CAuDhC"}

package/dist/org/metadatacenter/model/cedar/template-instance/InstanceValidator.d.ts

@@ -0,0 +1,96 @@
+import { TemplateInstance } from './TemplateInstance';
+import { Template } from '../template/Template';
+import { JsonArtifactParsingResult } from '../util/compare/JsonArtifactParsingResult';
+/**
+ * Check a parsed instance against the template that defines it.
+ *
+ * Reading an instance answers no question about whether it is *correct*. The
+ * reader takes a JSON document at face value — it is handed no template, so a
+ * field that has lost its `@type`, an element short of its `minItems`, or a
+ * property the template requires and the document omits all parse cleanly. The
+ * verdict on those needs the template, which is what this takes.
+ *
+ * It is deliberately the counterpart of `InstanceInflater`: the same walk over
+ * the same pairing of container and template, but reporting what is wrong
+ * instead of repairing it. Where the inflater re-adds a missing slot, this
+ * records that it was missing.
+ *
+ * ## What is checked
+ *
+ *  - **presence** — every child the template lists in its JSON Schema
+ *    `required` has a slot. Static fields and attribute-value fields are
+ *    excluded, exactly as `getChildrenNamesForRequiredInProperties` excludes
+ *    them from `required` itself.
+ *  - **cardinality** — a multi child holds an array and a single child does
+ *    not, and the array's length sits within `minItems`/`maxItems`.
+ *  - **value type** — a temporal or numeric value carries the `@type` its
+ *    field declares. These are the two field kinds whose instance
+ *    representation is a typed atom, so they are the two where a missing or
+ *    wrong `@type` is unambiguous rather than a matter of interpretation.
+ *  - **elements** — recursively, on the same terms.
+ *
+ * ## What is deliberately not checked
+ *
+ * An empty slot is valid. A property must be *present*, but `null` is a legal
+ * value for one — that is how CEDAR represents "not filled in", and the
+ * template's own schema permits it. So emptiness is never an error here; only
+ * absence is.
+ *
+ * Emptiness has a legal spelling, though, and `{"@id": null}` is not it. A
+ * literal's `@value` may be null; an `@id` may not, and an unfilled link is
+ * written `{}`. That asymmetry is checked — see `validateIri`.
+ *
+ * Nor does this police the atom kind of every field. Only temporal and numeric
+ * fields have a declared datatype to check against. Inferring the rest from
+ * `uiInputType` would mean asserting things the model does not actually
+ * constrain, and a validator that reports errors which are not errors is worse
+ * than one that stays quiet: consumers stop believing it. Widening the check is
+ * a matter of adding cases here as the model gains constraints worth enforcing.
+ */
+export declare class InstanceValidator {
+    private constructor();
+    /**
+     * The instance judged against its template.
+     *
+     * A `JsonArtifactParsingResult` rather than a new result type, so a consumer
+     * already reading `wasSuccessful()` or `adheresToBlueprint()` off a reader
+     * result can read this the same way.
+     */
+    static validate(instance: TemplateInstance, template: Template): JsonArtifactParsingResult;
+    private static validateContainer;
+    private static attributeValueGroups;
+    private static validateChild;
+    private static validateCardinality;
+    private static validateItem;
+    /**
+     * `{"@id": null}` is not an empty value. It is a malformed one.
+     *
+     * `@value` and `@id` are not symmetrical here, and the difference is easy to
+     * miss. A literal's `@value` may be null — JSON-LD allows it and CEDAR
+     * declares the property `["string", "null"]`, which is how an unfilled
+     * literal is written. An `@id` may not: JSON-LD requires an IRI, and CEDAR
+     * declares it `{"type": "string", "format": "uri"}` with no null branch. An
+     * unfilled link or controlled-term field is written `{}` instead, which the
+     * reader returns as an empty node.
+     *
+     * So a link atom carrying a null id came from a document that should not
+     * exist, and nothing else notices: the reader accepts it and the writer emits
+     * it back unchanged. None of the 120 instances in the shared corpus contains
+     * one.
+     *
+     * This is a structural rule rather than a datatype one, so it applies to any
+     * field. The instance's own top-level `@id` is a different matter — an unsaved
+     * instance legitimately has none — and is not reached here, which walks only
+     * the children the template declares.
+     */
+    private static validateIri;
+    /**
+     * The `@type` a filled value of this field must carry, or null where the
+     * field kind declares none.
+     */
+    private static declaredValueType;
+    private static validateTypedValue;
+    /** An unfilled slot, in any of the shapes the reader produces for one. */
+    private static isEmpty;
+}
+//# sourceMappingURL=InstanceValidator.d.ts.map

package/dist/org/metadatacenter/model/cedar/template-instance/InstanceValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstanceValidator.d.ts","sourceRoot":"","sources":["../../../../../../src/org/metadatacenter/model/cedar/template-instance/InstanceValidator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAatD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAGhD,OAAO,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AAatF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,qBAAa,iBAAiB;IAC5B,OAAO;IAEP;;;;;;OAMG;WACW,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,EAAE,QAAQ,EAAE,QAAQ,GAAG,yBAAyB;IAMjG,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAoEhC,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAkBnC,OAAO,CAAC,MAAM,CAAC,aAAa;IAqC5B,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAsBlC,OAAO,CAAC,MAAM,CAAC,YAAY;IA8B3B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,MAAM,CAAC,WAAW;IAS1B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAUhC,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAsCjC,0EAA0E;IAC1E,OAAO,CAAC,MAAM,CAAC,OAAO;CASvB"}

package/dist/org/metadatacenter/model/cedar/types/cedar-types/CedarFieldType.d.ts

@@ -0,0 +1,71 @@
+import { UiInputType } from '../wrapped-types/UiInputType';
+import { YamlArtifactType } from '../wrapped-types/YamlArtifactType';
+export declare const CedarFieldTypeValues: {
+    readonly TEXTFIELD: "DYNAMIC-textfield";
+    readonly TEXTAREA: "DYNAMIC-textarea";
+    readonly CONTROLLED_TERM: "DYNAMIC-controlled-term";
+    readonly LINK: "DYNAMIC-link";
+    readonly EXT_ROR: "DYNAMIC-ext-ror";
+    readonly EXT_ORCID: "DYNAMIC-ext-orcid";
+    readonly EXT_PFAS: "DYNAMIC-ext-pfas";
+    readonly EXT_PUBMED: "DYNAMIC-ext-pubmed";
+    readonly EXT_RRID: "DYNAMIC-ext-rrid";
+    readonly EXT_NIH_GRANT_ID: "DYNAMIC-ext-nih-grant-id";
+    readonly EXT_DOI: "DYNAMIC-ext-doi";
+    readonly TEMPORAL: "DYNAMIC-temporal";
+    readonly EMAIL: "DYNAMIC-email";
+    readonly NUMERIC: "DYNAMIC-numeric";
+    readonly PHONE_NUMBER: "DYNAMIC-phone-number";
+    readonly RADIO: "DYNAMIC-radio";
+    readonly CHECKBOX: "DYNAMIC-checkbox";
+    readonly SINGLE_SELECT_LIST: "DYNAMIC-single-select-list";
+    readonly MULTIPLE_SELECT_LIST: "DYNAMIC-multiple-select-list";
+    readonly ATTRIBUTE_VALUE: "DYNAMIC-attribute-value";
+    readonly STATIC_PAGE_BREAK: "STATIC-page-break";
+    readonly STATIC_SECTION_BREAK: "STATIC-section-break";
+    readonly STATIC_IMAGE: "STATIC-image";
+    readonly STATIC_RICH_TEXT: "STATIC-rich_text";
+    readonly STATIC_YOUTUBE: "STATIC-youtube";
+};
+export type CedarFieldTypeValue = (typeof CedarFieldTypeValues)[keyof typeof CedarFieldTypeValues] | null;
+export declare class CedarFieldType {
+    private readonly value;
+    private readonly _uiInputType;
+    private readonly _yamlType;
+    private readonly staticField;
+    private constructor();
+    getValue(): CedarFieldTypeValue;
+    getUiInputType(): UiInputType;
+    getYamlType(): YamlArtifactType;
+    get isStaticField(): boolean;
+    static values(): CedarFieldType[];
+    static TEXT: CedarFieldType;
+    static TEXTAREA: CedarFieldType;
+    static CONTROLLED_TERM: CedarFieldType;
+    static LINK: CedarFieldType;
+    static EXT_ROR: CedarFieldType;
+    static EXT_ORCID: CedarFieldType;
+    static EXT_PFAS: CedarFieldType;
+    static EXT_PUBMED: CedarFieldType;
+    static EXT_RRID: CedarFieldType;
+    static EXT_NIH_GRANT_ID: CedarFieldType;
+    static EXT_DOI: CedarFieldType;
+    static TEMPORAL: CedarFieldType;
+    static EMAIL: CedarFieldType;
+    static NUMERIC: CedarFieldType;
+    static PHONE_NUMBER: CedarFieldType;
+    static RADIO: CedarFieldType;
+    static CHECKBOX: CedarFieldType;
+    static SINGLE_SELECT_LIST: CedarFieldType;
+    static MULTIPLE_SELECT_LIST: CedarFieldType;
+    static ATTRIBUTE_VALUE: CedarFieldType;
+    static STATIC_PAGE_BREAK: CedarFieldType;
+    static STATIC_SECTION_BREAK: CedarFieldType;
+    static STATIC_IMAGE: CedarFieldType;
+    static STATIC_RICH_TEXT: CedarFieldType;
+    static STATIC_YOUTUBE: CedarFieldType;
+    static NULL: CedarFieldType;
+    static forUiInputType(uiInputType: UiInputType): CedarFieldType;
+    static forYamlArtifactType(yamlArtifactType: YamlArtifactType): CedarFieldType;
+}
+//# sourceMappingURL=CedarFieldType.d.ts.map

package/dist/org/metadatacenter/model/cedar/types/cedar-types/CedarFieldType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CedarFieldType.d.ts","sourceRoot":"","sources":["../../../../../../../src/org/metadatacenter/model/cedar/types/cedar-types/CedarFieldType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAErE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BvB,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,OAAO,oBAAoB,CAAC,GAAG,IAAI,CAAC;AAE1G,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA6B;IACnD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAc;IAC3C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmB;IAC7C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;IAE7B,OAAO;IAOA,QAAQ,IAAI,mBAAmB;IAI/B,cAAc,IAAI,WAAW;IAI7B,WAAW,IAAI,gBAAgB;IAItC,IAAI,aAAa,YAEhB;WAEa,MAAM,IAAI,cAAc,EAAE;IA8BxC,OAAc,IAAI,iBAAgH;IAClI,OAAc,QAAQ,iBAA6G;IACnI,OAAc,eAAe,iBAK3B;IACF,OAAc,IAAI,iBAAiG;IACnH,OAAc,OAAO,iBAA0G;IAC/H,OAAc,SAAS,iBAAgH;IACvI,OAAc,QAAQ,iBAA6G;IACnI,OAAc,UAAU,iBAKtB;IACF,OAAc,QAAQ,iBAA6G;IACnI,OAAc,gBAAgB,iBAK5B;IACF,OAAc,OAAO,iBAA0G;IAC/H,OAAc,QAAQ,iBAA6G;IACnI,OAAc,KAAK,iBAAoG;IACvH,OAAc,OAAO,iBAA0G;IAC/H,OAAc,YAAY,iBAKxB;IACF,OAAc,KAAK,iBAAoG;IACvH,OAAc,QAAQ,iBAA6G;IACnI,OAAc,kBAAkB,iBAK9B;IACF,OAAc,oBAAoB,iBAKhC;IACF,OAAc,eAAe,iBAK3B;IAEF,OAAc,iBAAiB,iBAK7B;IACF,OAAc,oBAAoB,iBAKhC;IACF,OAAc,YAAY,iBAA0G;IACpI,OAAc,gBAAgB,iBAK5B;IACF,OAAc,cAAc,iBAK1B;IAEF,OAAc,IAAI,iBAA2E;IAE7F,MAAM,CAAC,cAAc,CAAC,WAAW,EAAE,WAAW,GAAG,cAAc;IAS/D,MAAM,CAAC,mBAAmB,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,cAAc;CAQ/E"}

package/dist/org/metadatacenter/model/cedar/types/wrapped-types/IsoDate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsoDate.d.ts","sourceRoot":"","sources":["../../../../../../../src/org/metadatacenter/model/cedar/types/wrapped-types/IsoDate.ts"],"names":[],"mappings":"AAAA,qBAAa,OAAO;IAClB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAc;IACnC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAgB;IAE/C,OAAO;IAKP,OAAc,IAAI,UAA2B;IAGtC,QAAQ,IAAI,MAAM,GAAG,IAAI;WAkClB,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO;WAY/C,GAAG,IAAI,OAAO;WAMd,mBAAmB,IAAI,MAAM;CAc5C"}

package/dist/org/metadatacenter/model/cedar/types/wrapped-types/PropertyIri.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The namespace CEDAR identifies one of a container's properties by.
+ *
+ * A model fact rather than a key in any serialization, and the whole of what a consumer needs: the
+ * IRIs themselves are the repository's to assign, so nothing here derives one. It used to, from the
+ * property's name, and that is exactly what a name cannot carry — an author renames a child and the
+ * identity underneath it would move.
+ *
+ * It is here at all because the namespace was reachable only as `CedarModel.propertyIriPrefix`, a
+ * bare string in a class otherwise full of the *names* a template's JSON uses for its parts: `_ui`,
+ * `$schema`, `_valueConstraints`. A consumer that wanted to recognise a property IRI had to reach
+ * into that table, which is how CEE came to mint one a different way from the library.
+ */
+export declare class PropertyIri {
+    /** The namespace every property IRI CEDAR assigns belongs to. */
+    static get namespace(): string;
+}
+//# sourceMappingURL=PropertyIri.d.ts.map

package/dist/org/metadatacenter/model/cedar/types/wrapped-types/PropertyIri.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PropertyIri.d.ts","sourceRoot":"","sources":["../../../../../../../src/org/metadatacenter/model/cedar/types/wrapped-types/PropertyIri.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,qBAAa,WAAW;IACtB,iEAAiE;IACjE,MAAM,KAAK,SAAS,IAAI,MAAM,CAE7B;CACF"}

package/dist/org/metadatacenter/model/cedar/types/wrapped-types/UiInputType.d.ts

@@ -0,0 +1,58 @@
+export declare const UiInputTypeValues: {
+    readonly TEXTFIELD: "textfield";
+    readonly TEXTAREA: "textarea";
+    readonly LINK: "link";
+    readonly EXT_ROR: "ext-ror";
+    readonly EXT_ORCID: "ext-orcid";
+    readonly EXT_PFAS: "ext-pfas";
+    readonly EXT_PUBMED: "ext-pubmed";
+    readonly EXT_RRID: "ext-rrid";
+    readonly EXT_NIH_GRANT_ID: "ext-nih-grant-id";
+    readonly EXT_DOI: "ext-doi";
+    readonly TEMPORAL: "temporal";
+    readonly EMAIL: "email";
+    readonly NUMERIC: "numeric";
+    readonly PHONE_NUMBER: "phone-number";
+    readonly LIST: "list";
+    readonly CHECKBOX: "checkbox";
+    readonly RADIO: "radio";
+    readonly ATTRIBUTE_VALUE: "attribute-value";
+    readonly PAGE_BREAK: "page-break";
+    readonly SECTION_BREAK: "section-break";
+    readonly IMAGE: "image";
+    readonly RICH_TEXT: "richtext";
+    readonly YOUTUBE: "youtube";
+};
+export type UiInputTypeValue = (typeof UiInputTypeValues)[keyof typeof UiInputTypeValues] | null;
+export declare class UiInputType {
+    private readonly value;
+    private constructor();
+    getValue(): UiInputTypeValue;
+    static TEXTFIELD: UiInputType;
+    static TEXTAREA: UiInputType;
+    static LINK: UiInputType;
+    static EXT_ROR: UiInputType;
+    static EXT_ORCID: UiInputType;
+    static EXT_PFAS: UiInputType;
+    static EXT_PUBMED: UiInputType;
+    static EXT_RRID: UiInputType;
+    static EXT_NIH_GRANT_ID: UiInputType;
+    static EXT_DOI: UiInputType;
+    static TEMPORAL: UiInputType;
+    static EMAIL: UiInputType;
+    static NUMERIC: UiInputType;
+    static PHONE_NUMBER: UiInputType;
+    static LIST: UiInputType;
+    static CHECKBOX: UiInputType;
+    static RADIO: UiInputType;
+    static ATTRIBUTE_VALUE: UiInputType;
+    static PAGE_BREAK: UiInputType;
+    static SECTION_BREAK: UiInputType;
+    static IMAGE: UiInputType;
+    static RICH_TEXT: UiInputType;
+    static YOUTUBE: UiInputType;
+    static NULL: UiInputType;
+    static values(): UiInputType[];
+    static forValue(value: string | null): UiInputType;
+}
+//# sourceMappingURL=UiInputType.d.ts.map

package/dist/org/metadatacenter/model/cedar/types/wrapped-types/UiInputType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UiInputType.d.ts","sourceRoot":"","sources":["../../../../../../../src/org/metadatacenter/model/cedar/types/wrapped-types/UiInputType.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;CAyBpB,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,OAAO,iBAAiB,CAAC,GAAG,IAAI,CAAC;AAEjG,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA0B;IAEhD,OAAO;IAIA,QAAQ,IAAI,gBAAgB;IAInC,OAAc,SAAS,cAAgD;IACvE,OAAc,QAAQ,cAA+C;IACrE,OAAc,IAAI,cAA2C;IAC7D,OAAc,OAAO,cAA8C;IACnE,OAAc,SAAS,cAAgD;IACvE,OAAc,QAAQ,cAA+C;IACrE,OAAc,UAAU,cAAiD;IACzE,OAAc,QAAQ,cAA+C;IACrE,OAAc,gBAAgB,cAAuD;IACrF,OAAc,OAAO,cAA8C;IACnE,OAAc,QAAQ,cAA+C;IACrE,OAAc,KAAK,cAA4C;IAC/D,OAAc,OAAO,cAA8C;IACnE,OAAc,YAAY,cAAmD;IAC7E,OAAc,IAAI,cAA2C;IAC7D,OAAc,QAAQ,cAA+C;IACrE,OAAc,KAAK,cAA4C;IAC/D,OAAc,eAAe,cAAsD;IAEnF,OAAc,UAAU,cAAiD;IACzE,OAAc,aAAa,cAAoD;IAC/E,OAAc,KAAK,cAA4C;IAC/D,OAAc,SAAS,cAAgD;IACvE,OAAc,OAAO,cAA8C;IAEnE,OAAc,IAAI,cAAyB;WAE7B,MAAM,IAAI,WAAW,EAAE;WA+BvB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,WAAW;CAQ1D"}

package/dist/org/metadatacenter/model/cedar/types/wrapped-types/YamlArtifactType.d.ts

@@ -0,0 +1,75 @@
+export declare const YamlArtifactTypeValues: {
+    readonly TEMPLATE: "template";
+    readonly ELEMENT: "element";
+    readonly TEXTFIELD: "text-field";
+    readonly CONTROLLED_TERM: "controlled-term-field";
+    readonly TEXTAREA: "text-area-field";
+    readonly LINK: "link-field";
+    readonly EXT_ROR: "ext-ror-field";
+    readonly EXT_ORCID: "ext-orcid-field";
+    readonly EXT_PFAS: "ext-pfas-field";
+    readonly EXT_PUBMED: "ext-pubmed-field";
+    readonly EXT_RRID: "ext-rrid-field";
+    readonly EXT_NIH_GRANT_ID: "ext-nih-grant-id-field";
+    readonly EXT_DOI: "ext-doi-field";
+    readonly TEMPORAL: "temporal-field";
+    readonly EMAIL: "email-field";
+    readonly NUMERIC: "numeric-field";
+    readonly PHONE_NUMBER: "phone-number-field";
+    readonly SINGLE_SELECT_LIST: "single-select-list-field";
+    readonly MULTI_SELECT_LIST: "multi-select-list-field";
+    readonly CHECKBOX: "checkbox-field";
+    readonly RADIO: "radio-field";
+    readonly ATTRIBUTE_VALUE: "attribute-value-field";
+    readonly PAGE_BREAK: "static-page-break";
+    readonly SECTION_BREAK: "static-section-break";
+    readonly IMAGE: "static-image";
+    readonly RICH_TEXT: "static-rich-text";
+    readonly YOUTUBE: "static-youtube-video";
+    readonly TEMPLATE_INSTANCE: "instance";
+};
+export type YamlArtifactTypeValue = (typeof YamlArtifactTypeValues)[keyof typeof YamlArtifactTypeValues] | null;
+export declare class YamlArtifactType {
+    private readonly value;
+    private readonly category;
+    private constructor();
+    getValue(): YamlArtifactTypeValue;
+    static TEMPLATE: YamlArtifactType;
+    static ELEMENT: YamlArtifactType;
+    static TEXTFIELD: YamlArtifactType;
+    static CONTROLLED_TERM: YamlArtifactType;
+    static TEXTAREA: YamlArtifactType;
+    static LINK: YamlArtifactType;
+    static EXT_ROR: YamlArtifactType;
+    static EXT_ORCID: YamlArtifactType;
+    static EXT_PFAS: YamlArtifactType;
+    static EXT_PUBMED: YamlArtifactType;
+    static EXT_RRID: YamlArtifactType;
+    static EXT_NIH_GRANT_ID: YamlArtifactType;
+    static EXT_DOI: YamlArtifactType;
+    static TEMPORAL: YamlArtifactType;
+    static EMAIL: YamlArtifactType;
+    static NUMERIC: YamlArtifactType;
+    static PHONE_NUMBER: YamlArtifactType;
+    static SINGLE_SELECT_LIST: YamlArtifactType;
+    static MULTI_SELECT_LIST: YamlArtifactType;
+    static CHECKBOX: YamlArtifactType;
+    static RADIO: YamlArtifactType;
+    static ATTRIBUTE_VALUE: YamlArtifactType;
+    static PAGE_BREAK: YamlArtifactType;
+    static SECTION_BREAK: YamlArtifactType;
+    static IMAGE: YamlArtifactType;
+    static RICH_TEXT: YamlArtifactType;
+    static YOUTUBE: YamlArtifactType;
+    static TEMPLATE_INSTANCE: YamlArtifactType;
+    static NULL: YamlArtifactType;
+    static values(): YamlArtifactType[];
+    static forValue(value: string | null): YamlArtifactType;
+    isTemplate(): boolean;
+    isElement(): boolean;
+    isField(): boolean;
+    isStaticField(): boolean;
+    isDynamicField(): boolean;
+    isTemplateInstance(): boolean;
+}
+//# sourceMappingURL=YamlArtifactType.d.ts.map

package/dist/org/metadatacenter/model/cedar/types/wrapped-types/YamlArtifactType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"YamlArtifactType.d.ts","sourceRoot":"","sources":["../../../../../../../src/org/metadatacenter/model/cedar/types/wrapped-types/YamlArtifactType.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCzB,CAAC;AAEX,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,OAAO,sBAAsB,CAAC,GAAG,IAAI,CAAC;AAEhH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA+B;IACrD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAE9C,OAAO;IAKA,QAAQ,IAAI,qBAAqB;IAIxC,OAAc,QAAQ,mBAAkF;IACxG,OAAc,OAAO,mBAAiF;IAEtG,OAAc,SAAS,mBAAsF;IAC7G,OAAc,eAAe,mBAA4F;IACzH,OAAc,QAAQ,mBAAqF;IAC3G,OAAc,IAAI,mBAAiF;IACnG,OAAc,OAAO,mBAAoF;IACzG,OAAc,SAAS,mBAAsF;IAC7G,OAAc,QAAQ,mBAAqF;IAC3G,OAAc,UAAU,mBAAuF;IAC/G,OAAc,QAAQ,mBAAqF;IAC3G,OAAc,gBAAgB,mBAA6F;IAC3H,OAAc,OAAO,mBAAoF;IACzG,OAAc,QAAQ,mBAAqF;IAC3G,OAAc,KAAK,mBAAkF;IACrG,OAAc,OAAO,mBAAoF;IACzG,OAAc,YAAY,mBAAyF;IACnH,OAAc,kBAAkB,mBAA+F;IAC/H,OAAc,iBAAiB,mBAA8F;IAC7H,OAAc,QAAQ,mBAAqF;IAC3G,OAAc,KAAK,mBAAkF;IACrG,OAAc,eAAe,mBAA4F;IAEzH,OAAc,UAAU,mBAAsF;IAC9G,OAAc,aAAa,mBAAyF;IACpH,OAAc,KAAK,mBAAiF;IACpG,OAAc,SAAS,mBAAqF;IAC5G,OAAc,OAAO,mBAAmF;IAExG,OAAc,iBAAiB,mBAA2F;IAE1H,OAAc,IAAI,mBAAuD;WAE3D,MAAM,IAAI,gBAAgB,EAAE;WAsC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,gBAAgB;IAS9D,UAAU,IAAI,OAAO;IAIrB,SAAS,IAAI,OAAO;IAIb,OAAO;IAId,aAAa;IAIb,cAAc;IAId,kBAAkB;CAGnB"}

package/dist/org/metadatacenter/model/cedar/util/compare/ComparisonError.d.ts

@@ -0,0 +1,14 @@
+import { Primitive } from '../../types/basic-types/Primitive';
+import { JsonPath } from '../path/JsonPath';
+import { ComparisonErrorType } from './ComparisonErrorType';
+import { YamlComparisonErrorType } from './YamlComparisonErrorType';
+export declare class ComparisonError {
+    readonly errorLocation: string;
+    readonly errorType: ComparisonErrorType | YamlComparisonErrorType;
+    readonly errorPath: JsonPath;
+    readonly expectedValue?: Primitive;
+    readonly encounteredValue?: Primitive;
+    stackTopLines?: string[];
+    constructor(errorLocation: string, errorType: ComparisonErrorType | YamlComparisonErrorType, errorPath: JsonPath, expectedValue?: Primitive, encounteredValue?: Primitive);
+}
+//# sourceMappingURL=ComparisonError.d.ts.map

package/dist/org/metadatacenter/model/cedar/util/compare/ComparisonError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComparisonError.d.ts","sourceRoot":"","sources":["../../../../../../../src/org/metadatacenter/model/cedar/util/compare/ComparisonError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,qBAAa,eAAe;IAC1B,SAAgB,aAAa,EAAE,MAAM,CAAC;IACtC,SAAgB,SAAS,EAAE,mBAAmB,GAAG,uBAAuB,CAAC;IACzE,SAAgB,SAAS,EAAE,QAAQ,CAAC;IACpC,SAAgB,aAAa,CAAC,EAAE,SAAS,CAAC;IAC1C,SAAgB,gBAAgB,CAAC,EAAE,SAAS,CAAC;IACtC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;gBAG9B,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,mBAAmB,GAAG,uBAAuB,EACxD,SAAS,EAAE,QAAQ,EACnB,aAAa,CAAC,EAAE,SAAS,EACzB,gBAAgB,CAAC,EAAE,SAAS;CAQ/B"}