# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'AadDiagnosticSettingLog',
    'AadDiagnosticSettingLogRetentionPolicy',
    'ActionGroupArmRoleReceiver',
    'ActionGroupAutomationRunbookReceiver',
    'ActionGroupAzureAppPushReceiver',
    'ActionGroupAzureFunctionReceiver',
    'ActionGroupEmailReceiver',
    'ActionGroupItsmReceiver',
    'ActionGroupLogicAppReceiver',
    'ActionGroupSmsReceiver',
    'ActionGroupVoiceReceiver',
    'ActionGroupWebhookReceiver',
    'ActionGroupWebhookReceiverAadAuth',
    'ActionRuleActionGroupCondition',
    'ActionRuleActionGroupConditionAlertContext',
    'ActionRuleActionGroupConditionAlertRuleId',
    'ActionRuleActionGroupConditionDescription',
    'ActionRuleActionGroupConditionMonitor',
    'ActionRuleActionGroupConditionMonitorService',
    'ActionRuleActionGroupConditionSeverity',
    'ActionRuleActionGroupConditionTargetResourceType',
    'ActionRuleActionGroupScope',
    'ActionRuleSuppressionCondition',
    'ActionRuleSuppressionConditionAlertContext',
    'ActionRuleSuppressionConditionAlertRuleId',
    'ActionRuleSuppressionConditionDescription',
    'ActionRuleSuppressionConditionMonitor',
    'ActionRuleSuppressionConditionMonitorService',
    'ActionRuleSuppressionConditionSeverity',
    'ActionRuleSuppressionConditionTargetResourceType',
    'ActionRuleSuppressionScope',
    'ActionRuleSuppressionSuppression',
    'ActionRuleSuppressionSuppressionSchedule',
    'ActivityLogAlertAction',
    'ActivityLogAlertCriteria',
    'ActivityLogAlertCriteriaServiceHealth',
    'AutoscaleSettingNotification',
    'AutoscaleSettingNotificationEmail',
    'AutoscaleSettingNotificationWebhook',
    'AutoscaleSettingProfile',
    'AutoscaleSettingProfileCapacity',
    'AutoscaleSettingProfileFixedDate',
    'AutoscaleSettingProfileRecurrence',
    'AutoscaleSettingProfileRule',
    'AutoscaleSettingProfileRuleMetricTrigger',
    'AutoscaleSettingProfileRuleMetricTriggerDimension',
    'AutoscaleSettingProfileRuleScaleAction',
    'DiagnosticSettingLog',
    'DiagnosticSettingLogRetentionPolicy',
    'DiagnosticSettingMetric',
    'DiagnosticSettingMetricRetentionPolicy',
    'LogProfileRetentionPolicy',
    'MetricAlertAction',
    'MetricAlertApplicationInsightsWebTestLocationAvailabilityCriteria',
    'MetricAlertCriteria',
    'MetricAlertCriteriaDimension',
    'MetricAlertDynamicCriteria',
    'MetricAlertDynamicCriteriaDimension',
    'ScheduledQueryRulesAlertAction',
    'ScheduledQueryRulesAlertTrigger',
    'ScheduledQueryRulesAlertTriggerMetricTrigger',
    'ScheduledQueryRulesLogCriteria',
    'ScheduledQueryRulesLogCriteriaDimension',
    'SmartDetectorAlertRuleActionGroup',
    'GetActionGroupArmRoleReceiverResult',
    'GetActionGroupAutomationRunbookReceiverResult',
    'GetActionGroupAzureAppPushReceiverResult',
    'GetActionGroupAzureFunctionReceiverResult',
    'GetActionGroupEmailReceiverResult',
    'GetActionGroupItsmReceiverResult',
    'GetActionGroupLogicAppReceiverResult',
    'GetActionGroupSmsReceiverResult',
    'GetActionGroupVoiceReceiverResult',
    'GetActionGroupWebhookReceiverResult',
    'GetActionGroupWebhookReceiverAadAuthResult',
    'GetLogProfileRetentionPolicyResult',
    'GetScheduledQueryRulesAlertActionResult',
    'GetScheduledQueryRulesAlertTriggerResult',
    'GetScheduledQueryRulesAlertTriggerMetricTriggerResult',
    'GetScheduledQueryRulesLogCriteriaResult',
    'GetScheduledQueryRulesLogCriteriaDimensionResult',
]

@pulumi.output_type
class AadDiagnosticSettingLog(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "retentionPolicy":
            suggest = "retention_policy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AadDiagnosticSettingLog. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AadDiagnosticSettingLog.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AadDiagnosticSettingLog.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 category: str,
                 retention_policy: 'outputs.AadDiagnosticSettingLogRetentionPolicy',
                 enabled: Optional[bool] = None):
        """
        :param str category: The log category for the Azure Active Directory Diagnostic. Possible values are `AuditLogs`, `SignInLogs`, `ADFSSignInLogs`, `ManagedIdentitySignInLogs`, `NonInteractiveUserSignInLogs`, `ProvisioningLogs`, `ServicePrincipalSignInLogs`.
        :param 'AadDiagnosticSettingLogRetentionPolicyArgs' retention_policy: A `retention_policy` block as defined below.
        :param bool enabled: Is this Diagnostic Log enabled? Defaults to `true`.
        """
        pulumi.set(__self__, "category", category)
        pulumi.set(__self__, "retention_policy", retention_policy)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def category(self) -> str:
        """
        The log category for the Azure Active Directory Diagnostic. Possible values are `AuditLogs`, `SignInLogs`, `ADFSSignInLogs`, `ManagedIdentitySignInLogs`, `NonInteractiveUserSignInLogs`, `ProvisioningLogs`, `ServicePrincipalSignInLogs`.
        """
        return pulumi.get(self, "category")

    @property
    @pulumi.getter(name="retentionPolicy")
    def retention_policy(self) -> 'outputs.AadDiagnosticSettingLogRetentionPolicy':
        """
        A `retention_policy` block as defined below.
        """
        return pulumi.get(self, "retention_policy")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Is this Diagnostic Log enabled? Defaults to `true`.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class AadDiagnosticSettingLogRetentionPolicy(dict):
    def __init__(__self__, *,
                 days: Optional[int] = None,
                 enabled: Optional[bool] = None):
        """
        :param int days: The number of days for which this Retention Policy should apply. Defaults to `0`.
        :param bool enabled: Is this Retention Policy enabled? Defaults to `false`.
        """
        if days is not None:
            pulumi.set(__self__, "days", days)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def days(self) -> Optional[int]:
        """
        The number of days for which this Retention Policy should apply. Defaults to `0`.
        """
        return pulumi.get(self, "days")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Is this Retention Policy enabled? Defaults to `false`.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class ActionGroupArmRoleReceiver(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "roleId":
            suggest = "role_id"
        elif key == "useCommonAlertSchema":
            suggest = "use_common_alert_schema"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ActionGroupArmRoleReceiver. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ActionGroupArmRoleReceiver.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ActionGroupArmRoleReceiver.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 role_id: str,
                 use_common_alert_schema: Optional[bool] = None):
        """
        :param str name: The name of the ARM role receiver.
        :param str role_id: The arm role id.
        :param bool use_common_alert_schema: Enables or disables the common alert schema.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "role_id", role_id)
        if use_common_alert_schema is not None:
            pulumi.set(__self__, "use_common_alert_schema", use_common_alert_schema)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the ARM role receiver.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="roleId")
    def role_id(self) -> str:
        """
        The arm role id.
        """
        return pulumi.get(self, "role_id")

    @property
    @pulumi.getter(name="useCommonAlertSchema")
    def use_common_alert_schema(self) -> Optional[bool]:
        """
        Enables or disables the common alert schema.
        """
        return pulumi.get(self, "use_common_alert_schema")


@pulumi.output_type
class ActionGroupAutomationRunbookReceiver(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "automationAccountId":
            suggest = "automation_account_id"
        elif key == "isGlobalRunbook":
            suggest = "is_global_runbook"
        elif key == "runbookName":
            suggest = "runbook_name"
        elif key == "serviceUri":
            suggest = "service_uri"
        elif key == "webhookResourceId":
            suggest = "webhook_resource_id"
        elif key == "useCommonAlertSchema":
            suggest = "use_common_alert_schema"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ActionGroupAutomationRunbookReceiver. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ActionGroupAutomationRunbookReceiver.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ActionGroupAutomationRunbookReceiver.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 automation_account_id: str,
                 is_global_runbook: bool,
                 name: str,
                 runbook_name: str,
                 service_uri: str,
                 webhook_resource_id: str,
                 use_common_alert_schema: Optional[bool] = None):
        """
        :param str automation_account_id: The automation account ID which holds this runbook and authenticates to Azure resources.
        :param bool is_global_runbook: Indicates whether this instance is global runbook.
        :param str name: The name of the automation runbook receiver.
        :param str runbook_name: The name for this runbook.
        :param str service_uri: The URI where webhooks should be sent.
        :param str webhook_resource_id: The resource id for webhook linked to this runbook.
        :param bool use_common_alert_schema: Enables or disables the common alert schema.
        """
        pulumi.set(__self__, "automation_account_id", automation_account_id)
        pulumi.set(__self__, "is_global_runbook", is_global_runbook)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "runbook_name", runbook_name)
        pulumi.set(__self__, "service_uri", service_uri)
        pulumi.set(__self__, "webhook_resource_id", webhook_resource_id)
        if use_common_alert_schema is not None:
            pulumi.set(__self__, "use_common_alert_schema", use_common_alert_schema)

    @property
    @pulumi.getter(name="automationAccountId")
    def automation_account_id(self) -> str:
        """
        The automation account ID which holds this runbook and authenticates to Azure resources.
        """
        return pulumi.get(self, "automation_account_id")

    @property
    @pulumi.getter(name="isGlobalRunbook")
    def is_global_runbook(self) -> bool:
        """
        Indicates whether this instance is global runbook.
        """
        return pulumi.get(self, "is_global_runbook")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the automation runbook receiver.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="runbookName")
    def runbook_name(self) -> str:
        """
        The name for this runbook.
        """
        return pulumi.get(self, "runbook_name")

    @property
    @pulumi.getter(name="serviceUri")
    def service_uri(self) -> str:
        """
        The URI where webhooks should be sent.
        """
        return pulumi.get(self, "service_uri")

    @property
    @pulumi.getter(name="webhookResourceId")
    def webhook_resource_id(self) -> str:
        """
        The resource id for webhook linked to this runbook.
        """
        return pulumi.get(self, "webhook_resource_id")

    @property
    @pulumi.getter(name="useCommonAlertSchema")
    def use_common_alert_schema(self) -> Optional[bool]:
        """
        Enables or disables the common alert schema.
        """
        return pulumi.get(self, "use_common_alert_schema")


@pulumi.output_type
class ActionGroupAzureAppPushReceiver(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "emailAddress":
            suggest = "email_address"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ActionGroupAzureAppPushReceiver. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ActionGroupAzureAppPushReceiver.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ActionGroupAzureAppPushReceiver.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 email_address: str,
                 name: str):
        """
        :param str email_address: The email address of the user signed into the mobile app who will receive push notifications from this receiver.
        :param str name: The name of the Azure app push receiver.
        """
        pulumi.set(__self__, "email_address", email_address)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter(name="emailAddress")
    def email_address(self) -> str:
        """
        The email address of the user signed into the mobile app who will receive push notifications from this receiver.
        """
        return pulumi.get(self, "email_address")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Azure app push receiver.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class ActionGroupAzureFunctionReceiver(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "functionAppResourceId":
            suggest = "function_app_resource_id"
        elif key == "functionName":
            suggest = "function_name"
        elif key == "httpTriggerUrl":
            suggest = "http_trigger_url"
        elif key == "useCommonAlertSchema":
            suggest = "use_common_alert_schema"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ActionGroupAzureFunctionReceiver. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ActionGroupAzureFunctionReceiver.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ActionGroupAzureFunctionReceiver.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 function_app_resource_id: str,
                 function_name: str,
                 http_trigger_url: str,
                 name: str,
                 use_common_alert_schema: Optional[bool] = None):
        """
        :param str function_app_resource_id: The Azure resource ID of the function app.
        :param str function_name: The function name in the function app.
        :param str http_trigger_url: The http trigger url where http request sent to.
        :param str name: The name of the Azure Function receiver.
        :param bool use_common_alert_schema: Enables or disables the common alert schema.
        """
        pulumi.set(__self__, "function_app_resource_id", function_app_resource_id)
        pulumi.set(__self__, "function_name", function_name)
        pulumi.set(__self__, "http_trigger_url", http_trigger_url)
        pulumi.set(__self__, "name", name)
        if use_common_alert_schema is not None:
            pulumi.set(__self__, "use_common_alert_schema", use_common_alert_schema)

    @property
    @pulumi.getter(name="functionAppResourceId")
    def function_app_resource_id(self) -> str:
        """
        The Azure resource ID of the function app.
        """
        return pulumi.get(self, "function_app_resource_id")

    @property
    @pulumi.getter(name="functionName")
    def function_name(self) -> str:
        """
        The function name in the function app.
        """
        return pulumi.get(self, "function_name")

    @property
    @pulumi.getter(name="httpTriggerUrl")
    def http_trigger_url(self) -> str:
        """
        The http trigger url where http request sent to.
        """
        return pulumi.get(self, "http_trigger_url")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Azure Function receiver.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="useCommonAlertSchema")
    def use_common_alert_schema(self) -> Optional[bool]:
        """
        Enables or disables the common alert schema.
        """
        return pulumi.get(self, "use_common_alert_schema")


@pulumi.output_type
class ActionGroupEmailReceiver(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "emailAddress":
            suggest = "email_address"
        elif key == "useCommonAlertSchema":
            suggest = "use_common_alert_schema"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ActionGroupEmailReceiver. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ActionGroupEmailReceiver.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ActionGroupEmailReceiver.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 email_address: str,
                 name: str,
                 use_common_alert_schema: Optional[bool] = None):
        """
        :param str email_address: The email address of this receiver.
        :param str name: The name of the email receiver. Names must be unique (case-insensitive) across all receivers within an action group.
        :param bool use_common_alert_schema: Enables or disables the common alert schema.
        """
        pulumi.set(__self__, "email_address", email_address)
        pulumi.set(__self__, "name", name)
        if use_common_alert_schema is not None:
            pulumi.set(__self__, "use_common_alert_schema", use_common_alert_schema)

    @property
    @pulumi.getter(name="emailAddress")
    def email_address(self) -> str:
        """
        The email address of this receiver.
        """
        return pulumi.get(self, "email_address")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the email receiver. Names must be unique (case-insensitive) across all receivers within an action group.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="useCommonAlertSchema")
    def use_common_alert_schema(self) -> Optional[bool]:
        """
        Enables or disables the common alert schema.
        """
        return pulumi.get(self, "use_common_alert_schema")


@pulumi.output_type
class ActionGroupItsmReceiver(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "connectionId":
            suggest = "connection_id"
        elif key == "ticketConfiguration":
            suggest = "ticket_configuration"
        elif key == "workspaceId":
            suggest = "workspace_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ActionGroupItsmReceiver. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ActionGroupItsmReceiver.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ActionGroupItsmReceiver.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 connection_id: str,
                 name: str,
                 region: str,
                 ticket_configuration: str,
                 workspace_id: str):
        """
        :param str connection_id: The unique connection identifier of the ITSM connection.
        :param str name: The name of the ITSM receiver.
        :param str region: The region of the workspace.
        :param str ticket_configuration: A JSON blob for the configurations of the ITSM action. CreateMultipleWorkItems option will be part of this blob as well.
        :param str workspace_id: The Azure Log Analytics workspace ID where this connection is defined.
        """
        pulumi.set(__self__, "connection_id", connection_id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "ticket_configuration", ticket_configuration)
        pulumi.set(__self__, "workspace_id", workspace_id)

    @property
    @pulumi.getter(name="connectionId")
    def connection_id(self) -> str:
        """
        The unique connection identifier of the ITSM connection.
        """
        return pulumi.get(self, "connection_id")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the ITSM receiver.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        The region of the workspace.
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="ticketConfiguration")
    def ticket_configuration(self) -> str:
        """
        A JSON blob for the configurations of the ITSM action. CreateMultipleWorkItems option will be part of this blob as well.
        """
        return pulumi.get(self, "ticket_configuration")

    @property
    @pulumi.getter(name="workspaceId")
    def workspace_id(self) -> str:
        """
        The Azure Log Analytics workspace ID where this connection is defined.
        """
        return pulumi.get(self, "workspace_id")


@pulumi.output_type
class ActionGroupLogicAppReceiver(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "callbackUrl":
            suggest = "callback_url"
        elif key == "resourceId":
            suggest = "resource_id"
        elif key == "useCommonAlertSchema":
            suggest = "use_common_alert_schema"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ActionGroupLogicAppReceiver. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ActionGroupLogicAppReceiver.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ActionGroupLogicAppReceiver.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 callback_url: str,
                 name: str,
                 resource_id: str,
                 use_common_alert_schema: Optional[bool] = None):
        """
        :param str callback_url: The callback url where http request sent to.
        :param str name: The name of the logic app receiver.
        :param str resource_id: The Azure resource ID of the logic app.
        :param bool use_common_alert_schema: Enables or disables the common alert schema.
        """
        pulumi.set(__self__, "callback_url", callback_url)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "resource_id", resource_id)
        if use_common_alert_schema is not None:
            pulumi.set(__self__, "use_common_alert_schema", use_common_alert_schema)

    @property
    @pulumi.getter(name="callbackUrl")
    def callback_url(self) -> str:
        """
        The callback url where http request sent to.
        """
        return pulumi.get(self, "callback_url")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the logic app receiver.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="resourceId")
    def resource_id(self) -> str:
        """
        The Azure resource ID of the logic app.
        """
        return pulumi.get(self, "resource_id")

    @property
    @pulumi.getter(name="useCommonAlertSchema")
    def use_common_alert_schema(self) -> Optional[bool]:
        """
        Enables or disables the common alert schema.
        """
        return pulumi.get(self, "use_common_alert_schema")


@pulumi.output_type
class ActionGroupSmsReceiver(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "countryCode":
            suggest = "country_code"
        elif key == "phoneNumber":
            suggest = "phone_number"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ActionGroupSmsReceiver. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ActionGroupSmsReceiver.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ActionGroupSmsReceiver.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 country_code: str,
                 name: str,
                 phone_number: str):
        """
        :param str country_code: The country code of the SMS receiver.
        :param str name: The name of the SMS receiver. Names must be unique (case-insensitive) across all receivers within an action group.
        :param str phone_number: The phone number of the SMS receiver.
        """
        pulumi.set(__self__, "country_code", country_code)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "phone_number", phone_number)

    @property
    @pulumi.getter(name="countryCode")
    def country_code(self) -> str:
        """
        The country code of the SMS receiver.
        """
        return pulumi.get(self, "country_code")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the SMS receiver. Names must be unique (case-insensitive) across all receivers within an action group.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="phoneNumber")
    def phone_number(self) -> str:
        """
        The phone number of the SMS receiver.
        """
        return pulumi.get(self, "phone_number")


@pulumi.output_type
class ActionGroupVoiceReceiver(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "countryCode":
            suggest = "country_code"
        elif key == "phoneNumber":
            suggest = "phone_number"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ActionGroupVoiceReceiver. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ActionGroupVoiceReceiver.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ActionGroupVoiceReceiver.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 country_code: str,
                 name: str,
                 phone_number: str):
        """
        :param str country_code: The country code of the voice receiver.
        :param str name: The name of the voice receiver.
        :param str phone_number: The phone number of the voice receiver.
        """
        pulumi.set(__self__, "country_code", country_code)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "phone_number", phone_number)

    @property
    @pulumi.getter(name="countryCode")
    def country_code(self) -> str:
        """
        The country code of the voice receiver.
        """
        return pulumi.get(self, "country_code")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the voice receiver.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="phoneNumber")
    def phone_number(self) -> str:
        """
        The phone number of the voice receiver.
        """
        return pulumi.get(self, "phone_number")


@pulumi.output_type
class ActionGroupWebhookReceiver(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "serviceUri":
            suggest = "service_uri"
        elif key == "aadAuth":
            suggest = "aad_auth"
        elif key == "useCommonAlertSchema":
            suggest = "use_common_alert_schema"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ActionGroupWebhookReceiver. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ActionGroupWebhookReceiver.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ActionGroupWebhookReceiver.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 service_uri: str,
                 aad_auth: Optional['outputs.ActionGroupWebhookReceiverAadAuth'] = None,
                 use_common_alert_schema: Optional[bool] = None):
        """
        :param str name: The name of the webhook receiver. Names must be unique (case-insensitive) across all receivers within an action group.
        :param str service_uri: The URI where webhooks should be sent.
        :param 'ActionGroupWebhookReceiverAadAuthArgs' aad_auth: The `aad_auth` block as defined below
        :param bool use_common_alert_schema: Enables or disables the common alert schema.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "service_uri", service_uri)
        if aad_auth is not None:
            pulumi.set(__self__, "aad_auth", aad_auth)
        if use_common_alert_schema is not None:
            pulumi.set(__self__, "use_common_alert_schema", use_common_alert_schema)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the webhook receiver. Names must be unique (case-insensitive) across all receivers within an action group.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="serviceUri")
    def service_uri(self) -> str:
        """
        The URI where webhooks should be sent.
        """
        return pulumi.get(self, "service_uri")

    @property
    @pulumi.getter(name="aadAuth")
    def aad_auth(self) -> Optional['outputs.ActionGroupWebhookReceiverAadAuth']:
        """
        The `aad_auth` block as defined below
        """
        return pulumi.get(self, "aad_auth")

    @property
    @pulumi.getter(name="useCommonAlertSchema")
    def use_common_alert_schema(self) -> Optional[bool]:
        """
        Enables or disables the common alert schema.
        """
        return pulumi.get(self, "use_common_alert_schema")


