acryl-datahub-cloud 0.3.6.9rc2__py3-none-any.whl → 0.3.7__py3-none-any.whl

acryl_datahub_cloud/metadata/schema_classes.py

@@ -277,18 +277,21 @@ class DataHubActionConfigClass(DictWrapper):
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.action.DataHubActionConfig")
     def __init__(self,
         recipe: str,
+        executorId: Union[None, str]=None,
     ):
         super().__init__()
         
         self.recipe = recipe
+        self.executorId = executorId
     
     def _restore_defaults(self) -> None:
         self.recipe = str()
+        self.executorId = self.RECORD_SCHEMA.fields_dict["executorId"].default
     
     
     @property
     def recipe(self) -> str:
-        """The JSON recipe to use for ingestion"""
+        """The JSON recipe to use for the automation"""
         return self._inner_dict.get('recipe')  # type: ignore
     
     @recipe.setter
@@ -296,6 +299,16 @@ class DataHubActionConfigClass(DictWrapper):
         self._inner_dict['recipe'] = value
     
     
+    @property
+    def executorId(self) -> Union[None, str]:
+        """The id of the executor to use to execute the automation. Defaults to 'default' (runs locally)"""
+        return self._inner_dict.get('executorId')  # type: ignore
+    
+    @executorId.setter
+    def executorId(self, value: Union[None, str]) -> None:
+        self._inner_dict['executorId'] = value
+    
+    
 class DataHubActionInfoClass(_Aspect):
     """Info about a DataHub Action Pipeline"""
 
@@ -708,6 +721,8 @@ class ActionRequestInfoClass(_Aspect):
         subResource: Union[None, str]=None,
         params: Union[None, "ActionRequestParamsClass"]=None,
         dueDate: Union[None, int]=None,
+        origin: Optional[Union[Union[str, "ActionRequestOriginClass"], None]]=None,
+        inferenceMetadata: Union[None, "InferenceMetadataClass"]=None,
     ):
         super().__init__()
         
@@ -723,6 +738,12 @@ class ActionRequestInfoClass(_Aspect):
         self.created = created
         self.createdBy = createdBy
         self.dueDate = dueDate
+        if origin is None:
+            # default: 'MANUAL'
+            self.origin = self.RECORD_SCHEMA.fields_dict["origin"].default
+        else:
+            self.origin = origin
+        self.inferenceMetadata = inferenceMetadata
     
     def _restore_defaults(self) -> None:
         self.type = str()
@@ -737,6 +758,8 @@ class ActionRequestInfoClass(_Aspect):
         self.created = int()
         self.createdBy = str()
         self.dueDate = self.RECORD_SCHEMA.fields_dict["dueDate"].default
+        self.origin = self.RECORD_SCHEMA.fields_dict["origin"].default
+        self.inferenceMetadata = self.RECORD_SCHEMA.fields_dict["inferenceMetadata"].default
     
     
     @property
@@ -859,6 +882,37 @@ class ActionRequestInfoClass(_Aspect):
         self._inner_dict['dueDate'] = value
     
     
+    @property
+    def origin(self) -> Union[Union[str, "ActionRequestOriginClass"], None]:
+        """The origin of the action request"""
+        return self._inner_dict.get('origin')  # type: ignore
+    
+    @origin.setter
+    def origin(self, value: Union[Union[str, "ActionRequestOriginClass"], None]) -> None:
+        self._inner_dict['origin'] = value
+    
+    
+    @property
+    def inferenceMetadata(self) -> Union[None, "InferenceMetadataClass"]:
+        """Additional inference metadata. Optionally provided if the origin is INFERRED."""
+        return self._inner_dict.get('inferenceMetadata')  # type: ignore
+    
+    @inferenceMetadata.setter
+    def inferenceMetadata(self, value: Union[None, "InferenceMetadataClass"]) -> None:
+        self._inner_dict['inferenceMetadata'] = value
+    
+    
+class ActionRequestOriginClass(object):
+    """The origin type of an Action Request"""
+    
+    MANUAL = "MANUAL"
+    """The Action Request was created by the user or group via the API or UI"""
+    
+    INFERRED = "INFERRED"
+    """The Action Request was inferred by an inference pipeline, e.g. DataHub AI."""
+    
+    
+    
 class ActionRequestParamsClass(DictWrapper):
     """Parameters provided with a particular action request. Only one of the fields will be populated,
     depending on the action request type."""
@@ -1261,6 +1315,195 @@ class TagProposalClass(DictWrapper):
         self._inner_dict['tag'] = value
     
     
