# 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

__all__ = [
    'DatabaseLongTermRetentionPolicyArgs',
    'DatabaseShortTermRetentionPolicyArgs',
    'DatabaseThreatDetectionPolicyArgs',
    'DatabaseVulnerabilityAssessmentRuleBaselineBaselineResultArgs',
    'ElasticPoolPerDatabaseSettingsArgs',
    'ElasticPoolSkuArgs',
    'FailoverGroupPartnerServerArgs',
    'FailoverGroupReadWriteEndpointFailoverPolicyArgs',
    'ManagedInstanceFailoverGroupPartnerRegionArgs',
    'ManagedInstanceFailoverGroupReadWriteEndpointFailoverPolicyArgs',
    'ManagedInstanceIdentityArgs',
    'ManagedInstanceVulnerabilityAssessmentRecurringScansArgs',
    'ServerAzureadAdministratorArgs',
    'ServerIdentityArgs',
    'ServerVulnerabilityAssessmentRecurringScansArgs',
    'VirtualMachineAutoBackupArgs',
    'VirtualMachineAutoBackupManualScheduleArgs',
    'VirtualMachineAutoPatchingArgs',
    'VirtualMachineKeyVaultCredentialArgs',
    'VirtualMachineStorageConfigurationArgs',
    'VirtualMachineStorageConfigurationDataSettingsArgs',
    'VirtualMachineStorageConfigurationLogSettingsArgs',
    'VirtualMachineStorageConfigurationTempDbSettingsArgs',
]

@pulumi.input_type
class DatabaseLongTermRetentionPolicyArgs:
    def __init__(__self__, *,
                 monthly_retention: Optional[pulumi.Input[str]] = None,
                 week_of_year: Optional[pulumi.Input[int]] = None,
                 weekly_retention: Optional[pulumi.Input[str]] = None,
                 yearly_retention: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] monthly_retention: The monthly retention policy for an LTR backup in an ISO 8601 format. Valid value is between 1 to 120 months. e.g. `P1Y`, `P1M`, `P4W` or `P30D`.
        :param pulumi.Input[int] week_of_year: The week of year to take the yearly backup. Value has to be between `1` and `52`.
        :param pulumi.Input[str] weekly_retention: The weekly retention policy for an LTR backup in an ISO 8601 format. Valid value is between 1 to 520 weeks. e.g. `P1Y`, `P1M`, `P1W` or `P7D`.
        :param pulumi.Input[str] yearly_retention: The yearly retention policy for an LTR backup in an ISO 8601 format. Valid value is between 1 to 10 years. e.g. `P1Y`, `P12M`, `P52W` or `P365D`.
        """
        if monthly_retention is not None:
            pulumi.set(__self__, "monthly_retention", monthly_retention)
        if week_of_year is not None:
            pulumi.set(__self__, "week_of_year", week_of_year)
        if weekly_retention is not None:
            pulumi.set(__self__, "weekly_retention", weekly_retention)
        if yearly_retention is not None:
            pulumi.set(__self__, "yearly_retention", yearly_retention)

    @property
    @pulumi.getter(name="monthlyRetention")
    def monthly_retention(self) -> Optional[pulumi.Input[str]]:
        """
        The monthly retention policy for an LTR backup in an ISO 8601 format. Valid value is between 1 to 120 months. e.g. `P1Y`, `P1M`, `P4W` or `P30D`.
        """
        return pulumi.get(self, "monthly_retention")

    @monthly_retention.setter
    def monthly_retention(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "monthly_retention", value)

    @property
    @pulumi.getter(name="weekOfYear")
    def week_of_year(self) -> Optional[pulumi.Input[int]]:
        """
        The week of year to take the yearly backup. Value has to be between `1` and `52`.
        """
        return pulumi.get(self, "week_of_year")

    @week_of_year.setter
    def week_of_year(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "week_of_year", value)

    @property
    @pulumi.getter(name="weeklyRetention")
    def weekly_retention(self) -> Optional[pulumi.Input[str]]:
        """
        The weekly retention policy for an LTR backup in an ISO 8601 format. Valid value is between 1 to 520 weeks. e.g. `P1Y`, `P1M`, `P1W` or `P7D`.
        """
        return pulumi.get(self, "weekly_retention")

    @weekly_retention.setter
    def weekly_retention(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "weekly_retention", value)

    @property
    @pulumi.getter(name="yearlyRetention")
    def yearly_retention(self) -> Optional[pulumi.Input[str]]:
        """
        The yearly retention policy for an LTR backup in an ISO 8601 format. Valid value is between 1 to 10 years. e.g. `P1Y`, `P12M`, `P52W` or `P365D`.
        """
        return pulumi.get(self, "yearly_retention")

    @yearly_retention.setter
    def yearly_retention(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "yearly_retention", value)


@pulumi.input_type
class DatabaseShortTermRetentionPolicyArgs:
    def __init__(__self__, *,
                 retention_days: pulumi.Input[int],
                 backup_interval_in_hours: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] retention_days: Point In Time Restore configuration. Value has to be between `7` and `35`.
        :param pulumi.Input[int] backup_interval_in_hours: The hours between each differential backup. This is only applicable to live databases but not dropped databases. Value has to be `12` or `24`. Defaults to `12` hours.
        """
        pulumi.set(__self__, "retention_days", retention_days)
        if backup_interval_in_hours is not None:
            pulumi.set(__self__, "backup_interval_in_hours", backup_interval_in_hours)

    @property
    @pulumi.getter(name="retentionDays")
    def retention_days(self) -> pulumi.Input[int]:
        """
        Point In Time Restore configuration. Value has to be between `7` and `35`.
        """
        return pulumi.get(self, "retention_days")

    @retention_days.setter
    def retention_days(self, value: pulumi.Input[int]):
        pulumi.set(self, "retention_days", value)

    @property
    @pulumi.getter(name="backupIntervalInHours")
    def backup_interval_in_hours(self) -> Optional[pulumi.Input[int]]:
        """
        The hours between each differential backup. This is only applicable to live databases but not dropped databases. Value has to be `12` or `24`. Defaults to `12` hours.
        """
        return pulumi.get(self, "backup_interval_in_hours")

    @backup_interval_in_hours.setter
    def backup_interval_in_hours(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "backup_interval_in_hours", value)