@pulumi.output_type
class ActionGroupWebhookReceiverAadAuth(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "objectId":
            suggest = "object_id"
        elif key == "identifierUri":
            suggest = "identifier_uri"
        elif key == "tenantId":
            suggest = "tenant_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ActionGroupWebhookReceiverAadAuth. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ActionGroupWebhookReceiverAadAuth.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ActionGroupWebhookReceiverAadAuth.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 object_id: str,
                 identifier_uri: Optional[str] = None,
                 tenant_id: Optional[str] = None):
        """
        :param str object_id: The webhook application object Id for aad auth.
        :param str identifier_uri: The identifier uri for aad auth.
        :param str tenant_id: The tenant id for aad auth.
        """
        pulumi.set(__self__, "object_id", object_id)
        if identifier_uri is not None:
            pulumi.set(__self__, "identifier_uri", identifier_uri)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)

    @property
    @pulumi.getter(name="objectId")
    def object_id(self) -> str:
        """
        The webhook application object Id for aad auth.
        """
        return pulumi.get(self, "object_id")

    @property
    @pulumi.getter(name="identifierUri")
    def identifier_uri(self) -> Optional[str]:
        """
        The identifier uri for aad auth.
        """
        return pulumi.get(self, "identifier_uri")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[str]:
        """
        The tenant id for aad auth.
        """
        return pulumi.get(self, "tenant_id")


