@nfdi4plants/arctrl 2.3.1 → 2.5.0

package/ROCrate/Generic/Dataset.js

@@ -0,0 +1,669 @@
+import { value as value_1, unwrap } from "../../fable_modules/fable-library-js.4.24.0/Option.js";
+import { LDPerson } from "./Person.js";
+import { LDFile } from "./File.js";
+import { LDScholarlyArticle } from "./ScholarlyArticle.js";
+import { LDComment } from "./Comment.js";
+import { LDLabProcess } from "./LabProcess.js";
+import { LDDefinedTerm } from "./DefinedTerm.js";
+import { LDPropertyValue } from "./PropertyValue.js";
+import { ResizeArray_tryPick } from "../../Core/Helper/Collections.js";
+import { contains } from "../../fable_modules/fable-library-js.4.24.0/Array.js";
+import { stringHash } from "../../fable_modules/fable-library-js.4.24.0/Util.js";
+import { LDNode } from "../LDObject.js";
+import { class_type } from "../../fable_modules/fable-library-js.4.24.0/Reflection.js";
+
+export class LDDataset {
+    constructor() {
+    }
+    static get schemaType() {
+        return "http://schema.org/Dataset";
+    }
+    static get identifier() {
+        return "http://schema.org/identifier";
+    }
+    static get creator() {
+        return "http://schema.org/creator";
+    }
+    static get dateCreated() {
+        return "http://schema.org/dateCreated";
+    }
+    static get datePublished() {
+        return "http://schema.org/datePublished";
+    }
+    static get sdDatePublished() {
+        return "http://schema.org/datePublished";
+    }
+    static get license() {
+        return "http://schema.org/license";
+    }
+    static get dateModified() {
+        return "http://schema.org/dateModified";
+    }
+    static get description() {
+        return "http://schema.org/description";
+    }
+    static get hasPart() {
+        return "http://schema.org/hasPart";
+    }
+    static get headline() {
+        return "http://schema.org/headline";
+    }
+    static get name() {
+        return "http://schema.org/name";
+    }
+    static get citation() {
+        return "http://schema.org/citation";
+    }
+    static get comment() {
+        return "http://schema.org/comment";
+    }
+    static get mentions() {
+        return "http://schema.org/mentions";
+    }
+    static get url() {
+        return "http://schema.org/url";
+    }
+    static get about() {
+        return "http://schema.org/about";
+    }
+    static get measurementMethod() {
+        return "http://schema.org/measurementMethod";
+    }
+    static get measurementTechnique() {
+        return "http://schema.org/measurementTechnique";
+    }
+    static get variableMeasured() {
+        return "http://schema.org/variableMeasured";
+    }
+    static tryGetIdentifierAsString(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.identifier, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                matchResult = 0;
+                n = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static getIdentifierAsString(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.identifier, unwrap(context));
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                const n = value_1(matchValue);
+                return n;
+            }
+            else {
+                throw new Error(`property \`identifier\` of object with @id \`${lp.Id}\` was not a string`);
+            }
+        }
+        else {
+            throw new Error(`Could not access property \`identifier\` of object with @id \`${lp.Id}\``);
+        }
+    }
+    static setIdentifierAsString(lp, identifier, context) {
+        return lp.SetProperty(LDDataset.identifier, identifier, unwrap(context));
+    }
+    static getCreators(lp, graph, context) {
+        return lp.GetPropertyNodes(LDDataset.creator, (p, ctx) => LDPerson.validate(p, unwrap(ctx)), unwrap(graph), unwrap(context));
+    }
+    static setCreators(lp, creators, context) {
+        return lp.SetProperty(LDDataset.creator, creators, unwrap(context));
+    }
+    static tryGetDateCreatedAsDateTime(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.dateCreated, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (value_1(matchValue) instanceof Date) {
+                matchResult = 0;
+                n = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static setDateCreatedAsDateTime(lp, dateCreated, context) {
+        return lp.SetProperty(LDDataset.dateCreated, dateCreated, unwrap(context));
+    }
+    static tryGetDatePublishedAsDateTime(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.datePublished, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (value_1(matchValue) instanceof Date) {
+                matchResult = 0;
+                n = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static setDatePublishedAsDateTime(lp, datePublished, context) {
+        return lp.SetProperty(LDDataset.datePublished, datePublished, unwrap(context));
+    }
+    static tryGetSDDatePublishedAsDateTime(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.sdDatePublished, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (value_1(matchValue) instanceof Date) {
+                matchResult = 0;
+                n = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static setSDDatePublishedAsDateTime(lp, sdDatePublished, context) {
+        return lp.SetProperty(LDDataset.sdDatePublished, sdDatePublished, unwrap(context));
+    }
+    static tryGetLicenseAsString(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.license, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                matchResult = 0;
+                n = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static setLicenseAsString(lp, license, context) {
+        return lp.SetProperty(LDDataset.license, license, unwrap(context));
+    }
+    static setLicenseAsCreativeWork(lp, license, context) {
+        return lp.SetProperty(LDDataset.license, license, unwrap(context));
+    }
+    static tryGetDateModifiedAsDateTime(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.dateModified, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (value_1(matchValue) instanceof Date) {
+                matchResult = 0;
+                n = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static setDateModifiedAsDateTime(lp, dateModified, context) {
+        return lp.SetProperty(LDDataset.dateModified, dateModified, unwrap(context));
+    }
+    static tryGetDescriptionAsString(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.description, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                matchResult = 0;
+                n = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static getDescriptionAsString(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.description, unwrap(context));
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                const n = value_1(matchValue);
+                return n;
+            }
+            else {
+                throw new Error(`property \`description\` of object with @id \`${lp.Id}\` was not a string`);
+            }
+        }
+        else {
+            throw new Error(`Could not access property \`description\` of object with @id \`${lp.Id}\``);
+        }
+    }
+    static setDescriptionAsString(lp, description, context) {
+        return lp.SetProperty(LDDataset.description, description, unwrap(context));
+    }
+    static getHasParts(lp, graph, context) {
+        return lp.GetPropertyNodes(LDDataset.hasPart, undefined, unwrap(graph), unwrap(context));
+    }
+    static getHasPartsAsDataset(lp, graph, context) {
+        return lp.GetPropertyNodes(LDDataset.hasPart, (ldnode, context_1) => LDDataset.validate(ldnode, unwrap(context_1)), unwrap(graph), unwrap(context));
+    }
+    static getHasPartsAsFile(lp, graph, context) {
+        return lp.GetPropertyNodes(LDDataset.hasPart, (ldnode, context_1) => LDFile.validate(ldnode, unwrap(context_1)), unwrap(graph), unwrap(context));
+    }
+    static setHasParts(lp, hasParts, context) {
+        return lp.SetProperty(LDDataset.hasPart, hasParts, unwrap(context));
+    }
+    static tryGetHeadlineAsString(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.headline, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                matchResult = 0;
+                n = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static tryGetNameAsString(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.name, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                matchResult = 0;
+                n = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static getNameAsString(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.name, unwrap(context));
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                const n = value_1(matchValue);
+                return n;
+            }
+            else {
+                throw new Error(`property \`name\` of object with @id \`${lp.Id}\` was not a string`);
+            }
+        }
+        else {
+            throw new Error(`Could not access property \`name\` of object with @id \`${lp.Id}\``);
+        }
+    }
+    static setNameAsString(lp, name, context) {
+        return lp.SetProperty(LDDataset.name, name, unwrap(context));
+    }
+    static getCitations(lp, graph, context) {
+        return lp.GetPropertyNodes(LDDataset.citation, (ldnode, context_1) => LDScholarlyArticle.validate(ldnode, unwrap(context_1)), unwrap(graph), unwrap(context));
+    }
+    static setCitations(lp, citations, context) {
+        return lp.SetProperty(LDDataset.citation, citations, unwrap(context));
+    }
+    static getComments(lp, graph, context) {
+        return lp.GetPropertyNodes(LDDataset.comment, (ldnode, context_1) => LDComment.validate(ldnode, unwrap(context_1)), unwrap(graph), unwrap(context));
+    }
+    static setComments(lp, comments, context) {
+        return lp.SetProperty(LDDataset.comment, comments, unwrap(context));
+    }
+    static tryGetUrlAsString(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.url, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                matchResult = 0;
+                n = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static getUrlAsString(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.url, unwrap(context));
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                const n = value_1(matchValue);
+                return n;
+            }
+            else {
+                throw new Error(`property \`url\` of object with @id \`${lp.Id}\` was not a string`);
+            }
+        }
+        else {
+            throw new Error(`Could not access property \`url\` of object with @id \`${lp.Id}\``);
+        }
+    }
+    static setUrlAsString(lp, url, context) {
+        return lp.SetProperty(LDDataset.url, url, unwrap(context));
+    }
+    static getAbouts(lp, graph, context) {
+        return lp.GetPropertyNodes(LDDataset.about, undefined, unwrap(graph), unwrap(context));
+    }
+    static getAboutsAsLabProcess(lp, graph, context) {
+        return lp.GetPropertyNodes(LDDataset.about, (ldnode, context_1) => LDLabProcess.validate(ldnode, unwrap(context_1)), unwrap(graph), unwrap(context));
+    }
+    static setAbouts(lp, abouts, context) {
+        return lp.SetProperty(LDDataset.about, abouts, unwrap(context));
+    }
+    static tryGetMeasurementMethodAsString(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.measurementMethod, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                matchResult = 0;
+                n = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static tryGetMeasurementMethodAsDefinedTerm(lp, graph, context) {
+        let n;
+        const matchValue = lp.TryGetPropertyAsSingleNode(LDDataset.measurementMethod, unwrap(graph), unwrap(context));
+        let matchResult, n_1;
+        if (matchValue != null) {
+            if ((n = matchValue, LDDefinedTerm.validate(n, unwrap(context)))) {
+                matchResult = 0;
+                n_1 = matchValue;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n_1;
+            default:
+                return undefined;
+        }
+    }
+    static setMeasurementMethodAsString(lp, measurementMethod, context) {
+        return lp.SetProperty(LDDataset.measurementMethod, measurementMethod, unwrap(context));
+    }
+    static setMeasurementMethodAsDefinedTerm(lp, measurementMethod, context) {
+        return lp.SetProperty(LDDataset.measurementMethod, measurementMethod, unwrap(context));
+    }
+    static tryGetMeasurementTechniqueAsString(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.measurementTechnique, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                matchResult = 0;
+                n = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static tryGetMeasurementTechniqueAsDefinedTerm(lp, graph, context) {
+        let n;
+        const matchValue = lp.TryGetPropertyAsSingleNode(LDDataset.measurementTechnique, unwrap(graph), unwrap(context));
+        let matchResult, n_1;
+        if (matchValue != null) {
+            if ((n = matchValue, LDDefinedTerm.validate(n, unwrap(context)))) {
+                matchResult = 0;
+                n_1 = matchValue;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n_1;
+            default:
+                return undefined;
+        }
+    }
+    static setMeasurementTechniqueAsString(lp, measurementTechnique, context) {
+        return lp.SetProperty(LDDataset.measurementTechnique, measurementTechnique, unwrap(context));
+    }
+    static setMeasurementTechniqueAsDefinedTerm(lp, measurementTechnique, context) {
+        return lp.SetProperty(LDDataset.measurementTechnique, measurementTechnique, unwrap(context));
+    }
+    static tryGetVariableMeasuredAsString(lp, context) {
+        const matchValue = lp.TryGetPropertyAsSingleton(LDDataset.variableMeasured, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (typeof value_1(matchValue) === "string") {
+                matchResult = 0;
+                n = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static tryGetVariableMeasuredAsPropertyValue(lp, graph, context) {
+        let n;
+        const matchValue = lp.TryGetPropertyAsSingleNode(LDDataset.variableMeasured, unwrap(graph), unwrap(context));
+        let matchResult, n_1;
+        if (matchValue != null) {
+            if ((n = matchValue, LDPropertyValue.validate(n, unwrap(context)))) {
+                matchResult = 0;
+                n_1 = matchValue;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n_1;
+            default:
+                return undefined;
+        }
+    }
+    static tryGetVariableMeasuredAsMeasurementType(lp, graph, context) {
+        return ResizeArray_tryPick((n) => {
+            if (!LDPropertyValue.validateFragmentDescriptor(n, unwrap(context))) {
+                return n;
+            }
+            else {
+                return undefined;
+            }
+        }, lp.GetPropertyNodes(LDDataset.variableMeasured, undefined, unwrap(graph), unwrap(context)));
+    }
+    static getVariableMeasuredAsFragmentDescriptors(lp, graph, context) {
+        return lp.GetPropertyNodes(LDDataset.variableMeasured, (ldnode, context_1) => LDPropertyValue.validateFragmentDescriptor(ldnode, unwrap(context_1)), unwrap(graph), unwrap(context));
+    }
+    static setVariableMeasuredAsString(lp, variableMeasured, context) {
+        return lp.SetProperty(LDDataset.variableMeasured, variableMeasured, unwrap(context));
+    }
+    static setVariableMeasuredAsPropertyValue(lp, variableMeasured, context) {
+        return lp.SetProperty(LDDataset.variableMeasured, variableMeasured, unwrap(context));
+    }
+    static setVariableMeasuredAsPropertyValues(lp, variableMeasured, context) {
+        return lp.SetProperty(LDDataset.variableMeasured, variableMeasured, unwrap(context));
+    }
+    static genIDInvesigation() {
+        return "./";
+    }
+    static genIDStudy(identifier) {
+        return `studies/${identifier}/`;
+    }
+    static genIDAssay(identifier) {
+        return `assay/${identifier}/`;
+    }
+    static validate(lp, context) {
+        return lp.HasType(LDDataset.schemaType, unwrap(context));
+    }
+    static validateInvestigation(lp, context) {
+        return LDDataset.validate(lp, unwrap(context)) && contains("Investigation", lp.AdditionalType, {
+            Equals: (x, y) => (x === y),
+            GetHashCode: stringHash,
+        });
+    }
+    static validateStudy(lp, context) {
+        return LDDataset.validate(lp, unwrap(context)) && contains("Study", lp.AdditionalType, {
+            Equals: (x, y) => (x === y),
+            GetHashCode: stringHash,
+        });
+    }
+    static validateAssay(lp, context) {
+        return LDDataset.validate(lp, unwrap(context)) && contains("Assay", lp.AdditionalType, {
+            Equals: (x, y) => (x === y),
+            GetHashCode: stringHash,
+        });
+    }
+    static create(id, identier, creators, dateCreated, datePublished, dateModified, description, hasParts, name, citations, comments, mentions, url, abouts, measurementMethod, measurementTechnique, variableMeasureds, context) {
+        const s = new LDNode(id, [LDDataset.schemaType], undefined, unwrap(context));
+        s.SetOptionalProperty(LDDataset.identifier, identier, unwrap(context));
+        s.SetOptionalProperty(LDDataset.creator, creators, unwrap(context));
+        s.SetOptionalProperty(LDDataset.dateCreated, dateCreated, unwrap(context));
+        s.SetOptionalProperty(LDDataset.datePublished, datePublished, unwrap(context));
+        s.SetOptionalProperty(LDDataset.dateModified, dateModified, unwrap(context));
+        s.SetOptionalProperty(LDDataset.description, description, unwrap(context));
+        s.SetOptionalProperty(LDDataset.hasPart, hasParts, unwrap(context));
+        s.SetOptionalProperty(LDDataset.name, name, unwrap(context));
+        s.SetOptionalProperty(LDDataset.citation, citations, unwrap(context));
+        s.SetOptionalProperty(LDDataset.comment, comments, unwrap(context));
+        s.SetOptionalProperty(LDDataset.mentions, mentions, unwrap(context));
+        s.SetOptionalProperty(LDDataset.url, url, unwrap(context));
+        s.SetOptionalProperty(LDDataset.about, abouts, unwrap(context));
+        s.SetOptionalProperty(LDDataset.measurementMethod, measurementMethod, unwrap(context));
+        s.SetOptionalProperty(LDDataset.measurementTechnique, measurementTechnique, unwrap(context));
+        s.SetOptionalProperty(LDDataset.variableMeasured, variableMeasureds, unwrap(context));
+        return s;
+    }
+    static createInvestigation(identifier, name, id, creators, dateCreated, datePublished, dateModified, description, hasParts, citations, comments, mentions, url, context) {
+        const id_1 = (id == null) ? LDDataset.genIDInvesigation() : id;
+        const s = LDDataset.create(id_1, identifier, unwrap(creators), unwrap(dateCreated), unwrap(datePublished), unwrap(dateModified), unwrap(description), unwrap(hasParts), name, unwrap(citations), unwrap(comments), unwrap(mentions), unwrap(url), undefined, undefined, undefined, undefined, unwrap(context));
+        s.AdditionalType = ["Investigation"];
+        return s;
+    }
+    static createStudy(identifier, id, creators, dateCreated, datePublished, dateModified, description, hasParts, name, citations, variableMeasureds, comments, url, abouts, context) {
+        const id_1 = (id == null) ? LDDataset.genIDStudy(identifier) : id;
+        const s = LDDataset.create(id_1, identifier, unwrap(creators), unwrap(dateCreated), unwrap(datePublished), unwrap(dateModified), unwrap(description), unwrap(hasParts), unwrap(name), unwrap(citations), unwrap(comments), undefined, unwrap(url), unwrap(abouts), undefined, undefined, unwrap(variableMeasureds), unwrap(context));
+        s.AdditionalType = ["Study"];
+        return s;
+    }
+    static createAssay(identifier, id, description, creators, hasParts, measurementMethod, measurementTechnique, variableMeasureds, abouts, comments, context) {
+        const id_1 = (id == null) ? LDDataset.genIDAssay(identifier) : id;
+        const s = LDDataset.create(id_1, identifier, unwrap(creators), undefined, undefined, undefined, unwrap(description), unwrap(hasParts), undefined, undefined, unwrap(comments), undefined, undefined, unwrap(abouts), unwrap(measurementMethod), unwrap(measurementTechnique), unwrap(variableMeasureds), unwrap(context));
+        s.AdditionalType = ["Assay"];
+        return s;
+    }
+}
+
+export function LDDataset_$reflection() {
+    return class_type("ARCtrl.ROCrate.LDDataset", undefined, LDDataset);
+}
+