acryl-datahub-cloud 0.3.9.3__py3-none-any.whl → 0.3.10__py3-none-any.whl

acryl_datahub_cloud/metadata/schema_classes.py

@@ -1687,190 +1687,9 @@ class InferenceMetadataClass(DictWrapper):
         self._inner_dict['confidenceLevel'] = value
     
     
-class AnomalyInfoClass(_Aspect):
-    """Information about an anomaly raised on an asset."""
-
-
-    ASPECT_NAME = 'anomalyInfo'
-    ASPECT_INFO = {}
-    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.anomaly.AnomalyInfo")
-
-    def __init__(self,
-        type: Union[str, "AnomalyTypeClass"],
-        entity: str,
-        status: "AnomalyStatusClass",
-        source: "AnomalySourceClass",
-        created: "AuditStampClass",
-        description: Union[None, str]=None,
-        severity: Optional[Union[int, None]]=None,
-        review: Union[None, "AnomalyReviewClass"]=None,
-    ):
-        super().__init__()
-        
-        self.type = type
-        self.description = description
-        self.entity = entity
-        if severity is None:
-            # default: 0
-            self.severity = self.RECORD_SCHEMA.fields_dict["severity"].default
-        else:
-            self.severity = severity
-        self.status = status
-        self.review = review
-        self.source = source
-        self.created = created
-    
-    def _restore_defaults(self) -> None:
-        self.type = AnomalyTypeClass.FRESHNESS
-        self.description = self.RECORD_SCHEMA.fields_dict["description"].default
-        self.entity = str()
-        self.severity = self.RECORD_SCHEMA.fields_dict["severity"].default
-        self.status = AnomalyStatusClass._construct_with_defaults()
-        self.review = self.RECORD_SCHEMA.fields_dict["review"].default
-        self.source = AnomalySourceClass._construct_with_defaults()
-        self.created = AuditStampClass._construct_with_defaults()
-    
-    
-    @property
-    def type(self) -> Union[str, "AnomalyTypeClass"]:
-        """The type of anomaly"""
-        return self._inner_dict.get('type')  # type: ignore
-    
-    @type.setter
-    def type(self, value: Union[str, "AnomalyTypeClass"]) -> None:
-        self._inner_dict['type'] = value
-    
-    
-    @property
-    def description(self) -> Union[None, str]:
-        """Optional description associated with the anomaly. e.g. an explanation in human-readable form."""
-        return self._inner_dict.get('description')  # type: ignore
-    
-    @description.setter
-    def description(self, value: Union[None, str]) -> None:
-        self._inner_dict['description'] = value
-    
-    
-    @property
-    def entity(self) -> str:
-        """A reference to the entity associated with the anomaly."""
-        return self._inner_dict.get('entity')  # type: ignore
-    
-    @entity.setter
-    def entity(self, value: str) -> None:
-        self._inner_dict['entity'] = value
-    
-    
-    @property
-    def severity(self) -> Union[int, None]:
-        """A numeric severity for the anomaly.
-    This reflects the significance of the anomaly and is based on
-    how far out of the norm the anomaly resides."""
-        return self._inner_dict.get('severity')  # type: ignore
-    
-    @severity.setter
-    def severity(self, value: Union[int, None]) -> None:
-        self._inner_dict['severity'] = value
-    
-    
-    @property
-    def status(self) -> "AnomalyStatusClass":
-        """The current status of the anomaly, whether it is active or resolved."""
-        return self._inner_dict.get('status')  # type: ignore
-    
-    @status.setter
-    def status(self, value: "AnomalyStatusClass") -> None:
-        self._inner_dict['status'] = value
-    
-    
-    @property
-    def review(self) -> Union[None, "AnomalyReviewClass"]:
-        """The review of the anomaly, based on human-provided feedback.
-    If this is not present, then the Anomaly has not yet been reviewed."""
-        return self._inner_dict.get('review')  # type: ignore
-    
-    @review.setter
-    def review(self, value: Union[None, "AnomalyReviewClass"]) -> None:
-        self._inner_dict['review'] = value
-    
-    
-    @property
-    def source(self) -> "AnomalySourceClass":
-        """The source of an anomaly, i.e. how it was generated."""
-        return self._inner_dict.get('source')  # type: ignore
-    
-    @source.setter
-    def source(self, value: "AnomalySourceClass") -> None:
-        self._inner_dict['source'] = value
-    
-    
-    @property
-    def created(self) -> "AuditStampClass":
-        """The time at which the request was initially created"""
-        return self._inner_dict.get('created')  # type: ignore
-    
-    @created.setter
-    def created(self, value: "AuditStampClass") -> None:
-        self._inner_dict['created'] = value
-    
-    
-class AnomalyReviewClass(DictWrapper):
-    """The human-provided review of the anomaly."""
-    
-    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.anomaly.AnomalyReview")
-    def __init__(self,
-        state: Union[str, "AnomalyReviewStateClass"],
-        lastUpdated: "AuditStampClass",
-        message: Union[None, str]=None,
-    ):
-        super().__init__()
-        
-        self.state = state
-        self.message = message
-        self.lastUpdated = lastUpdated
-    
-    def _restore_defaults(self) -> None:
-        self.state = AnomalyReviewStateClass.PENDING
-        self.message = self.RECORD_SCHEMA.fields_dict["message"].default
-        self.lastUpdated = AuditStampClass._construct_with_defaults()
-    
-    
-    @property
-    def state(self) -> Union[str, "AnomalyReviewStateClass"]:
-        """The state of the anomaly"""
-        return self._inner_dict.get('state')  # type: ignore
-    
-    @state.setter
-    def state(self, value: Union[str, "AnomalyReviewStateClass"]) -> None:
-        self._inner_dict['state'] = value
-    
-    
-    @property
-    def message(self) -> Union[None, str]:
-        """An optional explanation of the review."""
-        return self._inner_dict.get('message')  # type: ignore
-    
-    @message.setter
-    def message(self, value: Union[None, str]) -> None:
-        self._inner_dict['message'] = value
-    
-    
-    @property
-    def lastUpdated(self) -> "AuditStampClass":
-        """The time at which the anomaly review state last changed"""
-        return self._inner_dict.get('lastUpdated')  # type: ignore
-    
-    @lastUpdated.setter
-    def lastUpdated(self, value: "AuditStampClass") -> None:
-        self._inner_dict['lastUpdated'] = value
-    
-    
 class AnomalyReviewStateClass(object):
     # No docs available.
     
-    PENDING = "PENDING"
-    """The anomaly is pending human review."""
-    
     CONFIRMED = "CONFIRMED"
     """The anomaly has been confirmed by a human reviewer. This means the anomaly was validated."""
     
@@ -1938,13 +1757,16 @@ class AnomalySourcePropertiesClass(DictWrapper):
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.anomaly.AnomalySourceProperties")
     def __init__(self,
         assertionRunEventTime: Union[None, int]=None,
+        metricCubeTimestamp: Union[None, int]=None,
     ):
         super().__init__()
         
         self.assertionRunEventTime = assertionRunEventTime
+        self.metricCubeTimestamp = metricCubeTimestamp
     
     def _restore_defaults(self) -> None:
         self.assertionRunEventTime = self.RECORD_SCHEMA.fields_dict["assertionRunEventTime"].default
+        self.metricCubeTimestamp = self.RECORD_SCHEMA.fields_dict["metricCubeTimestamp"].default
     
     
     @property
@@ -1957,114 +1779,148 @@ class AnomalySourcePropertiesClass(DictWrapper):
         self._inner_dict['assertionRunEventTime'] = value
     
     
-class AnomalySourceTypeClass(object):
-    # No docs available.
-    
-    INFERRED_ASSERTION_FAILURE = "INFERRED_ASSERTION_FAILURE"
-    """An assertion has failed, triggering the anomaly."""
+    @property
+    def metricCubeTimestamp(self) -> Union[None, int]:
+        """The timestamp associated with the metric cube value that triggered the anomaly."""
+        return self._inner_dict.get('metricCubeTimestamp')  # type: ignore
     
+    @metricCubeTimestamp.setter
+    def metricCubeTimestamp(self, value: Union[None, int]) -> None:
+        self._inner_dict['metricCubeTimestamp'] = value
     
     
-class AnomalyStateClass(object):
+class AnomalySourceTypeClass(object):
     # No docs available.
     
-    ACTIVE = "ACTIVE"
-    """The anomaly is ongoing, or active."""
-    
-    RESOLVED = "RESOLVED"
-    """The anomaly is resolved."""
-    
+    INFERRED_ASSERTION_FAILURE = "INFERRED_ASSERTION_FAILURE"
+    """An assertion has failed, triggering the anomaly."""
     
     
-class AnomalyStatusClass(DictWrapper):
-    """The status of an anomaly raised on an asset"""
     
-    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.anomaly.AnomalyStatus")
+class MonitorAnomalyEventClass(_Aspect):
+    """Information about an anomaly generated by a monitor"""
+
+
+    ASPECT_NAME = 'monitorAnomalyEvent'
+    ASPECT_TYPE = 'timeseries'
+    ASPECT_INFO = {}
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.anomaly.MonitorAnomalyEvent")
+
     def __init__(self,
-        state: Union[str, "AnomalyStateClass"],
-        lastUpdated: "AuditStampClass",
-        properties: Union[None, "AnomalyStatusPropertiesClass"]=None,
+        timestampMillis: int,
+        state: Union[str, "AnomalyReviewStateClass"],
+        source: "AnomalySourceClass",
+        created: "TimeStampClass",
+        lastUpdated: "TimeStampClass",
+        eventGranularity: Union[None, "TimeWindowSizeClass"]=None,
+        partitionSpec: Optional[Union["PartitionSpecClass", None]]=None,
+        messageId: Union[None, str]=None,
     ):
         super().__init__()
         
+        self.timestampMillis = timestampMillis
+        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
         self.state = state
-        self.properties = properties
+        self.source = source
+        self.created = created
         self.lastUpdated = lastUpdated
     
     def _restore_defaults(self) -> None:
-        self.state = AnomalyStateClass.ACTIVE
-        self.properties = self.RECORD_SCHEMA.fields_dict["properties"].default
-        self.lastUpdated = AuditStampClass._construct_with_defaults()
+        self.timestampMillis = int()
+        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
+        self.state = AnomalyReviewStateClass.CONFIRMED
+        self.source = AnomalySourceClass._construct_with_defaults()
+        self.created = TimeStampClass._construct_with_defaults()
+        self.lastUpdated = TimeStampClass._construct_with_defaults()
     
     
     @property
-    def state(self) -> Union[str, "AnomalyStateClass"]:
-        """The state of the anomaly"""
-        return self._inner_dict.get('state')  # type: ignore
+    def timestampMillis(self) -> int:
+        """The event timestamp field as epoch at UTC in milli seconds."""
+        return self._inner_dict.get('timestampMillis')  # type: ignore
     
-    @state.setter
-    def state(self, value: Union[str, "AnomalyStateClass"]) -> None:
-        self._inner_dict['state'] = value
+    @timestampMillis.setter
+    def timestampMillis(self, value: int) -> None:
+        self._inner_dict['timestampMillis'] = value
     
     
     @property
-    def properties(self) -> Union[None, "AnomalyStatusPropertiesClass"]:
-        """Additional properties about the status, for example which evaluation
-    of an assertion generated an Anomaly."""
-        return self._inner_dict.get('properties')  # type: ignore
+    def eventGranularity(self) -> Union[None, "TimeWindowSizeClass"]:
+        """Granularity of the event if applicable"""
+        return self._inner_dict.get('eventGranularity')  # type: ignore
     
-    @properties.setter
-    def properties(self, value: Union[None, "AnomalyStatusPropertiesClass"]) -> None:
-        self._inner_dict['properties'] = value
+    @eventGranularity.setter
+    def eventGranularity(self, value: Union[None, "TimeWindowSizeClass"]) -> None:
+        self._inner_dict['eventGranularity'] = value
     
     
     @property
-    def lastUpdated(self) -> "AuditStampClass":
-        """The time at which the anomaly state last changed"""
-        return self._inner_dict.get('lastUpdated')  # type: ignore
+    def partitionSpec(self) -> Union["PartitionSpecClass", None]:
+        """The optional partition specification."""
+        return self._inner_dict.get('partitionSpec')  # type: ignore
     
-    @lastUpdated.setter
-    def lastUpdated(self, value: "AuditStampClass") -> None:
-        self._inner_dict['lastUpdated'] = value
+    @partitionSpec.setter
+    def partitionSpec(self, value: Union["PartitionSpecClass", None]) -> None:
+        self._inner_dict['partitionSpec'] = value
     
     
-class AnomalyStatusPropertiesClass(DictWrapper):
-    """Ad-hoc properties about an anomaly status."""
+    @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
     
-    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.anomaly.AnomalyStatusProperties")
-    def __init__(self,
-        assertionRunEventTime: Union[None, int]=None,
-    ):
-        super().__init__()
-        
-        self.assertionRunEventTime = assertionRunEventTime
+    @messageId.setter
+    def messageId(self, value: Union[None, str]) -> None:
+        self._inner_dict['messageId'] = value
     
-    def _restore_defaults(self) -> None:
-        self.assertionRunEventTime = self.RECORD_SCHEMA.fields_dict["assertionRunEventTime"].default
+    
+    @property
+    def state(self) -> Union[str, "AnomalyReviewStateClass"]:
+        """The review of the anomaly, based on human-provided feedback.
+    If this is not present, then the Anomaly has not yet been reviewed."""
+        return self._inner_dict.get('state')  # type: ignore
+    
+    @state.setter
+    def state(self, value: Union[str, "AnomalyReviewStateClass"]) -> None:
+        self._inner_dict['state'] = value
     
     
     @property
-    def assertionRunEventTime(self) -> Union[None, int]:
-        """The timestampMillis field of the AssertionRunEvent which altered the anomaly status the anomaly (if applicable)."""
-        return self._inner_dict.get('assertionRunEventTime')  # type: ignore
+    def source(self) -> "AnomalySourceClass":
+        """The source of an anomaly, i.e. how it was generated."""
+        return self._inner_dict.get('source')  # type: ignore
     
-    @assertionRunEventTime.setter
-    def assertionRunEventTime(self, value: Union[None, int]) -> None:
-        self._inner_dict['assertionRunEventTime'] = value
+    @source.setter
+    def source(self, value: "AnomalySourceClass") -> None:
+        self._inner_dict['source'] = value
     
     
-class AnomalyTypeClass(object):
-    """A type of an anomaly"""
+    @property
+    def created(self) -> "TimeStampClass":
+        """The time at which the request was initially created"""
+        return self._inner_dict.get('created')  # type: ignore
     
-    FRESHNESS = "FRESHNESS"
-    """An inferred Freshness Assertion has failed, triggering the anomaly."""
+    @created.setter
+    def created(self, value: "TimeStampClass") -> None:
+        self._inner_dict['created'] = value
     
-    DATASET_COLUMN = "DATASET_COLUMN"
-    """An inferred assertion on a particular column(s) of a Dataset has triggered the anomaly."""
     
-    DATASET_ROWS = "DATASET_ROWS"
-    """An inferred assertion on the row count of a Dataset has triggered the anomaly."""
+    @property
+    def lastUpdated(self) -> "TimeStampClass":
+        """The time at which the request was initially created"""
+        return self._inner_dict.get('lastUpdated')  # type: ignore
     
+    @lastUpdated.setter
+    def lastUpdated(self, value: "TimeStampClass") -> None:
+        self._inner_dict['lastUpdated'] = value
     
     
 class AdjustmentAlgorithmClass(object):
@@ -2163,28 +2019,40 @@ class AssertionActionsClass(_Aspect):
     
 class AssertionAdjustmentSettingsClass(DictWrapper):
     """A set of settings that can be used to adjust assertion values
-    This is mainly applied against inferred assertions"""
+    NOTE: This is only applied against inferred assertions"""
     
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.assertion.AssertionAdjustmentSettings")
     def __init__(self,
-        algorithm: Union[str, "AdjustmentAlgorithmClass"],
-        algorithmName: str,
+        algorithm: Union[None, Union[str, "AdjustmentAlgorithmClass"]]=None,
+        algorithmName: Union[None, str]=None,
         context: Union[None, Dict[str, str]]=None,
+        exclusionWindows: Union[None, List["AssertionExclusionWindowClass"]]=None,
+        anomalyExclusionWindows: Union[None, List["AssertionExclusionWindowClass"]]=None,
+        trainingDataLookbackWindowDays: Union[None, int]=None,
+        sensitivity: Union[None, "AssertionMonitorSensitivityClass"]=None,
     ):
         super().__init__()
         
         self.algorithm = algorithm
         self.algorithmName = algorithmName
         self.context = context
+        self.exclusionWindows = exclusionWindows
+        self.anomalyExclusionWindows = anomalyExclusionWindows
+        self.trainingDataLookbackWindowDays = trainingDataLookbackWindowDays
+        self.sensitivity = sensitivity
     
     def _restore_defaults(self) -> None:
-        self.algorithm = AdjustmentAlgorithmClass.CUSTOM
-        self.algorithmName = str()
+        self.algorithm = self.RECORD_SCHEMA.fields_dict["algorithm"].default
+        self.algorithmName = self.RECORD_SCHEMA.fields_dict["algorithmName"].default
         self.context = self.RECORD_SCHEMA.fields_dict["context"].default
+        self.exclusionWindows = self.RECORD_SCHEMA.fields_dict["exclusionWindows"].default
+        self.anomalyExclusionWindows = self.RECORD_SCHEMA.fields_dict["anomalyExclusionWindows"].default
+        self.trainingDataLookbackWindowDays = self.RECORD_SCHEMA.fields_dict["trainingDataLookbackWindowDays"].default
+        self.sensitivity = self.RECORD_SCHEMA.fields_dict["sensitivity"].default
     
     
     @property
-    def algorithm(self) -> Union[str, "AdjustmentAlgorithmClass"]:
+    def algorithm(self) -> Union[None, Union[str, "AdjustmentAlgorithmClass"]]:
         """The algorithm to use to adjust assertion values to power the sensitivity control feature
     
     Note that for algorithm "STDDEV" which leverages the standard deviation of trailing values,
@@ -2192,17 +2060,17 @@ class AssertionAdjustmentSettingsClass(DictWrapper):
         return self._inner_dict.get('algorithm')  # type: ignore
     
     @algorithm.setter
-    def algorithm(self, value: Union[str, "AdjustmentAlgorithmClass"]) -> None:
+    def algorithm(self, value: Union[None, Union[str, "AdjustmentAlgorithmClass"]]) -> None:
         self._inner_dict['algorithm'] = value
     
     
     @property
-    def algorithmName(self) -> str:
+    def algorithmName(self) -> Union[None, str]:
         """The name of the algorithm to use to adjust assertion values to power the sensitivity control feature"""
         return self._inner_dict.get('algorithmName')  # type: ignore
     
     @algorithmName.setter
-    def algorithmName(self, value: str) -> None:
+    def algorithmName(self, value: Union[None, str]) -> None:
         self._inner_dict['algorithmName'] = value
     
     
@@ -2216,6 +2084,48 @@ class AssertionAdjustmentSettingsClass(DictWrapper):
         self._inner_dict['context'] = value
     
     