@pulumi.output_type
class ActionRuleActionGroupCondition(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "alertContext":
            suggest = "alert_context"
        elif key == "alertRuleId":
            suggest = "alert_rule_id"
        elif key == "monitorService":
            suggest = "monitor_service"
        elif key == "targetResourceType":
            suggest = "target_resource_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ActionRuleActionGroupCondition. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ActionRuleActionGroupCondition.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ActionRuleActionGroupCondition.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 alert_context: Optional['outputs.ActionRuleActionGroupConditionAlertContext'] = None,
                 alert_rule_id: Optional['outputs.ActionRuleActionGroupConditionAlertRuleId'] = None,
                 description: Optional['outputs.ActionRuleActionGroupConditionDescription'] = None,
                 monitor: Optional['outputs.ActionRuleActionGroupConditionMonitor'] = None,
                 monitor_service: Optional['outputs.ActionRuleActionGroupConditionMonitorService'] = None,
                 severity: Optional['outputs.ActionRuleActionGroupConditionSeverity'] = None,
                 target_resource_type: Optional['outputs.ActionRuleActionGroupConditionTargetResourceType'] = None):
        """
        :param 'ActionRuleActionGroupConditionAlertContextArgs' alert_context: A `alert_context` block as defined below.
        :param 'ActionRuleActionGroupConditionAlertRuleIdArgs' alert_rule_id: A `alert_rule_id` block as defined below.
        :param 'ActionRuleActionGroupConditionDescriptionArgs' description: A `description` block as defined below.
        :param 'ActionRuleActionGroupConditionMonitorArgs' monitor: A `monitor` block as defined below.
        :param 'ActionRuleActionGroupConditionMonitorServiceArgs' monitor_service: A `monitor_service` as block defined below.
        :param 'ActionRuleActionGroupConditionSeverityArgs' severity: A `severity` block as defined below.
        :param 'ActionRuleActionGroupConditionTargetResourceTypeArgs' target_resource_type: A `target_resource_type` block as defined below.
        """
        if alert_context is not None:
            pulumi.set(__self__, "alert_context", alert_context)
        if alert_rule_id is not None:
            pulumi.set(__self__, "alert_rule_id", alert_rule_id)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if monitor is not None:
            pulumi.set(__self__, "monitor", monitor)
        if monitor_service is not None:
            pulumi.set(__self__, "monitor_service", monitor_service)
        if severity is not None:
            pulumi.set(__self__, "severity", severity)
        if target_resource_type is not None:
            pulumi.set(__self__, "target_resource_type", target_resource_type)

    @property
    @pulumi.getter(name="alertContext")
    def alert_context(self) -> Optional['outputs.ActionRuleActionGroupConditionAlertContext']:
        """
        A `alert_context` block as defined below.
        """
        return pulumi.get(self, "alert_context")

    @property
    @pulumi.getter(name="alertRuleId")
    def alert_rule_id(self) -> Optional['outputs.ActionRuleActionGroupConditionAlertRuleId']:
        """
        A `alert_rule_id` block as defined below.
        """
        return pulumi.get(self, "alert_rule_id")

    @property
    @pulumi.getter
    def description(self) -> Optional['outputs.ActionRuleActionGroupConditionDescription']:
        """
        A `description` block as defined below.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def monitor(self) -> Optional['outputs.ActionRuleActionGroupConditionMonitor']:
        """
        A `monitor` block as defined below.
        """
        return pulumi.get(self, "monitor")

    @property
    @pulumi.getter(name="monitorService")
    def monitor_service(self) -> Optional['outputs.ActionRuleActionGroupConditionMonitorService']:
        """
        A `monitor_service` as block defined below.
        """
        return pulumi.get(self, "monitor_service")

    @property
    @pulumi.getter
    def severity(self) -> Optional['outputs.ActionRuleActionGroupConditionSeverity']:
        """
        A `severity` block as defined below.
        """
        return pulumi.get(self, "severity")

    @property
    @pulumi.getter(name="targetResourceType")
    def target_resource_type(self) -> Optional['outputs.ActionRuleActionGroupConditionTargetResourceType']:
        """
        A `target_resource_type` block as defined below.
        """
        return pulumi.get(self, "target_resource_type")


@pulumi.output_type
class ActionRuleActionGroupConditionAlertContext(dict):
    def __init__(__self__, *,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str operator: The operator for a given condition. Possible values are `Equals`, `NotEquals`, `Contains`, and `DoesNotContain`.
        :param Sequence[str] values: A list of values to match for a given condition.
        """
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The operator for a given condition. Possible values are `Equals`, `NotEquals`, `Contains`, and `DoesNotContain`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        A list of values to match for a given condition.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ActionRuleActionGroupConditionAlertRuleId(dict):
    def __init__(__self__, *,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str operator: The operator for a given condition. Possible values are `Equals`, `NotEquals`, `Contains`, and `DoesNotContain`.
        :param Sequence[str] values: A list of values to match for a given condition.
        """
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The operator for a given condition. Possible values are `Equals`, `NotEquals`, `Contains`, and `DoesNotContain`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        A list of values to match for a given condition.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ActionRuleActionGroupConditionDescription(dict):
    def __init__(__self__, *,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str operator: The operator for a given condition. Possible values are `Equals`, `NotEquals`, `Contains`, and `DoesNotContain`.
        :param Sequence[str] values: A list of values to match for a given condition.
        """
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The operator for a given condition. Possible values are `Equals`, `NotEquals`, `Contains`, and `DoesNotContain`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        A list of values to match for a given condition.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ActionRuleActionGroupConditionMonitor(dict):
    def __init__(__self__, *,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str operator: The operator for a given condition. Possible values are `Equals` and `NotEquals`.
        :param Sequence[str] values: A list of values to match for a given condition. Possible values are `Fired` and `Resolved`.
        """
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The operator for a given condition. Possible values are `Equals` and `NotEquals`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        A list of values to match for a given condition. Possible values are `Fired` and `Resolved`.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ActionRuleActionGroupConditionMonitorService(dict):
    def __init__(__self__, *,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str operator: The operator for a given condition. Possible values are `Equals` and `NotEquals`.
        :param Sequence[str] values: A list of values to match for a given condition. Possible values are `ActivityLog Administrative`, `ActivityLog Autoscale`, `ActivityLog Policy`, `ActivityLog Recommendation`, `ActivityLog Security`, `Application Insights`, `Azure Backup`, `Data Box Edge`, `Data Box Gateway`, `Health Platform`, `Log Analytics`, `Platform`, and `Resource Health`.
        """
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The operator for a given condition. Possible values are `Equals` and `NotEquals`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        A list of values to match for a given condition. Possible values are `ActivityLog Administrative`, `ActivityLog Autoscale`, `ActivityLog Policy`, `ActivityLog Recommendation`, `ActivityLog Security`, `Application Insights`, `Azure Backup`, `Data Box Edge`, `Data Box Gateway`, `Health Platform`, `Log Analytics`, `Platform`, and `Resource Health`.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ActionRuleActionGroupConditionSeverity(dict):
    def __init__(__self__, *,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str operator: The operator for a given condition. Possible values are `Equals`and `NotEquals`.
        :param Sequence[str] values: A list of values to match for a given condition. Possible values are `Sev0`, `Sev1`, `Sev2`, `Sev3`, and `Sev4`.
        """
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The operator for a given condition. Possible values are `Equals`and `NotEquals`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        A list of values to match for a given condition. Possible values are `Sev0`, `Sev1`, `Sev2`, `Sev3`, and `Sev4`.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ActionRuleActionGroupConditionTargetResourceType(dict):
    def __init__(__self__, *,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str operator: The operator for a given condition. Possible values are `Equals` and `NotEquals`.
        :param Sequence[str] values: A list of values to match for a given condition. The values should be valid resource types.
        """
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The operator for a given condition. Possible values are `Equals` and `NotEquals`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        A list of values to match for a given condition. The values should be valid resource types.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ActionRuleActionGroupScope(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceIds":
            suggest = "resource_ids"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ActionRuleActionGroupScope. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ActionRuleActionGroupScope.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ActionRuleActionGroupScope.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 resource_ids: Sequence[str],
                 type: str):
        """
        :param Sequence[str] resource_ids: A list of resource IDs of the given scope type which will be the target of action rule.
        :param str type: Specifies the type of target scope. Possible values are `ResourceGroup` and `Resource`.
        """
        pulumi.set(__self__, "resource_ids", resource_ids)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="resourceIds")
    def resource_ids(self) -> Sequence[str]:
        """
        A list of resource IDs of the given scope type which will be the target of action rule.
        """
        return pulumi.get(self, "resource_ids")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Specifies the type of target scope. Possible values are `ResourceGroup` and `Resource`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class ActionRuleSuppressionCondition(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "alertContext":
            suggest = "alert_context"
        elif key == "alertRuleId":
            suggest = "alert_rule_id"
        elif key == "monitorService":
            suggest = "monitor_service"
        elif key == "targetResourceType":
            suggest = "target_resource_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ActionRuleSuppressionCondition. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ActionRuleSuppressionCondition.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ActionRuleSuppressionCondition.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 alert_context: Optional['outputs.ActionRuleSuppressionConditionAlertContext'] = None,
                 alert_rule_id: Optional['outputs.ActionRuleSuppressionConditionAlertRuleId'] = None,
                 description: Optional['outputs.ActionRuleSuppressionConditionDescription'] = None,
                 monitor: Optional['outputs.ActionRuleSuppressionConditionMonitor'] = None,
                 monitor_service: Optional['outputs.ActionRuleSuppressionConditionMonitorService'] = None,
                 severity: Optional['outputs.ActionRuleSuppressionConditionSeverity'] = None,
                 target_resource_type: Optional['outputs.ActionRuleSuppressionConditionTargetResourceType'] = None):
        """
        :param 'ActionRuleSuppressionConditionAlertContextArgs' alert_context: A `alert_context` block as defined below.
        :param 'ActionRuleSuppressionConditionAlertRuleIdArgs' alert_rule_id: A `alert_rule_id` block as defined below.
        :param 'ActionRuleSuppressionConditionDescriptionArgs' description: A `description` block as defined below.
        :param 'ActionRuleSuppressionConditionMonitorArgs' monitor: A `monitor` block as defined below.
        :param 'ActionRuleSuppressionConditionMonitorServiceArgs' monitor_service: A `monitor_service` as block defined below.
        :param 'ActionRuleSuppressionConditionSeverityArgs' severity: A `severity` block as defined below.
        :param 'ActionRuleSuppressionConditionTargetResourceTypeArgs' target_resource_type: A `target_resource_type` block as defined below.
        """
        if alert_context is not None:
            pulumi.set(__self__, "alert_context", alert_context)
        if alert_rule_id is not None:
            pulumi.set(__self__, "alert_rule_id", alert_rule_id)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if monitor is not None:
            pulumi.set(__self__, "monitor", monitor)
        if monitor_service is not None:
            pulumi.set(__self__, "monitor_service", monitor_service)
        if severity is not None:
            pulumi.set(__self__, "severity", severity)
        if target_resource_type is not None:
            pulumi.set(__self__, "target_resource_type", target_resource_type)

    @property
    @pulumi.getter(name="alertContext")
    def alert_context(self) -> Optional['outputs.ActionRuleSuppressionConditionAlertContext']:
        """
        A `alert_context` block as defined below.
        """
        return pulumi.get(self, "alert_context")

    @property
    @pulumi.getter(name="alertRuleId")
    def alert_rule_id(self) -> Optional['outputs.ActionRuleSuppressionConditionAlertRuleId']:
        """
        A `alert_rule_id` block as defined below.
        """
        return pulumi.get(self, "alert_rule_id")

    @property
    @pulumi.getter
    def description(self) -> Optional['outputs.ActionRuleSuppressionConditionDescription']:
        """
        A `description` block as defined below.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def monitor(self) -> Optional['outputs.ActionRuleSuppressionConditionMonitor']:
        """
        A `monitor` block as defined below.
        """
        return pulumi.get(self, "monitor")

    @property
    @pulumi.getter(name="monitorService")
    def monitor_service(self) -> Optional['outputs.ActionRuleSuppressionConditionMonitorService']:
        """
        A `monitor_service` as block defined below.
        """
        return pulumi.get(self, "monitor_service")

    @property
    @pulumi.getter
    def severity(self) -> Optional['outputs.ActionRuleSuppressionConditionSeverity']:
        """
        A `severity` block as defined below.
        """
        return pulumi.get(self, "severity")

    @property
    @pulumi.getter(name="targetResourceType")
    def target_resource_type(self) -> Optional['outputs.ActionRuleSuppressionConditionTargetResourceType']:
        """
        A `target_resource_type` block as defined below.
        """
        return pulumi.get(self, "target_resource_type")


@pulumi.output_type
class ActionRuleSuppressionConditionAlertContext(dict):
    def __init__(__self__, *,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str operator: The operator for a given condition. Possible values are `Equals`, `NotEquals`, `Contains`, and `DoesNotContain`.
        :param Sequence[str] values: A list of values to match for a given condition.
        """
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The operator for a given condition. Possible values are `Equals`, `NotEquals`, `Contains`, and `DoesNotContain`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        A list of values to match for a given condition.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ActionRuleSuppressionConditionAlertRuleId(dict):
    def __init__(__self__, *,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str operator: The operator for a given condition. Possible values are `Equals`, `NotEquals`, `Contains`, and `DoesNotContain`.
        :param Sequence[str] values: A list of values to match for a given condition.
        """
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The operator for a given condition. Possible values are `Equals`, `NotEquals`, `Contains`, and `DoesNotContain`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        A list of values to match for a given condition.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ActionRuleSuppressionConditionDescription(dict):
    def __init__(__self__, *,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str operator: The operator for a given condition. Possible values are `Equals`, `NotEquals`, `Contains`, and `DoesNotContain`.
        :param Sequence[str] values: A list of values to match for a given condition.
        """
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The operator for a given condition. Possible values are `Equals`, `NotEquals`, `Contains`, and `DoesNotContain`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        A list of values to match for a given condition.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ActionRuleSuppressionConditionMonitor(dict):
    def __init__(__self__, *,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str operator: The operator for a given condition. Possible values are `Equals` and `NotEquals`.
        :param Sequence[str] values: A list of values to match for a given condition. Possible values are `Fired` and `Resolved`.
        """
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The operator for a given condition. Possible values are `Equals` and `NotEquals`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        A list of values to match for a given condition. Possible values are `Fired` and `Resolved`.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ActionRuleSuppressionConditionMonitorService(dict):
    def __init__(__self__, *,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str operator: The operator for a given condition. Possible values are `Equals` and `NotEquals`.
        :param Sequence[str] values: A list of values to match for a given condition. Possible values are `ActivityLog Administrative`, `ActivityLog Autoscale`, `ActivityLog Policy`, `ActivityLog Recommendation`, `ActivityLog Security`, `Application Insights`, `Azure Backup`, `Data Box Edge`, `Data Box Gateway`, `Health Platform`, `Log Analytics`, `Platform`, and `Resource Health`.
        """
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The operator for a given condition. Possible values are `Equals` and `NotEquals`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        A list of values to match for a given condition. Possible values are `ActivityLog Administrative`, `ActivityLog Autoscale`, `ActivityLog Policy`, `ActivityLog Recommendation`, `ActivityLog Security`, `Application Insights`, `Azure Backup`, `Data Box Edge`, `Data Box Gateway`, `Health Platform`, `Log Analytics`, `Platform`, and `Resource Health`.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ActionRuleSuppressionConditionSeverity(dict):
    def __init__(__self__, *,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str operator: The operator for a given condition. Possible values are `Equals`and `NotEquals`.
        :param Sequence[str] values: A list of values to match for a given condition. Possible values are `Sev0`, `Sev1`, `Sev2`, `Sev3`, and `Sev4`.
        """
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The operator for a given condition. Possible values are `Equals`and `NotEquals`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        A list of values to match for a given condition. Possible values are `Sev0`, `Sev1`, `Sev2`, `Sev3`, and `Sev4`.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ActionRuleSuppressionConditionTargetResourceType(dict):
    def __init__(__self__, *,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str operator: The operator for a given condition. Possible values are `Equals` and `NotEquals`.
        :param Sequence[str] values: A list of values to match for a given condition. The values should be valid resource types.
        """
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The operator for a given condition. Possible values are `Equals` and `NotEquals`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        A list of values to match for a given condition. The values should be valid resource types.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ActionRuleSuppressionScope(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceIds":
            suggest = "resource_ids"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ActionRuleSuppressionScope. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ActionRuleSuppressionScope.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ActionRuleSuppressionScope.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 resource_ids: Sequence[str],
                 type: str):
        """
        :param Sequence[str] resource_ids: A list of resource IDs of the given scope type which will be the target of action rule.
        :param str type: Specifies the type of target scope. Possible values are `ResourceGroup` and `Resource`.
        """
        pulumi.set(__self__, "resource_ids", resource_ids)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="resourceIds")
    def resource_ids(self) -> Sequence[str]:
        """
        A list of resource IDs of the given scope type which will be the target of action rule.
        """
        return pulumi.get(self, "resource_ids")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Specifies the type of target scope. Possible values are `ResourceGroup` and `Resource`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class ActionRuleSuppressionSuppression(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "recurrenceType":
            suggest = "recurrence_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ActionRuleSuppressionSuppression. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ActionRuleSuppressionSuppression.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ActionRuleSuppressionSuppression.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 recurrence_type: str,
                 schedule: Optional['outputs.ActionRuleSuppressionSuppressionSchedule'] = None):
        """
        :param str recurrence_type: Specifies the type of suppression. Possible values are `Always`, `Daily`, `Monthly`, `Once`, and `Weekly`.
        :param 'ActionRuleSuppressionSuppressionScheduleArgs' schedule: A `schedule` block as defined below. Required if `recurrence_type` is `Daily`, `Monthly`, `Once` or `Weekly`.
        """
        pulumi.set(__self__, "recurrence_type", recurrence_type)
        if schedule is not None:
            pulumi.set(__self__, "schedule", schedule)

    @property
    @pulumi.getter(name="recurrenceType")
    def recurrence_type(self) -> str:
        """
        Specifies the type of suppression. Possible values are `Always`, `Daily`, `Monthly`, `Once`, and `Weekly`.
        """
        return pulumi.get(self, "recurrence_type")

    @property
    @pulumi.getter
    def schedule(self) -> Optional['outputs.ActionRuleSuppressionSuppressionSchedule']:
        """
        A `schedule` block as defined below. Required if `recurrence_type` is `Daily`, `Monthly`, `Once` or `Weekly`.
        """
        return pulumi.get(self, "schedule")


@pulumi.output_type
class ActionRuleSuppressionSuppressionSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "endDateUtc":
            suggest = "end_date_utc"
        elif key == "startDateUtc":
            suggest = "start_date_utc"
        elif key == "recurrenceMonthlies":
            suggest = "recurrence_monthlies"
        elif key == "recurrenceWeeklies":
            suggest = "recurrence_weeklies"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ActionRuleSuppressionSuppressionSchedule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ActionRuleSuppressionSuppressionSchedule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ActionRuleSuppressionSuppressionSchedule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 end_date_utc: str,
                 start_date_utc: str,
                 recurrence_monthlies: Optional[Sequence[int]] = None,
                 recurrence_weeklies: Optional[Sequence[str]] = None):
        """
        :param str end_date_utc: specifies the recurrence UTC end datetime (Y-m-d'T'H:M:S'Z').
        :param str start_date_utc: specifies the recurrence UTC start datetime (Y-m-d'T'H:M:S'Z').
        :param Sequence[int] recurrence_monthlies: specifies the list of dayOfMonth to recurrence. Possible values are between `1` - `31`. Required if `recurrence_type` is `Monthly`.
        :param Sequence[str] recurrence_weeklies: specifies the list of dayOfWeek to recurrence. Possible values are `Sunday`, `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday` and  `Saturday`.
        """
        pulumi.set(__self__, "end_date_utc", end_date_utc)
        pulumi.set(__self__, "start_date_utc", start_date_utc)
        if recurrence_monthlies is not None:
            pulumi.set(__self__, "recurrence_monthlies", recurrence_monthlies)
        if recurrence_weeklies is not None:
            pulumi.set(__self__, "recurrence_weeklies", recurrence_weeklies)

    @property
    @pulumi.getter(name="endDateUtc")
    def end_date_utc(self) -> str:
        """
        specifies the recurrence UTC end datetime (Y-m-d'T'H:M:S'Z').
        """
        return pulumi.get(self, "end_date_utc")

    @property
    @pulumi.getter(name="startDateUtc")
    def start_date_utc(self) -> str:
        """
        specifies the recurrence UTC start datetime (Y-m-d'T'H:M:S'Z').
        """
        return pulumi.get(self, "start_date_utc")

    @property
    @pulumi.getter(name="recurrenceMonthlies")
    def recurrence_monthlies(self) -> Optional[Sequence[int]]:
        """
        specifies the list of dayOfMonth to recurrence. Possible values are between `1` - `31`. Required if `recurrence_type` is `Monthly`.
        """
        return pulumi.get(self, "recurrence_monthlies")

    @property
    @pulumi.getter(name="recurrenceWeeklies")
    def recurrence_weeklies(self) -> Optional[Sequence[str]]:
        """
        specifies the list of dayOfWeek to recurrence. Possible values are `Sunday`, `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday` and  `Saturday`.
        """
        return pulumi.get(self, "recurrence_weeklies")


@pulumi.output_type
class ActivityLogAlertAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "actionGroupId":
            suggest = "action_group_id"
        elif key == "webhookProperties":
            suggest = "webhook_properties"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ActivityLogAlertAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ActivityLogAlertAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ActivityLogAlertAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 action_group_id: str,
                 webhook_properties: Optional[Mapping[str, str]] = None):
        """
        :param str action_group_id: The ID of the Action Group can be sourced from the `monitoring.ActionGroup` resource.
        :param Mapping[str, str] webhook_properties: The map of custom string properties to include with the post operation. These data are appended to the webhook payload.
        """
        pulumi.set(__self__, "action_group_id", action_group_id)
        if webhook_properties is not None:
            pulumi.set(__self__, "webhook_properties", webhook_properties)

    @property
    @pulumi.getter(name="actionGroupId")
    def action_group_id(self) -> str:
        """
        The ID of the Action Group can be sourced from the `monitoring.ActionGroup` resource.
        """
        return pulumi.get(self, "action_group_id")

    @property
    @pulumi.getter(name="webhookProperties")
    def webhook_properties(self) -> Optional[Mapping[str, str]]:
        """
        The map of custom string properties to include with the post operation. These data are appended to the webhook payload.
        """
        return pulumi.get(self, "webhook_properties")


@pulumi.output_type
class ActivityLogAlertCriteria(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "operationName":
            suggest = "operation_name"
        elif key == "recommendationCategory":
            suggest = "recommendation_category"
        elif key == "recommendationImpact":
            suggest = "recommendation_impact"
        elif key == "recommendationType":
            suggest = "recommendation_type"
        elif key == "resourceGroup":
            suggest = "resource_group"
        elif key == "resourceId":
            suggest = "resource_id"
        elif key == "resourceProvider":
            suggest = "resource_provider"
        elif key == "resourceType":
            suggest = "resource_type"
        elif key == "serviceHealths":
            suggest = "service_healths"
        elif key == "subStatus":
            suggest = "sub_status"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ActivityLogAlertCriteria. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ActivityLogAlertCriteria.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ActivityLogAlertCriteria.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 category: str,
                 caller: Optional[str] = None,
                 level: Optional[str] = None,
                 operation_name: Optional[str] = None,
                 recommendation_category: Optional[str] = None,
                 recommendation_impact: Optional[str] = None,
                 recommendation_type: Optional[str] = None,
                 resource_group: Optional[str] = None,
                 resource_id: Optional[str] = None,
                 resource_provider: Optional[str] = None,
                 resource_type: Optional[str] = None,
                 service_healths: Optional[Sequence['outputs.ActivityLogAlertCriteriaServiceHealth']] = None,
                 status: Optional[str] = None,
                 sub_status: Optional[str] = None):
        """
        :param str category: The category of the operation. Possible values are `Administrative`, `Autoscale`, `Policy`, `Recommendation`, `ResourceHealth`, `Security` and `ServiceHealth`.
        :param str caller: The email address or Azure Active Directory identifier of the user who performed the operation.
        :param str level: The severity level of the event. Possible values are `Verbose`, `Informational`, `Warning`, `Error`, and `Critical`.
        :param str operation_name: The Resource Manager Role-Based Access Control operation name. Supported operation should be of the form: `<resourceProvider>/<resourceType>/<operation>`.
        :param str recommendation_category: The recommendation category of the event. Possible values are `Cost`, `Reliability`, `OperationalExcellence` and `Performance`. It is only allowed when `category` is `Recommendation`.
        :param str recommendation_impact: The recommendation impact of the event. Possible values are `High`, `Medium` and `Low`. It is only allowed when `category` is `Recommendation`.
        :param str recommendation_type: The recommendation type of the event. It is only allowed when `category` is `Recommendation`.
        :param str resource_group: The name of resource group monitored by the activity log alert.
        :param str resource_id: The specific resource monitored by the activity log alert. It should be within one of the `scopes`.
        :param str resource_provider: The name of the resource provider monitored by the activity log alert.
        :param str resource_type: The resource type monitored by the activity log alert.
        :param Sequence['ActivityLogAlertCriteriaServiceHealthArgs'] service_healths: A block to define fine grain service health settings.
        :param str status: The status of the event. For example, `Started`, `Failed`, or `Succeeded`.
        :param str sub_status: The sub status of the event.
        """
        pulumi.set(__self__, "category", category)
        if caller is not None:
            pulumi.set(__self__, "caller", caller)
        if level is not None:
            pulumi.set(__self__, "level", level)
        if operation_name is not None:
            pulumi.set(__self__, "operation_name", operation_name)
        if recommendation_category is not None:
            pulumi.set(__self__, "recommendation_category", recommendation_category)
        if recommendation_impact is not None:
            pulumi.set(__self__, "recommendation_impact", recommendation_impact)
        if recommendation_type is not None:
            pulumi.set(__self__, "recommendation_type", recommendation_type)
        if resource_group is not None:
            pulumi.set(__self__, "resource_group", resource_group)
        if resource_id is not None:
            pulumi.set(__self__, "resource_id", resource_id)
        if resource_provider is not None:
            pulumi.set(__self__, "resource_provider", resource_provider)
        if resource_type is not None:
            pulumi.set(__self__, "resource_type", resource_type)
        if service_healths is not None:
            pulumi.set(__self__, "service_healths", service_healths)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if sub_status is not None:
            pulumi.set(__self__, "sub_status", sub_status)

    @property
    @pulumi.getter
    def category(self) -> str:
        """
        The category of the operation. Possible values are `Administrative`, `Autoscale`, `Policy`, `Recommendation`, `ResourceHealth`, `Security` and `ServiceHealth`.
        """
        return pulumi.get(self, "category")

    @property
    @pulumi.getter
    def caller(self) -> Optional[str]:
        """
        The email address or Azure Active Directory identifier of the user who performed the operation.
        """
        return pulumi.get(self, "caller")

    @property
    @pulumi.getter
    def level(self) -> Optional[str]:
        """
        The severity level of the event. Possible values are `Verbose`, `Informational`, `Warning`, `Error`, and `Critical`.
        """
        return pulumi.get(self, "level")

    @property
    @pulumi.getter(name="operationName")
    def operation_name(self) -> Optional[str]:
        """
        The Resource Manager Role-Based Access Control operation name. Supported operation should be of the form: `<resourceProvider>/<resourceType>/<operation>`.
        """
        return pulumi.get(self, "operation_name")

    @property
    @pulumi.getter(name="recommendationCategory")
    def recommendation_category(self) -> Optional[str]:
        """
        The recommendation category of the event. Possible values are `Cost`, `Reliability`, `OperationalExcellence` and `Performance`. It is only allowed when `category` is `Recommendation`.
        """
        return pulumi.get(self, "recommendation_category")

    @property
    @pulumi.getter(name="recommendationImpact")
    def recommendation_impact(self) -> Optional[str]:
        """
        The recommendation impact of the event. Possible values are `High`, `Medium` and `Low`. It is only allowed when `category` is `Recommendation`.
        """
        return pulumi.get(self, "recommendation_impact")

    @property
    @pulumi.getter(name="recommendationType")
    def recommendation_type(self) -> Optional[str]:
        """
        The recommendation type of the event. It is only allowed when `category` is `Recommendation`.
        """
        return pulumi.get(self, "recommendation_type")

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> Optional[str]:
        """
        The name of resource group monitored by the activity log alert.
        """
        return pulumi.get(self, "resource_group")

    @property
    @pulumi.getter(name="resourceId")
    def resource_id(self) -> Optional[str]:
        """
        The specific resource monitored by the activity log alert. It should be within one of the `scopes`.
        """
        return pulumi.get(self, "resource_id")

    @property
    @pulumi.getter(name="resourceProvider")
    def resource_provider(self) -> Optional[str]:
        """
        The name of the resource provider monitored by the activity log alert.
        """
        return pulumi.get(self, "resource_provider")

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> Optional[str]:
        """
        The resource type monitored by the activity log alert.
        """
        return pulumi.get(self, "resource_type")

    @property
    @pulumi.getter(name="serviceHealths")
    def service_healths(self) -> Optional[Sequence['outputs.ActivityLogAlertCriteriaServiceHealth']]:
        """
        A block to define fine grain service health settings.
        """
        return pulumi.get(self, "service_healths")

    @property
    @pulumi.getter
    def status(self) -> Optional[str]:
        """
        The status of the event. For example, `Started`, `Failed`, or `Succeeded`.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="subStatus")
    def sub_status(self) -> Optional[str]:
        """
        The sub status of the event.
        """
        return pulumi.get(self, "sub_status")


@pulumi.output_type
class ActivityLogAlertCriteriaServiceHealth(dict):
    def __init__(__self__, *,
                 events: Optional[Sequence[str]] = None,
                 locations: Optional[Sequence[str]] = None,
                 services: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] events: Events this alert will monitor Possible values are `Incident`, `Maintenance`, `Informational`, `ActionRequired` and `Security`.
        :param Sequence[str] locations: Locations this alert will monitor. For example, `West Europe`. Defaults to `Global`.
        :param Sequence[str] services: Services this alert will monitor. For example, `Activity Logs & Alerts`, `Action Groups`. Defaults to all Services.
        """
        if events is not None:
            pulumi.set(__self__, "events", events)
        if locations is not None:
            pulumi.set(__self__, "locations", locations)
        if services is not None:
            pulumi.set(__self__, "services", services)

    @property
    @pulumi.getter
    def events(self) -> Optional[Sequence[str]]:
        """
        Events this alert will monitor Possible values are `Incident`, `Maintenance`, `Informational`, `ActionRequired` and `Security`.
        """
        return pulumi.get(self, "events")

    @property
    @pulumi.getter
    def locations(self) -> Optional[Sequence[str]]:
        """
        Locations this alert will monitor. For example, `West Europe`. Defaults to `Global`.
        """
        return pulumi.get(self, "locations")

    @property
    @pulumi.getter
    def services(self) -> Optional[Sequence[str]]:
        """
        Services this alert will monitor. For example, `Activity Logs & Alerts`, `Action Groups`. Defaults to all Services.
        """
        return pulumi.get(self, "services")


@pulumi.output_type
class AutoscaleSettingNotification(dict):
    def __init__(__self__, *,
                 email: Optional['outputs.AutoscaleSettingNotificationEmail'] = None,
                 webhooks: Optional[Sequence['outputs.AutoscaleSettingNotificationWebhook']] = None):
        """
        :param 'AutoscaleSettingNotificationEmailArgs' email: A `email` block as defined below.
        :param Sequence['AutoscaleSettingNotificationWebhookArgs'] webhooks: One or more `webhook` blocks as defined below.
        """
        if email is not None:
            pulumi.set(__self__, "email", email)
        if webhooks is not None:
            pulumi.set(__self__, "webhooks", webhooks)

    @property
    @pulumi.getter
    def email(self) -> Optional['outputs.AutoscaleSettingNotificationEmail']:
        """
        A `email` block as defined below.
        """
        return pulumi.get(self, "email")

    @property
    @pulumi.getter
    def webhooks(self) -> Optional[Sequence['outputs.AutoscaleSettingNotificationWebhook']]:
        """
        One or more `webhook` blocks as defined below.
        """
        return pulumi.get(self, "webhooks")


@pulumi.output_type
class AutoscaleSettingNotificationEmail(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "customEmails":
            suggest = "custom_emails"
        elif key == "sendToSubscriptionAdministrator":
            suggest = "send_to_subscription_administrator"
        elif key == "sendToSubscriptionCoAdministrator":
            suggest = "send_to_subscription_co_administrator"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AutoscaleSettingNotificationEmail. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AutoscaleSettingNotificationEmail.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AutoscaleSettingNotificationEmail.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 custom_emails: Optional[Sequence[str]] = None,
                 send_to_subscription_administrator: Optional[bool] = None,
                 send_to_subscription_co_administrator: Optional[bool] = None):
        """
        :param Sequence[str] custom_emails: Specifies a list of custom email addresses to which the email notifications will be sent.
        :param bool send_to_subscription_administrator: Should email notifications be sent to the subscription administrator? Defaults to `false`.
        :param bool send_to_subscription_co_administrator: Should email notifications be sent to the subscription co-administrator? Defaults to `false`.
        """
        if custom_emails is not None:
            pulumi.set(__self__, "custom_emails", custom_emails)
        if send_to_subscription_administrator is not None:
            pulumi.set(__self__, "send_to_subscription_administrator", send_to_subscription_administrator)
        if send_to_subscription_co_administrator is not None:
            pulumi.set(__self__, "send_to_subscription_co_administrator", send_to_subscription_co_administrator)

    @property
    @pulumi.getter(name="customEmails")
    def custom_emails(self) -> Optional[Sequence[str]]:
        """
        Specifies a list of custom email addresses to which the email notifications will be sent.
        """
        return pulumi.get(self, "custom_emails")

    @property
    @pulumi.getter(name="sendToSubscriptionAdministrator")
    def send_to_subscription_administrator(self) -> Optional[bool]:
        """
        Should email notifications be sent to the subscription administrator? Defaults to `false`.
        """
        return pulumi.get(self, "send_to_subscription_administrator")

    @property
    @pulumi.getter(name="sendToSubscriptionCoAdministrator")
    def send_to_subscription_co_administrator(self) -> Optional[bool]:
        """
        Should email notifications be sent to the subscription co-administrator? Defaults to `false`.
        """
        return pulumi.get(self, "send_to_subscription_co_administrator")


@pulumi.output_type
class AutoscaleSettingNotificationWebhook(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "serviceUri":
            suggest = "service_uri"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AutoscaleSettingNotificationWebhook. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AutoscaleSettingNotificationWebhook.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AutoscaleSettingNotificationWebhook.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 service_uri: str,
                 properties: Optional[Mapping[str, str]] = None):
        """
        :param str service_uri: The HTTPS URI which should receive scale notifications.
        :param Mapping[str, str] properties: A map of settings.
        """
        pulumi.set(__self__, "service_uri", service_uri)
        if properties is not None:
            pulumi.set(__self__, "properties", properties)

    @property
    @pulumi.getter(name="serviceUri")
    def service_uri(self) -> str:
        """
        The HTTPS URI which should receive scale notifications.
        """
        return pulumi.get(self, "service_uri")

    @property
    @pulumi.getter
    def properties(self) -> Optional[Mapping[str, str]]:
        """
        A map of settings.
        """
        return pulumi.get(self, "properties")


@pulumi.output_type
class AutoscaleSettingProfile(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fixedDate":
            suggest = "fixed_date"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AutoscaleSettingProfile. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AutoscaleSettingProfile.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AutoscaleSettingProfile.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 capacity: 'outputs.AutoscaleSettingProfileCapacity',
                 name: str,
                 fixed_date: Optional['outputs.AutoscaleSettingProfileFixedDate'] = None,
                 recurrence: Optional['outputs.AutoscaleSettingProfileRecurrence'] = None,
                 rules: Optional[Sequence['outputs.AutoscaleSettingProfileRule']] = None):
        """
        :param 'AutoscaleSettingProfileCapacityArgs' capacity: A `capacity` block as defined below.
        :param str name: Specifies the name of the profile.
        :param 'AutoscaleSettingProfileFixedDateArgs' fixed_date: A `fixed_date` block as defined below. This cannot be specified if a `recurrence` block is specified.
        :param 'AutoscaleSettingProfileRecurrenceArgs' recurrence: A `recurrence` block as defined below. This cannot be specified if a `fixed_date` block is specified.
        :param Sequence['AutoscaleSettingProfileRuleArgs'] rules: One or more (up to 10) `rule` blocks as defined below.
        """
        pulumi.set(__self__, "capacity", capacity)
        pulumi.set(__self__, "name", name)
        if fixed_date is not None:
            pulumi.set(__self__, "fixed_date", fixed_date)
        if recurrence is not None:
            pulumi.set(__self__, "recurrence", recurrence)
        if rules is not None:
            pulumi.set(__self__, "rules", rules)

    @property
    @pulumi.getter
    def capacity(self) -> 'outputs.AutoscaleSettingProfileCapacity':
        """
        A `capacity` block as defined below.
        """
        return pulumi.get(self, "capacity")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the profile.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="fixedDate")
    def fixed_date(self) -> Optional['outputs.AutoscaleSettingProfileFixedDate']:
        """
        A `fixed_date` block as defined below. This cannot be specified if a `recurrence` block is specified.
        """
        return pulumi.get(self, "fixed_date")

    @property
    @pulumi.getter
    def recurrence(self) -> Optional['outputs.AutoscaleSettingProfileRecurrence']:
        """
        A `recurrence` block as defined below. This cannot be specified if a `fixed_date` block is specified.
        """
        return pulumi.get(self, "recurrence")

    @property
    @pulumi.getter
    def rules(self) -> Optional[Sequence['outputs.AutoscaleSettingProfileRule']]:
        """
        One or more (up to 10) `rule` blocks as defined below.
        """
        return pulumi.get(self, "rules")


@pulumi.output_type
class AutoscaleSettingProfileCapacity(dict):
    def __init__(__self__, *,
                 default: int,
                 maximum: int,
                 minimum: int):
        """
        :param int default: The number of instances that are available for scaling if metrics are not available for evaluation. The default is only used if the current instance count is lower than the default. Valid values are between `0` and `1000`.
        :param int maximum: The maximum number of instances for this resource. Valid values are between `0` and `1000`.
        :param int minimum: The minimum number of instances for this resource. Valid values are between `0` and `1000`.
        """
        pulumi.set(__self__, "default", default)
        pulumi.set(__self__, "maximum", maximum)
        pulumi.set(__self__, "minimum", minimum)

    @property
    @pulumi.getter
    def default(self) -> int:
        """
        The number of instances that are available for scaling if metrics are not available for evaluation. The default is only used if the current instance count is lower than the default. Valid values are between `0` and `1000`.
        """
        return pulumi.get(self, "default")

    @property
    @pulumi.getter
    def maximum(self) -> int:
        """
        The maximum number of instances for this resource. Valid values are between `0` and `1000`.
        """
        return pulumi.get(self, "maximum")

    @property
    @pulumi.getter
    def minimum(self) -> int:
        """
        The minimum number of instances for this resource. Valid values are between `0` and `1000`.
        """
        return pulumi.get(self, "minimum")


@pulumi.output_type
class AutoscaleSettingProfileFixedDate(dict):
    def __init__(__self__, *,
                 end: str,
                 start: str,
                 timezone: Optional[str] = None):
        """
        :param str end: Specifies the end date for the profile, formatted as an RFC3339 date string.
        :param str start: Specifies the start date for the profile, formatted as an RFC3339 date string.
        :param str timezone: The Time Zone of the `start` and `end` times. A list of [possible values can be found here](https://msdn.microsoft.com/en-us/library/azure/dn931928.aspx). Defaults to `UTC`.
        """
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)
        if timezone is not None:
            pulumi.set(__self__, "timezone", timezone)

    @property
    @pulumi.getter
    def end(self) -> str:
        """
        Specifies the end date for the profile, formatted as an RFC3339 date string.
        """
        return pulumi.get(self, "end")

    @property
    @pulumi.getter
    def start(self) -> str:
        """
        Specifies the start date for the profile, formatted as an RFC3339 date string.
        """
        return pulumi.get(self, "start")

    @property
    @pulumi.getter
    def timezone(self) -> Optional[str]:
        """
        The Time Zone of the `start` and `end` times. A list of [possible values can be found here](https://msdn.microsoft.com/en-us/library/azure/dn931928.aspx). Defaults to `UTC`.
        """
        return pulumi.get(self, "timezone")


