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

pulumi_azure_native/monitor/_inputs.py

@@ -26,6 +26,10 @@ __all__ = [
     'ArmRoleReceiverArgsDict',
     'AutomationRunbookReceiverArgs',
     'AutomationRunbookReceiverArgsDict',
+    'AutoscaleNotificationArgs',
+    'AutoscaleNotificationArgsDict',
+    'AutoscaleProfileArgs',
+    'AutoscaleProfileArgsDict',
     'AzureAppPushReceiverArgs',
     'AzureAppPushReceiverArgsDict',
     'AzureFunctionReceiverArgs',
@@ -48,6 +52,8 @@ __all__ = [
     'ConditionArgsDict',
     'DimensionArgs',
     'DimensionArgsDict',
+    'EmailNotificationArgs',
+    'EmailNotificationArgsDict',
     'EmailReceiverArgs',
     'EmailReceiverArgsDict',
     'EventHubReceiverArgs',
@@ -68,10 +74,18 @@ __all__ = [
     'JsonMapperDestinationFieldArgsDict',
     'JsonMapperSourceFieldArgs',
     'JsonMapperSourceFieldArgsDict',
+    'LogSettingsArgs',
+    'LogSettingsArgsDict',
     'LogicAppReceiverArgs',
     'LogicAppReceiverArgsDict',
     'ManagedServiceIdentityArgs',
     'ManagedServiceIdentityArgsDict',
+    'ManagementGroupLogSettingsArgs',
+    'ManagementGroupLogSettingsArgsDict',
+    'MetricSettingsArgs',
+    'MetricSettingsArgsDict',
+    'MetricTriggerArgs',
+    'MetricTriggerArgsDict',
     'NetworkingConfigurationArgs',
     'NetworkingConfigurationArgsDict',
     'NetworkingRouteArgs',
@@ -84,6 +98,8 @@ __all__ = [
     'PipelineGroupPropertiesArgsDict',
     'PipelineArgs',
     'PipelineArgsDict',
+    'PredictiveAutoscalePolicyArgs',
+    'PredictiveAutoscalePolicyArgsDict',
     'PrivateLinkServiceConnectionStateArgs',
     'PrivateLinkServiceConnectionStateArgsDict',
     'ProcessorArgs',
@@ -92,10 +108,24 @@ __all__ = [
     'ReceiverArgsDict',
     'RecordMapArgs',
     'RecordMapArgsDict',
+    'RecurrenceArgs',
+    'RecurrenceArgsDict',
+    'RecurrentScheduleArgs',
+    'RecurrentScheduleArgsDict',
     'ResourceMapArgs',
     'ResourceMapArgsDict',
+    'RetentionPolicyArgs',
+    'RetentionPolicyArgsDict',
     'RuleResolveConfigurationArgs',
     'RuleResolveConfigurationArgsDict',
+    'ScaleActionArgs',
+    'ScaleActionArgsDict',
+    'ScaleCapacityArgs',
+    'ScaleCapacityArgsDict',
+    'ScaleRuleMetricDimensionArgs',
+    'ScaleRuleMetricDimensionArgsDict',
+    'ScaleRuleArgs',
+    'ScaleRuleArgsDict',
     'ScheduledQueryRuleCriteriaArgs',
     'ScheduledQueryRuleCriteriaArgsDict',
     'SchemaMapArgs',
@@ -106,14 +136,20 @@ __all__ = [
     'ServiceArgsDict',
     'SmsReceiverArgs',
     'SmsReceiverArgsDict',
+    'SubscriptionLogSettingsArgs',
+    'SubscriptionLogSettingsArgsDict',
     'SyslogReceiverArgs',
     'SyslogReceiverArgsDict',
     'TcpExporterArgs',
     'TcpExporterArgsDict',
+    'TimeWindowArgs',
+    'TimeWindowArgsDict',
     'UdpReceiverArgs',
     'UdpReceiverArgsDict',
     'VoiceReceiverArgs',
     'VoiceReceiverArgsDict',
+    'WebhookNotificationArgs',
+    'WebhookNotificationArgsDict',
     'WebhookReceiverArgs',
     'WebhookReceiverArgsDict',
 ]
@@ -596,6 +632,194 @@ class AutomationRunbookReceiverArgs:
         pulumi.set(self, "use_common_alert_schema", value)
 
 
+if not MYPY:
+    class AutoscaleNotificationArgsDict(TypedDict):
+        """
+        Autoscale notification.
+        """
+        operation: pulumi.Input['OperationType']
+        """
+        the operation associated with the notification and its value must be "scale"
+        """
+        email: NotRequired[pulumi.Input['EmailNotificationArgsDict']]
+        """
+        the email notification.
+        """
+        webhooks: NotRequired[pulumi.Input[Sequence[pulumi.Input['WebhookNotificationArgsDict']]]]
+        """
+        the collection of webhook notifications.
+        """
+elif False:
+    AutoscaleNotificationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AutoscaleNotificationArgs:
+    def __init__(__self__, *,
+                 operation: pulumi.Input['OperationType'],
+                 email: Optional[pulumi.Input['EmailNotificationArgs']] = None,
+                 webhooks: Optional[pulumi.Input[Sequence[pulumi.Input['WebhookNotificationArgs']]]] = None):
+        """
+        Autoscale notification.
+        :param pulumi.Input['OperationType'] operation: the operation associated with the notification and its value must be "scale"
+        :param pulumi.Input['EmailNotificationArgs'] email: the email notification.
+        :param pulumi.Input[Sequence[pulumi.Input['WebhookNotificationArgs']]] 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) -> pulumi.Input['OperationType']:
+        """
+        the operation associated with the notification and its value must be "scale"
+        """
+        return pulumi.get(self, "operation")
+
+    @operation.setter
+    def operation(self, value: pulumi.Input['OperationType']):
+        pulumi.set(self, "operation", value)
+
+    @property
+    @pulumi.getter
+    def email(self) -> Optional[pulumi.Input['EmailNotificationArgs']]:
+        """
+        the email notification.
+        """
+        return pulumi.get(self, "email")
+
+    @email.setter
+    def email(self, value: Optional[pulumi.Input['EmailNotificationArgs']]):
+        pulumi.set(self, "email", value)
+
+    @property
+    @pulumi.getter
+    def webhooks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['WebhookNotificationArgs']]]]:
+        """
+        the collection of webhook notifications.
+        """
+        return pulumi.get(self, "webhooks")
+
+    @webhooks.setter
+    def webhooks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['WebhookNotificationArgs']]]]):
+        pulumi.set(self, "webhooks", value)
+
+
+if not MYPY:
+    class AutoscaleProfileArgsDict(TypedDict):
+        """
+        Autoscale profile.
+        """
+        capacity: pulumi.Input['ScaleCapacityArgsDict']
+        """
+        the number of instances that can be used during this profile.
+        """
+        name: pulumi.Input[str]
+        """
+        the name of the profile.
+        """
+        rules: pulumi.Input[Sequence[pulumi.Input['ScaleRuleArgsDict']]]
+        """
+        the collection of rules that provide the triggers and parameters for the scaling action. A maximum of 10 rules can be specified.
+        """
+        fixed_date: NotRequired[pulumi.Input['TimeWindowArgsDict']]
+        """
+        the specific date-time for the profile. This element is not used if the Recurrence element is used.
+        """
+        recurrence: NotRequired[pulumi.Input['RecurrenceArgsDict']]
+        """
+        the repeating times at which this profile begins. This element is not used if the FixedDate element is used.
+        """
+elif False:
+    AutoscaleProfileArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AutoscaleProfileArgs:
+    def __init__(__self__, *,
+                 capacity: pulumi.Input['ScaleCapacityArgs'],
+                 name: pulumi.Input[str],
+                 rules: pulumi.Input[Sequence[pulumi.Input['ScaleRuleArgs']]],
+                 fixed_date: Optional[pulumi.Input['TimeWindowArgs']] = None,
+                 recurrence: Optional[pulumi.Input['RecurrenceArgs']] = None):
+        """
+        Autoscale profile.
+        :param pulumi.Input['ScaleCapacityArgs'] capacity: the number of instances that can be used during this profile.
+        :param pulumi.Input[str] name: the name of the profile.
+        :param pulumi.Input[Sequence[pulumi.Input['ScaleRuleArgs']]] rules: the collection of rules that provide the triggers and parameters for the scaling action. A maximum of 10 rules can be specified.
+        :param pulumi.Input['TimeWindowArgs'] fixed_date: the specific date-time for the profile. This element is not used if the Recurrence element is used.
+        :param pulumi.Input['RecurrenceArgs'] 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) -> pulumi.Input['ScaleCapacityArgs']:
+        """
+        the number of instances that can be used during this profile.
+        """
+        return pulumi.get(self, "capacity")
+
+    @capacity.setter
+    def capacity(self, value: pulumi.Input['ScaleCapacityArgs']):
+        pulumi.set(self, "capacity", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[str]:
+        """
+        the name of the profile.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def rules(self) -> pulumi.Input[Sequence[pulumi.Input['ScaleRuleArgs']]]:
+        """
+        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")
+
+    @rules.setter
+    def rules(self, value: pulumi.Input[Sequence[pulumi.Input['ScaleRuleArgs']]]):
+        pulumi.set(self, "rules", value)
+
+    @property
+    @pulumi.getter(name="fixedDate")
+    def fixed_date(self) -> Optional[pulumi.Input['TimeWindowArgs']]:
+        """
+        the specific date-time for the profile. This element is not used if the Recurrence element is used.
+        """
+        return pulumi.get(self, "fixed_date")
+
+    @fixed_date.setter
+    def fixed_date(self, value: Optional[pulumi.Input['TimeWindowArgs']]):
+        pulumi.set(self, "fixed_date", value)
+
+    @property
+    @pulumi.getter
+    def recurrence(self) -> Optional[pulumi.Input['RecurrenceArgs']]:
+        """
+        the repeating times at which this profile begins. This element is not used if the FixedDate element is used.
+        """
+        return pulumi.get(self, "recurrence")
+
+    @recurrence.setter
+    def recurrence(self, value: Optional[pulumi.Input['RecurrenceArgs']]):
+        pulumi.set(self, "recurrence", value)
+
+
 if not MYPY:
     class AzureAppPushReceiverArgsDict(TypedDict):
         """
@@ -1570,6 +1794,86 @@ class DimensionArgs:
         pulumi.set(self, "values", value)
 
 
+if not MYPY:
+    class EmailNotificationArgsDict(TypedDict):
+        """
+        Email notification of an autoscale event.
+        """
+        custom_emails: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        the custom e-mails list. This value can be null or empty, in which case this attribute will be ignored.
+        """
+        send_to_subscription_administrator: NotRequired[pulumi.Input[bool]]
+        """
+        a value indicating whether to send email to subscription administrator.
+        """
+        send_to_subscription_co_administrators: NotRequired[pulumi.Input[bool]]
+        """
+        a value indicating whether to send email to subscription co-administrators.
+        """
+elif False:
+    EmailNotificationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class EmailNotificationArgs:
+    def __init__(__self__, *,
+                 custom_emails: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 send_to_subscription_administrator: Optional[pulumi.Input[bool]] = None,
+                 send_to_subscription_co_administrators: Optional[pulumi.Input[bool]] = None):
+        """
+        Email notification of an autoscale event.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] custom_emails: the custom e-mails list. This value can be null or empty, in which case this attribute will be ignored.
+        :param pulumi.Input[bool] send_to_subscription_administrator: a value indicating whether to send email to subscription administrator.
+        :param pulumi.Input[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[pulumi.Input[Sequence[pulumi.Input[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")
+
+    @custom_emails.setter
+    def custom_emails(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "custom_emails", value)
+
+    @property
+    @pulumi.getter(name="sendToSubscriptionAdministrator")
+    def send_to_subscription_administrator(self) -> Optional[pulumi.Input[bool]]:
+        """
+        a value indicating whether to send email to subscription administrator.
+        """
+        return pulumi.get(self, "send_to_subscription_administrator")
+
+    @send_to_subscription_administrator.setter
+    def send_to_subscription_administrator(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "send_to_subscription_administrator", value)
+
+    @property
+    @pulumi.getter(name="sendToSubscriptionCoAdministrators")
+    def send_to_subscription_co_administrators(self) -> Optional[pulumi.Input[bool]]:
+        """
+        a value indicating whether to send email to subscription co-administrators.
+        """
+        return pulumi.get(self, "send_to_subscription_co_administrators")
+
+    @send_to_subscription_co_administrators.setter
+    def send_to_subscription_co_administrators(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "send_to_subscription_co_administrators", value)
+
+
 if not MYPY:
     class EmailReceiverArgsDict(TypedDict):
         """
@@ -2375,6 +2679,101 @@ class JsonMapperSourceFieldArgs:
         pulumi.set(self, "field_name", value)
 
 
+if not MYPY:
+    class LogSettingsArgsDict(TypedDict):
+        """
+        Part of MultiTenantDiagnosticSettings. Specifies the settings for a particular log.
+        """
+        enabled: pulumi.Input[bool]
+        """
+        a value indicating whether this log is enabled.
+        """
+        category: NotRequired[pulumi.Input[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.
+        """
+        category_group: NotRequired[pulumi.Input[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.
+        """
+        retention_policy: NotRequired[pulumi.Input['RetentionPolicyArgsDict']]
+        """
+        the retention policy for this log.
+        """
+elif False:
+    LogSettingsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class LogSettingsArgs:
+    def __init__(__self__, *,
+                 enabled: pulumi.Input[bool],
+                 category: Optional[pulumi.Input[str]] = None,
+                 category_group: Optional[pulumi.Input[str]] = None,
+                 retention_policy: Optional[pulumi.Input['RetentionPolicyArgs']] = None):
+        """
+        Part of MultiTenantDiagnosticSettings. Specifies the settings for a particular log.
+        :param pulumi.Input[bool] enabled: a value indicating whether this log is enabled.
+        :param pulumi.Input[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 pulumi.Input[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 pulumi.Input['RetentionPolicyArgs'] 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) -> pulumi.Input[bool]:
+        """
+        a value indicating whether this log is enabled.
+        """
+        return pulumi.get(self, "enabled")
+
+    @enabled.setter
+    def enabled(self, value: pulumi.Input[bool]):
+        pulumi.set(self, "enabled", value)
+
+    @property
+    @pulumi.getter
+    def category(self) -> Optional[pulumi.Input[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")
+
+    @category.setter
+    def category(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "category", value)
+
+    @property
+    @pulumi.getter(name="categoryGroup")
+    def category_group(self) -> Optional[pulumi.Input[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")
+
+    @category_group.setter
+    def category_group(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "category_group", value)
+
+    @property
+    @pulumi.getter(name="retentionPolicy")
+    def retention_policy(self) -> Optional[pulumi.Input['RetentionPolicyArgs']]:
+        """
+        the retention policy for this log.
+        """
+        return pulumi.get(self, "retention_policy")
+
+    @retention_policy.setter
+    def retention_policy(self, value: Optional[pulumi.Input['RetentionPolicyArgs']]):
+        pulumi.set(self, "retention_policy", value)
+
+
 if not MYPY:
     class LogicAppReceiverArgsDict(TypedDict):
         """
@@ -2546,914 +2945,1882 @@ class ManagedServiceIdentityArgs:
 
 
 if not MYPY:
-    class NetworkingConfigurationArgsDict(TypedDict):
+    class ManagementGroupLogSettingsArgsDict(TypedDict):
         """
-        Networking configuration for the pipeline group instance.
+        Part of Management Group diagnostic setting. Specifies the settings for a particular log.
         """
-        external_networking_mode: pulumi.Input[Union[str, 'ExternalNetworkingMode']]
+        enabled: pulumi.Input[bool]
         """
-        External networking mode.
+        a value indicating whether this log is enabled.
         """
-        routes: pulumi.Input[Sequence[pulumi.Input['NetworkingRouteArgsDict']]]
+        category: NotRequired[pulumi.Input[str]]
         """
-        Networking routes configuration.
+        Name of a Management Group Diagnostic Log category for a resource type this setting is applied to.
         """
-        host: NotRequired[pulumi.Input[str]]
+        category_group: NotRequired[pulumi.Input[str]]
         """
-        The address exposed on the cluster. Example: azuremonitorpipeline.contoso.com.
+        Name of a Management Group Diagnostic Log category group for a resource type this setting is applied to.
         """
 elif False:
-    NetworkingConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+    ManagementGroupLogSettingsArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class NetworkingConfigurationArgs:
+class ManagementGroupLogSettingsArgs:
     def __init__(__self__, *,
-                 external_networking_mode: pulumi.Input[Union[str, 'ExternalNetworkingMode']],
-                 routes: pulumi.Input[Sequence[pulumi.Input['NetworkingRouteArgs']]],
-                 host: Optional[pulumi.Input[str]] = None):
+                 enabled: pulumi.Input[bool],
+                 category: Optional[pulumi.Input[str]] = None,
+                 category_group: Optional[pulumi.Input[str]] = None):
         """
-        Networking configuration for the pipeline group instance.
-        :param pulumi.Input[Union[str, 'ExternalNetworkingMode']] external_networking_mode: External networking mode.
-        :param pulumi.Input[Sequence[pulumi.Input['NetworkingRouteArgs']]] routes: Networking routes configuration.
-        :param pulumi.Input[str] host: The address exposed on the cluster. Example: azuremonitorpipeline.contoso.com.
+        Part of Management Group diagnostic setting. Specifies the settings for a particular log.
+        :param pulumi.Input[bool] enabled: a value indicating whether this log is enabled.
+        :param pulumi.Input[str] category: Name of a Management Group Diagnostic Log category for a resource type this setting is applied to.
+        :param pulumi.Input[str] category_group: Name of a Management Group Diagnostic Log category group for a resource type this setting is applied to.
         """
-        pulumi.set(__self__, "external_networking_mode", external_networking_mode)
-        pulumi.set(__self__, "routes", routes)
-        if host is not None:
-            pulumi.set(__self__, "host", host)
+        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(name="externalNetworkingMode")
-    def external_networking_mode(self) -> pulumi.Input[Union[str, 'ExternalNetworkingMode']]:
+    @pulumi.getter
+    def enabled(self) -> pulumi.Input[bool]:
         """
-        External networking mode.
+        a value indicating whether this log is enabled.
         """
-        return pulumi.get(self, "external_networking_mode")
+        return pulumi.get(self, "enabled")
 
-    @external_networking_mode.setter
-    def external_networking_mode(self, value: pulumi.Input[Union[str, 'ExternalNetworkingMode']]):
-        pulumi.set(self, "external_networking_mode", value)
+    @enabled.setter
+    def enabled(self, value: pulumi.Input[bool]):
+        pulumi.set(self, "enabled", value)
 
     @property
     @pulumi.getter
-    def routes(self) -> pulumi.Input[Sequence[pulumi.Input['NetworkingRouteArgs']]]:
+    def category(self) -> Optional[pulumi.Input[str]]:
         """
-        Networking routes configuration.
+        Name of a Management Group Diagnostic Log category for a resource type this setting is applied to.
         """
-        return pulumi.get(self, "routes")
+        return pulumi.get(self, "category")
 
-    @routes.setter
-    def routes(self, value: pulumi.Input[Sequence[pulumi.Input['NetworkingRouteArgs']]]):
-        pulumi.set(self, "routes", value)
+    @category.setter
+    def category(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "category", value)
 
     @property
-    @pulumi.getter
-    def host(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter(name="categoryGroup")
+    def category_group(self) -> Optional[pulumi.Input[str]]:
         """
-        The address exposed on the cluster. Example: azuremonitorpipeline.contoso.com.
+        Name of a Management Group Diagnostic Log category group for a resource type this setting is applied to.
         """
-        return pulumi.get(self, "host")
+        return pulumi.get(self, "category_group")
 
-    @host.setter
-    def host(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "host", value)
+    @category_group.setter
+    def category_group(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "category_group", value)
 
 
 if not MYPY:
-    class NetworkingRouteArgsDict(TypedDict):
+    class MetricSettingsArgsDict(TypedDict):
         """
-        Networking route configuration.
+        Part of MultiTenantDiagnosticSettings. Specifies the settings for a particular metric.
         """
-        receiver: pulumi.Input[str]
+        enabled: pulumi.Input[bool]
         """
-        The name of the previously defined receiver.
+        a value indicating whether this category is enabled.
         """
-        path: NotRequired[pulumi.Input[str]]
+        category: NotRequired[pulumi.Input[str]]
         """
-        Route path.
+        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.
         """
-        port: NotRequired[pulumi.Input[int]]
+        retention_policy: NotRequired[pulumi.Input['RetentionPolicyArgsDict']]
         """
-        The port that will be configured externally. If not specified, it will use the port from the receiver definition.
+        the retention policy for this category.
         """
-        subdomain: NotRequired[pulumi.Input[str]]
+        time_grain: NotRequired[pulumi.Input[str]]
         """
-        Route subdomain.
+        the timegrain of the metric in ISO8601 format.
         """
 elif False:
-    NetworkingRouteArgsDict: TypeAlias = Mapping[str, Any]
+    MetricSettingsArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class NetworkingRouteArgs:
+class MetricSettingsArgs:
     def __init__(__self__, *,
-                 receiver: pulumi.Input[str],
-                 path: Optional[pulumi.Input[str]] = None,
-                 port: Optional[pulumi.Input[int]] = None,
-                 subdomain: Optional[pulumi.Input[str]] = None):
-        """
-        Networking route configuration.
-        :param pulumi.Input[str] receiver: The name of the previously defined receiver.
-        :param pulumi.Input[str] path: Route path.
-        :param pulumi.Input[int] port: The port that will be configured externally. If not specified, it will use the port from the receiver definition.
-        :param pulumi.Input[str] subdomain: Route subdomain.
-        """
-        pulumi.set(__self__, "receiver", receiver)
-        if path is not None:
-            pulumi.set(__self__, "path", path)
-        if port is not None:
-            pulumi.set(__self__, "port", port)
-        if subdomain is not None:
-            pulumi.set(__self__, "subdomain", subdomain)
+                 enabled: pulumi.Input[bool],
+                 category: Optional[pulumi.Input[str]] = None,
+                 retention_policy: Optional[pulumi.Input['RetentionPolicyArgs']] = None,
+                 time_grain: Optional[pulumi.Input[str]] = None):
+        """
+        Part of MultiTenantDiagnosticSettings. Specifies the settings for a particular metric.
+        :param pulumi.Input[bool] enabled: a value indicating whether this category is enabled.
+        :param pulumi.Input[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 pulumi.Input['RetentionPolicyArgs'] retention_policy: the retention policy for this category.
+        :param pulumi.Input[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 receiver(self) -> pulumi.Input[str]:
+    def enabled(self) -> pulumi.Input[bool]:
         """
-        The name of the previously defined receiver.
+        a value indicating whether this category is enabled.
         """
-        return pulumi.get(self, "receiver")
+        return pulumi.get(self, "enabled")
 
-    @receiver.setter
-    def receiver(self, value: pulumi.Input[str]):
-        pulumi.set(self, "receiver", value)
+    @enabled.setter
+    def enabled(self, value: pulumi.Input[bool]):
+        pulumi.set(self, "enabled", value)
 
     @property
     @pulumi.getter
-    def path(self) -> Optional[pulumi.Input[str]]:
+    def category(self) -> Optional[pulumi.Input[str]]:
         """
-        Route path.
+        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, "path")
+        return pulumi.get(self, "category")
 
-    @path.setter
-    def path(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "path", value)
+    @category.setter
+    def category(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "category", value)
 
     @property
-    @pulumi.getter
-    def port(self) -> Optional[pulumi.Input[int]]:
+    @pulumi.getter(name="retentionPolicy")
+    def retention_policy(self) -> Optional[pulumi.Input['RetentionPolicyArgs']]:
         """
-        The port that will be configured externally. If not specified, it will use the port from the receiver definition.
+        the retention policy for this category.
         """
-        return pulumi.get(self, "port")
+        return pulumi.get(self, "retention_policy")
 
-    @port.setter
-    def port(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "port", value)
+    @retention_policy.setter
+    def retention_policy(self, value: Optional[pulumi.Input['RetentionPolicyArgs']]):
+        pulumi.set(self, "retention_policy", value)
 
     @property
-    @pulumi.getter
-    def subdomain(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter(name="timeGrain")
+    def time_grain(self) -> Optional[pulumi.Input[str]]:
         """
-        Route subdomain.
+        the timegrain of the metric in ISO8601 format.
         """
-        return pulumi.get(self, "subdomain")
+        return pulumi.get(self, "time_grain")
 
-    @subdomain.setter
-    def subdomain(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "subdomain", value)
+    @time_grain.setter
+    def time_grain(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "time_grain", value)
 
 
 if not MYPY:
-    class OtlpReceiverArgsDict(TypedDict):
-        """
-        OTLP Receiver.
-        """
-        endpoint: pulumi.Input[str]
-        """
-        OTLP GRPC endpoint definition. Example: 0.0.0.0:<port>.
-        """
-elif False:
-    OtlpReceiverArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class OtlpReceiverArgs:
-    def __init__(__self__, *,
-                 endpoint: pulumi.Input[str]):
+    class MetricTriggerArgsDict(TypedDict):
         """
-        OTLP Receiver.
-        :param pulumi.Input[str] endpoint: OTLP GRPC endpoint definition. Example: 0.0.0.0:<port>.
+        The trigger that results in a scaling action.
         """
-        pulumi.set(__self__, "endpoint", endpoint)
-
-    @property
-    @pulumi.getter
-    def endpoint(self) -> pulumi.Input[str]:
+        metric_name: pulumi.Input[str]
         """
-        OTLP GRPC endpoint definition. Example: 0.0.0.0:<port>.
+        the name of the metric that defines what the rule monitors.
         """
-        return pulumi.get(self, "endpoint")
-
-    @endpoint.setter
-    def endpoint(self, value: pulumi.Input[str]):
-        pulumi.set(self, "endpoint", value)
-
-
-if not MYPY:
-    class PersistenceConfigurationsArgsDict(TypedDict):
+        metric_resource_uri: pulumi.Input[str]
         """
-        Persistence options to all pipelines in the instance.
+        the resource identifier of the resource the rule monitors.
         """
-        persistent_volume_name: pulumi.Input[str]
+        operator: pulumi.Input['ComparisonOperationType']
         """
-        The name of the mounted persistent volume.
+        the operator that is used to compare the metric data and the threshold.
         """
-elif False:
-    PersistenceConfigurationsArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class PersistenceConfigurationsArgs:
-    def __init__(__self__, *,
-                 persistent_volume_name: pulumi.Input[str]):
+        statistic: pulumi.Input['MetricStatisticType']
         """
-        Persistence options to all pipelines in the instance.
-        :param pulumi.Input[str] persistent_volume_name: The name of the mounted persistent volume.
+        the metric statistic type. How the metrics from multiple instances are combined.
         """
-        pulumi.set(__self__, "persistent_volume_name", persistent_volume_name)
-
-    @property
-    @pulumi.getter(name="persistentVolumeName")
-    def persistent_volume_name(self) -> pulumi.Input[str]:
+        threshold: pulumi.Input[float]
         """
-        The name of the mounted persistent volume.
+        the threshold of the metric that triggers the scale action.
         """
-        return pulumi.get(self, "persistent_volume_name")
-
-    @persistent_volume_name.setter
-    def persistent_volume_name(self, value: pulumi.Input[str]):
-        pulumi.set(self, "persistent_volume_name", value)
-
-
-if not MYPY:
-    class PipelineGroupPropertiesArgsDict(TypedDict):
+        time_aggregation: pulumi.Input['TimeAggregationType']
         """
-        Properties that need to be specified to create a new pipeline group instance.
+        time aggregation type. How the data that is collected should be combined over time. The default value is Average.
         """
-        exporters: pulumi.Input[Sequence[pulumi.Input['ExporterArgsDict']]]
+        time_grain: pulumi.Input[str]
         """
-        The exporters specified for a pipeline group instance.
+        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.
         """
-        processors: pulumi.Input[Sequence[pulumi.Input['ProcessorArgsDict']]]
+        time_window: pulumi.Input[str]
         """
-        The processors specified for a pipeline group instance.
+        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.
         """
-        receivers: pulumi.Input[Sequence[pulumi.Input['ReceiverArgsDict']]]
+        dimensions: NotRequired[pulumi.Input[Sequence[pulumi.Input['ScaleRuleMetricDimensionArgsDict']]]]
         """
-        The receivers specified for a pipeline group instance.
+        List of dimension conditions. For example: [{"DimensionName":"AppName","Operator":"Equals","Values":["App1"]},{"DimensionName":"Deployment","Operator":"Equals","Values":["default"]}].
         """
-        service: pulumi.Input['ServiceArgsDict']
+        divide_per_instance: NotRequired[pulumi.Input[bool]]
         """
-        The service section for a given pipeline group instance.
+        a value indicating whether metric should divide per instance.
         """
-        networking_configurations: NotRequired[pulumi.Input[Sequence[pulumi.Input['NetworkingConfigurationArgsDict']]]]
+        metric_namespace: NotRequired[pulumi.Input[str]]
         """
-        Networking configurations for the pipeline group instance.
+        the namespace of the metric that defines what the rule monitors.
         """
-        replicas: NotRequired[pulumi.Input[int]]
+        metric_resource_location: NotRequired[pulumi.Input[str]]
         """
-        Defines the amount of replicas of the pipeline group instance.
+        the location of the resource the rule monitors.
         """
 elif False:
-    PipelineGroupPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+    MetricTriggerArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class PipelineGroupPropertiesArgs:
+class MetricTriggerArgs:
     def __init__(__self__, *,
-                 exporters: pulumi.Input[Sequence[pulumi.Input['ExporterArgs']]],
-                 processors: pulumi.Input[Sequence[pulumi.Input['ProcessorArgs']]],
-                 receivers: pulumi.Input[Sequence[pulumi.Input['ReceiverArgs']]],
-                 service: pulumi.Input['ServiceArgs'],
-                 networking_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['NetworkingConfigurationArgs']]]] = None,
-                 replicas: Optional[pulumi.Input[int]] = None):
-        """
-        Properties that need to be specified to create a new pipeline group instance.
-        :param pulumi.Input[Sequence[pulumi.Input['ExporterArgs']]] exporters: The exporters specified for a pipeline group instance.
-        :param pulumi.Input[Sequence[pulumi.Input['ProcessorArgs']]] processors: The processors specified for a pipeline group instance.
-        :param pulumi.Input[Sequence[pulumi.Input['ReceiverArgs']]] receivers: The receivers specified for a pipeline group instance.
-        :param pulumi.Input['ServiceArgs'] service: The service section for a given pipeline group instance.
-        :param pulumi.Input[Sequence[pulumi.Input['NetworkingConfigurationArgs']]] networking_configurations: Networking configurations for the pipeline group instance.
-        :param pulumi.Input[int] replicas: Defines the amount of replicas of the pipeline group instance.
-        """
-        pulumi.set(__self__, "exporters", exporters)
-        pulumi.set(__self__, "processors", processors)
-        pulumi.set(__self__, "receivers", receivers)
-        pulumi.set(__self__, "service", service)
-        if networking_configurations is not None:
-            pulumi.set(__self__, "networking_configurations", networking_configurations)
-        if replicas is not None:
-            pulumi.set(__self__, "replicas", replicas)
+                 metric_name: pulumi.Input[str],
+                 metric_resource_uri: pulumi.Input[str],
+                 operator: pulumi.Input['ComparisonOperationType'],
+                 statistic: pulumi.Input['MetricStatisticType'],
+                 threshold: pulumi.Input[float],
+                 time_aggregation: pulumi.Input['TimeAggregationType'],
+                 time_grain: pulumi.Input[str],
+                 time_window: pulumi.Input[str],
+                 dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ScaleRuleMetricDimensionArgs']]]] = None,
+                 divide_per_instance: Optional[pulumi.Input[bool]] = None,
+                 metric_namespace: Optional[pulumi.Input[str]] = None,
+                 metric_resource_location: Optional[pulumi.Input[str]] = None):
+        """
+        The trigger that results in a scaling action.
+        :param pulumi.Input[str] metric_name: the name of the metric that defines what the rule monitors.
+        :param pulumi.Input[str] metric_resource_uri: the resource identifier of the resource the rule monitors.
+        :param pulumi.Input['ComparisonOperationType'] operator: the operator that is used to compare the metric data and the threshold.
+        :param pulumi.Input['MetricStatisticType'] statistic: the metric statistic type. How the metrics from multiple instances are combined.
+        :param pulumi.Input[float] threshold: the threshold of the metric that triggers the scale action.
+        :param pulumi.Input['TimeAggregationType'] time_aggregation: time aggregation type. How the data that is collected should be combined over time. The default value is Average.
+        :param pulumi.Input[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 pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input['ScaleRuleMetricDimensionArgs']]] dimensions: List of dimension conditions. For example: [{"DimensionName":"AppName","Operator":"Equals","Values":["App1"]},{"DimensionName":"Deployment","Operator":"Equals","Values":["default"]}].
+        :param pulumi.Input[bool] divide_per_instance: a value indicating whether metric should divide per instance.
+        :param pulumi.Input[str] metric_namespace: the namespace of the metric that defines what the rule monitors.
+        :param pulumi.Input[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
-    def exporters(self) -> pulumi.Input[Sequence[pulumi.Input['ExporterArgs']]]:
+    @pulumi.getter(name="metricName")
+    def metric_name(self) -> pulumi.Input[str]:
         """
-        The exporters specified for a pipeline group instance.
+        the name of the metric that defines what the rule monitors.
         """
-        return pulumi.get(self, "exporters")
+        return pulumi.get(self, "metric_name")
 
-    @exporters.setter
-    def exporters(self, value: pulumi.Input[Sequence[pulumi.Input['ExporterArgs']]]):
-        pulumi.set(self, "exporters", value)
+    @metric_name.setter
+    def metric_name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "metric_name", value)
 
     @property
-    @pulumi.getter
-    def processors(self) -> pulumi.Input[Sequence[pulumi.Input['ProcessorArgs']]]:
+    @pulumi.getter(name="metricResourceUri")
+    def metric_resource_uri(self) -> pulumi.Input[str]:
         """
-        The processors specified for a pipeline group instance.
+        the resource identifier of the resource the rule monitors.
         """
-        return pulumi.get(self, "processors")
+        return pulumi.get(self, "metric_resource_uri")
 
-    @processors.setter
-    def processors(self, value: pulumi.Input[Sequence[pulumi.Input['ProcessorArgs']]]):
-        pulumi.set(self, "processors", value)
+    @metric_resource_uri.setter
+    def metric_resource_uri(self, value: pulumi.Input[str]):
+        pulumi.set(self, "metric_resource_uri", value)
 
     @property
     @pulumi.getter
-    def receivers(self) -> pulumi.Input[Sequence[pulumi.Input['ReceiverArgs']]]:
+    def operator(self) -> pulumi.Input['ComparisonOperationType']:
         """
-        The receivers specified for a pipeline group instance.
+        the operator that is used to compare the metric data and the threshold.
         """
-        return pulumi.get(self, "receivers")
+        return pulumi.get(self, "operator")
 
-    @receivers.setter
-    def receivers(self, value: pulumi.Input[Sequence[pulumi.Input['ReceiverArgs']]]):
-        pulumi.set(self, "receivers", value)
+    @operator.setter
+    def operator(self, value: pulumi.Input['ComparisonOperationType']):
+        pulumi.set(self, "operator", value)
 
     @property
     @pulumi.getter
-    def service(self) -> pulumi.Input['ServiceArgs']:
+    def statistic(self) -> pulumi.Input['MetricStatisticType']:
         """
-        The service section for a given pipeline group instance.
+        the metric statistic type. How the metrics from multiple instances are combined.
         """
-        return pulumi.get(self, "service")
+        return pulumi.get(self, "statistic")
 
-    @service.setter
-    def service(self, value: pulumi.Input['ServiceArgs']):
-        pulumi.set(self, "service", value)
+    @statistic.setter
+    def statistic(self, value: pulumi.Input['MetricStatisticType']):
+        pulumi.set(self, "statistic", value)
 
     @property
-    @pulumi.getter(name="networkingConfigurations")
-    def networking_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NetworkingConfigurationArgs']]]]:
+    @pulumi.getter
+    def threshold(self) -> pulumi.Input[float]:
         """
-        Networking configurations for the pipeline group instance.
+        the threshold of the metric that triggers the scale action.
         """
-        return pulumi.get(self, "networking_configurations")
+        return pulumi.get(self, "threshold")
 
-    @networking_configurations.setter
-    def networking_configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NetworkingConfigurationArgs']]]]):
-        pulumi.set(self, "networking_configurations", value)
+    @threshold.setter
+    def threshold(self, value: pulumi.Input[float]):
+        pulumi.set(self, "threshold", value)
 
     @property
-    @pulumi.getter
-    def replicas(self) -> Optional[pulumi.Input[int]]:
+    @pulumi.getter(name="timeAggregation")
+    def time_aggregation(self) -> pulumi.Input['TimeAggregationType']:
         """
-        Defines the amount of replicas of the pipeline group instance.
+        time aggregation type. How the data that is collected should be combined over time. The default value is Average.
         """
-        return pulumi.get(self, "replicas")
-
-    @replicas.setter
-    def replicas(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "replicas", value)
+        return pulumi.get(self, "time_aggregation")
 
+    @time_aggregation.setter
+    def time_aggregation(self, value: pulumi.Input['TimeAggregationType']):
+        pulumi.set(self, "time_aggregation", value)
 
-if not MYPY:
-    class PipelineArgsDict(TypedDict):
-        """
-        Pipeline Info.
-        """
-        exporters: pulumi.Input[Sequence[pulumi.Input[str]]]
-        """
-        Reference to exporters configured for the pipeline.
-        """
-        name: pulumi.Input[str]
-        """
-        Name of the pipeline.
-        """
-        receivers: pulumi.Input[Sequence[pulumi.Input[str]]]
-        """
-        Reference to receivers configured for the pipeline.
-        """
-        type: pulumi.Input[Union[str, 'PipelineType']]
-        """
-        The type of pipeline
-        """
-        processors: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+    @property
+    @pulumi.getter(name="timeGrain")
+    def time_grain(self) -> pulumi.Input[str]:
         """
-        Reference to processors configured for the pipeline.
+        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.
         """
-elif False:
-    PipelineArgsDict: TypeAlias = Mapping[str, Any]
+        return pulumi.get(self, "time_grain")
 
-@pulumi.input_type
-class PipelineArgs:
-    def __init__(__self__, *,
-                 exporters: pulumi.Input[Sequence[pulumi.Input[str]]],
-                 name: pulumi.Input[str],
-                 receivers: pulumi.Input[Sequence[pulumi.Input[str]]],
-                 type: pulumi.Input[Union[str, 'PipelineType']],
-                 processors: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
-        """
-        Pipeline Info.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] exporters: Reference to exporters configured for the pipeline.
-        :param pulumi.Input[str] name: Name of the pipeline.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] receivers: Reference to receivers configured for the pipeline.
-        :param pulumi.Input[Union[str, 'PipelineType']] type: The type of pipeline
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] processors: Reference to processors configured for the pipeline.
-        """
-        pulumi.set(__self__, "exporters", exporters)
-        pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "receivers", receivers)
-        pulumi.set(__self__, "type", type)
-        if processors is not None:
-            pulumi.set(__self__, "processors", processors)
+    @time_grain.setter
+    def time_grain(self, value: pulumi.Input[str]):
+        pulumi.set(self, "time_grain", value)
 
     @property
-    @pulumi.getter
-    def exporters(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
+    @pulumi.getter(name="timeWindow")
+    def time_window(self) -> pulumi.Input[str]:
         """
