cedar-model-typescript-library 0.7.0 → 1.0.1

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/template-instance/TemplateInstanceBuilder.d.ts

@@ -0,0 +1,16 @@
+import { AbstractArtifactBuilder } from '../AbstractArtifacBuilder';
+import { TemplateInstance } from './TemplateInstance';
+import { InstanceDataContainer } from './InstanceDataContainer';
+import { InstanceDataAtomType } from './InstanceDataAtomType';
+import { CedarArtifactId } from '../types/cedar-types/CedarArtifactId';
+export declare class TemplateInstanceBuilder extends AbstractArtifactBuilder {
+    private schema_isBasedOn;
+    private dataContainer;
+    withSchemaIsBasedOn(schema_isBasedOn: CedarArtifactId | string): TemplateInstanceBuilder;
+    withDataValue(key: string, value: InstanceDataAtomType): TemplateInstanceBuilder;
+    withDataIri(key: string, iri: string): TemplateInstanceBuilder;
+    withDataId(id: string | null): TemplateInstanceBuilder;
+    withDataContainer(dataContainer: InstanceDataContainer): TemplateInstanceBuilder;
+    build(): TemplateInstance;
+}
+//# sourceMappingURL=TemplateInstanceBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TemplateInstanceBuilder.d.ts","sourceRoot":"","sources":["../../../../../../src/org/metadatacenter/model/cedar/template-instance/TemplateInstanceBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AAEvE,qBAAa,uBAAwB,SAAQ,uBAAuB;IAClE,OAAO,CAAC,gBAAgB,CAAyC;IACjE,OAAO,CAAC,aAAa,CAAsD;IAEpE,mBAAmB,CAAC,gBAAgB,EAAE,eAAe,GAAG,MAAM,GAAG,uBAAuB;IASxF,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,oBAAoB,GAAG,uBAAuB;IAKhF,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,uBAAuB;IAK9D,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,uBAAuB;IAKtD,iBAAiB,CAAC,aAAa,EAAE,qBAAqB,GAAG,uBAAuB;IAKhF,KAAK,IAAI,gBAAgB;CAmBjC"}

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"}

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

@@ -0,0 +1,36 @@
+import { ComparisonError } from './ComparisonError';
+export declare class JsonArtifactParsingResult {
+    private blueprintComparisonErrors;
+    private blueprintComparisonWarnings;
+    addBlueprintComparisonError(error: ComparisonError): void;
+    getBlueprintComparisonErrors(): Array<ComparisonError>;
+    getBlueprintComparisonErrorCount(): number;
+    addBlueprintComparisonWarning(warning: ComparisonError): void;
+    getBlueprintComparisonWarnings(): Array<ComparisonError>;
+    getBlueprintComparisonWarningCount(): number;
+    /**
+     * Nothing went wrong that stops a caller using what was read.
+     *
+     * Errors only. A document that parsed with warnings produced a usable
+     * artifact — the warnings say it was written in a form the blueprint no longer
+     * describes, not that reading it failed.
+     */
+    wasSuccessful(): boolean;
+    /**
+     * The document matches the blueprint exactly.
+     *
+     * Errors *and* warnings, which is what separates this from `wasSuccessful`.
+     * The two were identical implementations until warnings carried real signal;
+     * once a reader started recording production variations as warnings rather
+     * than rejecting them, "it read cleanly" and "it is in the canonical form"
+     * stopped being the same claim, and the stricter one had nowhere to live.
+     *
+     * A template CEDAR served in 2018 is the case that makes the difference
+     * concrete: it reads, so `wasSuccessful` is true, but it does not adhere, so
+     * this is false. Which one a caller wants depends on whether it is about to
+     * consume the artifact or about to judge it.
+     */
+    adheresToBlueprint(): boolean;
+    merge(otherResult: JsonArtifactParsingResult): void;
+}
+//# sourceMappingURL=JsonArtifactParsingResult.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"JsonArtifactParsingResult.d.ts","sourceRoot":"","sources":["../../../../../../../src/org/metadatacenter/model/cedar/util/compare/JsonArtifactParsingResult.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,qBAAa,yBAAyB;IACpC,OAAO,CAAC,yBAAyB,CAA8B;IAC/D,OAAO,CAAC,2BAA2B,CAA8B;IAE1D,2BAA2B,CAAC,KAAK,EAAE,eAAe;IAIlD,4BAA4B,IAAI,KAAK,CAAC,eAAe,CAAC;IAI7D,gCAAgC;IAIzB,6BAA6B,CAAC,OAAO,EAAE,eAAe;IAItD,8BAA8B,IAAI,KAAK,CAAC,eAAe,CAAC;IAI/D,kCAAkC;IAIlC;;;;;;OAMG;IACI,aAAa,IAAI,OAAO;IAI/B;;;;;;;;;;;;;OAaG;IACI,kBAAkB,IAAI,OAAO;IAIpC,KAAK,CAAC,WAAW,EAAE,yBAAyB;CAI7C"}

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

