nmdc-schema 11.11.1__py3-none-any.whl → 11.12.0__py3-none-any.whl

nmdc_schema/nmdc.py

@@ -1,5 +1,5 @@
 # Auto generated from nmdc.yaml by pythongen.py version: 0.0.1
-# Generation date: 2025-09-19T01:08:09
+# Generation date: 2025-10-09T17:14:07
 # Schema: NMDC
 #
 # id: https://w3id.org/nmdc/nmdc
@@ -60,7 +60,7 @@ from linkml_runtime.linkml_model.types import Boolean, Decimal, Double, Float, I
 from linkml_runtime.utils.metamodelcore import Bool, Decimal, URIorCURIE
 
 metamodel_version = "1.7.0"
-version = "11.11.1"
+version = "11.12.0"
 
 # Namespaces
 BFO = CurieNamespace('BFO', 'http://purl.obolibrary.org/obo/BFO_')
@@ -1194,6 +1194,74 @@ class GeolocationValue(AttributeValue):
         self.type = str(self.class_class_curie)
 
 
+@dataclass(repr=False)
+class PropertyAssertion(AttributeValue):
+    """
+    A structured record of data that doesn't fit nicely within the constraints of other NMDC AttributeValues. Uses
+    primitive ranges only.
+    """
+    _inherited_slots: ClassVar[list[str]] = []
+
+    class_class_uri: ClassVar[URIRef] = NMDC["PropertyAssertion"]
+    class_class_curie: ClassVar[str] = "nmdc:PropertyAssertion"
+    class_name: ClassVar[str] = "PropertyAssertion"
+    class_model_uri: ClassVar[URIRef] = NMDC.PropertyAssertion
+
+    type: Union[str, URIorCURIE] = None
+    has_raw_value: str = None
+    has_attribute_label: Optional[str] = None
+    has_attribute_id: Optional[Union[str, URIorCURIE]] = None
+    has_quantity_kind_id: Optional[Union[str, URIorCURIE]] = None
+    has_value_term_id: Optional[Union[str, URIorCURIE]] = None
+    has_boolean_value: Optional[Union[bool, Bool]] = None
+    has_datetime_value: Optional[str] = None
+    has_numeric_value: Optional[Decimal] = None
+    has_minimum_numeric_value: Optional[Decimal] = None
+    has_maximum_numeric_value: Optional[Decimal] = None
+    has_unit: Optional[str] = None
+
+    def __post_init__(self, *_: str, **kwargs: Any):
+        if self._is_empty(self.has_raw_value):
+            self.MissingRequiredField("has_raw_value")
+        if not isinstance(self.has_raw_value, str):
+            self.has_raw_value = str(self.has_raw_value)
+
+        if self.has_attribute_label is not None and not isinstance(self.has_attribute_label, str):
+            self.has_attribute_label = str(self.has_attribute_label)
+
+        if self.has_attribute_id is not None and not isinstance(self.has_attribute_id, URIorCURIE):
+            self.has_attribute_id = URIorCURIE(self.has_attribute_id)
+
+        if self.has_quantity_kind_id is not None and not isinstance(self.has_quantity_kind_id, URIorCURIE):
+            self.has_quantity_kind_id = URIorCURIE(self.has_quantity_kind_id)
+
+        if self.has_value_term_id is not None and not isinstance(self.has_value_term_id, URIorCURIE):
+            self.has_value_term_id = URIorCURIE(self.has_value_term_id)
+
+        if self.has_boolean_value is not None and not isinstance(self.has_boolean_value, Bool):
+            self.has_boolean_value = Bool(self.has_boolean_value)
+
+        if self.has_datetime_value is not None and not isinstance(self.has_datetime_value, str):
+            self.has_datetime_value = str(self.has_datetime_value)
+
+        if self.has_numeric_value is not None and not isinstance(self.has_numeric_value, Decimal):
+            self.has_numeric_value = Decimal(self.has_numeric_value)
+
+        if self.has_minimum_numeric_value is not None and not isinstance(self.has_minimum_numeric_value, Decimal):
+            self.has_minimum_numeric_value = Decimal(self.has_minimum_numeric_value)
+
+        if self.has_maximum_numeric_value is not None and not isinstance(self.has_maximum_numeric_value, Decimal):
+            self.has_maximum_numeric_value = Decimal(self.has_maximum_numeric_value)
+
+        if self.has_unit is not None and not isinstance(self.has_unit, str):
+            self.has_unit = str(self.has_unit)
+
+        super().__post_init__(**kwargs)
+        if self._is_empty(self.type):
+            self.MissingRequiredField("type")
+        self.type = str(self.class_class_curie)
+
+
 @dataclass(repr=False)
 class NamedThing(YAMLRoot):
     """
@@ -1848,7 +1916,7 @@ class Biosample(Sample):
     micro_biomass_meth: Optional[str] = None
     microbial_biomass: Optional[Union[dict, QuantityValue]] = None
     mineral_nutr_regm: Optional[Union[Union[dict, TextValue], list[Union[dict, TextValue]]]] = empty_list()
-    misc_param: Optional[Union[Union[dict, TextValue], list[Union[dict, TextValue]]]] = empty_list()
+    misc_param: Optional[Union[Union[dict, PropertyAssertion], list[Union[dict, PropertyAssertion]]]] = empty_list()
     n_alkanes: Optional[Union[Union[dict, TextValue], list[Union[dict, TextValue]]]] = empty_list()
     nitrate: Optional[Union[dict, QuantityValue]] = None
     nitrite: Optional[Union[dict, QuantityValue]] = None
@@ -2949,7 +3017,7 @@ class Biosample(Sample):
 
         if not isinstance(self.misc_param, list):
             self.misc_param = [self.misc_param] if self.misc_param is not None else []
-        self.misc_param = [v if isinstance(v, TextValue) else TextValue(**as_dict(v)) for v in self.misc_param]
+        self.misc_param = [v if isinstance(v, PropertyAssertion) else PropertyAssertion(**as_dict(v)) for v in self.misc_param]
 
         if not isinstance(self.n_alkanes, list):
             self.n_alkanes = [self.n_alkanes] if self.n_alkanes is not None else []
@@ -4008,7 +4076,8 @@ class FieldResearchSite(Site):
 @dataclass(repr=False)
 class Instrument(MaterialEntity):
     """
