# 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 copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'DatabaseImport',
    'DatabaseLongTermRetentionPolicy',
    'DatabaseShortTermRetentionPolicy',
    'DatabaseThreatDetectionPolicy',
    'DatabaseVulnerabilityAssessmentRuleBaselineBaselineResult',
    'ElasticPoolPerDatabaseSettings',
    'ElasticPoolSku',
    'FailoverGroupPartnerServer',
    'FailoverGroupReadWriteEndpointFailoverPolicy',
    'ManagedInstanceFailoverGroupPartnerRegion',
    'ManagedInstanceFailoverGroupReadWriteEndpointFailoverPolicy',
    'ManagedInstanceIdentity',
    'ManagedInstanceVulnerabilityAssessmentRecurringScans',
    'ServerAzureadAdministrator',
    'ServerIdentity',
    'ServerVulnerabilityAssessmentRecurringScans',
    'VirtualMachineAssessment',
    'VirtualMachineAssessmentSchedule',
    'VirtualMachineAutoBackup',
    'VirtualMachineAutoBackupManualSchedule',
    'VirtualMachineAutoPatching',
    'VirtualMachineKeyVaultCredential',
    'VirtualMachineSqlInstance',
    'VirtualMachineStorageConfiguration',
    'VirtualMachineStorageConfigurationDataSettings',
    'VirtualMachineStorageConfigurationLogSettings',
    'VirtualMachineStorageConfigurationTempDbSettings',
    'GetElasticPoolSkusResult',
    'GetManagedInstanceIdentityResult',
    'GetServerIdentityResult',
]