-        Reference to exporters configured for the pipeline.
+        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, "exporters")
+        return pulumi.get(self, "time_window")
 
-    @exporters.setter
-    def exporters(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
-        pulumi.set(self, "exporters", value)
+    @time_window.setter
+    def time_window(self, value: pulumi.Input[str]):
+        pulumi.set(self, "time_window", value)
 
     @property
     @pulumi.getter
-    def name(self) -> pulumi.Input[str]:
+    def dimensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ScaleRuleMetricDimensionArgs']]]]:
         """
-        Name of the pipeline.
+        List of dimension conditions. For example: [{"DimensionName":"AppName","Operator":"Equals","Values":["App1"]},{"DimensionName":"Deployment","Operator":"Equals","Values":["default"]}].
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "dimensions")
 
-    @name.setter
-    def name(self, value: pulumi.Input[str]):
-        pulumi.set(self, "name", value)
+    @dimensions.setter
+    def dimensions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ScaleRuleMetricDimensionArgs']]]]):
+        pulumi.set(self, "dimensions", value)
 
     @property
-    @pulumi.getter
-    def receivers(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
+    @pulumi.getter(name="dividePerInstance")
+    def divide_per_instance(self) -> Optional[pulumi.Input[bool]]:
         """
-        Reference to receivers configured for the pipeline.
+        a value indicating whether metric should divide per instance.
         """
-        return pulumi.get(self, "receivers")
+        return pulumi.get(self, "divide_per_instance")
 
-    @receivers.setter
-    def receivers(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
-        pulumi.set(self, "receivers", value)
+    @divide_per_instance.setter
+    def divide_per_instance(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "divide_per_instance", value)
 
     @property
-    @pulumi.getter
-    def type(self) -> pulumi.Input[Union[str, 'PipelineType']]:
+    @pulumi.getter(name="metricNamespace")
+    def metric_namespace(self) -> Optional[pulumi.Input[str]]:
         """
-        The type of pipeline
+        the namespace of the metric that defines what the rule monitors.
         """
-        return pulumi.get(self, "type")
+        return pulumi.get(self, "metric_namespace")
 
-    @type.setter
-    def type(self, value: pulumi.Input[Union[str, 'PipelineType']]):
-        pulumi.set(self, "type", value)
+    @metric_namespace.setter
+    def metric_namespace(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "metric_namespace", value)
 
     @property
-    @pulumi.getter
-    def processors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+    @pulumi.getter(name="metricResourceLocation")
+    def metric_resource_location(self) -> Optional[pulumi.Input[str]]:
         """
-        Reference to processors configured for the pipeline.
+        the location of the resource the rule monitors.
         """
-        return pulumi.get(self, "processors")
+        return pulumi.get(self, "metric_resource_location")
 
-    @processors.setter
-    def processors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
-        pulumi.set(self, "processors", value)
+    @metric_resource_location.setter
+    def metric_resource_location(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "metric_resource_location", value)
 
 
 if not MYPY:
-    class PrivateLinkServiceConnectionStateArgsDict(TypedDict):
+    class NetworkingConfigurationArgsDict(TypedDict):
         """
-        A collection of information about the state of the connection between service consumer and provider.
+        Networking configuration for the pipeline group instance.
         """
-        actions_required: NotRequired[pulumi.Input[str]]
+        external_networking_mode: pulumi.Input[Union[str, 'ExternalNetworkingMode']]
         """
-        A message indicating if changes on the service provider require any updates on the consumer.
+        External networking mode.
         """
-        description: NotRequired[pulumi.Input[str]]
+        routes: pulumi.Input[Sequence[pulumi.Input['NetworkingRouteArgsDict']]]
         """
-        The reason for approval/rejection of the connection.
+        Networking routes configuration.
         """
-        status: NotRequired[pulumi.Input[Union[str, 'PrivateEndpointServiceConnectionStatus']]]
+        host: NotRequired[pulumi.Input[str]]
         """
-        Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service.
+        The address exposed on the cluster. Example: azuremonitorpipeline.contoso.com.
         """
 elif False:
-    PrivateLinkServiceConnectionStateArgsDict: TypeAlias = Mapping[str, Any]
+    NetworkingConfigurationArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class PrivateLinkServiceConnectionStateArgs:
+class NetworkingConfigurationArgs:
     def __init__(__self__, *,
-                 actions_required: Optional[pulumi.Input[str]] = None,
-                 description: Optional[pulumi.Input[str]] = None,
-                 status: Optional[pulumi.Input[Union[str, 'PrivateEndpointServiceConnectionStatus']]] = None):
+                 external_networking_mode: pulumi.Input[Union[str, 'ExternalNetworkingMode']],
+                 routes: pulumi.Input[Sequence[pulumi.Input['NetworkingRouteArgs']]],
+                 host: Optional[pulumi.Input[str]] = None):
         """
-        A collection of information about the state of the connection between service consumer and provider.
-        :param pulumi.Input[str] actions_required: A message indicating if changes on the service provider require any updates on the consumer.
-        :param pulumi.Input[str] description: The reason for approval/rejection of the connection.
-        :param pulumi.Input[Union[str, 'PrivateEndpointServiceConnectionStatus']] status: Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service.
+        Networking configuration for the pipeline group instance.
+        :param pulumi.Input[Union[str, 'ExternalNetworkingMode']] external_networking_mode: External networking mode.
+        :param pulumi.Input[Sequence[pulumi.Input['NetworkingRouteArgs']]] routes: Networking routes configuration.
+        :param pulumi.Input[str] host: The address exposed on the cluster. Example: azuremonitorpipeline.contoso.com.
         """
-        if actions_required is not None:
-            pulumi.set(__self__, "actions_required", actions_required)
-        if description is not None:
-            pulumi.set(__self__, "description", description)
-        if status is not None:
-            pulumi.set(__self__, "status", status)
+        pulumi.set(__self__, "external_networking_mode", external_networking_mode)
+        pulumi.set(__self__, "routes", routes)
+        if host is not None:
+            pulumi.set(__self__, "host", host)
 
     @property
-    @pulumi.getter(name="actionsRequired")
-    def actions_required(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter(name="externalNetworkingMode")
+    def external_networking_mode(self) -> pulumi.Input[Union[str, 'ExternalNetworkingMode']]:
         """
-        A message indicating if changes on the service provider require any updates on the consumer.
+        External networking mode.
         """
-        return pulumi.get(self, "actions_required")
+        return pulumi.get(self, "external_networking_mode")
 
-    @actions_required.setter
-    def actions_required(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "actions_required", value)
+    @external_networking_mode.setter
+    def external_networking_mode(self, value: pulumi.Input[Union[str, 'ExternalNetworkingMode']]):
+        pulumi.set(self, "external_networking_mode", value)
 
     @property
     @pulumi.getter
-    def description(self) -> Optional[pulumi.Input[str]]:
+    def routes(self) -> pulumi.Input[Sequence[pulumi.Input['NetworkingRouteArgs']]]:
         """
-        The reason for approval/rejection of the connection.
+        Networking routes configuration.
         """
-        return pulumi.get(self, "description")
+        return pulumi.get(self, "routes")
 
-    @description.setter
-    def description(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "description", value)
+    @routes.setter
+    def routes(self, value: pulumi.Input[Sequence[pulumi.Input['NetworkingRouteArgs']]]):
+        pulumi.set(self, "routes", value)
 
     @property
     @pulumi.getter
-    def status(self) -> Optional[pulumi.Input[Union[str, 'PrivateEndpointServiceConnectionStatus']]]:
+    def host(self) -> Optional[pulumi.Input[str]]:
         """
-        Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service.
+        The address exposed on the cluster. Example: azuremonitorpipeline.contoso.com.
         """
-        return pulumi.get(self, "status")
+        return pulumi.get(self, "host")
 
-    @status.setter
-    def status(self, value: Optional[pulumi.Input[Union[str, 'PrivateEndpointServiceConnectionStatus']]]):
-        pulumi.set(self, "status", value)
+    @host.setter
+    def host(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "host", value)
 
 
 if not MYPY:
-    class ProcessorArgsDict(TypedDict):
+    class NetworkingRouteArgsDict(TypedDict):
         """
-        Processor Info.
+        Networking route configuration.
         """
-        name: pulumi.Input[str]
+        receiver: pulumi.Input[str]
         """
-        The name of processor.
+        The name of the previously defined receiver.
         """
-        type: pulumi.Input[Union[str, 'ProcessorType']]
+        path: NotRequired[pulumi.Input[str]]
         """
-        The type of processor.
+        Route path.
         """
-        batch: NotRequired[pulumi.Input['BatchProcessorArgsDict']]
+        port: NotRequired[pulumi.Input[int]]
         """
-        Batch processor configurations.
+        The port that will be configured externally. If not specified, it will use the port from the receiver definition.
+        """
+        subdomain: NotRequired[pulumi.Input[str]]
+        """
+        Route subdomain.
         """
 elif False:
-    ProcessorArgsDict: TypeAlias = Mapping[str, Any]
+    NetworkingRouteArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class ProcessorArgs:
+class NetworkingRouteArgs:
     def __init__(__self__, *,
-                 name: pulumi.Input[str],
-                 type: pulumi.Input[Union[str, 'ProcessorType']],
-                 batch: Optional[pulumi.Input['BatchProcessorArgs']] = None):
+                 receiver: pulumi.Input[str],
+                 path: Optional[pulumi.Input[str]] = None,
+                 port: Optional[pulumi.Input[int]] = None,
+                 subdomain: Optional[pulumi.Input[str]] = None):
         """
-        Processor Info.
-        :param pulumi.Input[str] name: The name of processor.
-        :param pulumi.Input[Union[str, 'ProcessorType']] type: The type of processor.
-        :param pulumi.Input['BatchProcessorArgs'] batch: Batch processor configurations.
+        Networking route configuration.
+        :param pulumi.Input[str] receiver: The name of the previously defined receiver.
+        :param pulumi.Input[str] path: Route path.
+        :param pulumi.Input[int] port: The port that will be configured externally. If not specified, it will use the port from the receiver definition.
+        :param pulumi.Input[str] subdomain: Route subdomain.
         """
-        pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "type", type)
-        if batch is not None:
-            pulumi.set(__self__, "batch", batch)
+        pulumi.set(__self__, "receiver", receiver)
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+        if subdomain is not None:
+            pulumi.set(__self__, "subdomain", subdomain)
 
     @property
     @pulumi.getter
-    def name(self) -> pulumi.Input[str]:
+    def receiver(self) -> pulumi.Input[str]:
         """
-        The name of processor.
+        The name of the previously defined receiver.
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "receiver")
 