@pulumi.input_type
class DatabaseThreatDetectionPolicyArgs:
    def __init__(__self__, *,
                 disabled_alerts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 email_account_admins: Optional[pulumi.Input[str]] = None,
                 email_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 retention_days: Optional[pulumi.Input[int]] = None,
                 state: Optional[pulumi.Input[str]] = None,
                 storage_account_access_key: Optional[pulumi.Input[str]] = None,
                 storage_endpoint: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] disabled_alerts: Specifies a list of alerts which should be disabled. Possible values include `Access_Anomaly`, `Sql_Injection` and `Sql_Injection_Vulnerability`.
        :param pulumi.Input[str] email_account_admins: Should the account administrators be emailed when this alert is triggered?
        :param pulumi.Input[Sequence[pulumi.Input[str]]] email_addresses: A list of email addresses which alerts should be sent to.
        :param pulumi.Input[int] retention_days: Specifies the number of days to keep in the Threat Detection audit logs.
        :param pulumi.Input[str] state: The State of the Policy. Possible values are `Enabled`, `Disabled` or `New`.
        :param pulumi.Input[str] storage_account_access_key: Specifies the identifier key of the Threat Detection audit storage account. Required if `state` is `Enabled`.
        :param pulumi.Input[str] storage_endpoint: Specifies the blob storage endpoint (e.g. https://example.blob.core.windows.net). This blob storage will hold all Threat Detection audit logs. Required if `state` is `Enabled`.
        """
        if disabled_alerts is not None:
            pulumi.set(__self__, "disabled_alerts", disabled_alerts)
        if email_account_admins is not None:
            pulumi.set(__self__, "email_account_admins", email_account_admins)
        if email_addresses is not None:
            pulumi.set(__self__, "email_addresses", email_addresses)
        if retention_days is not None:
            pulumi.set(__self__, "retention_days", retention_days)
        if state is not None:
            pulumi.set(__self__, "state", state)
        if storage_account_access_key is not None:
            pulumi.set(__self__, "storage_account_access_key", storage_account_access_key)
        if storage_endpoint is not None:
            pulumi.set(__self__, "storage_endpoint", storage_endpoint)

    @property
    @pulumi.getter(name="disabledAlerts")
    def disabled_alerts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies a list of alerts which should be disabled. Possible values include `Access_Anomaly`, `Sql_Injection` and `Sql_Injection_Vulnerability`.
        """
        return pulumi.get(self, "disabled_alerts")

    @disabled_alerts.setter
    def disabled_alerts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "disabled_alerts", value)

    @property
    @pulumi.getter(name="emailAccountAdmins")
    def email_account_admins(self) -> Optional[pulumi.Input[str]]:
        """
        Should the account administrators be emailed when this alert is triggered?
        """
        return pulumi.get(self, "email_account_admins")

    @email_account_admins.setter
    def email_account_admins(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "email_account_admins", value)

    @property
    @pulumi.getter(name="emailAddresses")
    def email_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of email addresses which alerts should be sent to.
        """
        return pulumi.get(self, "email_addresses")

    @email_addresses.setter
    def email_addresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "email_addresses", value)

    @property
    @pulumi.getter(name="retentionDays")
    def retention_days(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the number of days to keep in the Threat Detection audit logs.
        """
        return pulumi.get(self, "retention_days")

    @retention_days.setter
    def retention_days(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "retention_days", value)

    @property
    @pulumi.getter
    def state(self) -> Optional[pulumi.Input[str]]:
        """
        The State of the Policy. Possible values are `Enabled`, `Disabled` or `New`.
        """
        return pulumi.get(self, "state")

    @state.setter
    def state(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "state", value)

    @property
    @pulumi.getter(name="storageAccountAccessKey")
    def storage_account_access_key(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the identifier key of the Threat Detection audit storage account. Required if `state` is `Enabled`.
        """
        return pulumi.get(self, "storage_account_access_key")

    @storage_account_access_key.setter
    def storage_account_access_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "storage_account_access_key", value)

    @property
    @pulumi.getter(name="storageEndpoint")
    def storage_endpoint(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the blob storage endpoint (e.g. https://example.blob.core.windows.net). This blob storage will hold all Threat Detection audit logs. Required if `state` is `Enabled`.
        """
        return pulumi.get(self, "storage_endpoint")

    @storage_endpoint.setter
    def storage_endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "storage_endpoint", value)


@pulumi.input_type
class DatabaseVulnerabilityAssessmentRuleBaselineBaselineResultArgs:
    def __init__(__self__, *,
                 results: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] results: A list representing a result of the baseline.
        """
        pulumi.set(__self__, "results", results)

    @property
    @pulumi.getter
    def results(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        A list representing a result of the baseline.
        """
        return pulumi.get(self, "results")

    @results.setter
    def results(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "results", value)


@pulumi.input_type
class ElasticPoolPerDatabaseSettingsArgs:
    def __init__(__self__, *,
                 max_capacity: pulumi.Input[float],
                 min_capacity: pulumi.Input[float]):
        """
        :param pulumi.Input[float] max_capacity: The maximum capacity any one database can consume.
        :param pulumi.Input[float] min_capacity: The minimum capacity all databases are guaranteed.
        """
        pulumi.set(__self__, "max_capacity", max_capacity)
        pulumi.set(__self__, "min_capacity", min_capacity)

    @property
    @pulumi.getter(name="maxCapacity")
    def max_capacity(self) -> pulumi.Input[float]:
        """
        The maximum capacity any one database can consume.
        """
        return pulumi.get(self, "max_capacity")

    @max_capacity.setter
    def max_capacity(self, value: pulumi.Input[float]):
        pulumi.set(self, "max_capacity", value)

    @property
    @pulumi.getter(name="minCapacity")
    def min_capacity(self) -> pulumi.Input[float]:
        """
        The minimum capacity all databases are guaranteed.
        """
        return pulumi.get(self, "min_capacity")

    @min_capacity.setter
    def min_capacity(self, value: pulumi.Input[float]):
        pulumi.set(self, "min_capacity", value)


