pulumi-azure-native 3.9.0a1757522298__py3-none-any.whl → 3.11.0a1761334446__py3-none-any.whl

pulumi_azure_native/monitor/outputs.py

@@ -23,9 +23,11 @@ __all__ = [
     'ActionGroupResponse',
     'ActionListResponse',
     'ActionsResponse',
+    'AlertConfigurationResponse',
     'AlertRuleAllOfConditionResponse',
     'AlertRuleAnyOfOrLeafConditionResponse',
     'AlertRuleLeafConditionResponse',
+    'ApplicationInsightsTopologyDiscoveryRulePropertiesResponse',
     'ArmRoleReceiverResponse',
     'AutomationRunbookReceiverResponse',
     'AutoscaleNotificationResponse',
@@ -37,7 +39,9 @@ __all__ = [
     'AzureMonitorWorkspaceLogsExporterResponse',
     'AzureMonitorWorkspaceResponseDefaultIngestionSettings',
     'AzureMonitorWorkspaceResponseMetrics',
+    'AzureMonitorWorkspaceSignalGroupResponse',
     'AzureResourceManagerCommonTypesExtendedLocationResponse',
+    'AzureResourceSignalGroupResponse',
     'BatchProcessorResponse',
     'CacheConfigurationResponse',
     'ColumnDefinitionResponse',
@@ -62,33 +66,49 @@ __all__ = [
     'DataFlowResponse',
     'DataImportSourcesResponseEventHub',
     'DataSourcesSpecResponseDataImports',
+    'DependenciesSignalGroupResponse',
     'DestinationsSpecResponseAzureMonitorMetrics',
     'DiagnosticSettingsCategoryResourceResponse',
     'DimensionResponse',
+    'DiscoveryErrorResponse',
+    'DynamicDetectionRuleResponse',
     'DynamicMetricCriteriaResponse',
     'DynamicThresholdFailingPeriodsResponse',
     'EmailNotificationResponse',
     'EmailReceiverResponse',
+    'EntityAlertsResponse',
+    'EntityCoordinatesResponse',
+    'EntityPropertiesResponse',
+    'EvaluationRuleResponse',
     'EventHubDestinationResponse',
     'EventHubDirectDestinationResponse',
     'EventHubReceiverResponse',
     'ExporterResponse',
     'ExtensionDataSourceResponse',
+    'HealthModelPropertiesResponse',
+    'IconDefinitionResponse',
     'IdentityResponse',
     'IisLogsDataSourceResponse',
     'IncidentReceiverResponse',
     'IncidentServiceConnectionResponse',
+    'InvestigationExecutionResponse',
+    'InvestigationMetadataResponse',
+    'InvestigationScopeResponse',
+    'IssuePropertiesResponse',
     'ItsmReceiverResponse',
     'JsonArrayMapperResponse',
     'JsonMapperDestinationFieldResponse',
     'JsonMapperSourceFieldResponse',
     'LocationSpecResponse',
     'LogAnalyticsDestinationResponse',
+    'LogAnalyticsQuerySignalDefinitionPropertiesResponse',
+    'LogAnalyticsSignalGroupResponse',
     'LogFileSettingsResponseText',
     'LogFilesDataSourceResponse',
     'LogFilesDataSourceResponseSettings',
     'LogSettingsResponse',
     'LogicAppReceiverResponse',
+    'ManagedIdentityAuthenticationSettingPropertiesResponse',
     'ManagedServiceIdentityResponse',
     'ManagementGroupLogSettingsResponse',
     'MetricAlertActionResponse',
@@ -98,9 +118,11 @@ __all__ = [
     'MetricDimensionResponse',
     'MetricSettingsResponse',
     'MetricTriggerResponse',
+    'ModelDiscoverySettingsResponse',
     'MonitoringAccountDestinationResponse',
     'NetworkingConfigurationResponse',
     'NetworkingRouteResponse',
+    'OriginResponse',
     'OtlpReceiverResponse',
     'PerfCounterDataSourceResponse',
     'PersistenceConfigurationsResponse',
@@ -114,13 +136,20 @@ __all__ = [
     'PrivateLinkServiceConnectionStateResponse',
     'ProcessorResponse',
     'PrometheusForwarderDataSourceResponse',
+    'PrometheusMetricsSignalDefinitionPropertiesResponse',
     'ReceiverResponse',
     'RecordMapResponse',
     'RecurrenceResponse',
     'RecurrentScheduleResponse',
+    'RelatedAlertResponse',
+    'RelatedResourceResponse',
+    'RelationshipPropertiesResponse',
+    'ResourceGraphQueryDiscoveryRulePropertiesResponse',
     'ResourceMapResponse',
+    'ResourceMetricSignalDefinitionPropertiesResponse',
     'RetentionPolicyResponse',
     'RuleResolveConfigurationResponse',
+    'RunParametersResponse',
     'ScaleActionResponse',
     'ScaleCapacityResponse',
     'ScaleRuleMetricDimensionResponse',
@@ -129,6 +158,8 @@ __all__ = [
     'SchemaMapResponse',
     'ScopeMapResponse',
     'ServiceResponse',
+    'SignalAssignmentResponse',
+    'SignalGroupResponse',
     'SmsReceiverResponse',
     'StorageBlobDestinationResponse',
     'StorageTableDestinationResponse',
@@ -138,6 +169,7 @@ __all__ = [
     'SyslogReceiverResponse',
     'SystemDataResponse',
     'TcpExporterResponse',
+    'ThresholdRuleResponse',
     'TimeWindowResponse',
     'UdpReceiverResponse',
     'UserAssignedIdentityResponse',
@@ -443,6 +475,69 @@ class ActionsResponse(dict):
         return pulumi.get(self, "custom_properties")
 
 
+@pulumi.output_type
+class AlertConfigurationResponse(dict):
+    """
+    Alert configuration details
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "actionGroupIds":
+            suggest = "action_group_ids"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AlertConfigurationResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AlertConfigurationResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AlertConfigurationResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 severity: builtins.str,
+                 action_group_ids: Optional[Sequence[builtins.str]] = None,
+                 description: Optional[builtins.str] = None):
+        """
+        Alert configuration details
+        :param builtins.str severity: The severity of triggered alert.
+        :param Sequence[builtins.str] action_group_ids: Optional list of action group resource IDs to be notified when the alert is triggered.
+        :param builtins.str description: The alert rule description.
+        """
+        pulumi.set(__self__, "severity", severity)
+        if action_group_ids is not None:
+            pulumi.set(__self__, "action_group_ids", action_group_ids)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+
+    @property
+    @pulumi.getter
+    def severity(self) -> builtins.str:
+        """
+        The severity of triggered alert.
+        """
+        return pulumi.get(self, "severity")
+
+    @property
+    @pulumi.getter(name="actionGroupIds")
+    def action_group_ids(self) -> Optional[Sequence[builtins.str]]:
+        """
+        Optional list of action group resource IDs to be notified when the alert is triggered.
+        """
+        return pulumi.get(self, "action_group_ids")
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[builtins.str]:
+        """
+        The alert rule description.
+        """
+        return pulumi.get(self, "description")
+
+
 @pulumi.output_type
 class AlertRuleAllOfConditionResponse(dict):
     """
@@ -643,6 +738,163 @@ class AlertRuleLeafConditionResponse(dict):
         return pulumi.get(self, "field")
 
 
+@pulumi.output_type
+class ApplicationInsightsTopologyDiscoveryRulePropertiesResponse(dict):
+    """
+    Discovery rule properties for an Application Insights topology query
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "addRecommendedSignals":
+            suggest = "add_recommended_signals"
+        elif key == "applicationInsightsResourceId":
+            suggest = "application_insights_resource_id"
+        elif key == "authenticationSetting":
+            suggest = "authentication_setting"
+        elif key == "deletionDate":
+            suggest = "deletion_date"
+        elif key == "discoverRelationships":
+            suggest = "discover_relationships"
+        elif key == "discoveryRuleKind":
+            suggest = "discovery_rule_kind"
+        elif key == "entityName":
+            suggest = "entity_name"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "displayName":
+            suggest = "display_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ApplicationInsightsTopologyDiscoveryRulePropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ApplicationInsightsTopologyDiscoveryRulePropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ApplicationInsightsTopologyDiscoveryRulePropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 add_recommended_signals: builtins.str,
+                 application_insights_resource_id: builtins.str,
+                 authentication_setting: builtins.str,
+                 deletion_date: builtins.str,
+                 discover_relationships: builtins.str,
+                 discovery_rule_kind: builtins.str,
+                 entity_name: builtins.str,
+                 error: 'outputs.DiscoveryErrorResponse',
+                 provisioning_state: builtins.str,
+                 display_name: Optional[builtins.str] = None):
+        """
+        Discovery rule properties for an Application Insights topology query
+        :param builtins.str add_recommended_signals: Whether to add all recommended signals to the discovered entities.
+        :param builtins.str application_insights_resource_id: Application Insights resource ID
+        :param builtins.str authentication_setting: Reference to the name of the authentication setting which is used for querying Azure Resource Graph. The same authentication setting will also be assigned to any discovered entities.
+        :param builtins.str deletion_date: Date when the discovery rule was (soft-)deleted.
+        :param builtins.str discover_relationships: Whether to create relationships between the discovered entities based on a set of built-in rules. These relationships cannot be manually deleted.
+        :param builtins.str discovery_rule_kind: Discovery rule relationship discovery behavior
+               Expected value is 'ApplicationInsightsTopology'.
+        :param builtins.str entity_name: Name of the entity which represents the discovery rule. Note: It might take a few minutes after creating the discovery rule until the entity is created.
+        :param 'DiscoveryErrorResponse' error: Error details if the last discovery operation failed.
+        :param builtins.str provisioning_state: The status of the last operation.
+        :param builtins.str display_name: Display name
+        """
+        pulumi.set(__self__, "add_recommended_signals", add_recommended_signals)
+        pulumi.set(__self__, "application_insights_resource_id", application_insights_resource_id)
+        pulumi.set(__self__, "authentication_setting", authentication_setting)
+        pulumi.set(__self__, "deletion_date", deletion_date)
+        pulumi.set(__self__, "discover_relationships", discover_relationships)
+        pulumi.set(__self__, "discovery_rule_kind", 'ApplicationInsightsTopology')
+        pulumi.set(__self__, "entity_name", entity_name)
+        pulumi.set(__self__, "error", error)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        if display_name is not None:
+            pulumi.set(__self__, "display_name", display_name)
+
+    @property
+    @pulumi.getter(name="addRecommendedSignals")
+    def add_recommended_signals(self) -> builtins.str:
+        """
+        Whether to add all recommended signals to the discovered entities.
+        """
+        return pulumi.get(self, "add_recommended_signals")
+
+    @property
+    @pulumi.getter(name="applicationInsightsResourceId")
+    def application_insights_resource_id(self) -> builtins.str:
+        """
+        Application Insights resource ID
+        """
+        return pulumi.get(self, "application_insights_resource_id")
+
+    @property
+    @pulumi.getter(name="authenticationSetting")
+    def authentication_setting(self) -> builtins.str:
+        """
+        Reference to the name of the authentication setting which is used for querying Azure Resource Graph. The same authentication setting will also be assigned to any discovered entities.
+        """
+        return pulumi.get(self, "authentication_setting")
+
+    @property
+    @pulumi.getter(name="deletionDate")
+    def deletion_date(self) -> builtins.str:
+        """
+        Date when the discovery rule was (soft-)deleted.
+        """
+        return pulumi.get(self, "deletion_date")
+
+    @property
+    @pulumi.getter(name="discoverRelationships")
+    def discover_relationships(self) -> builtins.str:
+        """
+        Whether to create relationships between the discovered entities based on a set of built-in rules. These relationships cannot be manually deleted.
+        """
+        return pulumi.get(self, "discover_relationships")
+
+    @property
+    @pulumi.getter(name="discoveryRuleKind")
+    def discovery_rule_kind(self) -> builtins.str:
+        """
+        Discovery rule relationship discovery behavior
+        Expected value is 'ApplicationInsightsTopology'.
+        """
+        return pulumi.get(self, "discovery_rule_kind")
+
+    @property
+    @pulumi.getter(name="entityName")
+    def entity_name(self) -> builtins.str:
+        """
+        Name of the entity which represents the discovery rule. Note: It might take a few minutes after creating the discovery rule until the entity is created.
+        """
+        return pulumi.get(self, "entity_name")
+
+    @property
+    @pulumi.getter
+    def error(self) -> 'outputs.DiscoveryErrorResponse':
+        """
+        Error details if the last discovery operation failed.
+        """
+        return pulumi.get(self, "error")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        The status of the last operation.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> Optional[builtins.str]:
+        """
+        Display name
+        """
+        return pulumi.get(self, "display_name")
+
+
 @pulumi.output_type
 class ArmRoleReceiverResponse(dict):
     """
@@ -1471,6 +1723,72 @@ class AzureMonitorWorkspaceResponseMetrics(dict):
         return pulumi.get(self, "prometheus_query_endpoint")
 
 
+@pulumi.output_type
+class AzureMonitorWorkspaceSignalGroupResponse(dict):
+    """
+    A grouping of signal assignments for a Azure Monitor Workspace
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "authenticationSetting":
+            suggest = "authentication_setting"
+        elif key == "azureMonitorWorkspaceResourceId":
+            suggest = "azure_monitor_workspace_resource_id"
+        elif key == "signalAssignments":
+            suggest = "signal_assignments"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AzureMonitorWorkspaceSignalGroupResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AzureMonitorWorkspaceSignalGroupResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AzureMonitorWorkspaceSignalGroupResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 authentication_setting: builtins.str,
+                 azure_monitor_workspace_resource_id: builtins.str,
+                 signal_assignments: Optional[Sequence['outputs.SignalAssignmentResponse']] = None):
+        """
+        A grouping of signal assignments for a Azure Monitor Workspace
+        :param builtins.str authentication_setting: Reference to the name of the authentication setting which is used for querying the data source
+        :param builtins.str azure_monitor_workspace_resource_id: Azure Monitor workspace resource ID
+        :param Sequence['SignalAssignmentResponse'] signal_assignments: Signal definitions which are assigned to this signal group. All assignments are combined with an OR operator.
+        """
+        pulumi.set(__self__, "authentication_setting", authentication_setting)
+        pulumi.set(__self__, "azure_monitor_workspace_resource_id", azure_monitor_workspace_resource_id)
+        if signal_assignments is not None:
+            pulumi.set(__self__, "signal_assignments", signal_assignments)
+
+    @property
+    @pulumi.getter(name="authenticationSetting")
+    def authentication_setting(self) -> builtins.str:
+        """
+        Reference to the name of the authentication setting which is used for querying the data source
+        """
+        return pulumi.get(self, "authentication_setting")
+
+    @property
+    @pulumi.getter(name="azureMonitorWorkspaceResourceId")
+    def azure_monitor_workspace_resource_id(self) -> builtins.str:
+        """
+        Azure Monitor workspace resource ID
+        """
+        return pulumi.get(self, "azure_monitor_workspace_resource_id")
+
+    @property
+    @pulumi.getter(name="signalAssignments")
+    def signal_assignments(self) -> Optional[Sequence['outputs.SignalAssignmentResponse']]:
+        """
+        Signal definitions which are assigned to this signal group. All assignments are combined with an OR operator.
+        """
+        return pulumi.get(self, "signal_assignments")
+
+
 @pulumi.output_type
 class AzureResourceManagerCommonTypesExtendedLocationResponse(dict):
     """
@@ -1504,6 +1822,72 @@ class AzureResourceManagerCommonTypesExtendedLocationResponse(dict):
         return pulumi.get(self, "type")
 
 
+@pulumi.output_type
+class AzureResourceSignalGroupResponse(dict):
+    """
+    A grouping of signal assignments for an Azure resource
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "authenticationSetting":
+            suggest = "authentication_setting"
+        elif key == "azureResourceId":
+            suggest = "azure_resource_id"
+        elif key == "signalAssignments":
+            suggest = "signal_assignments"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AzureResourceSignalGroupResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AzureResourceSignalGroupResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AzureResourceSignalGroupResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 authentication_setting: builtins.str,
+                 azure_resource_id: builtins.str,
+                 signal_assignments: Optional[Sequence['outputs.SignalAssignmentResponse']] = None):
+        """
+        A grouping of signal assignments for an Azure resource
+        :param builtins.str authentication_setting: Reference to the name of the authentication setting which is used for querying the data source
+        :param builtins.str azure_resource_id: Azure resource ID
+        :param Sequence['SignalAssignmentResponse'] signal_assignments: Signal definitions which are assigned to this signal group. All assignments are combined with an OR operator.
+        """
+        pulumi.set(__self__, "authentication_setting", authentication_setting)
+        pulumi.set(__self__, "azure_resource_id", azure_resource_id)
+        if signal_assignments is not None:
+            pulumi.set(__self__, "signal_assignments", signal_assignments)
+
+    @property
+    @pulumi.getter(name="authenticationSetting")
+    def authentication_setting(self) -> builtins.str:
+        """
+        Reference to the name of the authentication setting which is used for querying the data source
+        """
+        return pulumi.get(self, "authentication_setting")
+
+    @property
+    @pulumi.getter(name="azureResourceId")
+    def azure_resource_id(self) -> builtins.str:
+        """
+        Azure resource ID
+        """
+        return pulumi.get(self, "azure_resource_id")
+
+    @property
+    @pulumi.getter(name="signalAssignments")
+    def signal_assignments(self) -> Optional[Sequence['outputs.SignalAssignmentResponse']]:
+        """
+        Signal definitions which are assigned to this signal group. All assignments are combined with an OR operator.
+        """
+        return pulumi.get(self, "signal_assignments")
+
+
 @pulumi.output_type
 class BatchProcessorResponse(dict):
     """
@@ -3263,6 +3647,75 @@ class DataSourcesSpecResponseDataImports(dict):
         return pulumi.get(self, "event_hub")
 
 
+@pulumi.output_type
+class DependenciesSignalGroupResponse(dict):
+    """
+    Properties for dependent entities, i.e. child entities
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "aggregationType":
+            suggest = "aggregation_type"
+        elif key == "degradedThreshold":
+            suggest = "degraded_threshold"
+        elif key == "unhealthyThreshold":
+            suggest = "unhealthy_threshold"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DependenciesSignalGroupResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DependenciesSignalGroupResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DependenciesSignalGroupResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 aggregation_type: Optional[builtins.str] = None,
+                 degraded_threshold: Optional[builtins.str] = None,
+                 unhealthy_threshold: Optional[builtins.str] = None):
+        """
+        Properties for dependent entities, i.e. child entities
+        :param builtins.str aggregation_type: Aggregation type for child dependencies.
+        :param builtins.str degraded_threshold: Degraded threshold for aggregating the propagated health state of child dependencies. Can be either an absolute number that is greater than 0, or a percentage between 1-100%. The entity will be considered degraded when the number of not healthy child dependents (unhealthy, degraded, unknown) is equal to or above the threshold value. Must only be set when AggregationType is 'Thresholds'.
+        :param builtins.str unhealthy_threshold: Unhealthy threshold for aggregating the propagated health state of child dependencies. Can be either an absolute number that is greater than 0, or a percentage between 1-100%. The entity will be considered unhealthy when the number of not healthy child dependents (unhealthy, degraded, unknown) is equal to or above the threshold value. Must only be set when AggregationType is 'Thresholds'.
+        """
+        if aggregation_type is None:
+            aggregation_type = 'WorstOf'
+        pulumi.set(__self__, "aggregation_type", aggregation_type)
+        if degraded_threshold is not None:
+            pulumi.set(__self__, "degraded_threshold", degraded_threshold)
+        if unhealthy_threshold is not None:
+            pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
+
+    @property
+    @pulumi.getter(name="aggregationType")
+    def aggregation_type(self) -> builtins.str:
+        """
+        Aggregation type for child dependencies.
+        """
+        return pulumi.get(self, "aggregation_type")
+
+    @property
+    @pulumi.getter(name="degradedThreshold")
+    def degraded_threshold(self) -> Optional[builtins.str]:
+        """
+        Degraded threshold for aggregating the propagated health state of child dependencies. Can be either an absolute number that is greater than 0, or a percentage between 1-100%. The entity will be considered degraded when the number of not healthy child dependents (unhealthy, degraded, unknown) is equal to or above the threshold value. Must only be set when AggregationType is 'Thresholds'.
+        """
+        return pulumi.get(self, "degraded_threshold")
+
+    @property
+    @pulumi.getter(name="unhealthyThreshold")
+    def unhealthy_threshold(self) -> Optional[builtins.str]:
+        """
+        Unhealthy threshold for aggregating the propagated health state of child dependencies. Can be either an absolute number that is greater than 0, or a percentage between 1-100%. The entity will be considered unhealthy when the number of not healthy child dependents (unhealthy, degraded, unknown) is equal to or above the threshold value. Must only be set when AggregationType is 'Thresholds'.
+        """
+        return pulumi.get(self, "unhealthy_threshold")
+
+
 @pulumi.output_type
 class DestinationsSpecResponseAzureMonitorMetrics(dict):
     """
@@ -3411,6 +3864,118 @@ class DimensionResponse(dict):
         return pulumi.get(self, "values")
 
 
+@pulumi.output_type
+class DiscoveryErrorResponse(dict):
+    """
+    Error details for a failed discovery operation
+    """
+    def __init__(__self__, *,
+                 context: Sequence[builtins.str],
+                 message: builtins.str):
+        """
+        Error details for a failed discovery operation
+        :param Sequence[builtins.str] context: Additional context information, like resource IDs or query details
+        :param builtins.str message: Error message
+        """
+        pulumi.set(__self__, "context", context)
+        pulumi.set(__self__, "message", message)
+
+    @property
+    @pulumi.getter
+    def context(self) -> Sequence[builtins.str]:
+        """
+        Additional context information, like resource IDs or query details
+        """
+        return pulumi.get(self, "context")
+
+    @property
+    @pulumi.getter
+    def message(self) -> builtins.str:
+        """
+        Error message
+        """
+        return pulumi.get(self, "message")
+
+
+@pulumi.output_type
+class DynamicDetectionRuleResponse(dict):
+    """
+    ML-based evaluation rule for a signal definition
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dynamicThresholdDirection":
+            suggest = "dynamic_threshold_direction"
+        elif key == "dynamicThresholdModel":
+            suggest = "dynamic_threshold_model"
+        elif key == "modelSensitivity":
+            suggest = "model_sensitivity"
+        elif key == "trainingStartTime":
+            suggest = "training_start_time"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DynamicDetectionRuleResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DynamicDetectionRuleResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DynamicDetectionRuleResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 dynamic_threshold_direction: builtins.str,
+                 dynamic_threshold_model: builtins.str,
+                 model_sensitivity: builtins.float,
+                 training_start_time: Optional[builtins.str] = None):
+        """
+        ML-based evaluation rule for a signal definition
+        :param builtins.str dynamic_threshold_direction: Threshold direction
+        :param builtins.str dynamic_threshold_model: ML model to use for dynamic thresholds
+        :param builtins.float model_sensitivity: ML model sensitivity. Lowest value = high sensitivity. Supported step size = 0.5
+        :param builtins.str training_start_time: Start time of the training in UTC.
+        """
+        pulumi.set(__self__, "dynamic_threshold_direction", dynamic_threshold_direction)
+        pulumi.set(__self__, "dynamic_threshold_model", dynamic_threshold_model)
+        pulumi.set(__self__, "model_sensitivity", model_sensitivity)
+        if training_start_time is not None:
+            pulumi.set(__self__, "training_start_time", training_start_time)
+
+    @property
+    @pulumi.getter(name="dynamicThresholdDirection")
+    def dynamic_threshold_direction(self) -> builtins.str:
+        """
+        Threshold direction
+        """
+        return pulumi.get(self, "dynamic_threshold_direction")
+
+    @property
+    @pulumi.getter(name="dynamicThresholdModel")
+    def dynamic_threshold_model(self) -> builtins.str:
+        """
+        ML model to use for dynamic thresholds
+        """
+        return pulumi.get(self, "dynamic_threshold_model")
+
+    @property
+    @pulumi.getter(name="modelSensitivity")
+    def model_sensitivity(self) -> builtins.float:
+        """
+        ML model sensitivity. Lowest value = high sensitivity. Supported step size = 0.5
+        """
+        return pulumi.get(self, "model_sensitivity")
+
+    @property
+    @pulumi.getter(name="trainingStartTime")
+    def training_start_time(self) -> Optional[builtins.str]:
+        """
+        Start time of the training in UTC.
+        """
+        return pulumi.get(self, "training_start_time")
+
+
 @pulumi.output_type
 class DynamicMetricCriteriaResponse(dict):
     """
@@ -3782,8 +4347,340 @@ class EmailReceiverResponse(dict):
 
 
 @pulumi.output_type
-class EventHubDestinationResponse(dict):
-    @staticmethod
+class EntityAlertsResponse(dict):
+    """
+    Alert configuration for an entity
+    """
+    def __init__(__self__, *,
+                 degraded: Optional['outputs.AlertConfigurationResponse'] = None,
+                 unhealthy: Optional['outputs.AlertConfigurationResponse'] = None):
+        """
+        Alert configuration for an entity
+        :param 'AlertConfigurationResponse' degraded: Alert to be triggered on state change to degraded
+        :param 'AlertConfigurationResponse' unhealthy: Alert to be triggered on state change to unhealthy
+        """
+        if degraded is not None:
+            pulumi.set(__self__, "degraded", degraded)
+        if unhealthy is not None:
+            pulumi.set(__self__, "unhealthy", unhealthy)
+
+    @property
+    @pulumi.getter
+    def degraded(self) -> Optional['outputs.AlertConfigurationResponse']:
+        """
+        Alert to be triggered on state change to degraded
+        """
+        return pulumi.get(self, "degraded")
+
+    @property
+    @pulumi.getter
+    def unhealthy(self) -> Optional['outputs.AlertConfigurationResponse']:
+        """
+        Alert to be triggered on state change to unhealthy
+        """
+        return pulumi.get(self, "unhealthy")
+
+
+@pulumi.output_type
+class EntityCoordinatesResponse(dict):
+    """
+    Visual position of the entity
+    """
+    def __init__(__self__, *,
+                 x: builtins.float,
+                 y: builtins.float):
+        """
+        Visual position of the entity
+        :param builtins.float x: X Coordinate
+        :param builtins.float y: Y Coordinate
+        """
+        pulumi.set(__self__, "x", x)
+        pulumi.set(__self__, "y", y)
+
+    @property
+    @pulumi.getter
+    def x(self) -> builtins.float:
+        """
+        X Coordinate
+        """
+        return pulumi.get(self, "x")
+
+    @property
+    @pulumi.getter
+    def y(self) -> builtins.float:
+        """
+        Y Coordinate
+        """
+        return pulumi.get(self, "y")
+
+
+@pulumi.output_type
+class EntityPropertiesResponse(dict):
+    """
+    Properties which are common across all kinds of entities
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "deletionDate":
+            suggest = "deletion_date"
+        elif key == "discoveredBy":
+            suggest = "discovered_by"
+        elif key == "healthState":
+            suggest = "health_state"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "canvasPosition":
+            suggest = "canvas_position"
+        elif key == "displayName":
+            suggest = "display_name"
+        elif key == "healthObjective":
+            suggest = "health_objective"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in EntityPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        EntityPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        EntityPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 deletion_date: builtins.str,
+                 discovered_by: builtins.str,
+                 health_state: builtins.str,
+                 provisioning_state: builtins.str,
+                 alerts: Optional['outputs.EntityAlertsResponse'] = None,
+                 canvas_position: Optional['outputs.EntityCoordinatesResponse'] = None,
+                 display_name: Optional[builtins.str] = None,
+                 health_objective: Optional[builtins.float] = None,
+                 icon: Optional['outputs.IconDefinitionResponse'] = None,
+                 impact: Optional[builtins.str] = None,
+                 kind: Optional[builtins.str] = None,
+                 signals: Optional['outputs.SignalGroupResponse'] = None,
+                 tags: Optional[Mapping[str, builtins.str]] = None):
+        """
+        Properties which are common across all kinds of entities
+        :param builtins.str deletion_date: Date when the entity was (soft-)deleted
+        :param builtins.str discovered_by: Discovered by which discovery rule. If set, the entity cannot be deleted manually.
+        :param builtins.str health_state: Health state of this entity
+        :param builtins.str provisioning_state: The status of the last operation.
+        :param 'EntityAlertsResponse' alerts: Alert configuration for this entity
+        :param 'EntityCoordinatesResponse' canvas_position: Positioning of the entity on the model canvas
+        :param builtins.str display_name: Display name
+        :param builtins.float health_objective: Health objective as a percentage of time the entity should be healthy.
+        :param 'IconDefinitionResponse' icon: Visual icon definition. If not set, a default icon is used.
+        :param builtins.str impact: Impact of the entity in health state propagation
+        :param builtins.str kind: Entity kind
+        :param 'SignalGroupResponse' signals: Signal groups which are assigned to this entity
+        :param Mapping[str, builtins.str] tags: Optional set of labels (key-value pairs)
+        """
+        pulumi.set(__self__, "deletion_date", deletion_date)
+        pulumi.set(__self__, "discovered_by", discovered_by)
+        pulumi.set(__self__, "health_state", health_state)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        if alerts is not None:
+            pulumi.set(__self__, "alerts", alerts)
+        if canvas_position is not None:
+            pulumi.set(__self__, "canvas_position", canvas_position)
+        if display_name is not None:
+            pulumi.set(__self__, "display_name", display_name)
+        if health_objective is not None:
+            pulumi.set(__self__, "health_objective", health_objective)
+        if icon is not None:
+            pulumi.set(__self__, "icon", icon)
+        if impact is None:
+            impact = 'Standard'
+        if impact is not None:
+            pulumi.set(__self__, "impact", impact)
+        if kind is None:
+            kind = 'Default'
+        if kind is not None:
+            pulumi.set(__self__, "kind", kind)
+        if signals is not None:
+            pulumi.set(__self__, "signals", signals)
+        if tags is not None:
+            pulumi.set(__self__, "tags", tags)
+
+    @property
+    @pulumi.getter(name="deletionDate")
+    def deletion_date(self) -> builtins.str:
+        """
+        Date when the entity was (soft-)deleted
+        """
+        return pulumi.get(self, "deletion_date")
+
+    @property
+    @pulumi.getter(name="discoveredBy")
+    def discovered_by(self) -> builtins.str:
+        """
+        Discovered by which discovery rule. If set, the entity cannot be deleted manually.
+        """
+        return pulumi.get(self, "discovered_by")
+
+    @property
+    @pulumi.getter(name="healthState")
+    def health_state(self) -> builtins.str:
+        """
+        Health state of this entity
+        """
+        return pulumi.get(self, "health_state")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        The status of the last operation.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter
+    def alerts(self) -> Optional['outputs.EntityAlertsResponse']:
+        """
+        Alert configuration for this entity
+        """
+        return pulumi.get(self, "alerts")
+
+    @property
+    @pulumi.getter(name="canvasPosition")
+    def canvas_position(self) -> Optional['outputs.EntityCoordinatesResponse']:
+        """
+        Positioning of the entity on the model canvas
+        """
+        return pulumi.get(self, "canvas_position")
+
+    @property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> Optional[builtins.str]:
+        """
+        Display name
+        """
+        return pulumi.get(self, "display_name")
+
+    @property
+    @pulumi.getter(name="healthObjective")
+    def health_objective(self) -> Optional[builtins.float]:
+        """
+        Health objective as a percentage of time the entity should be healthy.
+        """
+        return pulumi.get(self, "health_objective")
+
+    @property
+    @pulumi.getter
+    def icon(self) -> Optional['outputs.IconDefinitionResponse']:
+        """
+        Visual icon definition. If not set, a default icon is used.
+        """
+        return pulumi.get(self, "icon")
+
+    @property
+    @pulumi.getter
+    def impact(self) -> Optional[builtins.str]:
+        """
+        Impact of the entity in health state propagation
+        """
+        return pulumi.get(self, "impact")
+
+    @property
+    @pulumi.getter
+    def kind(self) -> Optional[builtins.str]:
+        """
+        Entity kind
+        """
+        return pulumi.get(self, "kind")
+
+    @property
+    @pulumi.getter
+    def signals(self) -> Optional['outputs.SignalGroupResponse']:
+        """
+        Signal groups which are assigned to this entity
+        """
+        return pulumi.get(self, "signals")
+
+    @property
+    @pulumi.getter
+    def tags(self) -> Optional[Mapping[str, builtins.str]]:
+        """
+        Optional set of labels (key-value pairs)
+        """
+        return pulumi.get(self, "tags")
+
+
+@pulumi.output_type
+class EvaluationRuleResponse(dict):
+    """
+    Evaluation rule for a signal definition
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "degradedRule":
+            suggest = "degraded_rule"
+        elif key == "dynamicDetectionRule":
+            suggest = "dynamic_detection_rule"
+        elif key == "unhealthyRule":
+            suggest = "unhealthy_rule"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in EvaluationRuleResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        EvaluationRuleResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        EvaluationRuleResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 degraded_rule: Optional['outputs.ThresholdRuleResponse'] = None,
+                 dynamic_detection_rule: Optional['outputs.DynamicDetectionRuleResponse'] = None,
+                 unhealthy_rule: Optional['outputs.ThresholdRuleResponse'] = None):
+        """
+        Evaluation rule for a signal definition
+        :param 'ThresholdRuleResponse' degraded_rule: Degraded rule with static threshold. When used, dynamicDetectionRule must not be set.
+        :param 'DynamicDetectionRuleResponse' dynamic_detection_rule: Configure to use ML-based dynamic thresholds. When used, degradedRule and unhealthyRule must not be set.
+        :param 'ThresholdRuleResponse' unhealthy_rule: Unhealthy rule with static threshold. When used, dynamicDetectionRule must not be set.
+        """
+        if degraded_rule is not None:
+            pulumi.set(__self__, "degraded_rule", degraded_rule)
+        if dynamic_detection_rule is not None:
+            pulumi.set(__self__, "dynamic_detection_rule", dynamic_detection_rule)
+        if unhealthy_rule is not None:
+            pulumi.set(__self__, "unhealthy_rule", unhealthy_rule)
+
+    @property
+    @pulumi.getter(name="degradedRule")
+    def degraded_rule(self) -> Optional['outputs.ThresholdRuleResponse']:
+        """
+        Degraded rule with static threshold. When used, dynamicDetectionRule must not be set.
+        """
+        return pulumi.get(self, "degraded_rule")
+
+    @property
+    @pulumi.getter(name="dynamicDetectionRule")
+    def dynamic_detection_rule(self) -> Optional['outputs.DynamicDetectionRuleResponse']:
+        """
+        Configure to use ML-based dynamic thresholds. When used, degradedRule and unhealthyRule must not be set.
+        """
+        return pulumi.get(self, "dynamic_detection_rule")
+
+    @property
+    @pulumi.getter(name="unhealthyRule")
+    def unhealthy_rule(self) -> Optional['outputs.ThresholdRuleResponse']:
+        """
+        Unhealthy rule with static threshold. When used, dynamicDetectionRule must not be set.
+        """
+        return pulumi.get(self, "unhealthy_rule")
+
+
+@pulumi.output_type
+class EventHubDestinationResponse(dict):
+    @staticmethod
     def __key_warning(key: str):
         suggest = None
         if key == "eventHubResourceId":
@@ -4172,6 +5069,123 @@ class ExtensionDataSourceResponse(dict):
         return pulumi.get(self, "streams")
 
 
+@pulumi.output_type
+class HealthModelPropertiesResponse(dict):
+    """
+    HealthModel properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "queryEndpoint":
+            suggest = "query_endpoint"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in HealthModelPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        HealthModelPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        HealthModelPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 provisioning_state: builtins.str,
+                 query_endpoint: builtins.str,
+                 discovery: Optional['outputs.ModelDiscoverySettingsResponse'] = None):
+        """
+        HealthModel properties
+        :param builtins.str provisioning_state: The status of the last operation.
+        :param builtins.str query_endpoint: The data plane endpoint for querying health data
+        :param 'ModelDiscoverySettingsResponse' discovery: Configure to automatically discover entities from a given scope, such as a Service Group. The discovered entities will be linked to the root entity of the health model.
+        """
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "query_endpoint", query_endpoint)
+        if discovery is not None:
+            pulumi.set(__self__, "discovery", discovery)
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        The status of the last operation.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="queryEndpoint")
+    def query_endpoint(self) -> builtins.str:
+        """
+        The data plane endpoint for querying health data
+        """
+        return pulumi.get(self, "query_endpoint")
+
+    @property
+    @pulumi.getter
+    def discovery(self) -> Optional['outputs.ModelDiscoverySettingsResponse']:
+        """
+        Configure to automatically discover entities from a given scope, such as a Service Group. The discovered entities will be linked to the root entity of the health model.
+        """
+        return pulumi.get(self, "discovery")
+
+
+@pulumi.output_type
+class IconDefinitionResponse(dict):
+    """
+    Visual icon definition of an entity
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "iconName":
+            suggest = "icon_name"
+        elif key == "customData":
+            suggest = "custom_data"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in IconDefinitionResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        IconDefinitionResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        IconDefinitionResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 icon_name: builtins.str,
+                 custom_data: Optional[builtins.str] = None):
+        """
+        Visual icon definition of an entity
+        :param builtins.str icon_name: Name of the built-in icon, or 'Custom' to use customData
+        :param builtins.str custom_data: Custom data. Base64-encoded SVG data. If set, this overrides the built-in icon.
+        """
+        pulumi.set(__self__, "icon_name", icon_name)
+        if custom_data is not None:
+            pulumi.set(__self__, "custom_data", custom_data)
+
+    @property
+    @pulumi.getter(name="iconName")
+    def icon_name(self) -> builtins.str:
+        """
+        Name of the built-in icon, or 'Custom' to use customData
+        """
+        return pulumi.get(self, "icon_name")
+
+    @property
+    @pulumi.getter(name="customData")
+    def custom_data(self) -> Optional[builtins.str]:
+        """
+        Custom data. Base64-encoded SVG data. If set, this overrides the built-in icon.
+        """
+        return pulumi.get(self, "custom_data")
+
+
 @pulumi.output_type
 class IdentityResponse(dict):
     """
@@ -4420,66 +5434,347 @@ class IncidentServiceConnectionResponse(dict):
 
 
 @pulumi.output_type
-class ItsmReceiverResponse(dict):
+class InvestigationExecutionResponse(dict):
     """
-    An Itsm receiver.
+    Details about the execution of the investigation
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "connectionId":
-            suggest = "connection_id"
-        elif key == "ticketConfiguration":
-            suggest = "ticket_configuration"
-        elif key == "workspaceId":
-            suggest = "workspace_id"
+        if key == "runState":
+            suggest = "run_state"
+        elif key == "completedAt":
+            suggest = "completed_at"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ItsmReceiverResponse. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in InvestigationExecutionResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        ItsmReceiverResponse.__key_warning(key)
+        InvestigationExecutionResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        ItsmReceiverResponse.__key_warning(key)
+        InvestigationExecutionResponse.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 connection_id: builtins.str,
-                 name: builtins.str,
-                 region: builtins.str,
-                 ticket_configuration: builtins.str,
-                 workspace_id: builtins.str):
+                 run_state: builtins.str,
+                 completed_at: Optional[builtins.str] = None):
         """
-        An Itsm receiver.
-        :param builtins.str connection_id: Unique identification of ITSM connection among multiple defined in above workspace.
-        :param builtins.str name: The name of the Itsm receiver. Names must be unique across all receivers within an action group.
-        :param builtins.str region: Region in which workspace resides. Supported values:'centralindia','japaneast','southeastasia','australiasoutheast','uksouth','westcentralus','canadacentral','eastus','westeurope'
-        :param builtins.str ticket_configuration: JSON blob for the configurations of the ITSM action. CreateMultipleWorkItems option will be part of this blob as well.
-        :param builtins.str workspace_id: OMS LA instance identifier.
+        Details about the execution of the investigation
+        :param builtins.str run_state: The state of the investigation execution
+        :param builtins.str completed_at: The time at which the investigation execution completed (in UTC)
         """
-        pulumi.set(__self__, "connection_id", connection_id)
-        pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "region", region)
-        pulumi.set(__self__, "ticket_configuration", ticket_configuration)
-        pulumi.set(__self__, "workspace_id", workspace_id)
+        pulumi.set(__self__, "run_state", run_state)
+        if completed_at is not None:
+            pulumi.set(__self__, "completed_at", completed_at)
 
     @property
-    @pulumi.getter(name="connectionId")
-    def connection_id(self) -> builtins.str:
+    @pulumi.getter(name="runState")
+    def run_state(self) -> builtins.str:
         """
-        Unique identification of ITSM connection among multiple defined in above workspace.
+        The state of the investigation execution
         """
-        return pulumi.get(self, "connection_id")
+        return pulumi.get(self, "run_state")
 
     @property
-    @pulumi.getter
-    def name(self) -> builtins.str:
+    @pulumi.getter(name="completedAt")
+    def completed_at(self) -> Optional[builtins.str]:
         """
-        The name of the Itsm receiver. Names must be unique across all receivers within an action group.
+        The time at which the investigation execution completed (in UTC)
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "completed_at")
+
+
+@pulumi.output_type
+class InvestigationMetadataResponse(dict):
+    """
+    Properties of the current investigation
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "createdAt":
+            suggest = "created_at"
+        elif key == "runParameters":
+            suggest = "run_parameters"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InvestigationMetadataResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InvestigationMetadataResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InvestigationMetadataResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 created_at: builtins.str,
+                 execution: 'outputs.InvestigationExecutionResponse',
+                 id: builtins.str,
+                 run_parameters: 'outputs.RunParametersResponse'):
+        """
+        Properties of the current investigation
+        :param builtins.str created_at: The creation time of the investigation (in UTC)
+        :param 'InvestigationExecutionResponse' execution: The execution details of the investigation
+        :param builtins.str id: The unique identifier of the investigation
+        :param 'RunParametersResponse' run_parameters: The parameters that were used to start the investigation
+        """
+        pulumi.set(__self__, "created_at", created_at)
+        pulumi.set(__self__, "execution", execution)
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "run_parameters", run_parameters)
+
+    @property
+    @pulumi.getter(name="createdAt")
+    def created_at(self) -> builtins.str:
+        """
+        The creation time of the investigation (in UTC)
+        """
+        return pulumi.get(self, "created_at")
+
+    @property
+    @pulumi.getter
+    def execution(self) -> 'outputs.InvestigationExecutionResponse':
+        """
+        The execution details of the investigation
+        """
+        return pulumi.get(self, "execution")
+
+    @property
+    @pulumi.getter
+    def id(self) -> builtins.str:
+        """
+        The unique identifier of the investigation
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="runParameters")
+    def run_parameters(self) -> 'outputs.RunParametersResponse':
+        """
+        The parameters that were used to start the investigation
+        """
+        return pulumi.get(self, "run_parameters")
+
+
+@pulumi.output_type
+class InvestigationScopeResponse(dict):
+    """
+    A single scope of the investigation
+    """
+    def __init__(__self__, *,
+                 id: builtins.str,
+                 origin: 'outputs.OriginResponse',
+                 relevance: Optional[builtins.str] = None):
+        """
+        A single scope of the investigation
+        :param builtins.str id: The ID of the scope of the investigation - either an Azure alert ID or an Azure resource ID
+        :param 'OriginResponse' origin: The origin of the scope
+        :param builtins.str relevance: The relevance of the scope
+        """
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "origin", origin)
+        if relevance is not None:
+            pulumi.set(__self__, "relevance", relevance)
+
+    @property
+    @pulumi.getter
+    def id(self) -> builtins.str:
+        """
+        The ID of the scope of the investigation - either an Azure alert ID or an Azure resource ID
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def origin(self) -> 'outputs.OriginResponse':
+        """
+        The origin of the scope
+        """
+        return pulumi.get(self, "origin")
+
+    @property
+    @pulumi.getter
+    def relevance(self) -> Optional[builtins.str]:
+        """
+        The relevance of the scope
+        """
+        return pulumi.get(self, "relevance")
+
+
+@pulumi.output_type
+class IssuePropertiesResponse(dict):
+    """
+    The issue properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "impactTime":
+            suggest = "impact_time"
+        elif key == "investigationsCount":
+            suggest = "investigations_count"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in IssuePropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        IssuePropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        IssuePropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 impact_time: builtins.str,
+                 investigations: Sequence['outputs.InvestigationMetadataResponse'],
+                 investigations_count: builtins.int,
+                 provisioning_state: builtins.str,
+                 severity: builtins.str,
+                 status: builtins.str,
+                 title: builtins.str):
+        """
+        The issue properties
+        :param builtins.str impact_time: The issue impact time (in UTC)
+        :param Sequence['InvestigationMetadataResponse'] investigations: The list of investigations in the issue
+        :param builtins.int investigations_count: The number of investigations in the issue
+        :param builtins.str provisioning_state: The provisioning state of the resource.
+        :param builtins.str severity: The issue severity
+        :param builtins.str status: The issue status
+        :param builtins.str title: The issue title
+        """
+        pulumi.set(__self__, "impact_time", impact_time)
+        pulumi.set(__self__, "investigations", investigations)
+        pulumi.set(__self__, "investigations_count", investigations_count)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "severity", severity)
+        pulumi.set(__self__, "status", status)
+        pulumi.set(__self__, "title", title)
+
+    @property
+    @pulumi.getter(name="impactTime")
+    def impact_time(self) -> builtins.str:
+        """
+        The issue impact time (in UTC)
+        """
+        return pulumi.get(self, "impact_time")
+
+    @property
+    @pulumi.getter
+    def investigations(self) -> Sequence['outputs.InvestigationMetadataResponse']:
+        """
+        The list of investigations in the issue
+        """
+        return pulumi.get(self, "investigations")
+
+    @property
+    @pulumi.getter(name="investigationsCount")
+    def investigations_count(self) -> builtins.int:
+        """
+        The number of investigations in the issue
+        """
+        return pulumi.get(self, "investigations_count")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        The provisioning state of the resource.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter
+    def severity(self) -> builtins.str:
+        """
+        The issue severity
+        """
+        return pulumi.get(self, "severity")
+
+    @property
+    @pulumi.getter
+    def status(self) -> builtins.str:
+        """
+        The issue status
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter
+    def title(self) -> builtins.str:
+        """
+        The issue title
+        """
+        return pulumi.get(self, "title")
+
+
+@pulumi.output_type
+class ItsmReceiverResponse(dict):
+    """
+    An Itsm receiver.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "connectionId":
+            suggest = "connection_id"
+        elif key == "ticketConfiguration":
+            suggest = "ticket_configuration"
+        elif key == "workspaceId":
+            suggest = "workspace_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ItsmReceiverResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ItsmReceiverResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ItsmReceiverResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 connection_id: builtins.str,
+                 name: builtins.str,
+                 region: builtins.str,
+                 ticket_configuration: builtins.str,
+                 workspace_id: builtins.str):
+        """
+        An Itsm receiver.
+        :param builtins.str connection_id: Unique identification of ITSM connection among multiple defined in above workspace.
+        :param builtins.str name: The name of the Itsm receiver. Names must be unique across all receivers within an action group.
+        :param builtins.str region: Region in which workspace resides. Supported values:'centralindia','japaneast','southeastasia','australiasoutheast','uksouth','westcentralus','canadacentral','eastus','westeurope'
+        :param builtins.str ticket_configuration: JSON blob for the configurations of the ITSM action. CreateMultipleWorkItems option will be part of this blob as well.
+        :param builtins.str workspace_id: OMS LA instance identifier.
+        """
+        pulumi.set(__self__, "connection_id", connection_id)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "region", region)
+        pulumi.set(__self__, "ticket_configuration", ticket_configuration)
+        pulumi.set(__self__, "workspace_id", workspace_id)
+
+    @property
+    @pulumi.getter(name="connectionId")
+    def connection_id(self) -> builtins.str:
+        """
+        Unique identification of ITSM connection among multiple defined in above workspace.
+        """
+        return pulumi.get(self, "connection_id")
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        """
+        The name of the Itsm receiver. Names must be unique across all receivers within an action group.
+        """
+        return pulumi.get(self, "name")
 
     @property
     @pulumi.getter
@@ -4781,65 +6076,308 @@ class LogAnalyticsDestinationResponse(dict):
 
 
 @pulumi.output_type
-class LogFileSettingsResponseText(dict):
+class LogAnalyticsQuerySignalDefinitionPropertiesResponse(dict):
     """