@pulumi.output_type
class DatabaseImport(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "administratorLogin":
            suggest = "administrator_login"
        elif key == "administratorLoginPassword":
            suggest = "administrator_login_password"
        elif key == "authenticationType":
            suggest = "authentication_type"
        elif key == "storageKey":
            suggest = "storage_key"
        elif key == "storageKeyType":
            suggest = "storage_key_type"
        elif key == "storageUri":
            suggest = "storage_uri"
        elif key == "storageAccountId":
            suggest = "storage_account_id"

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

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

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

    def __init__(__self__, *,
                 administrator_login: str,
                 administrator_login_password: str,
                 authentication_type: str,
                 storage_key: str,
                 storage_key_type: str,
                 storage_uri: str,
                 storage_account_id: Optional[str] = None):
        """
        :param str administrator_login: Specifies the name of the SQL administrator.
        :param str administrator_login_password: Specifies the password of the SQL administrator.
        :param str authentication_type: Specifies the type of authentication used to access the server. Valid values are `SQL` or `ADPassword`.
        :param str storage_key: Specifies the access key for the storage account.
        :param str storage_key_type: Specifies the type of access key for the storage account. Valid values are `StorageAccessKey` or `SharedAccessKey`.
        :param str storage_uri: Specifies the blob URI of the .bacpac file.
        :param str storage_account_id: The resource id for the storage account used to store BACPAC file. If set, private endpoint connection will be created for the storage account. Must match storage account used for storage_uri parameter.
        """
        pulumi.set(__self__, "administrator_login", administrator_login)
        pulumi.set(__self__, "administrator_login_password", administrator_login_password)
        pulumi.set(__self__, "authentication_type", authentication_type)
        pulumi.set(__self__, "storage_key", storage_key)
        pulumi.set(__self__, "storage_key_type", storage_key_type)
        pulumi.set(__self__, "storage_uri", storage_uri)
        if storage_account_id is not None:
            pulumi.set(__self__, "storage_account_id", storage_account_id)

    @property
    @pulumi.getter(name="administratorLogin")
    def administrator_login(self) -> str:
        """
        Specifies the name of the SQL administrator.
        """
        return pulumi.get(self, "administrator_login")

    @property
    @pulumi.getter(name="administratorLoginPassword")
    def administrator_login_password(self) -> str:
        """
        Specifies the password of the SQL administrator.
        """
        return pulumi.get(self, "administrator_login_password")

    @property
    @pulumi.getter(name="authenticationType")
    def authentication_type(self) -> str:
        """
        Specifies the type of authentication used to access the server. Valid values are `SQL` or `ADPassword`.
        """
        return pulumi.get(self, "authentication_type")

    @property
    @pulumi.getter(name="storageKey")
    def storage_key(self) -> str:
        """
        Specifies the access key for the storage account.
        """
        return pulumi.get(self, "storage_key")

    @property
    @pulumi.getter(name="storageKeyType")
    def storage_key_type(self) -> str:
        """
        Specifies the type of access key for the storage account. Valid values are `StorageAccessKey` or `SharedAccessKey`.
        """
        return pulumi.get(self, "storage_key_type")

    @property
    @pulumi.getter(name="storageUri")
    def storage_uri(self) -> str:
        """
        Specifies the blob URI of the .bacpac file.
        """
        return pulumi.get(self, "storage_uri")

    @property
    @pulumi.getter(name="storageAccountId")
    def storage_account_id(self) -> Optional[str]:
        """
        The resource id for the storage account used to store BACPAC file. If set, private endpoint connection will be created for the storage account. Must match storage account used for storage_uri parameter.
        """
        return pulumi.get(self, "storage_account_id")


@pulumi.output_type
class DatabaseLongTermRetentionPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "monthlyRetention":
            suggest = "monthly_retention"
        elif key == "weekOfYear":
            suggest = "week_of_year"
        elif key == "weeklyRetention":
            suggest = "weekly_retention"
        elif key == "yearlyRetention":
            suggest = "yearly_retention"

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

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

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

    def __init__(__self__, *,
                 monthly_retention: Optional[str] = None,
                 week_of_year: Optional[int] = None,
                 weekly_retention: Optional[str] = None,
                 yearly_retention: Optional[str] = None):
        """
        :param 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 int week_of_year: The week of year to take the yearly backup. Value has to be between `1` and `52`.
        :param 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 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[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")

    @property
    @pulumi.getter(name="weekOfYear")
    def week_of_year(self) -> Optional[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")

    @property
    @pulumi.getter(name="weeklyRetention")
    def weekly_retention(self) -> Optional[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")

    @property
    @pulumi.getter(name="yearlyRetention")
    def yearly_retention(self) -> Optional[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")


@pulumi.output_type
class DatabaseShortTermRetentionPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "retentionDays":
            suggest = "retention_days"
        elif key == "backupIntervalInHours":
            suggest = "backup_interval_in_hours"

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

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

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

    def __init__(__self__, *,
                 retention_days: int,
                 backup_interval_in_hours: Optional[int] = None):
        """
        :param int retention_days: Point In Time Restore configuration. Value has to be between `7` and `35`.
        :param 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) -> int:
        """
        Point In Time Restore configuration. Value has to be between `7` and `35`.
        """
        return pulumi.get(self, "retention_days")

    @property
    @pulumi.getter(name="backupIntervalInHours")
    def backup_interval_in_hours(self) -> Optional[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")


@pulumi.output_type
class DatabaseThreatDetectionPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "disabledAlerts":
            suggest = "disabled_alerts"
        elif key == "emailAccountAdmins":
            suggest = "email_account_admins"
        elif key == "emailAddresses":
            suggest = "email_addresses"
        elif key == "retentionDays":
            suggest = "retention_days"
        elif key == "storageAccountAccessKey":
            suggest = "storage_account_access_key"
        elif key == "storageEndpoint":
            suggest = "storage_endpoint"

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

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

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

    def __init__(__self__, *,
                 disabled_alerts: Optional[Sequence[str]] = None,
                 email_account_admins: Optional[str] = None,
                 email_addresses: Optional[Sequence[str]] = None,
                 retention_days: Optional[int] = None,
                 state: Optional[str] = None,
                 storage_account_access_key: Optional[str] = None,
                 storage_endpoint: Optional[str] = None):
        """
        :param Sequence[str] disabled_alerts: Specifies a list of alerts which should be disabled. Possible values include `Access_Anomaly`, `Sql_Injection` and `Sql_Injection_Vulnerability`.
        :param str email_account_admins: Should the account administrators be emailed when this alert is triggered? Possible values are `Disabled` and `Enabled`.
        :param Sequence[str] email_addresses: A list of email addresses which alerts should be sent to.
        :param int retention_days: Specifies the number of days to keep in the Threat Detection audit logs.
        :param str state: The State of the Policy. Possible values are `Enabled`, `Disabled` or `New`.
        :param str storage_account_access_key: Specifies the identifier key of the Threat Detection audit storage account. Required if `state` is `Enabled`.
        :param 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[Sequence[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")

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

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

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

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

    @property
    @pulumi.getter(name="storageAccountAccessKey")
    def storage_account_access_key(self) -> Optional[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")

    @property
    @pulumi.getter(name="storageEndpoint")
    def storage_endpoint(self) -> Optional[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")


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

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


@pulumi.output_type
class ElasticPoolPerDatabaseSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxCapacity":
            suggest = "max_capacity"
        elif key == "minCapacity":
            suggest = "min_capacity"

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

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

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

    def __init__(__self__, *,
                 max_capacity: float,
                 min_capacity: float):
        """
        :param float max_capacity: The maximum capacity any one database can consume.
        :param 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) -> float:
        """
        The maximum capacity any one database can consume.
        """
        return pulumi.get(self, "max_capacity")

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


@pulumi.output_type
class ElasticPoolSku(dict):
    def __init__(__self__, *,
                 capacity: int,
                 name: str,
                 tier: str,
                 family: Optional[str] = None):
        """
        :param 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 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. Possible values are `BasicPool`, `StandardPool`, `PremiumPool`, `GP_Gen4`, `GP_Gen5`, `GP_Fsv2`, `GP_DC`, `BC_Gen4`, `BC_Gen5` and `BC_DC`. Changing this forces a new resource to be created.
        :param 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 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) -> 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")

    @property
    @pulumi.getter
    def name(self) -> 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. Possible values are `BasicPool`, `StandardPool`, `PremiumPool`, `GP_Gen4`, `GP_Gen5`, `GP_Fsv2`, `GP_DC`, `BC_Gen4`, `BC_Gen5` and `BC_DC`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def tier(self) -> 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")

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


@pulumi.output_type
class FailoverGroupPartnerServer(dict):
    def __init__(__self__, *,
                 id: str,
                 location: Optional[str] = None,
                 role: Optional[str] = None):
        """
        :param str id: The ID of a partner SQL server to include in the failover group.
        :param str location: The location of the partner server.
        :param 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) -> str:
        """
        The ID of a partner SQL server to include in the failover group.
        """
        return pulumi.get(self, "id")

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

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