+    @property
+    def exclusionWindows(self) -> Union[None, List["AssertionExclusionWindowClass"]]:
+        """The user-defined exclusion windows for the assertion."""
+        return self._inner_dict.get('exclusionWindows')  # type: ignore
+    
+    @exclusionWindows.setter
+    def exclusionWindows(self, value: Union[None, List["AssertionExclusionWindowClass"]]) -> None:
+        self._inner_dict['exclusionWindows'] = value
+    
+    
+    @property
+    def anomalyExclusionWindows(self) -> Union[None, List["AssertionExclusionWindowClass"]]:
+        """Exclude the anomaly data points for the assertion. These are detected automatically by the system."""
+        return self._inner_dict.get('anomalyExclusionWindows')  # type: ignore
+    
+    @anomalyExclusionWindows.setter
+    def anomalyExclusionWindows(self, value: Union[None, List["AssertionExclusionWindowClass"]]) -> None:
+        self._inner_dict['anomalyExclusionWindows'] = value
+    
+    
+    @property
+    def trainingDataLookbackWindowDays(self) -> Union[None, int]:
+        """The lookback window configuration for retrieving training data points.
+    Defines how far back in time to look when gathering data for training.
+    Defaults to 60 days if not specified."""
+        return self._inner_dict.get('trainingDataLookbackWindowDays')  # type: ignore
+    
+    @trainingDataLookbackWindowDays.setter
+    def trainingDataLookbackWindowDays(self, value: Union[None, int]) -> None:
+        self._inner_dict['trainingDataLookbackWindowDays'] = value
+    
+    
+    @property
+    def sensitivity(self) -> Union[None, "AssertionMonitorSensitivityClass"]:
+        """The sensitivity level for an assertion"""
+        return self._inner_dict.get('sensitivity')  # type: ignore
+    
+    @sensitivity.setter
+    def sensitivity(self, value: Union[None, "AssertionMonitorSensitivityClass"]) -> None:
+        self._inner_dict['sensitivity'] = value
+    
+    
 class AssertionAnalyticsRunEventClass(_Aspect):
     """An event representing the current status of evaluating an assertion on a batch.
     This should be derrived from {@link AssertionRunEvent}.
@@ -2697,8 +2607,107 @@ class AssertionDryRunResultClass(DictWrapper):
         self._inner_dict['error'] = value
     
     
+class AssertionExclusionWindowClass(DictWrapper):
+    """Information about an assertion exclusion window.
+    This is used to exclude specific time periods from assertion evaluation or training.
+    For example, excluding holidays, weekends, or known anomalous periods.
+    Supports various recurrence patterns: one-off exclusions, or recurring exclusions
+    (yearly, monthly, weekly, daily, or specific holidays)."""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.assertion.AssertionExclusionWindow")
+    def __init__(self,
+        type: Union[str, "AssertionExclusionWindowTypeClass"],
+        displayName: Union[None, str]=None,
+        fixedRange: Union[None, "AbsoluteTimeWindowClass"]=None,
+        weekly: Union[None, "WeeklyWindowClass"]=None,
+        holiday: Union[None, "HolidayWindowClass"]=None,
+    ):
+        super().__init__()
+        
+        self.type = type
+        self.displayName = displayName
+        self.fixedRange = fixedRange
+        self.weekly = weekly
+        self.holiday = holiday
+    
+    def _restore_defaults(self) -> None:
+        self.type = AssertionExclusionWindowTypeClass.FIXED_RANGE
+        self.displayName = self.RECORD_SCHEMA.fields_dict["displayName"].default
+        self.fixedRange = self.RECORD_SCHEMA.fields_dict["fixedRange"].default
+        self.weekly = self.RECORD_SCHEMA.fields_dict["weekly"].default
+        self.holiday = self.RECORD_SCHEMA.fields_dict["holiday"].default
+    
+    
+    @property
+    def type(self) -> Union[str, "AssertionExclusionWindowTypeClass"]:
+        """The type of exclusion window."""
+        return self._inner_dict.get('type')  # type: ignore
+    
+    @type.setter
+    def type(self, value: Union[str, "AssertionExclusionWindowTypeClass"]) -> None:
+        self._inner_dict['type'] = value
+    
+    
+    @property
+    def displayName(self) -> Union[None, str]:
+        """Display name for this exclusion window"""
+        return self._inner_dict.get('displayName')  # type: ignore
+    
+    @displayName.setter
+    def displayName(self, value: Union[None, str]) -> None:
+        self._inner_dict['displayName'] = value
+    
+    
+    @property
+    def fixedRange(self) -> Union[None, "AbsoluteTimeWindowClass"]:
+        """Date window for one-off exclusion range
+    Only used when type is FIXED_RANGE"""
+        return self._inner_dict.get('fixedRange')  # type: ignore
+    
+    @fixedRange.setter
+    def fixedRange(self, value: Union[None, "AbsoluteTimeWindowClass"]) -> None:
+        self._inner_dict['fixedRange'] = value
+    
+    
+    @property
+    def weekly(self) -> Union[None, "WeeklyWindowClass"]:
+        """Window of time each week to exclude."""
+        return self._inner_dict.get('weekly')  # type: ignore
+    
+    @weekly.setter
+    def weekly(self, value: Union[None, "WeeklyWindowClass"]) -> None:
+        self._inner_dict['weekly'] = value
+    
+    
+    @property
+    def holiday(self) -> Union[None, "HolidayWindowClass"]:
+        """The holiday to exclude
+    Only used when type is HOLIDAY"""
+        return self._inner_dict.get('holiday')  # type: ignore
+    
+    @holiday.setter
+    def holiday(self, value: Union[None, "HolidayWindowClass"]) -> None:
+        self._inner_dict['holiday'] = value
+    
+    
+class AssertionExclusionWindowTypeClass(object):
+    # No docs available.
+    
+    FIXED_RANGE = "FIXED_RANGE"
+    """One-off time range to exclude"""
+    
+    WEEKLY = "WEEKLY"
+    """Recurring time range to exclude each week"""
+    
+    HOLIDAY = "HOLIDAY"
+    """Specific holiday to exclude"""
+    
+    
+    
 class AssertionInferenceDetailsClass(_Aspect):
-    """The details of an assertion that was inferred."""
+    """The details of an assertion that was inferred.
+    
+    Deprecated as an aspect for assertions!"""
 
 
     ASPECT_NAME = 'assertionInferenceDetails'
@@ -2986,6 +2995,31 @@ class AssertionInfoClass(_Aspect):
         self._inner_dict['description'] = value
     
     
+class AssertionMonitorSensitivityClass(DictWrapper):
+    """Assertion monitor sensitivity is a measure of how sensitive the assertion monitor is to the assertion condition."""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.assertion.AssertionMonitorSensitivity")
+    def __init__(self,
+        level: int,
+    ):
+        super().__init__()
+        
+        self.level = level
+    
+    def _restore_defaults(self) -> None:
+        self.level = int()
+    
+    
+    @property
+    def level(self) -> int:
+        """The assertion monitor level from 0-10"""
+        return self._inner_dict.get('level')  # type: ignore
+    
+    @level.setter
+    def level(self, value: int) -> None:
+        self._inner_dict['level'] = value
+    
+    
 class AssertionResultClass(DictWrapper):
     """The result of running an assertion"""
     
@@ -3429,18 +3463,15 @@ class AssertionSourceClass(DictWrapper):
     def __init__(self,
         type: Union[str, "AssertionSourceTypeClass"],
         created: Union[None, "AuditStampClass"]=None,
-        assertionInferenceDetails: Union[None, "AssertionInferenceDetailsClass"]=None,
     ):
         super().__init__()
         
         self.type = type
         self.created = created
-        self.assertionInferenceDetails = assertionInferenceDetails
     
     def _restore_defaults(self) -> None:
         self.type = AssertionSourceTypeClass.NATIVE
         self.created = self.RECORD_SCHEMA.fields_dict["created"].default
-        self.assertionInferenceDetails = self.RECORD_SCHEMA.fields_dict["assertionInferenceDetails"].default
     
     
     @property
@@ -3464,17 +3495,6 @@ class AssertionSourceClass(DictWrapper):
         self._inner_dict['created'] = value
     
     
-    @property
-    def assertionInferenceDetails(self) -> Union[None, "AssertionInferenceDetailsClass"]:
-        """The details of an assertion that was inferred.
-    This field is only present if the sourceType is INFERRED."""
-        return self._inner_dict.get('assertionInferenceDetails')  # type: ignore
-    
-    @assertionInferenceDetails.setter
-    def assertionInferenceDetails(self, value: Union[None, "AssertionInferenceDetailsClass"]) -> None:
-        self._inner_dict['assertionInferenceDetails'] = value
-    
-    
 class AssertionSourceTypeClass(object):
     # No docs available.
     
@@ -4579,7 +4599,7 @@ class FreshnessAssertionInfoClass(DictWrapper):
     def __init__(self,
         type: Union[str, "FreshnessAssertionTypeClass"],
         entity: str,
-        schedule: "FreshnessAssertionScheduleClass",
+        schedule: Union[None, "FreshnessAssertionScheduleClass"]=None,
         filter: Union[None, "DatasetFilterClass"]=None,
     ):
         super().__init__()
@@ -4592,7 +4612,7 @@ class FreshnessAssertionInfoClass(DictWrapper):
     def _restore_defaults(self) -> None:
         self.type = FreshnessAssertionTypeClass.DATASET_CHANGE
         self.entity = str()
-        self.schedule = FreshnessAssertionScheduleClass._construct_with_defaults()
+        self.schedule = self.RECORD_SCHEMA.fields_dict["schedule"].default
         self.filter = self.RECORD_SCHEMA.fields_dict["filter"].default
     
     
@@ -4617,12 +4637,12 @@ class FreshnessAssertionInfoClass(DictWrapper):
     
     
     @property
-    def schedule(self) -> "FreshnessAssertionScheduleClass":
+    def schedule(self) -> Union[None, "FreshnessAssertionScheduleClass"]:
         """Produce FAILURE Assertion Result if the asset is not updated on the cadence and within the time range described by the schedule."""
         return self._inner_dict.get('schedule')  # type: ignore
     
     @schedule.setter
-    def schedule(self, value: "FreshnessAssertionScheduleClass") -> None:
+    def schedule(self, value: Union[None, "FreshnessAssertionScheduleClass"]) -> None:
         self._inner_dict['schedule'] = value
     
     
@@ -4645,17 +4665,20 @@ class FreshnessAssertionScheduleClass(DictWrapper):
         type: Union[str, "FreshnessAssertionScheduleTypeClass"],
         cron: Union[None, "FreshnessCronScheduleClass"]=None,
         fixedInterval: Union[None, "FixedIntervalScheduleClass"]=None,
+        exclusions: Union[None, List["AssertionExclusionWindowClass"]]=None,
     ):
         super().__init__()
         
         self.type = type
         self.cron = cron
         self.fixedInterval = fixedInterval
+        self.exclusions = exclusions
     
     def _restore_defaults(self) -> None:
         self.type = FreshnessAssertionScheduleTypeClass.CRON
         self.cron = self.RECORD_SCHEMA.fields_dict["cron"].default
         self.fixedInterval = self.RECORD_SCHEMA.fields_dict["fixedInterval"].default
+        self.exclusions = self.RECORD_SCHEMA.fields_dict["exclusions"].default
     
     
     @property
@@ -4691,6 +4714,16 @@ class FreshnessAssertionScheduleClass(DictWrapper):
         self._inner_dict['fixedInterval'] = value
     
     
+    @property
+    def exclusions(self) -> Union[None, List["AssertionExclusionWindowClass"]]:
+        """Blackout windows. Periods of time to exclude from the schedule."""
+        return self._inner_dict.get('exclusions')  # type: ignore
+    
+    @exclusions.setter
+    def exclusions(self, value: Union[None, List["AssertionExclusionWindowClass"]]) -> None:
+        self._inner_dict['exclusions'] = value
+    
+    
 class FreshnessAssertionScheduleTypeClass(object):
     # No docs available.
     
@@ -8403,17 +8436,23 @@ class InstitutionalMemoryMetadataClass(DictWrapper):
         url: str,
         description: str,
         createStamp: "AuditStampClass",
+        updateStamp: Union[None, "AuditStampClass"]=None,
+        settings: Union[None, "InstitutionalMemoryMetadataSettingsClass"]=None,
     ):
         super().__init__()
         
         self.url = url
         self.description = description
         self.createStamp = createStamp
+        self.updateStamp = updateStamp
+        self.settings = settings
     
     def _restore_defaults(self) -> None:
         self.url = str()
         self.description = str()
         self.createStamp = AuditStampClass._construct_with_defaults()
+        self.updateStamp = self.RECORD_SCHEMA.fields_dict["updateStamp"].default
+        self.settings = self.RECORD_SCHEMA.fields_dict["settings"].default
     
     
     @property
@@ -8446,6 +8485,55 @@ class InstitutionalMemoryMetadataClass(DictWrapper):
         self._inner_dict['createStamp'] = value
     
     
+    @property
+    def updateStamp(self) -> Union[None, "AuditStampClass"]:
+        """Audit stamp associated with updation of this record"""
+        return self._inner_dict.get('updateStamp')  # type: ignore
+    
+    @updateStamp.setter
+    def updateStamp(self, value: Union[None, "AuditStampClass"]) -> None:
+        self._inner_dict['updateStamp'] = value
+    
+    
+    @property
+    def settings(self) -> Union[None, "InstitutionalMemoryMetadataSettingsClass"]:
+        """Settings for this record"""
+        return self._inner_dict.get('settings')  # type: ignore
+    
+    @settings.setter
+    def settings(self, value: Union[None, "InstitutionalMemoryMetadataSettingsClass"]) -> None:
+        self._inner_dict['settings'] = value
+    
+    
+class InstitutionalMemoryMetadataSettingsClass(DictWrapper):
+    """Settings related to a record of InstitutionalMemoryMetadata"""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.common.InstitutionalMemoryMetadataSettings")
+    def __init__(self,
+        showInAssetPreview: Optional[bool]=None,
+    ):
+        super().__init__()
+        
+        if showInAssetPreview is None:
+            # default: False
+            self.showInAssetPreview = self.RECORD_SCHEMA.fields_dict["showInAssetPreview"].default
+        else:
+            self.showInAssetPreview = showInAssetPreview
+    
+    def _restore_defaults(self) -> None:
+        self.showInAssetPreview = self.RECORD_SCHEMA.fields_dict["showInAssetPreview"].default
+    
+    
+    @property
+    def showInAssetPreview(self) -> bool:
+        """Show record in asset preview like on entity header and search previews"""
+        return self._inner_dict.get('showInAssetPreview')  # type: ignore
+    
+    @showInAssetPreview.setter
+    def showInAssetPreview(self, value: bool) -> None:
+        self._inner_dict['showInAssetPreview'] = value
+    
+    
 class MLFeatureDataTypeClass(object):
     """MLFeature Data Type"""
     
@@ -14095,7 +14183,7 @@ class DataProductKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'dataProductKey'
-    ASPECT_INFO = {'keyForEntity': 'dataProduct', 'entityCategory': 'core', 'entityAspects': ['ownership', 'glossaryTerms', 'globalTags', 'domains', 'dataProductProperties', 'institutionalMemory', 'status', 'structuredProperties', 'forms', 'testResults', 'share', 'origin']}
+    ASPECT_INFO = {'keyForEntity': 'dataProduct', 'entityCategory': 'core', 'entityAspects': ['ownership', 'glossaryTerms', 'globalTags', 'domains', 'dataProductProperties', 'institutionalMemory', 'status', 'structuredProperties', 'forms', 'testResults', 'subTypes', 'share', 'origin']}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.dataproduct.DataProductKey")
 
     def __init__(self,
@@ -16951,6 +17039,10 @@ class NotificationRecipientOriginTypeClass(object):
     GLOBAL_NOTIFICATION = "GLOBAL_NOTIFICATION"
     """The notification originated from a global change."""
     
+    ACTOR_NOTIFICATION = "ACTOR_NOTIFICATION"
+    """The notification originated from an actor-oriented default notification.
+    For example, proposal task or ownership assignment notifications."""
+    
     
     
 class NotificationRecipientTypeClass(object):
@@ -17115,22 +17207,25 @@ class NotificationSettingsClass(DictWrapper):
         sinkTypes: List[Union[str, "NotificationSinkTypeClass"]],
         slackSettings: Union[None, "SlackNotificationSettingsClass"]=None,
         emailSettings: Union[None, "EmailNotificationSettingsClass"]=None,
+        settings: Union[None, Dict[str, "NotificationSettingClass"]]=None,
     ):
         super().__init__()
         
         self.sinkTypes = sinkTypes
         self.slackSettings = slackSettings
         self.emailSettings = emailSettings
+        self.settings = settings
     
     def _restore_defaults(self) -> None:
         self.sinkTypes = list()
         self.slackSettings = self.RECORD_SCHEMA.fields_dict["slackSettings"].default
         self.emailSettings = self.RECORD_SCHEMA.fields_dict["emailSettings"].default
+        self.settings = self.RECORD_SCHEMA.fields_dict["settings"].default
     
     
     @property
     def sinkTypes(self) -> List[Union[str, "NotificationSinkTypeClass"]]:
-        """Sink types that notifications are sent to."""
+        """Sink types that notifications are sent to. This is a top-level on/off switch."""
         return self._inner_dict.get('sinkTypes')  # type: ignore
     
     @sinkTypes.setter
@@ -17158,6 +17253,19 @@ class NotificationSettingsClass(DictWrapper):
         self._inner_dict['emailSettings'] = value
     
     
+    @property
+    def settings(self) -> Union[None, Dict[str, "NotificationSettingClass"]]:
+        """User or Group Notification Scenario Settings.
+    
+    A map of notification scenario type to the settings associated with it.
+    For a list of all scenario types to notify on, check out NotificationScenarioType enum."""
+        return self._inner_dict.get('settings')  # type: ignore
+    
+    @settings.setter
+    def settings(self, value: Union[None, Dict[str, "NotificationSettingClass"]]) -> None:
+        self._inner_dict['settings'] = value
+    
+    
 class SlackNotificationSettingsClass(DictWrapper):
     """Slack Notification settings for an actor."""
     
@@ -17877,6 +17985,7 @@ class RemoteExecutorPoolInfoClass(_Aspect):
         creator: Union[None, str]=None,
         description: Union[None, str]=None,
         queueUrl: Union[None, str]=None,
+        queueRegion: Union[None, str]=None,
         isEmbedded: Union[None, bool]=None,
         state: Union[None, "RemoteExecutorPoolStateClass"]=None,
     ):
@@ -17886,6 +17995,7 @@ class RemoteExecutorPoolInfoClass(_Aspect):
         self.creator = creator
         self.description = description
         self.queueUrl = queueUrl
+        self.queueRegion = queueRegion
         self.isEmbedded = isEmbedded
         self.state = state
     
@@ -17894,6 +18004,7 @@ class RemoteExecutorPoolInfoClass(_Aspect):
         self.creator = self.RECORD_SCHEMA.fields_dict["creator"].default
         self.description = self.RECORD_SCHEMA.fields_dict["description"].default
         self.queueUrl = self.RECORD_SCHEMA.fields_dict["queueUrl"].default
+        self.queueRegion = self.RECORD_SCHEMA.fields_dict["queueRegion"].default
         self.isEmbedded = self.RECORD_SCHEMA.fields_dict["isEmbedded"].default
         self.state = self.RECORD_SCHEMA.fields_dict["state"].default
     
@@ -17938,6 +18049,16 @@ class RemoteExecutorPoolInfoClass(_Aspect):
         self._inner_dict['queueUrl'] = value
     
     
+    @property
+    def queueRegion(self) -> Union[None, str]:
+        """The region of the sqs queue for this pool for backwards compatibility."""
+        return self._inner_dict.get('queueRegion')  # type: ignore
+    
+    @queueRegion.setter
+    def queueRegion(self, value: Union[None, str]) -> None:
+        self._inner_dict['queueRegion'] = value
+    
+    
     @property
     def isEmbedded(self) -> Union[None, bool]:
         """Only set true if this is the pool embedded within the DataHub Cloud deployment"""
@@ -21491,7 +21612,7 @@ class AnomalyKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'anomalyKey'
-    ASPECT_INFO = {'keyForEntity': 'anomaly', 'entityCategory': 'core', 'entityAspects': ['anomalyInfo'], 'entityDoc': 'Anomalies represent issues that were detected based on inferred or auto-generated assertions.'}
+    ASPECT_INFO = {}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.AnomalyKey")
 
     def __init__(self,
@@ -21649,7 +21770,7 @@ class CorpGroupKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'corpGroupKey'
-    ASPECT_INFO = {'keyForEntity': 'corpGroup', 'entityCategory': '_unset_', 'entityAspects': ['corpGroupInfo', 'corpGroupEditableInfo', 'globalTags', 'ownership', 'status', 'origin', 'roleMembership', 'structuredProperties', 'forms', 'testResults', 'corpGroupSettings', 'share'], 'entityDoc': 'CorpGroup represents an identity of a group of users in the enterprise.'}
+    ASPECT_INFO = {'keyForEntity': 'corpGroup', 'entityCategory': '_unset_', 'entityAspects': ['corpGroupInfo', 'corpGroupEditableInfo', 'globalTags', 'ownership', 'status', 'origin', 'roleMembership', 'structuredProperties', 'forms', 'testResults', 'subTypes', 'corpGroupSettings', 'share'], 'entityDoc': 'CorpGroup represents an identity of a group of users in the enterprise.'}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.CorpGroupKey")
 
     def __init__(self,
@@ -21678,7 +21799,7 @@ class CorpUserKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'corpUserKey'
-    ASPECT_INFO = {'keyForEntity': 'corpuser', 'entityCategory': '_unset_', 'entityAspects': ['corpUserInfo', 'corpUserEditableInfo', 'corpUserStatus', 'groupMembership', 'globalTags', 'status', 'corpUserCredentials', 'nativeGroupMembership', 'corpUserSettings', 'origin', 'roleMembership', 'structuredProperties', 'forms', 'testResults', 'share', 'slackUserInfo'], 'entityDoc': 'CorpUser represents an identity of a person (or an account) in the enterprise.'}
+    ASPECT_INFO = {'keyForEntity': 'corpuser', 'entityCategory': '_unset_', 'entityAspects': ['corpUserInfo', 'corpUserEditableInfo', 'corpUserStatus', 'groupMembership', 'globalTags', 'status', 'corpUserCredentials', 'nativeGroupMembership', 'corpUserSettings', 'origin', 'roleMembership', 'structuredProperties', 'forms', 'testResults', 'subTypes', 'slackUserInfo', 'share'], 'entityDoc': 'CorpUser represents an identity of a person (or an account) in the enterprise.'}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.CorpUserKey")
 
     def __init__(self,
@@ -22365,7 +22486,7 @@ class DataProcessKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'dataProcessKey'
-    ASPECT_INFO = {'keyForEntity': 'dataProcess', 'entityCategory': '_unset_', 'entityAspects': ['dataProcessInfo', 'ownership', 'status', 'testResults']}
+    ASPECT_INFO = {'keyForEntity': 'dataProcess', 'entityCategory': '_unset_', 'entityAspects': ['dataProcessInfo', 'ownership', 'status', 'testResults', 'subTypes']}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.DataProcessKey")
 
     def __init__(self,
@@ -22653,7 +22774,7 @@ class GlossaryNodeKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'glossaryNodeKey'
-    ASPECT_INFO = {'keyForEntity': 'glossaryNode', 'entityCategory': 'core', 'entityAspects': ['glossaryNodeInfo', 'institutionalMemory', 'ownership', 'status', 'structuredProperties', 'forms', 'testResults', 'displayProperties', 'share', 'origin']}
+    ASPECT_INFO = {'keyForEntity': 'glossaryNode', 'entityCategory': 'core', 'entityAspects': ['glossaryNodeInfo', 'institutionalMemory', 'ownership', 'status', 'structuredProperties', 'forms', 'testResults', 'subTypes', 'displayProperties', 'share', 'origin']}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.GlossaryNodeKey")
 
     def __init__(self,
@@ -22682,7 +22803,7 @@ class GlossaryTermKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'glossaryTermKey'
-    ASPECT_INFO = {'keyForEntity': 'glossaryTerm', 'entityCategory': 'core', 'entityAspects': ['glossaryTermInfo', 'glossaryRelatedTerms', 'institutionalMemory', 'schemaMetadata', 'ownership', 'deprecation', 'domains', 'status', 'browsePaths', 'structuredProperties', 'forms', 'testResults', 'share', 'origin']}
+    ASPECT_INFO = {'keyForEntity': 'glossaryTerm', 'entityCategory': 'core', 'entityAspects': ['glossaryTermInfo', 'glossaryRelatedTerms', 'institutionalMemory', 'schemaMetadata', 'ownership', 'deprecation', 'domains', 'status', 'browsePaths', 'structuredProperties', 'forms', 'testResults', 'subTypes', 'share', 'origin']}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.GlossaryTermKey")
 
     def __init__(self,
@@ -22798,7 +22919,7 @@ class MLFeatureKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'mlFeatureKey'
-    ASPECT_INFO = {'keyForEntity': 'mlFeature', 'entityCategory': 'core', 'entityAspects': ['glossaryTerms', 'editableMlFeatureProperties', 'domains', 'mlFeatureProperties', 'ownership', 'institutionalMemory', 'status', 'deprecation', 'browsePaths', 'globalTags', 'dataPlatformInstance', 'browsePathsV2', 'structuredProperties', 'forms', 'testResults', 'proposals', 'share', 'origin', 'lineageFeatures', 'documentation', 'incidentsSummary']}
+    ASPECT_INFO = {'keyForEntity': 'mlFeature', 'entityCategory': 'core', 'entityAspects': ['glossaryTerms', 'editableMlFeatureProperties', 'domains', 'mlFeatureProperties', 'ownership', 'institutionalMemory', 'status', 'deprecation', 'browsePaths', 'globalTags', 'dataPlatformInstance', 'browsePathsV2', 'structuredProperties', 'forms', 'testResults', 'subTypes', 'proposals', 'share', 'origin', 'lineageFeatures', 'documentation', 'incidentsSummary']}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.MLFeatureKey")
 
     def __init__(self,
@@ -22840,7 +22961,7 @@ class MLFeatureTableKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'mlFeatureTableKey'
-    ASPECT_INFO = {'keyForEntity': 'mlFeatureTable', 'entityCategory': 'core', 'entityAspects': ['glossaryTerms', 'editableMlFeatureTableProperties', 'domains', 'mlFeatureTableProperties', 'ownership', 'institutionalMemory', 'status', 'deprecation', 'browsePaths', 'globalTags', 'dataPlatformInstance', 'browsePathsV2', 'structuredProperties', 'forms', 'testResults', 'proposals', 'share', 'origin', 'lineageFeatures', 'documentation']}
+    ASPECT_INFO = {'keyForEntity': 'mlFeatureTable', 'entityCategory': 'core', 'entityAspects': ['glossaryTerms', 'editableMlFeatureTableProperties', 'domains', 'mlFeatureTableProperties', 'ownership', 'institutionalMemory', 'status', 'deprecation', 'browsePaths', 'globalTags', 'dataPlatformInstance', 'browsePathsV2', 'structuredProperties', 'forms', 'testResults', 'subTypes', 'proposals', 'share', 'origin', 'lineageFeatures', 'documentation']}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.MLFeatureTableKey")
 
     def __init__(self,
@@ -22882,7 +23003,7 @@ class MLModelDeploymentKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'mlModelDeploymentKey'
-    ASPECT_INFO = {'keyForEntity': 'mlModelDeployment', 'entityCategory': 'core', 'entityAspects': ['mlModelDeploymentProperties', 'ownership', 'status', 'deprecation', 'globalTags', 'dataPlatformInstance', 'testResults']}
+    ASPECT_INFO = {'keyForEntity': 'mlModelDeployment', 'entityCategory': 'core', 'entityAspects': ['mlModelDeploymentProperties', 'ownership', 'status', 'deprecation', 'globalTags', 'dataPlatformInstance', 'testResults', 'container']}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.MLModelDeploymentKey")
 
     def __init__(self,
@@ -22937,7 +23058,7 @@ class MLModelGroupKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'mlModelGroupKey'
-    ASPECT_INFO = {'keyForEntity': 'mlModelGroup', 'entityCategory': 'core', 'entityAspects': ['glossaryTerms', 'editableMlModelGroupProperties', 'domains', 'mlModelGroupProperties', 'ownership', 'status', 'deprecation', 'browsePaths', 'globalTags', 'dataPlatformInstance', 'browsePathsV2', 'structuredProperties', 'forms', 'testResults', 'proposals', 'share', 'origin', 'lineageFeatures', 'documentation']}
+    ASPECT_INFO = {'keyForEntity': 'mlModelGroup', 'entityCategory': 'core', 'entityAspects': ['glossaryTerms', 'editableMlModelGroupProperties', 'domains', 'mlModelGroupProperties', 'ownership', 'status', 'deprecation', 'browsePaths', 'globalTags', 'dataPlatformInstance', 'browsePathsV2', 'structuredProperties', 'forms', 'testResults', 'subTypes', 'container', 'institutionalMemory', 'proposals', 'share', 'origin', 'lineageFeatures', 'documentation']}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.MLModelGroupKey")
 
     def __init__(self,
@@ -22992,7 +23113,7 @@ class MLModelKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'mlModelKey'
-    ASPECT_INFO = {'keyForEntity': 'mlModel', 'entityCategory': 'core', 'entityAspects': ['glossaryTerms', 'editableMlModelProperties', 'domains', 'ownership', 'mlModelProperties', 'intendedUse', 'mlModelFactorPrompts', 'mlModelMetrics', 'mlModelEvaluationData', 'mlModelTrainingData', 'mlModelQuantitativeAnalyses', 'mlModelEthicalConsiderations', 'mlModelCaveatsAndRecommendations', 'institutionalMemory', 'sourceCode', 'status', 'cost', 'deprecation', 'browsePaths', 'globalTags', 'dataPlatformInstance', 'browsePathsV2', 'structuredProperties', 'forms', 'testResults', 'versionProperties', 'proposals', 'share', 'origin', 'lineageFeatures', 'documentation', 'incidentsSummary']}
+    ASPECT_INFO = {'keyForEntity': 'mlModel', 'entityCategory': 'core', 'entityAspects': ['glossaryTerms', 'editableMlModelProperties', 'domains', 'ownership', 'mlModelProperties', 'intendedUse', 'mlModelFactorPrompts', 'mlModelMetrics', 'mlModelEvaluationData', 'mlModelTrainingData', 'mlModelQuantitativeAnalyses', 'mlModelEthicalConsiderations', 'mlModelCaveatsAndRecommendations', 'institutionalMemory', 'sourceCode', 'status', 'cost', 'deprecation', 'browsePaths', 'globalTags', 'dataPlatformInstance', 'browsePathsV2', 'structuredProperties', 'forms', 'testResults', 'versionProperties', 'subTypes', 'container', 'proposals', 'share', 'origin', 'lineageFeatures', 'documentation', 'incidentsSummary']}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.MLModelKey")
 
     def __init__(self,
@@ -23047,7 +23168,7 @@ class MLPrimaryKeyKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'mlPrimaryKeyKey'
-    ASPECT_INFO = {'keyForEntity': 'mlPrimaryKey', 'entityCategory': 'core', 'entityAspects': ['glossaryTerms', 'editableMlPrimaryKeyProperties', 'domains', 'mlPrimaryKeyProperties', 'ownership', 'institutionalMemory', 'status', 'deprecation', 'globalTags', 'dataPlatformInstance', 'structuredProperties', 'forms', 'testResults', 'proposals', 'share', 'origin', 'lineageFeatures']}
+    ASPECT_INFO = {'keyForEntity': 'mlPrimaryKey', 'entityCategory': 'core', 'entityAspects': ['glossaryTerms', 'editableMlPrimaryKeyProperties', 'domains', 'mlPrimaryKeyProperties', 'ownership', 'institutionalMemory', 'status', 'deprecation', 'globalTags', 'dataPlatformInstance', 'structuredProperties', 'forms', 'testResults', 'subTypes', 'proposals', 'share', 'origin', 'lineageFeatures']}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.MLPrimaryKeyKey")
 
     def __init__(self,
@@ -23089,7 +23210,7 @@ class MonitorKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'monitorKey'
-    ASPECT_INFO = {'keyForEntity': 'monitor', 'entityCategory': 'core', 'entityAspects': ['monitorInfo', 'monitorTimeseriesState']}
+    ASPECT_INFO = {'keyForEntity': 'monitor', 'entityCategory': 'core', 'entityAspects': ['monitorInfo', 'monitorTimeseriesState', 'monitorAnomalyEvent']}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.MonitorKey")
 
     def __init__(self,
@@ -23126,6 +23247,35 @@ class MonitorKeyClass(_Aspect):
         self._inner_dict['id'] = value
     
     
+class MonitorSuiteKeyClass(_Aspect):
+    """Key for a monitor suite."""
+
+
+    ASPECT_NAME = 'monitorSuiteKey'
+    ASPECT_INFO = {'keyForEntity': 'monitorSuite', 'entityCategory': 'core', 'entityAspects': ['monitorSuiteInfo']}
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.MonitorSuiteKey")
+
+    def __init__(self,
+        id: str,
+    ):
+        super().__init__()
+        
+        self.id = id
+    
+    def _restore_defaults(self) -> None:
+        self.id = str()
+    
+    
+    @property
+    def id(self) -> str:
+        """Unique id for the monitor suite."""
+        return self._inner_dict.get('id')  # type: ignore
+    
+    @id.setter
+    def id(self, value: str) -> None:
+        self._inner_dict['id'] = value
+    
+    
 class NotebookKeyClass(_Aspect):
     """Key for a Notebook"""
 
@@ -23203,7 +23353,7 @@ class PostKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'postKey'
-    ASPECT_INFO = {'keyForEntity': 'post', 'entityCategory': 'core', 'entityAspects': ['postInfo', 'status']}
+    ASPECT_INFO = {'keyForEntity': 'post', 'entityCategory': 'core', 'entityAspects': ['postInfo', 'subTypes', 'status']}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.PostKey")
 
     def __init__(self,
@@ -23420,7 +23570,7 @@ class SchemaFieldKeyClass(_Aspect):
 
 
     ASPECT_NAME = 'schemaFieldKey'
-    ASPECT_INFO = {'keyForEntity': 'schemaField', 'entityCategory': 'core', 'entityAspects': ['schemafieldInfo', 'structuredProperties', 'forms', 'businessAttributes', 'status', 'schemaFieldAliases', 'documentation', 'testResults', 'deprecation', 'schemaFieldProfile', 'lineageFeatures']}
+    ASPECT_INFO = {'keyForEntity': 'schemaField', 'entityCategory': 'core', 'entityAspects': ['schemafieldInfo', 'structuredProperties', 'forms', 'businessAttributes', 'status', 'schemaFieldAliases', 'documentation', 'testResults', 'deprecation', 'subTypes', 'schemaFieldProfile', 'lineageFeatures']}
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.metadata.key.SchemaFieldKey")
 
     def __init__(self,
@@ -26887,6 +27037,7 @@ class MLModelGroupPropertiesClass(_Aspect):
         customProperties: Optional[Dict[str, str]]=None,
         trainingJobs: Union[None, List[str]]=None,
         downstreamJobs: Union[None, List[str]]=None,
+        externalUrl: Union[None, str]=None,
         name: Union[None, str]=None,
         description: Union[None, str]=None,
         createdAt: Union[None, int]=None,
@@ -26903,6 +27054,7 @@ class MLModelGroupPropertiesClass(_Aspect):
             self.customProperties = customProperties
         self.trainingJobs = trainingJobs
         self.downstreamJobs = downstreamJobs
+        self.externalUrl = externalUrl
         self.name = name
         self.description = description
         self.createdAt = createdAt
@@ -26914,6 +27066,7 @@ class MLModelGroupPropertiesClass(_Aspect):
         self.customProperties = dict()
         self.trainingJobs = self.RECORD_SCHEMA.fields_dict["trainingJobs"].default
         self.downstreamJobs = self.RECORD_SCHEMA.fields_dict["downstreamJobs"].default
+        self.externalUrl = self.RECORD_SCHEMA.fields_dict["externalUrl"].default
         self.name = self.RECORD_SCHEMA.fields_dict["name"].default
         self.description = self.RECORD_SCHEMA.fields_dict["description"].default
         self.createdAt = self.RECORD_SCHEMA.fields_dict["createdAt"].default
@@ -26952,6 +27105,16 @@ class MLModelGroupPropertiesClass(_Aspect):
         self._inner_dict['downstreamJobs'] = value
     
     
+    @property
+    def externalUrl(self) -> Union[None, str]:
+        """URL where the reference exist"""
+        return self._inner_dict.get('externalUrl')  # type: ignore
+    
+    @externalUrl.setter
+    def externalUrl(self, value: Union[None, str]) -> None:
+        self._inner_dict['externalUrl'] = value
+    
+    
     @property
     def name(self) -> Union[None, str]:
         """Display name of the MLModelGroup"""
@@ -27662,15 +27825,18 @@ class AssertionEvaluationContextClass(DictWrapper):
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.monitor.AssertionEvaluationContext")
     def __init__(self,
         embeddedAssertions: Union[None, List["EmbeddedAssertionClass"]]=None,
+        inferenceDetails: Union[None, "AssertionInferenceDetailsClass"]=None,
         stdDev: Union[None, float]=None,
     ):
         super().__init__()
         
         self.embeddedAssertions = embeddedAssertions
+        self.inferenceDetails = inferenceDetails
         self.stdDev = stdDev
     
     def _restore_defaults(self) -> None:
         self.embeddedAssertions = self.RECORD_SCHEMA.fields_dict["embeddedAssertions"].default
+        self.inferenceDetails = self.RECORD_SCHEMA.fields_dict["inferenceDetails"].default
         self.stdDev = self.RECORD_SCHEMA.fields_dict["stdDev"].default
     
     
@@ -27686,6 +27852,16 @@ class AssertionEvaluationContextClass(DictWrapper):
         self._inner_dict['embeddedAssertions'] = value
     
     
+    @property
+    def inferenceDetails(self) -> Union[None, "AssertionInferenceDetailsClass"]:
+        """Details about the assertion inference."""
+        return self._inner_dict.get('inferenceDetails')  # type: ignore
+    
+    @inferenceDetails.setter
+    def inferenceDetails(self, value: Union[None, "AssertionInferenceDetailsClass"]) -> None:
+        self._inner_dict['inferenceDetails'] = value
+    
+    
     @property
     def stdDev(self) -> Union[None, float]:
         """The std deviation of the metric values used for training.