@pulumi.output_type
class AutoscaleSettingProfileRecurrence(dict):
    def __init__(__self__, *,
                 days: Sequence[str],
                 hours: int,
                 minutes: int,
                 timezone: Optional[str] = None):
        """
        :param Sequence[str] days: A list of days that this profile takes effect on. Possible values include `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday`, `Saturday` and `Sunday`.
        :param int hours: A list containing a single item, which specifies the Hour interval at which this recurrence should be triggered (in 24-hour time). Possible values are from `0` to `23`.
        :param int minutes: A list containing a single item which specifies the Minute interval at which this recurrence should be triggered.
        :param str timezone: The Time Zone used for the `hours` field. A list of [possible values can be found here](https://msdn.microsoft.com/en-us/library/azure/dn931928.aspx). Defaults to `UTC`.
        """
        pulumi.set(__self__, "days", days)
        pulumi.set(__self__, "hours", hours)
        pulumi.set(__self__, "minutes", minutes)
        if timezone is not None:
            pulumi.set(__self__, "timezone", timezone)

    @property
    @pulumi.getter
    def days(self) -> Sequence[str]:
        """
        A list of days that this profile takes effect on. Possible values include `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday`, `Saturday` and `Sunday`.
        """
        return pulumi.get(self, "days")

    @property
    @pulumi.getter
    def hours(self) -> int:
        """
        A list containing a single item, which specifies the Hour interval at which this recurrence should be triggered (in 24-hour time). Possible values are from `0` to `23`.
        """
        return pulumi.get(self, "hours")

    @property
    @pulumi.getter
    def minutes(self) -> int:
        """
        A list containing a single item which specifies the Minute interval at which this recurrence should be triggered.
        """
        return pulumi.get(self, "minutes")

    @property
    @pulumi.getter
    def timezone(self) -> Optional[str]:
        """
        The Time Zone used for the `hours` field. A list of [possible values can be found here](https://msdn.microsoft.com/en-us/library/azure/dn931928.aspx). Defaults to `UTC`.
        """
        return pulumi.get(self, "timezone")