-    Text settings
+    Log Analytics Query Signal Definition properties
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "recordStartTimestampFormat":
-            suggest = "record_start_timestamp_format"
+        if key == "deletionDate":
+            suggest = "deletion_date"
+        elif key == "evaluationRules":
+            suggest = "evaluation_rules"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "queryText":
+            suggest = "query_text"
+        elif key == "signalKind":
+            suggest = "signal_kind"
+        elif key == "dataUnit":
+            suggest = "data_unit"
+        elif key == "displayName":
+            suggest = "display_name"
+        elif key == "refreshInterval":
+            suggest = "refresh_interval"
+        elif key == "timeGrain":
+            suggest = "time_grain"
+        elif key == "valueColumnName":
+            suggest = "value_column_name"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in LogFileSettingsResponseText. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in LogAnalyticsQuerySignalDefinitionPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        LogFileSettingsResponseText.__key_warning(key)
+        LogAnalyticsQuerySignalDefinitionPropertiesResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        LogFileSettingsResponseText.__key_warning(key)
+        LogAnalyticsQuerySignalDefinitionPropertiesResponse.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 record_start_timestamp_format: builtins.str):
+                 deletion_date: builtins.str,
+                 evaluation_rules: 'outputs.EvaluationRuleResponse',
+                 provisioning_state: builtins.str,
+                 query_text: builtins.str,
+                 signal_kind: builtins.str,
+                 data_unit: Optional[builtins.str] = None,
+                 display_name: Optional[builtins.str] = None,
+                 refresh_interval: Optional[builtins.str] = None,
+                 tags: Optional[Mapping[str, builtins.str]] = None,
+                 time_grain: Optional[builtins.str] = None,
+                 value_column_name: Optional[builtins.str] = None):
+        """
+        Log Analytics Query Signal Definition properties
+        :param builtins.str deletion_date: Date when the signal definition was (soft-)deleted
+        :param 'EvaluationRuleResponse' evaluation_rules: Evaluation rules for the signal definition
+        :param builtins.str provisioning_state: The status of the last operation.
+        :param builtins.str query_text: Query text in KQL syntax
+        :param builtins.str signal_kind: Supported signal kinds as discriminator
+               Expected value is 'LogAnalyticsQuery'.
+        :param builtins.str data_unit: Unit of the signal result (e.g. Bytes, MilliSeconds, Percent, Count))
+        :param builtins.str display_name: Display name
+        :param builtins.str refresh_interval: Interval in which the signal is being evaluated. Defaults to PT1M (1 minute).
+        :param Mapping[str, builtins.str] tags: Optional set of labels (key-value pairs)
+        :param builtins.str time_grain: Time range of signal. ISO duration format like PT10M. If not specified, the KQL query must define a time range.
+        :param builtins.str value_column_name: Name of the column in the result set to evaluate against the thresholds. Defaults to the first column in the result set if not specified. The column must be numeric.
+        """
+        pulumi.set(__self__, "deletion_date", deletion_date)
+        pulumi.set(__self__, "evaluation_rules", evaluation_rules)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "query_text", query_text)
+        pulumi.set(__self__, "signal_kind", 'LogAnalyticsQuery')
+        if data_unit is not None:
+            pulumi.set(__self__, "data_unit", data_unit)
+        if display_name is not None:
+            pulumi.set(__self__, "display_name", display_name)
+        if refresh_interval is None:
+            refresh_interval = 'PT1M'
+        if refresh_interval is not None:
+            pulumi.set(__self__, "refresh_interval", refresh_interval)
+        if tags is not None:
+            pulumi.set(__self__, "tags", tags)
+        if time_grain is not None:
+            pulumi.set(__self__, "time_grain", time_grain)
+        if value_column_name is not None:
+            pulumi.set(__self__, "value_column_name", value_column_name)
+
+    @property
+    @pulumi.getter(name="deletionDate")
+    def deletion_date(self) -> builtins.str:
         """
-        Text settings
-        :param builtins.str record_start_timestamp_format: One of the supported timestamp formats
+        Date when the signal definition was (soft-)deleted
         """