+class AiInferenceMetadataClass(_Aspect):
+    """AI Inference Metadata of various types."""
+
+
+    ASPECT_NAME = 'aiInferenceMetadata'
+    ASPECT_INFO = {}
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.ai.AiInferenceMetadata")
+
+    def __init__(self,
+        glossaryTermsInference: Union[None, "GlossaryTermsInferenceMetadataClass"]=None,
+    ):
+        super().__init__()
+        
+        self.glossaryTermsInference = glossaryTermsInference
+    
+    def _restore_defaults(self) -> None:
+        self.glossaryTermsInference = self.RECORD_SCHEMA.fields_dict["glossaryTermsInference"].default
+    
+    
+    @property
+    def glossaryTermsInference(self) -> Union[None, "GlossaryTermsInferenceMetadataClass"]:
+        """Information about a glossary terms inference."""
+        return self._inner_dict.get('glossaryTermsInference')  # type: ignore
+    
+    @glossaryTermsInference.setter
+    def glossaryTermsInference(self, value: Union[None, "GlossaryTermsInferenceMetadataClass"]) -> None:
+        self._inner_dict['glossaryTermsInference'] = value
+    
+    
+class EntityInferenceMetadataClass(_Aspect):
+    """AI Inference Metadata for a specific entity."""
+
+
+    ASPECT_NAME = 'entityInferenceMetadata'
+    ASPECT_INFO = {}
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.ai.EntityInferenceMetadata")
+
+    def __init__(self,
+        glossaryTermsInference: Union[None, "InferenceGroupMetadataClass"]=None,
+    ):
+        super().__init__()
+        
+        self.glossaryTermsInference = glossaryTermsInference
+    
+    def _restore_defaults(self) -> None:
+        self.glossaryTermsInference = self.RECORD_SCHEMA.fields_dict["glossaryTermsInference"].default
+    
+    
+    @property
+    def glossaryTermsInference(self) -> Union[None, "InferenceGroupMetadataClass"]:
+        """Information about a group of inferences made for Glossary Terms."""
+        return self._inner_dict.get('glossaryTermsInference')  # type: ignore
+    
+    @glossaryTermsInference.setter
+    def glossaryTermsInference(self, value: Union[None, "InferenceGroupMetadataClass"]) -> None:
+        self._inner_dict['glossaryTermsInference'] = value
+    
+    
+class GlossaryTermsInferenceMetadataClass(DictWrapper):
+    # No docs available.
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.ai.GlossaryTermsInferenceMetadata")
+    def __init__(self,
+        lastInferredAt: int,
+        version: int,
+    ):
+        super().__init__()
+        
+        self.lastInferredAt = lastInferredAt
+        self.version = version
+    
+    def _restore_defaults(self) -> None:
+        self.lastInferredAt = int()
+        self.version = int()
+    
+    
+    @property
+    def lastInferredAt(self) -> int:
+        """Timestamp of the last inference in milliseconds."""
+        return self._inner_dict.get('lastInferredAt')  # type: ignore
+    
+    @lastInferredAt.setter
+    def lastInferredAt(self, value: int) -> None:
+        self._inner_dict['lastInferredAt'] = value
+    
+    
+    @property
+    def version(self) -> int:
+        """Monotonically incrementing version number. Once bumped, will re-trigger a new inference."""
+        return self._inner_dict.get('version')  # type: ignore
+    
+    @version.setter
+    def version(self, value: int) -> None:
+        self._inner_dict['version'] = value
+    
+    
+class InferenceGroupMetadataClass(DictWrapper):
+    """Reusable metadata about a group of inferences of the same type."""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.ai.InferenceGroupMetadata")
+    def __init__(self,
+        lastInferredAt: int,
+        version: int,
+    ):
+        super().__init__()
+        
+        self.lastInferredAt = lastInferredAt
+        self.version = version
+    
+    def _restore_defaults(self) -> None:
+        self.lastInferredAt = int()
+        self.version = int()
+    
+    
+    @property
+    def lastInferredAt(self) -> int:
+        """Timestamp of the last inference in milliseconds."""
+        return self._inner_dict.get('lastInferredAt')  # type: ignore
+    
+    @lastInferredAt.setter
+    def lastInferredAt(self, value: int) -> None:
+        self._inner_dict['lastInferredAt'] = value
+    
+    
+    @property
+    def version(self) -> int:
+        """Monotonically incrementing version number. Once bumped, will re-trigger a new inference."""
+        return self._inner_dict.get('version')  # type: ignore
+    
+    @version.setter
+    def version(self, value: int) -> None:
+        self._inner_dict['version'] = value
+    
+    
+class InferenceMetadataClass(DictWrapper):
+    """Reusable metadata about an individual inference - i.e. a single glossary term, tag, description, etc."""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.ai.InferenceMetadata")
+    def __init__(self,
+        lastInferredAt: int,
+        version: int,
+        confidenceLevel: Union[None, int]=None,
+    ):
+        super().__init__()
+        
+        self.lastInferredAt = lastInferredAt
+        self.version = version
+        self.confidenceLevel = confidenceLevel
+    
+    def _restore_defaults(self) -> None:
+        self.lastInferredAt = int()
+        self.version = int()
+        self.confidenceLevel = self.RECORD_SCHEMA.fields_dict["confidenceLevel"].default
+    
+    
+    @property
+    def lastInferredAt(self) -> int:
+        """Timestamp of the last inference in milliseconds."""
+        return self._inner_dict.get('lastInferredAt')  # type: ignore
+    
+    @lastInferredAt.setter
+    def lastInferredAt(self, value: int) -> None:
+        self._inner_dict['lastInferredAt'] = value
+    
+    
+    @property
+    def version(self) -> int:
+        """Monotonically incrementing version number. Once bumped, will re-trigger a new inference."""
+        return self._inner_dict.get('version')  # type: ignore
+    
+    @version.setter
+    def version(self, value: int) -> None:
+        self._inner_dict['version'] = value
+    
+    
+    @property
+    def confidenceLevel(self) -> Union[None, int]:
+        """Numeric confidence level of the inference that was made.
+    
+       0 = Low Confidence
+       1 = Medium Confidence
+       2 = High Confidence"""
+        return self._inner_dict.get('confidenceLevel')  # type: ignore
+    
+    @confidenceLevel.setter
+    def confidenceLevel(self, value: Union[None, int]) -> None:
+        self._inner_dict['confidenceLevel'] = value
+    
+    
 class AnomalyInfoClass(_Aspect):
     """Information about an anomaly raised on an asset."""
 
@@ -1787,6 +2030,265 @@ class AssertionAdjustmentSettingsClass(DictWrapper):
         self._inner_dict['context'] = value
     
     