@pulumi.output_type
class AutoscaleSettingProfileRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "metricTrigger":
            suggest = "metric_trigger"
        elif key == "scaleAction":
            suggest = "scale_action"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AutoscaleSettingProfileRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AutoscaleSettingProfileRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AutoscaleSettingProfileRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 metric_trigger: 'outputs.AutoscaleSettingProfileRuleMetricTrigger',
                 scale_action: 'outputs.AutoscaleSettingProfileRuleScaleAction'):
        """
        :param 'AutoscaleSettingProfileRuleMetricTriggerArgs' metric_trigger: A `metric_trigger` block as defined below.
        :param 'AutoscaleSettingProfileRuleScaleActionArgs' scale_action: A `scale_action` block as defined below.
        """
        pulumi.set(__self__, "metric_trigger", metric_trigger)
        pulumi.set(__self__, "scale_action", scale_action)

    @property
    @pulumi.getter(name="metricTrigger")
    def metric_trigger(self) -> 'outputs.AutoscaleSettingProfileRuleMetricTrigger':
        """
        A `metric_trigger` block as defined below.
        """
        return pulumi.get(self, "metric_trigger")

    @property
    @pulumi.getter(name="scaleAction")
    def scale_action(self) -> 'outputs.AutoscaleSettingProfileRuleScaleAction':
        """
        A `scale_action` block as defined below.
        """
        return pulumi.get(self, "scale_action")


@pulumi.output_type
class AutoscaleSettingProfileRuleMetricTrigger(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "metricName":
            suggest = "metric_name"
        elif key == "metricResourceId":
            suggest = "metric_resource_id"
        elif key == "timeAggregation":
            suggest = "time_aggregation"
        elif key == "timeGrain":
            suggest = "time_grain"
        elif key == "timeWindow":
            suggest = "time_window"
        elif key == "metricNamespace":
            suggest = "metric_namespace"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AutoscaleSettingProfileRuleMetricTrigger. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AutoscaleSettingProfileRuleMetricTrigger.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AutoscaleSettingProfileRuleMetricTrigger.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 metric_name: str,
                 metric_resource_id: str,
                 operator: str,
                 statistic: str,
                 threshold: float,
                 time_aggregation: str,
                 time_grain: str,
                 time_window: str,
                 dimensions: Optional[Sequence['outputs.AutoscaleSettingProfileRuleMetricTriggerDimension']] = None,
                 metric_namespace: Optional[str] = None):
        """
        :param str metric_name: The name of the metric that defines what the rule monitors, such as `Percentage CPU` for `Virtual Machine Scale Sets` and `CpuPercentage` for `App Service Plan`.
        :param str metric_resource_id: The ID of the Resource which the Rule monitors.
        :param str operator: Specifies the operator used to compare the metric data and threshold. Possible values are: `Equals`, `NotEquals`, `GreaterThan`, `GreaterThanOrEqual`, `LessThan`, `LessThanOrEqual`.
        :param str statistic: Specifies how the metrics from multiple instances are combined. Possible values are `Average`, `Min` and `Max`.
        :param float threshold: Specifies the threshold of the metric that triggers the scale action.
        :param str time_aggregation: Specifies how the data that's collected should be combined over time. Possible values include `Average`, `Count`, `Maximum`, `Minimum`, `Last` and `Total`. Defaults to `Average`.
        :param str time_grain: Specifies the granularity of metrics that the rule monitors, which must be one of the pre-defined values returned from the metric definitions for the metric. This value must be between 1 minute and 12 hours an be formatted as an ISO 8601 string.
        :param str time_window: Specifies the time range for which data is collected, which must be greater than the delay in metric collection (which varies from resource to resource). This value must be between 5 minutes and 12 hours and be formatted as an ISO 8601 string.
        :param Sequence['AutoscaleSettingProfileRuleMetricTriggerDimensionArgs'] dimensions: One or more `dimensions` block as defined below.
        :param str metric_namespace: The namespace of the metric that defines what the rule monitors, such as `microsoft.compute/virtualmachinescalesets` for `Virtual Machine Scale Sets`.
        """
        pulumi.set(__self__, "metric_name", metric_name)
        pulumi.set(__self__, "metric_resource_id", metric_resource_id)
        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 metric_namespace is not None:
            pulumi.set(__self__, "metric_namespace", metric_namespace)

    @property
    @pulumi.getter(name="metricName")
    def metric_name(self) -> str:
        """
        The name of the metric that defines what the rule monitors, such as `Percentage CPU` for `Virtual Machine Scale Sets` and `CpuPercentage` for `App Service Plan`.
        """
        return pulumi.get(self, "metric_name")

    @property
    @pulumi.getter(name="metricResourceId")
    def metric_resource_id(self) -> str:
        """
        The ID of the Resource which the Rule monitors.
        """
        return pulumi.get(self, "metric_resource_id")

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        Specifies the operator used to compare the metric data and threshold. Possible values are: `Equals`, `NotEquals`, `GreaterThan`, `GreaterThanOrEqual`, `LessThan`, `LessThanOrEqual`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def statistic(self) -> str:
        """
        Specifies how the metrics from multiple instances are combined. Possible values are `Average`, `Min` and `Max`.
        """
        return pulumi.get(self, "statistic")

    @property
    @pulumi.getter
    def threshold(self) -> float:
        """
        Specifies the threshold of the metric that triggers the scale action.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter(name="timeAggregation")
    def time_aggregation(self) -> str:
        """
        Specifies how the data that's collected should be combined over time. Possible values include `Average`, `Count`, `Maximum`, `Minimum`, `Last` and `Total`. Defaults to `Average`.
        """
        return pulumi.get(self, "time_aggregation")

    @property
    @pulumi.getter(name="timeGrain")
    def time_grain(self) -> str:
        """
        Specifies the granularity of metrics that the rule monitors, which must be one of the pre-defined values returned from the metric definitions for the metric. This value must be between 1 minute and 12 hours an be formatted as an ISO 8601 string.
        """
        return pulumi.get(self, "time_grain")

    @property
    @pulumi.getter(name="timeWindow")
    def time_window(self) -> str:
        """
        Specifies the time range for which data is collected, which must be greater than the delay in metric collection (which varies from resource to resource). This value must be between 5 minutes and 12 hours and be formatted as an ISO 8601 string.
        """
        return pulumi.get(self, "time_window")

    @property
    @pulumi.getter
    def dimensions(self) -> Optional[Sequence['outputs.AutoscaleSettingProfileRuleMetricTriggerDimension']]:
        """
        One or more `dimensions` block as defined below.
        """
        return pulumi.get(self, "dimensions")

    @property
    @pulumi.getter(name="metricNamespace")
    def metric_namespace(self) -> Optional[str]:
        """
        The namespace of the metric that defines what the rule monitors, such as `microsoft.compute/virtualmachinescalesets` for `Virtual Machine Scale Sets`.
        """
        return pulumi.get(self, "metric_namespace")


@pulumi.output_type
class AutoscaleSettingProfileRuleMetricTriggerDimension(dict):
    def __init__(__self__, *,
                 name: str,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str name: The name of the dimension.
        :param str operator: The dimension operator. Possible values are `Equals` and `NotEquals`. `Equals` means being equal to any of the values. `NotEquals` means being not equal to any of the values.
        :param Sequence[str] values: A list of dimension values.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the dimension.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The dimension operator. Possible values are `Equals` and `NotEquals`. `Equals` means being equal to any of the values. `NotEquals` means being not equal to any of the values.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        A list of dimension values.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class AutoscaleSettingProfileRuleScaleAction(dict):
    def __init__(__self__, *,
                 cooldown: str,
                 direction: str,
                 type: str,
                 value: int):
        """
        :param str cooldown: The amount of time to wait since the last scaling action before this action occurs. Must be between 1 minute and 1 week and formatted as a ISO 8601 string.
        :param str direction: The scale direction. Possible values are `Increase` and `Decrease`.
        :param str type: The type of action that should occur. Possible values are `ChangeCount`, `ExactCount` and `PercentChangeCount`.
        :param int value: The number of instances involved in the scaling action. Defaults to `1`.
        """
        pulumi.set(__self__, "cooldown", cooldown)
        pulumi.set(__self__, "direction", direction)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def cooldown(self) -> str:
        """
        The amount of time to wait since the last scaling action before this action occurs. Must be between 1 minute and 1 week and formatted as a ISO 8601 string.
        """
        return pulumi.get(self, "cooldown")

    @property
    @pulumi.getter
    def direction(self) -> str:
        """
        The scale direction. Possible values are `Increase` and `Decrease`.
        """
        return pulumi.get(self, "direction")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of action that should occur. Possible values are `ChangeCount`, `ExactCount` and `PercentChangeCount`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def value(self) -> int:
        """
        The number of instances involved in the scaling action. Defaults to `1`.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class DiagnosticSettingLog(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "retentionPolicy":
            suggest = "retention_policy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DiagnosticSettingLog. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DiagnosticSettingLog.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DiagnosticSettingLog.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 category: str,
                 enabled: Optional[bool] = None,
                 retention_policy: Optional['outputs.DiagnosticSettingLogRetentionPolicy'] = None):
        """
        :param str category: The name of a Diagnostic Log Category for this Resource.
        :param bool enabled: Is this Diagnostic Log enabled? Defaults to `true`.
        :param 'DiagnosticSettingLogRetentionPolicyArgs' retention_policy: A `retention_policy` block as defined below.
        """
        pulumi.set(__self__, "category", category)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if retention_policy is not None:
            pulumi.set(__self__, "retention_policy", retention_policy)

    @property
    @pulumi.getter
    def category(self) -> str:
        """
        The name of a Diagnostic Log Category for this Resource.
        """
        return pulumi.get(self, "category")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Is this Diagnostic Log enabled? Defaults to `true`.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="retentionPolicy")
    def retention_policy(self) -> Optional['outputs.DiagnosticSettingLogRetentionPolicy']:
        """
        A `retention_policy` block as defined below.
        """
        return pulumi.get(self, "retention_policy")


