nmdc-schema 11.12.0rc2__py3-none-any.whl → 11.12.1__py3-none-any.whl

nmdc_schema/nmdc-pydantic.py

@@ -27,7 +27,7 @@ from pydantic import (
 
 
 metamodel_version = "None"
-version = "11.12.0rc2"
+version = "11.12.1"
 
 
 class ConfiguredBaseModel(BaseModel):
@@ -3330,6 +3330,42 @@ class FailureWhereEnum(str, Enum):
     """
 
 
+class ProtocolForEnum(str, Enum):
+    """
+    The permitted values for describing the type of planned process that a protocol describes.
+    """
+    AnnotatingWorkflow = "AnnotatingWorkflow"
+    ChemicalConversionProcess = "ChemicalConversionProcess"
+    ChromatographicSeparationProcess = "ChromatographicSeparationProcess"
+    CollectingBiosamplesFromSite = "CollectingBiosamplesFromSite"
+    DataEmitterProcess = "DataEmitterProcess"
+    DataGeneration = "DataGeneration"
+    DissolvingProcess = "DissolvingProcess"
+    Extraction = "Extraction"
+    FiltrationProcess = "FiltrationProcess"
+    LibraryPreparation = "LibraryPreparation"
+    MagsAnalysis = "MagsAnalysis"
+    MassSpectrometry = "MassSpectrometry"
+    MaterialProcessing = "MaterialProcessing"
+    MetabolomicsAnalysis = "MetabolomicsAnalysis"
+    MetagenomeAnnotation = "MetagenomeAnnotation"
+    MetagenomeAssembly = "MetagenomeAssembly"
+    MetaproteomicsAnalysis = "MetaproteomicsAnalysis"
+    MetatranscriptomeAnnotation = "MetatranscriptomeAnnotation"
+    MetatranscriptomeAssembly = "MetatranscriptomeAssembly"
+    MetatranscriptomeExpressionAnalysis = "MetatranscriptomeExpressionAnalysis"
+    MixingProcess = "MixingProcess"
+    NomAnalysis = "NomAnalysis"
+    NucleotideSequencing = "NucleotideSequencing"
+    PlannedProcess = "PlannedProcess"
+    Pooling = "Pooling"
+    ReadBasedTaxonomyAnalysis = "ReadBasedTaxonomyAnalysis"
+    ReadQcAnalysis = "ReadQcAnalysis"
+    StorageProcess = "StorageProcess"
+    SubSamplingProcess = "SubSamplingProcess"
+    WorkflowExecution = "WorkflowExecution"
+
+
 class SampleTypeEnum(str, Enum):
     soil = "soil"
     soil___water_extract = "soil - water extract"
@@ -3711,7 +3747,7 @@ class PortionOfSubstance(ConfiguredBaseModel):
 
     final_concentration: Optional[QuantityValue] = Field(default=None, description="""When solutions A (containing substance X) and B are combined together, this slot captures the concentration of X in the combination""", json_schema_extra = { "linkml_meta": {'alias': 'final_concentration',
          'annotations': {'storage_units': {'tag': 'storage_units',
-                                           'value': '%|mmol/L|umol/L'}},
+                                           'value': '%|mmol/L|umol/L|mg/L|g/L'}},
          'domain_of': ['PortionOfSubstance'],
          'is_a': 'concentration'} })
     mass: Optional[QuantityValue] = Field(default=None, title="mass", description="""A physical quality that inheres in a bearer by virtue of the proportion of the bearer's amount of matter.""", json_schema_extra = { "linkml_meta": {'alias': 'mass',
@@ -4122,20 +4158,22 @@ class QuantityValue(AttributeValue):
                                                          'syntax {number} {unit}',
                                           'name': 'has_raw_value'},
                         'has_unit': {'description': 'The unit of the quantity',
-                                     'name': 'has_unit'}}})
+                                     'name': 'has_unit',
+                                     'range': 'UnitEnum',
+                                     'required': True}}})
 
     has_maximum_numeric_value: Optional[Decimal] = Field(default=None, description="""The maximum value part, expressed as number, of the quantity value when the value covers a range.""", json_schema_extra = { "linkml_meta": {'alias': 'has_maximum_numeric_value',
-         'domain_of': ['QuantityValue'],
+         'domain_of': ['QuantityValue', 'PropertyAssertion'],
          'is_a': 'has_numeric_value'} })
     has_minimum_numeric_value: Optional[Decimal] = Field(default=None, description="""The minimum value part, expressed as number, of the quantity value when the value covers a range.""", json_schema_extra = { "linkml_meta": {'alias': 'has_minimum_numeric_value',
-         'domain_of': ['QuantityValue'],
+         'domain_of': ['QuantityValue', 'PropertyAssertion'],
          'is_a': 'has_numeric_value'} })
     has_numeric_value: Optional[Decimal] = Field(default=None, description="""The number part of the quantity""", json_schema_extra = { "linkml_meta": {'alias': 'has_numeric_value',
-         'domain_of': ['QuantityValue'],
+         'domain_of': ['QuantityValue', 'PropertyAssertion'],
          'mappings': ['qud:quantityValue', 'schema:value']} })
     has_unit: UnitEnum = Field(default=..., description="""The unit of the quantity""", json_schema_extra = { "linkml_meta": {'alias': 'has_unit',
          'aliases': ['scale'],
-         'domain_of': ['QuantityValue'],
+         'domain_of': ['QuantityValue', 'PropertyAssertion'],
          'mappings': ['qud:unit', 'schema:unitCode']} })
     has_raw_value: Optional[str] = Field(default=None, description="""Unnormalized atomic string representation, should in syntax {number} {unit}""", json_schema_extra = { "linkml_meta": {'alias': 'has_raw_value', 'domain_of': ['AttributeValue']} })
     type: Literal["https://w3id.org/nmdc/QuantityValue","nmdc:QuantityValue"] = Field(default="nmdc:QuantityValue", description="""the class_uri of the class that has been instantiated""", json_schema_extra = { "linkml_meta": {'alias': 'type',
@@ -4543,6 +4581,135 @@ class GeolocationValue(AttributeValue):
                                                              'predicate': 'NARROW_SYNONYM'}}} })
 
 