@@ -27919,10 +28095,12 @@ class AssertionMonitorSettingsClass(DictWrapper):
     
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.monitor.AssertionMonitorSettings")
     def __init__(self,
+        adjustmentSettings: Union[None, "AssertionAdjustmentSettingsClass"]=None,
         capabilities: Optional[List[Union[str, "AssertionMonitorCapabilityClass"]]]=None,
     ):
         super().__init__()
         
+        self.adjustmentSettings = adjustmentSettings
         if capabilities is None:
             # default: ['ASSERTION_EVALUATION']
             self.capabilities = list()
@@ -27930,9 +28108,20 @@ class AssertionMonitorSettingsClass(DictWrapper):
             self.capabilities = capabilities
     
     def _restore_defaults(self) -> None:
+        self.adjustmentSettings = self.RECORD_SCHEMA.fields_dict["adjustmentSettings"].default
         self.capabilities = list()
     
     
+    @property
+    def adjustmentSettings(self) -> Union[None, "AssertionAdjustmentSettingsClass"]:
+        """In adjustment settings, the settings"""
+        return self._inner_dict.get('adjustmentSettings')  # type: ignore
+    
+    @adjustmentSettings.setter
+    def adjustmentSettings(self, value: Union[None, "AssertionAdjustmentSettingsClass"]) -> None:
+        self._inner_dict['adjustmentSettings'] = value
+    
+    
     @property
     def capabilities(self) -> List[Union[str, "AssertionMonitorCapabilityClass"]]:
         """Capabilities that are currently enabled for the assertion monitor."""