@pulumi.output_type
class DiagnosticSettingLogRetentionPolicy(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 days: Optional[int] = None):
        """
        :param bool enabled: Is this Retention Policy enabled?
        :param int days: The number of days for which this Retention Policy should apply.
        """
        pulumi.set(__self__, "enabled", enabled)
        if days is not None:
            pulumi.set(__self__, "days", days)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is this Retention Policy enabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def days(self) -> Optional[int]:
        """
        The number of days for which this Retention Policy should apply.
        """
        return pulumi.get(self, "days")


@pulumi.output_type
class DiagnosticSettingMetric(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "retentionPolicy":
            suggest = "retention_policy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DiagnosticSettingMetric. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DiagnosticSettingMetric.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DiagnosticSettingMetric.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 category: str,
                 enabled: Optional[bool] = None,
                 retention_policy: Optional['outputs.DiagnosticSettingMetricRetentionPolicy'] = None):
        """
        :param str category: The name of a Diagnostic Metric Category for this Resource.
        :param bool enabled: Is this Diagnostic Metric enabled? Defaults to `true`.
        :param 'DiagnosticSettingMetricRetentionPolicyArgs' retention_policy: A `retention_policy` block as defined below.
        """
        pulumi.set(__self__, "category", category)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if retention_policy is not None:
            pulumi.set(__self__, "retention_policy", retention_policy)

    @property
    @pulumi.getter
    def category(self) -> str:
        """
        The name of a Diagnostic Metric Category for this Resource.
        """
        return pulumi.get(self, "category")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Is this Diagnostic Metric enabled? Defaults to `true`.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="retentionPolicy")
    def retention_policy(self) -> Optional['outputs.DiagnosticSettingMetricRetentionPolicy']:
        """
        A `retention_policy` block as defined below.
        """
        return pulumi.get(self, "retention_policy")


@pulumi.output_type
class DiagnosticSettingMetricRetentionPolicy(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 days: Optional[int] = None):
        """
        :param bool enabled: Is this Retention Policy enabled?
        :param int days: The number of days for which this Retention Policy should apply.
        """
        pulumi.set(__self__, "enabled", enabled)
        if days is not None:
            pulumi.set(__self__, "days", days)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is this Retention Policy enabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def days(self) -> Optional[int]:
        """
        The number of days for which this Retention Policy should apply.
        """
        return pulumi.get(self, "days")


@pulumi.output_type
class LogProfileRetentionPolicy(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 days: Optional[int] = None):
        """
        :param bool enabled: A boolean value to indicate whether the retention policy is enabled.
        :param int days: The number of days for the retention policy. Defaults to 0.
        """
        pulumi.set(__self__, "enabled", enabled)
        if days is not None:
            pulumi.set(__self__, "days", days)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        A boolean value to indicate whether the retention policy is enabled.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def days(self) -> Optional[int]:
        """
        The number of days for the retention policy. Defaults to 0.
        """
        return pulumi.get(self, "days")


@pulumi.output_type
class MetricAlertAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "actionGroupId":
            suggest = "action_group_id"
        elif key == "webhookProperties":
            suggest = "webhook_properties"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MetricAlertAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MetricAlertAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MetricAlertAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 action_group_id: str,
                 webhook_properties: Optional[Mapping[str, str]] = None):
        """
        :param str action_group_id: The ID of the Action Group can be sourced from the `monitoring.ActionGroup` resource
        :param Mapping[str, str] webhook_properties: The map of custom string properties to include with the post operation. These data are appended to the webhook payload.
        """
        pulumi.set(__self__, "action_group_id", action_group_id)
        if webhook_properties is not None:
            pulumi.set(__self__, "webhook_properties", webhook_properties)

    @property
    @pulumi.getter(name="actionGroupId")
    def action_group_id(self) -> str:
        """
        The ID of the Action Group can be sourced from the `monitoring.ActionGroup` resource
        """
        return pulumi.get(self, "action_group_id")

    @property
    @pulumi.getter(name="webhookProperties")
    def webhook_properties(self) -> Optional[Mapping[str, str]]:
        """
        The map of custom string properties to include with the post operation. These data are appended to the webhook payload.
        """
        return pulumi.get(self, "webhook_properties")


@pulumi.output_type
class MetricAlertApplicationInsightsWebTestLocationAvailabilityCriteria(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "componentId":
            suggest = "component_id"
        elif key == "failedLocationCount":
            suggest = "failed_location_count"
        elif key == "webTestId":
            suggest = "web_test_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MetricAlertApplicationInsightsWebTestLocationAvailabilityCriteria. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MetricAlertApplicationInsightsWebTestLocationAvailabilityCriteria.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MetricAlertApplicationInsightsWebTestLocationAvailabilityCriteria.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 component_id: str,
                 failed_location_count: int,
                 web_test_id: str):
        """
        :param str component_id: The ID of the Application Insights Resource.
        :param int failed_location_count: The number of failed locations.
        :param str web_test_id: The ID of the Application Insights Web Test.
        """
        pulumi.set(__self__, "component_id", component_id)
        pulumi.set(__self__, "failed_location_count", failed_location_count)
        pulumi.set(__self__, "web_test_id", web_test_id)

    @property
    @pulumi.getter(name="componentId")
    def component_id(self) -> str:
        """
        The ID of the Application Insights Resource.
        """
        return pulumi.get(self, "component_id")

    @property
    @pulumi.getter(name="failedLocationCount")
    def failed_location_count(self) -> int:
        """
        The number of failed locations.
        """
        return pulumi.get(self, "failed_location_count")

    @property
    @pulumi.getter(name="webTestId")
    def web_test_id(self) -> str:
        """
        The ID of the Application Insights Web Test.
        """
        return pulumi.get(self, "web_test_id")


