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

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

@@ -0,0 +1,257 @@
+import { unwrap, value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { LDNode } from '../LDObject.js';
+import { LDDefinedTerm } from './DefinedTerm.js';
+import { LDComment } from './Comment.js';
+import { append, toList, delay, singleton as singleton$1, empty } from '../../../node_modules/@fable-org/fable-library-js/Seq.js';
+import { clean } from '../Helper.js';
+import { join } from '../../../node_modules/@fable-org/fable-library-js/String.js';
+import { append as append$1, singleton, isEmpty } from '../../../node_modules/@fable-org/fable-library-js/List.js';
+import { createMissingIdentifier } from '../../Core/Helper/Identifier.js';
+
+class LDLabProtocol {
+  constructor() {
+  }
+  static get schemaType() {
+    return "https://bioschemas.org/LabProtocol";
+  }
+  static get description() {
+    return "http://schema.org/description";
+  }
+  static get intendedUse() {
+    return "https://bioschemas.org/intendedUse";
+  }
+  static get name() {
+    return "http://schema.org/name";
+  }
+  static get comment() {
+    return "http://schema.org/comment";
+  }
+  static get computationalTool() {
+    return "https://bioschemas.org/computationalTool";
+  }
+  static get labEquipment() {
+    return "https://bioschemas.org/labEquipment";
+  }
+  static get reagent() {
+    return "https://bioschemas.org/reagent";
+  }
+  static get url() {
+    return "http://schema.org/url";
+  }
+  static get version() {
+    return "http://schema.org/version";
+  }
+  static tryGetDescriptionAsString(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDLabProtocol.description, unwrap(context));
+    let matchResult, d;
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        matchResult = 0;
+        d = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return d;
+      default:
+        return void 0;
+    }
+  }
+  static setDescriptionAsString(lp, description, context) {
+    return lp.SetProperty(LDLabProtocol.description, description, unwrap(context));
+  }
+  static tryGetIntendedUseAsString(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDLabProtocol.intendedUse, unwrap(context));
+    let matchResult, iu;
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        matchResult = 0;
+        iu = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return iu;
+      default:
+        return void 0;
+    }
+  }
+  static setIntendedUseAsString(lp, intendedUse, context) {
+    return lp.SetProperty(LDLabProtocol.intendedUse, intendedUse, unwrap(context));
+  }
+  static tryGetIntendedUseAsDefinedTerm(lp, graph, context) {
+    let ldObject;
+    const matchValue = lp.TryGetPropertyAsSingleNode(LDLabProtocol.intendedUse, unwrap(graph), unwrap(context));
+    let matchResult, iu_1;
+    if (matchValue != null) {
+      if (ldObject = value(matchValue), LDDefinedTerm.validate(ldObject, unwrap(context))) {
+        matchResult = 0;
+        iu_1 = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return iu_1;
+      default:
+        return void 0;
+    }
+  }
+  static setIntendedUseAsDefinedTerm(lp, intendedUse, context) {
+    return lp.SetProperty(LDLabProtocol.intendedUse, intendedUse, unwrap(context));
+  }
+  static tryGetNameAsString(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDLabProtocol.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(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDLabProtocol.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 \`${lp.Id}\``);
+    }
+  }
+  static setNameAsString(lp, name, context) {
+    return lp.SetProperty(LDLabProtocol.name, name, unwrap(context));
+  }
+  static getComments(lp, graph, context) {
+    return lp.GetPropertyNodes(LDLabProtocol.comment, (ldObject, context_1) => LDComment.validate(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+  }
+  static setComments(lp, comments, context) {
+    return lp.SetProperty(LDLabProtocol.comment, comments, unwrap(context));
+  }
+  static getComputationalTools(lp, graph, context) {
+    return lp.GetPropertyNodes(LDLabProtocol.computationalTool, void 0, unwrap(graph), unwrap(context));
+  }
+  static setComputationalTools(lp, computationalTools, context) {
+    return lp.SetProperty(LDLabProtocol.computationalTool, computationalTools, unwrap(context));
+  }
+  static getLabEquipments(lp, graph, context) {
+    return lp.GetPropertyNodes(LDLabProtocol.labEquipment, void 0, unwrap(graph), unwrap(context));
+  }
+  static setLabEquipments(lp, labEquipments, context) {
+    return lp.SetProperty(LDLabProtocol.labEquipment, labEquipments, unwrap(context));
+  }
+  static getReagents(lp, graph, context) {
+    return lp.GetPropertyNodes(LDLabProtocol.reagent, void 0, unwrap(graph), unwrap(context));
+  }
+  static setReagents(lp, reagents, context) {
+    return lp.SetProperty(LDLabProtocol.reagent, reagents, unwrap(context));
+  }
+  static getComponents(lp, graph, context) {
+    let collection;
+    let source_3;
+    const source_1 = LDLabProtocol.getLabEquipments(lp, unwrap(graph), unwrap(context));
+    source_3 = append(LDLabProtocol.getReagents(lp, unwrap(graph), unwrap(context)), source_1);
+    collection = append(LDLabProtocol.getComputationalTools(lp, unwrap(graph), unwrap(context)), source_3);
+    return Array.from(collection);
+  }
+  static tryGetUrl(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDLabProtocol.url, unwrap(context));
+    let matchResult, u;
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        matchResult = 0;
+        u = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return u;
+      default:
+        return void 0;
+    }
+  }
+  static setUrl(lp, url, context) {
+    return lp.SetProperty(LDLabProtocol.url, url, unwrap(context));
+  }
+  static tryGetVersionAsString(lp, context) {
+    const matchValue = lp.TryGetPropertyAsSingleton(LDLabProtocol.version, 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 setVersionAsString(lp, version, context) {
+    return lp.SetProperty(LDLabProtocol.version, version, unwrap(context));
+  }
+  static validate(lp, context) {
+    return lp.HasType(LDLabProtocol.schemaType, unwrap(context));
+  }
+  static genId(name, processName, assayName, studyName) {
+    let vals;
+    return clean(join("_", append$1(singleton("#Protocol"), (vals = toList(delay(() => append(name != null ? singleton$1(value(name)) : empty(), delay(() => append(processName != null ? singleton$1(value(processName)) : empty(), delay(() => append(assayName != null ? singleton$1(value(assayName)) : empty(), delay(() => studyName != null ? singleton$1(value(studyName)) : empty())))))))), isEmpty(vals) ? singleton(createMissingIdentifier()) : vals))));
+  }
+  static create(id, name, description, intendedUse, comments, computationalTools, labEquipments, reagents, url, version, context) {
+    const lp = new LDNode(id, [LDLabProtocol.schemaType], void 0, unwrap(context));
+    lp.SetOptionalProperty(LDLabProtocol.name, name, unwrap(context));
+    lp.SetOptionalProperty(LDLabProtocol.description, description, unwrap(context));
+    lp.SetOptionalProperty(LDLabProtocol.intendedUse, intendedUse, unwrap(context));
+    lp.SetOptionalProperty(LDLabProtocol.comment, comments, unwrap(context));
+    lp.SetOptionalProperty(LDLabProtocol.computationalTool, computationalTools, unwrap(context));
+    lp.SetOptionalProperty(LDLabProtocol.labEquipment, labEquipments, unwrap(context));
+    lp.SetOptionalProperty(LDLabProtocol.reagent, reagents, unwrap(context));
+    lp.SetOptionalProperty(LDLabProtocol.url, url, unwrap(context));
+    lp.SetOptionalProperty(LDLabProtocol.version, version, unwrap(context));
+    return lp;
+  }
+}
+
+export { LDLabProtocol };

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

@@ -0,0 +1,63 @@
+import { unwrap, value } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { LDNode } from '../LDObject.js';
+import { clean } from '../Helper.js';
+
+class LDOrganization {
+  constructor() {
+  }
+  static get schemaType() {
+    return "http://schema.org/Organization";
+  }
+  static get name() {
+    return "http://schema.org/name";
+  }
+  static tryGetNameAsString(o, context) {
+    const matchValue = o.TryGetPropertyAsSingleton(LDOrganization.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(o, context) {
+    const matchValue = o.TryGetPropertyAsSingleton(LDOrganization.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 \`${o.Id}\` was not a string`);
+      }
+    } else {
+      throw new Error(`Could not access property \`name\` of object with @id \`${o.Id}\``);
+    }
+  }
+  static setNameAsString(o, n, context) {
+    return o.SetProperty(LDOrganization.name, n, unwrap(context));
+  }
+  static genID(name) {
+    return clean(`#Organization_${name}`);
+  }
+  static validate(o, context) {
+    return o.HasType(LDOrganization.schemaType, unwrap(context)) && o.HasProperty(LDOrganization.name, unwrap(context));
+  }
+  static create(name, id, context) {
+    const o = new LDNode(id == null ? LDOrganization.genID(name) : value(id), [LDOrganization.schemaType], void 0, unwrap(context));
+    o.SetProperty(LDOrganization.name, name, unwrap(context));
+    return o;
+  }
+}
+
+export { LDOrganization };

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

@@ -0,0 +1,377 @@
+import { unwrap, value, some, map, bind } from '../../../node_modules/@fable-org/fable-library-js/Option.js';
+import { LDNode, LDRef } from '../LDObject.js';
+import { LDOrganization } from './Organization.js';
+import { LDDefinedTerm } from './DefinedTerm.js';
+import { LDPostalAddress } from './PostalAddress.js';
+import { ResizeArray_map } from '../../Core/Helper/Collections.js';
+import { clean } from '../Helper.js';
+import { tryGetOrcidURL } from '../../Core/Helper/ORCID.js';
+
+class LDPerson {
+  constructor() {
+  }
+  static get schemaType() {
+    return "http://schema.org/Person";
+  }
+  static get givenName() {
+    return "http://schema.org/givenName";
+  }
+  static get affiliation() {
+    return "http://schema.org/affiliation";
+  }
+  static get email() {
+    return "http://schema.org/email";
+  }
+  static get familyName() {
+    return "http://schema.org/familyName";
+  }
+  static get identifier() {
+    return "http://schema.org/identifier";
+  }
+  static get jobTitle() {
+    return "http://schema.org/jobTitle";
+  }
+  static get additionalName() {
+    return "http://schema.org/additionalName";
+  }
+  static get address() {
+    return "http://schema.org/address";
+  }
+  static get disambiguatingDescription() {
+    return "http://schema.org/disambiguatingDescription";
+  }
+  static get faxNumber() {
+    return "http://schema.org/faxNumber";
+  }
+  static get telephone() {
+    return "http://schema.org/telephone";
+  }
+  static tryGetGivenNameAsString(p, context) {
+    const matchValue = p.TryGetPropertyAsSingleton(LDPerson.givenName, 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 getGivenNameAsString(p, context) {
+    const matchValue = p.TryGetPropertyAsSingleton(LDPerson.givenName, unwrap(context));
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        const n = value(matchValue);
+        return n;
+      } else {
+        throw new Error(`Property of \`givenName\` of object with @id \`${p.Id}\` was not a string`);
+      }
+    } else {
+      throw new Error(`Could not access property \`givenName\` of object with @id \`${p.Id}\``);
+    }
+  }
+  static setGivenNameAsString(p, n, context) {
+    return p.SetProperty(LDPerson.givenName, n, unwrap(context));
+  }
+  static tryGetAffiliation(p, graph, context) {
+    let n;
+    const matchValue = p.TryGetPropertyAsSingleNode(LDPerson.affiliation, unwrap(graph), unwrap(context));
+    let matchResult, n_1;
+    if (matchValue != null) {
+      if (n = value(matchValue), LDOrganization.validate(n, unwrap(context))) {
+        matchResult = 0;
+        n_1 = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return n_1;
+      default:
+        return void 0;
+    }
+  }
+  static setAffiliation(p, a, context) {
+    return p.SetProperty(LDPerson.affiliation, a, unwrap(context));
+  }
+  static tryGetEmailAsString(p, context) {
+    const matchValue = p.TryGetPropertyAsSingleton(LDPerson.email, unwrap(context));
+    let matchResult, e;
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        matchResult = 0;
+        e = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return e;
+      default:
+        return void 0;
+    }
+  }
+  static setEmailAsString(p, e, context) {
+    return p.SetProperty(LDPerson.email, e, unwrap(context));
+  }
+  static tryGetFamilyNameAsString(p, context) {
+    const matchValue = p.TryGetPropertyAsSingleton(LDPerson.familyName, 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 getFamilyNameAsString(p, context) {
+    const matchValue = p.TryGetPropertyAsSingleton(LDPerson.familyName, unwrap(context));
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        const n = value(matchValue);
+        return n;
+      } else {
+        throw new Error(`Property of \`familyName\` of object with @id \`${p.Id}\` was not a string`);
+      }
+    } else {
+      throw new Error(`Could not access property \`familyName\` of object with @id \`${p.Id}\``);
+    }
+  }
+  static setFamilyNameAsString(p, n, context) {
+    return p.SetProperty(LDPerson.familyName, n, unwrap(context));
+  }
+  static tryGetIdentifier(p, context) {
+    const matchValue = p.TryGetPropertyAsSingleton(LDPerson.identifier, unwrap(context));
+    let matchResult, i;
+    if (matchValue != null) {
+      if (value(matchValue) instanceof LDNode) {
+        matchResult = 0;
+        i = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return i;
+      default:
+        return void 0;
+    }
+  }
+  static setIdentifier(p, i, context) {
+    return p.SetProperty(LDPerson.identifier, i, unwrap(context));
+  }
+  static getJobTitlesAsDefinedTerm(p, graph, context) {
+    return p.GetPropertyNodes(LDPerson.jobTitle, (ldObject, context_1) => LDDefinedTerm.validate(ldObject, unwrap(context_1)), unwrap(graph), unwrap(context));
+  }
+  static setJobTitleAsDefinedTerm(p, j, context) {
+    return p.SetProperty(LDPerson.jobTitle, j, unwrap(context));
+  }
+  static tryGetAdditionalNameAsString(p, context) {
+    const matchValue = p.TryGetPropertyAsSingleton(LDPerson.additionalName, 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 setAdditionalNameAsString(p, n, context) {
+    return p.SetProperty(LDPerson.additionalName, n, unwrap(context));
+  }
+  static tryGetAddress(p, graph, context) {
+    const matchValue = p.TryGetPropertyAsSingleton(LDPerson.address, unwrap(context));
+    let matchResult, r_1, a, s;
+    if (matchValue != null) {
+      if (value(matchValue) instanceof LDRef) {
+        if (value(matchValue), graph != null) {
+          matchResult = 0;
+          r_1 = value(matchValue);
+        } else {
+          matchResult = 3;
+        }
+      } else if (value(matchValue) instanceof LDNode) {
+        matchResult = 1;
+        a = value(matchValue);
+      } else if (typeof value(matchValue) === "string") {
+        matchResult = 2;
+        s = value(matchValue);
+      } else {
+        matchResult = 3;
+      }
+    } else {
+      matchResult = 3;
+    }
+    switch (matchResult) {
+      case 0:
+        return map((value) => value, value(graph).TryGetNode(r_1.Id));
+      case 1:
+        return some(a);
+      case 2:
+        return some(s);
+      default:
+        return void 0;
+    }
+  }
+  static tryGetAddressAsPostalAddress(p, graph, context) {
+    let n;
+    const matchValue = p.TryGetPropertyAsSingleNode(LDPerson.address, unwrap(graph), unwrap(context));
+    let matchResult, n_1;
+    if (matchValue != null) {
+      if (n = value(matchValue), LDPostalAddress.validate(n, unwrap(context))) {
+        matchResult = 0;
+        n_1 = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return n_1;
+      default:
+        return void 0;
+    }
+  }
+  static tryGetAddressAsString(p, context) {
+    const matchValue = p.TryGetPropertyAsSingleton(LDPerson.address, unwrap(context));
+    let matchResult, a;
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        matchResult = 0;
+        a = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return a;
+      default:
+        return void 0;
+    }
+  }
+  static setAddressAsPostalAddress(p, a, context) {
+    return p.SetProperty(LDPerson.address, a, unwrap(context));
+  }
+  static setAddressAsString(p, a, context) {
+    return p.SetProperty(LDPerson.address, a, unwrap(context));
+  }
+  static getDisambiguatingDescriptionsAsString(p, context) {
+    return ResizeArray_map((v) => v, p.GetPropertyValues(LDPerson.disambiguatingDescription, (value, context_1) => typeof value === "string", unwrap(context)));
+  }
+  static setDisambiguatingDescriptionsAsString(p, d, context) {
+    return p.SetProperty(LDPerson.disambiguatingDescription, d, unwrap(context));
+  }
+  static tryGetFaxNumberAsString(p, context) {
+    const matchValue = p.TryGetPropertyAsSingleton(LDPerson.faxNumber, unwrap(context));
+    let matchResult, f;
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        matchResult = 0;
+        f = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return f;
+      default:
+        return void 0;
+    }
+  }
+  static setFaxNumberAsString(p, f, context) {
+    return p.SetProperty(LDPerson.faxNumber, f, unwrap(context));
+  }
+  static tryGetTelephoneAsString(p, context) {
+    const matchValue = p.TryGetPropertyAsSingleton(LDPerson.telephone, unwrap(context));
+    let matchResult, t;
+    if (matchValue != null) {
+      if (typeof value(matchValue) === "string") {
+        matchResult = 0;
+        t = value(matchValue);
+      } else {
+        matchResult = 1;
+      }
+    } else {
+      matchResult = 1;
+    }
+    switch (matchResult) {
+      case 0:
+        return t;
+      default:
+        return void 0;
+    }
+  }
+  static setTelephoneAsString(p, t, context) {
+    return p.SetProperty(LDPerson.telephone, t, unwrap(context));
+  }
+  static genId(givenName, orcid, familyName) {
+    let matchValue;
+    return clean((matchValue = bind(tryGetOrcidURL, orcid), matchValue == null ? familyName == null ? `#Person_${givenName}` : `#Person_${givenName}_${value(familyName)}` : value(matchValue)));
+  }
+  static validate(p, context) {
+    return p.HasType(LDPerson.schemaType, unwrap(context)) && p.HasProperty(LDPerson.givenName, unwrap(context));
+  }
+  static create(givenName, orcid, id, affiliation, email, familyName, identifier, jobTitles, additionalName, address, disambiguatingDescriptions, faxNumber, telephone, context) {
+    const person = new LDNode(id == null ? LDPerson.genId(givenName, unwrap(orcid), unwrap(familyName)) : value(id), [LDPerson.schemaType], void 0, unwrap(context));
+    person.SetProperty(LDPerson.givenName, givenName, unwrap(context));
+    person.SetOptionalProperty(LDPerson.affiliation, affiliation, unwrap(context));
+    person.SetOptionalProperty(LDPerson.email, email, unwrap(context));
+    person.SetOptionalProperty(LDPerson.familyName, familyName, unwrap(context));
+    person.SetOptionalProperty(LDPerson.identifier, identifier, unwrap(context));
+    person.SetOptionalProperty(LDPerson.jobTitle, jobTitles, unwrap(context));
+    person.SetOptionalProperty(LDPerson.additionalName, additionalName, unwrap(context));
+    person.SetOptionalProperty(LDPerson.address, address, unwrap(context));
+    person.SetOptionalProperty(LDPerson.disambiguatingDescription, disambiguatingDescriptions, unwrap(context));
+    person.SetOptionalProperty(LDPerson.faxNumber, faxNumber, unwrap(context));
+    person.SetOptionalProperty(LDPerson.telephone, telephone, unwrap(context));
+    return person;
+  }
+}
+
+export { LDPerson };