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

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

@@ -0,0 +1,512 @@
+import { unwrap, value, defaultArg, toArray } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { LDNode } from '../LDObject.js';
+import { ResizeArray_map } from '../../Core/Helper/Collections.js';
+import { contains } from '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { stringHash } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+import { clean } from '../Helper.js';
+import { iterate } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+
+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(matchValue) === "string") {
+        matchResult = 0;
+        n = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return n;
+      default:
+        return void 0;
+    }
+  }
+  static getNameAsString(pv, context) {
+    const matchValue = pv.TryGetPropertyAsSingleton(LDPropertyValue.name, unwrap(context));
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        const n = value(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(matchValue) === "string") {
+        matchResult = 0;
+        v = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return v;
+      default:
+        return void 0;
+    }
+  }
+  static getValueAsString(pv, context) {
+    const matchValue = pv.TryGetPropertyAsSingleton(LDPropertyValue.value, unwrap(context));
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        const v = value(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(matchValue) === "string") {
+        matchResult = 0;
+        pid = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return pid;
+      default:
+        return void 0;
+    }
+  }
+  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(matchValue) === "string") {
+        matchResult = 0;
+        uc = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return uc;
+      default:
+        return void 0;
+    }
+  }
+  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(matchValue) === "string") {
+        matchResult = 0;
+        ut = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return ut;
+      default:
+        return void 0;
+    }
+  }
+  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(matchValue) === "string") {
+        matchResult = 0;
+        vr = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return vr;
+      default:
+        return void 0;
+    }
+  }
+  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(matchValue) === "string") {
+        matchResult = 0;
+        vr = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return vr;
+      default:
+        return void 0;
+    }
+  }
+  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(matchValue) === "string") {
+        matchResult = 0;
+        vr = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return vr;
+      default:
+        return void 0;
+    }
+  }
+  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(matchValue) === "string") {
+        matchResult = 0;
+        vr = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return vr;
+      default:
+        return void 0;
+    }
+  }
+  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(matchValue) : void 0;
+  }
+  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 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;
+      if (matchValue != null) {
+        if (matchValue_1 != null) {
+          if (matchValue_2 != null) {
+            if (value(matchValue_1), id = value(matchValue_2), value(matchValue) === LDPropertyValue.doiKey && id === LDPropertyValue.doiURL) {
+              matchResult = 0;
+              value(matchValue_2);
+              value(matchValue);
+              value(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 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;
+      if (matchValue != null) {
+        if (matchValue_1 != null) {
+          if (matchValue_2 != null) {
+            if (value(matchValue_1), id = value(matchValue_2), value(matchValue) === LDPropertyValue.pubmedIDKey && id === LDPropertyValue.pubmedIDURL) {
+              matchResult = 0;
+              value(matchValue_2);
+              value(matchValue);
+              value(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$1, propertyID, prefix) {
+    let value_2, value_1;
+    const prefix_1 = defaultArg(prefix, "PV");
+    return clean(value$1 == null ? propertyID != null ? (value(propertyID), `#${prefix_1}_${name}`) : `#${prefix_1}_${name}` : propertyID == null ? (value_2 = value(value$1), `#${prefix_1}_${name}_${value_2}`) : (value(propertyID), value_1 = value(value$1), `#${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$1, id, propertyID, unitCode, unitText, valueReference, context) {
+    const pv = new LDNode(id == null ? LDPropertyValue.genId(name, unwrap(value$1), unwrap(propertyID)) : value(id), [LDPropertyValue.schemaType], void 0, unwrap(context));
+    LDPropertyValue.setNameAsString(pv, name, unwrap(context));
+    pv.SetOptionalProperty(LDPropertyValue.value, value$1, 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$1, id, propertyID, unitCode, unitText, valueReference, context) {
+    const id_1 = id == null ? LDPropertyValue.genIdComponent(name, unwrap(value$1), unwrap(propertyID)) : value(id);
+    const c = LDPropertyValue.create(name, unwrap(value$1), id_1, unwrap(propertyID), unwrap(unitCode), unwrap(unitText), unwrap(valueReference), unwrap(context));
+    c.AdditionalType = ["Component"];
+    return c;
+  }
+  static createParameterValue(name, value$1, id, propertyID, unitCode, unitText, valueReference, context) {
+    const id_1 = id == null ? LDPropertyValue.genIdParameterValue(name, unwrap(value$1), unwrap(propertyID)) : value(id);
+    const pv = LDPropertyValue.create(name, unwrap(value$1), id_1, unwrap(propertyID), unwrap(unitCode), unwrap(unitText), unwrap(valueReference), unwrap(context));
+    pv.AdditionalType = ["ParameterValue"];
+    return pv;
+  }
+  static createCharacteristicValue(name, value$1, id, propertyID, unitCode, unitText, valueReference, context) {
+    const id_1 = id == null ? LDPropertyValue.genIdCharacteristicValue(name, unwrap(value$1), unwrap(propertyID)) : value(id);
+    const cv = LDPropertyValue.create(name, unwrap(value$1), id_1, unwrap(propertyID), unwrap(unitCode), unwrap(unitText), unwrap(valueReference), unwrap(context));
+    cv.AdditionalType = ["CharacteristicValue"];
+    return cv;
+  }
+  static createFactorValue(name, value$1, id, propertyID, unitCode, unitText, valueReference, context) {
+    const id_1 = id == null ? LDPropertyValue.genIdFactorValue(name, unwrap(value$1), unwrap(propertyID)) : value(id);
+    const fv = LDPropertyValue.create(name, unwrap(value$1), id_1, unwrap(propertyID), unwrap(unitCode), unwrap(unitText), unwrap(valueReference), unwrap(context));
+    fv.AdditionalType = ["FactorValue"];
+    return fv;
+  }
+  static createFragmentDescriptor(fileName, value$1, id, unitCode, unitText, valueReference, measurementMethod, description, alternateName, disambiguatingDescriptions, subjectOf, context) {
+    const id_1 = id == null ? LDPropertyValue.genIdFragmentDescriptor(fileName) : value(id);
+    const fd = LDPropertyValue.create("FragmentDescriptor", unwrap(value$1), 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(measurementMethod), unwrap(context));
+    }
+    if (description != null) {
+      LDPropertyValue.setDescriptionAsString(fd, value(description), unwrap(context));
+    }
+    if (alternateName != null) {
+      LDPropertyValue.setAlternateNameAsString(fd, value(alternateName), unwrap(context));
+    }
+    if (disambiguatingDescriptions != null) {
+      LDPropertyValue.setDisambiguatingDescriptionsAsString(fd, value(disambiguatingDescriptions), unwrap(context));
+    }
+    if (subjectOf != null) {
+      LDPropertyValue.setSubjectOf(fd, value(subjectOf), unwrap(context));
+    }
+    return fd;
+  }
+  static createDOI(value, context) {
+    return LDPropertyValue.create(LDPropertyValue.doiKey, value, value, LDPropertyValue.doiURL, void 0, void 0, void 0, unwrap(context));
+  }
+  static createPubMedID(value, context) {
+    return LDPropertyValue.create(LDPropertyValue.pubmedIDKey, value, value, LDPropertyValue.pubmedIDURL, void 0, void 0, void 0, unwrap(context));
+  }
+  static tryGetAsDOI(pv, context) {
+    return LDPropertyValue.validateDOI(pv, unwrap(context)) ? LDPropertyValue.getValueAsString(pv, unwrap(context)) : void 0;
+  }
+  static tryGetAsPubMedID(pv, context) {
+    return LDPropertyValue.validatePubMedID(pv, unwrap(context)) ? LDPropertyValue.getValueAsString(pv, unwrap(context)) : void 0;
+  }
+}
+
+export { LDPropertyValue };

package/dist/ts/ts/ROCrate/Generic/Sample.d.ts

@@ -0,0 +1,30 @@
+import { Option } from '@fable-org/fable-library-js/Option.js';
+import { LDGraph, LDNode } from '../LDObject.js';
+import { LDContext } from '../LDContext.js';
+import { TypeInfo } from '@fable-org/fable-library-js/Reflection.js';
+export declare class LDSample {
+    constructor();
+    static get schemaType(): string;
+    static get name(): string;
+    static get additionalProperty(): string;
+    static tryGetNameAsString(s: LDNode, context?: LDContext): Option<string>;
+    static getNameAsString(s: LDNode, context?: LDContext): string;
+    static setNameAsString(s: LDNode, n: string): void;
+    static getAdditionalProperties(s: LDNode, graph?: LDGraph, context?: LDContext): LDNode[];
+    static setAdditionalProperties<$a>(s: LDNode, additionalProperties: LDNode[], context?: LDContext): $a;
+    static getCharacteristics(s: LDNode, graph?: LDGraph, context?: LDContext): LDNode[];
+    static getFactors(s: LDNode, graph?: LDGraph, context?: LDContext): LDNode[];
+    static validate(s: LDNode, context?: LDContext): boolean;
+    static genIDSample(name: string): string;
+    static genIDSource(name: string): string;
+    static genIDMaterial(name: string): string;
+    static validateSample(s: LDNode, context?: LDContext): boolean;
+    static validateSource(s: LDNode, context?: LDContext): boolean;
+    static validateMaterial(s: LDNode, context?: LDContext): boolean;
+    static create(id: string, name: string, additionalProperties?: LDNode[], context?: LDContext): LDNode;
+    static createSample(name: string, id?: string, additionalProperties?: LDNode[], context?: LDContext): LDNode;
+    static createSource(name: string, id?: string, additionalProperties?: LDNode[], context?: LDContext): LDNode;
+    static createMaterial(name: string, id?: string, additionalProperties?: LDNode[], context?: LDContext): LDNode;
+}
+export declare function LDSample_$reflection(): TypeInfo;
+//# sourceMappingURL=Sample.d.ts.map

package/dist/ts/ts/ROCrate/Generic/Sample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sample.d.ts","sourceRoot":"","sources":["../../../../../src/ARCtrl/ts/ROCrate/Generic/Sample.ts"],"names":[],"mappings":"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"}

package/dist/ts/ts/ROCrate/Generic/Sample.js

@@ -0,0 +1,131 @@
+import { unwrap, value } from '../../../node_modules/@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 '../../../node_modules/@fable-org/fable-library-js/Array.js';
+import { stringHash } from '../../../node_modules/@fable-org/fable-library-js/Util.js';
+
+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 void 0;
+    }
+  }
+  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], void 0, 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 { LDSample };