@pulumi.output_type
class MetricAlertCriteria(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "metricName":
            suggest = "metric_name"
        elif key == "metricNamespace":
            suggest = "metric_namespace"
        elif key == "skipMetricValidation":
            suggest = "skip_metric_validation"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MetricAlertCriteria. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MetricAlertCriteria.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MetricAlertCriteria.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 aggregation: str,
                 metric_name: str,
                 metric_namespace: str,
                 operator: str,
                 threshold: float,
                 dimensions: Optional[Sequence['outputs.MetricAlertCriteriaDimension']] = None,
                 skip_metric_validation: Optional[bool] = None):
        """
        :param str aggregation: The statistic that runs over the metric values. Possible values are `Average`, `Count`, `Minimum`, `Maximum` and `Total`.
        :param str metric_name: One of the metric names to be monitored.
        :param str metric_namespace: One of the metric namespaces to be monitored.
        :param str operator: The criteria operator. Possible values are `Equals`, `NotEquals`, `GreaterThan`, `GreaterThanOrEqual`, `LessThan` and `LessThanOrEqual`.
        :param float threshold: The criteria threshold value that activates the alert.
        :param Sequence['MetricAlertCriteriaDimensionArgs'] dimensions: One or more `dimension` blocks as defined below.
        :param bool skip_metric_validation: Skip the metric validation to allow creating an alert rule on a custom metric that isn't yet emitted? Defaults to `false`.
        """
        pulumi.set(__self__, "aggregation", aggregation)
        pulumi.set(__self__, "metric_name", metric_name)
        pulumi.set(__self__, "metric_namespace", metric_namespace)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "threshold", threshold)
        if dimensions is not None:
            pulumi.set(__self__, "dimensions", dimensions)
        if skip_metric_validation is not None:
            pulumi.set(__self__, "skip_metric_validation", skip_metric_validation)

    @property
    @pulumi.getter
    def aggregation(self) -> str:
        """
        The statistic that runs over the metric values. Possible values are `Average`, `Count`, `Minimum`, `Maximum` and `Total`.
        """
        return pulumi.get(self, "aggregation")

    @property
    @pulumi.getter(name="metricName")
    def metric_name(self) -> str:
        """
        One of the metric names to be monitored.
        """
        return pulumi.get(self, "metric_name")

    @property
    @pulumi.getter(name="metricNamespace")
    def metric_namespace(self) -> str:
        """
        One of the metric namespaces to be monitored.
        """
        return pulumi.get(self, "metric_namespace")

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The criteria operator. Possible values are `Equals`, `NotEquals`, `GreaterThan`, `GreaterThanOrEqual`, `LessThan` and `LessThanOrEqual`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def threshold(self) -> float:
        """
        The criteria threshold value that activates the alert.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter
    def dimensions(self) -> Optional[Sequence['outputs.MetricAlertCriteriaDimension']]:
        """
        One or more `dimension` blocks as defined below.
        """
        return pulumi.get(self, "dimensions")

    @property
    @pulumi.getter(name="skipMetricValidation")
    def skip_metric_validation(self) -> Optional[bool]:
        """
        Skip the metric validation to allow creating an alert rule on a custom metric that isn't yet emitted? Defaults to `false`.
        """
        return pulumi.get(self, "skip_metric_validation")


@pulumi.output_type
class MetricAlertCriteriaDimension(dict):
    def __init__(__self__, *,
                 name: str,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str name: One of the dimension names.
        :param str operator: The dimension operator. Possible values are `Include` and `Exclude`.
        :param Sequence[str] values: The list of dimension values.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        One of the dimension names.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The dimension operator. Possible values are `Include` and `Exclude`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        The list of dimension values.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class MetricAlertDynamicCriteria(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "alertSensitivity":
            suggest = "alert_sensitivity"
        elif key == "metricName":
            suggest = "metric_name"
        elif key == "metricNamespace":
            suggest = "metric_namespace"
        elif key == "evaluationFailureCount":
            suggest = "evaluation_failure_count"
        elif key == "evaluationTotalCount":
            suggest = "evaluation_total_count"
        elif key == "ignoreDataBefore":
            suggest = "ignore_data_before"
        elif key == "skipMetricValidation":
            suggest = "skip_metric_validation"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MetricAlertDynamicCriteria. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MetricAlertDynamicCriteria.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MetricAlertDynamicCriteria.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 aggregation: str,
                 alert_sensitivity: str,
                 metric_name: str,
                 metric_namespace: str,
                 operator: str,
                 dimensions: Optional[Sequence['outputs.MetricAlertDynamicCriteriaDimension']] = None,
                 evaluation_failure_count: Optional[int] = None,
                 evaluation_total_count: Optional[int] = None,
                 ignore_data_before: Optional[str] = None,
                 skip_metric_validation: Optional[bool] = None):
        """
        :param str aggregation: The statistic that runs over the metric values. Possible values are `Average`, `Count`, `Minimum`, `Maximum` and `Total`.
        :param str alert_sensitivity: The extent of deviation required to trigger an alert. Possible values are `Low`, `Medium` and `High`.
        :param str metric_name: One of the metric names to be monitored.
        :param str metric_namespace: One of the metric namespaces to be monitored.
        :param str operator: The criteria operator. Possible values are `LessThan`, `GreaterThan` and `GreaterOrLessThan`.
        :param Sequence['MetricAlertDynamicCriteriaDimensionArgs'] dimensions: One or more `dimension` blocks as defined below.
        :param int evaluation_failure_count: The number of violations to trigger an alert. Should be smaller or equal to `evaluation_total_count`.
        :param int evaluation_total_count: The number of aggregated lookback points. The lookback time window is calculated based on the aggregation granularity (`window_size`) and the selected number of aggregated points.
        :param str ignore_data_before: The [ISO8601](https://en.wikipedia.org/wiki/ISO_8601) date from which to start learning the metric historical data and calculate the dynamic thresholds.
        :param bool skip_metric_validation: Skip the metric validation to allow creating an alert rule on a custom metric that isn't yet emitted? Defaults to `false`.
        """
        pulumi.set(__self__, "aggregation", aggregation)
        pulumi.set(__self__, "alert_sensitivity", alert_sensitivity)
        pulumi.set(__self__, "metric_name", metric_name)
        pulumi.set(__self__, "metric_namespace", metric_namespace)
        pulumi.set(__self__, "operator", operator)
        if dimensions is not None:
            pulumi.set(__self__, "dimensions", dimensions)
        if evaluation_failure_count is not None:
            pulumi.set(__self__, "evaluation_failure_count", evaluation_failure_count)
        if evaluation_total_count is not None:
            pulumi.set(__self__, "evaluation_total_count", evaluation_total_count)
        if ignore_data_before is not None:
            pulumi.set(__self__, "ignore_data_before", ignore_data_before)
        if skip_metric_validation is not None:
            pulumi.set(__self__, "skip_metric_validation", skip_metric_validation)

    @property
    @pulumi.getter
    def aggregation(self) -> str:
        """
        The statistic that runs over the metric values. Possible values are `Average`, `Count`, `Minimum`, `Maximum` and `Total`.
        """
        return pulumi.get(self, "aggregation")

    @property
    @pulumi.getter(name="alertSensitivity")
    def alert_sensitivity(self) -> str:
        """
        The extent of deviation required to trigger an alert. Possible values are `Low`, `Medium` and `High`.
        """
        return pulumi.get(self, "alert_sensitivity")

    @property
    @pulumi.getter(name="metricName")
    def metric_name(self) -> str:
        """
        One of the metric names to be monitored.
        """
        return pulumi.get(self, "metric_name")

    @property
    @pulumi.getter(name="metricNamespace")
    def metric_namespace(self) -> str:
        """
        One of the metric namespaces to be monitored.
        """
        return pulumi.get(self, "metric_namespace")

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The criteria operator. Possible values are `LessThan`, `GreaterThan` and `GreaterOrLessThan`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def dimensions(self) -> Optional[Sequence['outputs.MetricAlertDynamicCriteriaDimension']]:
        """
        One or more `dimension` blocks as defined below.
        """
        return pulumi.get(self, "dimensions")

    @property
    @pulumi.getter(name="evaluationFailureCount")
    def evaluation_failure_count(self) -> Optional[int]:
        """
        The number of violations to trigger an alert. Should be smaller or equal to `evaluation_total_count`.
        """
        return pulumi.get(self, "evaluation_failure_count")

    @property
    @pulumi.getter(name="evaluationTotalCount")
    def evaluation_total_count(self) -> Optional[int]:
        """
        The number of aggregated lookback points. The lookback time window is calculated based on the aggregation granularity (`window_size`) and the selected number of aggregated points.
        """
        return pulumi.get(self, "evaluation_total_count")

    @property
    @pulumi.getter(name="ignoreDataBefore")
    def ignore_data_before(self) -> Optional[str]:
        """
        The [ISO8601](https://en.wikipedia.org/wiki/ISO_8601) date from which to start learning the metric historical data and calculate the dynamic thresholds.
        """
        return pulumi.get(self, "ignore_data_before")

    @property
    @pulumi.getter(name="skipMetricValidation")
    def skip_metric_validation(self) -> Optional[bool]:
        """
        Skip the metric validation to allow creating an alert rule on a custom metric that isn't yet emitted? Defaults to `false`.
        """
        return pulumi.get(self, "skip_metric_validation")


@pulumi.output_type
class MetricAlertDynamicCriteriaDimension(dict):
    def __init__(__self__, *,
                 name: str,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str name: One of the dimension names.
        :param str operator: The dimension operator. Possible values are `Include` and `Exclude`.
        :param Sequence[str] values: The list of dimension values.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        One of the dimension names.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        The dimension operator. Possible values are `Include` and `Exclude`.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        The list of dimension values.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ScheduledQueryRulesAlertAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "actionGroups":
            suggest = "action_groups"
        elif key == "customWebhookPayload":
            suggest = "custom_webhook_payload"
        elif key == "emailSubject":
            suggest = "email_subject"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ScheduledQueryRulesAlertAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ScheduledQueryRulesAlertAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ScheduledQueryRulesAlertAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 action_groups: Sequence[str],
                 custom_webhook_payload: Optional[str] = None,
                 email_subject: Optional[str] = None):
        """
        :param Sequence[str] action_groups: List of action group reference resource IDs.
        :param str custom_webhook_payload: Custom payload to be sent for all webhook payloads in alerting action.
        :param str email_subject: Custom subject override for all email ids in Azure action group.
        """
        pulumi.set(__self__, "action_groups", action_groups)
        if custom_webhook_payload is not None:
            pulumi.set(__self__, "custom_webhook_payload", custom_webhook_payload)
        if email_subject is not None:
            pulumi.set(__self__, "email_subject", email_subject)

    @property
    @pulumi.getter(name="actionGroups")
    def action_groups(self) -> Sequence[str]:
        """
        List of action group reference resource IDs.
        """
        return pulumi.get(self, "action_groups")

    @property
    @pulumi.getter(name="customWebhookPayload")
    def custom_webhook_payload(self) -> Optional[str]:
        """
        Custom payload to be sent for all webhook payloads in alerting action.
        """
        return pulumi.get(self, "custom_webhook_payload")

    @property
    @pulumi.getter(name="emailSubject")
    def email_subject(self) -> Optional[str]:
        """
        Custom subject override for all email ids in Azure action group.
        """
        return pulumi.get(self, "email_subject")


@pulumi.output_type
class ScheduledQueryRulesAlertTrigger(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "metricTrigger":
            suggest = "metric_trigger"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ScheduledQueryRulesAlertTrigger. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ScheduledQueryRulesAlertTrigger.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ScheduledQueryRulesAlertTrigger.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 operator: str,
                 threshold: float,
                 metric_trigger: Optional['outputs.ScheduledQueryRulesAlertTriggerMetricTrigger'] = None):
        """
        :param str operator: Evaluation operation for rule - 'Equal', 'GreaterThan' or 'LessThan'.
        :param float threshold: Result or count threshold based on which rule should be triggered.  Values must be between 0 and 10000 inclusive.
        :param 'ScheduledQueryRulesAlertTriggerMetricTriggerArgs' metric_trigger: A `metric_trigger` block as defined above. Trigger condition for metric query rule.
        """
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "threshold", threshold)
        if metric_trigger is not None:
            pulumi.set(__self__, "metric_trigger", metric_trigger)

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        Evaluation operation for rule - 'Equal', 'GreaterThan' or 'LessThan'.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def threshold(self) -> float:
        """
        Result or count threshold based on which rule should be triggered.  Values must be between 0 and 10000 inclusive.
        """
        return pulumi.get(self, "threshold")

    @property
    @pulumi.getter(name="metricTrigger")
    def metric_trigger(self) -> Optional['outputs.ScheduledQueryRulesAlertTriggerMetricTrigger']:
        """
        A `metric_trigger` block as defined above. Trigger condition for metric query rule.
        """
        return pulumi.get(self, "metric_trigger")


@pulumi.output_type
class ScheduledQueryRulesAlertTriggerMetricTrigger(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "metricColumn":
            suggest = "metric_column"
        elif key == "metricTriggerType":
            suggest = "metric_trigger_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ScheduledQueryRulesAlertTriggerMetricTrigger. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ScheduledQueryRulesAlertTriggerMetricTrigger.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ScheduledQueryRulesAlertTriggerMetricTrigger.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 metric_column: str,
                 metric_trigger_type: str,
                 operator: str,
                 threshold: float):
        """
        :param str metric_column: Evaluation of metric on a particular column.
        :param str metric_trigger_type: Metric Trigger Type - 'Consecutive' or 'Total'.
        :param str operator: Evaluation operation for rule - 'Equal', 'GreaterThan' or 'LessThan'.
        :param float threshold: The threshold of the metric trigger.    Values must be between 0 and 10000 inclusive.
        """
        pulumi.set(__self__, "metric_column", metric_column)
        pulumi.set(__self__, "metric_trigger_type", metric_trigger_type)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "threshold", threshold)

    @property
    @pulumi.getter(name="metricColumn")
    def metric_column(self) -> str:
        """
        Evaluation of metric on a particular column.
        """
        return pulumi.get(self, "metric_column")

    @property
    @pulumi.getter(name="metricTriggerType")
    def metric_trigger_type(self) -> str:
        """
        Metric Trigger Type - 'Consecutive' or 'Total'.
        """
        return pulumi.get(self, "metric_trigger_type")

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        Evaluation operation for rule - 'Equal', 'GreaterThan' or 'LessThan'.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def threshold(self) -> float:
        """
        The threshold of the metric trigger.    Values must be between 0 and 10000 inclusive.
        """
        return pulumi.get(self, "threshold")


@pulumi.output_type
class ScheduledQueryRulesLogCriteria(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "metricName":
            suggest = "metric_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ScheduledQueryRulesLogCriteria. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ScheduledQueryRulesLogCriteria.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ScheduledQueryRulesLogCriteria.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 dimensions: Sequence['outputs.ScheduledQueryRulesLogCriteriaDimension'],
                 metric_name: str):
        """
        :param Sequence['ScheduledQueryRulesLogCriteriaDimensionArgs'] dimensions: A `dimension` block as defined below.
        :param str metric_name: Name of the metric.  Supported metrics are listed in the Azure Monitor [Microsoft.OperationalInsights/workspaces](https://docs.microsoft.com/en-us/azure/azure-monitor/platform/metrics-supported#microsoftoperationalinsightsworkspaces) metrics namespace.
        """
        pulumi.set(__self__, "dimensions", dimensions)
        pulumi.set(__self__, "metric_name", metric_name)

    @property
    @pulumi.getter
    def dimensions(self) -> Sequence['outputs.ScheduledQueryRulesLogCriteriaDimension']:
        """
        A `dimension` block as defined below.
        """
        return pulumi.get(self, "dimensions")

    @property
    @pulumi.getter(name="metricName")
    def metric_name(self) -> str:
        """
        Name of the metric.  Supported metrics are listed in the Azure Monitor [Microsoft.OperationalInsights/workspaces](https://docs.microsoft.com/en-us/azure/azure-monitor/platform/metrics-supported#microsoftoperationalinsightsworkspaces) metrics namespace.
        """
        return pulumi.get(self, "metric_name")


@pulumi.output_type
class ScheduledQueryRulesLogCriteriaDimension(dict):
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str],
                 operator: Optional[str] = None):
        """
        :param str name: Name of the dimension.
        :param Sequence[str] values: List of dimension values.
        :param str operator: Operator for dimension values, - 'Include'.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the dimension.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        List of dimension values.
        """
        return pulumi.get(self, "values")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        """
        Operator for dimension values, - 'Include'.
        """
        return pulumi.get(self, "operator")


@pulumi.output_type
class SmartDetectorAlertRuleActionGroup(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "emailSubject":
            suggest = "email_subject"
        elif key == "webhookPayload":
            suggest = "webhook_payload"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SmartDetectorAlertRuleActionGroup. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SmartDetectorAlertRuleActionGroup.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SmartDetectorAlertRuleActionGroup.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ids: Sequence[str],
                 email_subject: Optional[str] = None,
                 webhook_payload: Optional[str] = None):
        """
        :param Sequence[str] ids: Specifies the action group ids.
        :param str email_subject: Specifies a custom email subject if Email Receiver is specified in Monitor Action Group resource.
        :param str webhook_payload: A JSON String which Specifies the custom webhook payload if Webhook Receiver is specified in Monitor Action Group resource.
        """
        pulumi.set(__self__, "ids", ids)
        if email_subject is not None:
            pulumi.set(__self__, "email_subject", email_subject)
        if webhook_payload is not None:
            pulumi.set(__self__, "webhook_payload", webhook_payload)

    @property
    @pulumi.getter
    def ids(self) -> Sequence[str]:
        """
        Specifies the action group ids.
        """
        return pulumi.get(self, "ids")

    @property
    @pulumi.getter(name="emailSubject")
    def email_subject(self) -> Optional[str]:
        """
        Specifies a custom email subject if Email Receiver is specified in Monitor Action Group resource.
        """
        return pulumi.get(self, "email_subject")

    @property
    @pulumi.getter(name="webhookPayload")
    def webhook_payload(self) -> Optional[str]:
        """
        A JSON String which Specifies the custom webhook payload if Webhook Receiver is specified in Monitor Action Group resource.
        """
        return pulumi.get(self, "webhook_payload")


@pulumi.output_type
class GetActionGroupArmRoleReceiverResult(dict):
    def __init__(__self__, *,
                 name: str,
                 role_id: str,
                 use_common_alert_schema: bool):
        """
        :param str name: Specifies the name of the Action Group.
        :param str role_id: The arm role id.
        :param bool use_common_alert_schema: Indicates whether to use common alert schema.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "role_id", role_id)
        pulumi.set(__self__, "use_common_alert_schema", use_common_alert_schema)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the Action Group.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="roleId")
    def role_id(self) -> str:
        """
        The arm role id.
        """
        return pulumi.get(self, "role_id")

    @property
    @pulumi.getter(name="useCommonAlertSchema")
    def use_common_alert_schema(self) -> bool:
        """
        Indicates whether to use common alert schema.
        """
        return pulumi.get(self, "use_common_alert_schema")


@pulumi.output_type
class GetActionGroupAutomationRunbookReceiverResult(dict):
    def __init__(__self__, *,
                 automation_account_id: str,
                 is_global_runbook: bool,
                 name: str,
                 runbook_name: str,
                 service_uri: str,
                 use_common_alert_schema: bool,
                 webhook_resource_id: str):
        """
        :param str automation_account_id: The automation account ID which holds this runbook and authenticates to Azure resources.
        :param bool is_global_runbook: Indicates whether this instance is global runbook.
        :param str name: Specifies the name of the Action Group.
        :param str runbook_name: The name for this runbook.
        :param str service_uri: The URI where webhooks should be sent.
        :param bool use_common_alert_schema: Indicates whether to use common alert schema.
        :param str webhook_resource_id: The resource id for webhook linked to this runbook.
        """
        pulumi.set(__self__, "automation_account_id", automation_account_id)
        pulumi.set(__self__, "is_global_runbook", is_global_runbook)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "runbook_name", runbook_name)
        pulumi.set(__self__, "service_uri", service_uri)
        pulumi.set(__self__, "use_common_alert_schema", use_common_alert_schema)
        pulumi.set(__self__, "webhook_resource_id", webhook_resource_id)

    @property
    @pulumi.getter(name="automationAccountId")
    def automation_account_id(self) -> str:
        """
        The automation account ID which holds this runbook and authenticates to Azure resources.
        """
        return pulumi.get(self, "automation_account_id")

    @property
    @pulumi.getter(name="isGlobalRunbook")
    def is_global_runbook(self) -> bool:
        """
        Indicates whether this instance is global runbook.
        """
        return pulumi.get(self, "is_global_runbook")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the Action Group.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="runbookName")
    def runbook_name(self) -> str:
        """
        The name for this runbook.
        """
        return pulumi.get(self, "runbook_name")

    @property
    @pulumi.getter(name="serviceUri")
    def service_uri(self) -> str:
        """
        The URI where webhooks should be sent.
        """
        return pulumi.get(self, "service_uri")

    @property
    @pulumi.getter(name="useCommonAlertSchema")
    def use_common_alert_schema(self) -> bool:
        """
        Indicates whether to use common alert schema.
        """
        return pulumi.get(self, "use_common_alert_schema")

    @property
    @pulumi.getter(name="webhookResourceId")
    def webhook_resource_id(self) -> str:
        """
        The resource id for webhook linked to this runbook.
        """
        return pulumi.get(self, "webhook_resource_id")