-        pulumi.set(__self__, "record_start_timestamp_format", record_start_timestamp_format)
+        return pulumi.get(self, "deletion_date")
 
     @property
-    @pulumi.getter(name="recordStartTimestampFormat")
-    def record_start_timestamp_format(self) -> builtins.str:
+    @pulumi.getter(name="evaluationRules")
+    def evaluation_rules(self) -> 'outputs.EvaluationRuleResponse':
         """
-        One of the supported timestamp formats
+        Evaluation rules for the signal definition
         """
-        return pulumi.get(self, "record_start_timestamp_format")
+        return pulumi.get(self, "evaluation_rules")
 
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        The status of the last operation.
+        """
+        return pulumi.get(self, "provisioning_state")
 
-@pulumi.output_type
-class LogFilesDataSourceResponse(dict):
-    """
-    Definition of which custom log files will be collected by this data collection rule
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "filePatterns":
-            suggest = "file_patterns"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in LogFilesDataSourceResponse. Access the value via the '{suggest}' property getter instead.")
+    @property
+    @pulumi.getter(name="queryText")
+    def query_text(self) -> builtins.str:
+        """
+        Query text in KQL syntax
+        """
+        return pulumi.get(self, "query_text")
 
-    def __getitem__(self, key: str) -> Any:
-        LogFilesDataSourceResponse.__key_warning(key)
-        return super().__getitem__(key)
+    @property
+    @pulumi.getter(name="signalKind")
+    def signal_kind(self) -> builtins.str:
+        """
+        Supported signal kinds as discriminator
+        Expected value is 'LogAnalyticsQuery'.
+        """
+        return pulumi.get(self, "signal_kind")
 
