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

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

@@ -0,0 +1,143 @@
+import { unwrap, value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { LDNode } from '../LDObject.js';
+import { toList, delay, append, singleton, empty } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { isEmpty, reduce } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { clean } from '../Helper.js';
+import { createMissingIdentifier } from '../../Core/Helper/Identifier.js';
+import { toText, printf } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+
+class LDPostalAddress {
+  constructor() {
+  }
+  static get schemaType() {
+    return "http://schema.org/PostalAddress";
+  }
+  static get addressCountry() {
+    return "http://schema.org/addressCountry";
+  }
+  static get postalCode() {
+    return "http://schema.org/postalCode";
+  }
+  static get streetAddress() {
+    return "http://schema.org/streetAddress";
+  }
+  static tryGetAddressCountryAsString(s, context) {
+    const matchValue = s.TryGetPropertyAsSingleton(LDPostalAddress.addressCountry, 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 getAddressCountryAsString(s, context) {
+    const matchValue = s.TryGetPropertyAsSingleton(LDPostalAddress.addressCountry, unwrap(context));
+    if (matchValue == null) {
+      throw new Error(`Could not access property \`addressCountry\` of object with @id \`${s.Id}\``);
+    } else if (typeof value(matchValue) === "string") {
+      const n = value(matchValue);
+      return n;
+    } else {
+      throw new Error(`Value of property \`addressCountry\` of object with @id \`${s.Id}\` should have been a string`);
+    }
+  }
+  static setAddressCountryAsString(s, n) {
+    s.SetProperty(LDPostalAddress.addressCountry, n);
+  }
+  static tryGetPostalCodeAsString(s, context) {
+    const matchValue = s.TryGetPropertyAsSingleton(LDPostalAddress.postalCode, 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 getPostalCodeAsString(s, context) {
+    const matchValue = s.TryGetPropertyAsSingleton(LDPostalAddress.postalCode, unwrap(context));
+    if (matchValue == null) {
+      throw new Error(`Could not access property \`postalCode\` of object with @id \`${s.Id}\``);
+    } else if (typeof value(matchValue) === "string") {
+      const n = value(matchValue);
+      return n;
+    } else {
+      throw new Error(`Value of property \`postalCode\` of object with @id \`${s.Id}\` should have been a string`);
+    }
+  }
+  static setPostalCodeAsString(s, n) {
+    s.SetProperty(LDPostalAddress.postalCode, n);
+  }
+  static tryGetStreetAddressAsString(s, context) {
+    const matchValue = s.TryGetPropertyAsSingleton(LDPostalAddress.streetAddress, 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 getStreetAddressAsString(s, context) {
+    const matchValue = s.TryGetPropertyAsSingleton(LDPostalAddress.streetAddress, unwrap(context));
+    if (matchValue == null) {
+      throw new Error(`Could not access property \`streetAddress\` of object with @id \`${s.Id}\``);
+    } else if (typeof value(matchValue) === "string") {
+      const n = value(matchValue);
+      return n;
+    } else {
+      throw new Error(`Value of property \`streetAddress\` of object with @id \`${s.Id}\` should have been a string`);
+    }
+  }
+  static setStreetAddressAsString(s, n) {
+    s.SetProperty(LDPostalAddress.streetAddress, n);
+  }
+  static genID(addressCountry, postalCode, streetAddress) {
+    let arg;
+    const items = toList(delay(() => append(addressCountry != null ? singleton("addressCountry") : empty(), delay(() => append(postalCode != null ? singleton("postalCode") : empty(), delay(() => streetAddress != null ? singleton("streetAddress") : empty()))))));
+    return clean(isEmpty(items) ? createMissingIdentifier() : (arg = reduce((acc, x) => `${acc}_${x}`, items), toText(printf("#%s"))(arg)));
+  }
+  static validate(o, context) {
+    return o.HasType(LDPostalAddress.schemaType, unwrap(context));
+  }
+  static create(id, addressCountry, postalCode, streetAddress, context) {
+    const s = new LDNode(id == null ? LDPostalAddress.genID(unwrap(addressCountry), unwrap(postalCode), unwrap(streetAddress)) : value(id), [LDPostalAddress.schemaType], void 0, unwrap(context));
+    s.SetOptionalProperty(LDPostalAddress.addressCountry, addressCountry);
+    s.SetOptionalProperty(LDPostalAddress.postalCode, postalCode);
+    s.SetOptionalProperty(LDPostalAddress.streetAddress, streetAddress);
+    return s;
+  }
+}
+
+export { LDPostalAddress };

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