@pulumi.output_type
class GetActionGroupAzureAppPushReceiverResult(dict):
    def __init__(__self__, *,
                 email_address: str,
                 name: str):
        """
        :param str email_address: The email address of this receiver.
        :param str name: Specifies the name of the Action Group.
        """
        pulumi.set(__self__, "email_address", email_address)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter(name="emailAddress")
    def email_address(self) -> str:
        """
        The email address of this receiver.
        """
        return pulumi.get(self, "email_address")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the Action Group.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetActionGroupAzureFunctionReceiverResult(dict):
    def __init__(__self__, *,
                 function_app_resource_id: str,
                 function_name: str,
                 http_trigger_url: str,
                 name: str,
                 use_common_alert_schema: bool):
        """
        :param str function_app_resource_id: The Azure resource ID of the function app.
        :param str function_name: The function name in the function app.
        :param str http_trigger_url: The http trigger url where http request sent to.
        :param str name: Specifies the name of the Action Group.
        :param bool use_common_alert_schema: Indicates whether to use common alert schema.
        """
        pulumi.set(__self__, "function_app_resource_id", function_app_resource_id)
        pulumi.set(__self__, "function_name", function_name)
        pulumi.set(__self__, "http_trigger_url", http_trigger_url)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "use_common_alert_schema", use_common_alert_schema)

    @property
    @pulumi.getter(name="functionAppResourceId")
    def function_app_resource_id(self) -> str:
        """
        The Azure resource ID of the function app.
        """
        return pulumi.get(self, "function_app_resource_id")

    @property
    @pulumi.getter(name="functionName")
    def function_name(self) -> str:
        """
        The function name in the function app.
        """
        return pulumi.get(self, "function_name")

    @property
    @pulumi.getter(name="httpTriggerUrl")
    def http_trigger_url(self) -> str:
        """
        The http trigger url where http request sent to.
        """
        return pulumi.get(self, "http_trigger_url")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the Action Group.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="useCommonAlertSchema")
    def use_common_alert_schema(self) -> bool:
        """
        Indicates whether to use common alert schema.
        """
        return pulumi.get(self, "use_common_alert_schema")


@pulumi.output_type
class GetActionGroupEmailReceiverResult(dict):
    def __init__(__self__, *,
                 email_address: str,
                 name: str,
                 use_common_alert_schema: bool):
        """
        :param str email_address: The email address of this receiver.
        :param str name: Specifies the name of the Action Group.
        :param bool use_common_alert_schema: Indicates whether to use common alert schema.
        """
        pulumi.set(__self__, "email_address", email_address)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "use_common_alert_schema", use_common_alert_schema)

    @property
    @pulumi.getter(name="emailAddress")
    def email_address(self) -> str:
        """
        The email address of this receiver.
        """
        return pulumi.get(self, "email_address")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the Action Group.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="useCommonAlertSchema")
    def use_common_alert_schema(self) -> bool:
        """
        Indicates whether to use common alert schema.
        """
        return pulumi.get(self, "use_common_alert_schema")


@pulumi.output_type
class GetActionGroupItsmReceiverResult(dict):
    def __init__(__self__, *,
                 connection_id: str,
                 name: str,
                 region: str,
                 ticket_configuration: str,
                 workspace_id: str):
        """
        :param str connection_id: The unique connection identifier of the ITSM connection.
        :param str name: Specifies the name of the Action Group.
        :param str region: The region of the workspace.
        :param str ticket_configuration: A JSON blob for the configurations of the ITSM action. CreateMultipleWorkItems option will be part of this blob as well.
        :param str workspace_id: The Azure Log Analytics workspace ID where this connection is defined.
        """
        pulumi.set(__self__, "connection_id", connection_id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "ticket_configuration", ticket_configuration)
        pulumi.set(__self__, "workspace_id", workspace_id)

    @property
    @pulumi.getter(name="connectionId")
    def connection_id(self) -> str:
        """
        The unique connection identifier of the ITSM connection.
        """
        return pulumi.get(self, "connection_id")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the Action Group.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        The region of the workspace.
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="ticketConfiguration")
    def ticket_configuration(self) -> str:
        """
        A JSON blob for the configurations of the ITSM action. CreateMultipleWorkItems option will be part of this blob as well.
        """
        return pulumi.get(self, "ticket_configuration")

    @property
    @pulumi.getter(name="workspaceId")
    def workspace_id(self) -> str:
        """
        The Azure Log Analytics workspace ID where this connection is defined.
        """
        return pulumi.get(self, "workspace_id")


@pulumi.output_type
class GetActionGroupLogicAppReceiverResult(dict):
    def __init__(__self__, *,
                 callback_url: str,
                 name: str,
                 resource_id: str,
                 use_common_alert_schema: bool):
        """
        :param str callback_url: The callback url where http request sent to.
        :param str name: Specifies the name of the Action Group.
        :param str resource_id: The Azure resource ID of the logic app.
        :param bool use_common_alert_schema: Indicates whether to use common alert schema.
        """
        pulumi.set(__self__, "callback_url", callback_url)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "resource_id", resource_id)
        pulumi.set(__self__, "use_common_alert_schema", use_common_alert_schema)

    @property
    @pulumi.getter(name="callbackUrl")
    def callback_url(self) -> str:
        """
        The callback url where http request sent to.
        """
        return pulumi.get(self, "callback_url")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the Action Group.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="resourceId")
    def resource_id(self) -> str:
        """
        The Azure resource ID of the logic app.
        """
        return pulumi.get(self, "resource_id")

    @property
    @pulumi.getter(name="useCommonAlertSchema")
    def use_common_alert_schema(self) -> bool:
        """
        Indicates whether to use common alert schema.
        """
        return pulumi.get(self, "use_common_alert_schema")


@pulumi.output_type
class GetActionGroupSmsReceiverResult(dict):
    def __init__(__self__, *,
                 country_code: str,
                 name: str,
                 phone_number: str):
        """
        :param str country_code: The country code of the voice receiver.
        :param str name: Specifies the name of the Action Group.
        :param str phone_number: The phone number of the voice receiver.
        """
        pulumi.set(__self__, "country_code", country_code)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "phone_number", phone_number)

    @property
    @pulumi.getter(name="countryCode")
    def country_code(self) -> str:
        """
        The country code of the voice receiver.
        """
        return pulumi.get(self, "country_code")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the Action Group.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="phoneNumber")
    def phone_number(self) -> str:
        """
        The phone number of the voice receiver.
        """
        return pulumi.get(self, "phone_number")


@pulumi.output_type
class GetActionGroupVoiceReceiverResult(dict):
    def __init__(__self__, *,
                 country_code: str,
                 name: str,
                 phone_number: str):
        """
        :param str country_code: The country code of the voice receiver.
        :param str name: Specifies the name of the Action Group.
        :param str phone_number: The phone number of the voice receiver.
        """
        pulumi.set(__self__, "country_code", country_code)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "phone_number", phone_number)

    @property
    @pulumi.getter(name="countryCode")
    def country_code(self) -> str:
        """
        The country code of the voice receiver.
        """
        return pulumi.get(self, "country_code")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the Action Group.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="phoneNumber")
    def phone_number(self) -> str:
        """
        The phone number of the voice receiver.
        """
        return pulumi.get(self, "phone_number")


@pulumi.output_type
class GetActionGroupWebhookReceiverResult(dict):
    def __init__(__self__, *,
                 aad_auths: Sequence['outputs.GetActionGroupWebhookReceiverAadAuthResult'],
                 name: str,
                 service_uri: str,
                 use_common_alert_schema: bool):
        """
        :param str name: Specifies the name of the Action Group.
        :param str service_uri: The URI where webhooks should be sent.
        :param bool use_common_alert_schema: Indicates whether to use common alert schema.
        """
        pulumi.set(__self__, "aad_auths", aad_auths)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "service_uri", service_uri)
        pulumi.set(__self__, "use_common_alert_schema", use_common_alert_schema)

    @property
    @pulumi.getter(name="aadAuths")
    def aad_auths(self) -> Sequence['outputs.GetActionGroupWebhookReceiverAadAuthResult']:
        return pulumi.get(self, "aad_auths")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the Action Group.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="serviceUri")
    def service_uri(self) -> str:
        """
        The URI where webhooks should be sent.
        """
        return pulumi.get(self, "service_uri")

    @property
    @pulumi.getter(name="useCommonAlertSchema")
    def use_common_alert_schema(self) -> bool:
        """
        Indicates whether to use common alert schema.
        """
        return pulumi.get(self, "use_common_alert_schema")


@pulumi.output_type
class GetActionGroupWebhookReceiverAadAuthResult(dict):
    def __init__(__self__, *,
                 identifier_uri: str,
                 object_id: str,
                 tenant_id: str):
        pulumi.set(__self__, "identifier_uri", identifier_uri)
        pulumi.set(__self__, "object_id", object_id)
        pulumi.set(__self__, "tenant_id", tenant_id)

    @property
    @pulumi.getter(name="identifierUri")
    def identifier_uri(self) -> str:
        return pulumi.get(self, "identifier_uri")

    @property
    @pulumi.getter(name="objectId")
    def object_id(self) -> str:
        return pulumi.get(self, "object_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        return pulumi.get(self, "tenant_id")


@pulumi.output_type
class GetLogProfileRetentionPolicyResult(dict):
    def __init__(__self__, *,
                 days: int,
                 enabled: bool):
        """
        :param int days: The number of days for the retention policy.
        :param bool enabled: A boolean value indicating whether the retention policy is enabled.
        """
        pulumi.set(__self__, "days", days)
        pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def days(self) -> int:
        """
        The number of days for the retention policy.
        """
        return pulumi.get(self, "days")

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        A boolean value indicating whether the retention policy is enabled.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetScheduledQueryRulesAlertActionResult(dict):
    def __init__(__self__, *,
                 action_groups: Sequence[str],
                 custom_webhook_payload: str,
                 email_subject: str):
        """
        :param Sequence[str] action_groups: List of action group reference resource IDs.
        :param str custom_webhook_payload: Custom payload to be sent for all webhook URI in Azure action group.
        :param str email_subject: Custom subject override for all email IDs in Azure action group.
        """
        pulumi.set(__self__, "action_groups", action_groups)
        pulumi.set(__self__, "custom_webhook_payload", custom_webhook_payload)
        pulumi.set(__self__, "email_subject", email_subject)

    @property
    @pulumi.getter(name="actionGroups")
    def action_groups(self) -> Sequence[str]:
        """
        List of action group reference resource IDs.
        """
        return pulumi.get(self, "action_groups")

    @property
    @pulumi.getter(name="customWebhookPayload")
    def custom_webhook_payload(self) -> str:
        """
        Custom payload to be sent for all webhook URI in Azure action group.
        """
        return pulumi.get(self, "custom_webhook_payload")

    @property
    @pulumi.getter(name="emailSubject")
    def email_subject(self) -> str:
        """
        Custom subject override for all email IDs in Azure action group.
        """
        return pulumi.get(self, "email_subject")


@pulumi.output_type
class GetScheduledQueryRulesAlertTriggerResult(dict):
    def __init__(__self__, *,
                 metric_triggers: Sequence['outputs.GetScheduledQueryRulesAlertTriggerMetricTriggerResult'],
                 operator: str,
                 threshold: float):
        """
        :param str operator: Evaluation operation for rule.
        :param float threshold: Result or count threshold based on which rule should be triggered.
        """
        pulumi.set(__self__, "metric_triggers", metric_triggers)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "threshold", threshold)

    @property
    @pulumi.getter(name="metricTriggers")
    def metric_triggers(self) -> Sequence['outputs.GetScheduledQueryRulesAlertTriggerMetricTriggerResult']:
        return pulumi.get(self, "metric_triggers")

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        Evaluation operation for rule.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def threshold(self) -> float:
        """
        Result or count threshold based on which rule should be triggered.
        """
        return pulumi.get(self, "threshold")


@pulumi.output_type
class GetScheduledQueryRulesAlertTriggerMetricTriggerResult(dict):
    def __init__(__self__, *,
                 metric_column: str,
                 metric_trigger_type: str,
                 operator: str,
                 threshold: float):
        """
        :param str operator: Evaluation operation for rule.
        :param float threshold: Result or count threshold based on which rule should be triggered.
        """
        pulumi.set(__self__, "metric_column", metric_column)
        pulumi.set(__self__, "metric_trigger_type", metric_trigger_type)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "threshold", threshold)

    @property
    @pulumi.getter(name="metricColumn")
    def metric_column(self) -> str:
        return pulumi.get(self, "metric_column")

    @property
    @pulumi.getter(name="metricTriggerType")
    def metric_trigger_type(self) -> str:
        return pulumi.get(self, "metric_trigger_type")

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        Evaluation operation for rule.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def threshold(self) -> float:
        """
        Result or count threshold based on which rule should be triggered.
        """
        return pulumi.get(self, "threshold")


@pulumi.output_type
class GetScheduledQueryRulesLogCriteriaResult(dict):
    def __init__(__self__, *,
                 dimensions: Sequence['outputs.GetScheduledQueryRulesLogCriteriaDimensionResult'],
                 metric_name: str):
        """
        :param Sequence['GetScheduledQueryRulesLogCriteriaDimensionArgs'] dimensions: A `dimension` block as defined below.
        :param str metric_name: Name of the metric.
        """
        pulumi.set(__self__, "dimensions", dimensions)
        pulumi.set(__self__, "metric_name", metric_name)

    @property
    @pulumi.getter
    def dimensions(self) -> Sequence['outputs.GetScheduledQueryRulesLogCriteriaDimensionResult']:
        """
        A `dimension` block as defined below.
        """
        return pulumi.get(self, "dimensions")

    @property
    @pulumi.getter(name="metricName")
    def metric_name(self) -> str:
        """
        Name of the metric.
        """
        return pulumi.get(self, "metric_name")


@pulumi.output_type
class GetScheduledQueryRulesLogCriteriaDimensionResult(dict):
    def __init__(__self__, *,
                 name: str,
                 operator: str,
                 values: Sequence[str]):
        """
        :param str name: Specifies the name of the scheduled query rule.
        :param str operator: Operator for dimension values.
        :param Sequence[str] values: List of dimension values.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the scheduled query rule.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def operator(self) -> str:
        """
        Operator for dimension values.
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        List of dimension values.
        """
        return pulumi.get(self, "values")