-    def get(self, key: str, default = None) -> Any:
-        LogFilesDataSourceResponse.__key_warning(key)
-        return super().get(key, default)
+    @property
+    @pulumi.getter(name="dataUnit")
+    def data_unit(self) -> Optional[builtins.str]:
+        """
+        Unit of the signal result (e.g. Bytes, MilliSeconds, Percent, Count))
+        """
+        return pulumi.get(self, "data_unit")
+
+    @property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> Optional[builtins.str]:
+        """
+        Display name
+        """
+        return pulumi.get(self, "display_name")
+
+    @property
+    @pulumi.getter(name="refreshInterval")
+    def refresh_interval(self) -> Optional[builtins.str]:
+        """
+        Interval in which the signal is being evaluated. Defaults to PT1M (1 minute).
+        """
+        return pulumi.get(self, "refresh_interval")
+
+    @property
+    @pulumi.getter
+    def tags(self) -> Optional[Mapping[str, builtins.str]]:
+        """
+        Optional set of labels (key-value pairs)
+        """
+        return pulumi.get(self, "tags")
+
+    @property
+    @pulumi.getter(name="timeGrain")
+    def time_grain(self) -> Optional[builtins.str]:
+        """
+        Time range of signal. ISO duration format like PT10M. If not specified, the KQL query must define a time range.
+        """
+        return pulumi.get(self, "time_grain")
+
+    @property
+    @pulumi.getter(name="valueColumnName")
+    def value_column_name(self) -> Optional[builtins.str]:
+        """
+        Name of the column in the result set to evaluate against the thresholds. Defaults to the first column in the result set if not specified. The column must be numeric.
+        """
+        return pulumi.get(self, "value_column_name")
+
+
+@pulumi.output_type
+class LogAnalyticsSignalGroupResponse(dict):
+    """
+    A grouping of signal assignments for a Log Analytics Workspace
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "authenticationSetting":
+            suggest = "authentication_setting"
+        elif key == "logAnalyticsWorkspaceResourceId":
+            suggest = "log_analytics_workspace_resource_id"
+        elif key == "signalAssignments":
+            suggest = "signal_assignments"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in LogAnalyticsSignalGroupResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        LogAnalyticsSignalGroupResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        LogAnalyticsSignalGroupResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 authentication_setting: builtins.str,
+                 log_analytics_workspace_resource_id: builtins.str,
+                 signal_assignments: Optional[Sequence['outputs.SignalAssignmentResponse']] = None):
+        """
+        A grouping of signal assignments for a Log Analytics Workspace
+        :param builtins.str authentication_setting: Reference to the name of the authentication setting which is used for querying the data source
+        :param builtins.str log_analytics_workspace_resource_id: Log Analytics Workspace resource ID
+        :param Sequence['SignalAssignmentResponse'] signal_assignments: Signal definitions which are assigned to this signal group. All assignments are combined with an OR operator.
+        """
+        pulumi.set(__self__, "authentication_setting", authentication_setting)
+        pulumi.set(__self__, "log_analytics_workspace_resource_id", log_analytics_workspace_resource_id)
+        if signal_assignments is not None:
+            pulumi.set(__self__, "signal_assignments", signal_assignments)
+
+    @property
+    @pulumi.getter(name="authenticationSetting")
+    def authentication_setting(self) -> builtins.str:
+        """
+        Reference to the name of the authentication setting which is used for querying the data source
+        """
+        return pulumi.get(self, "authentication_setting")
+
+    @property
+    @pulumi.getter(name="logAnalyticsWorkspaceResourceId")
+    def log_analytics_workspace_resource_id(self) -> builtins.str:
+        """
+        Log Analytics Workspace resource ID
+        """
+        return pulumi.get(self, "log_analytics_workspace_resource_id")
+
+    @property
+    @pulumi.getter(name="signalAssignments")
+    def signal_assignments(self) -> Optional[Sequence['outputs.SignalAssignmentResponse']]:
+        """
+        Signal definitions which are assigned to this signal group. All assignments are combined with an OR operator.
+        """
+        return pulumi.get(self, "signal_assignments")
+
+
+@pulumi.output_type
+class LogFileSettingsResponseText(dict):
+    """
+    Text settings
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "recordStartTimestampFormat":
+            suggest = "record_start_timestamp_format"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in LogFileSettingsResponseText. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        LogFileSettingsResponseText.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        LogFileSettingsResponseText.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 record_start_timestamp_format: builtins.str):
+        """
+        Text settings
+        :param builtins.str record_start_timestamp_format: One of the supported timestamp formats
+        """
+        pulumi.set(__self__, "record_start_timestamp_format", record_start_timestamp_format)
+
+    @property
+    @pulumi.getter(name="recordStartTimestampFormat")
+    def record_start_timestamp_format(self) -> builtins.str:
+        """
+        One of the supported timestamp formats
+        """
+        return pulumi.get(self, "record_start_timestamp_format")
+
+
+@pulumi.output_type
+class LogFilesDataSourceResponse(dict):
+    """
+    Definition of which custom log files will be collected by this data collection rule
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "filePatterns":
+            suggest = "file_patterns"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in LogFilesDataSourceResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        LogFilesDataSourceResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        LogFilesDataSourceResponse.__key_warning(key)
+        return super().get(key, default)
 
     def __init__(__self__, *,
                  file_patterns: Sequence[builtins.str],
@@ -5101,6 +6639,87 @@ class LogicAppReceiverResponse(dict):
         return pulumi.get(self, "use_common_alert_schema")
 
 
+@pulumi.output_type
+class ManagedIdentityAuthenticationSettingPropertiesResponse(dict):
+    """
+    Authentication setting properties for Azure Managed Identity
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "authenticationKind":
+            suggest = "authentication_kind"
+        elif key == "managedIdentityName":
+            suggest = "managed_identity_name"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "displayName":
+            suggest = "display_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ManagedIdentityAuthenticationSettingPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ManagedIdentityAuthenticationSettingPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ManagedIdentityAuthenticationSettingPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 authentication_kind: builtins.str,
+                 managed_identity_name: builtins.str,
+                 provisioning_state: builtins.str,
+                 display_name: Optional[builtins.str] = None):
+        """
+        Authentication setting properties for Azure Managed Identity
+        :param builtins.str authentication_kind: Supported kinds of authentication settings as discriminator
+               Expected value is 'ManagedIdentity'.
+        :param builtins.str managed_identity_name: Name of the managed identity to use. Either 'SystemAssigned' or the resourceId of a user-assigned identity.
+        :param builtins.str provisioning_state: The status of the last operation.
+        :param builtins.str display_name: Display name
+        """
+        pulumi.set(__self__, "authentication_kind", 'ManagedIdentity')
+        pulumi.set(__self__, "managed_identity_name", managed_identity_name)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        if display_name is not None:
+            pulumi.set(__self__, "display_name", display_name)
+
+    @property
+    @pulumi.getter(name="authenticationKind")
+    def authentication_kind(self) -> builtins.str:
+        """
+        Supported kinds of authentication settings as discriminator
+        Expected value is 'ManagedIdentity'.
+        """
+        return pulumi.get(self, "authentication_kind")
+
+    @property
+    @pulumi.getter(name="managedIdentityName")
+    def managed_identity_name(self) -> builtins.str:
+        """
+        Name of the managed identity to use. Either 'SystemAssigned' or the resourceId of a user-assigned identity.
+        """
+        return pulumi.get(self, "managed_identity_name")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        The status of the last operation.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> Optional[builtins.str]:
+        """
+        Display name
+        """
+        return pulumi.get(self, "display_name")
+
+
 @pulumi.output_type
 class ManagedServiceIdentityResponse(dict):
     """
@@ -5844,6 +7463,68 @@ class MetricTriggerResponse(dict):
         return pulumi.get(self, "metric_resource_location")
 
 
+@pulumi.output_type
+class ModelDiscoverySettingsResponse(dict):
+    """
+    Settings for automatically discovering entities for the health model.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "addRecommendedSignals":
+            suggest = "add_recommended_signals"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ModelDiscoverySettingsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ModelDiscoverySettingsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ModelDiscoverySettingsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 add_recommended_signals: builtins.str,
+                 scope: builtins.str,
+                 identity: Optional[builtins.str] = None):
+        """
+        Settings for automatically discovering entities for the health model.
+        :param builtins.str add_recommended_signals: Whether to add all recommended signals to the discovered entities.
+        :param builtins.str scope: The scope from which entities should be automatically discovered. For example, the resource id of a Service Group.
+        :param builtins.str identity: Which Managed Identity of the health model to use for discovery. Defaults to SystemAssigned, if not set. Can be set to 'SystemAssigned' or to the resource id of a user-assigned managed identity which is linked to the health model.
+        """
+        pulumi.set(__self__, "add_recommended_signals", add_recommended_signals)
+        pulumi.set(__self__, "scope", scope)
+        if identity is not None:
+            pulumi.set(__self__, "identity", identity)
+
+    @property
+    @pulumi.getter(name="addRecommendedSignals")
+    def add_recommended_signals(self) -> builtins.str:
+        """
+        Whether to add all recommended signals to the discovered entities.
+        """
+        return pulumi.get(self, "add_recommended_signals")
+
+    @property
+    @pulumi.getter
+    def scope(self) -> builtins.str:
+        """
+        The scope from which entities should be automatically discovered. For example, the resource id of a Service Group.
+        """
+        return pulumi.get(self, "scope")
+
+    @property
+    @pulumi.getter
+    def identity(self) -> Optional[builtins.str]:
+        """
+        Which Managed Identity of the health model to use for discovery. Defaults to SystemAssigned, if not set. Can be set to 'SystemAssigned' or to the resource id of a user-assigned managed identity which is linked to the health model.
+        """
+        return pulumi.get(self, "identity")
+
+
 @pulumi.output_type
 class MonitoringAccountDestinationResponse(dict):
     """
@@ -6031,6 +7712,58 @@ class NetworkingRouteResponse(dict):
         return pulumi.get(self, "subdomain")
 
 
+@pulumi.output_type
+class OriginResponse(dict):
+    """
+    Details about the origin of the entity - the source that added it to the issue
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "addedBy":
+            suggest = "added_by"
+        elif key == "addedByType":
+            suggest = "added_by_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in OriginResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        OriginResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        OriginResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 added_by: builtins.str,
+                 added_by_type: builtins.str):
+        """
+        Details about the origin of the entity - the source that added it to the issue
+        :param builtins.str added_by: The ID of the origin - for example, in case of 'Manual', the user ID/app ID, and in case of 'Automatic', the name of the automatic system
+        :param builtins.str added_by_type: The source of the origin - Manual or Automatic
+        """
+        pulumi.set(__self__, "added_by", added_by)
+        pulumi.set(__self__, "added_by_type", added_by_type)
+
+    @property
+    @pulumi.getter(name="addedBy")
+    def added_by(self) -> builtins.str:
+        """
+        The ID of the origin - for example, in case of 'Manual', the user ID/app ID, and in case of 'Automatic', the name of the automatic system
+        """
+        return pulumi.get(self, "added_by")
+
+    @property
+    @pulumi.getter(name="addedByType")
+    def added_by_type(self) -> builtins.str:
+        """
+        The source of the origin - Manual or Automatic
+        """
+        return pulumi.get(self, "added_by_type")
+
+
 @pulumi.output_type
 class OtlpReceiverResponse(dict):
     """
@@ -6823,6 +8556,169 @@ class PrometheusForwarderDataSourceResponse(dict):
         return pulumi.get(self, "streams")
 
 
+@pulumi.output_type
+class PrometheusMetricsSignalDefinitionPropertiesResponse(dict):
+    """
+    Prometheus Metrics Signal Definition properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "deletionDate":
+            suggest = "deletion_date"
+        elif key == "evaluationRules":
+            suggest = "evaluation_rules"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "queryText":
+            suggest = "query_text"
+        elif key == "signalKind":
+            suggest = "signal_kind"
+        elif key == "dataUnit":
+            suggest = "data_unit"
+        elif key == "displayName":
+            suggest = "display_name"
+        elif key == "refreshInterval":
+            suggest = "refresh_interval"
+        elif key == "timeGrain":
+            suggest = "time_grain"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PrometheusMetricsSignalDefinitionPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PrometheusMetricsSignalDefinitionPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PrometheusMetricsSignalDefinitionPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 deletion_date: builtins.str,
+                 evaluation_rules: 'outputs.EvaluationRuleResponse',
+                 provisioning_state: builtins.str,
+                 query_text: builtins.str,
+                 signal_kind: builtins.str,
+                 data_unit: Optional[builtins.str] = None,
+                 display_name: Optional[builtins.str] = None,
+                 refresh_interval: Optional[builtins.str] = None,
+                 tags: Optional[Mapping[str, builtins.str]] = None,
+                 time_grain: Optional[builtins.str] = None):
+        """
+        Prometheus Metrics Signal Definition properties
+        :param builtins.str deletion_date: Date when the signal definition was (soft-)deleted
+        :param 'EvaluationRuleResponse' evaluation_rules: Evaluation rules for the signal definition
+        :param builtins.str provisioning_state: The status of the last operation.
+        :param builtins.str query_text: Query text in PromQL syntax
+        :param builtins.str signal_kind: Supported signal kinds as discriminator
+               Expected value is 'PrometheusMetricsQuery'.
+        :param builtins.str data_unit: Unit of the signal result (e.g. Bytes, MilliSeconds, Percent, Count))
+        :param builtins.str display_name: Display name
+        :param builtins.str refresh_interval: Interval in which the signal is being evaluated. Defaults to PT1M (1 minute).
+        :param Mapping[str, builtins.str] tags: Optional set of labels (key-value pairs)
+        :param builtins.str time_grain: Time range of signal. ISO duration format like PT10M.
+        """
+        pulumi.set(__self__, "deletion_date", deletion_date)
+        pulumi.set(__self__, "evaluation_rules", evaluation_rules)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "query_text", query_text)
+        pulumi.set(__self__, "signal_kind", 'PrometheusMetricsQuery')
+        if data_unit is not None:
+            pulumi.set(__self__, "data_unit", data_unit)
+        if display_name is not None:
+            pulumi.set(__self__, "display_name", display_name)
+        if refresh_interval is None:
+            refresh_interval = 'PT1M'
+        if refresh_interval is not None:
+            pulumi.set(__self__, "refresh_interval", refresh_interval)
+        if tags is not None:
+            pulumi.set(__self__, "tags", tags)
+        if time_grain is not None:
+            pulumi.set(__self__, "time_grain", time_grain)
+
+    @property
+    @pulumi.getter(name="deletionDate")
+    def deletion_date(self) -> builtins.str:
+        """
+        Date when the signal definition was (soft-)deleted
+        """
+        return pulumi.get(self, "deletion_date")
+
+    @property
+    @pulumi.getter(name="evaluationRules")
+    def evaluation_rules(self) -> 'outputs.EvaluationRuleResponse':
+        """
+        Evaluation rules for the signal definition
+        """
+        return pulumi.get(self, "evaluation_rules")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        The status of the last operation.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="queryText")
+    def query_text(self) -> builtins.str:
+        """
+        Query text in PromQL syntax
+        """
+        return pulumi.get(self, "query_text")
+
+    @property
+    @pulumi.getter(name="signalKind")
+    def signal_kind(self) -> builtins.str:
+        """
+        Supported signal kinds as discriminator
+        Expected value is 'PrometheusMetricsQuery'.
+        """
+        return pulumi.get(self, "signal_kind")
+
+    @property
+    @pulumi.getter(name="dataUnit")
+    def data_unit(self) -> Optional[builtins.str]:
+        """
+        Unit of the signal result (e.g. Bytes, MilliSeconds, Percent, Count))
+        """
+        return pulumi.get(self, "data_unit")
+
+    @property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> Optional[builtins.str]:
+        """
+        Display name
+        """
+        return pulumi.get(self, "display_name")
+
+    @property
+    @pulumi.getter(name="refreshInterval")
+    def refresh_interval(self) -> Optional[builtins.str]:
+        """
+        Interval in which the signal is being evaluated. Defaults to PT1M (1 minute).
+        """
+        return pulumi.get(self, "refresh_interval")
+
+    @property
+    @pulumi.getter
+    def tags(self) -> Optional[Mapping[str, builtins.str]]:
+        """
+        Optional set of labels (key-value pairs)
+        """
+        return pulumi.get(self, "tags")
+
+    @property
+    @pulumi.getter(name="timeGrain")
+    def time_grain(self) -> Optional[builtins.str]:
+        """
+        Time range of signal. ISO duration format like PT10M.
+        """
+        return pulumi.get(self, "time_grain")
+
+
 @pulumi.output_type
 class ReceiverResponse(dict):
     """
@@ -6997,54 +8893,460 @@ class RecurrentScheduleResponse(dict):
         RecurrentScheduleResponse.__key_warning(key)
         return super().get(key, default)
 
-    def __init__(__self__, *,
-                 days: Sequence[builtins.str],
-                 hours: Sequence[builtins.int],
-                 minutes: Sequence[builtins.int],
-                 time_zone: builtins.str):
+    def __init__(__self__, *,
+                 days: Sequence[builtins.str],
+                 hours: Sequence[builtins.int],
+                 minutes: Sequence[builtins.int],
+                 time_zone: builtins.str):
+        """
+        The scheduling constraints for when the profile begins.
+        :param Sequence[builtins.str] days: the collection of days that the profile takes effect on. Possible values are Sunday through Saturday.
+        :param Sequence[builtins.int] hours: A collection of hours that the profile takes effect on. Values supported are 0 to 23 on the 24-hour clock (AM/PM times are not supported).
+        :param Sequence[builtins.int] minutes: A collection of minutes at which the profile takes effect at.
+        :param builtins.str time_zone: the timezone for the hours of the profile. Some examples of valid time zones are: Dateline Standard Time, UTC-11, Hawaiian Standard Time, Alaskan Standard Time, Pacific Standard Time (Mexico), Pacific Standard Time, US Mountain Standard Time, Mountain Standard Time (Mexico), Mountain Standard Time, Central America Standard Time, Central Standard Time, Central Standard Time (Mexico), Canada Central Standard Time, SA Pacific Standard Time, Eastern Standard Time, US Eastern Standard Time, Venezuela Standard Time, Paraguay Standard Time, Atlantic Standard Time, Central Brazilian Standard Time, SA Western Standard Time, Pacific SA Standard Time, Newfoundland Standard Time, E. South America Standard Time, Argentina Standard Time, SA Eastern Standard Time, Greenland Standard Time, Montevideo Standard Time, Bahia Standard Time, UTC-02, Mid-Atlantic Standard Time, Azores Standard Time, Cape Verde Standard Time, Morocco Standard Time, UTC, GMT Standard Time, Greenwich Standard Time, W. Europe Standard Time, Central Europe Standard Time, Romance Standard Time, Central European Standard Time, W. Central Africa Standard Time, Namibia Standard Time, Jordan Standard Time, GTB Standard Time, Middle East Standard Time, Egypt Standard Time, Syria Standard Time, E. Europe Standard Time, South Africa Standard Time, FLE Standard Time, Turkey Standard Time, Israel Standard Time, Kaliningrad Standard Time, Libya Standard Time, Arabic Standard Time, Arab Standard Time, Belarus Standard Time, Russian Standard Time, E. Africa Standard Time, Iran Standard Time, Arabian Standard Time, Azerbaijan Standard Time, Russia Time Zone 3, Mauritius Standard Time, Georgian Standard Time, Caucasus Standard Time, Afghanistan Standard Time, West Asia Standard Time, Ekaterinburg Standard Time, Pakistan Standard Time, India Standard Time, Sri Lanka Standard Time, Nepal Standard Time, Central Asia Standard Time, Bangladesh Standard Time, N. Central Asia Standard Time, Myanmar Standard Time, SE Asia Standard Time, North Asia Standard Time, China Standard Time, North Asia East Standard Time, Singapore Standard Time, W. Australia Standard Time, Taipei Standard Time, Ulaanbaatar Standard Time, Tokyo Standard Time, Korea Standard Time, Yakutsk Standard Time, Cen. Australia Standard Time, AUS Central Standard Time, E. Australia Standard Time, AUS Eastern Standard Time, West Pacific Standard Time, Tasmania Standard Time, Magadan Standard Time, Vladivostok Standard Time, Russia Time Zone 10, Central Pacific Standard Time, Russia Time Zone 11, New Zealand Standard Time, UTC+12, Fiji Standard Time, Kamchatka Standard Time, Tonga Standard Time, Samoa Standard Time, Line Islands Standard Time
+        """
+        pulumi.set(__self__, "days", days)
+        pulumi.set(__self__, "hours", hours)
+        pulumi.set(__self__, "minutes", minutes)
+        pulumi.set(__self__, "time_zone", time_zone)
+
+    @property
+    @pulumi.getter
+    def days(self) -> Sequence[builtins.str]:
+        """
+        the collection of days that the profile takes effect on. Possible values are Sunday through Saturday.
+        """
+        return pulumi.get(self, "days")
+
+    @property
+    @pulumi.getter
+    def hours(self) -> Sequence[builtins.int]:
+        """
+        A collection of hours that the profile takes effect on. Values supported are 0 to 23 on the 24-hour clock (AM/PM times are not supported).
+        """
+        return pulumi.get(self, "hours")
+
+    @property
+    @pulumi.getter
+    def minutes(self) -> Sequence[builtins.int]:
+        """
+        A collection of minutes at which the profile takes effect at.
+        """
+        return pulumi.get(self, "minutes")
+
+    @property
+    @pulumi.getter(name="timeZone")
+    def time_zone(self) -> builtins.str:
+        """
+        the timezone for the hours of the profile. Some examples of valid time zones are: Dateline Standard Time, UTC-11, Hawaiian Standard Time, Alaskan Standard Time, Pacific Standard Time (Mexico), Pacific Standard Time, US Mountain Standard Time, Mountain Standard Time (Mexico), Mountain Standard Time, Central America Standard Time, Central Standard Time, Central Standard Time (Mexico), Canada Central Standard Time, SA Pacific Standard Time, Eastern Standard Time, US Eastern Standard Time, Venezuela Standard Time, Paraguay Standard Time, Atlantic Standard Time, Central Brazilian Standard Time, SA Western Standard Time, Pacific SA Standard Time, Newfoundland Standard Time, E. South America Standard Time, Argentina Standard Time, SA Eastern Standard Time, Greenland Standard Time, Montevideo Standard Time, Bahia Standard Time, UTC-02, Mid-Atlantic Standard Time, Azores Standard Time, Cape Verde Standard Time, Morocco Standard Time, UTC, GMT Standard Time, Greenwich Standard Time, W. Europe Standard Time, Central Europe Standard Time, Romance Standard Time, Central European Standard Time, W. Central Africa Standard Time, Namibia Standard Time, Jordan Standard Time, GTB Standard Time, Middle East Standard Time, Egypt Standard Time, Syria Standard Time, E. Europe Standard Time, South Africa Standard Time, FLE Standard Time, Turkey Standard Time, Israel Standard Time, Kaliningrad Standard Time, Libya Standard Time, Arabic Standard Time, Arab Standard Time, Belarus Standard Time, Russian Standard Time, E. Africa Standard Time, Iran Standard Time, Arabian Standard Time, Azerbaijan Standard Time, Russia Time Zone 3, Mauritius Standard Time, Georgian Standard Time, Caucasus Standard Time, Afghanistan Standard Time, West Asia Standard Time, Ekaterinburg Standard Time, Pakistan Standard Time, India Standard Time, Sri Lanka Standard Time, Nepal Standard Time, Central Asia Standard Time, Bangladesh Standard Time, N. Central Asia Standard Time, Myanmar Standard Time, SE Asia Standard Time, North Asia Standard Time, China Standard Time, North Asia East Standard Time, Singapore Standard Time, W. Australia Standard Time, Taipei Standard Time, Ulaanbaatar Standard Time, Tokyo Standard Time, Korea Standard Time, Yakutsk Standard Time, Cen. Australia Standard Time, AUS Central Standard Time, E. Australia Standard Time, AUS Eastern Standard Time, West Pacific Standard Time, Tasmania Standard Time, Magadan Standard Time, Vladivostok Standard Time, Russia Time Zone 10, Central Pacific Standard Time, Russia Time Zone 11, New Zealand Standard Time, UTC+12, Fiji Standard Time, Kamchatka Standard Time, Tonga Standard Time, Samoa Standard Time, Line Islands Standard Time
+        """
+        return pulumi.get(self, "time_zone")
+
+
+@pulumi.output_type
+class RelatedAlertResponse(dict):
+    """
+    Properties of an alert which is related to the issue
+    """
+    def __init__(__self__, *,
+                 added_at: builtins.str,
+                 id: builtins.str,
+                 last_modified_at: builtins.str,
+                 origin: 'outputs.OriginResponse',
+                 relevance: builtins.str):
+        """
+        Properties of an alert which is related to the issue
+        :param builtins.str added_at: The time this relation was added to the issue (in UTC)
+        :param builtins.str id: The alert ID
+        :param builtins.str last_modified_at: The last update time of this relation (in UTC)
+        :param 'OriginResponse' origin: The source that related the alert to the issue
+        :param builtins.str relevance: The alerts's relevance status
+        """
+        pulumi.set(__self__, "added_at", added_at)
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "last_modified_at", last_modified_at)
+        pulumi.set(__self__, "origin", origin)
+        pulumi.set(__self__, "relevance", relevance)
+
+    @property
+    @pulumi.getter(name="addedAt")
+    def added_at(self) -> builtins.str:
+        """
+        The time this relation was added to the issue (in UTC)
+        """
+        return pulumi.get(self, "added_at")
+
+    @property
+    @pulumi.getter
+    def id(self) -> builtins.str:
+        """
+        The alert ID
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="lastModifiedAt")
+    def last_modified_at(self) -> builtins.str:
+        """
+        The last update time of this relation (in UTC)
+        """
+        return pulumi.get(self, "last_modified_at")
+
+    @property
+    @pulumi.getter
+    def origin(self) -> 'outputs.OriginResponse':
+        """
+        The source that related the alert to the issue
+        """
+        return pulumi.get(self, "origin")
+
+    @property
+    @pulumi.getter
+    def relevance(self) -> builtins.str:
+        """
+        The alerts's relevance status
+        """
+        return pulumi.get(self, "relevance")
+
+
+@pulumi.output_type
+class RelatedResourceResponse(dict):
+    """
+    Properties of a resource which is related to the issue
+    """
+    def __init__(__self__, *,
+                 added_at: builtins.str,
+                 id: builtins.str,
+                 last_modified_at: builtins.str,
+                 origin: 'outputs.OriginResponse',
+                 relevance: builtins.str):
+        """
+        Properties of a resource which is related to the issue
+        :param builtins.str added_at: The time this relation was added to the issue (in UTC)
+        :param builtins.str id: The resource ID
+        :param builtins.str last_modified_at: The last update time of this relation (in UTC)
+        :param 'OriginResponse' origin: The source that related the resource to the issue
+        :param builtins.str relevance: The resource's relevance status
+        """
+        pulumi.set(__self__, "added_at", added_at)
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "last_modified_at", last_modified_at)
+        pulumi.set(__self__, "origin", origin)
+        pulumi.set(__self__, "relevance", relevance)
+
+    @property
+    @pulumi.getter(name="addedAt")
+    def added_at(self) -> builtins.str:
+        """
+        The time this relation was added to the issue (in UTC)
+        """
+        return pulumi.get(self, "added_at")
+
+    @property
+    @pulumi.getter
+    def id(self) -> builtins.str:
+        """
+        The resource ID
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="lastModifiedAt")
+    def last_modified_at(self) -> builtins.str:
+        """
+        The last update time of this relation (in UTC)
+        """
+        return pulumi.get(self, "last_modified_at")
+
+    @property
+    @pulumi.getter
+    def origin(self) -> 'outputs.OriginResponse':
+        """
+        The source that related the resource to the issue
+        """
+        return pulumi.get(self, "origin")
+
+    @property
+    @pulumi.getter
+    def relevance(self) -> builtins.str:
+        """
+        The resource's relevance status
+        """
+        return pulumi.get(self, "relevance")
+
+
+@pulumi.output_type
+class RelationshipPropertiesResponse(dict):
+    """
+    Relationship properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "childEntityName":
+            suggest = "child_entity_name"
+        elif key == "deletionDate":
+            suggest = "deletion_date"
+        elif key == "discoveredBy":
+            suggest = "discovered_by"
+        elif key == "parentEntityName":
+            suggest = "parent_entity_name"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "displayName":
+            suggest = "display_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in RelationshipPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        RelationshipPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        RelationshipPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 child_entity_name: builtins.str,
+                 deletion_date: builtins.str,
+                 discovered_by: builtins.str,
+                 parent_entity_name: builtins.str,
+                 provisioning_state: builtins.str,
+                 display_name: Optional[builtins.str] = None,
+                 tags: Optional[Mapping[str, builtins.str]] = None):
+        """
+        Relationship properties
+        :param builtins.str child_entity_name: Resource name of the child entity
+        :param builtins.str deletion_date: Date when the relationship was (soft-)deleted
+        :param builtins.str discovered_by: Discovered by which discovery rule. If set, the relationship cannot be deleted manually.
+        :param builtins.str parent_entity_name: Resource name of the parent entity
+        :param builtins.str provisioning_state: The status of the last operation.
+        :param builtins.str display_name: Display name
+        :param Mapping[str, builtins.str] tags: Optional set of labels (key-value pairs)
+        """
+        pulumi.set(__self__, "child_entity_name", child_entity_name)
+        pulumi.set(__self__, "deletion_date", deletion_date)
+        pulumi.set(__self__, "discovered_by", discovered_by)
+        pulumi.set(__self__, "parent_entity_name", parent_entity_name)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        if display_name is not None:
+            pulumi.set(__self__, "display_name", display_name)
+        if tags is not None:
+            pulumi.set(__self__, "tags", tags)
+
+    @property
+    @pulumi.getter(name="childEntityName")
+    def child_entity_name(self) -> builtins.str:
+        """
+        Resource name of the child entity
+        """
+        return pulumi.get(self, "child_entity_name")
+
+    @property
+    @pulumi.getter(name="deletionDate")
+    def deletion_date(self) -> builtins.str:
+        """
+        Date when the relationship was (soft-)deleted
+        """
+        return pulumi.get(self, "deletion_date")
+
+    @property
+    @pulumi.getter(name="discoveredBy")
+    def discovered_by(self) -> builtins.str:
+        """
+        Discovered by which discovery rule. If set, the relationship cannot be deleted manually.
+        """
+        return pulumi.get(self, "discovered_by")
+
+    @property
+    @pulumi.getter(name="parentEntityName")
+    def parent_entity_name(self) -> builtins.str:
+        """
+        Resource name of the parent entity
+        """
+        return pulumi.get(self, "parent_entity_name")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        The status of the last operation.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> Optional[builtins.str]:
+        """
+        Display name
+        """
+        return pulumi.get(self, "display_name")
+
+    @property
+    @pulumi.getter
+    def tags(self) -> Optional[Mapping[str, builtins.str]]:
+        """
+        Optional set of labels (key-value pairs)
+        """
+        return pulumi.get(self, "tags")
+
+
+@pulumi.output_type
+class ResourceGraphQueryDiscoveryRulePropertiesResponse(dict):
+    """
+    Discovery rule properties for an Azure Resource Graph query
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "addRecommendedSignals":
+            suggest = "add_recommended_signals"
+        elif key == "authenticationSetting":
+            suggest = "authentication_setting"
+        elif key == "deletionDate":
+            suggest = "deletion_date"
+        elif key == "discoverRelationships":
+            suggest = "discover_relationships"
+        elif key == "discoveryRuleKind":
+            suggest = "discovery_rule_kind"
+        elif key == "entityName":
+            suggest = "entity_name"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "resourceGraphQuery":
+            suggest = "resource_graph_query"
+        elif key == "displayName":
+            suggest = "display_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ResourceGraphQueryDiscoveryRulePropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ResourceGraphQueryDiscoveryRulePropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ResourceGraphQueryDiscoveryRulePropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 add_recommended_signals: builtins.str,
+                 authentication_setting: builtins.str,
+                 deletion_date: builtins.str,
+                 discover_relationships: builtins.str,
+                 discovery_rule_kind: builtins.str,
+                 entity_name: builtins.str,
+                 error: 'outputs.DiscoveryErrorResponse',
+                 provisioning_state: builtins.str,
+                 resource_graph_query: builtins.str,
+                 display_name: Optional[builtins.str] = None):
+        """
+        Discovery rule properties for an Azure Resource Graph query
+        :param builtins.str add_recommended_signals: Whether to add all recommended signals to the discovered entities.
+        :param builtins.str authentication_setting: Reference to the name of the authentication setting which is used for querying Azure Resource Graph. The same authentication setting will also be assigned to any discovered entities.
+        :param builtins.str deletion_date: Date when the discovery rule was (soft-)deleted.
+        :param builtins.str discover_relationships: Whether to create relationships between the discovered entities based on a set of built-in rules. These relationships cannot be manually deleted.
+        :param builtins.str discovery_rule_kind: Discovery rule relationship discovery behavior
+               Expected value is 'ResourceGraphQuery'.
+        :param builtins.str entity_name: Name of the entity which represents the discovery rule. Note: It might take a few minutes after creating the discovery rule until the entity is created.
+        :param 'DiscoveryErrorResponse' error: Error details if the last discovery operation failed.
+        :param builtins.str provisioning_state: The status of the last operation.
+        :param builtins.str resource_graph_query: Azure Resource Graph query text in KQL syntax. The query must return at least a column named 'id' which contains the resource ID of the discovered resources.
+        :param builtins.str display_name: Display name
+        """
+        pulumi.set(__self__, "add_recommended_signals", add_recommended_signals)
+        pulumi.set(__self__, "authentication_setting", authentication_setting)
+        pulumi.set(__self__, "deletion_date", deletion_date)
+        pulumi.set(__self__, "discover_relationships", discover_relationships)
+        pulumi.set(__self__, "discovery_rule_kind", 'ResourceGraphQuery')
+        pulumi.set(__self__, "entity_name", entity_name)
+        pulumi.set(__self__, "error", error)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "resource_graph_query", resource_graph_query)
+        if display_name is not None:
+            pulumi.set(__self__, "display_name", display_name)
+
+    @property
+    @pulumi.getter(name="addRecommendedSignals")
+    def add_recommended_signals(self) -> builtins.str:
+        """
+        Whether to add all recommended signals to the discovered entities.
+        """
+        return pulumi.get(self, "add_recommended_signals")
+
+    @property
+    @pulumi.getter(name="authenticationSetting")
+    def authentication_setting(self) -> builtins.str:
+        """
+        Reference to the name of the authentication setting which is used for querying Azure Resource Graph. The same authentication setting will also be assigned to any discovered entities.
+        """
+        return pulumi.get(self, "authentication_setting")
+
+    @property
+    @pulumi.getter(name="deletionDate")
+    def deletion_date(self) -> builtins.str:
+        """
+        Date when the discovery rule was (soft-)deleted.
+        """
+        return pulumi.get(self, "deletion_date")
+
+    @property
+    @pulumi.getter(name="discoverRelationships")
+    def discover_relationships(self) -> builtins.str:
+        """
+        Whether to create relationships between the discovered entities based on a set of built-in rules. These relationships cannot be manually deleted.
+        """
+        return pulumi.get(self, "discover_relationships")
+
+    @property
+    @pulumi.getter(name="discoveryRuleKind")
+    def discovery_rule_kind(self) -> builtins.str:
+        """
+        Discovery rule relationship discovery behavior
+        Expected value is 'ResourceGraphQuery'.
+        """
+        return pulumi.get(self, "discovery_rule_kind")
+
+    @property
+    @pulumi.getter(name="entityName")
+    def entity_name(self) -> builtins.str:
         """