+class PropertyAssertion(AttributeValue):
+    """
+    A structured record of data that doesn't fit nicely within the constraints of other NMDC AttributeValues. Uses primitive ranges only.
+    """
+    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'nmdc:PropertyAssertion',
+         'comments': ['This class enables flexible metadata capture for properties '
+                      "that don't align with existing, policy-governed slots in NMDC "
+                      'schema.',
+                      'Interoperability note: This approach is aligned with the '
+                      "BERtron schema's 'properties' slot pattern (see "
+                      'https://github.com/ber-data/bertron-schema), which uses any_of '
+                      "to support both TextValue and QuantityValue ranges. NMDC's "
+                      'PropertyAssertion provides a more granular approach by using '
+                      'primitive types with optional semantic annotations, enabling '
+                      'better validation while maintaining flexibility for diverse '
+                      'metadata types.',
+                      'PropertyAssertion supports both categorical values (via '
+                      'has_value_term_id) and numeric values (via has_numeric_value '
+                      'with optional min/max ranges), along with temporal '
+                      '(has_datetime_value) and boolean (has_boolean_value) data '
+                      'types.'],
+         'examples': [{'description': "Data provided from submission that doesn't "
+                                      'conform to required abs_air_humidity units',
+                       'object': {'has_attribute_id': 'MIXS:0000122',
+                                  'has_attribute_label': 'absolute air humidity',
+                                  'has_numeric_value': 50,
+                                  'has_raw_value': '50 kPa',
+                                  'has_unit': 'kPa',
+                                  'type': 'nmdc:PropertyAssertion'}},
+                      {'description': "Data provided from submission that doesn't "
+                                      'conform to required UCUM unit',
+                       'object': {'has_attribute_id': 'MIXS:0000119',
+                                  'has_attribute_label': 'dissolved oxygen',
+                                  'has_numeric_value': 5.5,
+                                  'has_raw_value': '5.5 mL/L',
+                                  'has_unit': 'mL/L',
+                                  'type': 'nmdc:PropertyAssertion'}},
+                      {'description': 'Unit provided is invalid for UCUM and standard',
+                       'object': {'has_attribute_id': 'MIXS:0000112',
+                                  'has_attribute_label': 'solar irradiance',
+                                  'has_numeric_value': 250,
+                                  'has_raw_value': '250 W/m2',
+                                  'has_unit': 'W/m2',
+                                  'type': 'nmdc:PropertyAssertion'}}],
+         'from_schema': 'https://w3id.org/nmdc/nmdc',
+         'slot_usage': {'has_raw_value': {'description': 'Original contributor string '
+                                                         'representation (unparsed)',
+                                          'name': 'has_raw_value',
+                                          'required': True},
+                        'has_unit': {'description': 'UCUM unit code (required only '
+                                                    'when numeric value is present)',
+                                     'name': 'has_unit',
+                                     'required': False}}})
+
+    has_attribute_label: Optional[str] = Field(default=None, description="""Human-readable label for the property (e.g., MIxS label, ENVO term label).""", json_schema_extra = { "linkml_meta": {'alias': 'has_attribute_label',
+         'comments': ['This provides a human-friendly name for the asserted property. '
+                      'For example, "bicarbonate ion concentration" or "total '
+                      'phosphorus". The label helps with readability and data '
+                      'discovery.'],
+         'domain_of': ['PropertyAssertion']} })
+    has_attribute_id: Optional[str] = Field(default=None, description="""CURIE or IRI for the property (MIxS slot, NMDC slot, ENVO/OBI term, etc.).""", json_schema_extra = { "linkml_meta": {'alias': 'has_attribute_id',
+         'comments': ['This provides a resolvable identifier for the property being '
+                      'asserted. Examples include MIXS:0000117 for total phosphorus, '
+                      'or ENVO:01001357 for bicarbonate ion concentration.',
+                      'Prefer using standard ontology terms (ENVO, PATO, OBI, etc.) or '
+                      'MIxS identifiers when available to enhance interoperability.'],
+         'domain_of': ['PropertyAssertion']} })
+    has_quantity_kind_id: Optional[str] = Field(default=None, description="""Optional CURIE or IRI for the physical quantity kind (e.g., qudt:QuantityKind).""", json_schema_extra = { "linkml_meta": {'alias': 'has_quantity_kind_id',
+         'comments': ['This slot enables precise semantic description of what physical '
+                      'quantity is being measured, independent of the specific units '
+                      'used. For example, qudt:MassConcentration or qudt:Temperature.',
+                      'Using quantity kind identifiers from QUDT or similar '
+                      'vocabularies improves data integration and enables automated '
+                      'unit conversion.'],
+         'domain_of': ['PropertyAssertion']} })
+    has_value_term_id: Optional[str] = Field(default=None, description="""CURIE or IRI for categorical values (ENVO, PATO, METPO, etc.).""", json_schema_extra = { "linkml_meta": {'alias': 'has_value_term_id',
+         'comments': ['Use this slot when the value of the property is a controlled '
+                      'vocabulary term rather than a numeric or free-text value. For '
+                      'example, ENVO:00002297 for "desert ecosystem" or PATO:0001199 '
+                      'for "dry".'],
+         'domain_of': ['PropertyAssertion']} })
+    has_boolean_value: Optional[bool] = Field(default=None, description="""Links a quantity value to a boolean""", json_schema_extra = { "linkml_meta": {'alias': 'has_boolean_value', 'domain_of': ['PropertyAssertion']} })
+    has_datetime_value: Optional[str] = Field(default=None, description="""Date-time value for the property in ISO-8601 format.""", json_schema_extra = { "linkml_meta": {'alias': 'has_datetime_value',
+         'comments': ['Use this slot for temporal properties. The value should follow '
+                      'ISO-8601 format (e.g., "2025-06-12T14:30:00Z").'],
+         'domain_of': ['PropertyAssertion']} })
+    has_numeric_value: Optional[Decimal] = Field(default=None, description="""Links a quantity value to a number""", json_schema_extra = { "linkml_meta": {'alias': 'has_numeric_value',
+         'domain_of': ['QuantityValue', 'PropertyAssertion'],
+         'mappings': ['qud:quantityValue', 'schema:value']} })
+    has_minimum_numeric_value: Optional[Decimal] = Field(default=None, description="""The minimum value part, expressed as number, of the quantity value when the value covers a range.""", json_schema_extra = { "linkml_meta": {'alias': 'has_minimum_numeric_value',
+         'domain_of': ['QuantityValue', 'PropertyAssertion'],
+         'is_a': 'has_numeric_value'} })
+    has_maximum_numeric_value: Optional[Decimal] = Field(default=None, description="""The maximum value part, expressed as number, of the quantity value when the value covers a range.""", json_schema_extra = { "linkml_meta": {'alias': 'has_maximum_numeric_value',
+         'domain_of': ['QuantityValue', 'PropertyAssertion'],
+         'is_a': 'has_numeric_value'} })
+    has_unit: Optional[str] = Field(default=None, description="""UCUM unit code (required only when numeric value is present)""", json_schema_extra = { "linkml_meta": {'alias': 'has_unit',
+         'aliases': ['scale'],
+         'domain_of': ['QuantityValue', 'PropertyAssertion'],
+         'mappings': ['qud:unit', 'schema:unitCode']} })
+    has_raw_value: str = Field(default=..., description="""Original contributor string representation (unparsed)""", json_schema_extra = { "linkml_meta": {'alias': 'has_raw_value', 'domain_of': ['AttributeValue']} })
+    type: Literal["https://w3id.org/nmdc/PropertyAssertion","nmdc:PropertyAssertion"] = Field(default="nmdc:PropertyAssertion", description="""the class_uri of the class that has been instantiated""", json_schema_extra = { "linkml_meta": {'alias': 'type',
+         'designates_type': True,
+         'domain_of': ['EukEval',
+                       'FunctionalAnnotationAggMember',
+                       'MobilePhaseSegment',
+                       'PortionOfSubstance',
+                       'MagBin',
+                       'MetaboliteIdentification',
+                       'GenomeFeature',
+                       'FunctionalAnnotation',
+                       'AttributeValue',
+                       'NamedThing',
+                       'OntologyRelation',
+                       'FailureCategorization',
+                       'Protocol',
+                       'CreditAssociation',
+                       'Doi'],
+         'examples': [{'value': 'nmdc:Biosample'}, {'value': 'nmdc:Study'}],
+         'notes': ['makes it easier to read example data files',
+                   'required for polymorphic MongoDB collections'],
+         'see_also': ['https://github.com/microbiomedata/nmdc-schema/issues/1048',
+                      'https://github.com/microbiomedata/nmdc-schema/issues/1233',
+                      'https://github.com/microbiomedata/nmdc-schema/issues/248'],
+         'slot_uri': 'rdf:type',
+         'structured_aliases': {'workflow_execution_class': {'contexts': ['https://bitbucket.org/berkeleylab/jgi-jat/macros/nmdc_metadata.yaml'],
+                                                             'literal_form': 'workflow_execution_class',
+                                                             'predicate': 'NARROW_SYNONYM'}}} })
+
+
 class NamedThing(ConfiguredBaseModel):
     """
     a databased entity or concept/class
@@ -8777,7 +8944,7 @@ class Biosample(Sample):
          'slot_uri': 'MIXS:0000570',
          'string_serialization': '{text};{float} '
                                  '{unit};{Rn/start_time/end_time/duration}'} })
-    misc_param: Optional[list[TextValue]] = Field(default=None, title="miscellaneous parameter", description="""Any other measurement performed or parameter collected, that is not listed here""", json_schema_extra = { "linkml_meta": {'alias': 'misc_param',
+    misc_param: Optional[list[PropertyAssertion]] = Field(default=None, title="miscellaneous parameter", description="""Structured miscellaneous property assertions for this Biosample. Use when a value cannot cleanly fit an existing, policy-governed slot.""", json_schema_extra = { "linkml_meta": {'alias': 'misc_param',
          'aliases': ['miscellaneous parameter'],
          'annotations': {'expected_value': {'tag': 'expected_value',
                                             'value': 'parameter name;measurement '
@@ -8788,7 +8955,8 @@ class Biosample(Sample):
                                 'kilogram'}],
          'is_a': 'core field',
          'slot_uri': 'MIXS:0000752',
-         'string_serialization': '{text};{float} {unit}'} })
+         'string_serialization': '{text};{float} {unit}',
+         'todos': ['This slot should not be available in the submission portal.']} })
     n_alkanes: Optional[list[TextValue]] = Field(default=None, title="n-alkanes", description="""Concentration of n-alkanes; can include multiple n-alkanes""", json_schema_extra = { "linkml_meta": {'alias': 'n_alkanes',
          'aliases': ['n-alkanes'],
          'annotations': {'expected_value': {'tag': 'expected_value',
@@ -11848,7 +12016,7 @@ class Biosample(Sample):
     analysis_type: Optional[list[AnalysisTypeEnum]] = Field(default=None, title="analysis/data type", description="""Select all the data types associated or available for this biosample""", json_schema_extra = { "linkml_meta": {'alias': 'analysis_type',
          'comments': ['MIxS:investigation_type was included as a `see_also` but that '
                       "term doesn't resolve any more"],
-         'domain_of': ['Biosample'],
+         'domain_of': ['Biosample', 'Protocol'],
          'examples': [{'value': 'metagenomics; metabolomics; metaproteomics'}],
          'rank': 3,
          'recommended': True,
@@ -12596,7 +12764,7 @@ class FieldResearchSite(Site):
 
 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.
     """
     linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'aliases': ['device'],
          'class_uri': 'nmdc:Instrument',