-    @name.setter
-    def name(self, value: pulumi.Input[str]):
-        pulumi.set(self, "name", value)
+    @receiver.setter
+    def receiver(self, value: pulumi.Input[str]):
+        pulumi.set(self, "receiver", value)
 
     @property
     @pulumi.getter
-    def type(self) -> pulumi.Input[Union[str, 'ProcessorType']]:
+    def path(self) -> Optional[pulumi.Input[str]]:
         """
-        The type of processor.
+        Route path.
         """
-        return pulumi.get(self, "type")
+        return pulumi.get(self, "path")
 
-    @type.setter
-    def type(self, value: pulumi.Input[Union[str, 'ProcessorType']]):
-        pulumi.set(self, "type", value)
+    @path.setter
+    def path(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "path", value)
 
     @property
     @pulumi.getter
-    def batch(self) -> Optional[pulumi.Input['BatchProcessorArgs']]:
+    def port(self) -> Optional[pulumi.Input[int]]:
         """
-        Batch processor configurations.
+        The port that will be configured externally. If not specified, it will use the port from the receiver definition.
         """
-        return pulumi.get(self, "batch")
+        return pulumi.get(self, "port")
 
-    @batch.setter
-    def batch(self, value: Optional[pulumi.Input['BatchProcessorArgs']]):
-        pulumi.set(self, "batch", value)
+    @port.setter
+    def port(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "port", value)
+
+    @property
+    @pulumi.getter
+    def subdomain(self) -> Optional[pulumi.Input[str]]:
+        """
+        Route subdomain.
+        """
+        return pulumi.get(self, "subdomain")
+
+    @subdomain.setter
+    def subdomain(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "subdomain", value)
 
 
 if not MYPY:
-    class ReceiverArgsDict(TypedDict):
+    class OtlpReceiverArgsDict(TypedDict):
         """
-        Receiver Info.
+        OTLP Receiver.
         """
-        name: pulumi.Input[str]
+        endpoint: pulumi.Input[str]
         """
-        The name of receiver.
+        OTLP GRPC endpoint definition. Example: 0.0.0.0:<port>.
         """
-        type: pulumi.Input[Union[str, 'ReceiverType']]
+elif False:
+    OtlpReceiverArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class OtlpReceiverArgs:
+    def __init__(__self__, *,
+                 endpoint: pulumi.Input[str]):
         """
-        The type of receiver.
+        OTLP Receiver.
+        :param pulumi.Input[str] endpoint: OTLP GRPC endpoint definition. Example: 0.0.0.0:<port>.
         """
-        otlp: NotRequired[pulumi.Input['OtlpReceiverArgsDict']]
+        pulumi.set(__self__, "endpoint", endpoint)
+
+    @property
+    @pulumi.getter
+    def endpoint(self) -> pulumi.Input[str]:
         """
-        OTLP receiver configurations. This field is mandatory for OTLP and pipelineGroup receivers.
+        OTLP GRPC endpoint definition. Example: 0.0.0.0:<port>.
         """
-        syslog: NotRequired[pulumi.Input['SyslogReceiverArgsDict']]
+        return pulumi.get(self, "endpoint")
+
+    @endpoint.setter
+    def endpoint(self, value: pulumi.Input[str]):
+        pulumi.set(self, "endpoint", value)
+
+
+if not MYPY:
+    class PersistenceConfigurationsArgsDict(TypedDict):
         """
-        Syslog configurations. This field is mandatory for syslog type receivers.
+        Persistence options to all pipelines in the instance.
         """