@@ -28242,15 +28431,18 @@ class EmbeddedAssertionClass(DictWrapper):
     def __init__(self,
         assertion: Union[None, "AssertionInfoClass"]=None,
         evaluationTimeWindow: Union[None, "TimeWindowClass"]=None,
+        context: Union[None, Dict[str, str]]=None,
     ):
         super().__init__()
         
         self.assertion = assertion
         self.evaluationTimeWindow = evaluationTimeWindow
+        self.context = context
     
     def _restore_defaults(self) -> None:
         self.assertion = self.RECORD_SCHEMA.fields_dict["assertion"].default
         self.evaluationTimeWindow = self.RECORD_SCHEMA.fields_dict["evaluationTimeWindow"].default
+        self.context = self.RECORD_SCHEMA.fields_dict["context"].default
     
     
     @property
@@ -28273,6 +28465,62 @@ class EmbeddedAssertionClass(DictWrapper):
         self._inner_dict['evaluationTimeWindow'] = value
     
     
+    @property
+    def context(self) -> Union[None, Dict[str, str]]:
+        """Context about the embedded assertion prediction"""
+        return self._inner_dict.get('context')  # type: ignore
+    
+    @context.setter
+    def context(self, value: Union[None, Dict[str, str]]) -> None:
+        self._inner_dict['context'] = value
+    
+    
+class MonitorErrorClass(DictWrapper):
+    """Error details for the monitor"""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.monitor.MonitorError")
+    def __init__(self,
+        type: Union[str, "MonitorErrorTypeClass"],
+        message: Union[None, str]=None,
+    ):
+        super().__init__()
+        
+        self.type = type
+        self.message = message
+    
+    def _restore_defaults(self) -> None:
+        self.type = MonitorErrorTypeClass.UNKNOWN
+        self.message = self.RECORD_SCHEMA.fields_dict["message"].default
+    
+    
+    @property
+    def type(self) -> Union[str, "MonitorErrorTypeClass"]:
+        """The error for the monitor"""
+        return self._inner_dict.get('type')  # type: ignore
+    
+    @type.setter
+    def type(self, value: Union[str, "MonitorErrorTypeClass"]) -> None:
+        self._inner_dict['type'] = value
+    
+    
+    @property
+    def message(self) -> Union[None, str]:
+        """Optional custom message for the error"""
+        return self._inner_dict.get('message')  # type: ignore
+    
+    @message.setter
+    def message(self, value: Union[None, str]) -> None:
+        self._inner_dict['message'] = value
+    
+    
+class MonitorErrorTypeClass(object):
+    # No docs available.
+    
+    UNKNOWN = "UNKNOWN"
+    """An unknown error occurred"""
+    
+    
+    
 class MonitorInfoClass(_Aspect):
     """Information about an asset monitor."""
 
@@ -28386,19 +28634,42 @@ class MonitorModeClass(object):
     
     
     
+class MonitorStateClass(object):
+    # No docs available.
+    
+    TRAINING = "TRAINING"
+    """The monitor is in the training stage."""
+    
+    EVALUATION = "EVALUATION"
+    """The monitor is in the evaluation stage."""
+    
+    ERROR = "ERROR"
+    """The monitor is in the evaluation stage."""
+    
+    
+    
 class MonitorStatusClass(DictWrapper):
     """The status of an asset monitor"""
     
     RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.monitor.MonitorStatus")
     def __init__(self,
         mode: Union[str, "MonitorModeClass"],
+        state: Union[None, Union[str, "MonitorStateClass"]]=None,
+        error: Union[None, "MonitorErrorClass"]=None,
+        reviewedAt: Union[None, int]=None,
     ):
         super().__init__()
         
         self.mode = mode
+        self.state = state
+        self.error = error
+        self.reviewedAt = reviewedAt
     
     def _restore_defaults(self) -> None:
         self.mode = MonitorModeClass.ACTIVE
+        self.state = self.RECORD_SCHEMA.fields_dict["state"].default
+        self.error = self.RECORD_SCHEMA.fields_dict["error"].default
+        self.reviewedAt = self.RECORD_SCHEMA.fields_dict["reviewedAt"].default
     
     
     @property
@@ -28411,6 +28682,297 @@ class MonitorStatusClass(DictWrapper):
         self._inner_dict['mode'] = value
     
     
+    @property
+    def state(self) -> Union[None, Union[str, "MonitorStateClass"]]:
+        """The start time of the monitor"""
+        return self._inner_dict.get('state')  # type: ignore
+    
+    @state.setter
+    def state(self, value: Union[None, Union[str, "MonitorStateClass"]]) -> None:
+        self._inner_dict['state'] = value
+    
+    
+    @property
+    def error(self) -> Union[None, "MonitorErrorClass"]:
+        """The last time the monitor was started"""
+        return self._inner_dict.get('error')  # type: ignore
+    
+    @error.setter
+    def error(self, value: Union[None, "MonitorErrorClass"]) -> None:
+        self._inner_dict['error'] = value
+    
+    
+    @property
+    def reviewedAt(self) -> Union[None, int]:
+        """The last time the monitor was started"""
+        return self._inner_dict.get('reviewedAt')  # type: ignore
+    
+    @reviewedAt.setter
+    def reviewedAt(self, value: Union[None, int]) -> None:
+        self._inner_dict['reviewedAt'] = value
+    
+    
+class MonitorSuiteAssertionSettingsClass(DictWrapper):
+    """Settings for assertion monitors within a monitor suite."""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.monitor.MonitorSuiteAssertionSettings")
+    def __init__(self,
+        schedule: Union[None, "FixedIntervalScheduleClass"]=None,
+        trainingDataLookbackWindowDays: Optional[int]=None,
+        action: Union[None, "AssertionActionClass"]=None,
+        exclusionWindows: Union[None, List["AssertionExclusionWindowClass"]]=None,
+    ):
+        super().__init__()
+        
+        self.schedule = schedule
+        if trainingDataLookbackWindowDays is None:
+            # default: 60
+            self.trainingDataLookbackWindowDays = self.RECORD_SCHEMA.fields_dict["trainingDataLookbackWindowDays"].default
+        else:
+            self.trainingDataLookbackWindowDays = trainingDataLookbackWindowDays
+        self.action = action
+        self.exclusionWindows = exclusionWindows
+    
+    def _restore_defaults(self) -> None:
+        self.schedule = self.RECORD_SCHEMA.fields_dict["schedule"].default
+        self.trainingDataLookbackWindowDays = self.RECORD_SCHEMA.fields_dict["trainingDataLookbackWindowDays"].default
+        self.action = self.RECORD_SCHEMA.fields_dict["action"].default
+        self.exclusionWindows = self.RECORD_SCHEMA.fields_dict["exclusionWindows"].default
+    
+    
+    @property
+    def schedule(self) -> Union[None, "FixedIntervalScheduleClass"]:
+        """The schedule for the assertion monitors within this group.
+    Not applicable for freshness anomaly monitors."""
+        return self._inner_dict.get('schedule')  # type: ignore
+    
+    @schedule.setter
+    def schedule(self, value: Union[None, "FixedIntervalScheduleClass"]) -> None:
+        self._inner_dict['schedule'] = value
+    
+    
+    @property
+    def trainingDataLookbackWindowDays(self) -> int:
+        """The lookback window configuration for retrieving training data points.
+    Defines how far back in time to look when gathering data for training.
+    Defaults to 60 days if not specified."""
+        return self._inner_dict.get('trainingDataLookbackWindowDays')  # type: ignore
+    
+    @trainingDataLookbackWindowDays.setter
+    def trainingDataLookbackWindowDays(self, value: int) -> None:
+        self._inner_dict['trainingDataLookbackWindowDays'] = value
+    
+    
+    @property
+    def action(self) -> Union[None, "AssertionActionClass"]:
+        """The action to take when an assertion evaluates.
+    I.e., raise an incident if the assertion fails."""
+        return self._inner_dict.get('action')  # type: ignore
+    
+    @action.setter
+    def action(self, value: Union[None, "AssertionActionClass"]) -> None:
+        self._inner_dict['action'] = value
+    
+    
+    @property
+    def exclusionWindows(self) -> Union[None, List["AssertionExclusionWindowClass"]]:
+        """The exclusion windows for the assertion monitors within this group."""
+        return self._inner_dict.get('exclusionWindows')  # type: ignore
+    
+    @exclusionWindows.setter
+    def exclusionWindows(self, value: Union[None, List["AssertionExclusionWindowClass"]]) -> None:
+        self._inner_dict['exclusionWindows'] = value
+    
+    
+class MonitorSuiteAssignmentSpecClass(DictWrapper):
+    """Information about entities that should be monitored by a monitor suite."""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.monitor.MonitorSuiteAssignmentSpec")
+    def __init__(self,
+        filter: "FilterClass",
+        json: Union[None, str]=None,
+    ):
+        super().__init__()
+        
+        self.filter = filter
+        self.json = json
+    
+    def _restore_defaults(self) -> None:
+        self.filter = FilterClass._construct_with_defaults()
+        self.json = self.RECORD_SCHEMA.fields_dict["json"].default
+    
+    
+    @property
+    def filter(self) -> "FilterClass":
+        """The filter applied when assigning this form to entities. Entities that match this filter
+    will have this form applied to them. Right now this filter only supports filtering by
+    platform, entity type, container, term, tag, domain, and urns through the UI."""
+        return self._inner_dict.get('filter')  # type: ignore
+    
+    @filter.setter
+    def filter(self, value: "FilterClass") -> None:
+        self._inner_dict['filter'] = value
+    
+    
+    @property
+    def json(self) -> Union[None, str]:
+        """The stringified json representing the logical predicate built in the UI to select assets.
+    This predicate is turned into orFilters to send through graphql since graphql doesn't support
+    arbitrary nesting. This string is used to restore the UI for this logical predicate."""
+        return self._inner_dict.get('json')  # type: ignore
+    
+    @json.setter
+    def json(self, value: Union[None, str]) -> None:
+        self._inner_dict['json'] = value
+    
+    
+class MonitorSuiteInfoClass(_Aspect):
+    """Information about an asset monitor."""
+
+
+    ASPECT_NAME = 'monitorSuiteInfo'
+    ASPECT_INFO = {}
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.monitor.MonitorSuiteInfo")
+
+    def __init__(self,
+        type: Union[str, "MonitorSuiteTypeClass"],
+        assignment: "MonitorSuiteAssignmentSpecClass",
+        assertionSettings: Union[None, "MonitorSuiteAssertionSettingsClass"]=None,
+        notificationSettings: Union[None, "MonitorSuiteNotificationSettingsClass"]=None,
+        created: Union[None, "AuditStampClass"]=None,
+        updated: Union[None, "AuditStampClass"]=None,
+    ):
+        super().__init__()
+        
+        self.type = type
+        self.assignment = assignment
+        self.assertionSettings = assertionSettings
+        self.notificationSettings = notificationSettings
+        self.created = created
+        self.updated = updated
+    
+    def _restore_defaults(self) -> None:
+        self.type = MonitorSuiteTypeClass.FRESHNESS
+        self.assignment = MonitorSuiteAssignmentSpecClass._construct_with_defaults()
+        self.assertionSettings = self.RECORD_SCHEMA.fields_dict["assertionSettings"].default
+        self.notificationSettings = self.RECORD_SCHEMA.fields_dict["notificationSettings"].default
+        self.created = self.RECORD_SCHEMA.fields_dict["created"].default
+        self.updated = self.RECORD_SCHEMA.fields_dict["updated"].default
+    
+    
+    @property
+    def type(self) -> Union[str, "MonitorSuiteTypeClass"]:
+        """Type of monitor suite."""
+        return self._inner_dict.get('type')  # type: ignore
+    
+    @type.setter
+    def type(self, value: Union[str, "MonitorSuiteTypeClass"]) -> None:
+        self._inner_dict['type'] = value
+    
+    
+    @property
+    def assignment(self) -> "MonitorSuiteAssignmentSpecClass":
+        """The assignment rule to define the entities that are monitored by this group."""
+        return self._inner_dict.get('assignment')  # type: ignore
+    
+    @assignment.setter
+    def assignment(self, value: "MonitorSuiteAssignmentSpecClass") -> None:
+        self._inner_dict['assignment'] = value
+    
+    
+    @property
+    def assertionSettings(self) -> Union[None, "MonitorSuiteAssertionSettingsClass"]:
+        """Settings for assertion monitors within this group."""
+        return self._inner_dict.get('assertionSettings')  # type: ignore
+    
+    @assertionSettings.setter
+    def assertionSettings(self, value: Union[None, "MonitorSuiteAssertionSettingsClass"]) -> None:
+        self._inner_dict['assertionSettings'] = value
+    
+    
+    @property
+    def notificationSettings(self) -> Union[None, "MonitorSuiteNotificationSettingsClass"]:
+        """Settings for notifications from monitors within this group."""
+        return self._inner_dict.get('notificationSettings')  # type: ignore
+    
+    @notificationSettings.setter
+    def notificationSettings(self, value: Union[None, "MonitorSuiteNotificationSettingsClass"]) -> None:
+        self._inner_dict['notificationSettings'] = 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 updated(self) -> Union[None, "AuditStampClass"]:
+        """Updated Audit stamp"""
+        return self._inner_dict.get('updated')  # type: ignore
+    
+    @updated.setter
+    def updated(self, value: Union[None, "AuditStampClass"]) -> None:
+        self._inner_dict['updated'] = value
+    
+    
+class MonitorSuiteNotificationSettingsClass(DictWrapper):
+    """Settings for notifications from monitors within a monitor suite."""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.monitor.MonitorSuiteNotificationSettings")
+    def __init__(self,
+        entityChangeTypes: List["EntityChangeDetailsClass"],
+        notificationConfig: "SubscriptionNotificationConfigClass",
+    ):
+        super().__init__()
+        
+        self.entityChangeTypes = entityChangeTypes
+        self.notificationConfig = notificationConfig
+    
+    def _restore_defaults(self) -> None:
+        self.entityChangeTypes = list()
+        self.notificationConfig = SubscriptionNotificationConfigClass._construct_with_defaults()
+    
+    
+    @property
+    def entityChangeTypes(self) -> List["EntityChangeDetailsClass"]:
+        """The change types that trigger a notification for the monitor suite.
+    NOTE: only use Assertion and Incident change types for monitor suites."""
+        return self._inner_dict.get('entityChangeTypes')  # type: ignore
+    
+    @entityChangeTypes.setter
+    def entityChangeTypes(self, value: List["EntityChangeDetailsClass"]) -> None:
+        self._inner_dict['entityChangeTypes'] = value
+    
+    
+    @property
+    def notificationConfig(self) -> "SubscriptionNotificationConfigClass":
+        """The notification config for the monitor suite."""
+        return self._inner_dict.get('notificationConfig')  # type: ignore
+    
+    @notificationConfig.setter
+    def notificationConfig(self, value: "SubscriptionNotificationConfigClass") -> None:
+        self._inner_dict['notificationConfig'] = value
+    
+    
+class MonitorSuiteTypeClass(object):
+    # No docs available.
+    
+    FRESHNESS = "FRESHNESS"
+    """A monitor responsible for evaluating freshness anomalies."""
+    
+    VOLUME = "VOLUME"
+    """A monitor responsible for evaluating volume anomalies."""
+    
+    DATA_SCHEMA = "DATA_SCHEMA"
+    """A monitor responsible for evaluating schema changes."""
+    
+    
+    
 class MonitorTimeseriesStateClass(_Aspect):
     """Stats required to evaluate continuous monitors."""
 
@@ -30681,12 +31243,18 @@ class QueryPropertiesClass(_Aspect):
         source: Union[str, "QuerySourceClass"],
         created: "AuditStampClass",
         lastModified: "AuditStampClass",
+        customProperties: Optional[Dict[str, str]]=None,
         name: Union[None, str]=None,
         description: Union[None, str]=None,
         origin: Union[None, str]=None,
     ):
         super().__init__()
         
+        if customProperties is None:
+            # default: {}
+            self.customProperties = dict()
+        else:
+            self.customProperties = customProperties
         self.statement = statement
         self.source = source
         self.name = name
@@ -30696,6 +31264,7 @@ class QueryPropertiesClass(_Aspect):
         self.origin = origin
     
     def _restore_defaults(self) -> None:
+        self.customProperties = dict()
         self.statement = QueryStatementClass._construct_with_defaults()
         self.source = QuerySourceClass.MANUAL
         self.name = self.RECORD_SCHEMA.fields_dict["name"].default
@@ -30705,6 +31274,16 @@ class QueryPropertiesClass(_Aspect):
         self.origin = self.RECORD_SCHEMA.fields_dict["origin"].default
     
     
+    @property
+    def customProperties(self) -> Dict[str, str]:
+        """Custom property bag."""
+        return self._inner_dict.get('customProperties')  # type: ignore
+    
+    @customProperties.setter
+    def customProperties(self, value: Dict[str, str]) -> None:
+        self._inner_dict['customProperties'] = value
+    
+    
     @property
     def statement(self) -> "QueryStatementClass":
         """The Query Statement."""
@@ -32964,7 +33543,9 @@ class NotificationSettingClass(DictWrapper):
     
     @property
     def params(self) -> Union[None, Dict[str, str]]:
-        """Custom set of setting parameters."""
+        """Custom set of setting parameters.
+    Currently used to store sink enabled / disabled settings.
+    E.g. slack.enabled = true, email.enabled = false"""
         return self._inner_dict.get('params')  # type: ignore
     
     @params.setter
@@ -35484,6 +36065,44 @@ class TestStatusClass(DictWrapper):
         self._inner_dict['mode'] = value
     
     
+class AbsoluteTimeWindowClass(DictWrapper):
+    # No docs available.
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.timeseries.AbsoluteTimeWindow")
+    def __init__(self,
+        startTimeMillis: int,
+        endTimeMillis: int,
+    ):
+        super().__init__()
+        
+        self.startTimeMillis = startTimeMillis
+        self.endTimeMillis = endTimeMillis
+    
+    def _restore_defaults(self) -> None:
+        self.startTimeMillis = int()
+        self.endTimeMillis = int()
+    
+    
+    @property
+    def startTimeMillis(self) -> int:
+        """Start time as epoch at UTC."""
+        return self._inner_dict.get('startTimeMillis')  # type: ignore
+    
+    @startTimeMillis.setter
+    def startTimeMillis(self, value: int) -> None:
+        self._inner_dict['startTimeMillis'] = value
+    
+    
+    @property
+    def endTimeMillis(self) -> int:
+        """End time as epoch at UTC."""
+        return self._inner_dict.get('endTimeMillis')  # type: ignore
+    
+    @endTimeMillis.setter
+    def endTimeMillis(self, value: int) -> None:
+        self._inner_dict['endTimeMillis'] = value
+    
+    
 class CalendarIntervalClass(object):
     # No docs available.
     
@@ -35497,6 +36116,71 @@ class CalendarIntervalClass(object):
     YEAR = "YEAR"
     
     