-        The scheduling constraints for when the profile begins.
-        :param Sequence[builtins.str] days: the collection of days that the profile takes effect on. Possible values are Sunday through Saturday.
-        :param Sequence[builtins.int] hours: A collection of hours that the profile takes effect on. Values supported are 0 to 23 on the 24-hour clock (AM/PM times are not supported).
-        :param Sequence[builtins.int] minutes: A collection of minutes at which the profile takes effect at.
-        :param builtins.str time_zone: the timezone for the hours of the profile. Some examples of valid time zones are: Dateline Standard Time, UTC-11, Hawaiian Standard Time, Alaskan Standard Time, Pacific Standard Time (Mexico), Pacific Standard Time, US Mountain Standard Time, Mountain Standard Time (Mexico), Mountain Standard Time, Central America Standard Time, Central Standard Time, Central Standard Time (Mexico), Canada Central Standard Time, SA Pacific Standard Time, Eastern Standard Time, US Eastern Standard Time, Venezuela Standard Time, Paraguay Standard Time, Atlantic Standard Time, Central Brazilian Standard Time, SA Western Standard Time, Pacific SA Standard Time, Newfoundland Standard Time, E. South America Standard Time, Argentina Standard Time, SA Eastern Standard Time, Greenland Standard Time, Montevideo Standard Time, Bahia Standard Time, UTC-02, Mid-Atlantic Standard Time, Azores Standard Time, Cape Verde Standard Time, Morocco Standard Time, UTC, GMT Standard Time, Greenwich Standard Time, W. Europe Standard Time, Central Europe Standard Time, Romance Standard Time, Central European Standard Time, W. Central Africa Standard Time, Namibia Standard Time, Jordan Standard Time, GTB Standard Time, Middle East Standard Time, Egypt Standard Time, Syria Standard Time, E. Europe Standard Time, South Africa Standard Time, FLE Standard Time, Turkey Standard Time, Israel Standard Time, Kaliningrad Standard Time, Libya Standard Time, Arabic Standard Time, Arab Standard Time, Belarus Standard Time, Russian Standard Time, E. Africa Standard Time, Iran Standard Time, Arabian Standard Time, Azerbaijan Standard Time, Russia Time Zone 3, Mauritius Standard Time, Georgian Standard Time, Caucasus Standard Time, Afghanistan Standard Time, West Asia Standard Time, Ekaterinburg Standard Time, Pakistan Standard Time, India Standard Time, Sri Lanka Standard Time, Nepal Standard Time, Central Asia Standard Time, Bangladesh Standard Time, N. Central Asia Standard Time, Myanmar Standard Time, SE Asia Standard Time, North Asia Standard Time, China Standard Time, North Asia East Standard Time, Singapore Standard Time, W. Australia Standard Time, Taipei Standard Time, Ulaanbaatar Standard Time, Tokyo Standard Time, Korea Standard Time, Yakutsk Standard Time, Cen. Australia Standard Time, AUS Central Standard Time, E. Australia Standard Time, AUS Eastern Standard Time, West Pacific Standard Time, Tasmania Standard Time, Magadan Standard Time, Vladivostok Standard Time, Russia Time Zone 10, Central Pacific Standard Time, Russia Time Zone 11, New Zealand Standard Time, UTC+12, Fiji Standard Time, Kamchatka Standard Time, Tonga Standard Time, Samoa Standard Time, Line Islands Standard Time
+        Name of the entity which represents the discovery rule. Note: It might take a few minutes after creating the discovery rule until the entity is created.
         """
-        pulumi.set(__self__, "days", days)
-        pulumi.set(__self__, "hours", hours)
-        pulumi.set(__self__, "minutes", minutes)
-        pulumi.set(__self__, "time_zone", time_zone)
+        return pulumi.get(self, "entity_name")
 
     @property
     @pulumi.getter
-    def days(self) -> Sequence[builtins.str]:
+    def error(self) -> 'outputs.DiscoveryErrorResponse':
         """