@pulumi.output_type
class FailoverGroupReadWriteEndpointFailoverPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "graceMinutes":
            suggest = "grace_minutes"

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

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

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

    def __init__(__self__, *,
                 mode: str,
                 grace_minutes: Optional[int] = None):
        """
        :param str mode: The failover policy of the read-write endpoint for the failover group. Possible values are `Automatic` or `Manual`.
        :param 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) -> str:
        """
        The failover policy of the read-write endpoint for the failover group. Possible values are `Automatic` or `Manual`.
        """
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter(name="graceMinutes")
    def grace_minutes(self) -> Optional[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")


@pulumi.output_type
class ManagedInstanceFailoverGroupPartnerRegion(dict):
    def __init__(__self__, *,
                 location: Optional[str] = None,
                 role: Optional[str] = None):
        """
        :param str location: The Azure Region where the Managed Instance Failover Group should exist. Changing this forces a new resource to be created.
        :param 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[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")

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


@pulumi.output_type
class ManagedInstanceFailoverGroupReadWriteEndpointFailoverPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "graceMinutes":
            suggest = "grace_minutes"

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

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

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

    def __init__(__self__, *,
                 mode: str,
                 grace_minutes: Optional[int] = None):
        """
        :param str mode: The failover mode. Possible values are `Automatic` or `Manual`.
        :param 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) -> str:
        """
        The failover mode. Possible values are `Automatic` or `Manual`.
        """
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter(name="graceMinutes")
    def grace_minutes(self) -> Optional[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")


@pulumi.output_type
class ManagedInstanceIdentity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "identityIds":
            suggest = "identity_ids"
        elif key == "principalId":
            suggest = "principal_id"
        elif key == "tenantId":
            suggest = "tenant_id"

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

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

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

    def __init__(__self__, *,
                 type: str,
                 identity_ids: Optional[Sequence[str]] = None,
                 principal_id: Optional[str] = None,
                 tenant_id: Optional[str] = None):
        """
        :param str type: Specifies the type of Managed Service Identity that should be configured on this SQL Managed Instance. Possible values are `SystemAssigned`, `UserAssigned`.
        :param Sequence[str] identity_ids: Specifies a list of User Assigned Managed Identity IDs to be assigned to this SQL Managed Instance. Required when `type` is set to `UserAssigned`.
        :param str principal_id: The Principal ID for the Service Principal associated with the Identity of this SQL Managed Instance.
        :param 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 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) -> str:
        """
        Specifies the type of Managed Service Identity that should be configured on this SQL Managed Instance. Possible values are `SystemAssigned`, `UserAssigned`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="identityIds")
    def identity_ids(self) -> Optional[Sequence[str]]:
        """
        Specifies a list of User Assigned Managed Identity IDs to be assigned to this SQL Managed Instance. Required when `type` is set to `UserAssigned`.
        """
        return pulumi.get(self, "identity_ids")

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

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


@pulumi.output_type
class ManagedInstanceVulnerabilityAssessmentRecurringScans(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "emailSubscriptionAdmins":
            suggest = "email_subscription_admins"

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

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

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

    def __init__(__self__, *,
                 email_subscription_admins: Optional[bool] = None,
                 emails: Optional[Sequence[str]] = None,
                 enabled: Optional[bool] = None):
        """
        :param bool email_subscription_admins: Boolean flag which specifies if the schedule scan notification will be sent to the subscription administrators. Defaults to `true`.
        :param Sequence[str] emails: Specifies an array of e-mail addresses to which the scan notification is sent.
        :param 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[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")

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

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


@pulumi.output_type
class ServerAzureadAdministrator(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "loginUsername":
            suggest = "login_username"
        elif key == "objectId":
            suggest = "object_id"
        elif key == "azureadAuthenticationOnly":
            suggest = "azuread_authentication_only"
        elif key == "tenantId":
            suggest = "tenant_id"

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

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

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

    def __init__(__self__, *,
                 login_username: str,
                 object_id: str,
                 azuread_authentication_only: Optional[bool] = None,
                 tenant_id: Optional[str] = None):
        """
        :param str login_username: The login username of the Azure AD Administrator of this SQL Server.
        :param str object_id: The object id of the Azure AD Administrator of this SQL Server.
        :param 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 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) -> str:
        """
        The login username of the Azure AD Administrator of this SQL Server.
        """
        return pulumi.get(self, "login_username")

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

    @property
    @pulumi.getter(name="azureadAuthenticationOnly")
    def azuread_authentication_only(self) -> Optional[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")

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


@pulumi.output_type
class ServerIdentity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "identityIds":
            suggest = "identity_ids"
        elif key == "principalId":
            suggest = "principal_id"
        elif key == "tenantId":
            suggest = "tenant_id"

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

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

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

    def __init__(__self__, *,
                 type: str,
                 identity_ids: Optional[Sequence[str]] = None,
                 principal_id: Optional[str] = None,
                 tenant_id: Optional[str] = None):
        """
        :param str type: Specifies the type of Managed Service Identity that should be configured on this SQL Server. Possible values are `SystemAssigned`, `UserAssigned`.
        :param Sequence[str] identity_ids: Specifies a list of User Assigned Managed Identity IDs to be assigned to this SQL Server.
        :param str principal_id: The Principal ID for the Service Principal associated with the Identity of this SQL Server.
        :param 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) -> str:
        """
        Specifies the type of Managed Service Identity that should be configured on this SQL Server. Possible values are `SystemAssigned`, `UserAssigned`.
        """
        return pulumi.get(self, "type")

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

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

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


@pulumi.output_type
class ServerVulnerabilityAssessmentRecurringScans(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "emailSubscriptionAdmins":
            suggest = "email_subscription_admins"

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

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

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

    def __init__(__self__, *,
                 email_subscription_admins: Optional[bool] = None,
                 emails: Optional[Sequence[str]] = None,
                 enabled: Optional[bool] = None):
        """
        :param bool email_subscription_admins: Boolean flag which specifies if the schedule scan notification will be sent to the subscription administrators. Defaults to `false`.
        :param Sequence[str] emails: Specifies an array of email addresses to which the scan notification is sent.
        :param 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[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")

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

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


@pulumi.output_type
class VirtualMachineAssessment(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "runImmediately":
            suggest = "run_immediately"

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

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

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

    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 run_immediately: Optional[bool] = None,
                 schedule: Optional['outputs.VirtualMachineAssessmentSchedule'] = None):
        """
        :param bool enabled: Should Assessment be enabled? Defaults to `true`.
        :param bool run_immediately: Should Assessment be run immediately? Defaults to `false`.
        :param 'VirtualMachineAssessmentScheduleArgs' schedule: An `schedule` block as defined below.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if run_immediately is not None:
            pulumi.set(__self__, "run_immediately", run_immediately)
        if schedule is not None:
            pulumi.set(__self__, "schedule", schedule)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Should Assessment be enabled? Defaults to `true`.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="runImmediately")
    def run_immediately(self) -> Optional[bool]:
        """
        Should Assessment be run immediately? Defaults to `false`.
        """
        return pulumi.get(self, "run_immediately")

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


@pulumi.output_type
class VirtualMachineAssessmentSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dayOfWeek":
            suggest = "day_of_week"
        elif key == "startTime":
            suggest = "start_time"
        elif key == "monthlyOccurrence":
            suggest = "monthly_occurrence"
        elif key == "weeklyInterval":
            suggest = "weekly_interval"

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

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

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

    def __init__(__self__, *,
                 day_of_week: str,
                 start_time: str,
                 monthly_occurrence: Optional[int] = None,
                 weekly_interval: Optional[int] = None):
        """
        :param str day_of_week: What day of the week the assessment will be run. Default value is `Monday`. Possible values are `Friday`, `Monday`, `Saturday`, `Sunday`, `Thursday`, `Tuesday` and `Wednesday`.
        :param str start_time: What time the assessment will be run. Must be in the format `HH:mm`.
        :param int monthly_occurrence: How many months between assessment runs. Valid values are between `1` and `5`.
        :param int weekly_interval: How many weeks between assessment runs. Valid values are between `1` and `6`.
        """
        pulumi.set(__self__, "day_of_week", day_of_week)
        pulumi.set(__self__, "start_time", start_time)
        if monthly_occurrence is not None:
            pulumi.set(__self__, "monthly_occurrence", monthly_occurrence)
        if weekly_interval is not None:
            pulumi.set(__self__, "weekly_interval", weekly_interval)

    @property
    @pulumi.getter(name="dayOfWeek")
    def day_of_week(self) -> str:
        """
        What day of the week the assessment will be run. Default value is `Monday`. Possible values are `Friday`, `Monday`, `Saturday`, `Sunday`, `Thursday`, `Tuesday` and `Wednesday`.
        """
        return pulumi.get(self, "day_of_week")

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> str:
        """
        What time the assessment will be run. Must be in the format `HH:mm`.
        """
        return pulumi.get(self, "start_time")

    @property
    @pulumi.getter(name="monthlyOccurrence")
    def monthly_occurrence(self) -> Optional[int]:
        """
        How many months between assessment runs. Valid values are between `1` and `5`.
        """
        return pulumi.get(self, "monthly_occurrence")

    @property
    @pulumi.getter(name="weeklyInterval")
    def weekly_interval(self) -> Optional[int]:
        """
        How many weeks between assessment runs. Valid values are between `1` and `6`.
        """
        return pulumi.get(self, "weekly_interval")


@pulumi.output_type
class VirtualMachineAutoBackup(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "retentionPeriodInDays":
            suggest = "retention_period_in_days"
        elif key == "storageAccountAccessKey":
            suggest = "storage_account_access_key"
        elif key == "storageBlobEndpoint":
            suggest = "storage_blob_endpoint"
        elif key == "encryptionEnabled":
            suggest = "encryption_enabled"
        elif key == "encryptionPassword":
            suggest = "encryption_password"
        elif key == "manualSchedule":
            suggest = "manual_schedule"
        elif key == "systemDatabasesBackupEnabled":
            suggest = "system_databases_backup_enabled"

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

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

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

    def __init__(__self__, *,
                 retention_period_in_days: int,
                 storage_account_access_key: str,
                 storage_blob_endpoint: str,
                 encryption_enabled: Optional[bool] = None,
                 encryption_password: Optional[str] = None,
                 manual_schedule: Optional['outputs.VirtualMachineAutoBackupManualSchedule'] = None,
                 system_databases_backup_enabled: Optional[bool] = None):
        """
        :param int retention_period_in_days: Retention period of backups, in days. Valid values are from `1` to `30`.
        :param str storage_account_access_key: Access key for the storage account where backups will be kept.
        :param str storage_blob_endpoint: Blob endpoint for the storage account where backups will be kept.
        :param bool encryption_enabled: Enable or disable encryption for backups. Defaults to `false`.
        :param str encryption_password: Encryption password to use. Must be specified when encryption is enabled.
        :param '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 bool system_databases_backup_enabled: Include or exclude system databases from auto backup.
        """
        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) -> int:
        """
        Retention period of backups, in days. Valid values are from `1` to `30`.
        """
        return pulumi.get(self, "retention_period_in_days")

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

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

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

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

    @property
    @pulumi.getter(name="manualSchedule")
    def manual_schedule(self) -> Optional['outputs.VirtualMachineAutoBackupManualSchedule']:
        """
        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")

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


@pulumi.output_type
class VirtualMachineAutoBackupManualSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fullBackupFrequency":
            suggest = "full_backup_frequency"
        elif key == "fullBackupStartHour":
            suggest = "full_backup_start_hour"
        elif key == "fullBackupWindowInHours":
            suggest = "full_backup_window_in_hours"
        elif key == "logBackupFrequencyInMinutes":
            suggest = "log_backup_frequency_in_minutes"
        elif key == "daysOfWeeks":
            suggest = "days_of_weeks"

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

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

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

    def __init__(__self__, *,
                 full_backup_frequency: str,
                 full_backup_start_hour: int,
                 full_backup_window_in_hours: int,
                 log_backup_frequency_in_minutes: int,
                 days_of_weeks: Optional[Sequence[str]] = None):
        """
        :param str full_backup_frequency: Frequency of full backups. Valid values include `Daily` or `Weekly`.
        :param 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`.
        :param 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`.
        :param int log_backup_frequency_in_minutes: Frequency of log backups, in minutes. Valid values are from `5` to `60`.
        :param Sequence[str] days_of_weeks: A list of days on which backup can take place. Possible values are `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday`, `Saturday` and `Sunday`
        """
        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)
        if days_of_weeks is not None:
            pulumi.set(__self__, "days_of_weeks", days_of_weeks)

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

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

    @property
    @pulumi.getter(name="fullBackupWindowInHours")
    def full_backup_window_in_hours(self) -> 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`.
        """
        return pulumi.get(self, "full_backup_window_in_hours")

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

    @property
    @pulumi.getter(name="daysOfWeeks")
    def days_of_weeks(self) -> Optional[Sequence[str]]:
        """
        A list of days on which backup can take place. Possible values are `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday`, `Saturday` and `Sunday`
        """
        return pulumi.get(self, "days_of_weeks")


@pulumi.output_type
class VirtualMachineAutoPatching(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dayOfWeek":
            suggest = "day_of_week"
        elif key == "maintenanceWindowDurationInMinutes":
            suggest = "maintenance_window_duration_in_minutes"
        elif key == "maintenanceWindowStartingHour":
            suggest = "maintenance_window_starting_hour"

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

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

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

    def __init__(__self__, *,
                 day_of_week: str,
                 maintenance_window_duration_in_minutes: int,
                 maintenance_window_starting_hour: int):
        """
        :param str day_of_week: The day of week to apply the patch on. Possible values are `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday`, `Saturday` and `Sunday`.
        :param int maintenance_window_duration_in_minutes: The size of the Maintenance Window in minutes.
        :param 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) -> str:
        """
        The day of week to apply the patch on. Possible values are `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday`, `Saturday` and `Sunday`.
        """
        return pulumi.get(self, "day_of_week")

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

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


@pulumi.output_type
class VirtualMachineKeyVaultCredential(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keyVaultUrl":
            suggest = "key_vault_url"
        elif key == "servicePrincipalName":
            suggest = "service_principal_name"
        elif key == "servicePrincipalSecret":
            suggest = "service_principal_secret"

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

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

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

    def __init__(__self__, *,
                 key_vault_url: str,
                 name: str,
                 service_principal_name: str,
                 service_principal_secret: str):
        """
        :param str key_vault_url: The Azure Key Vault url. Changing this forces a new resource to be created.
        :param str name: The credential name.
        :param str service_principal_name: The service principal name to access key vault. Changing this forces a new resource to be created.
        :param 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) -> str:
        """
        The Azure Key Vault url. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "key_vault_url")

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

    @property
    @pulumi.getter(name="servicePrincipalName")
    def service_principal_name(self) -> 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")

    @property
    @pulumi.getter(name="servicePrincipalSecret")
    def service_principal_secret(self) -> 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")


@pulumi.output_type
class VirtualMachineSqlInstance(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "adhocWorkloadsOptimizationEnabled":
            suggest = "adhoc_workloads_optimization_enabled"
        elif key == "instantFileInitializationEnabled":
            suggest = "instant_file_initialization_enabled"
        elif key == "lockPagesInMemoryEnabled":
            suggest = "lock_pages_in_memory_enabled"
        elif key == "maxDop":
            suggest = "max_dop"
        elif key == "maxServerMemoryMb":
            suggest = "max_server_memory_mb"
        elif key == "minServerMemoryMb":
            suggest = "min_server_memory_mb"

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

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

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

    def __init__(__self__, *,
                 adhoc_workloads_optimization_enabled: Optional[bool] = None,
                 collation: Optional[str] = None,
                 instant_file_initialization_enabled: Optional[bool] = None,
                 lock_pages_in_memory_enabled: Optional[bool] = None,
                 max_dop: Optional[int] = None,
                 max_server_memory_mb: Optional[int] = None,
                 min_server_memory_mb: Optional[int] = None):
        """
        :param bool adhoc_workloads_optimization_enabled: Specifies if the SQL Server is optimized for adhoc workloads. Possible values are `true` and `false`. Defaults to `false`.
        :param str collation: Collation of the SQL Server. Defaults to `SQL_Latin1_General_CP1_CI_AS`. Changing this forces a new resource to be created.
        :param bool instant_file_initialization_enabled: Specifies if Instant File Initialization is enabled for the SQL Server. Possible values are `true` and `false`. Defaults to `false`. Changing this forces a new resource to be created.
        :param bool lock_pages_in_memory_enabled: Specifies if Lock Pages in Memory is enabled for the SQL Server. Possible values are `true` and `false`. Defaults to `false`. Changing this forces a new resource to be created.
        :param int max_dop: Maximum Degree of Parallelism of the SQL Server. Possible values are between `0` and `32767`. Defaults to `0`.
        :param int max_server_memory_mb: Maximum amount memory that SQL Server Memory Manager can allocate to the SQL Server process. Possible values are between `128` and `2147483647` Defaults to `2147483647`.
        :param int min_server_memory_mb: Minimum amount memory that SQL Server Memory Manager can allocate to the SQL Server process. Possible values are between `0` and `2147483647` Defaults to `0`.
        """
        if adhoc_workloads_optimization_enabled is not None:
            pulumi.set(__self__, "adhoc_workloads_optimization_enabled", adhoc_workloads_optimization_enabled)
        if collation is not None:
            pulumi.set(__self__, "collation", collation)
        if instant_file_initialization_enabled is not None:
            pulumi.set(__self__, "instant_file_initialization_enabled", instant_file_initialization_enabled)
        if lock_pages_in_memory_enabled is not None:
            pulumi.set(__self__, "lock_pages_in_memory_enabled", lock_pages_in_memory_enabled)
        if max_dop is not None:
            pulumi.set(__self__, "max_dop", max_dop)
        if max_server_memory_mb is not None:
            pulumi.set(__self__, "max_server_memory_mb", max_server_memory_mb)
        if min_server_memory_mb is not None:
            pulumi.set(__self__, "min_server_memory_mb", min_server_memory_mb)

    @property
    @pulumi.getter(name="adhocWorkloadsOptimizationEnabled")
    def adhoc_workloads_optimization_enabled(self) -> Optional[bool]:
        """
        Specifies if the SQL Server is optimized for adhoc workloads. Possible values are `true` and `false`. Defaults to `false`.
        """
        return pulumi.get(self, "adhoc_workloads_optimization_enabled")

    @property
    @pulumi.getter
    def collation(self) -> Optional[str]:
        """
        Collation of the SQL Server. Defaults to `SQL_Latin1_General_CP1_CI_AS`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "collation")

    @property
    @pulumi.getter(name="instantFileInitializationEnabled")
    def instant_file_initialization_enabled(self) -> Optional[bool]:
        """
        Specifies if Instant File Initialization is enabled for the SQL Server. Possible values are `true` and `false`. Defaults to `false`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "instant_file_initialization_enabled")

    @property
    @pulumi.getter(name="lockPagesInMemoryEnabled")
    def lock_pages_in_memory_enabled(self) -> Optional[bool]:
        """
        Specifies if Lock Pages in Memory is enabled for the SQL Server. Possible values are `true` and `false`. Defaults to `false`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "lock_pages_in_memory_enabled")

    @property
    @pulumi.getter(name="maxDop")
    def max_dop(self) -> Optional[int]:
        """
        Maximum Degree of Parallelism of the SQL Server. Possible values are between `0` and `32767`. Defaults to `0`.
        """
        return pulumi.get(self, "max_dop")

    @property
    @pulumi.getter(name="maxServerMemoryMb")
    def max_server_memory_mb(self) -> Optional[int]:
        """
        Maximum amount memory that SQL Server Memory Manager can allocate to the SQL Server process. Possible values are between `128` and `2147483647` Defaults to `2147483647`.
        """
        return pulumi.get(self, "max_server_memory_mb")

    @property
    @pulumi.getter(name="minServerMemoryMb")
    def min_server_memory_mb(self) -> Optional[int]:
        """
        Minimum amount memory that SQL Server Memory Manager can allocate to the SQL Server process. Possible values are between `0` and `2147483647` Defaults to `0`.
        """
        return pulumi.get(self, "min_server_memory_mb")


