@nfdi4plants/arctrl 2.4.0 → 2.5.1

package/ROCrate/Generic/PropertyValue.js

@@ -0,0 +1,548 @@
+import { toArray, defaultArg, value as value_3, unwrap } from "../../fable_modules/fable-library-js.4.24.0/Option.js";
+import { ResizeArray_map } 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 { clean } from "../Helper.js";
+import { LDNode } from "../LDObject.js";
+import { iterate } from "../../fable_modules/fable-library-js.4.24.0/Seq.js";
+import { class_type } from "../../fable_modules/fable-library-js.4.24.0/Reflection.js";
+
+export class LDPropertyValue {
+    constructor() {
+    }
+    static get schemaType() {
+        return "http://schema.org/PropertyValue";
+    }
+    static get name() {
+        return "http://schema.org/name";
+    }
+    static get value() {
+        return "http://schema.org/value";
+    }
+    static get propertyID() {
+        return "http://schema.org/propertyID";
+    }
+    static get unitCode() {
+        return "http://schema.org/unitCode";
+    }
+    static get unitText() {
+        return "http://schema.org/unitText";
+    }
+    static get valueReference() {
+        return "http://schema.org/valueReference";
+    }
+    static get measurementMethod() {
+        return "http://schema.org/measurementMethod";
+    }
+    static get description() {
+        return "http://schema.org/description";
+    }
+    static get alternateName() {
+        return "http://schema.org/alternateName";
+    }
+    static get subjectOf() {
+        return "http://schema.org/subjectOf";
+    }
+    static get disambiguatingDescription() {
+        return "http://schema.org/disambiguatingDescription";
+    }
+    static get doiKey() {
+        return "DOI";
+    }
+    static get doiURL() {
+        return "http://purl.obolibrary.org/obo/OBI_0002110";
+    }
+    static get pubmedIDKey() {
+        return "PubMedID";
+    }
+    static get pubmedIDURL() {
+        return "http://purl.obolibrary.org/obo/OBI_0001617";
+    }
+    static tryGetNameAsString(pv, context) {
+        const matchValue = pv.TryGetPropertyAsSingleton(LDPropertyValue.name, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (typeof value_3(matchValue) === "string") {
+                matchResult = 0;
+                n = value_3(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static getNameAsString(pv, context) {
+        const matchValue = pv.TryGetPropertyAsSingleton(LDPropertyValue.name, unwrap(context));
+        if (matchValue != null) {
+            if (typeof value_3(matchValue) === "string") {
+                const n = value_3(matchValue);
+                return n;
+            }
+            else {
+                throw new Error(`Property of \`name\` of object with @id \`${pv.Id}\` was not a string`);
+            }
+        }
+        else {
+            throw new Error(`Could not access property \`name\` of object with @id \`${pv.Id}\``);
+        }
+    }
+    static setNameAsString(pv, name, context) {
+        return pv.SetProperty(LDPropertyValue.name, name, unwrap(context));
+    }
+    static tryGetValueAsString(pv, context) {
+        const matchValue = pv.TryGetPropertyAsSingleton(LDPropertyValue.value, unwrap(context));
+        let matchResult, v;
+        if (matchValue != null) {
+            if (typeof value_3(matchValue) === "string") {
+                matchResult = 0;
+                v = value_3(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return v;
+            default:
+                return undefined;
+        }
+    }
+    static getValueAsString(pv, context) {
+        const matchValue = pv.TryGetPropertyAsSingleton(LDPropertyValue.value, unwrap(context));
+        if (matchValue != null) {
+            if (typeof value_3(matchValue) === "string") {
+                const v = value_3(matchValue);
+                return v;
+            }
+            else {
+                throw new Error(`Property of \`value\` of object with @id \`${pv.Id}\` was not a string`);
+            }
+        }
+        else {
+            throw new Error(`Could not access property \`value\` of object with @id \`${pv.Id}\``);
+        }
+    }
+    static setValueAsString(pv, value, context) {
+        return pv.SetProperty(LDPropertyValue.value, value, unwrap(context));
+    }
+    static tryGetPropertyIDAsString(pv, context) {
+        const matchValue = pv.TryGetPropertyAsSingleton(LDPropertyValue.propertyID, unwrap(context));
+        let matchResult, pid;
+        if (matchValue != null) {
+            if (typeof value_3(matchValue) === "string") {
+                matchResult = 0;
+                pid = value_3(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return pid;
+            default:
+                return undefined;
+        }
+    }
+    static setPropertyIDAsString(pv, propertyID, context) {
+        return pv.SetProperty(LDPropertyValue.propertyID, propertyID, unwrap(context));
+    }
+    static tryGetUnitCodeAsString(pv, context) {
+        const matchValue = pv.TryGetPropertyAsSingleton(LDPropertyValue.unitCode, unwrap(context));
+        let matchResult, uc;
+        if (matchValue != null) {
+            if (typeof value_3(matchValue) === "string") {
+                matchResult = 0;
+                uc = value_3(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return uc;
+            default:
+                return undefined;
+        }
+    }
+    static setUnitCodeAsString(pv, unitCode, context) {
+        return pv.SetProperty(LDPropertyValue.unitCode, unitCode, unwrap(context));
+    }
+    static tryGetUnitTextAsString(pv, context) {
+        const matchValue = pv.TryGetPropertyAsSingleton(LDPropertyValue.unitText, unwrap(context));
+        let matchResult, ut;
+        if (matchValue != null) {
+            if (typeof value_3(matchValue) === "string") {
+                matchResult = 0;
+                ut = value_3(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return ut;
+            default:
+                return undefined;
+        }
+    }
+    static setUnitTextAsString(pv, unitText, context) {
+        return pv.SetProperty(LDPropertyValue.unitText, unitText, unwrap(context));
+    }
+    static tryGetValueReferenceAsString(pv, context) {
+        const matchValue = pv.TryGetPropertyAsSingleton(LDPropertyValue.valueReference, unwrap(context));
+        let matchResult, vr;
+        if (matchValue != null) {
+            if (typeof value_3(matchValue) === "string") {
+                matchResult = 0;
+                vr = value_3(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return vr;
+            default:
+                return undefined;
+        }
+    }
+    static setValueReferenceAsString(pv, valueReference, context) {
+        return pv.SetProperty(LDPropertyValue.valueReference, valueReference, unwrap(context));
+    }
+    static tryGetMeasurementMethodAsString(pv, context) {
+        const matchValue = pv.TryGetPropertyAsSingleton(LDPropertyValue.measurementMethod, unwrap(context));
+        let matchResult, vr;
+        if (matchValue != null) {
+            if (typeof value_3(matchValue) === "string") {
+                matchResult = 0;
+                vr = value_3(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return vr;
+            default:
+                return undefined;
+        }
+    }
+    static setMeasurementMethodAsString(pv, measurementMethod, context) {
+        return pv.SetProperty(LDPropertyValue.measurementMethod, measurementMethod, unwrap(context));
+    }
+    static tryGetDescriptionAsString(pv, context) {
+        const matchValue = pv.TryGetPropertyAsSingleton(LDPropertyValue.description, unwrap(context));
+        let matchResult, vr;
+        if (matchValue != null) {
+            if (typeof value_3(matchValue) === "string") {
+                matchResult = 0;
+                vr = value_3(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return vr;
+            default:
+                return undefined;
+        }
+    }
+    static setDescriptionAsString(pv, description, context) {
+        return pv.SetProperty(LDPropertyValue.description, description, unwrap(context));
+    }
+    static tryGetAlternateNameAsString(pv, context) {
+        const matchValue = pv.TryGetPropertyAsSingleton(LDPropertyValue.alternateName, unwrap(context));
+        let matchResult, vr;
+        if (matchValue != null) {
+            if (typeof value_3(matchValue) === "string") {
+                matchResult = 0;
+                vr = value_3(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return vr;
+            default:
+                return undefined;
+        }
+    }
+    static setAlternateNameAsString(pv, alternateName, context) {
+        return pv.SetProperty(LDPropertyValue.alternateName, alternateName, unwrap(context));
+    }
+    static getDisambiguatingDescriptionsAsString(pv, context) {
+        return ResizeArray_map((o_1) => o_1, pv.GetPropertyValues(LDPropertyValue.disambiguatingDescription, (o, context_1) => (typeof o === "string"), unwrap(context)));
+    }
+    static setDisambiguatingDescriptionsAsString(lp, disambiguatingDescriptions, context) {
+        return lp.SetProperty(LDPropertyValue.disambiguatingDescription, disambiguatingDescriptions, unwrap(context));
+    }
+    static tryGetSubjectOf(pv, graph, context) {
+        const matchValue = pv.TryGetPropertyAsSingleNode(LDPropertyValue.subjectOf, unwrap(graph), unwrap(context));
+        return (matchValue != null) ? matchValue : undefined;
+    }
+    static setSubjectOf(pv, subjectOf, context) {
+        return pv.SetProperty(LDPropertyValue.subjectOf, subjectOf, unwrap(context));
+    }
+    static validate(pv, context) {
+        return pv.HasType(LDPropertyValue.schemaType, unwrap(context)) && pv.HasProperty(LDPropertyValue.name, unwrap(context));
+    }
+    static validateComponent(pv, context) {
+        return LDPropertyValue.validate(pv, unwrap(context)) && contains("Component", pv.AdditionalType, {
+            Equals: (x, y) => (x === y),
+            GetHashCode: stringHash,
+        });
+    }
+    static validateParameterValue(pv, context) {
+        return LDPropertyValue.validate(pv, unwrap(context)) && (contains("ParameterValue", pv.AdditionalType, {
+            Equals: (x, y) => (x === y),
+            GetHashCode: stringHash,
+        }) ? true : contains("ProcessParameterValue", pv.AdditionalType, {
+            Equals: (x_1, y_1) => (x_1 === y_1),
+            GetHashCode: stringHash,
+        }));
+    }
+    static validateCharacteristicValue(pv, context) {
+        return LDPropertyValue.validate(pv, unwrap(context)) && (contains("CharacteristicValue", pv.AdditionalType, {
+            Equals: (x, y) => (x === y),
+            GetHashCode: stringHash,
+        }) ? true : contains("MaterialAttributeValue", pv.AdditionalType, {
+            Equals: (x_1, y_1) => (x_1 === y_1),
+            GetHashCode: stringHash,
+        }));
+    }
+    static validateFactorValue(pv, context) {
+        return LDPropertyValue.validate(pv, unwrap(context)) && contains("FactorValue", pv.AdditionalType, {
+            Equals: (x, y) => (x === y),
+            GetHashCode: stringHash,
+        });
+    }
+    static validateFragmentDescriptor(pv, context) {
+        return LDPropertyValue.validate(pv, unwrap(context)) && (LDPropertyValue.getNameAsString(pv, unwrap(context)) === "FragmentDescriptor");
+    }
+    static validateDOI(pv, context) {
+        let value, id;
+        if (LDPropertyValue.validate(pv, unwrap(context))) {
+            const matchValue = LDPropertyValue.tryGetNameAsString(pv, unwrap(context));
+            const matchValue_1 = LDPropertyValue.tryGetValueAsString(pv, unwrap(context));
+            const matchValue_2 = LDPropertyValue.tryGetPropertyIDAsString(pv, unwrap(context));
+            let matchResult, id_1, name_1, value_1;
+            if (matchValue != null) {
+                if (matchValue_1 != null) {
+                    if (matchValue_2 != null) {
+                        if ((value = matchValue_1, (id = matchValue_2, (matchValue === LDPropertyValue.doiKey) && (id === LDPropertyValue.doiURL)))) {
+                            matchResult = 0;
+                            id_1 = matchValue_2;
+                            name_1 = matchValue;
+                            value_1 = matchValue_1;
+                        }
+                        else {
+                            matchResult = 1;
+                        }
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    static validatePubMedID(pv, context) {
+        let value, id;
+        if (LDPropertyValue.validate(pv, unwrap(context))) {
+            const matchValue = LDPropertyValue.tryGetNameAsString(pv, unwrap(context));
+            const matchValue_1 = LDPropertyValue.tryGetValueAsString(pv, unwrap(context));
+            const matchValue_2 = LDPropertyValue.tryGetPropertyIDAsString(pv, unwrap(context));
+            let matchResult, id_1, name_1, value_1;
+            if (matchValue != null) {
+                if (matchValue_1 != null) {
+                    if (matchValue_2 != null) {
+                        if ((value = matchValue_1, (id = matchValue_2, (matchValue === LDPropertyValue.pubmedIDKey) && (id === LDPropertyValue.pubmedIDURL)))) {
+                            matchResult = 0;
+                            id_1 = matchValue_2;
+                            name_1 = matchValue;
+                            value_1 = matchValue_1;
+                        }
+                        else {
+                            matchResult = 1;
+                        }
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    static genId(name, value, propertyID, prefix) {
+        let pid_1, value_2, pid, value_1;
+        const prefix_1 = defaultArg(prefix, "PV");
+        return clean((value == null) ? ((propertyID != null) ? ((pid_1 = propertyID, `#${prefix_1}_${name}`)) : (`#${prefix_1}_${name}`)) : ((propertyID == null) ? ((value_2 = value, `#${prefix_1}_${name}_${value_2}`)) : ((pid = propertyID, (value_1 = value, `#${prefix_1}_${name}_${value_1}`)))));
+    }
+    static genIdComponent(name, value, propertyID) {
+        return LDPropertyValue.genId(name, unwrap(value), unwrap(propertyID), "Component");
+    }
+    static genIdParameterValue(name, value, propertyID) {
+        return LDPropertyValue.genId(name, unwrap(value), unwrap(propertyID), "ParameterValue");
+    }
+    static genIdCharacteristicValue(name, value, propertyID) {
+        return LDPropertyValue.genId(name, unwrap(value), unwrap(propertyID), "CharacteristicValue");
+    }
+    static genIdFactorValue(name, value, propertyID) {
+        return LDPropertyValue.genId(name, unwrap(value), unwrap(propertyID), "FactorValue");
+    }
+    static genIdFragmentDescriptor(fileName) {
+        return `#Descriptor_${fileName}`;
+    }
+    static create(name, value, id, propertyID, unitCode, unitText, valueReference, context) {
+        const pv = new LDNode((id == null) ? LDPropertyValue.genId(name, unwrap(value), unwrap(propertyID)) : id, [LDPropertyValue.schemaType], undefined, unwrap(context));
+        LDPropertyValue.setNameAsString(pv, name, unwrap(context));
+        pv.SetOptionalProperty(LDPropertyValue.value, value, unwrap(context));
+        iterate((pid) => {
+            LDPropertyValue.setPropertyIDAsString(pv, pid, unwrap(context));
+        }, toArray(propertyID));
+        iterate((uc) => {
+            LDPropertyValue.setUnitCodeAsString(pv, uc, unwrap(context));
+        }, toArray(unitCode));
+        iterate((ut) => {
+            LDPropertyValue.setUnitTextAsString(pv, ut, unwrap(context));
+        }, toArray(unitText));
+        iterate((vr) => {
+            LDPropertyValue.setValueReferenceAsString(pv, vr, unwrap(context));
+        }, toArray(valueReference));
+        return pv;
+    }
+    static createComponent(name, value, id, propertyID, unitCode, unitText, valueReference, context) {
+        const id_1 = (id == null) ? LDPropertyValue.genIdComponent(name, unwrap(value), unwrap(propertyID)) : id;
+        const c = LDPropertyValue.create(name, unwrap(value), id_1, unwrap(propertyID), unwrap(unitCode), unwrap(unitText), unwrap(valueReference), unwrap(context));
+        c.AdditionalType = ["Component"];
+        return c;
+    }
+    static createParameterValue(name, value, id, propertyID, unitCode, unitText, valueReference, context) {
+        const id_1 = (id == null) ? LDPropertyValue.genIdParameterValue(name, unwrap(value), unwrap(propertyID)) : id;
+        const pv = LDPropertyValue.create(name, unwrap(value), id_1, unwrap(propertyID), unwrap(unitCode), unwrap(unitText), unwrap(valueReference), unwrap(context));
+        pv.AdditionalType = ["ParameterValue"];
+        return pv;
+    }
+    static createCharacteristicValue(name, value, id, propertyID, unitCode, unitText, valueReference, context) {
+        const id_1 = (id == null) ? LDPropertyValue.genIdCharacteristicValue(name, unwrap(value), unwrap(propertyID)) : id;
+        const cv = LDPropertyValue.create(name, unwrap(value), id_1, unwrap(propertyID), unwrap(unitCode), unwrap(unitText), unwrap(valueReference), unwrap(context));
+        cv.AdditionalType = ["CharacteristicValue"];
+        return cv;
+    }
+    static createFactorValue(name, value, id, propertyID, unitCode, unitText, valueReference, context) {
+        const id_1 = (id == null) ? LDPropertyValue.genIdFactorValue(name, unwrap(value), unwrap(propertyID)) : id;
+        const fv = LDPropertyValue.create(name, unwrap(value), id_1, unwrap(propertyID), unwrap(unitCode), unwrap(unitText), unwrap(valueReference), unwrap(context));
+        fv.AdditionalType = ["FactorValue"];
+        return fv;
+    }
+    static createFragmentDescriptor(fileName, value, id, unitCode, unitText, valueReference, measurementMethod, description, alternateName, disambiguatingDescriptions, subjectOf, context) {
+        const id_1 = (id == null) ? LDPropertyValue.genIdFragmentDescriptor(fileName) : id;
+        const fd = LDPropertyValue.create("FragmentDescriptor", unwrap(value), id_1, "https://github.com/nfdi4plants/ARC-specification/blob/dev/ISA-XLSX.md#datamap-table-sheets", unwrap(unitCode), unwrap(unitText), unwrap(valueReference), unwrap(context));
+        if (measurementMethod != null) {
+            LDPropertyValue.setMeasurementMethodAsString(fd, value_3(measurementMethod), unwrap(context));
+        }
+        if (description != null) {
+            LDPropertyValue.setDescriptionAsString(fd, value_3(description), unwrap(context));
+        }
+        if (alternateName != null) {
+            LDPropertyValue.setAlternateNameAsString(fd, value_3(alternateName), unwrap(context));
+        }
+        if (disambiguatingDescriptions != null) {
+            LDPropertyValue.setDisambiguatingDescriptionsAsString(fd, value_3(disambiguatingDescriptions), unwrap(context));
+        }
+        if (subjectOf != null) {
+            LDPropertyValue.setSubjectOf(fd, value_3(subjectOf), unwrap(context));
+        }
+        return fd;
+    }
+    static createDOI(value, context) {
+        return LDPropertyValue.create(LDPropertyValue.doiKey, value, value, LDPropertyValue.doiURL, undefined, undefined, undefined, unwrap(context));
+    }
+    static createPubMedID(value, context) {
+        return LDPropertyValue.create(LDPropertyValue.pubmedIDKey, value, value, LDPropertyValue.pubmedIDURL, undefined, undefined, undefined, unwrap(context));
+    }
+    static tryGetAsDOI(pv, context) {
+        return LDPropertyValue.validateDOI(pv, unwrap(context)) ? LDPropertyValue.getValueAsString(pv, unwrap(context)) : undefined;
+    }
+    static tryGetAsPubMedID(pv, context) {
+        return LDPropertyValue.validatePubMedID(pv, unwrap(context)) ? LDPropertyValue.getValueAsString(pv, unwrap(context)) : undefined;
+    }
+}
+
+export function LDPropertyValue_$reflection() {
+    return class_type("ARCtrl.ROCrate.LDPropertyValue", undefined, LDPropertyValue);
+}
+

package/ROCrate/Generic/Sample.js

@@ -0,0 +1,139 @@
+import { value, unwrap } from "../../fable_modules/fable-library-js.4.24.0/Option.js";
+import { LDPropertyValue } from "./PropertyValue.js";
+import { clean } from "../Helper.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 LDSample {
+    constructor() {
+    }
+    static get schemaType() {
+        return "https://bioschemas.org/Sample";
+    }
+    static get name() {
+        return "http://schema.org/name";
+    }
+    static get additionalProperty() {
+        return "http://schema.org/additionalProperty";
+    }
+    static tryGetNameAsString(s, context) {
+        const matchValue = s.TryGetPropertyAsSingleton(LDSample.name, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (typeof value(matchValue) === "string") {
+                matchResult = 0;
+                n = value(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                return undefined;
+        }
+    }
+    static getNameAsString(s, context) {
+        const matchValue = s.TryGetPropertyAsSingleton(LDSample.name, unwrap(context));
+        let matchResult, n;
+        if (matchValue != null) {
+            if (typeof value(matchValue) === "string") {
+                matchResult = 0;
+                n = value(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return n;
+            default:
+                throw new Error(`Could not access property \`name\` of object with @id \`${s.Id}\``);
+        }
+    }
+    static setNameAsString(s, n) {
+        s.SetProperty(LDSample.name, n);
+    }
+    static getAdditionalProperties(s, graph, context) {
+        return s.GetPropertyNodes(LDSample.additionalProperty, (ldObject, context_1) => LDPropertyValue.validate(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+    }
+    static setAdditionalProperties(s, additionalProperties, context) {
+        return s.SetProperty(LDSample.additionalProperty, additionalProperties, unwrap(context));
+    }
+    static getCharacteristics(s, graph, context) {
+        return s.GetPropertyNodes(LDSample.additionalProperty, (ldObject, context_1) => LDPropertyValue.validateCharacteristicValue(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+    }
+    static getFactors(s, graph, context) {
+        return s.GetPropertyNodes(LDSample.additionalProperty, (ldObject, context_1) => LDPropertyValue.validateFactorValue(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+    }
+    static validate(s, context) {
+        return s.HasType(LDSample.schemaType, unwrap(context)) && s.HasProperty(LDSample.name, unwrap(context));
+    }
+    static genIDSample(name) {
+        return clean(`#Sample_${name}`);
+    }
+    static genIDSource(name) {
+        return clean(`#Source_${name}`);
+    }
+    static genIDMaterial(name) {
+        return clean(`#Material_${name}`);
+    }
+    static validateSample(s, context) {
+        return LDSample.validate(s, unwrap(context)) && contains("Sample", s.AdditionalType, {
+            Equals: (x, y) => (x === y),
+            GetHashCode: stringHash,
+        });
+    }
+    static validateSource(s, context) {
+        return LDSample.validate(s, unwrap(context)) && contains("Source", s.AdditionalType, {
+            Equals: (x, y) => (x === y),
+            GetHashCode: stringHash,
+        });
+    }
+    static validateMaterial(s, context) {
+        return LDSample.validate(s, unwrap(context)) && contains("Material", s.AdditionalType, {
+            Equals: (x, y) => (x === y),
+            GetHashCode: stringHash,
+        });
+    }
+    static create(id, name, additionalProperties, context) {
+        const s = new LDNode(id, [LDSample.schemaType], undefined, unwrap(context));
+        s.SetProperty(LDSample.name, name, unwrap(context));
+        s.SetOptionalProperty(LDSample.additionalProperty, additionalProperties, unwrap(context));
+        return s;
+    }
+    static createSample(name, id, additionalProperties, context) {
+        const id_2 = (id == null) ? LDSample.genIDSample(name) : id;
+        const s = LDSample.create(id_2, name, unwrap(additionalProperties), unwrap(context));
+        s.AdditionalType = ["Sample"];
+        return s;
+    }
+    static createSource(name, id, additionalProperties, context) {
+        const id_2 = (id == null) ? LDSample.genIDSource(name) : id;
+        const s = LDSample.create(id_2, name, unwrap(additionalProperties), unwrap(context));
+        s.AdditionalType = ["Source"];
+        return s;
+    }
+    static createMaterial(name, id, additionalProperties, context) {
+        const id_2 = (id == null) ? LDSample.genIDMaterial(name) : id;
+        const s = LDSample.create(id_2, name, unwrap(additionalProperties), unwrap(context));
+        s.AdditionalType = ["Material"];
+        return s;
+    }
+}
+
+export function LDSample_$reflection() {
+    return class_type("ARCtrl.ROCrate.LDSample", undefined, LDSample);
+}
+