@pulumi.input_type
class ElasticPoolSkuArgs:
    def __init__(__self__, *,
                 capacity: pulumi.Input[int],
                 name: pulumi.Input[str],
                 tier: pulumi.Input[str],
                 family: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] capacity: The scale up/out capacity, representing server's compute units. For more information see the documentation for your Elasticpool configuration: [vCore-based](https://docs.microsoft.com/azure/sql-database/sql-database-vcore-resource-limits-elastic-pools) or [DTU-based](https://docs.microsoft.com/azure/sql-database/sql-database-dtu-resource-limits-elastic-pools).
        :param pulumi.Input[str] name: Specifies the SKU Name for this Elasticpool. The name of the SKU, will be either `vCore` based `tier` + `family` pattern (e.g. GP_Gen4, BC_Gen5) or the `DTU` based `BasicPool`, `StandardPool`, or `PremiumPool` pattern.
        :param pulumi.Input[str] tier: The tier of the particular SKU. Possible values are `GeneralPurpose`, `BusinessCritical`, `Basic`, `Standard`, or `Premium`. For more information see the documentation for your Elasticpool configuration: [vCore-based](https://docs.microsoft.com/azure/sql-database/sql-database-vcore-resource-limits-elastic-pools) or [DTU-based](https://docs.microsoft.com/azure/sql-database/sql-database-dtu-resource-limits-elastic-pools).
        :param pulumi.Input[str] family: The `family` of hardware `Gen4`, `Gen5`, `Fsv2` or `DC`.
        """
        pulumi.set(__self__, "capacity", capacity)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "tier", tier)
        if family is not None:
            pulumi.set(__self__, "family", family)

    @property
    @pulumi.getter
    def capacity(self) -> pulumi.Input[int]:
        """
        The scale up/out capacity, representing server's compute units. For more information see the documentation for your Elasticpool configuration: [vCore-based](https://docs.microsoft.com/azure/sql-database/sql-database-vcore-resource-limits-elastic-pools) or [DTU-based](https://docs.microsoft.com/azure/sql-database/sql-database-dtu-resource-limits-elastic-pools).
        """
        return pulumi.get(self, "capacity")

    @capacity.setter
    def capacity(self, value: pulumi.Input[int]):
        pulumi.set(self, "capacity", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Specifies the SKU Name for this Elasticpool. The name of the SKU, will be either `vCore` based `tier` + `family` pattern (e.g. GP_Gen4, BC_Gen5) or the `DTU` based `BasicPool`, `StandardPool`, or `PremiumPool` pattern.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def tier(self) -> pulumi.Input[str]:
        """
        The tier of the particular SKU. Possible values are `GeneralPurpose`, `BusinessCritical`, `Basic`, `Standard`, or `Premium`. For more information see the documentation for your Elasticpool configuration: [vCore-based](https://docs.microsoft.com/azure/sql-database/sql-database-vcore-resource-limits-elastic-pools) or [DTU-based](https://docs.microsoft.com/azure/sql-database/sql-database-dtu-resource-limits-elastic-pools).
        """
        return pulumi.get(self, "tier")

    @tier.setter
    def tier(self, value: pulumi.Input[str]):
        pulumi.set(self, "tier", value)

    @property
    @pulumi.getter
    def family(self) -> Optional[pulumi.Input[str]]:
        """
        The `family` of hardware `Gen4`, `Gen5`, `Fsv2` or `DC`.
        """
        return pulumi.get(self, "family")

    @family.setter
    def family(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "family", value)


@pulumi.input_type
class FailoverGroupPartnerServerArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str],
                 location: Optional[pulumi.Input[str]] = None,
                 role: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] id: The ID of a partner SQL server to include in the failover group.
        :param pulumi.Input[str] location: The location of the partner server.
        :param pulumi.Input[str] role: The replication role of the partner server. Possible values include `Primary` or `Secondary`.
        """
        pulumi.set(__self__, "id", id)
        if location is not None:
            pulumi.set(__self__, "location", location)
        if role is not None:
            pulumi.set(__self__, "role", role)

    @property
    @pulumi.getter
    def id(self) -> pulumi.Input[str]:
        """
        The ID of a partner SQL server to include in the failover group.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter
    def location(self) -> Optional[pulumi.Input[str]]:
        """
        The location of the partner server.
        """
        return pulumi.get(self, "location")

    @location.setter
    def location(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "location", value)

    @property
    @pulumi.getter
    def role(self) -> Optional[pulumi.Input[str]]:
        """
        The replication role of the partner server. Possible values include `Primary` or `Secondary`.
        """
        return pulumi.get(self, "role")

    @role.setter
    def role(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "role", value)


@pulumi.input_type
class FailoverGroupReadWriteEndpointFailoverPolicyArgs:
    def __init__(__self__, *,
                 mode: pulumi.Input[str],
                 grace_minutes: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] mode: The failover policy of the read-write endpoint for the failover group. Possible values are `Automatic` or `Manual`.
        :param pulumi.Input[int] grace_minutes: The grace period in minutes, before failover with data loss is attempted for the read-write endpoint. Required when `mode` is `Automatic`.
        """
        pulumi.set(__self__, "mode", mode)
        if grace_minutes is not None:
            pulumi.set(__self__, "grace_minutes", grace_minutes)

    @property
    @pulumi.getter
    def mode(self) -> pulumi.Input[str]:
        """
        The failover policy of the read-write endpoint for the failover group. Possible values are `Automatic` or `Manual`.
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: pulumi.Input[str]):
        pulumi.set(self, "mode", value)

    @property
    @pulumi.getter(name="graceMinutes")
    def grace_minutes(self) -> Optional[pulumi.Input[int]]:
        """
        The grace period in minutes, before failover with data loss is attempted for the read-write endpoint. Required when `mode` is `Automatic`.
        """
        return pulumi.get(self, "grace_minutes")

    @grace_minutes.setter
    def grace_minutes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "grace_minutes", value)


@pulumi.input_type
class ManagedInstanceFailoverGroupPartnerRegionArgs:
    def __init__(__self__, *,
                 location: Optional[pulumi.Input[str]] = None,
                 role: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] location: The Azure Region where the Managed Instance Failover Group should exist. Changing this forces a new resource to be created.
        :param pulumi.Input[str] role: The partner replication role of the Managed Instance Failover Group.
        """
        if location is not None:
            pulumi.set(__self__, "location", location)
        if role is not None:
            pulumi.set(__self__, "role", role)

    @property
    @pulumi.getter
    def location(self) -> Optional[pulumi.Input[str]]:
        """
        The Azure Region where the Managed Instance Failover Group should exist. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "location")

    @location.setter
    def location(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "location", value)

    @property
    @pulumi.getter
    def role(self) -> Optional[pulumi.Input[str]]:
        """
        The partner replication role of the Managed Instance Failover Group.
        """
        return pulumi.get(self, "role")

    @role.setter
    def role(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "role", value)


@pulumi.input_type
class ManagedInstanceFailoverGroupReadWriteEndpointFailoverPolicyArgs:
    def __init__(__self__, *,
                 mode: pulumi.Input[str],
                 grace_minutes: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] mode: The failover mode. Possible values are `Automatic` or `Manual`.
        :param pulumi.Input[int] grace_minutes: Applies only if `mode` is `Automatic`. The grace period in minutes before failover with data loss is attempted.
        """
        pulumi.set(__self__, "mode", mode)
        if grace_minutes is not None:
            pulumi.set(__self__, "grace_minutes", grace_minutes)

    @property
    @pulumi.getter
    def mode(self) -> pulumi.Input[str]:
        """
        The failover mode. Possible values are `Automatic` or `Manual`.
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: pulumi.Input[str]):
        pulumi.set(self, "mode", value)

    @property
    @pulumi.getter(name="graceMinutes")
    def grace_minutes(self) -> Optional[pulumi.Input[int]]:
        """
        Applies only if `mode` is `Automatic`. The grace period in minutes before failover with data loss is attempted.
        """
        return pulumi.get(self, "grace_minutes")

    @grace_minutes.setter
    def grace_minutes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "grace_minutes", value)


@pulumi.input_type
class ManagedInstanceIdentityArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 principal_id: Optional[pulumi.Input[str]] = None,
                 tenant_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] type: The identity type of the SQL Managed Instance. The only possible value is `SystemAssigned`.
        :param pulumi.Input[str] principal_id: The Principal ID for the Service Principal associated with the Identity of this SQL Managed Instance.
        :param pulumi.Input[str] tenant_id: The Tenant ID for the Service Principal associated with the Identity of this SQL Managed Instance.
        """
        pulumi.set(__self__, "type", type)
        if principal_id is not None:
            pulumi.set(__self__, "principal_id", principal_id)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        The identity type of the SQL Managed Instance. The only possible value is `SystemAssigned`.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> Optional[pulumi.Input[str]]:
        """
        The Principal ID for the Service Principal associated with the Identity of this SQL Managed Instance.
        """
        return pulumi.get(self, "principal_id")

    @principal_id.setter
    def principal_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "principal_id", value)

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[pulumi.Input[str]]:
        """
        The Tenant ID for the Service Principal associated with the Identity of this SQL Managed Instance.
        """
        return pulumi.get(self, "tenant_id")

    @tenant_id.setter
    def tenant_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tenant_id", value)


@pulumi.input_type
class ManagedInstanceVulnerabilityAssessmentRecurringScansArgs:
    def __init__(__self__, *,
                 email_subscription_admins: Optional[pulumi.Input[bool]] = None,
                 emails: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] email_subscription_admins: Boolean flag which specifies if the schedule scan notification will be sent to the subscription administrators. Defaults to `true`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] emails: Specifies an array of e-mail addresses to which the scan notification is sent.
        :param pulumi.Input[bool] enabled: Boolean flag which specifies if recurring scans is enabled or disabled. Defaults to `false`.
        """
        if email_subscription_admins is not None:
            pulumi.set(__self__, "email_subscription_admins", email_subscription_admins)
        if emails is not None:
            pulumi.set(__self__, "emails", emails)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="emailSubscriptionAdmins")
    def email_subscription_admins(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean flag which specifies if the schedule scan notification will be sent to the subscription administrators. Defaults to `true`.
        """
        return pulumi.get(self, "email_subscription_admins")

    @email_subscription_admins.setter
    def email_subscription_admins(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "email_subscription_admins", value)

    @property
    @pulumi.getter
    def emails(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies an array of e-mail addresses to which the scan notification is sent.
        """
        return pulumi.get(self, "emails")

    @emails.setter
    def emails(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "emails", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean flag which specifies if recurring scans is enabled or disabled. Defaults to `false`.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class ServerAzureadAdministratorArgs:
    def __init__(__self__, *,
                 login_username: pulumi.Input[str],
                 object_id: pulumi.Input[str],
                 azuread_authentication_only: Optional[pulumi.Input[bool]] = None,
                 tenant_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] login_username: The login username of the Azure AD Administrator of this SQL Server.
        :param pulumi.Input[str] object_id: The object id of the Azure AD Administrator of this SQL Server.
        :param pulumi.Input[bool] azuread_authentication_only: Specifies whether only AD Users and administrators (like `azuread_administrator.0.login_username`) can be used to login, or also local database users (like `administrator_login`). When `true`, the `administrator_login` and `administrator_login_password` properties can be omitted.
        :param pulumi.Input[str] tenant_id: The tenant id of the Azure AD Administrator of this SQL Server.
        """
        pulumi.set(__self__, "login_username", login_username)
        pulumi.set(__self__, "object_id", object_id)
        if azuread_authentication_only is not None:
            pulumi.set(__self__, "azuread_authentication_only", azuread_authentication_only)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)

    @property
    @pulumi.getter(name="loginUsername")
    def login_username(self) -> pulumi.Input[str]:
        """
        The login username of the Azure AD Administrator of this SQL Server.
        """
        return pulumi.get(self, "login_username")

    @login_username.setter
    def login_username(self, value: pulumi.Input[str]):
        pulumi.set(self, "login_username", value)

    @property
    @pulumi.getter(name="objectId")
    def object_id(self) -> pulumi.Input[str]:
        """
        The object id of the Azure AD Administrator of this SQL Server.
        """
        return pulumi.get(self, "object_id")

    @object_id.setter
    def object_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "object_id", value)

    @property
    @pulumi.getter(name="azureadAuthenticationOnly")
    def azuread_authentication_only(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether only AD Users and administrators (like `azuread_administrator.0.login_username`) can be used to login, or also local database users (like `administrator_login`). When `true`, the `administrator_login` and `administrator_login_password` properties can be omitted.
        """
        return pulumi.get(self, "azuread_authentication_only")

    @azuread_authentication_only.setter
    def azuread_authentication_only(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "azuread_authentication_only", value)

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[pulumi.Input[str]]:
        """
        The tenant id of the Azure AD Administrator of this SQL Server.
        """
        return pulumi.get(self, "tenant_id")

    @tenant_id.setter
    def tenant_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tenant_id", value)


@pulumi.input_type
class ServerIdentityArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 identity_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 principal_id: Optional[pulumi.Input[str]] = None,
                 tenant_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] type: Specifies the type of Managed Service Identity that should be configured on this API Management Service. Possible values are `SystemAssigned`, `UserAssigned`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] identity_ids: Specifies a list of User Assigned Managed Identity IDs to be assigned to this API Management Service.
        :param pulumi.Input[str] principal_id: The Principal ID for the Service Principal associated with the Identity of this SQL Server.
        :param pulumi.Input[str] tenant_id: The tenant id of the Azure AD Administrator of this SQL Server.
        """
        pulumi.set(__self__, "type", type)
        if identity_ids is not None:
            pulumi.set(__self__, "identity_ids", identity_ids)
        if principal_id is not None:
            pulumi.set(__self__, "principal_id", principal_id)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        Specifies the type of Managed Service Identity that should be configured on this API Management Service. Possible values are `SystemAssigned`, `UserAssigned`.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter(name="identityIds")
    def identity_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies a list of User Assigned Managed Identity IDs to be assigned to this API Management Service.
        """
        return pulumi.get(self, "identity_ids")

    @identity_ids.setter
    def identity_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "identity_ids", value)

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> Optional[pulumi.Input[str]]:
        """
        The Principal ID for the Service Principal associated with the Identity of this SQL Server.
        """
        return pulumi.get(self, "principal_id")

    @principal_id.setter
    def principal_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "principal_id", value)

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[pulumi.Input[str]]:
        """
        The tenant id of the Azure AD Administrator of this SQL Server.
        """
        return pulumi.get(self, "tenant_id")

    @tenant_id.setter
    def tenant_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tenant_id", value)


@pulumi.input_type
class ServerVulnerabilityAssessmentRecurringScansArgs:
    def __init__(__self__, *,
                 email_subscription_admins: Optional[pulumi.Input[bool]] = None,
                 emails: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] email_subscription_admins: Boolean flag which specifies if the schedule scan notification will be sent to the subscription administrators. Defaults to `false`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] emails: Specifies an array of email addresses to which the scan notification is sent.
        :param pulumi.Input[bool] enabled: Boolean flag which specifies if recurring scans is enabled or disabled. Defaults to `false`.
        """
        if email_subscription_admins is not None:
            pulumi.set(__self__, "email_subscription_admins", email_subscription_admins)
        if emails is not None:
            pulumi.set(__self__, "emails", emails)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="emailSubscriptionAdmins")
    def email_subscription_admins(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean flag which specifies if the schedule scan notification will be sent to the subscription administrators. Defaults to `false`.
        """
        return pulumi.get(self, "email_subscription_admins")

    @email_subscription_admins.setter
    def email_subscription_admins(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "email_subscription_admins", value)

    @property
    @pulumi.getter
    def emails(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies an array of email addresses to which the scan notification is sent.
        """
        return pulumi.get(self, "emails")

    @emails.setter
    def emails(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "emails", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Boolean flag which specifies if recurring scans is enabled or disabled. Defaults to `false`.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class VirtualMachineAutoBackupArgs:
    def __init__(__self__, *,
                 retention_period_in_days: pulumi.Input[int],
                 storage_account_access_key: pulumi.Input[str],
                 storage_blob_endpoint: pulumi.Input[str],
                 encryption_enabled: Optional[pulumi.Input[bool]] = None,
                 encryption_password: Optional[pulumi.Input[str]] = None,
                 manual_schedule: Optional[pulumi.Input['VirtualMachineAutoBackupManualScheduleArgs']] = None,
                 system_databases_backup_enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[int] retention_period_in_days: Retention period of backups, in days. Valid values are from `1` to `30`.
        :param pulumi.Input[str] storage_account_access_key: Access key for the storage account where backups will be kept.
        :param pulumi.Input[str] storage_blob_endpoint: Blob endpoint for the storage account where backups will be kept.
        :param pulumi.Input[bool] encryption_enabled: Enable or disable encryption for backups. Defaults to `false`.
        :param pulumi.Input[str] encryption_password: Encryption password to use. Must be specified when encryption is enabled.
        :param pulumi.Input['VirtualMachineAutoBackupManualScheduleArgs'] manual_schedule: A `manual_schedule` block as documented below. When this block is present, the schedule type is set to `Manual`. Without this block, the schedule type is set to `Automated`.
        :param pulumi.Input[bool] system_databases_backup_enabled: Include or exclude system databases from auto backup. Defaults to `false`.
        """
        pulumi.set(__self__, "retention_period_in_days", retention_period_in_days)
        pulumi.set(__self__, "storage_account_access_key", storage_account_access_key)
        pulumi.set(__self__, "storage_blob_endpoint", storage_blob_endpoint)
        if encryption_enabled is not None:
            pulumi.set(__self__, "encryption_enabled", encryption_enabled)
        if encryption_password is not None:
            pulumi.set(__self__, "encryption_password", encryption_password)
        if manual_schedule is not None:
            pulumi.set(__self__, "manual_schedule", manual_schedule)
        if system_databases_backup_enabled is not None:
            pulumi.set(__self__, "system_databases_backup_enabled", system_databases_backup_enabled)

    @property
    @pulumi.getter(name="retentionPeriodInDays")
    def retention_period_in_days(self) -> pulumi.Input[int]:
        """
        Retention period of backups, in days. Valid values are from `1` to `30`.
        """
        return pulumi.get(self, "retention_period_in_days")

    @retention_period_in_days.setter
    def retention_period_in_days(self, value: pulumi.Input[int]):
        pulumi.set(self, "retention_period_in_days", value)

    @property
    @pulumi.getter(name="storageAccountAccessKey")
    def storage_account_access_key(self) -> pulumi.Input[str]:
        """
        Access key for the storage account where backups will be kept.
        """
        return pulumi.get(self, "storage_account_access_key")

    @storage_account_access_key.setter
    def storage_account_access_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "storage_account_access_key", value)

    @property
    @pulumi.getter(name="storageBlobEndpoint")
    def storage_blob_endpoint(self) -> pulumi.Input[str]:
        """
        Blob endpoint for the storage account where backups will be kept.
        """
        return pulumi.get(self, "storage_blob_endpoint")

    @storage_blob_endpoint.setter
    def storage_blob_endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "storage_blob_endpoint", value)

    @property
    @pulumi.getter(name="encryptionEnabled")
    def encryption_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable or disable encryption for backups. Defaults to `false`.
        """
        return pulumi.get(self, "encryption_enabled")

    @encryption_enabled.setter
    def encryption_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "encryption_enabled", value)

    @property
    @pulumi.getter(name="encryptionPassword")
    def encryption_password(self) -> Optional[pulumi.Input[str]]:
        """
        Encryption password to use. Must be specified when encryption is enabled.
        """
        return pulumi.get(self, "encryption_password")

    @encryption_password.setter
    def encryption_password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "encryption_password", value)

    @property
    @pulumi.getter(name="manualSchedule")
    def manual_schedule(self) -> Optional[pulumi.Input['VirtualMachineAutoBackupManualScheduleArgs']]:
        """
        A `manual_schedule` block as documented below. When this block is present, the schedule type is set to `Manual`. Without this block, the schedule type is set to `Automated`.
        """
        return pulumi.get(self, "manual_schedule")

    @manual_schedule.setter
    def manual_schedule(self, value: Optional[pulumi.Input['VirtualMachineAutoBackupManualScheduleArgs']]):
        pulumi.set(self, "manual_schedule", value)

    @property
    @pulumi.getter(name="systemDatabasesBackupEnabled")
    def system_databases_backup_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Include or exclude system databases from auto backup. Defaults to `false`.
        """
        return pulumi.get(self, "system_databases_backup_enabled")

    @system_databases_backup_enabled.setter
    def system_databases_backup_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "system_databases_backup_enabled", value)


@pulumi.input_type
class VirtualMachineAutoBackupManualScheduleArgs:
    def __init__(__self__, *,
                 full_backup_frequency: pulumi.Input[str],
                 full_backup_start_hour: pulumi.Input[int],
                 full_backup_window_in_hours: pulumi.Input[int],
                 log_backup_frequency_in_minutes: pulumi.Input[int]):
        """
        :param pulumi.Input[str] full_backup_frequency: Frequency of full backups. Valid values include `Daily` or `Weekly`. Required when `backup_schedule_automated` is false.
        :param pulumi.Input[int] full_backup_start_hour: Start hour of a given day during which full backups can take place. Valid values are from `0` to `23`. Required when `backup_schedule_automated` is false.
        :param pulumi.Input[int] full_backup_window_in_hours: Duration of the time window of a given day during which full backups can take place, in hours. Valid values are between `1` and `23`. Required when `backup_schedule_automated` is false.
        :param pulumi.Input[int] log_backup_frequency_in_minutes: Frequency of log backups, in minutes. Valid values are from `5` to `60`. Required when `backup_schedule_automated` is false.
        """
        pulumi.set(__self__, "full_backup_frequency", full_backup_frequency)
        pulumi.set(__self__, "full_backup_start_hour", full_backup_start_hour)
        pulumi.set(__self__, "full_backup_window_in_hours", full_backup_window_in_hours)
        pulumi.set(__self__, "log_backup_frequency_in_minutes", log_backup_frequency_in_minutes)

    @property
    @pulumi.getter(name="fullBackupFrequency")
    def full_backup_frequency(self) -> pulumi.Input[str]:
        """
        Frequency of full backups. Valid values include `Daily` or `Weekly`. Required when `backup_schedule_automated` is false.
        """
        return pulumi.get(self, "full_backup_frequency")

    @full_backup_frequency.setter
    def full_backup_frequency(self, value: pulumi.Input[str]):
        pulumi.set(self, "full_backup_frequency", value)

    @property
    @pulumi.getter(name="fullBackupStartHour")
    def full_backup_start_hour(self) -> pulumi.Input[int]:
        """
        Start hour of a given day during which full backups can take place. Valid values are from `0` to `23`. Required when `backup_schedule_automated` is false.
        """
        return pulumi.get(self, "full_backup_start_hour")

    @full_backup_start_hour.setter
    def full_backup_start_hour(self, value: pulumi.Input[int]):
        pulumi.set(self, "full_backup_start_hour", value)

    @property
    @pulumi.getter(name="fullBackupWindowInHours")
    def full_backup_window_in_hours(self) -> pulumi.Input[int]:
        """
        Duration of the time window of a given day during which full backups can take place, in hours. Valid values are between `1` and `23`. Required when `backup_schedule_automated` is false.
        """
        return pulumi.get(self, "full_backup_window_in_hours")

    @full_backup_window_in_hours.setter
    def full_backup_window_in_hours(self, value: pulumi.Input[int]):
        pulumi.set(self, "full_backup_window_in_hours", value)

    @property
    @pulumi.getter(name="logBackupFrequencyInMinutes")
    def log_backup_frequency_in_minutes(self) -> pulumi.Input[int]:
        """
        Frequency of log backups, in minutes. Valid values are from `5` to `60`. Required when `backup_schedule_automated` is false.
        """
        return pulumi.get(self, "log_backup_frequency_in_minutes")

    @log_backup_frequency_in_minutes.setter
    def log_backup_frequency_in_minutes(self, value: pulumi.Input[int]):
        pulumi.set(self, "log_backup_frequency_in_minutes", value)


@pulumi.input_type
class VirtualMachineAutoPatchingArgs:
    def __init__(__self__, *,
                 day_of_week: pulumi.Input[str],
                 maintenance_window_duration_in_minutes: pulumi.Input[int],
                 maintenance_window_starting_hour: pulumi.Input[int]):
        """
        :param pulumi.Input[str] day_of_week: The day of week to apply the patch on.
        :param pulumi.Input[int] maintenance_window_duration_in_minutes: The size of the Maintenance Window in minutes.
        :param pulumi.Input[int] maintenance_window_starting_hour: The Hour, in the Virtual Machine Time-Zone when the patching maintenance window should begin.
        """
        pulumi.set(__self__, "day_of_week", day_of_week)
        pulumi.set(__self__, "maintenance_window_duration_in_minutes", maintenance_window_duration_in_minutes)
        pulumi.set(__self__, "maintenance_window_starting_hour", maintenance_window_starting_hour)

    @property
    @pulumi.getter(name="dayOfWeek")
    def day_of_week(self) -> pulumi.Input[str]:
        """
        The day of week to apply the patch on.
        """
        return pulumi.get(self, "day_of_week")

    @day_of_week.setter
    def day_of_week(self, value: pulumi.Input[str]):
        pulumi.set(self, "day_of_week", value)

    @property
    @pulumi.getter(name="maintenanceWindowDurationInMinutes")
    def maintenance_window_duration_in_minutes(self) -> pulumi.Input[int]:
        """
        The size of the Maintenance Window in minutes.
        """
        return pulumi.get(self, "maintenance_window_duration_in_minutes")

    @maintenance_window_duration_in_minutes.setter
    def maintenance_window_duration_in_minutes(self, value: pulumi.Input[int]):
        pulumi.set(self, "maintenance_window_duration_in_minutes", value)

    @property
    @pulumi.getter(name="maintenanceWindowStartingHour")
    def maintenance_window_starting_hour(self) -> pulumi.Input[int]:
        """
        The Hour, in the Virtual Machine Time-Zone when the patching maintenance window should begin.
        """
        return pulumi.get(self, "maintenance_window_starting_hour")

    @maintenance_window_starting_hour.setter
    def maintenance_window_starting_hour(self, value: pulumi.Input[int]):
        pulumi.set(self, "maintenance_window_starting_hour", value)


@pulumi.input_type
class VirtualMachineKeyVaultCredentialArgs:
    def __init__(__self__, *,
                 key_vault_url: pulumi.Input[str],
                 name: pulumi.Input[str],
                 service_principal_name: pulumi.Input[str],
                 service_principal_secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key_vault_url: The Azure Key Vault url. Changing this forces a new resource to be created.
        :param pulumi.Input[str] name: The credential name.
        :param pulumi.Input[str] service_principal_name: The service principal name to access key vault. Changing this forces a new resource to be created.
        :param pulumi.Input[str] service_principal_secret: The service principal name secret to access key vault. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "key_vault_url", key_vault_url)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "service_principal_name", service_principal_name)
        pulumi.set(__self__, "service_principal_secret", service_principal_secret)

    @property
    @pulumi.getter(name="keyVaultUrl")
    def key_vault_url(self) -> pulumi.Input[str]:
        """
        The Azure Key Vault url. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "key_vault_url")

    @key_vault_url.setter
    def key_vault_url(self, value: pulumi.Input[str]):
        pulumi.set(self, "key_vault_url", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The credential name.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="servicePrincipalName")
    def service_principal_name(self) -> pulumi.Input[str]:
        """
        The service principal name to access key vault. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "service_principal_name")

    @service_principal_name.setter
    def service_principal_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "service_principal_name", value)

    @property
    @pulumi.getter(name="servicePrincipalSecret")
    def service_principal_secret(self) -> pulumi.Input[str]:
        """
        The service principal name secret to access key vault. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "service_principal_secret")

    @service_principal_secret.setter
    def service_principal_secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "service_principal_secret", value)