-        udp: NotRequired[pulumi.Input['UdpReceiverArgsDict']]
+        persistent_volume_name: pulumi.Input[str]
         """
-        UDP receiver configurations. This field is mandatory for UDP receivers.
+        The name of the mounted persistent volume.
         """
 elif False:
-    ReceiverArgsDict: TypeAlias = Mapping[str, Any]
+    PersistenceConfigurationsArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class ReceiverArgs:
+class PersistenceConfigurationsArgs:
     def __init__(__self__, *,
-                 name: pulumi.Input[str],
-                 type: pulumi.Input[Union[str, 'ReceiverType']],
-                 otlp: Optional[pulumi.Input['OtlpReceiverArgs']] = None,
-                 syslog: Optional[pulumi.Input['SyslogReceiverArgs']] = None,
-                 udp: Optional[pulumi.Input['UdpReceiverArgs']] = None):
+                 persistent_volume_name: pulumi.Input[str]):
         """
-        Receiver Info.
-        :param pulumi.Input[str] name: The name of receiver.
-        :param pulumi.Input[Union[str, 'ReceiverType']] type: The type of receiver.
-        :param pulumi.Input['OtlpReceiverArgs'] otlp: OTLP receiver configurations. This field is mandatory for OTLP and pipelineGroup receivers.
-        :param pulumi.Input['SyslogReceiverArgs'] syslog: Syslog configurations. This field is mandatory for syslog type receivers.
-        :param pulumi.Input['UdpReceiverArgs'] udp: UDP receiver configurations. This field is mandatory for UDP receivers.
+        Persistence options to all pipelines in the instance.
+        :param pulumi.Input[str] persistent_volume_name: The name of the mounted persistent volume.
         """
-        pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "type", type)
-        if otlp is not None:
-            pulumi.set(__self__, "otlp", otlp)
-        if syslog is not None:
-            pulumi.set(__self__, "syslog", syslog)
-        if udp is not None:
-            pulumi.set(__self__, "udp", udp)
+        pulumi.set(__self__, "persistent_volume_name", persistent_volume_name)
 
     @property
