acryl-datahub-cloud 0.3.9.2rc1__py3-none-any.whl → 0.3.10rc1__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,
@@ -37651,6 +38431,7 @@ ASPECT_CLASSES: List[Type[_Aspect]] = [
     EditableDataJobPropertiesClass,
     DatahubIngestionRunSummaryClass,
     DatahubIngestionCheckpointClass,
+    MonitorSuiteInfoClass,
     MonitorInfoClass,
     MonitorTimeseriesStateClass,
     SchemaFieldAliasesClass,
@@ -37730,7 +38511,7 @@ ASPECT_CLASSES: List[Type[_Aspect]] = [
     DataProcessInstanceRunEventClass,
     DataProcessInfoClass,
     DataProcessInstanceOutputClass,
-    AnomalyInfoClass,
+    MonitorAnomalyEventClass,
     SchemaFieldProfileClass,
     EditableDatasetPropertiesClass,
     DatasetProfileClass,
@@ -37801,6 +38582,7 @@ ASPECT_CLASSES: List[Type[_Aspect]] = [
     TagKeyClass,
     DataHubPolicyKeyClass,
     ConstraintKeyClass,
+    MonitorSuiteKeyClass,
     GlossaryNodeKeyClass,
     DataProcessKeyClass,
     DataHubStepStateKeyClass,
@@ -37928,6 +38710,7 @@ class AspectBag(TypedDict, total=False):
     editableDataJobProperties: EditableDataJobPropertiesClass
     datahubIngestionRunSummary: DatahubIngestionRunSummaryClass
     datahubIngestionCheckpoint: DatahubIngestionCheckpointClass
+    monitorSuiteInfo: MonitorSuiteInfoClass
     monitorInfo: MonitorInfoClass
     monitorTimeseriesState: MonitorTimeseriesStateClass
     schemaFieldAliases: SchemaFieldAliasesClass
@@ -38007,7 +38790,7 @@ class AspectBag(TypedDict, total=False):
     dataProcessInstanceRunEvent: DataProcessInstanceRunEventClass
     dataProcessInfo: DataProcessInfoClass
     dataProcessInstanceOutput: DataProcessInstanceOutputClass
-    anomalyInfo: AnomalyInfoClass
+    monitorAnomalyEvent: MonitorAnomalyEventClass
     schemaFieldProfile: SchemaFieldProfileClass
     editableDatasetProperties: EditableDatasetPropertiesClass
     datasetProfile: DatasetProfileClass
@@ -38078,6 +38861,7 @@ class AspectBag(TypedDict, total=False):
     tagKey: TagKeyClass
     dataHubPolicyKey: DataHubPolicyKeyClass
     constraintKey: ConstraintKeyClass
+    monitorSuiteKey: MonitorSuiteKeyClass
     glossaryNodeKey: GlossaryNodeKeyClass
     dataProcessKey: DataProcessKeyClass
     dataHubStepStateKey: DataHubStepStateKeyClass
@@ -38164,7 +38948,6 @@ KEY_ASPECTS: Dict[str, Type[_Aspect]] = {
     'chart': ChartKeyClass,
     'mlModelGroup': MLModelGroupKeyClass,
     'subscription': SubscriptionKeyClass,
-    'anomaly': AnomalyKeyClass,
     'dataHubRemoteExecutorPool': RemoteExecutorPoolKeyClass,
     'dataJob': DataJobKeyClass,
     'domain': DomainKeyClass,
@@ -38178,6 +38961,7 @@ KEY_ASPECTS: Dict[str, Type[_Aspect]] = {
     'tag': TagKeyClass,
     'dataHubPolicy': DataHubPolicyKeyClass,
     'constraint': ConstraintKeyClass,
+    'monitorSuite': MonitorSuiteKeyClass,
     'glossaryNode': GlossaryNodeKeyClass,
     'dataProcess': DataProcessKeyClass,
     'dataHubStepState': DataHubStepStateKeyClass,
@@ -38235,7 +39019,6 @@ ENTITY_TYPE_NAMES: List[str] = [
     'chart',
     'mlModelGroup',
     'subscription',
-    'anomaly',
     'dataHubRemoteExecutorPool',
     'dataJob',
     'domain',
@@ -38249,6 +39032,7 @@ ENTITY_TYPE_NAMES: List[str] = [
     'tag',
     'dataHubPolicy',
     'constraint',
+    'monitorSuite',
     'glossaryNode',
     'dataProcess',
     'dataHubStepState',
@@ -38305,7 +39089,6 @@ EntityTypeName = Literal[
     'chart',
     'mlModelGroup',
     'subscription',
-    'anomaly',
     'dataHubRemoteExecutorPool',
     'dataJob',
     'domain',
@@ -38319,6 +39102,7 @@ EntityTypeName = Literal[
     'tag',
     'dataHubPolicy',
     'constraint',
+    'monitorSuite',
     'glossaryNode',
     'dataProcess',
     'dataHubStepState',