+class AssertionAnalyticsRunEventClass(_Aspect):
+    """An event representing the current status of evaluating an assertion on a batch.
+    This should be derrived from {@link AssertionRunEvent}.
+    
+    It represents the subset of data used for analytics, and hydrates extra fields for filtering"""
+
+
+    ASPECT_NAME = 'assertionAnalyticsRunEvent'
+    ASPECT_TYPE = 'timeseries'
+    ASPECT_INFO = {}
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.assertion.AssertionAnalyticsRunEvent")
+
+    def __init__(self,
+        type: Union[str, "AssertionTypeClass"],
+        timestampMillis: int,
+        runId: str,
+        asserteeUrn: str,
+        assertionUrn: str,
+        status: Union[str, "AssertionRunStatusClass"],
+        parentDomains: Union[None, List[str]]=None,
+        parentDataProducts: Union[None, List[str]]=None,
+        parentGlobalTags: Union[None, List["TagAssociationClass"]]=None,
+        parentOwners: Union[None, List[str]]=None,
+        parentDataPlatform: Union[None, str]=None,
+        parentDataPlatformInstance: Union[None, str]=None,
+        result: Union[None, "AssertionResultClass"]=None,
+        runtimeContext: Union[None, Dict[str, str]]=None,
+        batchSpec: Union[None, "BatchSpecClass"]=None,
+        eventGranularity: Union[None, "TimeWindowSizeClass"]=None,
+        partitionSpec: Optional[Union["PartitionSpecClass", None]]=None,
+        messageId: Union[None, str]=None,
+    ):
+        super().__init__()
+        
+        self.type = type
+        self.parentDomains = parentDomains
+        self.parentDataProducts = parentDataProducts
+        self.parentGlobalTags = parentGlobalTags
+        self.parentOwners = parentOwners
+        self.parentDataPlatform = parentDataPlatform
+        self.parentDataPlatformInstance = parentDataPlatformInstance
+        self.timestampMillis = timestampMillis
+        self.runId = runId
+        self.asserteeUrn = asserteeUrn
+        self.assertionUrn = assertionUrn
+        self.status = status
+        self.result = result
+        self.runtimeContext = runtimeContext
+        self.batchSpec = batchSpec
+        self.eventGranularity = eventGranularity
+        if partitionSpec is None:
+            # default: {'partition': 'FULL_TABLE_SNAPSHOT', 'type': 'FULL_TABLE', 'timePartition': None}
+            self.partitionSpec = _json_converter.from_json_object(self.RECORD_SCHEMA.fields_dict["partitionSpec"].default, writers_schema=self.RECORD_SCHEMA.fields_dict["partitionSpec"].type)
+        else:
+            self.partitionSpec = partitionSpec
+        self.messageId = messageId
+    
+    def _restore_defaults(self) -> None:
+        self.type = AssertionTypeClass.DATASET
+        self.parentDomains = self.RECORD_SCHEMA.fields_dict["parentDomains"].default
+        self.parentDataProducts = self.RECORD_SCHEMA.fields_dict["parentDataProducts"].default
+        self.parentGlobalTags = self.RECORD_SCHEMA.fields_dict["parentGlobalTags"].default
+        self.parentOwners = self.RECORD_SCHEMA.fields_dict["parentOwners"].default
+        self.parentDataPlatform = self.RECORD_SCHEMA.fields_dict["parentDataPlatform"].default
+        self.parentDataPlatformInstance = self.RECORD_SCHEMA.fields_dict["parentDataPlatformInstance"].default
+        self.timestampMillis = int()
+        self.runId = str()
+        self.asserteeUrn = str()
+        self.assertionUrn = str()
+        self.status = AssertionRunStatusClass.COMPLETE
+        self.result = self.RECORD_SCHEMA.fields_dict["result"].default
+        self.runtimeContext = self.RECORD_SCHEMA.fields_dict["runtimeContext"].default
+        self.batchSpec = self.RECORD_SCHEMA.fields_dict["batchSpec"].default
+        self.eventGranularity = self.RECORD_SCHEMA.fields_dict["eventGranularity"].default
+        self.partitionSpec = _json_converter.from_json_object(self.RECORD_SCHEMA.fields_dict["partitionSpec"].default, writers_schema=self.RECORD_SCHEMA.fields_dict["partitionSpec"].type)
+        self.messageId = self.RECORD_SCHEMA.fields_dict["messageId"].default
+    
+    
+    @property
+    def type(self) -> Union[str, "AssertionTypeClass"]:
+        """Type of assertion."""
+        return self._inner_dict.get('type')  # type: ignore
+    
+    @type.setter
+    def type(self, value: Union[str, "AssertionTypeClass"]) -> None:
+        self._inner_dict['type'] = value
+    
+    
+    @property
+    def parentDomains(self) -> Union[None, List[str]]:
+        """The Domains attached to the entity's parent Asset"""
+        return self._inner_dict.get('parentDomains')  # type: ignore
+    
+    @parentDomains.setter
+    def parentDomains(self, value: Union[None, List[str]]) -> None:
+        self._inner_dict['parentDomains'] = value
+    
+    
+    @property
+    def parentDataProducts(self) -> Union[None, List[str]]:
+        """The Data Products attached to the entity's parent Asset"""
+        return self._inner_dict.get('parentDataProducts')  # type: ignore
+    
+    @parentDataProducts.setter
+    def parentDataProducts(self, value: Union[None, List[str]]) -> None:
+        self._inner_dict['parentDataProducts'] = value
+    
+    
+    @property
+    def parentGlobalTags(self) -> Union[None, List["TagAssociationClass"]]:
+        """The Tags attached to the entity's parent Asset"""
+        return self._inner_dict.get('parentGlobalTags')  # type: ignore
+    
+    @parentGlobalTags.setter
+    def parentGlobalTags(self, value: Union[None, List["TagAssociationClass"]]) -> None:
+        self._inner_dict['parentGlobalTags'] = value
+    
+    
+    @property
+    def parentOwners(self) -> Union[None, List[str]]:
+        """Parent Owner URN, e.g. urn:li:corpuser:ldap, urn:li:corpGroup:group_name, and urn:li:multiProduct:mp_name
+    (Caveat: only corpuser is currently supported in the frontend.)"""
+        return self._inner_dict.get('parentOwners')  # type: ignore
+    
+    @parentOwners.setter
+    def parentOwners(self, value: Union[None, List[str]]) -> None:
+        self._inner_dict['parentOwners'] = value
+    
+    
+    @property
+    def parentDataPlatform(self) -> Union[None, str]:
+        """Data Platform for parent"""
+        return self._inner_dict.get('parentDataPlatform')  # type: ignore
+    
+    @parentDataPlatform.setter
+    def parentDataPlatform(self, value: Union[None, str]) -> None:
+        self._inner_dict['parentDataPlatform'] = value
+    
+    
+    @property
+    def parentDataPlatformInstance(self) -> Union[None, str]:
+        """Instance of the parent's data platform (e.g. db instance)"""
+        return self._inner_dict.get('parentDataPlatformInstance')  # type: ignore
+    
+    @parentDataPlatformInstance.setter
+    def parentDataPlatformInstance(self, value: Union[None, str]) -> None:
+        self._inner_dict['parentDataPlatformInstance'] = value
+    
+    
+    @property
+    def timestampMillis(self) -> int:
+        """The event timestamp field as epoch at UTC in milliseconds."""
+        return self._inner_dict.get('timestampMillis')  # type: ignore
+    
+    @timestampMillis.setter
+    def timestampMillis(self, value: int) -> None:
+        self._inner_dict['timestampMillis'] = value
+    
+    
+    @property
+    def runId(self) -> str:
+        """ Native (platform-specific) identifier for this run"""
+        return self._inner_dict.get('runId')  # type: ignore
+    
+    @runId.setter
+    def runId(self, value: str) -> None:
+        self._inner_dict['runId'] = value
+    
+    
+    @property
+    def asserteeUrn(self) -> str:
+        # No docs available.
+        return self._inner_dict.get('asserteeUrn')  # type: ignore
+    
+    @asserteeUrn.setter
+    def asserteeUrn(self, value: str) -> None:
+        self._inner_dict['asserteeUrn'] = value
+    
+    
+    @property
+    def assertionUrn(self) -> str:
+        # No docs available.
+        return self._inner_dict.get('assertionUrn')  # type: ignore
+    
+    @assertionUrn.setter
+    def assertionUrn(self, value: str) -> None:
+        self._inner_dict['assertionUrn'] = value
+    
+    
+    @property
+    def status(self) -> Union[str, "AssertionRunStatusClass"]:
+        """The status of the assertion run as per this timeseries event."""
+        return self._inner_dict.get('status')  # type: ignore
+    
+    @status.setter
+    def status(self, value: Union[str, "AssertionRunStatusClass"]) -> None:
+        self._inner_dict['status'] = value
+    
+    
+    @property
+    def result(self) -> Union[None, "AssertionResultClass"]:
+        """Results of assertion, present if the status is COMPLETE"""
+        return self._inner_dict.get('result')  # type: ignore
+    
+    @result.setter
+    def result(self, value: Union[None, "AssertionResultClass"]) -> None:
+        self._inner_dict['result'] = value
+    
+    
+    @property
+    def runtimeContext(self) -> Union[None, Dict[str, str]]:
+        """Runtime parameters of evaluation"""
+        return self._inner_dict.get('runtimeContext')  # type: ignore
+    
+    @runtimeContext.setter
+    def runtimeContext(self, value: Union[None, Dict[str, str]]) -> None:
+        self._inner_dict['runtimeContext'] = value
+    
+    
+    @property
+    def batchSpec(self) -> Union[None, "BatchSpecClass"]:
+        """Specification of the batch which this run is evaluating"""
+        return self._inner_dict.get('batchSpec')  # type: ignore
+    
+    @batchSpec.setter
+    def batchSpec(self, value: Union[None, "BatchSpecClass"]) -> None:
+        self._inner_dict['batchSpec'] = value
+    
+    
+    @property
+    def eventGranularity(self) -> Union[None, "TimeWindowSizeClass"]:
+        """Granularity of the event if applicable"""
+        return self._inner_dict.get('eventGranularity')  # type: ignore
+    
+    @eventGranularity.setter
+    def eventGranularity(self, value: Union[None, "TimeWindowSizeClass"]) -> None:
+        self._inner_dict['eventGranularity'] = value
+    
+    
+    @property
+    def partitionSpec(self) -> Union["PartitionSpecClass", None]:
+        """The optional partition specification."""
+        return self._inner_dict.get('partitionSpec')  # type: ignore
+    
+    @partitionSpec.setter
+    def partitionSpec(self, value: Union["PartitionSpecClass", None]) -> None:
+        self._inner_dict['partitionSpec'] = value
+    
+    
+    @property
+    def messageId(self) -> Union[None, str]:
+        """The optional messageId, if provided serves as a custom user-defined unique identifier for an aspect value."""
+        return self._inner_dict.get('messageId')  # type: ignore
+    
+    @messageId.setter
+    def messageId(self, value: Union[None, str]) -> None:
+        self._inner_dict['messageId'] = value
+    
+    
 class AssertionDryRunEventClass(_Aspect):
     """An event produced when assertion is executed in dry-run mode, e.g.
     when an assertion is being "dark-tested".
@@ -2186,7 +2688,7 @@ class AssertionInfoClass(_Aspect):
     
     @property
     def type(self) -> Union[str, "AssertionTypeClass"]:
-        """Type of assertion. Assertion types can evolve to span Datasets, Flows (Pipelines), Models, Features etc."""
+        """Type of assertion."""
         return self._inner_dict.get('type')  # type: ignore
     
     @type.setter
@@ -2618,7 +3120,7 @@ class AssertionRunEventClass(_Aspect):
     
     @property
     def timestampMillis(self) -> int:
-        """The event timestamp field as epoch at UTC in milli seconds."""
+        """The event timestamp field as epoch at UTC in milliseconds."""
         return self._inner_dict.get('timestampMillis')  # type: ignore
     
     @timestampMillis.setter
@@ -3024,8 +3526,64 @@ class AssertionStdParametersClass(DictWrapper):
         self._inner_dict['minValue'] = value
     
     
+class AssertionSummaryClass(_Aspect):
+    """Derived.
+    Tracks the latest summary details of an assertion."""
+
+
+    ASPECT_NAME = 'assertionSummary'
+    ASPECT_INFO = {}
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.assertion.AssertionSummary")
+
+    def __init__(self,
+        lastFailedAtMillis: Union[None, int]=None,
+        lastErroredAtMillis: Union[None, int]=None,
+        lastPassedAtMillis: Union[None, int]=None,
+    ):
+        super().__init__()
+        
+        self.lastFailedAtMillis = lastFailedAtMillis
+        self.lastErroredAtMillis = lastErroredAtMillis
+        self.lastPassedAtMillis = lastPassedAtMillis
+    
+    def _restore_defaults(self) -> None:
+        self.lastFailedAtMillis = self.RECORD_SCHEMA.fields_dict["lastFailedAtMillis"].default
+        self.lastErroredAtMillis = self.RECORD_SCHEMA.fields_dict["lastErroredAtMillis"].default
+        self.lastPassedAtMillis = self.RECORD_SCHEMA.fields_dict["lastPassedAtMillis"].default
+    
+    
+    @property
+    def lastFailedAtMillis(self) -> Union[None, int]:
+        """The last failure event timestamp field as epoch at UTC in milliseconds."""
+        return self._inner_dict.get('lastFailedAtMillis')  # type: ignore
+    
+    @lastFailedAtMillis.setter
+    def lastFailedAtMillis(self, value: Union[None, int]) -> None:
+        self._inner_dict['lastFailedAtMillis'] = value
+    
+    
+    @property
+    def lastErroredAtMillis(self) -> Union[None, int]:
+        """The last error event timestamp field as epoch at UTC in milliseconds."""
+        return self._inner_dict.get('lastErroredAtMillis')  # type: ignore
+    
+    @lastErroredAtMillis.setter
+    def lastErroredAtMillis(self, value: Union[None, int]) -> None:
+        self._inner_dict['lastErroredAtMillis'] = value
+    
+    
+    @property
+    def lastPassedAtMillis(self) -> Union[None, int]:
+        """The last pass event timestamp field as epoch at UTC in milliseconds."""
+        return self._inner_dict.get('lastPassedAtMillis')  # type: ignore
+    
+    @lastPassedAtMillis.setter
+    def lastPassedAtMillis(self, value: Union[None, int]) -> None:
+        self._inner_dict['lastPassedAtMillis'] = value
+    
+    
 class AssertionTypeClass(object):
-    # No docs available.
+    """Type of assertion. Assertion types can evolve to span Datasets, Flows (Pipelines), Models, Features etc."""
     
     DATASET = "DATASET"
     """A single-dataset assertion.