@pulumi.input_type
class VirtualMachineStorageConfigurationArgs:
    def __init__(__self__, *,
                 disk_type: pulumi.Input[str],
                 storage_workload_type: pulumi.Input[str],
                 data_settings: Optional[pulumi.Input['VirtualMachineStorageConfigurationDataSettingsArgs']] = None,
                 log_settings: Optional[pulumi.Input['VirtualMachineStorageConfigurationLogSettingsArgs']] = None,
                 temp_db_settings: Optional[pulumi.Input['VirtualMachineStorageConfigurationTempDbSettingsArgs']] = None):
        """
        :param pulumi.Input[str] disk_type: The type of disk configuration to apply to the SQL Server. Valid values include `NEW`, `EXTEND`, or `ADD`.
        :param pulumi.Input[str] storage_workload_type: The type of storage workload. Valid values include `GENERAL`, `OLTP`, or `DW`.
        :param pulumi.Input['VirtualMachineStorageConfigurationDataSettingsArgs'] data_settings: An `storage_settings` as defined below.
        :param pulumi.Input['VirtualMachineStorageConfigurationLogSettingsArgs'] log_settings: An `storage_settings` as defined below.
        :param pulumi.Input['VirtualMachineStorageConfigurationTempDbSettingsArgs'] temp_db_settings: An `storage_settings` as defined below.
        """
        pulumi.set(__self__, "disk_type", disk_type)
        pulumi.set(__self__, "storage_workload_type", storage_workload_type)
        if data_settings is not None:
            pulumi.set(__self__, "data_settings", data_settings)
        if log_settings is not None:
            pulumi.set(__self__, "log_settings", log_settings)
        if temp_db_settings is not None:
            pulumi.set(__self__, "temp_db_settings", temp_db_settings)

    @property
    @pulumi.getter(name="diskType")
    def disk_type(self) -> pulumi.Input[str]:
        """
        The type of disk configuration to apply to the SQL Server. Valid values include `NEW`, `EXTEND`, or `ADD`.
        """
        return pulumi.get(self, "disk_type")

    @disk_type.setter
    def disk_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "disk_type", value)

    @property
    @pulumi.getter(name="storageWorkloadType")
    def storage_workload_type(self) -> pulumi.Input[str]:
        """
        The type of storage workload. Valid values include `GENERAL`, `OLTP`, or `DW`.
        """
        return pulumi.get(self, "storage_workload_type")

    @storage_workload_type.setter
    def storage_workload_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "storage_workload_type", value)

    @property
    @pulumi.getter(name="dataSettings")
    def data_settings(self) -> Optional[pulumi.Input['VirtualMachineStorageConfigurationDataSettingsArgs']]:
        """
        An `storage_settings` as defined below.
        """
        return pulumi.get(self, "data_settings")

    @data_settings.setter
    def data_settings(self, value: Optional[pulumi.Input['VirtualMachineStorageConfigurationDataSettingsArgs']]):
        pulumi.set(self, "data_settings", value)

    @property
    @pulumi.getter(name="logSettings")
    def log_settings(self) -> Optional[pulumi.Input['VirtualMachineStorageConfigurationLogSettingsArgs']]:
        """
        An `storage_settings` as defined below.
        """
        return pulumi.get(self, "log_settings")

    @log_settings.setter
    def log_settings(self, value: Optional[pulumi.Input['VirtualMachineStorageConfigurationLogSettingsArgs']]):
        pulumi.set(self, "log_settings", value)

    @property
    @pulumi.getter(name="tempDbSettings")
    def temp_db_settings(self) -> Optional[pulumi.Input['VirtualMachineStorageConfigurationTempDbSettingsArgs']]:
        """
        An `storage_settings` as defined below.
        """
        return pulumi.get(self, "temp_db_settings")

    @temp_db_settings.setter
    def temp_db_settings(self, value: Optional[pulumi.Input['VirtualMachineStorageConfigurationTempDbSettingsArgs']]):
        pulumi.set(self, "temp_db_settings", value)