-    @pulumi.getter
-    def name(self) -> pulumi.Input[str]:
+    @pulumi.getter(name="persistentVolumeName")
+    def persistent_volume_name(self) -> pulumi.Input[str]:
+        """
+        The name of the mounted persistent volume.
+        """
+        return pulumi.get(self, "persistent_volume_name")
+
+    @persistent_volume_name.setter
+    def persistent_volume_name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "persistent_volume_name", value)
+
+
+if not MYPY:
+    class PipelineGroupPropertiesArgsDict(TypedDict):
+        """
+        Properties that need to be specified to create a new pipeline group instance.
+        """
+        exporters: pulumi.Input[Sequence[pulumi.Input['ExporterArgsDict']]]
+        """
+        The exporters specified for a pipeline group instance.
+        """
+        processors: pulumi.Input[Sequence[pulumi.Input['ProcessorArgsDict']]]
+        """
+        The processors specified for a pipeline group instance.
+        """
+        receivers: pulumi.Input[Sequence[pulumi.Input['ReceiverArgsDict']]]
+        """
+        The receivers specified for a pipeline group instance.
+        """
+        service: pulumi.Input['ServiceArgsDict']
+        """
+        The service section for a given pipeline group instance.
+        """
+        networking_configurations: NotRequired[pulumi.Input[Sequence[pulumi.Input['NetworkingConfigurationArgsDict']]]]
+        """
+        Networking configurations for the pipeline group instance.
+        """
+        replicas: NotRequired[pulumi.Input[int]]
+        """
+        Defines the amount of replicas of the pipeline group instance.
+        """
+elif False:
+    PipelineGroupPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PipelineGroupPropertiesArgs:
+    def __init__(__self__, *,
+                 exporters: pulumi.Input[Sequence[pulumi.Input['ExporterArgs']]],
+                 processors: pulumi.Input[Sequence[pulumi.Input['ProcessorArgs']]],
+                 receivers: pulumi.Input[Sequence[pulumi.Input['ReceiverArgs']]],
+                 service: pulumi.Input['ServiceArgs'],
+                 networking_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['NetworkingConfigurationArgs']]]] = None,
+                 replicas: Optional[pulumi.Input[int]] = None):
+        """
+        Properties that need to be specified to create a new pipeline group instance.
+        :param pulumi.Input[Sequence[pulumi.Input['ExporterArgs']]] exporters: The exporters specified for a pipeline group instance.
+        :param pulumi.Input[Sequence[pulumi.Input['ProcessorArgs']]] processors: The processors specified for a pipeline group instance.
+        :param pulumi.Input[Sequence[pulumi.Input['ReceiverArgs']]] receivers: The receivers specified for a pipeline group instance.
+        :param pulumi.Input['ServiceArgs'] service: The service section for a given pipeline group instance.
+        :param pulumi.Input[Sequence[pulumi.Input['NetworkingConfigurationArgs']]] networking_configurations: Networking configurations for the pipeline group instance.
+        :param pulumi.Input[int] replicas: Defines the amount of replicas of the pipeline group instance.
+        """
+        pulumi.set(__self__, "exporters", exporters)
+        pulumi.set(__self__, "processors", processors)
+        pulumi.set(__self__, "receivers", receivers)
+        pulumi.set(__self__, "service", service)
+        if networking_configurations is not None:
+            pulumi.set(__self__, "networking_configurations", networking_configurations)
+        if replicas is not None:
+            pulumi.set(__self__, "replicas", replicas)
+
+    @property
+    @pulumi.getter
+    def exporters(self) -> pulumi.Input[Sequence[pulumi.Input['ExporterArgs']]]:
+        """
+        The exporters specified for a pipeline group instance.
+        """
+        return pulumi.get(self, "exporters")
+
+    @exporters.setter
+    def exporters(self, value: pulumi.Input[Sequence[pulumi.Input['ExporterArgs']]]):
+        pulumi.set(self, "exporters", value)
+
+    @property
+    @pulumi.getter
+    def processors(self) -> pulumi.Input[Sequence[pulumi.Input['ProcessorArgs']]]:
+        """
+        The processors specified for a pipeline group instance.
+        """
+        return pulumi.get(self, "processors")
+
+    @processors.setter
+    def processors(self, value: pulumi.Input[Sequence[pulumi.Input['ProcessorArgs']]]):
+        pulumi.set(self, "processors", value)
+
+    @property
+    @pulumi.getter
+    def receivers(self) -> pulumi.Input[Sequence[pulumi.Input['ReceiverArgs']]]:
+        """
+        The receivers specified for a pipeline group instance.
+        """
+        return pulumi.get(self, "receivers")
+
+    @receivers.setter
+    def receivers(self, value: pulumi.Input[Sequence[pulumi.Input['ReceiverArgs']]]):
+        pulumi.set(self, "receivers", value)
+
+    @property
+    @pulumi.getter
+    def service(self) -> pulumi.Input['ServiceArgs']:
+        """
+        The service section for a given pipeline group instance.
+        """
+        return pulumi.get(self, "service")
+
+    @service.setter
+    def service(self, value: pulumi.Input['ServiceArgs']):
+        pulumi.set(self, "service", value)
+
+    @property
+    @pulumi.getter(name="networkingConfigurations")
+    def networking_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NetworkingConfigurationArgs']]]]:
+        """
+        Networking configurations for the pipeline group instance.
+        """
+        return pulumi.get(self, "networking_configurations")
+
+    @networking_configurations.setter
+    def networking_configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NetworkingConfigurationArgs']]]]):
+        pulumi.set(self, "networking_configurations", value)
+
+    @property
+    @pulumi.getter
+    def replicas(self) -> Optional[pulumi.Input[int]]:
+        """
+        Defines the amount of replicas of the pipeline group instance.
+        """
+        return pulumi.get(self, "replicas")
+
+    @replicas.setter
+    def replicas(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "replicas", value)
+
+
+if not MYPY:
+    class PipelineArgsDict(TypedDict):
+        """
+        Pipeline Info.
+        """
+        exporters: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        Reference to exporters configured for the pipeline.
+        """
+        name: pulumi.Input[str]
+        """
+        Name of the pipeline.
+        """
+        receivers: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        Reference to receivers configured for the pipeline.
+        """
+        type: pulumi.Input[Union[str, 'PipelineType']]
+        """
+        The type of pipeline
+        """
+        processors: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Reference to processors configured for the pipeline.
+        """
+elif False:
+    PipelineArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PipelineArgs:
+    def __init__(__self__, *,
+                 exporters: pulumi.Input[Sequence[pulumi.Input[str]]],
+                 name: pulumi.Input[str],
+                 receivers: pulumi.Input[Sequence[pulumi.Input[str]]],
+                 type: pulumi.Input[Union[str, 'PipelineType']],
+                 processors: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        Pipeline Info.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] exporters: Reference to exporters configured for the pipeline.
+        :param pulumi.Input[str] name: Name of the pipeline.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] receivers: Reference to receivers configured for the pipeline.
+        :param pulumi.Input[Union[str, 'PipelineType']] type: The type of pipeline
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] processors: Reference to processors configured for the pipeline.
+        """
+        pulumi.set(__self__, "exporters", exporters)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "receivers", receivers)
+        pulumi.set(__self__, "type", type)
+        if processors is not None:
+            pulumi.set(__self__, "processors", processors)
+
+    @property
+    @pulumi.getter
+    def exporters(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
+        """
+        Reference to exporters configured for the pipeline.
+        """
+        return pulumi.get(self, "exporters")
+
+    @exporters.setter
+    def exporters(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
+        pulumi.set(self, "exporters", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[str]:
+        """
+        Name of the pipeline.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def receivers(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
+        """
+        Reference to receivers configured for the pipeline.
+        """
+        return pulumi.get(self, "receivers")
+
+    @receivers.setter
+    def receivers(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
+        pulumi.set(self, "receivers", value)
+
+    @property
+    @pulumi.getter
+    def type(self) -> pulumi.Input[Union[str, 'PipelineType']]:
+        """
+        The type of pipeline
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: pulumi.Input[Union[str, 'PipelineType']]):
+        pulumi.set(self, "type", value)
+
+    @property
+    @pulumi.getter
+    def processors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Reference to processors configured for the pipeline.
+        """
+        return pulumi.get(self, "processors")
+
+    @processors.setter
+    def processors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "processors", value)
+
+
+if not MYPY:
+    class PredictiveAutoscalePolicyArgsDict(TypedDict):
+        """
+        The parameters for enabling predictive autoscale.
+        """
+        scale_mode: pulumi.Input['PredictiveAutoscalePolicyScaleMode']
+        """
+        the predictive autoscale mode
+        """
+        scale_look_ahead_time: NotRequired[pulumi.Input[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.
+        """
+elif False:
+    PredictiveAutoscalePolicyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PredictiveAutoscalePolicyArgs:
+    def __init__(__self__, *,
+                 scale_mode: pulumi.Input['PredictiveAutoscalePolicyScaleMode'],
+                 scale_look_ahead_time: Optional[pulumi.Input[str]] = None):
+        """
+        The parameters for enabling predictive autoscale.
+        :param pulumi.Input['PredictiveAutoscalePolicyScaleMode'] scale_mode: the predictive autoscale mode
+        :param pulumi.Input[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) -> pulumi.Input['PredictiveAutoscalePolicyScaleMode']:
+        """
+        the predictive autoscale mode
+        """
+        return pulumi.get(self, "scale_mode")
+
+    @scale_mode.setter
+    def scale_mode(self, value: pulumi.Input['PredictiveAutoscalePolicyScaleMode']):
+        pulumi.set(self, "scale_mode", value)
+
+    @property
+    @pulumi.getter(name="scaleLookAheadTime")
+    def scale_look_ahead_time(self) -> Optional[pulumi.Input[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")
+
+    @scale_look_ahead_time.setter
+    def scale_look_ahead_time(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "scale_look_ahead_time", value)
+
+
+if not MYPY:
+    class PrivateLinkServiceConnectionStateArgsDict(TypedDict):
+        """
+        A collection of information about the state of the connection between service consumer and provider.
+        """
+        actions_required: NotRequired[pulumi.Input[str]]
+        """
+        A message indicating if changes on the service provider require any updates on the consumer.
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        The reason for approval/rejection of the connection.
+        """
+        status: NotRequired[pulumi.Input[Union[str, 'PrivateEndpointServiceConnectionStatus']]]
+        """
+        Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service.
+        """
+elif False:
+    PrivateLinkServiceConnectionStateArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PrivateLinkServiceConnectionStateArgs:
+    def __init__(__self__, *,
+                 actions_required: Optional[pulumi.Input[str]] = None,
+                 description: Optional[pulumi.Input[str]] = None,
+                 status: Optional[pulumi.Input[Union[str, 'PrivateEndpointServiceConnectionStatus']]] = None):
+        """
+        A collection of information about the state of the connection between service consumer and provider.
+        :param pulumi.Input[str] actions_required: A message indicating if changes on the service provider require any updates on the consumer.
+        :param pulumi.Input[str] description: The reason for approval/rejection of the connection.
+        :param pulumi.Input[Union[str, 'PrivateEndpointServiceConnectionStatus']] status: Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service.
+        """
+        if actions_required is not None:
+            pulumi.set(__self__, "actions_required", actions_required)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter(name="actionsRequired")
+    def actions_required(self) -> Optional[pulumi.Input[str]]:
+        """
+        A message indicating if changes on the service provider require any updates on the consumer.
+        """
+        return pulumi.get(self, "actions_required")
+
+    @actions_required.setter
+    def actions_required(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "actions_required", value)
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[pulumi.Input[str]]:
+        """
+        The reason for approval/rejection of the connection.
+        """
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "description", value)
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[pulumi.Input[Union[str, 'PrivateEndpointServiceConnectionStatus']]]:
+        """
+        Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service.
+        """
+        return pulumi.get(self, "status")
+
+    @status.setter
+    def status(self, value: Optional[pulumi.Input[Union[str, 'PrivateEndpointServiceConnectionStatus']]]):
+        pulumi.set(self, "status", value)
+
+
+if not MYPY:
+    class ProcessorArgsDict(TypedDict):
+        """
+        Processor Info.
+        """
+        name: pulumi.Input[str]
+        """
+        The name of processor.
+        """
+        type: pulumi.Input[Union[str, 'ProcessorType']]
+        """
+        The type of processor.
+        """
+        batch: NotRequired[pulumi.Input['BatchProcessorArgsDict']]
+        """
+        Batch processor configurations.
+        """
+elif False:
+    ProcessorArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ProcessorArgs:
+    def __init__(__self__, *,
+                 name: pulumi.Input[str],
+                 type: pulumi.Input[Union[str, 'ProcessorType']],
+                 batch: Optional[pulumi.Input['BatchProcessorArgs']] = None):
+        """
+        Processor Info.
+        :param pulumi.Input[str] name: The name of processor.
+        :param pulumi.Input[Union[str, 'ProcessorType']] type: The type of processor.
+        :param pulumi.Input['BatchProcessorArgs'] batch: Batch processor configurations.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "type", type)
+        if batch is not None:
+            pulumi.set(__self__, "batch", batch)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[str]:
+        """
+        The name of processor.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def type(self) -> pulumi.Input[Union[str, 'ProcessorType']]:
+        """
+        The type of processor.
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: pulumi.Input[Union[str, 'ProcessorType']]):
+        pulumi.set(self, "type", value)
+
+    @property
+    @pulumi.getter
+    def batch(self) -> Optional[pulumi.Input['BatchProcessorArgs']]:
+        """
+        Batch processor configurations.
+        """
+        return pulumi.get(self, "batch")
+
+    @batch.setter
+    def batch(self, value: Optional[pulumi.Input['BatchProcessorArgs']]):
+        pulumi.set(self, "batch", value)
+
+
+if not MYPY:
+    class ReceiverArgsDict(TypedDict):
+        """
+        Receiver Info.
+        """
+        name: pulumi.Input[str]
+        """
+        The name of receiver.
+        """
+        type: pulumi.Input[Union[str, 'ReceiverType']]
+        """
+        The type of receiver.
+        """
+        otlp: NotRequired[pulumi.Input['OtlpReceiverArgsDict']]
+        """
+        OTLP receiver configurations. This field is mandatory for OTLP and pipelineGroup receivers.
+        """
+        syslog: NotRequired[pulumi.Input['SyslogReceiverArgsDict']]
+        """
+        Syslog configurations. This field is mandatory for syslog type receivers.
+        """
+        udp: NotRequired[pulumi.Input['UdpReceiverArgsDict']]
+        """
+        UDP receiver configurations. This field is mandatory for UDP receivers.
+        """
+elif False:
+    ReceiverArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ReceiverArgs:
+    def __init__(__self__, *,
+                 name: pulumi.Input[str],
+                 type: pulumi.Input[Union[str, 'ReceiverType']],
+                 otlp: Optional[pulumi.Input['OtlpReceiverArgs']] = None,
+                 syslog: Optional[pulumi.Input['SyslogReceiverArgs']] = None,
+                 udp: Optional[pulumi.Input['UdpReceiverArgs']] = None):
+        """
+        Receiver Info.
+        :param pulumi.Input[str] name: The name of receiver.
+        :param pulumi.Input[Union[str, 'ReceiverType']] type: The type of receiver.
+        :param pulumi.Input['OtlpReceiverArgs'] otlp: OTLP receiver configurations. This field is mandatory for OTLP and pipelineGroup receivers.
+        :param pulumi.Input['SyslogReceiverArgs'] syslog: Syslog configurations. This field is mandatory for syslog type receivers.
+        :param pulumi.Input['UdpReceiverArgs'] udp: UDP receiver configurations. This field is mandatory for UDP receivers.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "type", type)
+        if otlp is not None:
+            pulumi.set(__self__, "otlp", otlp)
+        if syslog is not None:
+            pulumi.set(__self__, "syslog", syslog)
+        if udp is not None:
+            pulumi.set(__self__, "udp", udp)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[str]:
+        """
+        The name of receiver.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def type(self) -> pulumi.Input[Union[str, 'ReceiverType']]:
+        """
+        The type of receiver.
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: pulumi.Input[Union[str, 'ReceiverType']]):
+        pulumi.set(self, "type", value)
+
+    @property
+    @pulumi.getter
+    def otlp(self) -> Optional[pulumi.Input['OtlpReceiverArgs']]:
+        """
+        OTLP receiver configurations. This field is mandatory for OTLP and pipelineGroup receivers.
+        """
+        return pulumi.get(self, "otlp")
+
+    @otlp.setter
+    def otlp(self, value: Optional[pulumi.Input['OtlpReceiverArgs']]):
+        pulumi.set(self, "otlp", value)
+
+    @property
+    @pulumi.getter
+    def syslog(self) -> Optional[pulumi.Input['SyslogReceiverArgs']]:
+        """
+        Syslog configurations. This field is mandatory for syslog type receivers.
+        """
+        return pulumi.get(self, "syslog")
+
+    @syslog.setter
+    def syslog(self, value: Optional[pulumi.Input['SyslogReceiverArgs']]):
+        pulumi.set(self, "syslog", value)
+
+    @property
+    @pulumi.getter
+    def udp(self) -> Optional[pulumi.Input['UdpReceiverArgs']]:
+        """
+        UDP receiver configurations. This field is mandatory for UDP receivers.
+        """
+        return pulumi.get(self, "udp")
+
+    @udp.setter
+    def udp(self, value: Optional[pulumi.Input['UdpReceiverArgs']]):
+        pulumi.set(self, "udp", value)
+
+
+if not MYPY:
+    class RecordMapArgsDict(TypedDict):
+        """
+        Record map for schema in azure monitor.
+        """
+        from_: pulumi.Input[str]
+        """
+        Record Map Key.
+        """
+        to: pulumi.Input[str]
+        """
+        Record Map Value.
+        """
+elif False:
+    RecordMapArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RecordMapArgs:
+    def __init__(__self__, *,
+                 from_: pulumi.Input[str],
+                 to: pulumi.Input[str]):
+        """
+        Record map for schema in azure monitor.
+        :param pulumi.Input[str] from_: Record Map Key.
+        :param pulumi.Input[str] to: Record Map Value.
+        """
+        pulumi.set(__self__, "from_", from_)
+        pulumi.set(__self__, "to", to)
+
+    @property
+    @pulumi.getter(name="from")
+    def from_(self) -> pulumi.Input[str]:
+        """
+        Record Map Key.
+        """
+        return pulumi.get(self, "from_")
+
+    @from_.setter
+    def from_(self, value: pulumi.Input[str]):
+        pulumi.set(self, "from_", value)
+
+    @property
+    @pulumi.getter
+    def to(self) -> pulumi.Input[str]:
+        """
+        Record Map Value.
+        """
+        return pulumi.get(self, "to")
+
+    @to.setter
+    def to(self, value: pulumi.Input[str]):
+        pulumi.set(self, "to", value)
+
+
+if not MYPY:
+    class RecurrenceArgsDict(TypedDict):
+        """
+        The repeating times at which this profile begins. This element is not used if the FixedDate element is used.
+        """
+        frequency: pulumi.Input['RecurrenceFrequency']
+        """
+        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.
+        """
+        schedule: pulumi.Input['RecurrentScheduleArgsDict']
+        """
+        the scheduling constraints for when the profile begins.
+        """
+elif False:
+    RecurrenceArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RecurrenceArgs:
+    def __init__(__self__, *,
+                 frequency: pulumi.Input['RecurrenceFrequency'],
+                 schedule: pulumi.Input['RecurrentScheduleArgs']):
+        """
+        The repeating times at which this profile begins. This element is not used if the FixedDate element is used.
+        :param pulumi.Input['RecurrenceFrequency'] 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 pulumi.Input['RecurrentScheduleArgs'] 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) -> pulumi.Input['RecurrenceFrequency']:
+        """
+        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")
+
+    @frequency.setter
+    def frequency(self, value: pulumi.Input['RecurrenceFrequency']):
+        pulumi.set(self, "frequency", value)
+
+    @property
+    @pulumi.getter
+    def schedule(self) -> pulumi.Input['RecurrentScheduleArgs']:
+        """
+        the scheduling constraints for when the profile begins.
+        """
+        return pulumi.get(self, "schedule")
+
+    @schedule.setter
+    def schedule(self, value: pulumi.Input['RecurrentScheduleArgs']):
+        pulumi.set(self, "schedule", value)
+
+
+if not MYPY:
+    class RecurrentScheduleArgsDict(TypedDict):
+        """
+        The scheduling constraints for when the profile begins.
+        """
+        days: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        the collection of days that the profile takes effect on. Possible values are Sunday through Saturday.
+        """
+        hours: pulumi.Input[Sequence[pulumi.Input[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).
+        """
+        minutes: pulumi.Input[Sequence[pulumi.Input[int]]]
+        """
+        A collection of minutes at which the profile takes effect at.
+        """
+        time_zone: pulumi.Input[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
+        """
+elif False:
+    RecurrentScheduleArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RecurrentScheduleArgs:
+    def __init__(__self__, *,
+                 days: pulumi.Input[Sequence[pulumi.Input[str]]],
+                 hours: pulumi.Input[Sequence[pulumi.Input[int]]],
+                 minutes: pulumi.Input[Sequence[pulumi.Input[int]]],
+                 time_zone: pulumi.Input[str]):
+        """
+        The scheduling constraints for when the profile begins.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] days: the collection of days that the profile takes effect on. Possible values are Sunday through Saturday.
+        :param pulumi.Input[Sequence[pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input[int]]] minutes: A collection of minutes at which the profile takes effect at.
+        :param pulumi.Input[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) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
+        """
+        the collection of days that the profile takes effect on. Possible values are Sunday through Saturday.
+        """
+        return pulumi.get(self, "days")
+
+    @days.setter
+    def days(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
+        pulumi.set(self, "days", value)
+
+    @property
+    @pulumi.getter
+    def hours(self) -> pulumi.Input[Sequence[pulumi.Input[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")
+
+    @hours.setter
+    def hours(self, value: pulumi.Input[Sequence[pulumi.Input[int]]]):
+        pulumi.set(self, "hours", value)
+
+    @property
+    @pulumi.getter
+    def minutes(self) -> pulumi.Input[Sequence[pulumi.Input[int]]]:
+        """
+        A collection of minutes at which the profile takes effect at.
+        """
+        return pulumi.get(self, "minutes")
+
+    @minutes.setter
+    def minutes(self, value: pulumi.Input[Sequence[pulumi.Input[int]]]):
+        pulumi.set(self, "minutes", value)
+
+    @property
+    @pulumi.getter(name="timeZone")
+    def time_zone(self) -> pulumi.Input[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")
+
+    @time_zone.setter
+    def time_zone(self, value: pulumi.Input[str]):
+        pulumi.set(self, "time_zone", value)
+
+
+if not MYPY:
+    class ResourceMapArgsDict(TypedDict):
+        """
+        Resource map for schema in azure monitor.
+        """
+        from_: pulumi.Input[str]
+        """
+        Resource Map Key.
+        """
+        to: pulumi.Input[str]
+        """
+        Resource Map Value.
+        """
+elif False:
+    ResourceMapArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ResourceMapArgs:
+    def __init__(__self__, *,
+                 from_: pulumi.Input[str],
+                 to: pulumi.Input[str]):
+        """
+        Resource map for schema in azure monitor.
+        :param pulumi.Input[str] from_: Resource Map Key.
+        :param pulumi.Input[str] to: Resource Map Value.
+        """
+        pulumi.set(__self__, "from_", from_)
+        pulumi.set(__self__, "to", to)
+
+    @property
+    @pulumi.getter(name="from")
+    def from_(self) -> pulumi.Input[str]:
+        """
+        Resource Map Key.
+        """
+        return pulumi.get(self, "from_")
+
+    @from_.setter
+    def from_(self, value: pulumi.Input[str]):
+        pulumi.set(self, "from_", value)
+
+    @property
+    @pulumi.getter
+    def to(self) -> pulumi.Input[str]:
+        """
+        Resource Map Value.
+        """
+        return pulumi.get(self, "to")
+
+    @to.setter
+    def to(self, value: pulumi.Input[str]):
+        pulumi.set(self, "to", value)
+
+
+if not MYPY:
+    class RetentionPolicyArgsDict(TypedDict):
+        """
+        Specifies the retention policy for the log.
+        """
+        days: pulumi.Input[int]
+        """
+        the number of days for the retention in days. A value of 0 will retain the events indefinitely.
+        """
+        enabled: pulumi.Input[bool]
+        """
+        a value indicating whether the retention policy is enabled.
+        """
+elif False:
+    RetentionPolicyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RetentionPolicyArgs:
+    def __init__(__self__, *,
+                 days: pulumi.Input[int],
+                 enabled: pulumi.Input[bool]):
+        """
+        Specifies the retention policy for the log.
+        :param pulumi.Input[int] days: the number of days for the retention in days. A value of 0 will retain the events indefinitely.
+        :param pulumi.Input[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) -> pulumi.Input[int]:
+        """
+        the number of days for the retention in days. A value of 0 will retain the events indefinitely.
+        """
+        return pulumi.get(self, "days")
+
+    @days.setter
+    def days(self, value: pulumi.Input[int]):
+        pulumi.set(self, "days", value)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> pulumi.Input[bool]:
+        """
+        a value indicating whether the retention policy is enabled.
+        """
+        return pulumi.get(self, "enabled")
+
+    @enabled.setter
+    def enabled(self, value: pulumi.Input[bool]):
+        pulumi.set(self, "enabled", value)
+
+
+if not MYPY:
+    class RuleResolveConfigurationArgsDict(TypedDict):
+        """
+        TBD. Relevant only for rules of the kind LogAlert.
+        """
+        auto_resolved: NotRequired[pulumi.Input[bool]]
+        """
+        The flag that indicates whether or not to auto resolve a fired alert.
+        """
+        time_to_resolve: NotRequired[pulumi.Input[str]]
+        """
+        The duration a rule must evaluate as healthy before the fired alert is automatically resolved represented in ISO 8601 duration format.
+        """
+elif False:
+    RuleResolveConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RuleResolveConfigurationArgs:
+    def __init__(__self__, *,
+                 auto_resolved: Optional[pulumi.Input[bool]] = None,
+                 time_to_resolve: Optional[pulumi.Input[str]] = None):
+        """
+        TBD. Relevant only for rules of the kind LogAlert.
+        :param pulumi.Input[bool] auto_resolved: The flag that indicates whether or not to auto resolve a fired alert.
+        :param pulumi.Input[str] time_to_resolve: The duration a rule must evaluate as healthy before the fired alert is automatically resolved represented in ISO 8601 duration format.
+        """
+        if auto_resolved is not None:
+            pulumi.set(__self__, "auto_resolved", auto_resolved)
+        if time_to_resolve is not None:
+            pulumi.set(__self__, "time_to_resolve", time_to_resolve)
+
+    @property
+    @pulumi.getter(name="autoResolved")
+    def auto_resolved(self) -> Optional[pulumi.Input[bool]]:
+        """
+        The flag that indicates whether or not to auto resolve a fired alert.
+        """
+        return pulumi.get(self, "auto_resolved")
+
+    @auto_resolved.setter
+    def auto_resolved(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "auto_resolved", value)
+
+    @property
+    @pulumi.getter(name="timeToResolve")
+    def time_to_resolve(self) -> Optional[pulumi.Input[str]]:
+        """
+        The duration a rule must evaluate as healthy before the fired alert is automatically resolved represented in ISO 8601 duration format.
+        """
+        return pulumi.get(self, "time_to_resolve")
+
+    @time_to_resolve.setter
+    def time_to_resolve(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "time_to_resolve", value)
+
+
+if not MYPY:
+    class ScaleActionArgsDict(TypedDict):
+        """
+        The parameters for the scaling action.
+        """
+        cooldown: pulumi.Input[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.
+        """
+        direction: pulumi.Input['ScaleDirection']
+        """
+        the scale direction. Whether the scaling action increases or decreases the number of instances.
+        """
+        type: pulumi.Input['ScaleType']
+        """
+        the type of action that should occur when the scale rule fires.
         """
-        The name of receiver.
+        value: NotRequired[pulumi.Input[str]]
         """
-        return pulumi.get(self, "name")
+        the number of instances that are involved in the scaling action. This value must be 1 or greater. The default value is 1.
+        """
+elif False:
+    ScaleActionArgsDict: TypeAlias = Mapping[str, Any]
 
-    @name.setter
-    def name(self, value: pulumi.Input[str]):
-        pulumi.set(self, "name", value)
+@pulumi.input_type
+class ScaleActionArgs:
+    def __init__(__self__, *,
+                 cooldown: pulumi.Input[str],
+                 direction: pulumi.Input['ScaleDirection'],
+                 type: pulumi.Input['ScaleType'],
+                 value: Optional[pulumi.Input[str]] = None):
+        """
+        The parameters for the scaling action.
+        :param pulumi.Input[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 pulumi.Input['ScaleDirection'] direction: the scale direction. Whether the scaling action increases or decreases the number of instances.
+        :param pulumi.Input['ScaleType'] type: the type of action that should occur when the scale rule fires.
+        :param pulumi.Input[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 type(self) -> pulumi.Input[Union[str, 'ReceiverType']]:
+    def cooldown(self) -> pulumi.Input[str]:
         """
-        The type of receiver.
+        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, "type")
+        return pulumi.get(self, "cooldown")
 
-    @type.setter
-    def type(self, value: pulumi.Input[Union[str, 'ReceiverType']]):
-        pulumi.set(self, "type", value)
+    @cooldown.setter
+    def cooldown(self, value: pulumi.Input[str]):
+        pulumi.set(self, "cooldown", value)
 
     @property
     @pulumi.getter
-    def otlp(self) -> Optional[pulumi.Input['OtlpReceiverArgs']]:
+    def direction(self) -> pulumi.Input['ScaleDirection']:
         """
-        OTLP receiver configurations. This field is mandatory for OTLP and pipelineGroup receivers.
+        the scale direction. Whether the scaling action increases or decreases the number of instances.
         """
-        return pulumi.get(self, "otlp")
+        return pulumi.get(self, "direction")
 
-    @otlp.setter
-    def otlp(self, value: Optional[pulumi.Input['OtlpReceiverArgs']]):
-        pulumi.set(self, "otlp", value)
+    @direction.setter
+    def direction(self, value: pulumi.Input['ScaleDirection']):
+        pulumi.set(self, "direction", value)
 
     @property
     @pulumi.getter
-    def syslog(self) -> Optional[pulumi.Input['SyslogReceiverArgs']]:
+    def type(self) -> pulumi.Input['ScaleType']:
         """
-        Syslog configurations. This field is mandatory for syslog type receivers.
+        the type of action that should occur when the scale rule fires.
         """
-        return pulumi.get(self, "syslog")
+        return pulumi.get(self, "type")
 
-    @syslog.setter
-    def syslog(self, value: Optional[pulumi.Input['SyslogReceiverArgs']]):
-        pulumi.set(self, "syslog", value)
+    @type.setter
+    def type(self, value: pulumi.Input['ScaleType']):
+        pulumi.set(self, "type", value)
 
     @property
     @pulumi.getter
-    def udp(self) -> Optional[pulumi.Input['UdpReceiverArgs']]:
+    def value(self) -> Optional[pulumi.Input[str]]:
         """
-        UDP receiver configurations. This field is mandatory for UDP receivers.
+        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, "udp")
+        return pulumi.get(self, "value")
 
-    @udp.setter
-    def udp(self, value: Optional[pulumi.Input['UdpReceiverArgs']]):
-        pulumi.set(self, "udp", value)
+    @value.setter
+    def value(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "value", value)
 
 
 if not MYPY:
-    class RecordMapArgsDict(TypedDict):
+    class ScaleCapacityArgsDict(TypedDict):
         """
-        Record map for schema in azure monitor.
+        The number of instances that can be used during this profile.
         """
-        from_: pulumi.Input[str]
+        default: pulumi.Input[str]
         """
-        Record Map Key.
+        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.
         """
-        to: pulumi.Input[str]
+        maximum: pulumi.Input[str]
         """
-        Record Map Value.
+        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.
+        """
+        minimum: pulumi.Input[str]
+        """
+        the minimum number of instances for the resource.
         """
 elif False:
-    RecordMapArgsDict: TypeAlias = Mapping[str, Any]
+    ScaleCapacityArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class RecordMapArgs:
+class ScaleCapacityArgs:
     def __init__(__self__, *,
-                 from_: pulumi.Input[str],
-                 to: pulumi.Input[str]):
+                 default: pulumi.Input[str],
+                 maximum: pulumi.Input[str],
+                 minimum: pulumi.Input[str]):
         """
-        Record map for schema in azure monitor.
-        :param pulumi.Input[str] from_: Record Map Key.
-        :param pulumi.Input[str] to: Record Map Value.
+        The number of instances that can be used during this profile.
+        :param pulumi.Input[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 pulumi.Input[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 pulumi.Input[str] minimum: the minimum number of instances for the resource.
         """
-        pulumi.set(__self__, "from_", from_)
-        pulumi.set(__self__, "to", to)
+        pulumi.set(__self__, "default", default)
+        pulumi.set(__self__, "maximum", maximum)
+        pulumi.set(__self__, "minimum", minimum)
 
     @property
-    @pulumi.getter(name="from")
-    def from_(self) -> pulumi.Input[str]:
+    @pulumi.getter
+    def default(self) -> pulumi.Input[str]:
         """
-        Record Map Key.
+        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, "from_")
+        return pulumi.get(self, "default")
 
-    @from_.setter
-    def from_(self, value: pulumi.Input[str]):
-        pulumi.set(self, "from_", value)
+    @default.setter
+    def default(self, value: pulumi.Input[str]):
+        pulumi.set(self, "default", value)
 
     @property
     @pulumi.getter
-    def to(self) -> pulumi.Input[str]:
+    def maximum(self) -> pulumi.Input[str]:
         """
-        Record Map Value.
+        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, "to")
+        return pulumi.get(self, "maximum")
 
-    @to.setter
-    def to(self, value: pulumi.Input[str]):
-        pulumi.set(self, "to", value)
+    @maximum.setter
+    def maximum(self, value: pulumi.Input[str]):
+        pulumi.set(self, "maximum", value)
+
+    @property
+    @pulumi.getter
+    def minimum(self) -> pulumi.Input[str]:
+        """
+        the minimum number of instances for the resource.
+        """
+        return pulumi.get(self, "minimum")
+
+    @minimum.setter
+    def minimum(self, value: pulumi.Input[str]):
+        pulumi.set(self, "minimum", value)
 
 
 if not MYPY:
-    class ResourceMapArgsDict(TypedDict):
+    class ScaleRuleMetricDimensionArgsDict(TypedDict):
         """
-        Resource map for schema in azure monitor.
+        Specifies an auto scale rule metric dimension.
         """
-        from_: pulumi.Input[str]
+        dimension_name: pulumi.Input[str]
         """
-        Resource Map Key.
+        Name of the dimension.
         """
-        to: pulumi.Input[str]
+        operator: pulumi.Input[Union[str, 'ScaleRuleMetricDimensionOperationType']]
         """
-        Resource Map Value.
+        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
+        """
+        values: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        list of dimension values. For example: ["App1","App2"].
         """
 elif False:
-    ResourceMapArgsDict: TypeAlias = Mapping[str, Any]
+    ScaleRuleMetricDimensionArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class ResourceMapArgs:
+class ScaleRuleMetricDimensionArgs:
     def __init__(__self__, *,
-                 from_: pulumi.Input[str],
-                 to: pulumi.Input[str]):
+                 dimension_name: pulumi.Input[str],
+                 operator: pulumi.Input[Union[str, 'ScaleRuleMetricDimensionOperationType']],
+                 values: pulumi.Input[Sequence[pulumi.Input[str]]]):
         """
-        Resource map for schema in azure monitor.
-        :param pulumi.Input[str] from_: Resource Map Key.
-        :param pulumi.Input[str] to: Resource Map Value.
+        Specifies an auto scale rule metric dimension.
+        :param pulumi.Input[str] dimension_name: Name of the dimension.
+        :param pulumi.Input[Union[str, 'ScaleRuleMetricDimensionOperationType']] 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 pulumi.Input[Sequence[pulumi.Input[str]]] values: list of dimension values. For example: ["App1","App2"].
         """
-        pulumi.set(__self__, "from_", from_)
-        pulumi.set(__self__, "to", to)
+        pulumi.set(__self__, "dimension_name", dimension_name)
+        pulumi.set(__self__, "operator", operator)
+        pulumi.set(__self__, "values", values)
 
     @property
-    @pulumi.getter(name="from")
-    def from_(self) -> pulumi.Input[str]:
+    @pulumi.getter(name="dimensionName")
+    def dimension_name(self) -> pulumi.Input[str]:
         """
-        Resource Map Key.
+        Name of the dimension.
         """
-        return pulumi.get(self, "from_")
+        return pulumi.get(self, "dimension_name")
 
-    @from_.setter
-    def from_(self, value: pulumi.Input[str]):
-        pulumi.set(self, "from_", value)
+    @dimension_name.setter
+    def dimension_name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "dimension_name", value)
 
     @property
     @pulumi.getter
-    def to(self) -> pulumi.Input[str]:
+    def operator(self) -> pulumi.Input[Union[str, 'ScaleRuleMetricDimensionOperationType']]:
         """
-        Resource Map Value.
+        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, "to")
+        return pulumi.get(self, "operator")
 
-    @to.setter
-    def to(self, value: pulumi.Input[str]):
-        pulumi.set(self, "to", value)
+    @operator.setter
+    def operator(self, value: pulumi.Input[Union[str, 'ScaleRuleMetricDimensionOperationType']]):
+        pulumi.set(self, "operator", value)
+
+    @property
+    @pulumi.getter
+    def values(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
+        """
+        list of dimension values. For example: ["App1","App2"].
+        """
+        return pulumi.get(self, "values")
+
+    @values.setter
+    def values(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
+        pulumi.set(self, "values", value)
 
 
 if not MYPY:
-    class RuleResolveConfigurationArgsDict(TypedDict):
+    class ScaleRuleArgsDict(TypedDict):
         """
-        TBD. Relevant only for rules of the kind LogAlert.
+        A rule that provide the triggers and parameters for the scaling action.
         """
-        auto_resolved: NotRequired[pulumi.Input[bool]]
+        metric_trigger: pulumi.Input['MetricTriggerArgsDict']
         """
-        The flag that indicates whether or not to auto resolve a fired alert.
+        the trigger that results in a scaling action.
         """
-        time_to_resolve: NotRequired[pulumi.Input[str]]
+        scale_action: pulumi.Input['ScaleActionArgsDict']
         """
-        The duration a rule must evaluate as healthy before the fired alert is automatically resolved represented in ISO 8601 duration format.
+        the parameters for the scaling action.
         """
 elif False:
-    RuleResolveConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+    ScaleRuleArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class RuleResolveConfigurationArgs:
+class ScaleRuleArgs:
     def __init__(__self__, *,
-                 auto_resolved: Optional[pulumi.Input[bool]] = None,
-                 time_to_resolve: Optional[pulumi.Input[str]] = None):
+                 metric_trigger: pulumi.Input['MetricTriggerArgs'],
+                 scale_action: pulumi.Input['ScaleActionArgs']):
         """
-        TBD. Relevant only for rules of the kind LogAlert.
-        :param pulumi.Input[bool] auto_resolved: The flag that indicates whether or not to auto resolve a fired alert.
-        :param pulumi.Input[str] time_to_resolve: The duration a rule must evaluate as healthy before the fired alert is automatically resolved represented in ISO 8601 duration format.
+        A rule that provide the triggers and parameters for the scaling action.
+        :param pulumi.Input['MetricTriggerArgs'] metric_trigger: the trigger that results in a scaling action.
+        :param pulumi.Input['ScaleActionArgs'] scale_action: the parameters for the scaling action.
         """
-        if auto_resolved is not None:
-            pulumi.set(__self__, "auto_resolved", auto_resolved)
-        if time_to_resolve is not None:
-            pulumi.set(__self__, "time_to_resolve", time_to_resolve)
+        pulumi.set(__self__, "metric_trigger", metric_trigger)
+        pulumi.set(__self__, "scale_action", scale_action)
 
     @property
-    @pulumi.getter(name="autoResolved")
-    def auto_resolved(self) -> Optional[pulumi.Input[bool]]:
+    @pulumi.getter(name="metricTrigger")
+    def metric_trigger(self) -> pulumi.Input['MetricTriggerArgs']:
         """
-        The flag that indicates whether or not to auto resolve a fired alert.
+        the trigger that results in a scaling action.
         """
-        return pulumi.get(self, "auto_resolved")
+        return pulumi.get(self, "metric_trigger")
 
-    @auto_resolved.setter
-    def auto_resolved(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "auto_resolved", value)
+    @metric_trigger.setter
+    def metric_trigger(self, value: pulumi.Input['MetricTriggerArgs']):
+        pulumi.set(self, "metric_trigger", value)
 
     @property
-    @pulumi.getter(name="timeToResolve")
-    def time_to_resolve(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter(name="scaleAction")
+    def scale_action(self) -> pulumi.Input['ScaleActionArgs']:
         """
-        The duration a rule must evaluate as healthy before the fired alert is automatically resolved represented in ISO 8601 duration format.
+        the parameters for the scaling action.
         """
-        return pulumi.get(self, "time_to_resolve")
+        return pulumi.get(self, "scale_action")
 
-    @time_to_resolve.setter
-    def time_to_resolve(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "time_to_resolve", value)
+    @scale_action.setter
+    def scale_action(self, value: pulumi.Input['ScaleActionArgs']):
+        pulumi.set(self, "scale_action", value)
 
 
 if not MYPY:
@@ -3749,6 +5116,81 @@ class SmsReceiverArgs:
         pulumi.set(self, "phone_number", value)
 
 
+if not MYPY:
+    class SubscriptionLogSettingsArgsDict(TypedDict):
+        """
+        Part of Subscription diagnostic setting. Specifies the settings for a particular log.
+        """
+        enabled: pulumi.Input[bool]
+        """
+        a value indicating whether this log is enabled.
+        """
+        category: NotRequired[pulumi.Input[str]]
+        """
+        Name of a Subscription Diagnostic Log category for a resource type this setting is applied to.
+        """
+        category_group: NotRequired[pulumi.Input[str]]
+        """
+        Name of a Subscription Diagnostic Log category group for a resource type this setting is applied to.
+        """
+elif False:
+    SubscriptionLogSettingsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SubscriptionLogSettingsArgs:
+    def __init__(__self__, *,
+                 enabled: pulumi.Input[bool],
+                 category: Optional[pulumi.Input[str]] = None,
+                 category_group: Optional[pulumi.Input[str]] = None):
+        """
+        Part of Subscription diagnostic setting. Specifies the settings for a particular log.
+        :param pulumi.Input[bool] enabled: a value indicating whether this log is enabled.
+        :param pulumi.Input[str] category: Name of a Subscription Diagnostic Log category for a resource type this setting is applied to.
+        :param pulumi.Input[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) -> pulumi.Input[bool]:
+        """
+        a value indicating whether this log is enabled.
+        """
+        return pulumi.get(self, "enabled")
+
+    @enabled.setter
+    def enabled(self, value: pulumi.Input[bool]):
+        pulumi.set(self, "enabled", value)
+
+    @property
+    @pulumi.getter
+    def category(self) -> Optional[pulumi.Input[str]]:
+        """
+        Name of a Subscription Diagnostic Log category for a resource type this setting is applied to.
+        """
+        return pulumi.get(self, "category")
+
+    @category.setter
+    def category(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "category", value)
+
+    @property
+    @pulumi.getter(name="categoryGroup")
+    def category_group(self) -> Optional[pulumi.Input[str]]:
+        """
+        Name of a Subscription Diagnostic Log category group for a resource type this setting is applied to.
+        """
+        return pulumi.get(self, "category_group")
+
+    @category_group.setter
+    def category_group(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "category_group", value)
+
+
 if not MYPY:
     class SyslogReceiverArgsDict(TypedDict):
         """
@@ -3841,6 +5283,80 @@ class TcpExporterArgs:
         pulumi.set(self, "url", value)
 
 
+if not MYPY:
+    class TimeWindowArgsDict(TypedDict):
+        """
+        A specific date-time for the profile.
+        """
+        end: pulumi.Input[str]
+        """
+        the end time for the profile in ISO 8601 format.
+        """
+        start: pulumi.Input[str]
+        """
+        the start time for the profile in ISO 8601 format.
+        """
+        time_zone: NotRequired[pulumi.Input[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
+        """
+elif False:
+    TimeWindowArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class TimeWindowArgs:
+    def __init__(__self__, *,
+                 end: pulumi.Input[str],
+                 start: pulumi.Input[str],
+                 time_zone: Optional[pulumi.Input[str]] = None):
+        """
+        A specific date-time for the profile.
+        :param pulumi.Input[str] end: the end time for the profile in ISO 8601 format.
+        :param pulumi.Input[str] start: the start time for the profile in ISO 8601 format.
+        :param pulumi.Input[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) -> pulumi.Input[str]:
+        """
+        the end time for the profile in ISO 8601 format.
+        """
+        return pulumi.get(self, "end")
+
+    @end.setter
+    def end(self, value: pulumi.Input[str]):
+        pulumi.set(self, "end", value)
+
+    @property
+    @pulumi.getter
+    def start(self) -> pulumi.Input[str]:
+        """
+        the start time for the profile in ISO 8601 format.
+        """
+        return pulumi.get(self, "start")
+
+    @start.setter
+    def start(self, value: pulumi.Input[str]):
+        pulumi.set(self, "start", value)
+
+    @property
+    @pulumi.getter(name="timeZone")
+    def time_zone(self) -> Optional[pulumi.Input[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")
+
+    @time_zone.setter
+    def time_zone(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "time_zone", value)
+
+
 if not MYPY:
     class UdpReceiverArgsDict(TypedDict):
         """
@@ -4013,6 +5529,62 @@ class VoiceReceiverArgs:
         pulumi.set(self, "phone_number", value)
 
 
+if not MYPY:
+    class WebhookNotificationArgsDict(TypedDict):
+        """
+        Webhook notification of an autoscale event.
+        """
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        a property bag of settings. This value can be empty.
+        """
+        service_uri: NotRequired[pulumi.Input[str]]
+        """
+        the service address to receive the notification.
+        """
+elif False:
+    WebhookNotificationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class WebhookNotificationArgs:
+    def __init__(__self__, *,
+                 properties: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 service_uri: Optional[pulumi.Input[str]] = None):
+        """
+        Webhook notification of an autoscale event.
+        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] properties: a property bag of settings. This value can be empty.
+        :param pulumi.Input[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[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
+        """
+        a property bag of settings. This value can be empty.
+        """
+        return pulumi.get(self, "properties")
+
+    @properties.setter
+    def properties(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
+        pulumi.set(self, "properties", value)
+
+    @property
+    @pulumi.getter(name="serviceUri")
+    def service_uri(self) -> Optional[pulumi.Input[str]]:
+        """
+        the service address to receive the notification.
+        """
+        return pulumi.get(self, "service_uri")
+
+    @service_uri.setter
+    def service_uri(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "service_uri", value)
+
+
 if not MYPY:
     class WebhookReceiverArgsDict(TypedDict):
         """