@@ -5769,6 +6327,7 @@ class AssertionsSummaryClass(_Aspect):
         passingAssertions: Optional[List[str]]=None,
         passingAssertionDetails: Optional[List["AssertionSummaryDetailsClass"]]=None,
         failingAssertionDetails: Optional[List["AssertionSummaryDetailsClass"]]=None,
+        erroringAssertionDetails: Optional[List["AssertionSummaryDetailsClass"]]=None,
     ):
         super().__init__()
         
@@ -5792,12 +6351,18 @@ class AssertionsSummaryClass(_Aspect):
             self.failingAssertionDetails = list()
         else:
             self.failingAssertionDetails = failingAssertionDetails
+        if erroringAssertionDetails is None:
+            # default: []
+            self.erroringAssertionDetails = list()
+        else:
+            self.erroringAssertionDetails = erroringAssertionDetails
     
     def _restore_defaults(self) -> None:
         self.failingAssertions = list()
         self.passingAssertions = list()
         self.passingAssertionDetails = list()
         self.failingAssertionDetails = list()
+        self.erroringAssertionDetails = list()
     
     
     @property
@@ -5842,6 +6407,16 @@ class AssertionsSummaryClass(_Aspect):
         self._inner_dict['failingAssertionDetails'] = value
     
     
+    @property
+    def erroringAssertionDetails(self) -> List["AssertionSummaryDetailsClass"]:
+        """Summary details about the set of erroring assertions"""
+        return self._inner_dict.get('erroringAssertionDetails')  # type: ignore
+    
+    @erroringAssertionDetails.setter
+    def erroringAssertionDetails(self, value: List["AssertionSummaryDetailsClass"]) -> None:
+        self._inner_dict['erroringAssertionDetails'] = value
+    
+    
 class AuditStampClass(DictWrapper):
     """Data captured on a resource/association/sub-resource level giving insight into when that resource/association/sub-resource moved into a particular lifecycle stage, and who acted to move it into that specific lifecycle stage."""
     
@@ -6664,6 +7239,9 @@ class FabricTypeClass(object):
     TST = "TST"
     """Alternative Test spelling"""
     
+    SANDBOX = "SANDBOX"
+    """Designates sandbox fabrics"""
+    
     
     
 class FieldFormPromptAssociationClass(DictWrapper):
@@ -9695,6 +10273,7 @@ class DashboardInfoClass(_Aspect):
         chartEdges: Union[None, List["EdgeClass"]]=None,
         datasets: Optional[List[str]]=None,
         datasetEdges: Union[None, List["EdgeClass"]]=None,
+        dashboards: Optional[List["EdgeClass"]]=None,
         dashboardUrl: Union[None, str]=None,
         access: Union[None, Union[str, "AccessLevelClass"]]=None,
         lastRefreshed: Union[None, int]=None,
@@ -9722,6 +10301,11 @@ class DashboardInfoClass(_Aspect):
         else:
             self.datasets = datasets
         self.datasetEdges = datasetEdges
+        if dashboards is None:
+            # default: []
+            self.dashboards = list()
+        else:
+            self.dashboards = dashboards
         self.lastModified = lastModified
         self.dashboardUrl = dashboardUrl
         self.access = access
@@ -9737,6 +10321,7 @@ class DashboardInfoClass(_Aspect):
         self.chartEdges = self.RECORD_SCHEMA.fields_dict["chartEdges"].default
         self.datasets = list()
         self.datasetEdges = self.RECORD_SCHEMA.fields_dict["datasetEdges"].default
+        self.dashboards = list()
         self.lastModified = ChangeAuditStampsClass._construct_with_defaults()
         self.dashboardUrl = self.RECORD_SCHEMA.fields_dict["dashboardUrl"].default
         self.access = self.RECORD_SCHEMA.fields_dict["access"].default
