arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/ROCrate/Generic/sample.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ...fable_modules.fable_library.array_ import contains
+from ...fable_modules.fable_library.option import value
+from ...fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ...fable_modules.fable_library.types import Array
+from ...fable_modules.fable_library.util import string_hash
+from ..helper import clean
+from ..ldcontext import LDContext
+from ..ldobject import (LDNode, LDGraph)
+from .property_value import LDPropertyValue
+
+def _expr1543() -> TypeInfo:
+    return class_type("ARCtrl.ROCrate.LDSample", None, LDSample)
+
+
+class LDSample:
+    @staticmethod
+    def schema_type() -> str:
+        return "https://bioschemas.org/Sample"
+
+    @staticmethod
+    def name() -> str:
+        return "http://schema.org/name"
+
+    @staticmethod
+    def additional_property() -> str:
+        return "http://schema.org/additionalProperty"
+
+    @staticmethod
+    def try_get_name_as_string(s: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = s.TryGetPropertyAsSingleton(LDSample.name(), context)
+        (pattern_matching_result, n) = (None, None)
+        if match_value is not None:
+            if str(type(value(match_value))) == "<class \'str\'>":
+                pattern_matching_result = 0
+                n = value(match_value)
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return n
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def get_name_as_string(s: LDNode, context: LDContext | None=None) -> str:
+        match_value: Any | None = s.TryGetPropertyAsSingleton(LDSample.name(), context)
+        (pattern_matching_result, n) = (None, None)
+        if match_value is not None:
+            if str(type(value(match_value))) == "<class \'str\'>":
+                pattern_matching_result = 0
+                n = value(match_value)
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return n
+
+        elif pattern_matching_result == 1:
+            raise Exception(("Could not access property `name` of object with @id `" + s.Id) + "`")
+
+
+    @staticmethod
+    def set_name_as_string(s: LDNode, n: str) -> None:
+        s.SetProperty(LDSample.name(), n)
+
+    @staticmethod
+    def get_additional_properties(s: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        def filter(ld_object: LDNode, context_1: LDContext | None=None) -> bool:
+            return LDPropertyValue.validate(ld_object, context_1)
+
+        return s.GetPropertyNodes(LDSample.additional_property(), filter, graph, context)
+
+    @staticmethod
+    def set_additional_properties(s: LDNode, additional_properties: Array[LDNode], context: LDContext | None=None) -> Any:
+        return s.SetProperty(LDSample.additional_property(), additional_properties, context)
+
+    @staticmethod
+    def get_characteristics(s: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        def filter(ld_object: LDNode, context_1: LDContext | None=None) -> bool:
+            return LDPropertyValue.validate_characteristic_value(ld_object, context_1)
+
+        return s.GetPropertyNodes(LDSample.additional_property(), filter, graph, context)
+
+    @staticmethod
+    def get_factors(s: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        def filter(ld_object: LDNode, context_1: LDContext | None=None) -> bool:
+            return LDPropertyValue.validate_factor_value(ld_object, context_1)
+
+        return s.GetPropertyNodes(LDSample.additional_property(), filter, graph, context)
+
+    @staticmethod
+    def validate(s: LDNode, context: LDContext | None=None) -> bool:
+        return s.HasProperty(LDSample.name(), context) if s.HasType(LDSample.schema_type(), context) else False
+
+    @staticmethod
+    def gen_idsample(name: str) -> str:
+        return clean(("#Sample_" + name) + "")
+
+    @staticmethod
+    def gen_idsource(name: str) -> str:
+        return clean(("#Source_" + name) + "")
+
+    @staticmethod
+    def gen_idmaterial(name: str) -> str:
+        return clean(("#Material_" + name) + "")
+
+    @staticmethod
+    def validate_sample(s: LDNode, context: LDContext | None=None) -> bool:
+        class ObjectExpr1538:
+            @property
+            def Equals(self) -> Callable[[str, str], bool]:
+                def _arrow1537(x: str, y: str) -> bool:
+                    return x == y
+
+                return _arrow1537
+
+            @property
+            def GetHashCode(self) -> Callable[[str], int]:
+                return string_hash
+
+        return contains("Sample", s.AdditionalType, ObjectExpr1538()) if LDSample.validate(s, context) else False
+
+    @staticmethod
+    def validate_source(s: LDNode, context: LDContext | None=None) -> bool:
+        class ObjectExpr1540:
+            @property
+            def Equals(self) -> Callable[[str, str], bool]:
+                def _arrow1539(x: str, y: str) -> bool:
+                    return x == y
+
+                return _arrow1539
+
+            @property
+            def GetHashCode(self) -> Callable[[str], int]:
+                return string_hash
+
+        return contains("Source", s.AdditionalType, ObjectExpr1540()) if LDSample.validate(s, context) else False
+
+    @staticmethod
+    def validate_material(s: LDNode, context: LDContext | None=None) -> bool:
+        class ObjectExpr1542:
+            @property
+            def Equals(self) -> Callable[[str, str], bool]:
+                def _arrow1541(x: str, y: str) -> bool:
+                    return x == y
+
+                return _arrow1541
+
+            @property
+            def GetHashCode(self) -> Callable[[str], int]:
+                return string_hash
+
+        return contains("Material", s.AdditionalType, ObjectExpr1542()) if LDSample.validate(s, context) else False
+
+    @staticmethod
+    def create(id: str, name: str, additional_properties: Array[LDNode] | None=None, context: LDContext | None=None) -> LDNode:
+        s: LDNode = LDNode(id, [LDSample.schema_type()], None, context)
+        s.SetProperty(LDSample.name(), name, context)
+        s.SetOptionalProperty(LDSample.additional_property(), additional_properties, context)
+        return s
+
+    @staticmethod
+    def create_sample(name: str, id: str | None=None, additional_properties: Array[LDNode] | None=None, context: LDContext | None=None) -> LDNode:
+        id_2: str = LDSample.gen_idsample(name) if (id is None) else id
+        s: LDNode = LDSample.create(id_2, name, additional_properties, context)
+        s.AdditionalType = ["Sample"]
+        return s
+
+    @staticmethod
+    def create_source(name: str, id: str | None=None, additional_properties: Array[LDNode] | None=None, context: LDContext | None=None) -> LDNode:
+        id_2: str = LDSample.gen_idsource(name) if (id is None) else id
+        s: LDNode = LDSample.create(id_2, name, additional_properties, context)
+        s.AdditionalType = ["Source"]
+        return s
+
+    @staticmethod
+    def create_material(name: str, id: str | None=None, additional_properties: Array[LDNode] | None=None, context: LDContext | None=None) -> LDNode:
+        id_2: str = LDSample.gen_idmaterial(name) if (id is None) else id
+        s: LDNode = LDSample.create(id_2, name, additional_properties, context)
+        s.AdditionalType = ["Material"]
+        return s
+
+
+LDSample_reflection = _expr1543
+
+__all__ = ["LDSample_reflection"]
+

arctrl/py/ROCrate/Generic/scholarly_article.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+from typing import Any
+from ...fable_modules.fable_library.option import value
+from ...fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ...fable_modules.fable_library.types import Array
+from ..helper import clean
+from ..ldcontext import LDContext
+from ..ldobject import (LDNode, LDGraph)
+from .comment import LDComment
+from .defined_term import LDDefinedTerm
+from .person import LDPerson
+from .property_value import LDPropertyValue
+
+def _expr1536() -> TypeInfo:
+    return class_type("ARCtrl.ROCrate.LDScholarlyArticle", None, LDScholarlyArticle)
+
+
+class LDScholarlyArticle:
+    @staticmethod
+    def schema_type() -> str:
+        return "http://schema.org/ScholarlyArticle"
+
+    @staticmethod
+    def headline() -> str:
+        return "http://schema.org/headline"
+
+    @staticmethod
+    def identifier() -> str:
+        return "http://schema.org/identifier"
+
+    @staticmethod
+    def author() -> str:
+        return "http://schema.org/author"
+
+    @staticmethod
+    def url() -> str:
+        return "http://schema.org/url"
+
+    @staticmethod
+    def same_as() -> str:
+        return "http://schema.org/sameAs"
+
+    @staticmethod
+    def creative_work_status() -> str:
+        return "http://schema.org/creativeWorkStatus"
+
+    @staticmethod
+    def comment() -> str:
+        return "http://schema.org/comment"
+
+    @staticmethod
+    def try_get_headline_as_string(s: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = s.TryGetPropertyAsSingleton(LDScholarlyArticle.headline(), context)
+        (pattern_matching_result, n) = (None, None)
+        if match_value is not None:
+            if str(type(value(match_value))) == "<class \'str\'>":
+                pattern_matching_result = 0
+                n = value(match_value)
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return n
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def get_headline_as_string(s: LDNode, context: LDContext | None=None) -> str:
+        match_value: Any | None = s.TryGetPropertyAsSingleton(LDScholarlyArticle.headline(), context)
+        if match_value is None:
+            raise Exception(("Could not access property `headline` of object with @id `" + s.Id) + "`")
+
+        elif str(type(value(match_value))) == "<class \'str\'>":
+            n: str = value(match_value)
+            return n
+
+        else: 
+            raise Exception(("Value of property `headline` of object with @id `" + s.Id) + "` should have been a string")
+
+
+    @staticmethod
+    def set_headline_as_string(s: LDNode, n: str) -> None:
+        s.SetProperty(LDScholarlyArticle.headline(), n)
+
+    @staticmethod
+    def get_identifiers(s: LDNode, context: LDContext | None=None) -> Array[Any]:
+        return s.GetPropertyValues(LDScholarlyArticle.identifier(), None, context)
+
+    @staticmethod
+    def get_identifiers_as_property_value(s: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        def filter(ld_object: LDNode, context_1: LDContext | None=None) -> bool:
+            return LDPropertyValue.validate(ld_object, context_1)
+
+        return s.GetPropertyNodes(LDScholarlyArticle.identifier(), filter, graph, context)
+
+    @staticmethod
+    def set_identifiers(s: LDNode, identifiers: Array[Any]) -> None:
+        s.SetProperty(LDScholarlyArticle.identifier(), identifiers)
+
+    @staticmethod
+    def get_authors(s: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        def filter(ld_object: LDNode, context_1: LDContext | None=None) -> bool:
+            return LDPerson.validate(ld_object, context_1)
+
+        return s.GetPropertyNodes(LDScholarlyArticle.author(), filter, graph, context)
+
+    @staticmethod
+    def set_authors(s: LDNode, authors: Array[LDNode], context: LDContext | None=None) -> Any:
+        return s.SetProperty(LDScholarlyArticle.author(), authors, context)
+
+    @staticmethod
+    def try_get_url_as_string(s: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = s.TryGetPropertyAsSingleton(LDScholarlyArticle.url(), context)
+        (pattern_matching_result, u) = (None, None)
+        if match_value is not None:
+            if str(type(value(match_value))) == "<class \'str\'>":
+                pattern_matching_result = 0
+                u = value(match_value)
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return u
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def try_get_same_as_as_string(s: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = s.TryGetPropertyAsSingleton(LDScholarlyArticle.same_as(), context)
+        (pattern_matching_result, sa) = (None, None)
+        if match_value is not None:
+            if str(type(value(match_value))) == "<class \'str\'>":
+                pattern_matching_result = 0
+                sa = value(match_value)
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return sa
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def try_get_creative_work_status(s: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> LDNode | None:
+        match_value: LDNode | None = s.TryGetPropertyAsSingleNode(LDScholarlyArticle.creative_work_status(), graph, context)
+        (pattern_matching_result, cws_1) = (None, None)
+        if match_value is not None:
+            def _arrow1535(__unit: None=None) -> bool:
+                cws: LDNode = match_value
+                return LDDefinedTerm.validate(cws, context)
+
+            if _arrow1535():
+                pattern_matching_result = 0
+                cws_1 = match_value
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return cws_1
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def set_creative_work_status(s: LDNode, cws: LDNode, context: LDContext | None=None) -> Any:
+        return s.SetProperty(LDScholarlyArticle.creative_work_status(), cws, context)
+
+    @staticmethod
+    def get_comments(s: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        def filter(ld_object: LDNode, context_1: LDContext | None=None) -> bool:
+            return LDComment.validate(ld_object, context_1)
+
+        return s.GetPropertyNodes(LDScholarlyArticle.comment(), filter, graph, context)
+
+    @staticmethod
+    def setcomments(s: LDNode, comments: Array[LDNode], context: LDContext | None=None) -> Any:
+        return s.SetProperty(LDScholarlyArticle.comment(), comments, context)
+
+    @staticmethod
+    def gen_id(headline: str, url: str | None=None) -> str:
+        return clean((("#" + headline) + "") if (url is None) else url)
+
+    @staticmethod
+    def validate(s: LDNode, context: LDContext | None=None) -> bool:
+        return s.HasProperty(LDScholarlyArticle.headline(), context) if s.HasType(LDScholarlyArticle.schema_type(), context) else False
+
+    @staticmethod
+    def create(headline: str, identifiers: Array[Any], id: str | None=None, authors: Array[LDNode] | None=None, url: str | None=None, creative_work_status: LDNode | None=None, comments: Array[LDNode] | None=None, context: LDContext | None=None) -> LDNode:
+        s: LDNode = LDNode(LDScholarlyArticle.gen_id(headline, url) if (id is None) else id, [LDScholarlyArticle.schema_type()], None, context)
+        s.SetProperty(LDScholarlyArticle.headline(), headline, context)
+        s.SetProperty(LDScholarlyArticle.identifier(), identifiers, context)
+        s.SetOptionalProperty(LDScholarlyArticle.author(), authors, context)
+        s.SetOptionalProperty(LDScholarlyArticle.url(), url, context)
+        s.SetOptionalProperty(LDScholarlyArticle.creative_work_status(), creative_work_status, context)
+        s.SetOptionalProperty(LDScholarlyArticle.comment(), comments, context)
+        return s
+
+
+LDScholarlyArticle_reflection = _expr1536
+
+__all__ = ["LDScholarlyArticle_reflection"]
+

arctrl/py/ROCrate/ISAProfile/assay.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ...fable_modules.dynamic_obj.dynamic_obj import DynamicObj
+from ...fable_modules.dynamic_obj.dyn_obj import (try_get_property_value, set_property, set_optional_property)
+from ...fable_modules.fable_library.option import value as value_1
+from ...fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ...fable_modules.fable_library.types import FSharpRef
+from .dataset import (Dataset, Dataset_reflection)
+
+def _expr1567() -> TypeInfo:
+    return class_type("ARCtrl.ROCrate.Assay", None, Assay, Dataset_reflection())
+
+
+class Assay(Dataset):
+    def __init__(self, id: str, identifier: str, about: Any | None=None, comment: Any | None=None, creator: Any | None=None, has_part: Any | None=None, measurement_method: Any | None=None, measurement_technique: Any | None=None, url: Any | None=None, variable_measured: Any | None=None) -> None:
+        super().__init__(id, ["Assay"])
+        this: FSharpRef[Assay] = FSharpRef(None)
+        this.contents = self
+        self.init_00408_1: int = 1
+        set_property("identifier", identifier, this.contents)
+        set_optional_property("measurementMethod", measurement_method, this.contents)
+        set_optional_property("measurementTechnique", measurement_technique, this.contents)
+        set_optional_property("variableMeasured", variable_measured, this.contents)
+        set_optional_property("about", about, this.contents)
+        set_optional_property("comment", comment, this.contents)
+        set_optional_property("creator", creator, this.contents)
+        set_optional_property("hasPart", has_part, this.contents)
+        set_optional_property("url", url, this.contents)
+
+    def GetIdentifier(self, __unit: None=None) -> str:
+        this: Assay = self
+        obj: DynamicObj = this
+        if try_get_property_value("identifier", obj) is not None:
+            match_value: str | None
+            match_value_1: Any | None = obj.TryGetPropertyValue("identifier")
+            if match_value_1 is not None:
+                o: Any = value_1(match_value_1)
+                match_value = o if (str(type(o)) == "<class \'str\'>") else None
+
+            else: 
+                match_value = None
+
+            if match_value is None:
+                raise Exception(((((("Property \'" + "identifier") + "\' is set on this \'") + "Assay") + "\' object but cannot be cast to \'") + "String") + "\'")
+
+            else: 
+                return match_value
+
+
+        else: 
+            raise Exception(((("No property \'" + "identifier") + "\' set on this \'") + "Assay") + "\' object although it is mandatory. Was it created correctly?")
+
+
+    @staticmethod
+    def get_identifier() -> Callable[[Assay], str]:
+        def _arrow1566(ass: Assay) -> str:
+            return ass.GetIdentifier()
+
+        return _arrow1566
+
+
+Assay_reflection = _expr1567
+
+def Assay__ctor_Z318F9460(id: str, identifier: str, about: Any | None=None, comment: Any | None=None, creator: Any | None=None, has_part: Any | None=None, measurement_method: Any | None=None, measurement_technique: Any | None=None, url: Any | None=None, variable_measured: Any | None=None) -> Assay:
+    return Assay(id, identifier, about, comment, creator, has_part, measurement_method, measurement_technique, url, variable_measured)
+
+
+__all__ = ["Assay_reflection"]
+

arctrl/py/ROCrate/ISAProfile/data.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ...fable_modules.dynamic_obj.dynamic_obj import DynamicObj
+from ...fable_modules.dynamic_obj.dyn_obj import (try_get_property_value, set_property, set_optional_property)
+from ...fable_modules.fable_library.option import (value as value_1, default_arg)
+from ...fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ...fable_modules.fable_library.types import (FSharpRef, Array)
+from ..ldobject import (LDNode, LDNode_reflection)
+
+def _expr1587() -> TypeInfo:
+    return class_type("ARCtrl.ROCrate.Data", None, Data, LDNode_reflection())
+
+
+class Data(LDNode):
+    def __init__(self, id: str, name: Any=None, additional_type: Array[str] | None=None, comment: Any | None=None, encoding_format: Any | None=None, disambiguating_description: Any | None=None) -> None:
+        super().__init__(id, ["schema.org/MediaObject"], default_arg(additional_type, []))
+        this: FSharpRef[Data] = FSharpRef(None)
+        this.contents = self
+        self.init_00408: int = 1
+        set_property("name", name, this.contents)
+        set_optional_property("comment", comment, this.contents)
+        set_optional_property("encodingFormat", encoding_format, this.contents)
+        set_optional_property("disambiguatingDescription", disambiguating_description, this.contents)
+
+    def GetName(self, __unit: None=None) -> str:
+        this: Data = self
+        obj: DynamicObj = this
+        if try_get_property_value("name", obj) is not None:
+            match_value: str | None
+            match_value_1: Any | None = obj.TryGetPropertyValue("name")
+            if match_value_1 is not None:
+                o: Any = value_1(match_value_1)
+                match_value = o if (str(type(o)) == "<class \'str\'>") else None
+
+            else: 
+                match_value = None
+
+            if match_value is None:
+                raise Exception(((((("Property \'" + "name") + "\' is set on this \'") + "Data") + "\' object but cannot be cast to \'") + "String") + "\'")
+
+            else: 
+                return match_value
+
+
+        else: 
+            raise Exception(((("No property \'" + "name") + "\' set on this \'") + "Data") + "\' object although it is mandatory. Was it created correctly?")
+
+
+    @staticmethod
+    def get_name() -> Callable[[Data], str]:
+        def _arrow1586(d: Data) -> str:
+            return d.GetName()
+
+        return _arrow1586
+
+
+Data_reflection = _expr1587
+
+def Data__ctor_Z11AF9DE7(id: str, name: Any=None, additional_type: Array[str] | None=None, comment: Any | None=None, encoding_format: Any | None=None, disambiguating_description: Any | None=None) -> Data:
+    return Data(id, name, additional_type, comment, encoding_format, disambiguating_description)
+
+
+__all__ = ["Data_reflection"]
+

arctrl/py/ROCrate/ISAProfile/dataset.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+from ...fable_modules.fable_library.option import default_arg
+from ...fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ...fable_modules.fable_library.types import Array
+from ..ldobject import (LDNode, LDNode_reflection)
+
+def _expr1561() -> TypeInfo:
+    return class_type("ARCtrl.ROCrate.Dataset", None, Dataset, LDNode_reflection())
+
+
+class Dataset(LDNode):
+    def __init__(self, id: str, additional_type: Array[str] | None=None) -> None:
+        super().__init__(id, ["schema.org/Dataset"], default_arg(additional_type, []))
+        self.init_00408: int = 1
+
+
+Dataset_reflection = _expr1561
+
+def Dataset__ctor_Z7E7CD246(id: str, additional_type: Array[str] | None=None) -> Dataset:
+    return Dataset(id, additional_type)
+
+
+__all__ = ["Dataset_reflection"]
+

arctrl/py/ROCrate/ISAProfile/investigation.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ...fable_modules.dynamic_obj.dynamic_obj import DynamicObj
+from ...fable_modules.dynamic_obj.dyn_obj import (try_get_property_value, set_property, set_optional_property)
+from ...fable_modules.fable_library.option import value as value_1
+from ...fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ...fable_modules.fable_library.types import FSharpRef
+from .dataset import (Dataset, Dataset_reflection)
+
+def _expr1563() -> TypeInfo:
+    return class_type("ARCtrl.ROCrate.Investigation", None, Investigation, Dataset_reflection())
+
+
+class Investigation(Dataset):
+    def __init__(self, id: str, identifier: str, citation: Any | None=None, comment: Any | None=None, creator: Any | None=None, date_created: Any | None=None, date_modified: Any | None=None, date_published: Any | None=None, has_part: Any | None=None, headline: Any | None=None, mentions: Any | None=None, url: Any | None=None, description: Any | None=None) -> None:
+        super().__init__(id, ["Investigation"])
+        this: FSharpRef[Investigation] = FSharpRef(None)
+        this.contents = self
+        self.init_00408_1: int = 1
+        set_property("identifier", identifier, this.contents)
+        set_optional_property("citation", citation, this.contents)
+        set_optional_property("comment", comment, this.contents)
+        set_optional_property("creator", creator, this.contents)
+        set_optional_property("dateCreated", date_created, this.contents)
+        set_optional_property("dateModified", date_modified, this.contents)
+        set_optional_property("datePublished", date_published, this.contents)
+        set_optional_property("hasPart", has_part, this.contents)
+        set_optional_property("headline", headline, this.contents)
+        set_optional_property("mentions", mentions, this.contents)
+        set_optional_property("url", url, this.contents)
+        set_optional_property("description", description, this.contents)
+
+    def GetIdentifier(self, __unit: None=None) -> str:
+        this: Investigation = self
+        obj: DynamicObj = this
+        if try_get_property_value("identifier", obj) is not None:
+            match_value: str | None
+            match_value_1: Any | None = obj.TryGetPropertyValue("identifier")
+            if match_value_1 is not None:
+                o: Any = value_1(match_value_1)
+                match_value = o if (str(type(o)) == "<class \'str\'>") else None
+
+            else: 
+                match_value = None
+
+            if match_value is None:
+                raise Exception(((((("Property \'" + "identifier") + "\' is set on this \'") + "Investigation") + "\' object but cannot be cast to \'") + "String") + "\'")
+
+            else: 
+                return match_value
+
+
+        else: 
+            raise Exception(((("No property \'" + "identifier") + "\' set on this \'") + "Investigation") + "\' object although it is mandatory. Was it created correctly?")
+
+
+    @staticmethod
+    def get_identifier() -> Callable[[Investigation], str]:
+        def _arrow1562(inv: Investigation) -> str:
+            return inv.GetIdentifier()
+
+        return _arrow1562
+
+
+Investigation_reflection = _expr1563
+
+def Investigation__ctor_Z47833D48(id: str, identifier: str, citation: Any | None=None, comment: Any | None=None, creator: Any | None=None, date_created: Any | None=None, date_modified: Any | None=None, date_published: Any | None=None, has_part: Any | None=None, headline: Any | None=None, mentions: Any | None=None, url: Any | None=None, description: Any | None=None) -> Investigation:
+    return Investigation(id, identifier, citation, comment, creator, date_created, date_modified, date_published, has_part, headline, mentions, url, description)
+
+
+__all__ = ["Investigation_reflection"]
+