@@ -12605,7 +12773,11 @@ class Instrument(MaterialEntity):
          'slot_usage': {'id': {'name': 'id',
                                'pattern': '^(nmdc):inst-([0-9][a-z]{0,6}[0-9])-([A-Za-z0-9]{1,})$',
                                'structured_pattern': {'interpolated': True,
-                                                      'syntax': '{id_nmdc_prefix}:inst-{id_shoulder}-{id_blade}$'}}}})
+                                                      'syntax': '{id_nmdc_prefix}:inst-{id_shoulder}-{id_blade}$'}}},
+         'unique_keys': {'main': {'description': 'A unique instrument is defined by '
+                                                 'its vendor and model.',
+                                  'unique_key_name': 'main',
+                                  'unique_key_slots': ['vendor', 'model']}}})
 
     vendor: Optional[InstrumentVendorEnum] = Field(default=None, json_schema_extra = { "linkml_meta": {'alias': 'vendor', 'domain_of': ['Instrument']} })
     model: Optional[InstrumentModelEnum] = Field(default=None, json_schema_extra = { "linkml_meta": {'alias': 'model', 'domain_of': ['Instrument']} })
@@ -15209,6 +15381,15 @@ class Protocol(ConfiguredBaseModel):
     description: Optional[str] = Field(default=None, description="""a human-readable description of a thing""", json_schema_extra = { "linkml_meta": {'alias': 'description',
          'domain_of': ['ImageValue', 'NamedThing', 'Protocol'],
          'slot_uri': 'dcterms:description'} })