@@ -0,0 +1,47 @@
+import { JsonArtifactParsingResult } from './JsonArtifactParsingResult';
+import { Primitive } from '../../types/basic-types/Primitive';
+import { JsonPath } from '../path/JsonPath';
+import { ReaderWriterBehavior } from '../../../../behavior/ReaderWriterBehavior';
+import { ComparableObject } from './ComparableObject';
+export declare class JsonObjectComparator {
+    static compareBothWays(comparisonResult: JsonArtifactParsingResult, blueprintObject: ComparableObject, realObject: ComparableObject, path: JsonPath, behavior: ReaderWriterBehavior, acceptDiffKeys?: string[]): void;
+    /**
+     * Differences that real CEDAR templates exhibit, and which the library must
+     * therefore read rather than reject.
+     *
+     * The blueprint describes what the library writes today. The corpus contains
+     * templates CEDAR served between 2018 and 2024, and 23 of the 123 differ from
+     * that blueprint — not because they are broken, but because the canonical form
+     * moved while they stayed as they were emitted. A reader that rejects them
+     * cannot open documents that demonstrably exist, so each shape below is
+     * downgraded to a warning under a behavior that tolerates known issues.
+     * `STRICT` still treats every one as an error, which is what makes it strict.
+     *
+     * The observation is not discarded: it is recorded as a warning and remains
+     * retrievable through `getBlueprintComparisonWarnings`.
+     *
+     *  - **`@context` additionalProperties** — the blueprint pins `false`; older
+     *    templates allow further URI-valued entries.
+     *  - **`@context` prefixes and required list** — `bibo` and others were added
+     *    to the canonical context over time, so earlier documents lack them.
+     *  - **an attribute-value field's `@context` enum** — omitted by templates
+     *    predating the current attribute-value serialization.
+     *  - **`_ui.propertyDescriptions`** — a later addition, absent throughout
+     *    documents written before it existed.
+     */
+    static isKnownProductionVariation(path: JsonPath): boolean;
+    /**
+     * A one-sided blueprint difference, at the severity the behavior asks for.
+     *
+     * `compareToLeft` walks the template's `properties` against the blueprint, and
+     * it is where the last of the production variations surface: an older
+     * `@context` schema whose `additionalProperties` permits further URI entries
+     * rather than pinning `false`, and one whose `required` list predates prefixes
+     * later added to the canonical context. Both belong to documents CEDAR served,
+     * so a reader that rejects them is refusing real data.
+     */
+    private static reportToLeft;
+    static compareToLeft(comparisonResult: JsonArtifactParsingResult, blueprintObject: ComparableObject, realObject: ComparableObject, path: JsonPath, behavior: ReaderWriterBehavior): void;
+    static comparePrimitive(comparisonResult: JsonArtifactParsingResult, blue: Primitive, actual: Primitive, path: JsonPath): JsonArtifactParsingResult;
+}
+//# sourceMappingURL=JsonObjectComparator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"JsonObjectComparator.d.ts","sourceRoot":"","sources":["../../../../../../../src/org/metadatacenter/model/cedar/util/compare/JsonObjectComparator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAExE,OAAO,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAK5C,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,qBAAa,oBAAoB;IAC/B,MAAM,CAAC,eAAe,CACpB,gBAAgB,EAAE,yBAAyB,EAC3C,eAAe,EAAE,gBAAgB,EACjC,UAAU,EAAE,gBAAgB,EAC5B,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,oBAAoB,EAC9B,cAAc,GAAE,MAAM,EAAO,GAC5B,IAAI;IAkHP;;;;;;;;;;;;;;;;;;;;;;;OAuBG;WACW,0BAA0B,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO;IAcjE;;;;;;;;;OASG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAQ3B,MAAM,CAAC,aAAa,CAClB,gBAAgB,EAAE,yBAAyB,EAC3C,eAAe,EAAE,gBAAgB,EACjC,UAAU,EAAE,gBAAgB,EAC5B,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,oBAAoB,GAC7B,IAAI;IAmEP,MAAM,CAAC,gBAAgB,CACrB,gBAAgB,EAAE,yBAAyB,EAC3C,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,QAAQ,GACb,yBAAyB;CAM7B"}

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