@@ -9826,6 +10411,19 @@ class DashboardInfoClass(_Aspect):
         self._inner_dict['datasetEdges'] = value
     
     
+    @property
+    def dashboards(self) -> List["EdgeClass"]:
+        """Dashboards included by this dashboard.
+    Some dashboard entities (e.g. PowerBI Apps) can contain other dashboards.
+    
+    The Edge's sourceUrn should never be set, as it will always be the base dashboard."""
+        return self._inner_dict.get('dashboards')  # type: ignore
+    
+    @dashboards.setter
+    def dashboards(self, value: List["EdgeClass"]) -> None:
+        self._inner_dict['dashboards'] = value
+    
+    
     @property
     def lastModified(self) -> "ChangeAuditStampsClass":
         """Captures information about who created/last modified/deleted this dashboard and when"""
@@ -16581,6 +17179,8 @@ class FormInfoClass(_Aspect):
         prompts: Optional[List["FormPromptClass"]]=None,
         actors: Optional["FormActorAssignmentClass"]=None,
         status: Optional["FormStatusClass"]=None,
+        created: Union[None, "AuditStampClass"]=None,
+        lastModified: Union[None, "AuditStampClass"]=None,
     ):
         super().__init__()
         
@@ -16606,6 +17206,8 @@ class FormInfoClass(_Aspect):
             self.status = _json_converter.from_json_object(self.RECORD_SCHEMA.fields_dict["status"].default, writers_schema=self.RECORD_SCHEMA.fields_dict["status"].type)
         else:
             self.status = status
+        self.created = created
+        self.lastModified = lastModified
     
     def _restore_defaults(self) -> None:
         self.name = str()
@@ -16614,6 +17216,8 @@ class FormInfoClass(_Aspect):
         self.prompts = list()
         self.actors = _json_converter.from_json_object(self.RECORD_SCHEMA.fields_dict["actors"].default, writers_schema=self.RECORD_SCHEMA.fields_dict["actors"].type)
         self.status = _json_converter.from_json_object(self.RECORD_SCHEMA.fields_dict["status"].default, writers_schema=self.RECORD_SCHEMA.fields_dict["status"].type)
+        self.created = self.RECORD_SCHEMA.fields_dict["created"].default
+        self.lastModified = self.RECORD_SCHEMA.fields_dict["lastModified"].default
     
     
     @property
@@ -16676,6 +17280,26 @@ class FormInfoClass(_Aspect):
         self._inner_dict['status'] = value
     
     
+    @property
+    def created(self) -> Union[None, "AuditStampClass"]:
+        """Created Audit stamp"""
+        return self._inner_dict.get('created')  # type: ignore
+    
+    @created.setter
+    def created(self, value: Union[None, "AuditStampClass"]) -> None:
+        self._inner_dict['created'] = value
+    
+    
+    @property
+    def lastModified(self) -> Union[None, "AuditStampClass"]:
+        """Last Modified Audit stamp"""
+        return self._inner_dict.get('lastModified')  # type: ignore
+    
+    @lastModified.setter
+    def lastModified(self, value: Union[None, "AuditStampClass"]) -> None:
+        self._inner_dict['lastModified'] = value
+    
+    
 class FormPromptClass(DictWrapper):
     """A prompt to present to the user to encourage filling out metadata"""
     