+    protocol_for: Optional[ProtocolForEnum] = Field(default=None, description="""The type of planned process that the protocol describes.""", json_schema_extra = { "linkml_meta": {'alias': 'protocol_for', 'domain_of': ['Protocol']} })
+    analysis_type: Optional[list[AnalysisTypeEnum]] = Field(default=None, title="analysis/data type", description="""Select all the data types associated or available for this biosample""", json_schema_extra = { "linkml_meta": {'alias': 'analysis_type',
+         'comments': ['MIxS:investigation_type was included as a `see_also` but that '
+                      "term doesn't resolve any more"],
+         'domain_of': ['Biosample', 'Protocol'],
+         'examples': [{'value': 'metagenomics; metabolomics; metaproteomics'}],
+         'rank': 3,
+         'recommended': True,
+         'slot_group': 'Sample ID'} })
 
 
 class CreditAssociation(ConfiguredBaseModel):
@@ -21054,6 +21235,7 @@ TimestampValue.model_rebuild()
 ControlledTermValue.model_rebuild()
 ControlledIdentifiedTermValue.model_rebuild()
 GeolocationValue.model_rebuild()
+PropertyAssertion.model_rebuild()
 NamedThing.model_rebuild()
 GeneProduct.model_rebuild()
 OntologyClass.model_rebuild()

nmdc_schema/nmdc.py

@@ -1,5 +1,5 @@
 # Auto generated from nmdc.yaml by pythongen.py version: 0.0.1
-# Generation date: 2025-10-01T19:32:11
+# Generation date: 2025-10-09T18:05:09
 # 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.12.0rc2"
+version = "11.12.1"
 
 # 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)
 
 
@@ -8295,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")
@@ -10935,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])
@@ -10962,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"]])
 
@@ -11213,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])
 
@@ -12146,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]]]])
@@ -13418,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_\-\/\.,]*$'))