+class DayOfWeekClass(object):
+    # No docs available.
+    
+    MONDAY = "MONDAY"
+    TUESDAY = "TUESDAY"
+    WEDNESDAY = "WEDNESDAY"
+    THURSDAY = "THURSDAY"
+    FRIDAY = "FRIDAY"
+    SATURDAY = "SATURDAY"
+    SUNDAY = "SUNDAY"
+    
+    
+class HolidayWindowClass(DictWrapper):
+    # No docs available.
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.timeseries.HolidayWindow")
+    def __init__(self,
+        name: str,
+        region: Union[None, str]=None,
+        timezone: Union[None, str]=None,
+    ):
+        super().__init__()
+        
+        self.name = name
+        self.region = region
+        self.timezone = timezone
+    
+    def _restore_defaults(self) -> None:
+        self.name = str()
+        self.region = self.RECORD_SCHEMA.fields_dict["region"].default
+        self.timezone = self.RECORD_SCHEMA.fields_dict["timezone"].default
+    
+    
+    @property
+    def name(self) -> str:
+        """The name of the holiday."""
+        return self._inner_dict.get('name')  # type: ignore
+    
+    @name.setter
+    def name(self, value: str) -> None:
+        self._inner_dict['name'] = value
+    
+    
+    @property
+    def region(self) -> Union[None, str]:
+        """The region of the holiday.
+    Example: 'US'"""
+        return self._inner_dict.get('region')  # type: ignore
+    
+    @region.setter
+    def region(self, value: Union[None, str]) -> None:
+        self._inner_dict['region'] = value
+    
+    
+    @property
+    def timezone(self) -> Union[None, str]:
+        """The timezone of the holiday.
+    Example: 'America/New_York'"""
+        return self._inner_dict.get('timezone')  # type: ignore
+    
+    @timezone.setter
+    def timezone(self, value: Union[None, str]) -> None:
+        self._inner_dict['timezone'] = value
+    
+    
 class PartitionSpecClass(DictWrapper):
     """A reference to a specific partition in a dataset."""
     
@@ -35641,6 +36325,78 @@ class TimeWindowSizeClass(DictWrapper):
         self._inner_dict['multiple'] = value
     
     
+class WeeklyWindowClass(DictWrapper):
+    """Represents a recurring time window that repeats weekly.
+    Used to define exclusion periods for model training based on day of week and time of day."""
+    
+    RECORD_SCHEMA = get_schema_type("com.linkedin.pegasus2avro.timeseries.WeeklyWindow")
+    def __init__(self,
+        daysOfWeek: List[Union[str, "DayOfWeekClass"]],
+        startTime: Union[None, str]=None,
+        endTime: Union[None, str]=None,
+        timezone: Union[None, str]=None,
+    ):
+        super().__init__()
+        
+        self.daysOfWeek = daysOfWeek
+        self.startTime = startTime
+        self.endTime = endTime
+        self.timezone = timezone
+    
+    def _restore_defaults(self) -> None:
+        self.daysOfWeek = list()
+        self.startTime = self.RECORD_SCHEMA.fields_dict["startTime"].default
+        self.endTime = self.RECORD_SCHEMA.fields_dict["endTime"].default
+        self.timezone = self.RECORD_SCHEMA.fields_dict["timezone"].default
+    
+    
+    @property
+    def daysOfWeek(self) -> List[Union[str, "DayOfWeekClass"]]:
+        """Days of the week to include in the window.
+    If not specified, all days are included."""
+        return self._inner_dict.get('daysOfWeek')  # type: ignore
+    
+    @daysOfWeek.setter
+    def daysOfWeek(self, value: List[Union[str, "DayOfWeekClass"]]) -> None:
+        self._inner_dict['daysOfWeek'] = value
+    
+    
+    @property
+    def startTime(self) -> Union[None, str]:
+        """Start time for the window on each specified day.
+    Format: "HH:MM" in 24-hour format (e.g., "09:00" for 9am, "17:30" for 5:30pm).
+    If not specified, defaults to start of day ("00:00")."""
+        return self._inner_dict.get('startTime')  # type: ignore
+    
+    @startTime.setter
+    def startTime(self, value: Union[None, str]) -> None:
+        self._inner_dict['startTime'] = value
+    
+    
+    @property
+    def endTime(self) -> Union[None, str]:
+        """End time for the window on each specified day.
+    Format: "HH:MM" in 24-hour format (e.g., "17:00" for 5pm, "23:59" for end of day).
+    If not specified, defaults to end of day ("23:59")."""
+        return self._inner_dict.get('endTime')  # type: ignore
+    
+    @endTime.setter
+    def endTime(self, value: Union[None, str]) -> None:
+        self._inner_dict['endTime'] = value
+    
+    
+    @property
+    def timezone(self) -> Union[None, str]:
+        """Time zone to interpret start and end times in.
+    Uses standard time zone identifiers (e.g., "America/Los_Angeles", "UTC").
+    If not specified, defaults to UTC."""
+        return self._inner_dict.get('timezone')  # type: ignore
+    
+    @timezone.setter
+    def timezone(self, value: Union[None, str]) -> None:
+        self._inner_dict['timezone'] = value
+    
+    
 class DataHubUpgradeRequestClass(_Aspect):
     """Information collected when kicking off a DataHubUpgrade"""
 