-    A material entity that is designed to perform a function in a scientific investigation, but is not a reagent.
+    A material entity that is designed to perform a function in a scientific investigation, but is not a reagent. This
+    class models the make and model of the instrument, not the specific instance of the instrument.
     """
     _inherited_slots: ClassVar[list[str]] = []
 
@@ -4736,6 +4805,8 @@ class Protocol(YAMLRoot):
     url: Optional[str] = None
     name: Optional[str] = None
     description: Optional[str] = None
+    protocol_for: Optional[Union[str, "ProtocolForEnum"]] = None
+    analysis_type: Optional[Union[Union[str, "AnalysisTypeEnum"], list[Union[str, "AnalysisTypeEnum"]]]] = empty_list()
 
     def __post_init__(self, *_: str, **kwargs: Any):
         if self._is_empty(self.type):
@@ -4751,6 +4822,13 @@ class Protocol(YAMLRoot):
         if self.description is not None and not isinstance(self.description, str):
             self.description = str(self.description)
 
+        if self.protocol_for is not None and not isinstance(self.protocol_for, ProtocolForEnum):
+            self.protocol_for = ProtocolForEnum(self.protocol_for)
+
+        if not isinstance(self.analysis_type, list):
+            self.analysis_type = [self.analysis_type] if self.analysis_type is not None else []
+        self.analysis_type = [v if isinstance(v, AnalysisTypeEnum) else AnalysisTypeEnum(v) for v in self.analysis_type]
+
         super().__post_init__(**kwargs)
 
 
@@ -6950,6 +7028,9 @@ class UnitEnum(EnumDefinitionImpl):
     cm = PermissibleValue(
         text="cm",
         description="The Unified Code for Units of Measure (UCUM) representation of centimeter.")
+    cP = PermissibleValue(
+        text="cP",
+        description="The Unified Code for Units of Measure (UCUM) representation of centipoise.")
     d = PermissibleValue(
         text="d",
         description="The Unified Code for Units of Measure (UCUM) representation of day.")
@@ -6986,27 +7067,21 @@ class UnitEnum(EnumDefinitionImpl):
     atm = PermissibleValue(
         text="atm",
         description="The Unified Code for Units of Measure (UCUM) representation of atmosphere.")
+    V = PermissibleValue(
+        text="V",
+        description="The Unified Code for Units of Measure (UCUM) representation of volt.")
     mV = PermissibleValue(
         text="mV",
         description="The Unified Code for Units of Measure (UCUM) representation of millivolt.")
-    PSU = PermissibleValue(
-        text="PSU",
-        description="The Unified Code for Units of Measure (UCUM) representation of practical salinity unit.")
     L = PermissibleValue(
         text="L",
         description="The Unified Code for Units of Measure (UCUM) representation of liter.")
     um = PermissibleValue(
         text="um",
         description="The Unified Code for Units of Measure (UCUM) representation of micrometer.")
-    y = PermissibleValue(
-        text="y",
-        description="The Unified Code for Units of Measure (UCUM) representation of year.")
     kg = PermissibleValue(
         text="kg",
         description="The Unified Code for Units of Measure (UCUM) representation of kilogram.")
-    ppt = PermissibleValue(
-        text="ppt",
-        description="The Unified Code for Units of Measure (UCUM) representation of parts per thousand.")
     lx = PermissibleValue(
         text="lx",
         description="The Unified Code for Units of Measure (UCUM) representation of lux.")
@@ -7106,30 +7181,30 @@ class UnitEnum(EnumDefinitionImpl):
     kW = PermissibleValue(
         text="kW",
         description="The Unified Code for Units of Measure (UCUM) representation of kilowatt.")
-    API = PermissibleValue(
-        text="API",
-        description="The Unified Code for Units of Measure (UCUM) representation of API units.")
     mbar = PermissibleValue(
         text="mbar",
         description="The Unified Code for Units of Measure (UCUM) representation of millibar.")
-    ratio = PermissibleValue(
-        text="ratio",
-        description="The Unified Code for Units of Measure (UCUM) representation of ratio (dimensionless).")
-    people = PermissibleValue(
-        text="people",
-        description="The Unified Code for Units of Measure (UCUM) representation of people count.")
-    pets = PermissibleValue(
-        text="pets",
-        description="The Unified Code for Units of Measure (UCUM) representation of pet count.")
-    plants = PermissibleValue(
-        text="plants",
-        description="The Unified Code for Units of Measure (UCUM) representation of plant count.")
-    pH = PermissibleValue(
-        text="pH",
-        description="The Unified Code for Units of Measure (UCUM) representation of pH units.")
-    NTU = PermissibleValue(
-        text="NTU",
-        description="The Unified Code for Units of Measure (UCUM) representation of Nephelometric Turbidity Units.")
+    mg = PermissibleValue(
+        text="mg",
+        description="The Unified Code for Units of Measure (UCUM) representation of milligram.")
+    wk = PermissibleValue(
+        text="wk",
+        description="The Unified Code for Units of Measure (UCUM) representation of week.")
+    Gy = PermissibleValue(
+        text="Gy",
+        description="The Unified Code for Units of Measure (UCUM) representation of gray (absorbed dose).")
+    RAD = PermissibleValue(
+        text="RAD",
+        description="The Unified Code for Units of Measure (UCUM) representation of rad (radiation absorbed dose).")
+    m3 = PermissibleValue(
+        text="m3",
+        description="The Unified Code for Units of Measure (UCUM) representation of cubic meter.")
+    ug = PermissibleValue(
+        text="ug",
+        description="The Unified Code for Units of Measure (UCUM) representation of microgram.")
+    cm2 = PermissibleValue(
+        text="cm2",
+        description="The Unified Code for Units of Measure (UCUM) representation of square centimeter.")
 
     _defn = EnumDefinition(
         name="UnitEnum",
@@ -7237,6 +7312,10 @@ class UnitEnum(EnumDefinitionImpl):
             PermissibleValue(
                 text="uL/kg",
                 description="""The Unified Code for Units of Measure (UCUM) representation of microliters per kilogram."""))
+        setattr(cls, "[ppth]",
+            PermissibleValue(
+                text="[ppth]",
+                description="The Unified Code for Units of Measure (UCUM) representation of parts per thousand."))
         setattr(cls, "g/g",
             PermissibleValue(
                 text="g/g",
@@ -7297,14 +7376,10 @@ class UnitEnum(EnumDefinitionImpl):
             PermissibleValue(
                 text="pg/mL",
                 description="""The Unified Code for Units of Measure (UCUM) representation of picograms per milliliter."""))
-        setattr(cls, "J/Cel",
+        setattr(cls, "1/d",
             PermissibleValue(
-                text="J/Cel",
-                description="The Unified Code for Units of Measure (UCUM) representation of joules per Celsius."))
-        setattr(cls, "uE/m2/s",
-            PermissibleValue(
-                text="uE/m2/s",
-                description="""The Unified Code for Units of Measure (UCUM) representation of microeinsteins per square meter per second."""))
+                text="1/d",
+                description="The Unified Code for Units of Measure (UCUM) representation of per day (frequency)."))
         setattr(cls, "kW/m2",
             PermissibleValue(
                 text="kW/m2",
@@ -7321,10 +7396,22 @@ class UnitEnum(EnumDefinitionImpl):
             PermissibleValue(
                 text="L/h",
                 description="The Unified Code for Units of Measure (UCUM) representation of liters per hour."))
+        setattr(cls, "[pH]",
+            PermissibleValue(
+                text="[pH]",
+                description="The Unified Code for Units of Measure (UCUM) representation of pH units."))
         setattr(cls, "kW/m2/d",
             PermissibleValue(
                 text="kW/m2/d",
                 description="""The Unified Code for Units of Measure (UCUM) representation of kilowatts per square meter per day."""))
+        setattr(cls, "[NTU]",
+            PermissibleValue(
+                text="[NTU]",
+                description="""The Unified Code for Units of Measure (UCUM) representation of Nephelometric Turbidity Units."""))
+        setattr(cls, "[FNU]",
+            PermissibleValue(
+                text="[FNU]",
+                description="""The Unified Code for Units of Measure (UCUM) representation of Formazin Nephelometric Units."""))
         setattr(cls, "m3/min",
             PermissibleValue(
                 text="m3/min",
@@ -7333,6 +7420,94 @@ class UnitEnum(EnumDefinitionImpl):
             PermissibleValue(
                 text="km/h",
                 description="The Unified Code for Units of Measure (UCUM) representation of kilometers per hour."))
+        setattr(cls, "[lb_av]",
+            PermissibleValue(
+                text="[lb_av]",
+                description="The Unified Code for Units of Measure (UCUM) representation of pound (avoirdupois)."))
+        setattr(cls, "kg/kg",
+            PermissibleValue(
+                text="kg/kg",
+                description="The Unified Code for Units of Measure (UCUM) representation of kilogram per kilogram."))
+        setattr(cls, "ug/m3",
+            PermissibleValue(
+                text="ug/m3",
+                description="""The Unified Code for Units of Measure (UCUM) representation of micrograms per cubic meter."""))
+        setattr(cls, "meq/L",
+            PermissibleValue(
+                text="meq/L",
+                description="""The Unified Code for Units of Measure (UCUM) representation of milliequivalents per liter."""))
+        setattr(cls, "lm/m2",
+            PermissibleValue(
+                text="lm/m2",
+                description="""The Unified Code for Units of Measure (UCUM) representation of lumens per square meter."""))
+        setattr(cls, "umol/L/h",
+            PermissibleValue(
+                text="umol/L/h",
+                description="""The Unified Code for Units of Measure (UCUM) representation of micromoles per liter per hour."""))
+        setattr(cls, "g/cm3",
+            PermissibleValue(
+                text="g/cm3",
+                description="""The Unified Code for Units of Measure (UCUM) representation of grams per cubic centimeter."""))
+        setattr(cls, "g/L",
+            PermissibleValue(
+                text="g/L",
+                description="The Unified Code for Units of Measure (UCUM) representation of grams per liter."))
+        setattr(cls, "[g]",
+            PermissibleValue(
+                text="[g]",
+                description="The Unified Code for Units of Measure (UCUM) representation of standard gravity."))
+        setattr(cls, "m/s2",
+            PermissibleValue(
+                text="m/s2",
+                description="""The Unified Code for Units of Measure (UCUM) representation of meters per second squared."""))
+        setattr(cls, "mol/g",
+            PermissibleValue(
+                text="mol/g",
+                description="The Unified Code for Units of Measure (UCUM) representation of moles per gram."))
+        setattr(cls, "g/m2/d",
+            PermissibleValue(
+                text="g/m2/d",
+                description="""The Unified Code for Units of Measure (UCUM) representation of grams per square meter per day."""))
+        setattr(cls, "[sft_i]",
+            PermissibleValue(
+                text="[sft_i]",
+                description="The Unified Code for Units of Measure (UCUM) representation of square feet."))
+        setattr(cls, "[cft_i]",
+            PermissibleValue(
+                text="[cft_i]",
+                description="The Unified Code for Units of Measure (UCUM) representation of cubic feet."))
+        setattr(cls, "mm/a",
+            PermissibleValue(
+                text="mm/a",
+                description="The Unified Code for Units of Measure (UCUM) representation of millimeters per year."))
+        setattr(cls, "erg/cm2/s",
+            PermissibleValue(
+                text="erg/cm2/s",
+                description="""The Unified Code for Units of Measure (UCUM) representation of ergs per square centimeter per second."""))
+        setattr(cls, "g/m2",
+            PermissibleValue(
+                text="g/m2",
+                description="The Unified Code for Units of Measure (UCUM) representation of grams per square meter."))
+        setattr(cls, "L/s",
+            PermissibleValue(
+                text="L/s",
+                description="The Unified Code for Units of Measure (UCUM) representation of liters per second."))
+        setattr(cls, "cm3/cm3",
+            PermissibleValue(
+                text="cm3/cm3",
+                description="""The Unified Code for Units of Measure (UCUM) representation of cubic centimeters per cubic centimeter."""))
+        setattr(cls, "[kn_i]",
+            PermissibleValue(
+                text="[kn_i]",
+                description="""The Unified Code for Units of Measure (UCUM) representation of knot (nautical miles per hour)."""))
+        setattr(cls, "m3/s",
+            PermissibleValue(
+                text="m3/s",
+                description="""The Unified Code for Units of Measure (UCUM) representation of cubic meters per second."""))
+        setattr(cls, "[in_i]",
+            PermissibleValue(
+                text="[in_i]",
+                description="The Unified Code for Units of Measure (UCUM) representation of inch."))
 
 class ExecutionResourceEnum(EnumDefinitionImpl):
 
@@ -8198,6 +8373,46 @@ class FailureWhereEnum(EnumDefinitionImpl):
         description="""The permitted values for describing where in the process, either a lab or analysis workflow step, the failure occurred.""",
     )
 
+class ProtocolForEnum(EnumDefinitionImpl):
+    """
+    The permitted values for describing the type of planned process that a protocol describes.
+    """
+    AnnotatingWorkflow = PermissibleValue(text="AnnotatingWorkflow")
+    ChemicalConversionProcess = PermissibleValue(text="ChemicalConversionProcess")
+    ChromatographicSeparationProcess = PermissibleValue(text="ChromatographicSeparationProcess")
+    CollectingBiosamplesFromSite = PermissibleValue(text="CollectingBiosamplesFromSite")
+    DataEmitterProcess = PermissibleValue(text="DataEmitterProcess")
+    DataGeneration = PermissibleValue(text="DataGeneration")
+    DissolvingProcess = PermissibleValue(text="DissolvingProcess")
+    Extraction = PermissibleValue(text="Extraction")
+    FiltrationProcess = PermissibleValue(text="FiltrationProcess")
+    LibraryPreparation = PermissibleValue(text="LibraryPreparation")
+    MagsAnalysis = PermissibleValue(text="MagsAnalysis")
+    MassSpectrometry = PermissibleValue(text="MassSpectrometry")
+    MaterialProcessing = PermissibleValue(text="MaterialProcessing")
+    MetabolomicsAnalysis = PermissibleValue(text="MetabolomicsAnalysis")
+    MetagenomeAnnotation = PermissibleValue(text="MetagenomeAnnotation")
+    MetagenomeAssembly = PermissibleValue(text="MetagenomeAssembly")
+    MetaproteomicsAnalysis = PermissibleValue(text="MetaproteomicsAnalysis")
+    MetatranscriptomeAnnotation = PermissibleValue(text="MetatranscriptomeAnnotation")
+    MetatranscriptomeAssembly = PermissibleValue(text="MetatranscriptomeAssembly")
+    MetatranscriptomeExpressionAnalysis = PermissibleValue(text="MetatranscriptomeExpressionAnalysis")
+    MixingProcess = PermissibleValue(text="MixingProcess")
+    NomAnalysis = PermissibleValue(text="NomAnalysis")
+    NucleotideSequencing = PermissibleValue(text="NucleotideSequencing")
+    PlannedProcess = PermissibleValue(text="PlannedProcess")
+    Pooling = PermissibleValue(text="Pooling")
+    ReadBasedTaxonomyAnalysis = PermissibleValue(text="ReadBasedTaxonomyAnalysis")
+    ReadQcAnalysis = PermissibleValue(text="ReadQcAnalysis")
+    StorageProcess = PermissibleValue(text="StorageProcess")
+    SubSamplingProcess = PermissibleValue(text="SubSamplingProcess")
+    WorkflowExecution = PermissibleValue(text="WorkflowExecution")
+
+    _defn = EnumDefinition(
+        name="ProtocolForEnum",
+        description="The permitted values for describing the type of planned process that a protocol describes.",
+    )
+
 class ArchStrucEnum(EnumDefinitionImpl):
 
     building = PermissibleValue(text="building")
@@ -10838,7 +11053,7 @@ slots.has_raw_value = Slot(uri=NMDC['attribute_values/has_raw_value'], name="has
                    model_uri=NMDC.has_raw_value, domain=None, range=Optional[str])
 
 slots.has_unit = Slot(uri=NMDC['attribute_values/has_unit'], name="has_unit", curie=NMDC.curie('attribute_values/has_unit'),
-                   model_uri=NMDC.has_unit, domain=None, range=Union[str, "UnitEnum"], mappings = [QUD["unit"], SCHEMA["unitCode"]])
+                   model_uri=NMDC.has_unit, domain=None, range=Optional[str], mappings = [QUD["unit"], SCHEMA["unitCode"]])
 
 slots.type = Slot(uri=RDF.type, name="type", curie=RDF.curie('type'),
                    model_uri=NMDC.type, domain=None, range=Union[str, URIorCURIE])
@@ -10865,6 +11080,21 @@ slots.websites = Slot(uri=NMDC['attribute_values/websites'], name="websites", cu
                    model_uri=NMDC.websites, domain=None, range=Optional[Union[str, list[str]]],
                    pattern=re.compile(r'^[Hh][Tt][Tt][Pp][Ss]?:\/\/(?!.*[Dd][Oo][Ii]\.[Oo][Rr][Gg]).*$'))
 
+slots.has_attribute_label = Slot(uri=NMDC['attribute_values/has_attribute_label'], name="has_attribute_label", curie=NMDC.curie('attribute_values/has_attribute_label'),
+                   model_uri=NMDC.has_attribute_label, domain=None, range=Optional[str])
+
+slots.has_attribute_id = Slot(uri=NMDC['attribute_values/has_attribute_id'], name="has_attribute_id", curie=NMDC.curie('attribute_values/has_attribute_id'),
+                   model_uri=NMDC.has_attribute_id, domain=None, range=Optional[Union[str, URIorCURIE]])
+
+slots.has_quantity_kind_id = Slot(uri=NMDC['attribute_values/has_quantity_kind_id'], name="has_quantity_kind_id", curie=NMDC.curie('attribute_values/has_quantity_kind_id'),
+                   model_uri=NMDC.has_quantity_kind_id, domain=None, range=Optional[Union[str, URIorCURIE]])
+
+slots.has_value_term_id = Slot(uri=NMDC['attribute_values/has_value_term_id'], name="has_value_term_id", curie=NMDC.curie('attribute_values/has_value_term_id'),
+                   model_uri=NMDC.has_value_term_id, domain=None, range=Optional[Union[str, URIorCURIE]])
+
+slots.has_datetime_value = Slot(uri=NMDC['attribute_values/has_datetime_value'], name="has_datetime_value", curie=NMDC.curie('attribute_values/has_datetime_value'),
+                   model_uri=NMDC.has_datetime_value, domain=None, range=Optional[str])
+
 slots.processing_institution_workflow_metadata = Slot(uri=NMDC.processing_institution_workflow_metadata, name="processing_institution_workflow_metadata", curie=NMDC.curie('processing_institution_workflow_metadata'),
                    model_uri=NMDC.processing_institution_workflow_metadata, domain=None, range=Optional[str], mappings = [NCIT["C165211"]])
 
@@ -11116,6 +11346,9 @@ slots.qc_failure_where = Slot(uri=NMDC['basic_classes/qc_failure_where'], name="
 slots.qc_failure_what = Slot(uri=NMDC['basic_classes/qc_failure_what'], name="qc_failure_what", curie=NMDC.curie('basic_classes/qc_failure_what'),
                    model_uri=NMDC.qc_failure_what, domain=None, range=Optional[Union[str, "FailureWhatEnum"]])
 
+slots.protocol_for = Slot(uri=NMDC['basic_classes/protocol_for'], name="protocol_for", curie=NMDC.curie('basic_classes/protocol_for'),
+                   model_uri=NMDC.protocol_for, domain=None, range=Optional[Union[str, "ProtocolForEnum"]])
+
 slots.emsl_store_temp = Slot(uri=NMDC.emsl_store_temp, name="emsl_store_temp", curie=NMDC.curie('emsl_store_temp'),
                    model_uri=NMDC.emsl_store_temp, domain=None, range=Optional[str])
 
@@ -12049,7 +12282,7 @@ slots.mineral_nutr_regm = Slot(uri=MIXS['0000570'], name="mineral_nutr_regm", cu
                    model_uri=NMDC.mineral_nutr_regm, domain=None, range=Optional[Union[Union[dict, TextValue], list[Union[dict, TextValue]]]])
 
 slots.misc_param = Slot(uri=MIXS['0000752'], name="misc_param", curie=MIXS.curie('0000752'),
-                   model_uri=NMDC.misc_param, domain=None, range=Optional[Union[Union[dict, TextValue], list[Union[dict, TextValue]]]])
+                   model_uri=NMDC.misc_param, domain=None, range=Optional[Union[Union[dict, PropertyAssertion], list[Union[dict, PropertyAssertion]]]])
 
 slots.n_alkanes = Slot(uri=MIXS['0000503'], name="n_alkanes", curie=MIXS.curie('0000503'),
                    model_uri=NMDC.n_alkanes, domain=None, range=Optional[Union[Union[dict, TextValue], list[Union[dict, TextValue]]]])
@@ -13224,9 +13457,6 @@ slots.Biosample_al_sat = Slot(uri=MIXS['0000607'], name="Biosample_al_sat", curi
 slots.Biosample_al_sat_meth = Slot(uri=MIXS['0000324'], name="Biosample_al_sat_meth", curie=MIXS.curie('0000324'),
                    model_uri=NMDC.Biosample_al_sat_meth, domain=Biosample, range=Optional[Union[dict, TextValue]])
 
-slots.Biosample_annual_precpt = Slot(uri=MIXS['0000644'], name="Biosample_annual_precpt", curie=MIXS.curie('0000644'),
-                   model_uri=NMDC.Biosample_annual_precpt, domain=Biosample, range=Optional[Union[dict, QuantityValue]])
-
 slots.Biosample_cur_vegetation = Slot(uri=MIXS['0000312'], name="Biosample_cur_vegetation", curie=MIXS.curie('0000312'),
                    model_uri=NMDC.Biosample_cur_vegetation, domain=Biosample, range=Optional[Union[dict, TextValue]])
 
@@ -13257,9 +13487,6 @@ slots.Biosample_tot_carb = Slot(uri=MIXS['0000525'], name="Biosample_tot_carb",
 slots.Biosample_tot_nitro_cont_meth = Slot(uri=MIXS['0000338'], name="Biosample_tot_nitro_cont_meth", curie=MIXS.curie('0000338'),
                    model_uri=NMDC.Biosample_tot_nitro_cont_meth, domain=Biosample, range=Optional[str])
 
-slots.Biosample_tot_nitro_content = Slot(uri=MIXS['0000530'], name="Biosample_tot_nitro_content", curie=MIXS.curie('0000530'),
-                   model_uri=NMDC.Biosample_tot_nitro_content, domain=Biosample, range=Optional[Union[dict, QuantityValue]])
-
 slots.Biosample_tot_org_c_meth = Slot(uri=MIXS['0000337'], name="Biosample_tot_org_c_meth", curie=MIXS.curie('0000337'),
                    model_uri=NMDC.Biosample_tot_org_c_meth, domain=Biosample, range=Optional[Union[dict, TextValue]])
 
@@ -13327,6 +13554,12 @@ slots.GeolocationValue_latitude = Slot(uri=WGS84.lat, name="GeolocationValue_lat
 slots.GeolocationValue_longitude = Slot(uri=WGS84.long, name="GeolocationValue_longitude", curie=WGS84.curie('long'),
                    model_uri=NMDC.GeolocationValue_longitude, domain=GeolocationValue, range=float, mappings = [SCHEMA["longitude"]])
 
+slots.PropertyAssertion_has_raw_value = Slot(uri=NMDC['attribute_values/has_raw_value'], name="PropertyAssertion_has_raw_value", curie=NMDC.curie('attribute_values/has_raw_value'),
+                   model_uri=NMDC.PropertyAssertion_has_raw_value, domain=PropertyAssertion, range=str)
+
+slots.PropertyAssertion_has_unit = Slot(uri=NMDC['attribute_values/has_unit'], name="PropertyAssertion_has_unit", curie=NMDC.curie('attribute_values/has_unit'),
+                   model_uri=NMDC.PropertyAssertion_has_unit, domain=PropertyAssertion, range=Optional[str], mappings = [QUD["unit"], SCHEMA["unitCode"]])
+
 slots.OntologyClass_id = Slot(uri=NMDC.id, name="OntologyClass_id", curie=NMDC.curie('id'),
                    model_uri=NMDC.OntologyClass_id, domain=OntologyClass, range=Union[str, OntologyClassId],
                    pattern=re.compile(r'^[a-zA-Z0-9][a-zA-Z0-9_\.]+:[a-zA-Z0-9_][a-zA-Z0-9_\-\/\.,]*$'))