@@ -19902,7 +20526,7 @@ class AssertionKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'assertionKey'
-    ASPECT_INFO = {'keyForEntity': 'assertion', 'entityCategory': 'core', 'entityAspects': ['assertionInfo', 'dataPlatformInstance', 'assertionRunEvent', 'assertionActions', 'status', 'globalTags', 'lineageFeatures', 'assertionDryRunEvent', 'assertionInferenceDetails'], 'entityDoc': 'Assertion represents a data quality rule applied on one or more dataset.'}
+    ASPECT_INFO = {'keyForEntity': 'assertion', 'entityCategory': 'core', 'entityAspects': ['assertionInfo', 'dataPlatformInstance', 'assertionRunEvent', 'assertionActions', 'status', 'globalTags', 'lineageFeatures', 'assertionSummary', 'assertionAnalyticsRunEvent', 'assertionDryRunEvent', 'assertionInferenceDetails'], 'entityDoc': 'Assertion represents a data quality rule applied on one or more dataset.'}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.AssertionKey")
 
     def __init__(self,
@@ -20002,7 +20626,7 @@ class ContainerKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'containerKey'
-    ASPECT_INFO = {'keyForEntity': 'container', 'entityCategory': 'core', 'entityAspects': ['containerProperties', 'editableContainerProperties', 'dataPlatformInstance', 'subTypes', 'ownership', 'container', 'globalTags', 'glossaryTerms', 'institutionalMemory', 'browsePaths', 'status', 'domains', 'proposals', 'browsePathsV2', 'structuredProperties', 'forms', 'testResults', 'share', 'origin', 'documentation'], 'entityDoc': 'A container of related data assets.'}
+    ASPECT_INFO = {'keyForEntity': 'container', 'entityCategory': 'core', 'entityAspects': ['containerProperties', 'editableContainerProperties', 'dataPlatformInstance', 'subTypes', 'ownership', 'container', 'globalTags', 'glossaryTerms', 'institutionalMemory', 'browsePaths', 'status', 'domains', 'proposals', 'browsePathsV2', 'structuredProperties', 'forms', 'testResults', 'access', 'share', 'origin', 'documentation'], 'entityDoc': 'A container of related data assets.'}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.ContainerKey")
 
     def __init__(self,
@@ -20774,7 +21398,7 @@ class DatasetKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'datasetKey'
-    ASPECT_INFO = {'keyForEntity': 'dataset', 'entityCategory': 'core', 'entityAspects': ['viewProperties', 'subTypes', 'datasetProfile', 'datasetUsageStatistics', 'operation', 'domains', 'proposals', 'schemaProposals', 'schemaMetadata', 'status', 'container', 'deprecation', 'usageFeatures', 'storageFeatures', 'lineageFeatures', 'testResults', 'siblings', 'embed', 'incidentsSummary', 'inferredNeighbors', 'inferredMetadata', 'schemaFieldsInferredMetadata', 'schemaFieldsInferredNeighbors', 'assertionsSummary', 'datasetProperties', 'editableDatasetProperties', 'datasetDeprecation', 'datasetUpstreamLineage', 'upstreamLineage', 'institutionalMemory', 'ownership', 'editableSchemaMetadata', 'globalTags', 'glossaryTerms', 'browsePaths', 'dataPlatformInstance', 'browsePathsV2', 'anomaliesSummary', 'access', 'structuredProperties', 'forms', 'partitionsSummary', 'share', 'origin', 'documentation'], 'entityDoc': 'Datasets represent logical or physical data assets stored or represented in various data platforms. Tables, Views, Streams are all instances of datasets.'}
+    ASPECT_INFO = {'keyForEntity': 'dataset', 'entityCategory': 'core', 'entityAspects': ['viewProperties', 'subTypes', 'datasetProfile', 'datasetUsageStatistics', 'operation', 'domains', 'proposals', 'schemaProposals', 'schemaMetadata', 'status', 'container', 'deprecation', 'usageFeatures', 'storageFeatures', 'lineageFeatures', 'testResults', 'siblings', 'embed', 'incidentsSummary', 'inferredNeighbors', 'inferredMetadata', 'schemaFieldsInferredMetadata', 'schemaFieldsInferredNeighbors', 'assertionsSummary', 'datasetProperties', 'editableDatasetProperties', 'datasetDeprecation', 'datasetUpstreamLineage', 'upstreamLineage', 'institutionalMemory', 'ownership', 'editableSchemaMetadata', 'globalTags', 'glossaryTerms', 'browsePaths', 'dataPlatformInstance', 'browsePathsV2', 'anomaliesSummary', 'access', 'structuredProperties', 'forms', 'partitionsSummary', 'share', 'origin', 'documentation', 'entityInferenceMetadata'], 'entityDoc': 'Datasets represent logical or physical data assets stored or represented in various data platforms. Tables, Views, Streams are all instances of datasets.'}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.DatasetKey")
 
     def __init__(self,
@@ -21151,7 +21775,7 @@ class MLFeatureKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'mlFeatureKey'
-    ASPECT_INFO = {'keyForEntity': 'mlFeature', 'entityCategory': 'core', 'entityAspects': ['glossaryTerms', 'editableMlFeatureProperties', 'domains', 'proposals', 'mlFeatureProperties', 'ownership', 'institutionalMemory', 'status', 'deprecation', 'browsePaths', 'globalTags', 'dataPlatformInstance', 'browsePathsV2', 'structuredProperties', 'forms', 'testResults', 'share', 'origin', 'lineageFeatures', 'documentation']}
+    ASPECT_INFO = {'keyForEntity': 'mlFeature', 'entityCategory': 'core', 'entityAspects': ['glossaryTerms', 'editableMlFeatureProperties', 'domains', 'proposals', 'mlFeatureProperties', 'ownership', 'institutionalMemory', 'status', 'deprecation', 'browsePaths', 'globalTags', 'dataPlatformInstance', 'browsePathsV2', 'structuredProperties', 'forms', 'testResults', 'share', 'origin', 'lineageFeatures', 'documentation', 'incidentsSummary']}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.MLFeatureKey")
 
     def __init__(self,
@@ -21345,7 +21969,7 @@ class MLModelKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'mlModelKey'
-    ASPECT_INFO = {'keyForEntity': 'mlModel', 'entityCategory': 'core', 'entityAspects': ['glossaryTerms', 'editableMlModelProperties', 'domains', 'proposals', 'ownership', 'mlModelProperties', 'intendedUse', 'mlModelFactorPrompts', 'mlModelMetrics', 'mlModelEvaluationData', 'mlModelTrainingData', 'mlModelQuantitativeAnalyses', 'mlModelEthicalConsiderations', 'mlModelCaveatsAndRecommendations', 'institutionalMemory', 'sourceCode', 'status', 'cost', 'deprecation', 'browsePaths', 'globalTags', 'dataPlatformInstance', 'browsePathsV2', 'structuredProperties', 'forms', 'testResults', 'share', 'origin', 'lineageFeatures', 'documentation']}
+    ASPECT_INFO = {'keyForEntity': 'mlModel', 'entityCategory': 'core', 'entityAspects': ['glossaryTerms', 'editableMlModelProperties', 'domains', 'proposals', 'ownership', 'mlModelProperties', 'intendedUse', 'mlModelFactorPrompts', 'mlModelMetrics', 'mlModelEvaluationData', 'mlModelTrainingData', 'mlModelQuantitativeAnalyses', 'mlModelEthicalConsiderations', 'mlModelCaveatsAndRecommendations', 'institutionalMemory', 'sourceCode', 'status', 'cost', 'deprecation', 'browsePaths', 'globalTags', 'dataPlatformInstance', 'browsePathsV2', 'structuredProperties', 'forms', 'testResults', 'share', 'origin', 'lineageFeatures', 'documentation', 'incidentsSummary']}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.MLModelKey")
 
     def __init__(self,
@@ -21850,6 +22474,9 @@ class ConditionClass(object):
     EQUAL = "EQUAL"
     """Represent the relation: field = value, e.g. platform = hdfs"""
     
+    IEQUAL = "IEQUAL"
+    """Represent the relation: field = value and support case insensitive values, e.g. platform = hdfs"""
+    
     IS_NULL = "IS_NULL"
     """Represent the relation: field is null, e.g. platform is null"""
     
@@ -27471,8 +28098,14 @@ class PlatformResourceInfoClass(_Aspect):
     @property
     def resourceType(self) -> str:
         """The type of the resource. 
-    This is used to differentiate between different types of resources.
-    Possible values specified in {@link com.linkedin.pegasus2avro.platformresource.PlatformResourceType}"""
+    Intended as a loose specifier of the generic type of the resource.
+    Producer is not forced to conform to a specific set of symbols for
+    resource types.
+    The @PlatformResourceType enumeration offers a paved path for agreed upon
+    common terms, but is not required to be followed.
+    Example values could be: conversation, user, grant, etc.
+    Resource types are indexed for ease of access. 
+    e.g. Get me all platform resources of type user for the platform looker"""
         return self._inner_dict.get('resourceType')  # type: ignore
     
     @resourceType.setter
@@ -27483,7 +28116,10 @@ class PlatformResourceInfoClass(_Aspect):
     @property
     def primaryKey(self) -> str:
         """The primary key for this platform resource.
-    I.e., for a slack member this would be the memberID."""
+    e.g. for a slack member this would be the memberID.
+    primary keys specified here don't need to include any additional specificity for the
+         dataPlatform
+    The @PlatformResourceKey is supposed to represent that"""
         return self._inner_dict.get('primaryKey')  # type: ignore
     
     @primaryKey.setter
@@ -27513,13 +28149,16 @@ class PlatformResourceInfoClass(_Aspect):
     
     
 class PlatformResourceKeyClass(_Aspect):
-    """Key for Platform Resource.
-    These entities are for miscelaneous data that is used in non-core parts of the system.
-    For instance, if we want to persist & retrieve data from auxiliary integrations such as Slack or Microsoft Teams."""
+    """Key for a Platform Resource.
+    Platform Resources are assets that are not part of the core data model.
+    They are stored in DataHub primarily to help with application-specific
+    use-cases that are not sufficiently generalized to move into the core data model.
+    For instance, if we want to persist & retrieve additional user profile data 
+    from auxiliary integrations such as Slack or Microsoft Teams for resolving details later."""
 
 
     ASPECT_NAME = 'platformResourceKey'
-    ASPECT_INFO = {'keyForEntity': 'platformResource', 'entityCategory': 'core', 'entityAspects': ['dataPlatformInstance', 'platformResourceInfo', 'status']}
+    ASPECT_INFO = {'keyForEntity': 'platformResource', 'entityCategory': 'core', 'entityAspects': ['dataPlatformInstance', 'platformResourceInfo', 'status'], 'entityDoc': 'Platform Resources are assets that are unmodeled and stored outside of the core data model. They are stored in DataHub primarily to help with application-specific use-cases that are not sufficiently generalized to move into the core data model.'}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.platformresource.PlatformResourceKey")
 
     def __init__(self,
@@ -27535,8 +28174,16 @@ class PlatformResourceKeyClass(_Aspect):
     
     @property
     def id(self) -> str:
-        """A unique id for this entity. Generated on the server side at entity creation time.
-    Format will be a guid."""
+        """A unique id for this entity.
+    There are no constraints on the format of this id, but most implementations
+    will choose to use a UUID.
+    This id should be globally unique for the entire DataHub instance and
+         uniquely identify the resource that is being stored, so most
+         implementations
+    will combine logical attributes like platform name, platform instance,
+    platform-specific-id and the resource type to create the unique id.
+    e.g. slack:slack-instance:slack-user-id:user-info 
+    or guid(slack, slack-instance, slack-user-id, user-info) etc."""
         return self._inner_dict.get('id')  # type: ignore
     
     @id.setter
@@ -27932,6 +28579,9 @@ class PolicyMatchConditionClass(object):
     EQUALS = "EQUALS"
     """Whether the field matches the value"""
     
+    STARTS_WITH = "STARTS_WITH"
+    """Whether the field value starts with the value"""
+    
     
     
 class PolicyMatchCriterionClass(DictWrapper):
@@ -28188,7 +28838,7 @@ class PostInfoClass(_Aspect):
     
     @property
     def target(self) -> Union[None, str]:
-        """Optional URN that the post is associated with."""
+        """Optional Entity URN that the post is associated with."""
         return self._inner_dict.get('target')  # type: ignore
     
     @target.setter
@@ -30873,13 +31523,19 @@ class GlobalVisualSettingsClass(DictWrapper):
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.settings.global.GlobalVisualSettings")
     def __init__(self,
         helpLink: Union[None, "HelpLinkClass"]=None,
+        customLogoUrl: Union[None, str]=None,
+        customOrgName: Union[None, str]=None,
     ):
         super().__init__()
         
         self.helpLink = helpLink
+        self.customLogoUrl = customLogoUrl
+        self.customOrgName = customOrgName
     
     def _restore_defaults(self) -> None:
         self.helpLink = self.RECORD_SCHEMA.fields_dict["helpLink"].default
+        self.customLogoUrl = self.RECORD_SCHEMA.fields_dict["customLogoUrl"].default
+        self.customOrgName = self.RECORD_SCHEMA.fields_dict["customOrgName"].default
     
     
     @property
@@ -30892,6 +31548,26 @@ class GlobalVisualSettingsClass(DictWrapper):
         self._inner_dict['helpLink'] = value
     
     
+    @property
+    def customLogoUrl(self) -> Union[None, str]:
+        """The Url for a custom logo to display in the UI"""
+        return self._inner_dict.get('customLogoUrl')  # type: ignore
+    
+    @customLogoUrl.setter
+    def customLogoUrl(self, value: Union[None, str]) -> None:
+        self._inner_dict['customLogoUrl'] = value
+    
+    
+    @property
+    def customOrgName(self) -> Union[None, str]:
+        """A customized name for organization display preferences"""
+        return self._inner_dict.get('customOrgName')  # type: ignore
+    
+    @customOrgName.setter
+    def customOrgName(self, value: Union[None, str]) -> None:
+        self._inner_dict['customOrgName'] = value
+    
+    
 class HelpLinkClass(DictWrapper):
     """Information regarding the help link dislayed in the UI"""
     
@@ -31440,6 +32116,7 @@ class StructuredPropertyDefinitionClass(_Aspect):
         version: Union[None, str]=None,
         created: Union[None, "AuditStampClass"]=None,
         lastModified: Union[None, "AuditStampClass"]=None,
+        filterStatus: Optional[Union[Union[str, "StructuredPropertyFilterStatusClass"], None]]=None,
     ):
         super().__init__()
         
@@ -31464,6 +32141,11 @@ class StructuredPropertyDefinitionClass(_Aspect):
         self.version = version
         self.created = created
         self.lastModified = lastModified
+        if filterStatus is None:
+            # default: 'DISABLED'
+            self.filterStatus = self.RECORD_SCHEMA.fields_dict["filterStatus"].default
+        else:
+            self.filterStatus = filterStatus
     
     def _restore_defaults(self) -> None:
         self.qualifiedName = str()
@@ -31479,6 +32161,7 @@ class StructuredPropertyDefinitionClass(_Aspect):
         self.version = self.RECORD_SCHEMA.fields_dict["version"].default
         self.created = self.RECORD_SCHEMA.fields_dict["created"].default
         self.lastModified = self.RECORD_SCHEMA.fields_dict["lastModified"].default
+        self.filterStatus = self.RECORD_SCHEMA.fields_dict["filterStatus"].default
     
     
     @property
@@ -31612,7 +32295,7 @@ class StructuredPropertyDefinitionClass(_Aspect):
     
     @property
     def lastModified(self) -> Union[None, "AuditStampClass"]:
-        """Created Audit stamp"""
+        """Last Modified Audit stamp"""
         return self._inner_dict.get('lastModified')  # type: ignore
     
     @lastModified.setter
@@ -31620,6 +32303,27 @@ class StructuredPropertyDefinitionClass(_Aspect):
         self._inner_dict['lastModified'] = value
     
     
+    @property
+    def filterStatus(self) -> Union[Union[str, "StructuredPropertyFilterStatusClass"], None]:
+        """The filter status of this structured property - whether it will show up in search filters or not"""
+        return self._inner_dict.get('filterStatus')  # type: ignore
+    
+    @filterStatus.setter
+    def filterStatus(self, value: Union[Union[str, "StructuredPropertyFilterStatusClass"], None]) -> None:
+        self._inner_dict['filterStatus'] = value
+    
+    
+class StructuredPropertyFilterStatusClass(object):
+    # No docs available.
+    
+    ENABLED = "ENABLED"
+    """This structured property will show up in search filters"""
+    
+    DISABLED = "DISABLED"
+    """This structured property will not show up in search filters"""
+    
+    
+    
 class StructuredPropertyKeyClass(_Aspect):
     # No docs available.
 
@@ -33522,6 +34226,7 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.action.DataHubActionStatus': DataHubActionStatusClass,
     'com.linkedin.pegasus2avro.actionrequest.ActionRequestArchived': ActionRequestArchivedClass,
     'com.linkedin.pegasus2avro.actionrequest.ActionRequestInfo': ActionRequestInfoClass,
+    'com.linkedin.pegasus2avro.actionrequest.ActionRequestOrigin': ActionRequestOriginClass,
     'com.linkedin.pegasus2avro.actionrequest.ActionRequestParams': ActionRequestParamsClass,
     'com.linkedin.pegasus2avro.actionrequest.ActionRequestStatus': ActionRequestStatusClass,
     'com.linkedin.pegasus2avro.actionrequest.CreateGlossaryNodeProposal': CreateGlossaryNodeProposalClass,
@@ -33531,6 +34236,11 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.actionrequest.DescriptionProposal': DescriptionProposalClass,
     'com.linkedin.pegasus2avro.actionrequest.GlossaryTermProposal': GlossaryTermProposalClass,
     'com.linkedin.pegasus2avro.actionrequest.TagProposal': TagProposalClass,
+    'com.linkedin.pegasus2avro.ai.AiInferenceMetadata': AiInferenceMetadataClass,
+    'com.linkedin.pegasus2avro.ai.EntityInferenceMetadata': EntityInferenceMetadataClass,
+    'com.linkedin.pegasus2avro.ai.GlossaryTermsInferenceMetadata': GlossaryTermsInferenceMetadataClass,
+    'com.linkedin.pegasus2avro.ai.InferenceGroupMetadata': InferenceGroupMetadataClass,
+    'com.linkedin.pegasus2avro.ai.InferenceMetadata': InferenceMetadataClass,
     'com.linkedin.pegasus2avro.anomaly.AnomalyInfo': AnomalyInfoClass,
     'com.linkedin.pegasus2avro.anomaly.AnomalyReview': AnomalyReviewClass,
     'com.linkedin.pegasus2avro.anomaly.AnomalyReviewState': AnomalyReviewStateClass,
@@ -33546,6 +34256,7 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.assertion.AssertionActionType': AssertionActionTypeClass,
     'com.linkedin.pegasus2avro.assertion.AssertionActions': AssertionActionsClass,
     'com.linkedin.pegasus2avro.assertion.AssertionAdjustmentSettings': AssertionAdjustmentSettingsClass,
+    'com.linkedin.pegasus2avro.assertion.AssertionAnalyticsRunEvent': AssertionAnalyticsRunEventClass,
     'com.linkedin.pegasus2avro.assertion.AssertionDryRunEvent': AssertionDryRunEventClass,
     'com.linkedin.pegasus2avro.assertion.AssertionDryRunResult': AssertionDryRunResultClass,
     'com.linkedin.pegasus2avro.assertion.AssertionInferenceDetails': AssertionInferenceDetailsClass,
@@ -33563,6 +34274,7 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.assertion.AssertionStdParameter': AssertionStdParameterClass,
     'com.linkedin.pegasus2avro.assertion.AssertionStdParameterType': AssertionStdParameterTypeClass,
     'com.linkedin.pegasus2avro.assertion.AssertionStdParameters': AssertionStdParametersClass,
+    'com.linkedin.pegasus2avro.assertion.AssertionSummary': AssertionSummaryClass,
     'com.linkedin.pegasus2avro.assertion.AssertionType': AssertionTypeClass,
     'com.linkedin.pegasus2avro.assertion.AssertionValueChangeType': AssertionValueChangeTypeClass,
     'com.linkedin.pegasus2avro.assertion.BatchSpec': BatchSpecClass,
@@ -34117,6 +34829,7 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.structured.PropertyValue': PropertyValueClass,
     'com.linkedin.pegasus2avro.structured.StructuredProperties': StructuredPropertiesClass,
     'com.linkedin.pegasus2avro.structured.StructuredPropertyDefinition': StructuredPropertyDefinitionClass,
+    'com.linkedin.pegasus2avro.structured.StructuredPropertyFilterStatus': StructuredPropertyFilterStatusClass,
     'com.linkedin.pegasus2avro.structured.StructuredPropertyKey': StructuredPropertyKeyClass,
     'com.linkedin.pegasus2avro.structured.StructuredPropertyValueAssignment': StructuredPropertyValueAssignmentClass,
     'com.linkedin.pegasus2avro.subscription.EntityChangeDetails': EntityChangeDetailsClass,
@@ -34172,6 +34885,7 @@ __SCHEMA_TYPES = {
     'DataHubActionStatus': DataHubActionStatusClass,
     'ActionRequestArchived': ActionRequestArchivedClass,
     'ActionRequestInfo': ActionRequestInfoClass,
+    'ActionRequestOrigin': ActionRequestOriginClass,
     'ActionRequestParams': ActionRequestParamsClass,
     'ActionRequestStatus': ActionRequestStatusClass,
     'CreateGlossaryNodeProposal': CreateGlossaryNodeProposalClass,
@@ -34181,6 +34895,11 @@ __SCHEMA_TYPES = {
     'DescriptionProposal': DescriptionProposalClass,
     'GlossaryTermProposal': GlossaryTermProposalClass,
     'TagProposal': TagProposalClass,
+    'AiInferenceMetadata': AiInferenceMetadataClass,
+    'EntityInferenceMetadata': EntityInferenceMetadataClass,
+    'GlossaryTermsInferenceMetadata': GlossaryTermsInferenceMetadataClass,
+    'InferenceGroupMetadata': InferenceGroupMetadataClass,
+    'InferenceMetadata': InferenceMetadataClass,
     'AnomalyInfo': AnomalyInfoClass,
     'AnomalyReview': AnomalyReviewClass,
     'AnomalyReviewState': AnomalyReviewStateClass,
@@ -34196,6 +34915,7 @@ __SCHEMA_TYPES = {
     'AssertionActionType': AssertionActionTypeClass,
     'AssertionActions': AssertionActionsClass,
     'AssertionAdjustmentSettings': AssertionAdjustmentSettingsClass,
+    'AssertionAnalyticsRunEvent': AssertionAnalyticsRunEventClass,
     'AssertionDryRunEvent': AssertionDryRunEventClass,
     'AssertionDryRunResult': AssertionDryRunResultClass,
     'AssertionInferenceDetails': AssertionInferenceDetailsClass,
@@ -34213,6 +34933,7 @@ __SCHEMA_TYPES = {
     'AssertionStdParameter': AssertionStdParameterClass,
     'AssertionStdParameterType': AssertionStdParameterTypeClass,
     'AssertionStdParameters': AssertionStdParametersClass,
+    'AssertionSummary': AssertionSummaryClass,
     'AssertionType': AssertionTypeClass,
     'AssertionValueChangeType': AssertionValueChangeTypeClass,
     'BatchSpec': BatchSpecClass,
@@ -34767,6 +35488,7 @@ __SCHEMA_TYPES = {
     'PropertyValue': PropertyValueClass,
     'StructuredProperties': StructuredPropertiesClass,
     'StructuredPropertyDefinition': StructuredPropertyDefinitionClass,
+    'StructuredPropertyFilterStatus': StructuredPropertyFilterStatusClass,
     'StructuredPropertyKey': StructuredPropertyKeyClass,
     'StructuredPropertyValueAssignment': StructuredPropertyValueAssignmentClass,
     'EntityChangeDetails': EntityChangeDetailsClass,
@@ -34905,6 +35627,8 @@ ASPECT_CLASSES: List[Type[_Aspect]] = [
     QueryUsageFeaturesClass,
     QueryUsageStatisticsClass,
     QuerySubjectsClass,
+    EntityInferenceMetadataClass,
+    AiInferenceMetadataClass,
     StructuredPropertyKeyClass,
     StructuredPropertyDefinitionClass,
     StructuredPropertiesClass,
@@ -34920,7 +35644,9 @@ ASPECT_CLASSES: List[Type[_Aspect]] = [
     AssertionRunEventClass,
     AssertionDryRunEventClass,
     AssertionActionsClass,
+    AssertionAnalyticsRunEventClass,
     AssertionInferenceDetailsClass,
+    AssertionSummaryClass,
     AssertionInfoClass,
     ProposalsClass,
     ShareClass,
@@ -35160,6 +35886,8 @@ class AspectBag(TypedDict, total=False):
     queryUsageFeatures: QueryUsageFeaturesClass
     queryUsageStatistics: QueryUsageStatisticsClass
     querySubjects: QuerySubjectsClass
+    entityInferenceMetadata: EntityInferenceMetadataClass
+    aiInferenceMetadata: AiInferenceMetadataClass
     structuredPropertyKey: StructuredPropertyKeyClass
     propertyDefinition: StructuredPropertyDefinitionClass
     structuredProperties: StructuredPropertiesClass
@@ -35175,7 +35903,9 @@ class AspectBag(TypedDict, total=False):
     assertionRunEvent: AssertionRunEventClass
     assertionDryRunEvent: AssertionDryRunEventClass
     assertionActions: AssertionActionsClass
+    assertionAnalyticsRunEvent: AssertionAnalyticsRunEventClass
     assertionInferenceDetails: AssertionInferenceDetailsClass
+    assertionSummary: AssertionSummaryClass
     assertionInfo: AssertionInfoClass
     proposals: ProposalsClass
     share: ShareClass