-        the collection of days that the profile takes effect on. Possible values are Sunday through Saturday.
+        Error details if the last discovery operation failed.
         """
-        return pulumi.get(self, "days")
+        return pulumi.get(self, "error")
 
     @property
-    @pulumi.getter
-    def hours(self) -> Sequence[builtins.int]:
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
         """
-        A collection of hours that the profile takes effect on. Values supported are 0 to 23 on the 24-hour clock (AM/PM times are not supported).
+        The status of the last operation.
         """
-        return pulumi.get(self, "hours")
+        return pulumi.get(self, "provisioning_state")
 
     @property
-    @pulumi.getter
-    def minutes(self) -> Sequence[builtins.int]:
+    @pulumi.getter(name="resourceGraphQuery")
+    def resource_graph_query(self) -> builtins.str:
         """
-        A collection of minutes at which the profile takes effect at.
+        Azure Resource Graph query text in KQL syntax. The query must return at least a column named 'id' which contains the resource ID of the discovered resources.
         """
-        return pulumi.get(self, "minutes")
+        return pulumi.get(self, "resource_graph_query")
 
     @property
-    @pulumi.getter(name="timeZone")
-    def time_zone(self) -> builtins.str:
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> Optional[builtins.str]:
         """
-        the timezone for the hours of the profile. Some examples of valid time zones are: Dateline Standard Time, UTC-11, Hawaiian Standard Time, Alaskan Standard Time, Pacific Standard Time (Mexico), Pacific Standard Time, US Mountain Standard Time, Mountain Standard Time (Mexico), Mountain Standard Time, Central America Standard Time, Central Standard Time, Central Standard Time (Mexico), Canada Central Standard Time, SA Pacific Standard Time, Eastern Standard Time, US Eastern Standard Time, Venezuela Standard Time, Paraguay Standard Time, Atlantic Standard Time, Central Brazilian Standard Time, SA Western Standard Time, Pacific SA Standard Time, Newfoundland Standard Time, E. South America Standard Time, Argentina Standard Time, SA Eastern Standard Time, Greenland Standard Time, Montevideo Standard Time, Bahia Standard Time, UTC-02, Mid-Atlantic Standard Time, Azores Standard Time, Cape Verde Standard Time, Morocco Standard Time, UTC, GMT Standard Time, Greenwich Standard Time, W. Europe Standard Time, Central Europe Standard Time, Romance Standard Time, Central European Standard Time, W. Central Africa Standard Time, Namibia Standard Time, Jordan Standard Time, GTB Standard Time, Middle East Standard Time, Egypt Standard Time, Syria Standard Time, E. Europe Standard Time, South Africa Standard Time, FLE Standard Time, Turkey Standard Time, Israel Standard Time, Kaliningrad Standard Time, Libya Standard Time, Arabic Standard Time, Arab Standard Time, Belarus Standard Time, Russian Standard Time, E. Africa Standard Time, Iran Standard Time, Arabian Standard Time, Azerbaijan Standard Time, Russia Time Zone 3, Mauritius Standard Time, Georgian Standard Time, Caucasus Standard Time, Afghanistan Standard Time, West Asia Standard Time, Ekaterinburg Standard Time, Pakistan Standard Time, India Standard Time, Sri Lanka Standard Time, Nepal Standard Time, Central Asia Standard Time, Bangladesh Standard Time, N. Central Asia Standard Time, Myanmar Standard Time, SE Asia Standard Time, North Asia Standard Time, China Standard Time, North Asia East Standard Time, Singapore Standard Time, W. Australia Standard Time, Taipei Standard Time, Ulaanbaatar Standard Time, Tokyo Standard Time, Korea Standard Time, Yakutsk Standard Time, Cen. Australia Standard Time, AUS Central Standard Time, E. Australia Standard Time, AUS Eastern Standard Time, West Pacific Standard Time, Tasmania Standard Time, Magadan Standard Time, Vladivostok Standard Time, Russia Time Zone 10, Central Pacific Standard Time, Russia Time Zone 11, New Zealand Standard Time, UTC+12, Fiji Standard Time, Kamchatka Standard Time, Tonga Standard Time, Samoa Standard Time, Line Islands Standard Time
+        Display name
         """
-        return pulumi.get(self, "time_zone")
+        return pulumi.get(self, "display_name")
 
 
 @pulumi.output_type
@@ -7097,6 +9399,220 @@ class ResourceMapResponse(dict):
         return pulumi.get(self, "to")
 
 
+@pulumi.output_type
+class ResourceMetricSignalDefinitionPropertiesResponse(dict):
+    """
+    Azure Resource Metric Signal Definition properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "aggregationType":
+            suggest = "aggregation_type"
+        elif key == "deletionDate":
+            suggest = "deletion_date"
+        elif key == "evaluationRules":
+            suggest = "evaluation_rules"
+        elif key == "metricName":
+            suggest = "metric_name"
+        elif key == "metricNamespace":
+            suggest = "metric_namespace"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "signalKind":
+            suggest = "signal_kind"
+        elif key == "timeGrain":
+            suggest = "time_grain"
+        elif key == "dataUnit":
+            suggest = "data_unit"
+        elif key == "dimensionFilter":
+            suggest = "dimension_filter"
+        elif key == "displayName":
+            suggest = "display_name"
+        elif key == "refreshInterval":
+            suggest = "refresh_interval"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ResourceMetricSignalDefinitionPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ResourceMetricSignalDefinitionPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ResourceMetricSignalDefinitionPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 aggregation_type: builtins.str,
+                 deletion_date: builtins.str,
+                 evaluation_rules: 'outputs.EvaluationRuleResponse',
+                 metric_name: builtins.str,
+                 metric_namespace: builtins.str,
+                 provisioning_state: builtins.str,
+                 signal_kind: builtins.str,
+                 time_grain: builtins.str,
+                 data_unit: Optional[builtins.str] = None,
+                 dimension: Optional[builtins.str] = None,
+                 dimension_filter: Optional[builtins.str] = None,
+                 display_name: Optional[builtins.str] = None,
+                 refresh_interval: Optional[builtins.str] = None,
+                 tags: Optional[Mapping[str, builtins.str]] = None):
+        """
+        Azure Resource Metric Signal Definition properties
+        :param builtins.str aggregation_type: Type of aggregation to apply to the metric
+        :param builtins.str deletion_date: Date when the signal definition was (soft-)deleted
+        :param 'EvaluationRuleResponse' evaluation_rules: Evaluation rules for the signal definition
+        :param builtins.str metric_name: Name of the metric
+        :param builtins.str metric_namespace: Metric namespace
+        :param builtins.str provisioning_state: The status of the last operation.
+        :param builtins.str signal_kind: Supported signal kinds as discriminator
+               Expected value is 'AzureResourceMetric'.
+        :param builtins.str time_grain: Time range of signal. ISO duration format like PT10M.
+        :param builtins.str data_unit: Unit of the signal result (e.g. Bytes, MilliSeconds, Percent, Count))
+        :param builtins.str dimension: Optional: Dimension to split by
+        :param builtins.str dimension_filter: Optional: Dimension filter to apply to the dimension. Must only be set if also Dimension is set.
+        :param builtins.str display_name: Display name
+        :param builtins.str refresh_interval: Interval in which the signal is being evaluated. Defaults to PT1M (1 minute).
+        :param Mapping[str, builtins.str] tags: Optional set of labels (key-value pairs)
+        """
+        pulumi.set(__self__, "aggregation_type", aggregation_type)
+        pulumi.set(__self__, "deletion_date", deletion_date)
+        pulumi.set(__self__, "evaluation_rules", evaluation_rules)
+        pulumi.set(__self__, "metric_name", metric_name)
+        pulumi.set(__self__, "metric_namespace", metric_namespace)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "signal_kind", 'AzureResourceMetric')
+        pulumi.set(__self__, "time_grain", time_grain)
+        if data_unit is not None:
+            pulumi.set(__self__, "data_unit", data_unit)
+        if dimension is not None:
+            pulumi.set(__self__, "dimension", dimension)
+        if dimension_filter is not None:
+            pulumi.set(__self__, "dimension_filter", dimension_filter)
+        if display_name is not None:
+            pulumi.set(__self__, "display_name", display_name)
+        if refresh_interval is None:
+            refresh_interval = 'PT1M'
+        if refresh_interval is not None:
+            pulumi.set(__self__, "refresh_interval", refresh_interval)
+        if tags is not None:
+            pulumi.set(__self__, "tags", tags)
+
+    @property
+    @pulumi.getter(name="aggregationType")
+    def aggregation_type(self) -> builtins.str:
+        """
+        Type of aggregation to apply to the metric
+        """
+        return pulumi.get(self, "aggregation_type")
+
+    @property
+    @pulumi.getter(name="deletionDate")
+    def deletion_date(self) -> builtins.str:
+        """
+        Date when the signal definition was (soft-)deleted
+        """
+        return pulumi.get(self, "deletion_date")
+
+    @property
+    @pulumi.getter(name="evaluationRules")
+    def evaluation_rules(self) -> 'outputs.EvaluationRuleResponse':
+        """
+        Evaluation rules for the signal definition
+        """
+        return pulumi.get(self, "evaluation_rules")
+
+    @property
+    @pulumi.getter(name="metricName")
+    def metric_name(self) -> builtins.str:
+        """
+        Name of the metric
+        """
+        return pulumi.get(self, "metric_name")
+
+    @property
+    @pulumi.getter(name="metricNamespace")
+    def metric_namespace(self) -> builtins.str:
+        """
+        Metric namespace
+        """
+        return pulumi.get(self, "metric_namespace")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
+        """
+        The status of the last operation.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="signalKind")
+    def signal_kind(self) -> builtins.str:
+        """
+        Supported signal kinds as discriminator
+        Expected value is 'AzureResourceMetric'.
+        """
+        return pulumi.get(self, "signal_kind")
+
+    @property
+    @pulumi.getter(name="timeGrain")
+    def time_grain(self) -> builtins.str:
+        """
+        Time range of signal. ISO duration format like PT10M.
+        """
+        return pulumi.get(self, "time_grain")
+
+    @property
+    @pulumi.getter(name="dataUnit")
+    def data_unit(self) -> Optional[builtins.str]:
+        """
+        Unit of the signal result (e.g. Bytes, MilliSeconds, Percent, Count))
+        """
+        return pulumi.get(self, "data_unit")
+
+    @property
+    @pulumi.getter
+    def dimension(self) -> Optional[builtins.str]:
+        """
+        Optional: Dimension to split by
+        """
+        return pulumi.get(self, "dimension")
+
+    @property
+    @pulumi.getter(name="dimensionFilter")
+    def dimension_filter(self) -> Optional[builtins.str]:
+        """
+        Optional: Dimension filter to apply to the dimension. Must only be set if also Dimension is set.
+        """
+        return pulumi.get(self, "dimension_filter")
+
+    @property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> Optional[builtins.str]:
+        """
+        Display name
+        """
+        return pulumi.get(self, "display_name")
+
+    @property
+    @pulumi.getter(name="refreshInterval")
+    def refresh_interval(self) -> Optional[builtins.str]:
+        """
+        Interval in which the signal is being evaluated. Defaults to PT1M (1 minute).
+        """
+        return pulumi.get(self, "refresh_interval")
+
+    @property
+    @pulumi.getter
+    def tags(self) -> Optional[Mapping[str, builtins.str]]:
+        """
+        Optional set of labels (key-value pairs)
+        """
+        return pulumi.get(self, "tags")
+
+
 @pulumi.output_type
 class RetentionPolicyResponse(dict):
     """
