@nfdi4plants/arctrl 3.0.0-beta.2 → 3.0.0-beta.4

package/dist/ts/esm/ts/ROCrate/Generic/PropertyValue.js

@@ -1,545 +0,0 @@
-import { toArray, defaultArg, value as value_3, unwrap } from "@fable-org/fable-library-js/Option.js";
-import { LDNode } from "../LDObject.js";
-import { ResizeArray_map } from "../../Core/Helper/Collections.js";
-import { contains } from "@fable-org/fable-library-js/Array.js";
-import { stringHash } from "@fable-org/fable-library-js/Util.js";
-import { clean } from "../Helper.js";
-import { iterate } from "@fable-org/fable-library-js/Seq.js";
-import { class_type } from "@fable-org/fable-library-js/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) ? value_3(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 = value_3(matchValue_1), (id = value_3(matchValue_2), (value_3(matchValue) === LDPropertyValue.doiKey) && (id === LDPropertyValue.doiURL)))) {
-                            matchResult = 0;
-                            id_1 = value_3(matchValue_2);
-                            name_1 = value_3(matchValue);
-                            value_1 = value_3(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 = value_3(matchValue_1), (id = value_3(matchValue_2), (value_3(matchValue) === LDPropertyValue.pubmedIDKey) && (id === LDPropertyValue.pubmedIDURL)))) {
-                            matchResult = 0;
-                            id_1 = value_3(matchValue_2);
-                            name_1 = value_3(matchValue);
-                            value_1 = value_3(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 = value_3(propertyID), `#${prefix_1}_${name}`)) : (`#${prefix_1}_${name}`)) : ((propertyID == null) ? ((value_2 = value_3(value), `#${prefix_1}_${name}_${value_2}`)) : ((pid = value_3(propertyID), (value_1 = value_3(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)) : value_3(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)) : value_3(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)) : value_3(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)) : value_3(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)) : value_3(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) : value_3(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/dist/ts/esm/ts/ROCrate/Generic/Sample.js

@@ -1,136 +0,0 @@
-import { value, unwrap } from "@fable-org/fable-library-js/Option.js";
-import { LDNode } from "../LDObject.js";
-import { LDPropertyValue } from "./PropertyValue.js";
-import { clean } from "../Helper.js";
-import { contains } from "@fable-org/fable-library-js/Array.js";
-import { stringHash } from "@fable-org/fable-library-js/Util.js";
-import { class_type } from "@fable-org/fable-library-js/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) : value(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) : value(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) : value(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);
-}