@@ -0,0 +1,28 @@
+import { ComparisonError } from './ComparisonError';
+export declare class YamlArtifactParsingResult {
+    private blueprintComparisonErrors;
+    private blueprintComparisonWarnings;
+    addBlueprintComparisonError(error: ComparisonError): void;
+    getBlueprintComparisonErrors(): Array<ComparisonError>;
+    getBlueprintComparisonErrorCount(): number;
+    addBlueprintComparisonWarning(warning: ComparisonError): void;
+    getBlueprintComparisonWarnings(): Array<ComparisonError>;
+    getBlueprintComparisonWarningCount(): number;
+    /**
+     * Nothing went wrong that stops a caller using what was read.
+     *
+     * Errors only. A document that parsed with warnings produced a usable
+     * artifact — the warnings say it was written in a form the blueprint no longer
+     * describes, not that reading it failed.
+     */
+    wasSuccessful(): boolean;
+    /**
+     * The document matches the blueprint exactly.
+     *
+     * Errors *and* warnings, which is what separates this from `wasSuccessful`.
+     * See the JSON counterpart for why the two stopped meaning the same thing.
+     */
+    adheresToBlueprint(): boolean;
+    merge(otherResult: YamlArtifactParsingResult): void;
+}
+//# sourceMappingURL=YamlArtifactParsingResult.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"YamlArtifactParsingResult.d.ts","sourceRoot":"","sources":["../../../../../../../src/org/metadatacenter/model/cedar/util/compare/YamlArtifactParsingResult.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,qBAAa,yBAAyB;IACpC,OAAO,CAAC,yBAAyB,CAA8B;IAC/D,OAAO,CAAC,2BAA2B,CAA8B;IAE1D,2BAA2B,CAAC,KAAK,EAAE,eAAe;IAIlD,4BAA4B,IAAI,KAAK,CAAC,eAAe,CAAC;IAI7D,gCAAgC;IAIzB,6BAA6B,CAAC,OAAO,EAAE,eAAe;IAItD,8BAA8B,IAAI,KAAK,CAAC,eAAe,CAAC;IAI/D,kCAAkC;IAIlC;;;;;;OAMG;IACI,aAAa,IAAI,OAAO;IAI/B;;;;;OAKG;IACI,kBAAkB,IAAI,OAAO;IAIpC,KAAK,CAAC,WAAW,EAAE,yBAAyB;CAI7C"}

package/dist/org/metadatacenter/model/cedar/util/serialization/JsonTemplateElementContent.d.ts

@@ -0,0 +1,25 @@
+import { JsonNode } from '../../types/basic-types/JsonNode';
+export declare class JsonTemplateElementContent {
+    static REQUIRED_PARTIAL: string[];
+    static PROPERTIES_PARTIAL: JsonNode;
+    /**
+     * The `@id` typing a stored element carries, which is not the one written now.
+     *
+     * An occurrence has no identity until its instance is uploaded, so a template written since the
+     * server took that over types the key `["string", "null"]`. Everything written before types it
+     * `"string"`, and both are documents this library has to read: nothing rewrites a stored artifact,
+     * and an artifact is not wrong for predating a rule. A reader accepts either; only a writer moves.
+     */
+    static readonly LEGACY_ID_TYPING: JsonNode;
+    /**
+     * The blueprint, with the `@id` typing the document actually carries.
+     *
+     * Comparison is verbatim, so the blueprint has to name the accepted form the document chose, or a
+     * stored element reads as departing from the model for a key it types exactly as it was told to.
+     */
+    static acceptEitherIdTyping(blueprint: JsonNode, documentProperties: JsonNode): void;
+    static REQUIRED_PARTIAL_KEY_MAP: Map<string, boolean>;
+    static PROPERTIES_PARTIAL_KEY_MAP: Map<string, boolean>;
+    static CONTEXT_VERBATIM_NO_BIBO: JsonNode;
+}
+//# sourceMappingURL=JsonTemplateElementContent.d.ts.map

package/dist/org/metadatacenter/model/cedar/util/serialization/JsonTemplateElementContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonTemplateElementContent.d.ts","sourceRoot":"","sources":["../../../../../../../src/org/metadatacenter/model/cedar/util/serialization/JsonTemplateElementContent.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAE5D,qBAAa,0BAA0B;IAErC,OAAc,gBAAgB,WAAuB;IAIrD,OAAc,kBAAkB,EAAE,QAAQ,CAgCxC;IAEF;;;;;;;OAOG;IACH,gBAAuB,gBAAgB,EAAE,QAAQ,CAG/C;IAEF;;;;;OAKG;WACW,oBAAoB,CAAC,SAAS,EAAE,QAAQ,EAAE,kBAAkB,EAAE,QAAQ,GAAG,IAAI;IAO3F,OAAc,wBAAwB,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7D,OAAc,0BAA0B,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAa;IAC3E,OAAc,wBAAwB,EAAE,QAAQ,CAAC;CAgBlD"}

package/dist/package-lock.json

@@ -0,0 +1,13 @@
+{
+  "name": "@org.metadatacenter/cedar-model-typescript-library",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@org.metadatacenter/cedar-model-typescript-library",
+      "version": "1.0.0",
+      "license": "ISC"
+    }
+  }
+}

package/dist/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@org.metadatacenter/cedar-model-typescript-library",
+  "version": "1.0.1",
+  "description": "CEDAR Model Typescript Library - a library to work with fields, elements, templates and instances implemented in TypeScript",
+  "main": "index.js",
+  "module": "index.esm.js",
+  "types": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/metadatacenter/cedar-model-typescript-library.git"
+  },
+  "keywords": ["CEDAR", "Model", "TypeScript", "Library"],
+  "author": "Metadatacenter.org - Attila L. Egyedi",
+  "license": "BSD-2-Clause",
+  "bugs": {
+    "url": "https://github.com/metadatacenter/cedar-model-typescript-library/issues"
+  },
+  "homepage": "https://github.com/metadatacenter/cedar-model-typescript-library#readme"
+}