@@ -7184,6 +9700,67 @@ class RuleResolveConfigurationResponse(dict):
         return pulumi.get(self, "time_to_resolve")
 
 
+@pulumi.output_type
+class RunParametersResponse(dict):
+    """
+    The parameters used to run the investigation
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "impactTime":
+            suggest = "impact_time"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in RunParametersResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        RunParametersResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        RunParametersResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 alerts: Sequence['outputs.InvestigationScopeResponse'],
+                 impact_time: builtins.str,
+                 resources: Sequence['outputs.InvestigationScopeResponse']):
+        """
+        The parameters used to run the investigation
+        :param Sequence['InvestigationScopeResponse'] alerts: The alerts used to run the investigation
+        :param builtins.str impact_time: The impact time to investigate (in UTC)
+        :param Sequence['InvestigationScopeResponse'] resources: The resources used to run the investigation
+        """
+        pulumi.set(__self__, "alerts", alerts)
+        pulumi.set(__self__, "impact_time", impact_time)
+        pulumi.set(__self__, "resources", resources)
+
+    @property
+    @pulumi.getter
+    def alerts(self) -> Sequence['outputs.InvestigationScopeResponse']:
+        """
+        The alerts used to run the investigation
+        """
+        return pulumi.get(self, "alerts")
+
+    @property
+    @pulumi.getter(name="impactTime")
+    def impact_time(self) -> builtins.str:
+        """
+        The impact time to investigate (in UTC)
+        """
+        return pulumi.get(self, "impact_time")
+
+    @property
+    @pulumi.getter
+    def resources(self) -> Sequence['outputs.InvestigationScopeResponse']:
+        """
+        The resources used to run the investigation
+        """
+        return pulumi.get(self, "resources")
+
+
 @pulumi.output_type
 class ScaleActionResponse(dict):
     """