@@ -36234,16 +36990,11 @@ __SCHEMA_TYPES = {
     '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,
     'com.linkedin.pegasus2avro.anomaly.AnomalySource': AnomalySourceClass,
     'com.linkedin.pegasus2avro.anomaly.AnomalySourceProperties': AnomalySourcePropertiesClass,
     'com.linkedin.pegasus2avro.anomaly.AnomalySourceType': AnomalySourceTypeClass,
-    'com.linkedin.pegasus2avro.anomaly.AnomalyState': AnomalyStateClass,
-    'com.linkedin.pegasus2avro.anomaly.AnomalyStatus': AnomalyStatusClass,
-    'com.linkedin.pegasus2avro.anomaly.AnomalyStatusProperties': AnomalyStatusPropertiesClass,
-    'com.linkedin.pegasus2avro.anomaly.AnomalyType': AnomalyTypeClass,
+    'com.linkedin.pegasus2avro.anomaly.MonitorAnomalyEvent': MonitorAnomalyEventClass,
     'com.linkedin.pegasus2avro.assertion.AdjustmentAlgorithm': AdjustmentAlgorithmClass,
     'com.linkedin.pegasus2avro.assertion.AssertionAction': AssertionActionClass,
     'com.linkedin.pegasus2avro.assertion.AssertionActionType': AssertionActionTypeClass,
@@ -36252,8 +37003,11 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.assertion.AssertionAnalyticsRunEvent': AssertionAnalyticsRunEventClass,
     'com.linkedin.pegasus2avro.assertion.AssertionDryRunEvent': AssertionDryRunEventClass,
     'com.linkedin.pegasus2avro.assertion.AssertionDryRunResult': AssertionDryRunResultClass,
+    'com.linkedin.pegasus2avro.assertion.AssertionExclusionWindow': AssertionExclusionWindowClass,
+    'com.linkedin.pegasus2avro.assertion.AssertionExclusionWindowType': AssertionExclusionWindowTypeClass,
     'com.linkedin.pegasus2avro.assertion.AssertionInferenceDetails': AssertionInferenceDetailsClass,
     'com.linkedin.pegasus2avro.assertion.AssertionInfo': AssertionInfoClass,
+    'com.linkedin.pegasus2avro.assertion.AssertionMonitorSensitivity': AssertionMonitorSensitivityClass,
     'com.linkedin.pegasus2avro.assertion.AssertionResult': AssertionResultClass,
     'com.linkedin.pegasus2avro.assertion.AssertionResultError': AssertionResultErrorClass,
     'com.linkedin.pegasus2avro.assertion.AssertionResultErrorType': AssertionResultErrorTypeClass,
@@ -36362,6 +37116,7 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.common.InputFields': InputFieldsClass,
     'com.linkedin.pegasus2avro.common.InstitutionalMemory': InstitutionalMemoryClass,
     'com.linkedin.pegasus2avro.common.InstitutionalMemoryMetadata': InstitutionalMemoryMetadataClass,
+    'com.linkedin.pegasus2avro.common.InstitutionalMemoryMetadataSettings': InstitutionalMemoryMetadataSettingsClass,
     'com.linkedin.pegasus2avro.common.MLFeatureDataType': MLFeatureDataTypeClass,
     'com.linkedin.pegasus2avro.common.Media': MediaClass,
     'com.linkedin.pegasus2avro.common.MediaType': MediaTypeClass,
@@ -36627,6 +37382,7 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.metadata.key.MLModelKey': MLModelKeyClass,
     'com.linkedin.pegasus2avro.metadata.key.MLPrimaryKeyKey': MLPrimaryKeyKeyClass,
     'com.linkedin.pegasus2avro.metadata.key.MonitorKey': MonitorKeyClass,
+    'com.linkedin.pegasus2avro.metadata.key.MonitorSuiteKey': MonitorSuiteKeyClass,
     'com.linkedin.pegasus2avro.metadata.key.NotebookKey': NotebookKeyClass,
     'com.linkedin.pegasus2avro.metadata.key.OwnershipTypeKey': OwnershipTypeKeyClass,
     'com.linkedin.pegasus2avro.metadata.key.PostKey': PostKeyClass,
@@ -36736,9 +37492,17 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.monitor.DatasetVolumeAssertionParameters': DatasetVolumeAssertionParametersClass,
     'com.linkedin.pegasus2avro.monitor.DatasetVolumeSourceType': DatasetVolumeSourceTypeClass,
     'com.linkedin.pegasus2avro.monitor.EmbeddedAssertion': EmbeddedAssertionClass,
+    'com.linkedin.pegasus2avro.monitor.MonitorError': MonitorErrorClass,
+    'com.linkedin.pegasus2avro.monitor.MonitorErrorType': MonitorErrorTypeClass,
     'com.linkedin.pegasus2avro.monitor.MonitorInfo': MonitorInfoClass,
     'com.linkedin.pegasus2avro.monitor.MonitorMode': MonitorModeClass,
+    'com.linkedin.pegasus2avro.monitor.MonitorState': MonitorStateClass,
     'com.linkedin.pegasus2avro.monitor.MonitorStatus': MonitorStatusClass,
+    'com.linkedin.pegasus2avro.monitor.MonitorSuiteAssertionSettings': MonitorSuiteAssertionSettingsClass,
+    'com.linkedin.pegasus2avro.monitor.MonitorSuiteAssignmentSpec': MonitorSuiteAssignmentSpecClass,
+    'com.linkedin.pegasus2avro.monitor.MonitorSuiteInfo': MonitorSuiteInfoClass,
+    'com.linkedin.pegasus2avro.monitor.MonitorSuiteNotificationSettings': MonitorSuiteNotificationSettingsClass,
+    'com.linkedin.pegasus2avro.monitor.MonitorSuiteType': MonitorSuiteTypeClass,
     'com.linkedin.pegasus2avro.monitor.MonitorTimeseriesState': MonitorTimeseriesStateClass,
     'com.linkedin.pegasus2avro.monitor.MonitorType': MonitorTypeClass,
     'com.linkedin.pegasus2avro.mxe.GenericAspect': GenericAspectClass,
@@ -36876,11 +37640,15 @@ __SCHEMA_TYPES = {
     'com.linkedin.pegasus2avro.test.TestSource': TestSourceClass,
     'com.linkedin.pegasus2avro.test.TestSourceType': TestSourceTypeClass,
     'com.linkedin.pegasus2avro.test.TestStatus': TestStatusClass,
+    'com.linkedin.pegasus2avro.timeseries.AbsoluteTimeWindow': AbsoluteTimeWindowClass,
     'com.linkedin.pegasus2avro.timeseries.CalendarInterval': CalendarIntervalClass,
+    'com.linkedin.pegasus2avro.timeseries.DayOfWeek': DayOfWeekClass,
+    'com.linkedin.pegasus2avro.timeseries.HolidayWindow': HolidayWindowClass,
     'com.linkedin.pegasus2avro.timeseries.PartitionSpec': PartitionSpecClass,
     'com.linkedin.pegasus2avro.timeseries.PartitionType': PartitionTypeClass,
     'com.linkedin.pegasus2avro.timeseries.TimeWindow': TimeWindowClass,
     'com.linkedin.pegasus2avro.timeseries.TimeWindowSize': TimeWindowSizeClass,
+    'com.linkedin.pegasus2avro.timeseries.WeeklyWindow': WeeklyWindowClass,
     'com.linkedin.pegasus2avro.upgrade.DataHubUpgradeRequest': DataHubUpgradeRequestClass,
     'com.linkedin.pegasus2avro.upgrade.DataHubUpgradeResult': DataHubUpgradeResultClass,
     'com.linkedin.pegasus2avro.upgrade.DataHubUpgradeState': DataHubUpgradeStateClass,
@@ -36923,16 +37691,11 @@ __SCHEMA_TYPES = {
     'GlossaryTermsInferenceMetadata': GlossaryTermsInferenceMetadataClass,
     'InferenceGroupMetadata': InferenceGroupMetadataClass,
     'InferenceMetadata': InferenceMetadataClass,
-    'AnomalyInfo': AnomalyInfoClass,
-    'AnomalyReview': AnomalyReviewClass,
     'AnomalyReviewState': AnomalyReviewStateClass,
     'AnomalySource': AnomalySourceClass,
     'AnomalySourceProperties': AnomalySourcePropertiesClass,
     'AnomalySourceType': AnomalySourceTypeClass,
-    'AnomalyState': AnomalyStateClass,
-    'AnomalyStatus': AnomalyStatusClass,
-    'AnomalyStatusProperties': AnomalyStatusPropertiesClass,
-    'AnomalyType': AnomalyTypeClass,
+    'MonitorAnomalyEvent': MonitorAnomalyEventClass,
     'AdjustmentAlgorithm': AdjustmentAlgorithmClass,
     'AssertionAction': AssertionActionClass,
     'AssertionActionType': AssertionActionTypeClass,
@@ -36941,8 +37704,11 @@ __SCHEMA_TYPES = {
     'AssertionAnalyticsRunEvent': AssertionAnalyticsRunEventClass,
     'AssertionDryRunEvent': AssertionDryRunEventClass,
     'AssertionDryRunResult': AssertionDryRunResultClass,
+    'AssertionExclusionWindow': AssertionExclusionWindowClass,
+    'AssertionExclusionWindowType': AssertionExclusionWindowTypeClass,
     'AssertionInferenceDetails': AssertionInferenceDetailsClass,
     'AssertionInfo': AssertionInfoClass,
+    'AssertionMonitorSensitivity': AssertionMonitorSensitivityClass,
     'AssertionResult': AssertionResultClass,
     'AssertionResultError': AssertionResultErrorClass,
     'AssertionResultErrorType': AssertionResultErrorTypeClass,
@@ -37051,6 +37817,7 @@ __SCHEMA_TYPES = {
     'InputFields': InputFieldsClass,
     'InstitutionalMemory': InstitutionalMemoryClass,
     'InstitutionalMemoryMetadata': InstitutionalMemoryMetadataClass,
+    'InstitutionalMemoryMetadataSettings': InstitutionalMemoryMetadataSettingsClass,
     'MLFeatureDataType': MLFeatureDataTypeClass,
     'Media': MediaClass,
     'MediaType': MediaTypeClass,
@@ -37316,6 +38083,7 @@ __SCHEMA_TYPES = {
     'MLModelKey': MLModelKeyClass,
     'MLPrimaryKeyKey': MLPrimaryKeyKeyClass,
     'MonitorKey': MonitorKeyClass,
+    'MonitorSuiteKey': MonitorSuiteKeyClass,
     'NotebookKey': NotebookKeyClass,
     'OwnershipTypeKey': OwnershipTypeKeyClass,
     'PostKey': PostKeyClass,
@@ -37425,9 +38193,17 @@ __SCHEMA_TYPES = {
     'DatasetVolumeAssertionParameters': DatasetVolumeAssertionParametersClass,
     'DatasetVolumeSourceType': DatasetVolumeSourceTypeClass,
     'EmbeddedAssertion': EmbeddedAssertionClass,
+    'MonitorError': MonitorErrorClass,
+    'MonitorErrorType': MonitorErrorTypeClass,
     'MonitorInfo': MonitorInfoClass,
     'MonitorMode': MonitorModeClass,
+    'MonitorState': MonitorStateClass,
     'MonitorStatus': MonitorStatusClass,
+    'MonitorSuiteAssertionSettings': MonitorSuiteAssertionSettingsClass,
+    'MonitorSuiteAssignmentSpec': MonitorSuiteAssignmentSpecClass,
+    'MonitorSuiteInfo': MonitorSuiteInfoClass,
+    'MonitorSuiteNotificationSettings': MonitorSuiteNotificationSettingsClass,
+    'MonitorSuiteType': MonitorSuiteTypeClass,
     'MonitorTimeseriesState': MonitorTimeseriesStateClass,
     'MonitorType': MonitorTypeClass,
     'GenericAspect': GenericAspectClass,
@@ -37565,11 +38341,15 @@ __SCHEMA_TYPES = {
     'TestSource': TestSourceClass,
     'TestSourceType': TestSourceTypeClass,
     'TestStatus': TestStatusClass,
+    'AbsoluteTimeWindow': AbsoluteTimeWindowClass,
     'CalendarInterval': CalendarIntervalClass,
+    'DayOfWeek': DayOfWeekClass,
+    'HolidayWindow': HolidayWindowClass,
     'PartitionSpec': PartitionSpecClass,
     'PartitionType': PartitionTypeClass,
     'TimeWindow': TimeWindowClass,
     'TimeWindowSize': TimeWindowSizeClass,
+    'WeeklyWindow': WeeklyWindowClass,
     'DataHubUpgradeRequest': DataHubUpgradeRequestClass,
     'DataHubUpgradeResult': DataHubUpgradeResultClass,
     'DataHubUpgradeState': DataHubUpgradeStateClass,
@@ -37591,761 +38371,765 @@ avrojson.set_global_json_converter(_json_converter)
     
 
 ASPECT_CLASSES: List[Type[_Aspect]] = [
-    DataHubSecretValueClass,
-    DataHubViewInfoClass,
-    OwnershipTypeInfoClass,
-    AssertionInfoClass,
-    AssertionAnalyticsRunEventClass,
-    AssertionActionsClass,
-    AssertionDryRunEventClass,
-    AssertionInferenceDetailsClass,
-    AssertionRunEventClass,
-    AssertionSummaryClass,
-    ExecutionRequestSignalClass,
-    ExecutionRequestResultClass,
-    ExecutionRequestInputClass,
-    RemoteExecutorStatusClass,
-    MLMetricClass,
-    MLModelGroupPropertiesClass,
-    MLModelFactorPromptsClass,
-    EvaluationDataClass,
-    MLModelDeploymentPropertiesClass,
-    IntendedUseClass,
-    MLModelPropertiesClass,
-    EditableMLPrimaryKeyPropertiesClass,
-    MetricsClass,
-    SourceCodeClass,
-    QuantitativeAnalysesClass,
-    TrainingDataClass,
-    EditableMLFeatureTablePropertiesClass,
-    MLPrimaryKeyPropertiesClass,
-    EditableMLModelGroupPropertiesClass,
-    CaveatsAndRecommendationsClass,
-    MLFeaturePropertiesClass,
-    MLFeatureTablePropertiesClass,
-    MLTrainingRunPropertiesClass,
-    EditableMLFeaturePropertiesClass,
-    MLHyperParamClass,
-    EditableMLModelPropertiesClass,
-    EthicalConsiderationsClass,
+    RolePropertiesClass,
+    ActorsClass,
     EditableContainerPropertiesClass,
     ContainerPropertiesClass,
     ContainerClass,
-    RemoteExecutorPoolGlobalConfigClass,
-    DataHubRetentionConfigClass,
-    TelemetryClientIdClass,
-    DataHubAccessTokenInfoClass,
-    DataProductKeyClass,
-    DataProductPropertiesClass,
-    ActorsClass,
-    RolePropertiesClass,
-    InferredMetadataClass,
-    InferredNeighborsClass,
-    SchemaFieldsInferredNeighborsClass,
-    SchemaFieldsInferredMetadataClass,
-    DataJobInputOutputClass,
-    VersionInfoClass,
-    DataJobInfoClass,
-    EditableDataFlowPropertiesClass,
-    DataFlowInfoClass,
-    EditableDataJobPropertiesClass,
-    DatahubIngestionRunSummaryClass,
-    DatahubIngestionCheckpointClass,
-    MonitorInfoClass,
-    MonitorTimeseriesStateClass,
-    SchemaFieldAliasesClass,
-    SchemaFieldInfoClass,
-    IncidentInfoClass,
-    IncidentNotificationDetailsClass,
-    IncidentSourceClass,
-    IncidentActivityEventClass,
-    DataHubUpgradeResultClass,
-    DataHubUpgradeRequestClass,
-    SubscriptionInfoClass,
-    DataHubPersonaInfoClass,
-    GlobalSettingsInfoClass,
-    RemoteExecutorPoolInfoClass,
-    StructuredPropertiesClass,
-    StructuredPropertyKeyClass,
-    StructuredPropertySettingsClass,
-    StructuredPropertyDefinitionClass,
-    AiInferenceMetadataClass,
-    EntityInferenceMetadataClass,
-    TestResultsClass,
-    TestInfoClass,
-    BatchTestRunEventClass,
-    DataPlatformInstancePropertiesClass,
-    IcebergWarehouseInfoClass,
-    EditableERModelRelationshipPropertiesClass,
-    ERModelRelationshipPropertiesClass,
-    EntityTypeInfoClass,
-    EntityTypeKeyClass,
-    PlatformResourceKeyClass,
-    PlatformResourceInfoClass,
-    EditableSchemaMetadataClass,
-    SchemaProposalsClass,
-    SchemaMetadataClass,
-    DataHubMetricCubeEventClass,
-    DataHubMetricCubeDefinitionClass,
-    AccessClass,
-    AnomaliesSummaryClass,
-    ProposalsClass,
-    InputFieldsClass,
-    GlobalTagsClass,
-    OriginClass,
-    GlossaryTermsClass,
-    DataPlatformInstanceClass,
-    OwnershipClass,
-    DocumentationClass,
-    DeprecationClass,
-    VersionPropertiesClass,
-    SiblingsClass,
-    ShareClass,
-    StatusClass,
-    IncidentsSummaryClass,
-    BrowsePathsV2Class,
-    DisplayPropertiesClass,
-    CostClass,
-    AssertionsSummaryClass,
-    InstitutionalMemoryClass,
-    BrowsePathsClass,
-    EmbedClass,
-    OperationClass,
-    FormsClass,
-    SubTypesClass,
-    DataTransformLogicClass,
     DataContractPropertiesClass,
     DataContractStatusClass,
-    BusinessAttributeInfoClass,
-    BusinessAttributesClass,
-    BusinessAttributeKeyClass,
-    FormInfoClass,
-    DynamicFormAssignmentClass,
-    DomainPropertiesClass,
-    DomainsClass,
-    DataHubConnectionDetailsClass,
-    DataProcessInstanceInputClass,
-    DataProcessInstanceRelationshipsClass,
-    DataProcessInstancePropertiesClass,
-    DataProcessInstanceRunEventClass,
-    DataProcessInfoClass,
-    DataProcessInstanceOutputClass,
-    AnomalyInfoClass,
-    SchemaFieldProfileClass,
+    DataHubSecretValueClass,
+    DataHubUpgradeResultClass,
+    DataHubUpgradeRequestClass,
+    DataHubAccessTokenInfoClass,
+    DatasetUsageStatisticsClass,
+    UpstreamLineageClass,
+    ViewPropertiesClass,
     EditableDatasetPropertiesClass,
     DatasetProfileClass,
+    SchemaFieldProfileClass,
     DatasetDeprecationClass,
     IcebergCatalogInfoClass,
     DatasetPropertiesClass,
     PartitionsSummaryClass,
     DatasetUpstreamLineageClass,
-    DatasetUsageStatisticsClass,
-    ViewPropertiesClass,
-    UpstreamLineageClass,
-    GlossaryNodeInfoClass,
-    GlossaryTermInfoClass,
-    GlossaryRelatedTermsClass,
-    CorpUserCredentialsClass,
-    InviteTokenClass,
-    CorpUserStatusClass,
-    CorpGroupSettingsClass,
-    CorpUserInfoClass,
-    CorpUserEditableInfoClass,
-    NativeGroupMembershipClass,
-    CorpGroupInfoClass,
-    CorpGroupEditableInfoClass,
-    CorpUserSettingsClass,
-    RoleMembershipClass,
-    GroupMembershipClass,
-    DataTypeKeyClass,
-    DataTypeInfoClass,
-    NotebookInfoClass,
-    EditableNotebookPropertiesClass,
-    NotebookContentClass,
-    TagPropertiesClass,
-    ActionRequestInfoClass,
-    ActionRequestArchivedClass,
-    ActionRequestStatusClass,
+    UsageFeaturesClass,
+    StorageFeaturesClass,
+    LineageFeaturesClass,
+    CostFeaturesClass,
+    DataPlatformInstanceKeyClass,
+    DataHubRoleKeyClass,
+    DataHubUpgradeKeyClass,
+    DataHubPersonaKeyClass,
+    TagKeyClass,
+    MLModelGroupKeyClass,
+    DataContractKeyClass,
+    DomainKeyClass,
     InviteTokenKeyClass,
-    AssertionKeyClass,
-    SchemaFieldKeyClass,
-    CorpGroupKeyClass,
-    RoleKeyClass,
+    DashboardKeyClass,
+    DataFlowKeyClass,
     DataProcessInstanceKeyClass,
-    DataHubSecretKeyClass,
-    DataHubPersonaKeyClass,
+    CorpUserKeyClass,
+    DataHubRetentionKeyClass,
+    NotebookKeyClass,
+    IncidentKeyClass,
     MLFeatureTableKeyClass,
-    GlossaryTermKeyClass,
-    RecommendationModuleKeyClass,
-    PostKeyClass,
-    MLPrimaryKeyKeyClass,
-    DataPlatformInstanceKeyClass,
-    DataHubMetricCubeKeyClass,
-    QueryKeyClass,
-    DatasetKeyClass,
-    ExecutionRequestKeyClass,
-    ChartKeyClass,
-    MLModelGroupKeyClass,
+    ConstraintKeyClass,
     SubscriptionKeyClass,
-    AnomalyKeyClass,
+    QueryKeyClass,
+    MLFeatureKeyClass,
+    RemoteExecutorGlobalConfigKeyClass,
+    GlobalSettingsKeyClass,
+    MLModelKeyClass,
+    VersionSetKeyClass,
     RemoteExecutorPoolKeyClass,
-    DataJobKeyClass,
-    DomainKeyClass,
-    ERModelRelationshipKeyClass,
-    DataHubRoleKeyClass,
-    FormKeyClass,
-    DataHubAccessTokenKeyClass,
     DataHubActionKeyClass,
-    DataPlatformKeyClass,
+    DataJobKeyClass,
+    CorpGroupKeyClass,
+    RoleKeyClass,
     ContainerKeyClass,
-    TagKeyClass,
+    MLPrimaryKeyKeyClass,
     DataHubPolicyKeyClass,
-    ConstraintKeyClass,
-    GlossaryNodeKeyClass,
-    DataProcessKeyClass,
+    DataHubMetricCubeKeyClass,
+    ERModelRelationshipKeyClass,
+    GlossaryTermKeyClass,
     DataHubStepStateKeyClass,
-    NotebookKeyClass,
-    MLFeatureKeyClass,
-    DataHubUpgradeKeyClass,
-    DashboardKeyClass,
-    MLModelKeyClass,
-    IncidentKeyClass,
-    GlobalSettingsKeyClass,
-    DataHubViewKeyClass,
-    DataHubRetentionKeyClass,
+    GlossaryNodeKeyClass,
+    FormKeyClass,
+    LinkPreviewKeyClass,
+    ChartKeyClass,
+    DataHubSecretKeyClass,
     OwnershipTypeKeyClass,
-    ActionRequestKeyClass,
-    RemoteExecutorGlobalConfigKeyClass,
-    DataFlowKeyClass,
+    MonitorSuiteKeyClass,
     GenericEntityKeyClass,
-    DataContractKeyClass,
-    DataHubConnectionKeyClass,
+    TelemetryKeyClass,
+    MLModelDeploymentKeyClass,
+    AssertionKeyClass,
+    ExecutionRequestKeyClass,
+    DataHubAccessTokenKeyClass,
+    DataHubIngestionSourceKeyClass,
+    DatasetKeyClass,
+    ActionRequestKeyClass,
+    DataHubViewKeyClass,
     RemoteExecutorKeyClass,
-    MonitorKeyClass,
-    CorpUserKeyClass,
-    VersionSetKeyClass,
     TestKeyClass,
-    DataHubIngestionSourceKeyClass,
-    MLModelDeploymentKeyClass,
-    LinkPreviewKeyClass,
-    TelemetryKeyClass,
-    UsageFeaturesClass,
-    CostFeaturesClass,
-    LineageFeaturesClass,
-    StorageFeaturesClass,
+    DataPlatformKeyClass,
+    AnomalyKeyClass,
+    DataProcessKeyClass,
+    DataHubConnectionKeyClass,
+    RecommendationModuleKeyClass,
+    SchemaFieldKeyClass,
+    PostKeyClass,
+    MonitorKeyClass,
     RecommendationModuleClass,
-    DataHubIngestionSourceInfoClass,
-    LinkPreviewInfoClass,
-    DataHubStepStatePropertiesClass,
-    PostInfoClass,
-    DataHubPolicyInfoClass,
-    DataHubRoleInfoClass,
-    QuerySubjectsClass,
-    QueryUsageFeaturesClass,
-    QueryPropertiesClass,
-    QueryUsageStatisticsClass,
+    DataHubConnectionDetailsClass,
+    ChartQueryClass,
+    EditableChartPropertiesClass,
     ChartUsageStatisticsClass,
     ChartInfoClass,
-    EditableChartPropertiesClass,
-    ChartQueryClass,
-    VersionSetPropertiesClass,
-    DashboardUsageStatisticsClass,
-    DashboardInfoClass,
-    EditableDashboardPropertiesClass,
+    DataTypeInfoClass,
+    DataTypeKeyClass,
+    ERModelRelationshipPropertiesClass,
+    EditableERModelRelationshipPropertiesClass,
+    EntityInferenceMetadataClass,
+    AiInferenceMetadataClass,
+    RemoteExecutorStatusClass,
+    PostInfoClass,
+    DataHubRetentionConfigClass,
+    DynamicFormAssignmentClass,
+    FormInfoClass,
+    DataProcessInstanceRelationshipsClass,
+    DataProcessInfoClass,
+    DataProcessInstanceInputClass,
+    DataProcessInstanceOutputClass,
+    DataProcessInstancePropertiesClass,
+    DataProcessInstanceRunEventClass,
+    BusinessAttributeInfoClass,
+    BusinessAttributeKeyClass,
+    BusinessAttributesClass,
+    ExecutionRequestSignalClass,
+    ExecutionRequestInputClass,
+    ExecutionRequestResultClass,
+    DataHubStepStatePropertiesClass,
+    CorpGroupInfoClass,
+    CorpUserSettingsClass,
+    RoleMembershipClass,
+    CorpGroupEditableInfoClass,
+    CorpGroupSettingsClass,
+    CorpUserStatusClass,
+    InviteTokenClass,
+    CorpUserEditableInfoClass,
+    GroupMembershipClass,
+    CorpUserInfoClass,
+    CorpUserCredentialsClass,
+    NativeGroupMembershipClass,
+    ConstraintInfoClass,
+    DataHubIngestionSourceInfoClass,
     DataPlatformInfoClass,
     SlackUserInfoClass,
-    ConstraintInfoClass,
-    DataHubActionInfoClass,
-    DataHubActionStatusClass
-]
-
-ASPECT_NAME_MAP: Dict[str, Type[_Aspect]] = {
-    aspect.get_aspect_name(): aspect
-    for aspect in ASPECT_CLASSES
-}
-
-from typing import Literal
-from typing_extensions import TypedDict
-
-class AspectBag(TypedDict, total=False):
-    dataHubSecretValue: DataHubSecretValueClass
-    dataHubViewInfo: DataHubViewInfoClass
-    ownershipTypeInfo: OwnershipTypeInfoClass
-    assertionInfo: AssertionInfoClass
-    assertionAnalyticsRunEvent: AssertionAnalyticsRunEventClass
-    assertionActions: AssertionActionsClass
-    assertionDryRunEvent: AssertionDryRunEventClass
-    assertionInferenceDetails: AssertionInferenceDetailsClass
-    assertionRunEvent: AssertionRunEventClass
-    assertionSummary: AssertionSummaryClass
-    dataHubExecutionRequestSignal: ExecutionRequestSignalClass
-    dataHubExecutionRequestResult: ExecutionRequestResultClass
-    dataHubExecutionRequestInput: ExecutionRequestInputClass
-    dataHubRemoteExecutorStatus: RemoteExecutorStatusClass
-    mlMetric: MLMetricClass
-    mlModelGroupProperties: MLModelGroupPropertiesClass
-    mlModelFactorPrompts: MLModelFactorPromptsClass
-    mlModelEvaluationData: EvaluationDataClass
-    mlModelDeploymentProperties: MLModelDeploymentPropertiesClass
-    intendedUse: IntendedUseClass
-    mlModelProperties: MLModelPropertiesClass
-    editableMlPrimaryKeyProperties: EditableMLPrimaryKeyPropertiesClass
-    mlModelMetrics: MetricsClass
-    sourceCode: SourceCodeClass
-    mlModelQuantitativeAnalyses: QuantitativeAnalysesClass
-    mlModelTrainingData: TrainingDataClass
-    editableMlFeatureTableProperties: EditableMLFeatureTablePropertiesClass
-    mlPrimaryKeyProperties: MLPrimaryKeyPropertiesClass
-    editableMlModelGroupProperties: EditableMLModelGroupPropertiesClass
-    mlModelCaveatsAndRecommendations: CaveatsAndRecommendationsClass
-    mlFeatureProperties: MLFeaturePropertiesClass
-    mlFeatureTableProperties: MLFeatureTablePropertiesClass
-    mlTrainingRunProperties: MLTrainingRunPropertiesClass
-    editableMlFeatureProperties: EditableMLFeaturePropertiesClass
-    mlHyperParam: MLHyperParamClass
-    editableMlModelProperties: EditableMLModelPropertiesClass
-    mlModelEthicalConsiderations: EthicalConsiderationsClass
+    AssertionInfoClass,
+    AssertionDryRunEventClass,
+    AssertionSummaryClass,
+    AssertionActionsClass,
+    AssertionAnalyticsRunEventClass,
+    AssertionInferenceDetailsClass,
+    AssertionRunEventClass,
+    PlatformResourceInfoClass,
+    PlatformResourceKeyClass,
+    TelemetryClientIdClass,
+    DomainsClass,
+    DomainPropertiesClass,
+    DataHubViewInfoClass,
+    DataJobInfoClass,
+    DataFlowInfoClass,
+    DataJobInputOutputClass,
+    VersionInfoClass,
+    EditableDataFlowPropertiesClass,
+    EditableDataJobPropertiesClass,
+    DatahubIngestionRunSummaryClass,
+    DatahubIngestionCheckpointClass,
+    EntityTypeKeyClass,
+    EntityTypeInfoClass,
+    IncidentSourceClass,
+    IncidentActivityEventClass,
+    IncidentNotificationDetailsClass,
+    IncidentInfoClass,
+    QueryUsageStatisticsClass,
+    QueryUsageFeaturesClass,
+    QuerySubjectsClass,
+    QueryPropertiesClass,
+    NotebookContentClass,
+    EditableNotebookPropertiesClass,
+    NotebookInfoClass,
+    DataHubRoleInfoClass,
+    DataHubPolicyInfoClass,
+    MonitorAnomalyEventClass,
+    DataHubMetricCubeDefinitionClass,
+    DataHubMetricCubeEventClass,
+    BatchTestRunEventClass,
+    TestResultsClass,
+    TestInfoClass,
+    OwnershipTypeInfoClass,
+    GlobalSettingsInfoClass,
+    DataProductKeyClass,
+    DataProductPropertiesClass,
+    StructuredPropertyDefinitionClass,
+    StructuredPropertyKeyClass,
+    StructuredPropertySettingsClass,
+    StructuredPropertiesClass,
+    RemoteExecutorPoolInfoClass,
+    SubscriptionInfoClass,
+    EthicalConsiderationsClass,
+    MLFeaturePropertiesClass,
+    TrainingDataClass,
+    EditableMLPrimaryKeyPropertiesClass,
+    IntendedUseClass,
+    MLTrainingRunPropertiesClass,
+    MLModelDeploymentPropertiesClass,
+    EditableMLFeatureTablePropertiesClass,
+    QuantitativeAnalysesClass,
+    MLModelPropertiesClass,
+    EditableMLModelGroupPropertiesClass,
+    MetricsClass,
+    MLPrimaryKeyPropertiesClass,
+    MLModelGroupPropertiesClass,
+    SourceCodeClass,
+    EvaluationDataClass,
+    EditableMLFeaturePropertiesClass,
+    CaveatsAndRecommendationsClass,
+    MLModelFactorPromptsClass,
+    EditableMLModelPropertiesClass,
+    MLHyperParamClass,
+    MLMetricClass,
+    MLFeatureTablePropertiesClass,
+    ActionRequestInfoClass,
+    ActionRequestArchivedClass,
+    ActionRequestStatusClass,
+    SchemaFieldInfoClass,
+    SchemaFieldAliasesClass,
+    FormsClass,
+    AnomaliesSummaryClass,
+    AssertionsSummaryClass,
+    GlobalTagsClass,
+    OperationClass,
+    VersionPropertiesClass,
+    InstitutionalMemoryClass,
+    DisplayPropertiesClass,
+    AccessClass,
+    OwnershipClass,
+    OriginClass,
+    StatusClass,
+    DataPlatformInstanceClass,
+    BrowsePathsV2Class,
+    GlossaryTermsClass,
+    DataTransformLogicClass,
+    CostClass,
+    EmbedClass,
+    IncidentsSummaryClass,
+    DocumentationClass,
+    InputFieldsClass,
+    BrowsePathsClass,
+    ShareClass,
+    ProposalsClass,
+    SubTypesClass,
+    SiblingsClass,
+    DeprecationClass,
+    DataPlatformInstancePropertiesClass,
+    IcebergWarehouseInfoClass,
+    DataHubPersonaInfoClass,
+    VersionSetPropertiesClass,
+    EditableSchemaMetadataClass,
+    SchemaProposalsClass,
+    SchemaMetadataClass,
+    DataHubActionInfoClass,
+    DataHubActionStatusClass,
+    DashboardUsageStatisticsClass,
+    DashboardInfoClass,
+    EditableDashboardPropertiesClass,
+    TagPropertiesClass,
+    LinkPreviewInfoClass,
+    RemoteExecutorPoolGlobalConfigClass,
+    InferredNeighborsClass,
+    InferredMetadataClass,
+    SchemaFieldsInferredNeighborsClass,
+    SchemaFieldsInferredMetadataClass,
+    MonitorSuiteInfoClass,
+    MonitorInfoClass,
+    MonitorTimeseriesStateClass,
+    GlossaryTermInfoClass,
+    GlossaryRelatedTermsClass,
+    GlossaryNodeInfoClass
+]
+
+ASPECT_NAME_MAP: Dict[str, Type[_Aspect]] = {
+    aspect.get_aspect_name(): aspect
+    for aspect in ASPECT_CLASSES
+}
+
+from typing import Literal
+from typing_extensions import TypedDict
+
+class AspectBag(TypedDict, total=False):
+    roleProperties: RolePropertiesClass
+    actors: ActorsClass
     editableContainerProperties: EditableContainerPropertiesClass
     containerProperties: ContainerPropertiesClass
     container: ContainerClass
-    dataHubRemoteExecutorPoolGlobalConfig: RemoteExecutorPoolGlobalConfigClass
-    dataHubRetentionConfig: DataHubRetentionConfigClass
-    telemetryClientId: TelemetryClientIdClass
-    dataHubAccessTokenInfo: DataHubAccessTokenInfoClass
-    dataProductKey: DataProductKeyClass
-    dataProductProperties: DataProductPropertiesClass
-    actors: ActorsClass
-    roleProperties: RolePropertiesClass
-    inferredMetadata: InferredMetadataClass
-    inferredNeighbors: InferredNeighborsClass
-    schemaFieldsInferredNeighbors: SchemaFieldsInferredNeighborsClass
-    schemaFieldsInferredMetadata: SchemaFieldsInferredMetadataClass
-    dataJobInputOutput: DataJobInputOutputClass
-    versionInfo: VersionInfoClass
-    dataJobInfo: DataJobInfoClass
-    editableDataFlowProperties: EditableDataFlowPropertiesClass
-    dataFlowInfo: DataFlowInfoClass
-    editableDataJobProperties: EditableDataJobPropertiesClass
-    datahubIngestionRunSummary: DatahubIngestionRunSummaryClass
-    datahubIngestionCheckpoint: DatahubIngestionCheckpointClass
-    monitorInfo: MonitorInfoClass
-    monitorTimeseriesState: MonitorTimeseriesStateClass
-    schemaFieldAliases: SchemaFieldAliasesClass
-    schemafieldInfo: SchemaFieldInfoClass
-    incidentInfo: IncidentInfoClass
-    incidentNotificationDetails: IncidentNotificationDetailsClass
-    incidentSource: IncidentSourceClass
-    incidentActivityEvent: IncidentActivityEventClass
-    dataHubUpgradeResult: DataHubUpgradeResultClass
-    dataHubUpgradeRequest: DataHubUpgradeRequestClass
-    subscriptionInfo: SubscriptionInfoClass
-    dataHubPersonaInfo: DataHubPersonaInfoClass
-    globalSettingsInfo: GlobalSettingsInfoClass
-    dataHubRemoteExecutorPoolInfo: RemoteExecutorPoolInfoClass
-    structuredProperties: StructuredPropertiesClass
-    structuredPropertyKey: StructuredPropertyKeyClass
-    structuredPropertySettings: StructuredPropertySettingsClass
-    propertyDefinition: StructuredPropertyDefinitionClass
-    aiInferenceMetadata: AiInferenceMetadataClass
-    entityInferenceMetadata: EntityInferenceMetadataClass
-    testResults: TestResultsClass
-    testInfo: TestInfoClass
-    batchTestRunEvent: BatchTestRunEventClass
-    dataPlatformInstanceProperties: DataPlatformInstancePropertiesClass
-    icebergWarehouseInfo: IcebergWarehouseInfoClass
-    editableERModelRelationshipProperties: EditableERModelRelationshipPropertiesClass
-    erModelRelationshipProperties: ERModelRelationshipPropertiesClass
-    entityTypeInfo: EntityTypeInfoClass
-    entityTypeKey: EntityTypeKeyClass
-    platformResourceKey: PlatformResourceKeyClass
-    platformResourceInfo: PlatformResourceInfoClass
-    editableSchemaMetadata: EditableSchemaMetadataClass
-    schemaProposals: SchemaProposalsClass
-    schemaMetadata: SchemaMetadataClass
-    dataHubMetricCubeEvent: DataHubMetricCubeEventClass
-    dataHubMetricCubeDefinition: DataHubMetricCubeDefinitionClass
-    access: AccessClass
-    anomaliesSummary: AnomaliesSummaryClass
-    proposals: ProposalsClass
-    inputFields: InputFieldsClass
-    globalTags: GlobalTagsClass
-    origin: OriginClass
-    glossaryTerms: GlossaryTermsClass
-    dataPlatformInstance: DataPlatformInstanceClass
-    ownership: OwnershipClass
-    documentation: DocumentationClass
-    deprecation: DeprecationClass
-    versionProperties: VersionPropertiesClass
-    siblings: SiblingsClass
-    share: ShareClass
-    status: StatusClass
-    incidentsSummary: IncidentsSummaryClass
-    browsePathsV2: BrowsePathsV2Class
-    displayProperties: DisplayPropertiesClass
-    cost: CostClass
-    assertionsSummary: AssertionsSummaryClass
-    institutionalMemory: InstitutionalMemoryClass
-    browsePaths: BrowsePathsClass
-    embed: EmbedClass
-    operation: OperationClass
-    forms: FormsClass
-    subTypes: SubTypesClass
-    dataTransformLogic: DataTransformLogicClass
     dataContractProperties: DataContractPropertiesClass
     dataContractStatus: DataContractStatusClass
-    businessAttributeInfo: BusinessAttributeInfoClass
-    businessAttributes: BusinessAttributesClass
-    businessAttributeKey: BusinessAttributeKeyClass
-    formInfo: FormInfoClass
-    dynamicFormAssignment: DynamicFormAssignmentClass
-    domainProperties: DomainPropertiesClass
-    domains: DomainsClass
-    dataHubConnectionDetails: DataHubConnectionDetailsClass
-    dataProcessInstanceInput: DataProcessInstanceInputClass
-    dataProcessInstanceRelationships: DataProcessInstanceRelationshipsClass
-    dataProcessInstanceProperties: DataProcessInstancePropertiesClass
-    dataProcessInstanceRunEvent: DataProcessInstanceRunEventClass
-    dataProcessInfo: DataProcessInfoClass
-    dataProcessInstanceOutput: DataProcessInstanceOutputClass
-    anomalyInfo: AnomalyInfoClass
-    schemaFieldProfile: SchemaFieldProfileClass
+    dataHubSecretValue: DataHubSecretValueClass
+    dataHubUpgradeResult: DataHubUpgradeResultClass
+    dataHubUpgradeRequest: DataHubUpgradeRequestClass
+    dataHubAccessTokenInfo: DataHubAccessTokenInfoClass
+    datasetUsageStatistics: DatasetUsageStatisticsClass
+    upstreamLineage: UpstreamLineageClass
+    viewProperties: ViewPropertiesClass
     editableDatasetProperties: EditableDatasetPropertiesClass
     datasetProfile: DatasetProfileClass
+    schemaFieldProfile: SchemaFieldProfileClass
     datasetDeprecation: DatasetDeprecationClass
     icebergCatalogInfo: IcebergCatalogInfoClass
     datasetProperties: DatasetPropertiesClass
     partitionsSummary: PartitionsSummaryClass
     datasetUpstreamLineage: DatasetUpstreamLineageClass
-    datasetUsageStatistics: DatasetUsageStatisticsClass
-    viewProperties: ViewPropertiesClass
-    upstreamLineage: UpstreamLineageClass
-    glossaryNodeInfo: GlossaryNodeInfoClass
-    glossaryTermInfo: GlossaryTermInfoClass
-    glossaryRelatedTerms: GlossaryRelatedTermsClass
-    corpUserCredentials: CorpUserCredentialsClass
-    inviteToken: InviteTokenClass
-    corpUserStatus: CorpUserStatusClass
-    corpGroupSettings: CorpGroupSettingsClass
-    corpUserInfo: CorpUserInfoClass
-    corpUserEditableInfo: CorpUserEditableInfoClass
-    nativeGroupMembership: NativeGroupMembershipClass
-    corpGroupInfo: CorpGroupInfoClass
-    corpGroupEditableInfo: CorpGroupEditableInfoClass
-    corpUserSettings: CorpUserSettingsClass
-    roleMembership: RoleMembershipClass
-    groupMembership: GroupMembershipClass
-    dataTypeKey: DataTypeKeyClass
-    dataTypeInfo: DataTypeInfoClass
-    notebookInfo: NotebookInfoClass
-    editableNotebookProperties: EditableNotebookPropertiesClass
-    notebookContent: NotebookContentClass
-    tagProperties: TagPropertiesClass
-    actionRequestInfo: ActionRequestInfoClass
-    actionRequestArchived: ActionRequestArchivedClass
-    actionRequestStatus: ActionRequestStatusClass
+    usageFeatures: UsageFeaturesClass
+    storageFeatures: StorageFeaturesClass
+    lineageFeatures: LineageFeaturesClass
+    costFeatures: CostFeaturesClass
+    dataPlatformInstanceKey: DataPlatformInstanceKeyClass
+    dataHubRoleKey: DataHubRoleKeyClass
+    dataHubUpgradeKey: DataHubUpgradeKeyClass
+    dataHubPersonaKey: DataHubPersonaKeyClass
+    tagKey: TagKeyClass
+    mlModelGroupKey: MLModelGroupKeyClass
+    dataContractKey: DataContractKeyClass
+    domainKey: DomainKeyClass
     inviteTokenKey: InviteTokenKeyClass
-    assertionKey: AssertionKeyClass
-    schemaFieldKey: SchemaFieldKeyClass
-    corpGroupKey: CorpGroupKeyClass
-    roleKey: RoleKeyClass
+    dashboardKey: DashboardKeyClass
+    dataFlowKey: DataFlowKeyClass
     dataProcessInstanceKey: DataProcessInstanceKeyClass
-    dataHubSecretKey: DataHubSecretKeyClass
-    dataHubPersonaKey: DataHubPersonaKeyClass
+    corpUserKey: CorpUserKeyClass
+    dataHubRetentionKey: DataHubRetentionKeyClass
+    notebookKey: NotebookKeyClass
+    incidentKey: IncidentKeyClass
     mlFeatureTableKey: MLFeatureTableKeyClass
-    glossaryTermKey: GlossaryTermKeyClass
-    recommendationModuleKey: RecommendationModuleKeyClass
-    postKey: PostKeyClass
-    mlPrimaryKeyKey: MLPrimaryKeyKeyClass
-    dataPlatformInstanceKey: DataPlatformInstanceKeyClass
-    dataHubMetricCubeKey: DataHubMetricCubeKeyClass
-    queryKey: QueryKeyClass
-    datasetKey: DatasetKeyClass
-    dataHubExecutionRequestKey: ExecutionRequestKeyClass
-    chartKey: ChartKeyClass
-    mlModelGroupKey: MLModelGroupKeyClass
+    constraintKey: ConstraintKeyClass
     subscriptionKey: SubscriptionKeyClass
-    anomalyKey: AnomalyKeyClass
+    queryKey: QueryKeyClass
+    mlFeatureKey: MLFeatureKeyClass
+    dataHubRemoteExecutorGlobalConfigKey: RemoteExecutorGlobalConfigKeyClass
+    globalSettingsKey: GlobalSettingsKeyClass
+    mlModelKey: MLModelKeyClass
+    versionSetKey: VersionSetKeyClass
     dataHubRemoteExecutorPoolKey: RemoteExecutorPoolKeyClass
-    dataJobKey: DataJobKeyClass
-    domainKey: DomainKeyClass
-    erModelRelationshipKey: ERModelRelationshipKeyClass
-    dataHubRoleKey: DataHubRoleKeyClass
-    formKey: FormKeyClass
-    dataHubAccessTokenKey: DataHubAccessTokenKeyClass
     dataHubActionKey: DataHubActionKeyClass
-    dataPlatformKey: DataPlatformKeyClass
+    dataJobKey: DataJobKeyClass
+    corpGroupKey: CorpGroupKeyClass
+    roleKey: RoleKeyClass
     containerKey: ContainerKeyClass
-    tagKey: TagKeyClass
+    mlPrimaryKeyKey: MLPrimaryKeyKeyClass
     dataHubPolicyKey: DataHubPolicyKeyClass
-    constraintKey: ConstraintKeyClass
-    glossaryNodeKey: GlossaryNodeKeyClass
-    dataProcessKey: DataProcessKeyClass
+    dataHubMetricCubeKey: DataHubMetricCubeKeyClass
+    erModelRelationshipKey: ERModelRelationshipKeyClass
+    glossaryTermKey: GlossaryTermKeyClass
     dataHubStepStateKey: DataHubStepStateKeyClass
-    notebookKey: NotebookKeyClass
-    mlFeatureKey: MLFeatureKeyClass
-    dataHubUpgradeKey: DataHubUpgradeKeyClass
-    dashboardKey: DashboardKeyClass
-    mlModelKey: MLModelKeyClass
-    incidentKey: IncidentKeyClass
-    globalSettingsKey: GlobalSettingsKeyClass
-    dataHubViewKey: DataHubViewKeyClass
-    dataHubRetentionKey: DataHubRetentionKeyClass
+    glossaryNodeKey: GlossaryNodeKeyClass
+    formKey: FormKeyClass
+    linkPreviewKey: LinkPreviewKeyClass
+    chartKey: ChartKeyClass
+    dataHubSecretKey: DataHubSecretKeyClass
     ownershipTypeKey: OwnershipTypeKeyClass
-    actionRequestKey: ActionRequestKeyClass
-    dataHubRemoteExecutorGlobalConfigKey: RemoteExecutorGlobalConfigKeyClass
-    dataFlowKey: DataFlowKeyClass
+    monitorSuiteKey: MonitorSuiteKeyClass
     genericEntityKey: GenericEntityKeyClass
-    dataContractKey: DataContractKeyClass
-    dataHubConnectionKey: DataHubConnectionKeyClass
+    telemetryKey: TelemetryKeyClass
+    mlModelDeploymentKey: MLModelDeploymentKeyClass
+    assertionKey: AssertionKeyClass
+    dataHubExecutionRequestKey: ExecutionRequestKeyClass
+    dataHubAccessTokenKey: DataHubAccessTokenKeyClass
+    dataHubIngestionSourceKey: DataHubIngestionSourceKeyClass
+    datasetKey: DatasetKeyClass
+    actionRequestKey: ActionRequestKeyClass
+    dataHubViewKey: DataHubViewKeyClass
     dataHubRemoteExecutorKey: RemoteExecutorKeyClass
-    monitorKey: MonitorKeyClass
-    corpUserKey: CorpUserKeyClass
-    versionSetKey: VersionSetKeyClass
     testKey: TestKeyClass
-    dataHubIngestionSourceKey: DataHubIngestionSourceKeyClass
-    mlModelDeploymentKey: MLModelDeploymentKeyClass
-    linkPreviewKey: LinkPreviewKeyClass
-    telemetryKey: TelemetryKeyClass
-    usageFeatures: UsageFeaturesClass
-    costFeatures: CostFeaturesClass
-    lineageFeatures: LineageFeaturesClass
-    storageFeatures: StorageFeaturesClass
+    dataPlatformKey: DataPlatformKeyClass
+    anomalyKey: AnomalyKeyClass
+    dataProcessKey: DataProcessKeyClass
+    dataHubConnectionKey: DataHubConnectionKeyClass
+    recommendationModuleKey: RecommendationModuleKeyClass
+    schemaFieldKey: SchemaFieldKeyClass
+    postKey: PostKeyClass
+    monitorKey: MonitorKeyClass
     recommendationModule: RecommendationModuleClass
-    dataHubIngestionSourceInfo: DataHubIngestionSourceInfoClass
-    linkPreviewInfo: LinkPreviewInfoClass
-    dataHubStepStateProperties: DataHubStepStatePropertiesClass
+    dataHubConnectionDetails: DataHubConnectionDetailsClass
+    chartQuery: ChartQueryClass
+    editableChartProperties: EditableChartPropertiesClass
+    chartUsageStatistics: ChartUsageStatisticsClass
+    chartInfo: ChartInfoClass
+    dataTypeInfo: DataTypeInfoClass
+    dataTypeKey: DataTypeKeyClass
+    erModelRelationshipProperties: ERModelRelationshipPropertiesClass
+    editableERModelRelationshipProperties: EditableERModelRelationshipPropertiesClass
+    entityInferenceMetadata: EntityInferenceMetadataClass
+    aiInferenceMetadata: AiInferenceMetadataClass
+    dataHubRemoteExecutorStatus: RemoteExecutorStatusClass
     postInfo: PostInfoClass
-    dataHubPolicyInfo: DataHubPolicyInfoClass
-    dataHubRoleInfo: DataHubRoleInfoClass
-    querySubjects: QuerySubjectsClass
+    dataHubRetentionConfig: DataHubRetentionConfigClass
+    dynamicFormAssignment: DynamicFormAssignmentClass
+    formInfo: FormInfoClass
+    dataProcessInstanceRelationships: DataProcessInstanceRelationshipsClass
+    dataProcessInfo: DataProcessInfoClass
+    dataProcessInstanceInput: DataProcessInstanceInputClass
+    dataProcessInstanceOutput: DataProcessInstanceOutputClass
+    dataProcessInstanceProperties: DataProcessInstancePropertiesClass
+    dataProcessInstanceRunEvent: DataProcessInstanceRunEventClass
+    businessAttributeInfo: BusinessAttributeInfoClass
+    businessAttributeKey: BusinessAttributeKeyClass
+    businessAttributes: BusinessAttributesClass
+    dataHubExecutionRequestSignal: ExecutionRequestSignalClass
+    dataHubExecutionRequestInput: ExecutionRequestInputClass
+    dataHubExecutionRequestResult: ExecutionRequestResultClass
+    dataHubStepStateProperties: DataHubStepStatePropertiesClass
+    corpGroupInfo: CorpGroupInfoClass
+    corpUserSettings: CorpUserSettingsClass
+    roleMembership: RoleMembershipClass
+    corpGroupEditableInfo: CorpGroupEditableInfoClass
+    corpGroupSettings: CorpGroupSettingsClass
+    corpUserStatus: CorpUserStatusClass
+    inviteToken: InviteTokenClass
+    corpUserEditableInfo: CorpUserEditableInfoClass
+    groupMembership: GroupMembershipClass
+    corpUserInfo: CorpUserInfoClass
+    corpUserCredentials: CorpUserCredentialsClass
+    nativeGroupMembership: NativeGroupMembershipClass
+    constraintInfo: ConstraintInfoClass
+    dataHubIngestionSourceInfo: DataHubIngestionSourceInfoClass
+    dataPlatformInfo: DataPlatformInfoClass
+    slackUserInfo: SlackUserInfoClass
+    assertionInfo: AssertionInfoClass
+    assertionDryRunEvent: AssertionDryRunEventClass
+    assertionSummary: AssertionSummaryClass
+    assertionActions: AssertionActionsClass
+    assertionAnalyticsRunEvent: AssertionAnalyticsRunEventClass
+    assertionInferenceDetails: AssertionInferenceDetailsClass
+    assertionRunEvent: AssertionRunEventClass
+    platformResourceInfo: PlatformResourceInfoClass
+    platformResourceKey: PlatformResourceKeyClass
+    telemetryClientId: TelemetryClientIdClass
+    domains: DomainsClass
+    domainProperties: DomainPropertiesClass
+    dataHubViewInfo: DataHubViewInfoClass
+    dataJobInfo: DataJobInfoClass
+    dataFlowInfo: DataFlowInfoClass
+    dataJobInputOutput: DataJobInputOutputClass
+    versionInfo: VersionInfoClass
+    editableDataFlowProperties: EditableDataFlowPropertiesClass
+    editableDataJobProperties: EditableDataJobPropertiesClass
+    datahubIngestionRunSummary: DatahubIngestionRunSummaryClass
+    datahubIngestionCheckpoint: DatahubIngestionCheckpointClass
+    entityTypeKey: EntityTypeKeyClass
+    entityTypeInfo: EntityTypeInfoClass
+    incidentSource: IncidentSourceClass
+    incidentActivityEvent: IncidentActivityEventClass
+    incidentNotificationDetails: IncidentNotificationDetailsClass
+    incidentInfo: IncidentInfoClass
+    queryUsageStatistics: QueryUsageStatisticsClass
     queryUsageFeatures: QueryUsageFeaturesClass
+    querySubjects: QuerySubjectsClass
     queryProperties: QueryPropertiesClass
-    queryUsageStatistics: QueryUsageStatisticsClass
-    chartUsageStatistics: ChartUsageStatisticsClass
-    chartInfo: ChartInfoClass
-    editableChartProperties: EditableChartPropertiesClass
-    chartQuery: ChartQueryClass
+    notebookContent: NotebookContentClass
+    editableNotebookProperties: EditableNotebookPropertiesClass
+    notebookInfo: NotebookInfoClass
+    dataHubRoleInfo: DataHubRoleInfoClass
+    dataHubPolicyInfo: DataHubPolicyInfoClass
+    monitorAnomalyEvent: MonitorAnomalyEventClass
+    dataHubMetricCubeDefinition: DataHubMetricCubeDefinitionClass
+    dataHubMetricCubeEvent: DataHubMetricCubeEventClass
+    batchTestRunEvent: BatchTestRunEventClass
+    testResults: TestResultsClass
+    testInfo: TestInfoClass
+    ownershipTypeInfo: OwnershipTypeInfoClass
+    globalSettingsInfo: GlobalSettingsInfoClass
+    dataProductKey: DataProductKeyClass
+    dataProductProperties: DataProductPropertiesClass
+    propertyDefinition: StructuredPropertyDefinitionClass
+    structuredPropertyKey: StructuredPropertyKeyClass
+    structuredPropertySettings: StructuredPropertySettingsClass
+    structuredProperties: StructuredPropertiesClass
+    dataHubRemoteExecutorPoolInfo: RemoteExecutorPoolInfoClass
+    subscriptionInfo: SubscriptionInfoClass
+    mlModelEthicalConsiderations: EthicalConsiderationsClass
+    mlFeatureProperties: MLFeaturePropertiesClass
+    mlModelTrainingData: TrainingDataClass
+    editableMlPrimaryKeyProperties: EditableMLPrimaryKeyPropertiesClass
+    intendedUse: IntendedUseClass
+    mlTrainingRunProperties: MLTrainingRunPropertiesClass
+    mlModelDeploymentProperties: MLModelDeploymentPropertiesClass
+    editableMlFeatureTableProperties: EditableMLFeatureTablePropertiesClass
+    mlModelQuantitativeAnalyses: QuantitativeAnalysesClass
+    mlModelProperties: MLModelPropertiesClass
+    editableMlModelGroupProperties: EditableMLModelGroupPropertiesClass
+    mlModelMetrics: MetricsClass
+    mlPrimaryKeyProperties: MLPrimaryKeyPropertiesClass
+    mlModelGroupProperties: MLModelGroupPropertiesClass
+    sourceCode: SourceCodeClass
+    mlModelEvaluationData: EvaluationDataClass
+    editableMlFeatureProperties: EditableMLFeaturePropertiesClass
+    mlModelCaveatsAndRecommendations: CaveatsAndRecommendationsClass
+    mlModelFactorPrompts: MLModelFactorPromptsClass
+    editableMlModelProperties: EditableMLModelPropertiesClass
+    mlHyperParam: MLHyperParamClass
+    mlMetric: MLMetricClass
+    mlFeatureTableProperties: MLFeatureTablePropertiesClass
+    actionRequestInfo: ActionRequestInfoClass
+    actionRequestArchived: ActionRequestArchivedClass
+    actionRequestStatus: ActionRequestStatusClass
+    schemafieldInfo: SchemaFieldInfoClass
+    schemaFieldAliases: SchemaFieldAliasesClass
+    forms: FormsClass
+    anomaliesSummary: AnomaliesSummaryClass
+    assertionsSummary: AssertionsSummaryClass
+    globalTags: GlobalTagsClass
+    operation: OperationClass
+    versionProperties: VersionPropertiesClass
+    institutionalMemory: InstitutionalMemoryClass
+    displayProperties: DisplayPropertiesClass
+    access: AccessClass
+    ownership: OwnershipClass
+    origin: OriginClass
+    status: StatusClass
+    dataPlatformInstance: DataPlatformInstanceClass
+    browsePathsV2: BrowsePathsV2Class
+    glossaryTerms: GlossaryTermsClass
+    dataTransformLogic: DataTransformLogicClass
+    cost: CostClass
+    embed: EmbedClass
+    incidentsSummary: IncidentsSummaryClass
+    documentation: DocumentationClass
+    inputFields: InputFieldsClass
+    browsePaths: BrowsePathsClass
+    share: ShareClass
+    proposals: ProposalsClass
+    subTypes: SubTypesClass
+    siblings: SiblingsClass
+    deprecation: DeprecationClass
+    dataPlatformInstanceProperties: DataPlatformInstancePropertiesClass
+    icebergWarehouseInfo: IcebergWarehouseInfoClass
+    dataHubPersonaInfo: DataHubPersonaInfoClass
     versionSetProperties: VersionSetPropertiesClass
+    editableSchemaMetadata: EditableSchemaMetadataClass
+    schemaProposals: SchemaProposalsClass
+    schemaMetadata: SchemaMetadataClass
+    dataHubActionInfo: DataHubActionInfoClass
+    dataHubActionStatus: DataHubActionStatusClass
     dashboardUsageStatistics: DashboardUsageStatisticsClass
     dashboardInfo: DashboardInfoClass
     editableDashboardProperties: EditableDashboardPropertiesClass
-    dataPlatformInfo: DataPlatformInfoClass
-    slackUserInfo: SlackUserInfoClass
-    constraintInfo: ConstraintInfoClass
-    dataHubActionInfo: DataHubActionInfoClass
-    dataHubActionStatus: DataHubActionStatusClass
+    tagProperties: TagPropertiesClass
+    linkPreviewInfo: LinkPreviewInfoClass
+    dataHubRemoteExecutorPoolGlobalConfig: RemoteExecutorPoolGlobalConfigClass
+    inferredNeighbors: InferredNeighborsClass
+    inferredMetadata: InferredMetadataClass
+    schemaFieldsInferredNeighbors: SchemaFieldsInferredNeighborsClass
+    schemaFieldsInferredMetadata: SchemaFieldsInferredMetadataClass
+    monitorSuiteInfo: MonitorSuiteInfoClass
+    monitorInfo: MonitorInfoClass
+    monitorTimeseriesState: MonitorTimeseriesStateClass
+    glossaryTermInfo: GlossaryTermInfoClass
+    glossaryRelatedTerms: GlossaryRelatedTermsClass
+    glossaryNodeInfo: GlossaryNodeInfoClass
 
 
 KEY_ASPECTS: Dict[str, Type[_Aspect]] = {
-    'dataProduct': DataProductKeyClass,
-    'structuredProperty': StructuredPropertyKeyClass,
-    'entityType': EntityTypeKeyClass,
-    'platformResource': PlatformResourceKeyClass,
-    'businessAttribute': BusinessAttributeKeyClass,
-    'dataType': DataTypeKeyClass,
+    'dataPlatformInstance': DataPlatformInstanceKeyClass,
+    'dataHubRole': DataHubRoleKeyClass,
+    'dataHubUpgrade': DataHubUpgradeKeyClass,
+    'dataHubPersona': DataHubPersonaKeyClass,
+    'tag': TagKeyClass,
+    'mlModelGroup': MLModelGroupKeyClass,
+    'dataContract': DataContractKeyClass,
+    'domain': DomainKeyClass,
     'inviteToken': InviteTokenKeyClass,
-    'assertion': AssertionKeyClass,
-    'schemaField': SchemaFieldKeyClass,
-    'corpGroup': CorpGroupKeyClass,
-    'role': RoleKeyClass,
+    'dashboard': DashboardKeyClass,
+    'dataFlow': DataFlowKeyClass,
     'dataProcessInstance': DataProcessInstanceKeyClass,
-    'dataHubSecret': DataHubSecretKeyClass,
-    'dataHubPersona': DataHubPersonaKeyClass,
+    'corpuser': CorpUserKeyClass,
+    'dataHubRetention': DataHubRetentionKeyClass,
+    'notebook': NotebookKeyClass,
+    'incident': IncidentKeyClass,
     'mlFeatureTable': MLFeatureTableKeyClass,
-    'glossaryTerm': GlossaryTermKeyClass,
-    'recommendationModule': RecommendationModuleKeyClass,
-    'post': PostKeyClass,
-    'mlPrimaryKey': MLPrimaryKeyKeyClass,
-    'dataPlatformInstance': DataPlatformInstanceKeyClass,
-    'dataHubMetricCube': DataHubMetricCubeKeyClass,
-    'query': QueryKeyClass,
-    'dataset': DatasetKeyClass,
-    'dataHubExecutionRequest': ExecutionRequestKeyClass,
-    'chart': ChartKeyClass,
-    'mlModelGroup': MLModelGroupKeyClass,
+    'constraint': ConstraintKeyClass,
     'subscription': SubscriptionKeyClass,
-    'anomaly': AnomalyKeyClass,
+    'query': QueryKeyClass,
+    'mlFeature': MLFeatureKeyClass,
+    'dataHubRemoteExecutorGlobalConfig': RemoteExecutorGlobalConfigKeyClass,
+    'globalSettings': GlobalSettingsKeyClass,
+    'mlModel': MLModelKeyClass,
+    'versionSet': VersionSetKeyClass,
     'dataHubRemoteExecutorPool': RemoteExecutorPoolKeyClass,
-    'dataJob': DataJobKeyClass,
-    'domain': DomainKeyClass,
-    'erModelRelationship': ERModelRelationshipKeyClass,
-    'dataHubRole': DataHubRoleKeyClass,
-    'form': FormKeyClass,
-    'dataHubAccessToken': DataHubAccessTokenKeyClass,
     'dataHubAction': DataHubActionKeyClass,
-    'dataPlatform': DataPlatformKeyClass,
+    'dataJob': DataJobKeyClass,
+    'corpGroup': CorpGroupKeyClass,
+    'role': RoleKeyClass,
     'container': ContainerKeyClass,
-    'tag': TagKeyClass,
+    'mlPrimaryKey': MLPrimaryKeyKeyClass,
     'dataHubPolicy': DataHubPolicyKeyClass,
-    'constraint': ConstraintKeyClass,
-    'glossaryNode': GlossaryNodeKeyClass,
-    'dataProcess': DataProcessKeyClass,
+    'dataHubMetricCube': DataHubMetricCubeKeyClass,
+    'erModelRelationship': ERModelRelationshipKeyClass,
+    'glossaryTerm': GlossaryTermKeyClass,
     'dataHubStepState': DataHubStepStateKeyClass,
-    'notebook': NotebookKeyClass,
-    'mlFeature': MLFeatureKeyClass,
-    'dataHubUpgrade': DataHubUpgradeKeyClass,
-    'dashboard': DashboardKeyClass,
-    'mlModel': MLModelKeyClass,
-    'incident': IncidentKeyClass,
-    'globalSettings': GlobalSettingsKeyClass,
-    'dataHubView': DataHubViewKeyClass,
-    'dataHubRetention': DataHubRetentionKeyClass,
+    'glossaryNode': GlossaryNodeKeyClass,
+    'form': FormKeyClass,
+    'linkPreview': LinkPreviewKeyClass,
+    'chart': ChartKeyClass,
+    'dataHubSecret': DataHubSecretKeyClass,
     'ownershipType': OwnershipTypeKeyClass,
+    'monitorSuite': MonitorSuiteKeyClass,
+    'telemetry': TelemetryKeyClass,
+    'mlModelDeployment': MLModelDeploymentKeyClass,
+    'assertion': AssertionKeyClass,
+    'dataHubExecutionRequest': ExecutionRequestKeyClass,
+    'dataHubAccessToken': DataHubAccessTokenKeyClass,
+    'dataHubIngestionSource': DataHubIngestionSourceKeyClass,
+    'dataset': DatasetKeyClass,
     'actionRequest': ActionRequestKeyClass,
-    'dataHubRemoteExecutorGlobalConfig': RemoteExecutorGlobalConfigKeyClass,
-    'dataFlow': DataFlowKeyClass,
-    'dataContract': DataContractKeyClass,
-    'dataHubConnection': DataHubConnectionKeyClass,
+    'dataHubView': DataHubViewKeyClass,
     'dataHubRemoteExecutor': RemoteExecutorKeyClass,
-    'monitor': MonitorKeyClass,
-    'corpuser': CorpUserKeyClass,
-    'versionSet': VersionSetKeyClass,
     'test': TestKeyClass,
-    'dataHubIngestionSource': DataHubIngestionSourceKeyClass,
-    'mlModelDeployment': MLModelDeploymentKeyClass,
-    'linkPreview': LinkPreviewKeyClass,
-    'telemetry': TelemetryKeyClass
+    'dataPlatform': DataPlatformKeyClass,
+    'dataProcess': DataProcessKeyClass,
+    'dataHubConnection': DataHubConnectionKeyClass,
+    'recommendationModule': RecommendationModuleKeyClass,
+    'schemaField': SchemaFieldKeyClass,
+    'post': PostKeyClass,
+    'monitor': MonitorKeyClass,
+    'dataType': DataTypeKeyClass,
+    'businessAttribute': BusinessAttributeKeyClass,
+    'platformResource': PlatformResourceKeyClass,
+    'entityType': EntityTypeKeyClass,
+    'dataProduct': DataProductKeyClass,
+    'structuredProperty': StructuredPropertyKeyClass
 }
 
 ENTITY_TYPE_NAMES: List[str] = [
-    'dataProduct',
-    'structuredProperty',
-    'entityType',
-    'platformResource',
-    'businessAttribute',
-    'dataType',
+    'dataPlatformInstance',
+    'dataHubRole',
+    'dataHubUpgrade',
+    'dataHubPersona',
+    'tag',
+    'mlModelGroup',
+    'dataContract',
+    'domain',
     'inviteToken',
-    'assertion',
-    'schemaField',
-    'corpGroup',
-    'role',
+    'dashboard',
+    'dataFlow',
     'dataProcessInstance',
-    'dataHubSecret',
-    'dataHubPersona',
+    'corpuser',
+    'dataHubRetention',
+    'notebook',
+    'incident',
     'mlFeatureTable',
-    'glossaryTerm',
-    'recommendationModule',
-    'post',
-    'mlPrimaryKey',
-    'dataPlatformInstance',
-    'dataHubMetricCube',
-    'query',
-    'dataset',
-    'dataHubExecutionRequest',
-    'chart',
-    'mlModelGroup',
+    'constraint',
     'subscription',
-    'anomaly',
+    'query',
+    'mlFeature',
+    'dataHubRemoteExecutorGlobalConfig',
+    'globalSettings',
+    'mlModel',
+    'versionSet',
     'dataHubRemoteExecutorPool',
-    'dataJob',
-    'domain',
-    'erModelRelationship',
-    'dataHubRole',
-    'form',
-    'dataHubAccessToken',
     'dataHubAction',
-    'dataPlatform',
+    'dataJob',
+    'corpGroup',
+    'role',
     'container',
-    'tag',
+    'mlPrimaryKey',
     'dataHubPolicy',
-    'constraint',
-    'glossaryNode',
-    'dataProcess',
+    'dataHubMetricCube',
+    'erModelRelationship',
+    'glossaryTerm',
     'dataHubStepState',
-    'notebook',
-    'mlFeature',
-    'dataHubUpgrade',
-    'dashboard',
-    'mlModel',
-    'incident',
-    'globalSettings',
-    'dataHubView',
-    'dataHubRetention',
+    'glossaryNode',
+    'form',
+    'linkPreview',
+    'chart',
+    'dataHubSecret',
     'ownershipType',
+    'monitorSuite',
+    'telemetry',
+    'mlModelDeployment',
+    'assertion',
+    'dataHubExecutionRequest',
+    'dataHubAccessToken',
+    'dataHubIngestionSource',
+    'dataset',
     'actionRequest',
-    'dataHubRemoteExecutorGlobalConfig',
-    'dataFlow',
-    'dataContract',
-    'dataHubConnection',
+    'dataHubView',
     'dataHubRemoteExecutor',
-    'monitor',
-    'corpuser',
-    'versionSet',
     'test',
-    'dataHubIngestionSource',
-    'mlModelDeployment',
-    'linkPreview',
-    'telemetry'
+    'dataPlatform',
+    'dataProcess',
+    'dataHubConnection',
+    'recommendationModule',
+    'schemaField',
+    'post',
+    'monitor',
+    'dataType',
+    'businessAttribute',
+    'platformResource',
+    'entityType',
+    'dataProduct',
+    'structuredProperty'
 ]
 EntityTypeName = Literal[
-    'dataProduct',
-    'structuredProperty',
-    'entityType',
-    'platformResource',
-    'businessAttribute',
-    'dataType',
+    'dataPlatformInstance',
+    'dataHubRole',
+    'dataHubUpgrade',
+    'dataHubPersona',
+    'tag',
+    'mlModelGroup',
+    'dataContract',
+    'domain',
     'inviteToken',
-    'assertion',
-    'schemaField',
-    'corpGroup',
-    'role',
+    'dashboard',
+    'dataFlow',
     'dataProcessInstance',
-    'dataHubSecret',
-    'dataHubPersona',
+    'corpuser',
+    'dataHubRetention',
+    'notebook',
+    'incident',
     'mlFeatureTable',
-    'glossaryTerm',
-    'recommendationModule',
-    'post',
-    'mlPrimaryKey',
-    'dataPlatformInstance',
-    'dataHubMetricCube',
-    'query',
-    'dataset',
-    'dataHubExecutionRequest',
-    'chart',
-    'mlModelGroup',
+    'constraint',
     'subscription',
-    'anomaly',
+    'query',
+    'mlFeature',
+    'dataHubRemoteExecutorGlobalConfig',
+    'globalSettings',
+    'mlModel',
+    'versionSet',
     'dataHubRemoteExecutorPool',
-    'dataJob',
-    'domain',
-    'erModelRelationship',
-    'dataHubRole',
-    'form',
-    'dataHubAccessToken',
     'dataHubAction',
-    'dataPlatform',
+    'dataJob',
+    'corpGroup',
+    'role',
     'container',
-    'tag',
+    'mlPrimaryKey',
     'dataHubPolicy',
-    'constraint',
-    'glossaryNode',
-    'dataProcess',
+    'dataHubMetricCube',
+    'erModelRelationship',
+    'glossaryTerm',
     'dataHubStepState',
-    'notebook',
-    'mlFeature',
-    'dataHubUpgrade',
-    'dashboard',
-    'mlModel',
-    'incident',
-    'globalSettings',
-    'dataHubView',
-    'dataHubRetention',
+    'glossaryNode',
+    'form',
+    'linkPreview',
+    'chart',
+    'dataHubSecret',
     'ownershipType',
+    'monitorSuite',
+    'telemetry',
+    'mlModelDeployment',
+    'assertion',
+    'dataHubExecutionRequest',
+    'dataHubAccessToken',
+    'dataHubIngestionSource',
+    'dataset',
     'actionRequest',
-    'dataHubRemoteExecutorGlobalConfig',
-    'dataFlow',
-    'dataContract',
-    'dataHubConnection',
+    'dataHubView',
     'dataHubRemoteExecutor',
-    'monitor',
-    'corpuser',
-    'versionSet',
     'test',
-    'dataHubIngestionSource',
-    'mlModelDeployment',
-    'linkPreview',
-    'telemetry'
+    'dataPlatform',
+    'dataProcess',
+    'dataHubConnection',
+    'recommendationModule',
+    'schemaField',
+    'post',
+    'monitor',
+    'dataType',
+    'businessAttribute',
+    'platformResource',
+    'entityType',
+    'dataProduct',
+    'structuredProperty'
 ]
 
 # fmt: on