pulumi-azure-native 3.0.0a1743504154__py3-none-any.whl → 3.0.1__py3-none-any.whl

pulumi_azure_native/monitor/outputs.py

@@ -22,6 +22,9 @@ __all__ = [
     'ActionsResponse',
     'ArmRoleReceiverResponse',
     'AutomationRunbookReceiverResponse',
+    'AutoscaleNotificationResponse',
+    'AutoscaleProfileResponse',
+    'AutoscaleSettingResponse',
     'AzureAppPushReceiverResponse',
     'AzureFunctionReceiverResponse',
     'AzureMonitorWorkspaceLogsApiConfigResponse',
@@ -32,7 +35,9 @@ __all__ = [
     'ConcurrencyConfigurationResponse',
     'ConditionResponse',
     'ConditionResponseFailingPeriods',
+    'DiagnosticSettingsCategoryResourceResponse',
     'DimensionResponse',
+    'EmailNotificationResponse',
     'EmailReceiverResponse',
     'EventHubReceiverResponse',
     'ExporterResponse',
@@ -44,8 +49,12 @@ __all__ = [
     'JsonArrayMapperResponse',
     'JsonMapperDestinationFieldResponse',
     'JsonMapperSourceFieldResponse',
+    'LogSettingsResponse',
     'LogicAppReceiverResponse',
     'ManagedServiceIdentityResponse',
+    'ManagementGroupLogSettingsResponse',
+    'MetricSettingsResponse',
+    'MetricTriggerResponse',
     'MetricsResponse',
     'NetworkingConfigurationResponse',
     'NetworkingRouteResponse',
@@ -53,26 +62,37 @@ __all__ = [
     'PersistenceConfigurationsResponse',
     'PipelineGroupPropertiesResponse',
     'PipelineResponse',
+    'PredictiveAutoscalePolicyResponse',
     'PrivateEndpointConnectionResponse',
     'PrivateEndpointResponse',
     'PrivateLinkServiceConnectionStateResponse',
     'ProcessorResponse',
     'ReceiverResponse',
     'RecordMapResponse',
+    'RecurrenceResponse',
+    'RecurrentScheduleResponse',
     'ResourceMapResponse',
+    'RetentionPolicyResponse',
     'RuleResolveConfigurationResponse',
+    'ScaleActionResponse',
+    'ScaleCapacityResponse',
+    'ScaleRuleMetricDimensionResponse',
+    'ScaleRuleResponse',
     'ScheduledQueryRuleCriteriaResponse',
     'SchemaMapResponse',
     'ScopeMapResponse',
     'ServiceResponse',
     'SmsReceiverResponse',
+    'SubscriptionLogSettingsResponse',
     'SyslogReceiverResponse',
     'SystemDataResponse',
     'TcpExporterResponse',
+    'TimeWindowResponse',
     'UdpReceiverResponse',
     'UserAssignedIdentityResponse',
     'UserIdentityPropertiesResponse',
     'VoiceReceiverResponse',
+    'WebhookNotificationResponse',
     'WebhookReceiverResponse',
 ]
 
@@ -476,6 +496,254 @@ class AutomationRunbookReceiverResponse(dict):
         return pulumi.get(self, "use_common_alert_schema")
 
 
+@pulumi.output_type
+class AutoscaleNotificationResponse(dict):
+    """
+    Autoscale notification.
+    """
+    def __init__(__self__, *,
+                 operation: str,
+                 email: Optional['outputs.EmailNotificationResponse'] = None,
+                 webhooks: Optional[Sequence['outputs.WebhookNotificationResponse']] = None):
+        """
+        Autoscale notification.
+        :param str operation: the operation associated with the notification and its value must be "scale"
+        :param 'EmailNotificationResponse' email: the email notification.
+        :param Sequence['WebhookNotificationResponse'] webhooks: the collection of webhook notifications.
+        """
+        pulumi.set(__self__, "operation", operation)
+        if email is not None:
+            pulumi.set(__self__, "email", email)
+        if webhooks is not None:
+            pulumi.set(__self__, "webhooks", webhooks)
+
+    @property
+    @pulumi.getter
+    def operation(self) -> str:
+        """
+        the operation associated with the notification and its value must be "scale"
+        """
+        return pulumi.get(self, "operation")
+
+    @property
+    @pulumi.getter
+    def email(self) -> Optional['outputs.EmailNotificationResponse']:
+        """
+        the email notification.
+        """
+        return pulumi.get(self, "email")
+
+    @property
+    @pulumi.getter
+    def webhooks(self) -> Optional[Sequence['outputs.WebhookNotificationResponse']]:
+        """
+        the collection of webhook notifications.
+        """
+        return pulumi.get(self, "webhooks")
+
+
+@pulumi.output_type
+class AutoscaleProfileResponse(dict):
+    """
+    Autoscale profile.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "fixedDate":
+            suggest = "fixed_date"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AutoscaleProfileResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AutoscaleProfileResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AutoscaleProfileResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 capacity: 'outputs.ScaleCapacityResponse',
+                 name: str,
+                 rules: Sequence['outputs.ScaleRuleResponse'],
+                 fixed_date: Optional['outputs.TimeWindowResponse'] = None,
+                 recurrence: Optional['outputs.RecurrenceResponse'] = None):
+        """
+        Autoscale profile.
+        :param 'ScaleCapacityResponse' capacity: the number of instances that can be used during this profile.
+        :param str name: the name of the profile.
+        :param Sequence['ScaleRuleResponse'] rules: the collection of rules that provide the triggers and parameters for the scaling action. A maximum of 10 rules can be specified.
+        :param 'TimeWindowResponse' fixed_date: the specific date-time for the profile. This element is not used if the Recurrence element is used.
+        :param 'RecurrenceResponse' recurrence: the repeating times at which this profile begins. This element is not used if the FixedDate element is used.
+        """
+        pulumi.set(__self__, "capacity", capacity)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "rules", rules)
+        if fixed_date is not None:
+            pulumi.set(__self__, "fixed_date", fixed_date)
+        if recurrence is not None:
+            pulumi.set(__self__, "recurrence", recurrence)
+
+    @property
+    @pulumi.getter
+    def capacity(self) -> 'outputs.ScaleCapacityResponse':
+        """
+        the number of instances that can be used during this profile.
+        """
+        return pulumi.get(self, "capacity")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        the name of the profile.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def rules(self) -> Sequence['outputs.ScaleRuleResponse']:
+        """
+        the collection of rules that provide the triggers and parameters for the scaling action. A maximum of 10 rules can be specified.
+        """
+        return pulumi.get(self, "rules")
+
+    @property
+    @pulumi.getter(name="fixedDate")
+    def fixed_date(self) -> Optional['outputs.TimeWindowResponse']:
+        """
+        the specific date-time for the profile. This element is not used if the Recurrence element is used.
+        """
+        return pulumi.get(self, "fixed_date")
+
+    @property
+    @pulumi.getter
+    def recurrence(self) -> Optional['outputs.RecurrenceResponse']:
+        """
+        the repeating times at which this profile begins. This element is not used if the FixedDate element is used.
+        """
+        return pulumi.get(self, "recurrence")
+
+
+@pulumi.output_type
+class AutoscaleSettingResponse(dict):
+    """
+    A setting that contains all of the configuration for the automatic scaling of a resource.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "predictiveAutoscalePolicy":
+            suggest = "predictive_autoscale_policy"
+        elif key == "targetResourceLocation":
+            suggest = "target_resource_location"
+        elif key == "targetResourceUri":
+            suggest = "target_resource_uri"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AutoscaleSettingResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AutoscaleSettingResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AutoscaleSettingResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 profiles: Sequence['outputs.AutoscaleProfileResponse'],
+                 enabled: Optional[bool] = None,
+                 name: Optional[str] = None,
+                 notifications: Optional[Sequence['outputs.AutoscaleNotificationResponse']] = None,
+                 predictive_autoscale_policy: Optional['outputs.PredictiveAutoscalePolicyResponse'] = None,
+                 target_resource_location: Optional[str] = None,
+                 target_resource_uri: Optional[str] = None):
+        """
+        A setting that contains all of the configuration for the automatic scaling of a resource.
+        :param Sequence['AutoscaleProfileResponse'] profiles: the collection of automatic scaling profiles that specify different scaling parameters for different time periods. A maximum of 20 profiles can be specified.
+        :param bool enabled: the enabled flag. Specifies whether automatic scaling is enabled for the resource. The default value is 'false'.
+        :param str name: the name of the autoscale setting.
+        :param Sequence['AutoscaleNotificationResponse'] notifications: the collection of notifications.
+        :param 'PredictiveAutoscalePolicyResponse' predictive_autoscale_policy: the predictive autoscale policy mode.
+        :param str target_resource_location: the location of the resource that the autoscale setting should be added to.
+        :param str target_resource_uri: the resource identifier of the resource that the autoscale setting should be added to.
+        """
+        pulumi.set(__self__, "profiles", profiles)
+        if enabled is None:
+            enabled = False
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if notifications is not None:
+            pulumi.set(__self__, "notifications", notifications)
+        if predictive_autoscale_policy is not None:
+            pulumi.set(__self__, "predictive_autoscale_policy", predictive_autoscale_policy)
+        if target_resource_location is not None:
+            pulumi.set(__self__, "target_resource_location", target_resource_location)
+        if target_resource_uri is not None:
+            pulumi.set(__self__, "target_resource_uri", target_resource_uri)
+
+    @property
+    @pulumi.getter
+    def profiles(self) -> Sequence['outputs.AutoscaleProfileResponse']:
+        """
+        the collection of automatic scaling profiles that specify different scaling parameters for different time periods. A maximum of 20 profiles can be specified.
+        """
+        return pulumi.get(self, "profiles")
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[bool]:
+        """
+        the enabled flag. Specifies whether automatic scaling is enabled for the resource. The default value is 'false'.
+        """
+        return pulumi.get(self, "enabled")
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        the name of the autoscale setting.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def notifications(self) -> Optional[Sequence['outputs.AutoscaleNotificationResponse']]:
+        """
+        the collection of notifications.
+        """
+        return pulumi.get(self, "notifications")
+
+    @property
+    @pulumi.getter(name="predictiveAutoscalePolicy")
+    def predictive_autoscale_policy(self) -> Optional['outputs.PredictiveAutoscalePolicyResponse']:
+        """
+        the predictive autoscale policy mode.
+        """
+        return pulumi.get(self, "predictive_autoscale_policy")
+
+    @property
+    @pulumi.getter(name="targetResourceLocation")
+    def target_resource_location(self) -> Optional[str]:
+        """
+        the location of the resource that the autoscale setting should be added to.
+        """
+        return pulumi.get(self, "target_resource_location")
+
+    @property
+    @pulumi.getter(name="targetResourceUri")
+    def target_resource_uri(self) -> Optional[str]:
+        """
+        the resource identifier of the resource that the autoscale setting should be added to.
+        """
+        return pulumi.get(self, "target_resource_uri")
+
+
 @pulumi.output_type
 class AzureAppPushReceiverResponse(dict):
     """
@@ -1197,6 +1465,85 @@ class ConditionResponseFailingPeriods(dict):
         return pulumi.get(self, "number_of_evaluation_periods")
 
 
+@pulumi.output_type
+class DiagnosticSettingsCategoryResourceResponse(dict):
+    """
+    The diagnostic settings category resource.
+    """
+    def __init__(__self__, *,
+                 id: str,
+                 name: str,
+                 system_data: 'outputs.SystemDataResponse',
+                 type: str,
+                 category_groups: Optional[Sequence[str]] = None,
+                 category_type: Optional[str] = None):
+        """
+        The diagnostic settings category resource.
+        :param str id: Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
+        :param str name: The name of the resource
+        :param 'SystemDataResponse' system_data: The system metadata related to this resource.
+        :param str type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
+        :param Sequence[str] category_groups: the collection of what category groups are supported.
+        :param str category_type: The type of the diagnostic settings category.
+        """
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "system_data", system_data)
+        pulumi.set(__self__, "type", type)
+        if category_groups is not None:
+            pulumi.set(__self__, "category_groups", category_groups)
+        if category_type is not None:
+            pulumi.set(__self__, "category_type", category_type)
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The name of the resource
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="systemData")
+    def system_data(self) -> 'outputs.SystemDataResponse':
+        """
+        The system metadata related to this resource.
+        """
+        return pulumi.get(self, "system_data")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter(name="categoryGroups")
+    def category_groups(self) -> Optional[Sequence[str]]:
+        """
+        the collection of what category groups are supported.
+        """
+        return pulumi.get(self, "category_groups")
+
+    @property
+    @pulumi.getter(name="categoryType")
+    def category_type(self) -> Optional[str]:
+        """
+        The type of the diagnostic settings category.
+        """
+        return pulumi.get(self, "category_type")
+
+
 @pulumi.output_type
 class DimensionResponse(dict):
     """
@@ -1241,6 +1588,78 @@ class DimensionResponse(dict):
         return pulumi.get(self, "values")
 
 
+@pulumi.output_type
+class EmailNotificationResponse(dict):
+    """
+    Email notification of an autoscale event.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "customEmails":
+            suggest = "custom_emails"
+        elif key == "sendToSubscriptionAdministrator":
+            suggest = "send_to_subscription_administrator"
+        elif key == "sendToSubscriptionCoAdministrators":
+            suggest = "send_to_subscription_co_administrators"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in EmailNotificationResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        EmailNotificationResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        EmailNotificationResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 custom_emails: Optional[Sequence[str]] = None,
+                 send_to_subscription_administrator: Optional[bool] = None,
+                 send_to_subscription_co_administrators: Optional[bool] = None):
+        """
+        Email notification of an autoscale event.
+        :param Sequence[str] custom_emails: the custom e-mails list. This value can be null or empty, in which case this attribute will be ignored.
+        :param bool send_to_subscription_administrator: a value indicating whether to send email to subscription administrator.
+        :param bool send_to_subscription_co_administrators: a value indicating whether to send email to subscription co-administrators.
+        """
+        if custom_emails is not None:
+            pulumi.set(__self__, "custom_emails", custom_emails)
+        if send_to_subscription_administrator is None:
+            send_to_subscription_administrator = False
+        if send_to_subscription_administrator is not None:
+            pulumi.set(__self__, "send_to_subscription_administrator", send_to_subscription_administrator)
+        if send_to_subscription_co_administrators is None:
+            send_to_subscription_co_administrators = False
+        if send_to_subscription_co_administrators is not None:
+            pulumi.set(__self__, "send_to_subscription_co_administrators", send_to_subscription_co_administrators)
+
+    @property
+    @pulumi.getter(name="customEmails")
+    def custom_emails(self) -> Optional[Sequence[str]]:
+        """
+        the custom e-mails list. This value can be null or empty, in which case this attribute will be ignored.
+        """
+        return pulumi.get(self, "custom_emails")
+
+    @property
+    @pulumi.getter(name="sendToSubscriptionAdministrator")
+    def send_to_subscription_administrator(self) -> Optional[bool]:
+        """
+        a value indicating whether to send email to subscription administrator.
+        """
+        return pulumi.get(self, "send_to_subscription_administrator")
+
+    @property
+    @pulumi.getter(name="sendToSubscriptionCoAdministrators")
+    def send_to_subscription_co_administrators(self) -> Optional[bool]:
+        """
+        a value indicating whether to send email to subscription co-administrators.
+        """
+        return pulumi.get(self, "send_to_subscription_co_administrators")
+
+
 @pulumi.output_type
 class EmailReceiverResponse(dict):
     """
@@ -1992,6 +2411,83 @@ class JsonMapperSourceFieldResponse(dict):
         return pulumi.get(self, "field_name")
 
 
+@pulumi.output_type
+class LogSettingsResponse(dict):
+    """
+    Part of MultiTenantDiagnosticSettings. Specifies the settings for a particular log.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "categoryGroup":
+            suggest = "category_group"
+        elif key == "retentionPolicy":
+            suggest = "retention_policy"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in LogSettingsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        LogSettingsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        LogSettingsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 enabled: bool,
+                 category: Optional[str] = None,
+                 category_group: Optional[str] = None,
+                 retention_policy: Optional['outputs.RetentionPolicyResponse'] = None):
+        """
+        Part of MultiTenantDiagnosticSettings. Specifies the settings for a particular log.
+        :param bool enabled: a value indicating whether this log is enabled.
+        :param str category: Name of a Diagnostic Log category for a resource type this setting is applied to. To obtain the list of Diagnostic Log categories for a resource, first perform a GET diagnostic settings operation.
+        :param str category_group: Name of a Diagnostic Log category group for a resource type this setting is applied to. To obtain the list of Diagnostic Log categories for a resource, first perform a GET diagnostic settings operation.
+        :param 'RetentionPolicyResponse' retention_policy: the retention policy for this log.
+        """
+        pulumi.set(__self__, "enabled", enabled)
+        if category is not None:
+            pulumi.set(__self__, "category", category)
+        if category_group is not None:
+            pulumi.set(__self__, "category_group", category_group)
+        if retention_policy is not None:
+            pulumi.set(__self__, "retention_policy", retention_policy)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> bool:
+        """
+        a value indicating whether this log is enabled.
+        """
+        return pulumi.get(self, "enabled")
+
+    @property
+    @pulumi.getter
+    def category(self) -> Optional[str]:
+        """
+        Name of a Diagnostic Log category for a resource type this setting is applied to. To obtain the list of Diagnostic Log categories for a resource, first perform a GET diagnostic settings operation.
+        """
+        return pulumi.get(self, "category")
+
+    @property
+    @pulumi.getter(name="categoryGroup")
+    def category_group(self) -> Optional[str]:
+        """
+        Name of a Diagnostic Log category group for a resource type this setting is applied to. To obtain the list of Diagnostic Log categories for a resource, first perform a GET diagnostic settings operation.
+        """
+        return pulumi.get(self, "category_group")
+
+    @property
+    @pulumi.getter(name="retentionPolicy")
+    def retention_policy(self) -> Optional['outputs.RetentionPolicyResponse']:
+        """
+        the retention policy for this log.
+        """
+        return pulumi.get(self, "retention_policy")
+
+
 @pulumi.output_type
 class LogicAppReceiverResponse(dict):
     """
@@ -2163,27 +2659,345 @@ class ManagedServiceIdentityResponse(dict):
 
 
 @pulumi.output_type
-class MetricsResponse(dict):
+class ManagementGroupLogSettingsResponse(dict):
     """
-    Information about metrics for the workspace
+    Part of Management Group diagnostic setting. Specifies the settings for a particular log.
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "internalId":
-            suggest = "internal_id"
-        elif key == "prometheusQueryEndpoint":
-            suggest = "prometheus_query_endpoint"
+        if key == "categoryGroup":
+            suggest = "category_group"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in MetricsResponse. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in ManagementGroupLogSettingsResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        MetricsResponse.__key_warning(key)
+        ManagementGroupLogSettingsResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        MetricsResponse.__key_warning(key)
+        ManagementGroupLogSettingsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 enabled: bool,
+                 category: Optional[str] = None,
+                 category_group: Optional[str] = None):
+        """
+        Part of Management Group diagnostic setting. Specifies the settings for a particular log.
+        :param bool enabled: a value indicating whether this log is enabled.
+        :param str category: Name of a Management Group Diagnostic Log category for a resource type this setting is applied to.
+        :param str category_group: Name of a Management Group Diagnostic Log category group for a resource type this setting is applied to.
+        """
+        pulumi.set(__self__, "enabled", enabled)
+        if category is not None:
+            pulumi.set(__self__, "category", category)
+        if category_group is not None:
+            pulumi.set(__self__, "category_group", category_group)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> bool:
+        """
+        a value indicating whether this log is enabled.
+        """
+        return pulumi.get(self, "enabled")
+
+    @property
+    @pulumi.getter
+    def category(self) -> Optional[str]:
+        """
+        Name of a Management Group Diagnostic Log category for a resource type this setting is applied to.
+        """
+        return pulumi.get(self, "category")
+
+    @property
+    @pulumi.getter(name="categoryGroup")
+    def category_group(self) -> Optional[str]:
+        """
+        Name of a Management Group Diagnostic Log category group for a resource type this setting is applied to.
+        """
+        return pulumi.get(self, "category_group")
+
+
+@pulumi.output_type
+class MetricSettingsResponse(dict):
+    """
+    Part of MultiTenantDiagnosticSettings. Specifies the settings for a particular metric.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "retentionPolicy":
+            suggest = "retention_policy"
+        elif key == "timeGrain":
+            suggest = "time_grain"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in MetricSettingsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        MetricSettingsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        MetricSettingsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 enabled: bool,
+                 category: Optional[str] = None,
+                 retention_policy: Optional['outputs.RetentionPolicyResponse'] = None,
+                 time_grain: Optional[str] = None):
+        """
+        Part of MultiTenantDiagnosticSettings. Specifies the settings for a particular metric.
+        :param bool enabled: a value indicating whether this category is enabled.
+        :param str category: Name of a Diagnostic Metric category for a resource type this setting is applied to. To obtain the list of Diagnostic metric categories for a resource, first perform a GET diagnostic settings operation.
+        :param 'RetentionPolicyResponse' retention_policy: the retention policy for this category.
+        :param str time_grain: the timegrain of the metric in ISO8601 format.
+        """
+        pulumi.set(__self__, "enabled", enabled)
+        if category is not None:
+            pulumi.set(__self__, "category", category)
+        if retention_policy is not None:
+            pulumi.set(__self__, "retention_policy", retention_policy)
+        if time_grain is not None:
+            pulumi.set(__self__, "time_grain", time_grain)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> bool:
+        """
+        a value indicating whether this category is enabled.
+        """
+        return pulumi.get(self, "enabled")
+
+    @property
+    @pulumi.getter
+    def category(self) -> Optional[str]:
+        """
+        Name of a Diagnostic Metric category for a resource type this setting is applied to. To obtain the list of Diagnostic metric categories for a resource, first perform a GET diagnostic settings operation.
+        """
+        return pulumi.get(self, "category")
+
+    @property
+    @pulumi.getter(name="retentionPolicy")
+    def retention_policy(self) -> Optional['outputs.RetentionPolicyResponse']:
+        """
+        the retention policy for this category.
+        """
+        return pulumi.get(self, "retention_policy")
+
+    @property
+    @pulumi.getter(name="timeGrain")
+    def time_grain(self) -> Optional[str]:
+        """
+        the timegrain of the metric in ISO8601 format.
+        """
+        return pulumi.get(self, "time_grain")
+
+
+@pulumi.output_type
+class MetricTriggerResponse(dict):
+    """
+    The trigger that results in a scaling action.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "metricName":
+            suggest = "metric_name"
+        elif key == "metricResourceUri":
+            suggest = "metric_resource_uri"
+        elif key == "timeAggregation":
+            suggest = "time_aggregation"
+        elif key == "timeGrain":
+            suggest = "time_grain"
+        elif key == "timeWindow":
+            suggest = "time_window"
+        elif key == "dividePerInstance":
+            suggest = "divide_per_instance"
+        elif key == "metricNamespace":
+            suggest = "metric_namespace"
+        elif key == "metricResourceLocation":
+            suggest = "metric_resource_location"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in MetricTriggerResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        MetricTriggerResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        MetricTriggerResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 metric_name: str,
+                 metric_resource_uri: str,
+                 operator: str,
+                 statistic: str,
+                 threshold: float,
+                 time_aggregation: str,
+                 time_grain: str,
+                 time_window: str,
+                 dimensions: Optional[Sequence['outputs.ScaleRuleMetricDimensionResponse']] = None,
+                 divide_per_instance: Optional[bool] = None,
+                 metric_namespace: Optional[str] = None,
+                 metric_resource_location: Optional[str] = None):
+        """
+        The trigger that results in a scaling action.
+        :param str metric_name: the name of the metric that defines what the rule monitors.
+        :param str metric_resource_uri: the resource identifier of the resource the rule monitors.
+        :param str operator: the operator that is used to compare the metric data and the threshold.
+        :param str statistic: the metric statistic type. How the metrics from multiple instances are combined.
+        :param float threshold: the threshold of the metric that triggers the scale action.
+        :param str time_aggregation: time aggregation type. How the data that is collected should be combined over time. The default value is Average.
+        :param str time_grain: the granularity of metrics the rule monitors. Must be one of the predefined values returned from metric definitions for the metric. Must be between 12 hours and 1 minute.
+        :param str time_window: the range of time in which instance data is collected. This value must be greater than the delay in metric collection, which can vary from resource-to-resource. Must be between 12 hours and 5 minutes.
+        :param Sequence['ScaleRuleMetricDimensionResponse'] dimensions: List of dimension conditions. For example: [{"DimensionName":"AppName","Operator":"Equals","Values":["App1"]},{"DimensionName":"Deployment","Operator":"Equals","Values":["default"]}].
+        :param bool divide_per_instance: a value indicating whether metric should divide per instance.
+        :param str metric_namespace: the namespace of the metric that defines what the rule monitors.
+        :param str metric_resource_location: the location of the resource the rule monitors.
+        """
+        pulumi.set(__self__, "metric_name", metric_name)
+        pulumi.set(__self__, "metric_resource_uri", metric_resource_uri)
+        pulumi.set(__self__, "operator", operator)
+        pulumi.set(__self__, "statistic", statistic)
+        pulumi.set(__self__, "threshold", threshold)
+        pulumi.set(__self__, "time_aggregation", time_aggregation)
+        pulumi.set(__self__, "time_grain", time_grain)
+        pulumi.set(__self__, "time_window", time_window)
+        if dimensions is not None:
+            pulumi.set(__self__, "dimensions", dimensions)
+        if divide_per_instance is not None:
+            pulumi.set(__self__, "divide_per_instance", divide_per_instance)
+        if metric_namespace is not None:
+            pulumi.set(__self__, "metric_namespace", metric_namespace)
+        if metric_resource_location is not None:
+            pulumi.set(__self__, "metric_resource_location", metric_resource_location)
+
+    @property
+    @pulumi.getter(name="metricName")
+    def metric_name(self) -> str:
+        """
+        the name of the metric that defines what the rule monitors.
+        """
+        return pulumi.get(self, "metric_name")
+
+    @property
+    @pulumi.getter(name="metricResourceUri")
+    def metric_resource_uri(self) -> str:
+        """
+        the resource identifier of the resource the rule monitors.
+        """
+        return pulumi.get(self, "metric_resource_uri")
+
+    @property
+    @pulumi.getter
+    def operator(self) -> str:
+        """
+        the operator that is used to compare the metric data and the threshold.
+        """
+        return pulumi.get(self, "operator")
+
+    @property
+    @pulumi.getter
+    def statistic(self) -> str:
+        """
+        the metric statistic type. How the metrics from multiple instances are combined.
+        """
+        return pulumi.get(self, "statistic")
+
+    @property
+    @pulumi.getter
+    def threshold(self) -> float:
+        """
+        the threshold of the metric that triggers the scale action.
+        """
+        return pulumi.get(self, "threshold")
+
+    @property
+    @pulumi.getter(name="timeAggregation")
+    def time_aggregation(self) -> str:
+        """
+        time aggregation type. How the data that is collected should be combined over time. The default value is Average.
+        """
+        return pulumi.get(self, "time_aggregation")
+
+    @property
+    @pulumi.getter(name="timeGrain")
+    def time_grain(self) -> str:
+        """
+        the granularity of metrics the rule monitors. Must be one of the predefined values returned from metric definitions for the metric. Must be between 12 hours and 1 minute.
+        """
+        return pulumi.get(self, "time_grain")
+
+    @property
+    @pulumi.getter(name="timeWindow")
+    def time_window(self) -> str:
+        """
+        the range of time in which instance data is collected. This value must be greater than the delay in metric collection, which can vary from resource-to-resource. Must be between 12 hours and 5 minutes.
+        """
+        return pulumi.get(self, "time_window")
+
+    @property
+    @pulumi.getter
+    def dimensions(self) -> Optional[Sequence['outputs.ScaleRuleMetricDimensionResponse']]:
+        """
+        List of dimension conditions. For example: [{"DimensionName":"AppName","Operator":"Equals","Values":["App1"]},{"DimensionName":"Deployment","Operator":"Equals","Values":["default"]}].
+        """
+        return pulumi.get(self, "dimensions")
+
+    @property
+    @pulumi.getter(name="dividePerInstance")
+    def divide_per_instance(self) -> Optional[bool]:
+        """
+        a value indicating whether metric should divide per instance.
+        """
+        return pulumi.get(self, "divide_per_instance")
+
+    @property
+    @pulumi.getter(name="metricNamespace")
+    def metric_namespace(self) -> Optional[str]:
+        """
+        the namespace of the metric that defines what the rule monitors.
+        """
+        return pulumi.get(self, "metric_namespace")
+
+    @property
+    @pulumi.getter(name="metricResourceLocation")
+    def metric_resource_location(self) -> Optional[str]:
+        """
+        the location of the resource the rule monitors.
+        """
+        return pulumi.get(self, "metric_resource_location")
+
+
+@pulumi.output_type
+class MetricsResponse(dict):
+    """
+    Information about metrics for the workspace
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "internalId":
+            suggest = "internal_id"
+        elif key == "prometheusQueryEndpoint":
+            suggest = "prometheus_query_endpoint"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in MetricsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        MetricsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        MetricsResponse.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
@@ -2571,6 +3385,59 @@ class PipelineResponse(dict):
         return pulumi.get(self, "processors")
 
 
+@pulumi.output_type
+class PredictiveAutoscalePolicyResponse(dict):
+    """
+    The parameters for enabling predictive autoscale.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "scaleMode":
+            suggest = "scale_mode"
+        elif key == "scaleLookAheadTime":
+            suggest = "scale_look_ahead_time"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PredictiveAutoscalePolicyResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PredictiveAutoscalePolicyResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PredictiveAutoscalePolicyResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 scale_mode: str,
+                 scale_look_ahead_time: Optional[str] = None):
+        """
+        The parameters for enabling predictive autoscale.
+        :param str scale_mode: the predictive autoscale mode
+        :param str scale_look_ahead_time: the amount of time to specify by which instances are launched in advance. It must be between 1 minute and 60 minutes in ISO 8601 format.
+        """
+        pulumi.set(__self__, "scale_mode", scale_mode)
+        if scale_look_ahead_time is not None:
+            pulumi.set(__self__, "scale_look_ahead_time", scale_look_ahead_time)
+
+    @property
+    @pulumi.getter(name="scaleMode")
+    def scale_mode(self) -> str:
+        """
+        the predictive autoscale mode
+        """
+        return pulumi.get(self, "scale_mode")
+
+    @property
+    @pulumi.getter(name="scaleLookAheadTime")
+    def scale_look_ahead_time(self) -> Optional[str]:
+        """
+        the amount of time to specify by which instances are launched in advance. It must be between 1 minute and 60 minutes in ISO 8601 format.
+        """
+        return pulumi.get(self, "scale_look_ahead_time")
+
+
 @pulumi.output_type
 class PrivateEndpointConnectionResponse(dict):
     """
@@ -2948,6 +3815,111 @@ class RecordMapResponse(dict):
         return pulumi.get(self, "to")
 
 
+@pulumi.output_type
+class RecurrenceResponse(dict):
+    """
+    The repeating times at which this profile begins. This element is not used if the FixedDate element is used.
+    """
+    def __init__(__self__, *,
+                 frequency: str,
+                 schedule: 'outputs.RecurrentScheduleResponse'):
+        """
+        The repeating times at which this profile begins. This element is not used if the FixedDate element is used.
+        :param str frequency: the recurrence frequency. How often the schedule profile should take effect. This value must be Week, meaning each week will have the same set of profiles. For example, to set a daily schedule, set **schedule** to every day of the week. The frequency property specifies that the schedule is repeated weekly.
+        :param 'RecurrentScheduleResponse' schedule: the scheduling constraints for when the profile begins.
+        """
+        pulumi.set(__self__, "frequency", frequency)
+        pulumi.set(__self__, "schedule", schedule)
+
+    @property
+    @pulumi.getter
+    def frequency(self) -> str:
+        """
+        the recurrence frequency. How often the schedule profile should take effect. This value must be Week, meaning each week will have the same set of profiles. For example, to set a daily schedule, set **schedule** to every day of the week. The frequency property specifies that the schedule is repeated weekly.
+        """
+        return pulumi.get(self, "frequency")
+
+    @property
+    @pulumi.getter
+    def schedule(self) -> 'outputs.RecurrentScheduleResponse':
+        """
+        the scheduling constraints for when the profile begins.
+        """
+        return pulumi.get(self, "schedule")
+
+
+@pulumi.output_type
+class RecurrentScheduleResponse(dict):
+    """
+    The scheduling constraints for when the profile begins.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "timeZone":
+            suggest = "time_zone"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in RecurrentScheduleResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        RecurrentScheduleResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        RecurrentScheduleResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 days: Sequence[str],
+                 hours: Sequence[int],
+                 minutes: Sequence[int],
+                 time_zone: str):
+        """
+        The scheduling constraints for when the profile begins.
+        :param Sequence[str] days: the collection of days that the profile takes effect on. Possible values are Sunday through Saturday.
+        :param Sequence[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[int] minutes: A collection of minutes at which the profile takes effect at.
+        :param 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[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[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[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) -> 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 ResourceMapResponse(dict):
     """
@@ -2998,6 +3970,39 @@ class ResourceMapResponse(dict):
         return pulumi.get(self, "to")
 
 
+@pulumi.output_type
+class RetentionPolicyResponse(dict):
+    """
+    Specifies the retention policy for the log.
+    """
+    def __init__(__self__, *,
+                 days: int,
+                 enabled: bool):
+        """
+        Specifies the retention policy for the log.
+        :param int days: the number of days for the retention in days. A value of 0 will retain the events indefinitely.
+        :param bool enabled: a value indicating whether the retention policy is enabled.
+        """
+        pulumi.set(__self__, "days", days)
+        pulumi.set(__self__, "enabled", enabled)
+
+    @property
+    @pulumi.getter
+    def days(self) -> int:
+        """
+        the number of days for the retention in days. A value of 0 will retain the events indefinitely.
+        """
+        return pulumi.get(self, "days")
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> bool:
+        """
+        a value indicating whether the retention policy is enabled.
+        """
+        return pulumi.get(self, "enabled")
+
+
 @pulumi.output_type
 class RuleResolveConfigurationResponse(dict):
     """
@@ -3052,6 +4057,221 @@ class RuleResolveConfigurationResponse(dict):
         return pulumi.get(self, "time_to_resolve")
 
 
+@pulumi.output_type
+class ScaleActionResponse(dict):
+    """
+    The parameters for the scaling action.
+    """
+    def __init__(__self__, *,
+                 cooldown: str,
+                 direction: str,
+                 type: str,
+                 value: Optional[str] = None):
+        """
+        The parameters for the scaling action.
+        :param str cooldown: the amount of time to wait since the last scaling action before this action occurs. It must be between 1 week and 1 minute in ISO 8601 format.
+        :param str direction: the scale direction. Whether the scaling action increases or decreases the number of instances.
+        :param str type: the type of action that should occur when the scale rule fires.
+        :param str value: the number of instances that are involved in the scaling action. This value must be 1 or greater. The default value is 1.
+        """
+        pulumi.set(__self__, "cooldown", cooldown)
+        pulumi.set(__self__, "direction", direction)
+        pulumi.set(__self__, "type", type)
+        if value is None:
+            value = '1'
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def cooldown(self) -> str:
+        """
+        the amount of time to wait since the last scaling action before this action occurs. It must be between 1 week and 1 minute in ISO 8601 format.
+        """
+        return pulumi.get(self, "cooldown")
+
+    @property
+    @pulumi.getter
+    def direction(self) -> str:
+        """
+        the scale direction. Whether the scaling action increases or decreases the number of instances.
+        """
+        return pulumi.get(self, "direction")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        the type of action that should occur when the scale rule fires.
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter
+    def value(self) -> Optional[str]:
+        """
+        the number of instances that are involved in the scaling action. This value must be 1 or greater. The default value is 1.
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class ScaleCapacityResponse(dict):
+    """
+    The number of instances that can be used during this profile.
+    """
+    def __init__(__self__, *,
+                 default: str,
+                 maximum: str,
+                 minimum: str):
+        """
+        The number of instances that can be used during this profile.
+        :param str default: the number of instances that will be set if metrics are not available for evaluation. The default is only used if the current instance count is lower than the default.
+        :param str maximum: the maximum number of instances for the resource. The actual maximum number of instances is limited by the cores that are available in the subscription.
+        :param str minimum: the minimum number of instances for the resource.
+        """
+        pulumi.set(__self__, "default", default)
+        pulumi.set(__self__, "maximum", maximum)
+        pulumi.set(__self__, "minimum", minimum)
+
+    @property
+    @pulumi.getter
+    def default(self) -> str:
+        """
+        the number of instances that will be set if metrics are not available for evaluation. The default is only used if the current instance count is lower than the default.
+        """
+        return pulumi.get(self, "default")
+
+    @property
+    @pulumi.getter
+    def maximum(self) -> str:
+        """
+        the maximum number of instances for the resource. The actual maximum number of instances is limited by the cores that are available in the subscription.
+        """
+        return pulumi.get(self, "maximum")
+
+    @property
+    @pulumi.getter
+    def minimum(self) -> str:
+        """
+        the minimum number of instances for the resource.
+        """
+        return pulumi.get(self, "minimum")
+
+
+@pulumi.output_type
+class ScaleRuleMetricDimensionResponse(dict):
+    """
+    Specifies an auto scale rule metric dimension.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dimensionName":
+            suggest = "dimension_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ScaleRuleMetricDimensionResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ScaleRuleMetricDimensionResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ScaleRuleMetricDimensionResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 dimension_name: str,
+                 operator: str,
+                 values: Sequence[str]):
+        """
+        Specifies an auto scale rule metric dimension.
+        :param str dimension_name: Name of the dimension.
+        :param str operator: the dimension operator. Only 'Equals' and 'NotEquals' are supported. 'Equals' being equal to any of the values. 'NotEquals' being not equal to all of the values
+        :param Sequence[str] values: list of dimension values. For example: ["App1","App2"].
+        """
+        pulumi.set(__self__, "dimension_name", dimension_name)
+        pulumi.set(__self__, "operator", operator)
+        pulumi.set(__self__, "values", values)
+
+    @property
+    @pulumi.getter(name="dimensionName")
+    def dimension_name(self) -> str:
+        """
+        Name of the dimension.
+        """
+        return pulumi.get(self, "dimension_name")
+
+    @property
+    @pulumi.getter
+    def operator(self) -> str:
+        """
+        the dimension operator. Only 'Equals' and 'NotEquals' are supported. 'Equals' being equal to any of the values. 'NotEquals' being not equal to all of the values
+        """
+        return pulumi.get(self, "operator")
+
+    @property
+    @pulumi.getter
+    def values(self) -> Sequence[str]:
+        """
+        list of dimension values. For example: ["App1","App2"].
+        """
+        return pulumi.get(self, "values")
+
+
+@pulumi.output_type
+class ScaleRuleResponse(dict):
+    """
+    A rule that provide the triggers and parameters for the scaling action.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "metricTrigger":
+            suggest = "metric_trigger"
+        elif key == "scaleAction":
+            suggest = "scale_action"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ScaleRuleResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ScaleRuleResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ScaleRuleResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 metric_trigger: 'outputs.MetricTriggerResponse',
+                 scale_action: 'outputs.ScaleActionResponse'):
+        """
+        A rule that provide the triggers and parameters for the scaling action.
+        :param 'MetricTriggerResponse' metric_trigger: the trigger that results in a scaling action.
+        :param 'ScaleActionResponse' scale_action: the parameters for the scaling action.
+        """
+        pulumi.set(__self__, "metric_trigger", metric_trigger)
+        pulumi.set(__self__, "scale_action", scale_action)
+
+    @property
+    @pulumi.getter(name="metricTrigger")
+    def metric_trigger(self) -> 'outputs.MetricTriggerResponse':
+        """
+        the trigger that results in a scaling action.
+        """
+        return pulumi.get(self, "metric_trigger")
+
+    @property
+    @pulumi.getter(name="scaleAction")
+    def scale_action(self) -> 'outputs.ScaleActionResponse':
+        """
+        the parameters for the scaling action.
+        """
+        return pulumi.get(self, "scale_action")
+
+
 @pulumi.output_type
 class ScheduledQueryRuleCriteriaResponse(dict):
     """
@@ -3317,6 +4537,69 @@ class SmsReceiverResponse(dict):
         return pulumi.get(self, "status")
 
 
+@pulumi.output_type
+class SubscriptionLogSettingsResponse(dict):
+    """
+    Part of Subscription diagnostic setting. Specifies the settings for a particular log.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "categoryGroup":
+            suggest = "category_group"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SubscriptionLogSettingsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SubscriptionLogSettingsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SubscriptionLogSettingsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 enabled: bool,
+                 category: Optional[str] = None,
+                 category_group: Optional[str] = None):
+        """
+        Part of Subscription diagnostic setting. Specifies the settings for a particular log.
+        :param bool enabled: a value indicating whether this log is enabled.
+        :param str category: Name of a Subscription Diagnostic Log category for a resource type this setting is applied to.
+        :param str category_group: Name of a Subscription Diagnostic Log category group for a resource type this setting is applied to.
+        """
+        pulumi.set(__self__, "enabled", enabled)
+        if category is not None:
+            pulumi.set(__self__, "category", category)
+        if category_group is not None:
+            pulumi.set(__self__, "category_group", category_group)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> bool:
+        """
+        a value indicating whether this log is enabled.
+        """
+        return pulumi.get(self, "enabled")
+
+    @property
+    @pulumi.getter
+    def category(self) -> Optional[str]:
+        """
+        Name of a Subscription Diagnostic Log category for a resource type this setting is applied to.
+        """
+        return pulumi.get(self, "category")
+
+    @property
+    @pulumi.getter(name="categoryGroup")
+    def category_group(self) -> Optional[str]:
+        """
+        Name of a Subscription Diagnostic Log category group for a resource type this setting is applied to.
+        """
+        return pulumi.get(self, "category_group")
+
+
 @pulumi.output_type
 class SyslogReceiverResponse(dict):
     """
@@ -3485,6 +4768,68 @@ class TcpExporterResponse(dict):
         return pulumi.get(self, "url")
 
 
+@pulumi.output_type
+class TimeWindowResponse(dict):
+    """
+    A specific date-time for the profile.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "timeZone":
+            suggest = "time_zone"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in TimeWindowResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        TimeWindowResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        TimeWindowResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 end: str,
+                 start: str,
+                 time_zone: Optional[str] = None):
+        """
+        A specific date-time for the profile.
+        :param str end: the end time for the profile in ISO 8601 format.
+        :param str start: the start time for the profile in ISO 8601 format.
+        :param str time_zone: the timezone of the start and end times for 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__, "end", end)
+        pulumi.set(__self__, "start", start)
+        if time_zone is not None:
+            pulumi.set(__self__, "time_zone", time_zone)
+
+    @property
+    @pulumi.getter
+    def end(self) -> str:
+        """
+        the end time for the profile in ISO 8601 format.
+        """
+        return pulumi.get(self, "end")
+
+    @property
+    @pulumi.getter
+    def start(self) -> str:
+        """
+        the start time for the profile in ISO 8601 format.
+        """
+        return pulumi.get(self, "start")
+
+    @property
+    @pulumi.getter(name="timeZone")
+    def time_zone(self) -> Optional[str]:
+        """
+        the timezone of the start and end times for 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 UdpReceiverResponse(dict):
     """
@@ -3733,6 +5078,58 @@ class VoiceReceiverResponse(dict):
         return pulumi.get(self, "phone_number")
 
 
+@pulumi.output_type
+class WebhookNotificationResponse(dict):
+    """
+    Webhook notification of an autoscale event.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "serviceUri":
+            suggest = "service_uri"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WebhookNotificationResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WebhookNotificationResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WebhookNotificationResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 properties: Optional[Mapping[str, str]] = None,
+                 service_uri: Optional[str] = None):
+        """
+        Webhook notification of an autoscale event.
+        :param Mapping[str, str] properties: a property bag of settings. This value can be empty.
+        :param str service_uri: the service address to receive the notification.
+        """
+        if properties is not None:
+            pulumi.set(__self__, "properties", properties)
+        if service_uri is not None:
+            pulumi.set(__self__, "service_uri", service_uri)
+
+    @property
+    @pulumi.getter
+    def properties(self) -> Optional[Mapping[str, str]]:
+        """
+        a property bag of settings. This value can be empty.
+        """
+        return pulumi.get(self, "properties")
+
+    @property
+    @pulumi.getter(name="serviceUri")
+    def service_uri(self) -> Optional[str]:
+        """
+        the service address to receive the notification.
+        """
+        return pulumi.get(self, "service_uri")
+
+
 @pulumi.output_type
 class WebhookReceiverResponse(dict):
     """