@pulumi.input_type
class VirtualMachineStorageConfigurationDataSettingsArgs:
    def __init__(__self__, *,
                 default_file_path: pulumi.Input[str],
                 luns: pulumi.Input[Sequence[pulumi.Input[int]]]):
        """
        :param pulumi.Input[str] default_file_path: The SQL Server default path
        :param pulumi.Input[Sequence[pulumi.Input[int]]] luns: A list of Logical Unit Numbers for the disks.
        """
        pulumi.set(__self__, "default_file_path", default_file_path)
        pulumi.set(__self__, "luns", luns)

    @property
    @pulumi.getter(name="defaultFilePath")
    def default_file_path(self) -> pulumi.Input[str]:
        """
        The SQL Server default path
        """
        return pulumi.get(self, "default_file_path")

    @default_file_path.setter
    def default_file_path(self, value: pulumi.Input[str]):
        pulumi.set(self, "default_file_path", value)

    @property
    @pulumi.getter
    def luns(self) -> pulumi.Input[Sequence[pulumi.Input[int]]]:
        """
        A list of Logical Unit Numbers for the disks.
        """
        return pulumi.get(self, "luns")

    @luns.setter
    def luns(self, value: pulumi.Input[Sequence[pulumi.Input[int]]]):
        pulumi.set(self, "luns", value)