@pulumi.output_type
class VirtualMachineStorageConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "diskType":
            suggest = "disk_type"
        elif key == "storageWorkloadType":
            suggest = "storage_workload_type"
        elif key == "dataSettings":
            suggest = "data_settings"
        elif key == "logSettings":
            suggest = "log_settings"
        elif key == "systemDbOnDataDiskEnabled":
            suggest = "system_db_on_data_disk_enabled"
        elif key == "tempDbSettings":
            suggest = "temp_db_settings"

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

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

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

    def __init__(__self__, *,
                 disk_type: str,
                 storage_workload_type: str,
                 data_settings: Optional['outputs.VirtualMachineStorageConfigurationDataSettings'] = None,
                 log_settings: Optional['outputs.VirtualMachineStorageConfigurationLogSettings'] = None,
                 system_db_on_data_disk_enabled: Optional[bool] = None,
                 temp_db_settings: Optional['outputs.VirtualMachineStorageConfigurationTempDbSettings'] = None):
        """
        :param str disk_type: The type of disk configuration to apply to the SQL Server. Valid values include `NEW`, `EXTEND`, or `ADD`.
        :param str storage_workload_type: The type of storage workload. Valid values include `GENERAL`, `OLTP`, or `DW`.
        :param 'VirtualMachineStorageConfigurationDataSettingsArgs' data_settings: An `storage_settings` as defined below.
        :param 'VirtualMachineStorageConfigurationLogSettingsArgs' log_settings: An `storage_settings` as defined below.
        :param bool system_db_on_data_disk_enabled: Specifies whether to set system databases (except tempDb) location to newly created data storage. Possible values are `true` and `false`. Defaults to `false`.
        :param 'VirtualMachineStorageConfigurationTempDbSettingsArgs' temp_db_settings: An `temp_db_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 system_db_on_data_disk_enabled is not None:
            pulumi.set(__self__, "system_db_on_data_disk_enabled", system_db_on_data_disk_enabled)
        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) -> 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")

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

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

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

    @property
    @pulumi.getter(name="systemDbOnDataDiskEnabled")
    def system_db_on_data_disk_enabled(self) -> Optional[bool]:
        """
        Specifies whether to set system databases (except tempDb) location to newly created data storage. Possible values are `true` and `false`. Defaults to `false`.
        """
        return pulumi.get(self, "system_db_on_data_disk_enabled")

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


@pulumi.output_type
class VirtualMachineStorageConfigurationDataSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultFilePath":
            suggest = "default_file_path"

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

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

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

    def __init__(__self__, *,
                 default_file_path: str,
                 luns: Sequence[int]):
        """
        :param str default_file_path: The SQL Server default path
        :param Sequence[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) -> str:
        """
        The SQL Server default path
        """
        return pulumi.get(self, "default_file_path")

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