@@ -7590,6 +10167,125 @@ class ServiceResponse(dict):
         return pulumi.get(self, "persistence")
 
 
+@pulumi.output_type
+class SignalAssignmentResponse(dict):
+    """
+    Group of signal definition assignments
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "signalDefinitions":
+            suggest = "signal_definitions"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SignalAssignmentResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SignalAssignmentResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SignalAssignmentResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 signal_definitions: Sequence[builtins.str]):
+        """
+        Group of signal definition assignments
+        :param Sequence[builtins.str] signal_definitions: Signal definitions referenced by their names. All definitions are combined with an AND operator.
+        """
+        pulumi.set(__self__, "signal_definitions", signal_definitions)
+
+    @property
+    @pulumi.getter(name="signalDefinitions")
+    def signal_definitions(self) -> Sequence[builtins.str]:
+        """
+        Signal definitions referenced by their names. All definitions are combined with an AND operator.
+        """
+        return pulumi.get(self, "signal_definitions")
+
+
+@pulumi.output_type
+class SignalGroupResponse(dict):
+    """
+    Contains various signal groups that can be assigned to an entity
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "azureLogAnalytics":
+            suggest = "azure_log_analytics"
+        elif key == "azureMonitorWorkspace":
+            suggest = "azure_monitor_workspace"
+        elif key == "azureResource":
+            suggest = "azure_resource"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SignalGroupResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SignalGroupResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SignalGroupResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 azure_log_analytics: Optional['outputs.LogAnalyticsSignalGroupResponse'] = None,
+                 azure_monitor_workspace: Optional['outputs.AzureMonitorWorkspaceSignalGroupResponse'] = None,
+                 azure_resource: Optional['outputs.AzureResourceSignalGroupResponse'] = None,
+                 dependencies: Optional['outputs.DependenciesSignalGroupResponse'] = None):
+        """
+        Contains various signal groups that can be assigned to an entity
+        :param 'LogAnalyticsSignalGroupResponse' azure_log_analytics: Log Analytics Signal Group
+        :param 'AzureMonitorWorkspaceSignalGroupResponse' azure_monitor_workspace: Azure Monitor Workspace Signal Group
+        :param 'AzureResourceSignalGroupResponse' azure_resource: Azure Resource Signal Group
+        :param 'DependenciesSignalGroupResponse' dependencies: Settings for dependency signals to control how the health state of child entities influences the health state of the parent entity.
+        """
+        if azure_log_analytics is not None:
+            pulumi.set(__self__, "azure_log_analytics", azure_log_analytics)
+        if azure_monitor_workspace is not None:
+            pulumi.set(__self__, "azure_monitor_workspace", azure_monitor_workspace)
+        if azure_resource is not None:
+            pulumi.set(__self__, "azure_resource", azure_resource)
+        if dependencies is not None:
+            pulumi.set(__self__, "dependencies", dependencies)
+
+    @property
+    @pulumi.getter(name="azureLogAnalytics")
+    def azure_log_analytics(self) -> Optional['outputs.LogAnalyticsSignalGroupResponse']:
+        """
+        Log Analytics Signal Group
+        """
+        return pulumi.get(self, "azure_log_analytics")
+
+    @property
+    @pulumi.getter(name="azureMonitorWorkspace")
+    def azure_monitor_workspace(self) -> Optional['outputs.AzureMonitorWorkspaceSignalGroupResponse']:
+        """
+        Azure Monitor Workspace Signal Group
+        """
+        return pulumi.get(self, "azure_monitor_workspace")
+
+    @property
+    @pulumi.getter(name="azureResource")
+    def azure_resource(self) -> Optional['outputs.AzureResourceSignalGroupResponse']:
+        """
+        Azure Resource Signal Group
+        """
+        return pulumi.get(self, "azure_resource")
+
+    @property
+    @pulumi.getter
+    def dependencies(self) -> Optional['outputs.DependenciesSignalGroupResponse']:
+        """
+        Settings for dependency signals to control how the health state of child entities influences the health state of the parent entity.
+        """
+        return pulumi.get(self, "dependencies")
+
+
 @pulumi.output_type
 class SmsReceiverResponse(dict):
     """
@@ -8130,6 +10826,39 @@ class TcpExporterResponse(dict):
         return pulumi.get(self, "url")
 
 
+@pulumi.output_type
+class ThresholdRuleResponse(dict):
+    """
+    Threshold-based evaluation rule for a signal definition
+    """
+    def __init__(__self__, *,
+                 operator: builtins.str,
+                 threshold: builtins.str):
+        """
+        Threshold-based evaluation rule for a signal definition
+        :param builtins.str operator: Operator how to compare the signal value with the threshold
+        :param builtins.str threshold: Threshold value
+        """
+        pulumi.set(__self__, "operator", operator)
+        pulumi.set(__self__, "threshold", threshold)
+
+    @property
+    @pulumi.getter
+    def operator(self) -> builtins.str:
+        """
+        Operator how to compare the signal value with the threshold
+        """
+        return pulumi.get(self, "operator")
+
+    @property
+    @pulumi.getter
+    def threshold(self) -> builtins.str:
+        """
+        Threshold value
+        """
+        return pulumi.get(self, "threshold")
+
+
 @pulumi.output_type
 class TimeWindowResponse(dict):
     """