@pulumi.input_type
class VirtualMachineStorageConfigurationLogSettingsArgs:
    def __init__(__self__, *,
                 default_file_path: pulumi.Input[str],
                 luns: pulumi.Input[Sequence[pulumi.Input[int]]]):
        """
        :param pulumi.Input[str] default_file_path: The SQL Server default path
        :param pulumi.Input[Sequence[pulumi.Input[int]]] luns: A list of Logical Unit Numbers for the disks.
        """
        pulumi.set(__self__, "default_file_path", default_file_path)
        pulumi.set(__self__, "luns", luns)

    @property
    @pulumi.getter(name="defaultFilePath")
    def default_file_path(self) -> pulumi.Input[str]:
        """
        The SQL Server default path
        """
        return pulumi.get(self, "default_file_path")

    @default_file_path.setter
    def default_file_path(self, value: pulumi.Input[str]):
        pulumi.set(self, "default_file_path", value)

    @property
    @pulumi.getter
    def luns(self) -> pulumi.Input[Sequence[pulumi.Input[int]]]:
        """
        A list of Logical Unit Numbers for the disks.
        """
        return pulumi.get(self, "luns")

    @luns.setter
    def luns(self, value: pulumi.Input[Sequence[pulumi.Input[int]]]):
        pulumi.set(self, "luns", value)