@pulumi.output_type
class VirtualMachineStorageConfigurationLogSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultFilePath":
            suggest = "default_file_path"

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

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

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

    def __init__(__self__, *,
                 default_file_path: str,
                 luns: Sequence[int]):
        """
        :param str default_file_path: The SQL Server default path
        :param Sequence[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) -> str:
        """
        The SQL Server default path
        """
        return pulumi.get(self, "default_file_path")

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


@pulumi.output_type
class VirtualMachineStorageConfigurationTempDbSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultFilePath":
            suggest = "default_file_path"
        elif key == "dataFileCount":
            suggest = "data_file_count"
        elif key == "dataFileGrowthInMb":
            suggest = "data_file_growth_in_mb"
        elif key == "dataFileSizeMb":
            suggest = "data_file_size_mb"
        elif key == "logFileGrowthMb":
            suggest = "log_file_growth_mb"
        elif key == "logFileSizeMb":
            suggest = "log_file_size_mb"

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

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

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

    def __init__(__self__, *,
                 default_file_path: str,
                 luns: Sequence[int],
                 data_file_count: Optional[int] = None,
                 data_file_growth_in_mb: Optional[int] = None,
                 data_file_size_mb: Optional[int] = None,
                 log_file_growth_mb: Optional[int] = None,
                 log_file_size_mb: Optional[int] = None):
        """
        :param str default_file_path: The SQL Server default path
        :param Sequence[int] luns: A list of Logical Unit Numbers for the disks.
        :param int data_file_count: The SQL Server default file count. This value defaults to `8`
        :param int data_file_growth_in_mb: The SQL Server default file size - This value defaults to `512`
        :param int data_file_size_mb: The SQL Server default file size - This value defaults to `256`
        :param int log_file_growth_mb: The SQL Server default file size - This value defaults to `512`
        :param int log_file_size_mb: The SQL Server default file size - This value defaults to `256`
        """
        pulumi.set(__self__, "default_file_path", default_file_path)
        pulumi.set(__self__, "luns", luns)
        if data_file_count is not None:
            pulumi.set(__self__, "data_file_count", data_file_count)
        if data_file_growth_in_mb is not None:
            pulumi.set(__self__, "data_file_growth_in_mb", data_file_growth_in_mb)
        if data_file_size_mb is not None:
            pulumi.set(__self__, "data_file_size_mb", data_file_size_mb)
        if log_file_growth_mb is not None:
            pulumi.set(__self__, "log_file_growth_mb", log_file_growth_mb)
        if log_file_size_mb is not None:
            pulumi.set(__self__, "log_file_size_mb", log_file_size_mb)

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

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

    @property
    @pulumi.getter(name="dataFileCount")
    def data_file_count(self) -> Optional[int]:
        """
        The SQL Server default file count. This value defaults to `8`
        """
        return pulumi.get(self, "data_file_count")

    @property
    @pulumi.getter(name="dataFileGrowthInMb")
    def data_file_growth_in_mb(self) -> Optional[int]:
        """
        The SQL Server default file size - This value defaults to `512`
        """
        return pulumi.get(self, "data_file_growth_in_mb")

    @property
    @pulumi.getter(name="dataFileSizeMb")
    def data_file_size_mb(self) -> Optional[int]:
        """
        The SQL Server default file size - This value defaults to `256`
        """
        return pulumi.get(self, "data_file_size_mb")

    @property
    @pulumi.getter(name="logFileGrowthMb")
    def log_file_growth_mb(self) -> Optional[int]:
        """
        The SQL Server default file size - This value defaults to `512`
        """
        return pulumi.get(self, "log_file_growth_mb")

    @property
    @pulumi.getter(name="logFileSizeMb")
    def log_file_size_mb(self) -> Optional[int]:
        """
        The SQL Server default file size - This value defaults to `256`
        """
        return pulumi.get(self, "log_file_size_mb")


@pulumi.output_type
class GetElasticPoolSkusResult(dict):
    def __init__(__self__, *,
                 capacity: int,
                 family: str,
                 name: str,
                 tier: str):
        """
        :param int capacity: The scale up/out capacity, representing server's compute units.
        :param str family: The `family` of hardware.
        :param str name: The name of the elastic pool.
        :param str tier: The tier of the particular SKU.
        """
        pulumi.set(__self__, "capacity", capacity)
        pulumi.set(__self__, "family", family)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "tier", tier)

    @property
    @pulumi.getter
    def capacity(self) -> int:
        """
        The scale up/out capacity, representing server's compute units.
        """
        return pulumi.get(self, "capacity")

    @property
    @pulumi.getter
    def family(self) -> str:
        """
        The `family` of hardware.
        """
        return pulumi.get(self, "family")

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

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


@pulumi.output_type
class GetManagedInstanceIdentityResult(dict):
    def __init__(__self__, *,
                 identity_ids: Sequence[str],
                 principal_id: str,
                 tenant_id: str,
                 type: str):
        """
        :param Sequence[str] identity_ids: A list of User Assigned Managed Identity IDs assigned with the Identity of this SQL Managed Instance.
        :param str principal_id: The Principal ID for the Service Principal associated with the Identity of this SQL Managed Instance.
        :param str tenant_id: The Tenant ID for the Service Principal associated with the Identity of this SQL Managed Instance.
        :param str type: The identity type of the SQL Managed Instance.
        """
        pulumi.set(__self__, "identity_ids", identity_ids)
        pulumi.set(__self__, "principal_id", principal_id)
        pulumi.set(__self__, "tenant_id", tenant_id)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="identityIds")
    def identity_ids(self) -> Sequence[str]:
        """
        A list of User Assigned Managed Identity IDs assigned with the Identity of this SQL Managed Instance.
        """
        return pulumi.get(self, "identity_ids")

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

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

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The identity type of the SQL Managed Instance.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetServerIdentityResult(dict):
    def __init__(__self__, *,
                 identity_ids: Sequence[str],
                 principal_id: str,
                 tenant_id: str,
                 type: str):
        """
        :param Sequence[str] identity_ids: The list of User Assigned Managed Identity IDs assigned to this Microsoft SQL Server.
        :param str principal_id: The Principal ID of the System Assigned Managed Service Identity that is configured on this Microsoft SQL Server.
        :param str tenant_id: The Tenant ID of the System Assigned Managed Service Identity that is configured on this Microsoft SQL Server.
        :param str type: The type of Managed Service Identity that is configured on this Microsoft SQL Server.
        """
        pulumi.set(__self__, "identity_ids", identity_ids)
        pulumi.set(__self__, "principal_id", principal_id)
        pulumi.set(__self__, "tenant_id", tenant_id)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="identityIds")
    def identity_ids(self) -> Sequence[str]:
        """
        The list of User Assigned Managed Identity IDs assigned to this Microsoft SQL Server.
        """
        return pulumi.get(self, "identity_ids")

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> str:
        """
        The Principal ID of the System Assigned Managed Service Identity that is configured on this Microsoft SQL Server.
        """
        return pulumi.get(self, "principal_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        """
        The Tenant ID of the System Assigned Managed Service Identity that is configured on this Microsoft SQL Server.
        """
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of Managed Service Identity that is configured on this Microsoft SQL Server.
        """
        return pulumi.get(self, "type")