@pulumi.input_type
class VirtualMachineStorageConfigurationTempDbSettingsArgs:
    def __init__(__self__, *,
                 default_file_path: pulumi.Input[str],
                 luns: pulumi.Input[Sequence[pulumi.Input[int]]]):
        """
        :param pulumi.Input[str] default_file_path: The SQL Server default path
        :param pulumi.Input[Sequence[pulumi.Input[int]]] luns: A list of Logical Unit Numbers for the disks.
        """
        pulumi.set(__self__, "default_file_path", default_file_path)
        pulumi.set(__self__, "luns", luns)

    @property
    @pulumi.getter(name="defaultFilePath")
    def default_file_path(self) -> pulumi.Input[str]:
        """
        The SQL Server default path
        """
        return pulumi.get(self, "default_file_path")

    @default_file_path.setter
    def default_file_path(self, value: pulumi.Input[str]):
        pulumi.set(self, "default_file_path", value)

    @property
    @pulumi.getter
    def luns(self) -> pulumi.Input[Sequence[pulumi.Input[int]]]:
        """
        A list of Logical Unit Numbers for the disks.
        """
        return pulumi.get(self, "luns")

    @luns.setter
    def luns(self, value: pulumi.Input[Sequence[pulumi.Input[int]]]):
        pulumi.set(self, "luns", value)


