<reponame>pulumi-bot/pulumi-azure-native
# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** 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
from ... import _utilities, _tables
from . import outputs
from ._enums import *

__all__ = [
    'DatabaseVulnerabilityAssessmentRuleBaselineItemResponse',
    'ElasticPoolPerDatabaseSettingsResponse',
    'FailoverGroupReadOnlyEndpointResponse',
    'FailoverGroupReadWriteEndpointResponse',
    'InstanceFailoverGroupReadOnlyEndpointResponse',
    'InstanceFailoverGroupReadWriteEndpointResponse',
    'JobScheduleResponse',
    'JobStepActionResponse',
    'JobStepExecutionOptionsResponse',
    'JobStepOutputResponse',
    'JobTargetResponse',
    'ManagedInstancePairInfoResponse',
    'ManagedInstancePecPropertyResponse',
    'ManagedInstancePrivateEndpointConnectionPropertiesResponse',
    'ManagedInstancePrivateEndpointPropertyResponse',
    'ManagedInstancePrivateLinkServiceConnectionStatePropertyResponse',
    'PartnerInfoResponse',
    'PartnerRegionInfoResponse',
    'PrivateEndpointConnectionPropertiesResponse',
    'PrivateEndpointPropertyResponse',
    'PrivateLinkServiceConnectionStatePropertyResponse',
    'ResourceIdentityResponse',
    'ServerInfoResponse',
    'ServerPrivateEndpointConnectionResponse',
    'SkuResponse',
    'SyncGroupSchemaResponse',
    'SyncGroupSchemaTableColumnResponse',
    'SyncGroupSchemaTableResponse',
    'VulnerabilityAssessmentRecurringScansPropertiesResponse',
]

@pulumi.output_type
class DatabaseVulnerabilityAssessmentRuleBaselineItemResponse(dict):
    """
    Properties for an Azure SQL Database Vulnerability Assessment rule baseline's result.
    """
    def __init__(__self__, *,
                 result: Sequence[str]):
        """
        Properties for an Azure SQL Database Vulnerability Assessment rule baseline's result.
        :param Sequence[str] result: The rule baseline result
        """
        pulumi.set(__self__, "result", result)

    @property
    @pulumi.getter
    def result(self) -> Sequence[str]:
        """
        The rule baseline result
        """
        return pulumi.get(self, "result")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ElasticPoolPerDatabaseSettingsResponse(dict):
    """
    Per database settings of an elastic pool.
    """
    def __init__(__self__, *,
                 max_capacity: Optional[float] = None,
                 min_capacity: Optional[float] = None):
        """
        Per database settings of an elastic pool.
        :param float max_capacity: The maximum capacity any one database can consume.
        :param float min_capacity: The minimum capacity all databases are guaranteed.
        """
        if max_capacity is not None:
            pulumi.set(__self__, "max_capacity", max_capacity)
        if min_capacity is not None:
            pulumi.set(__self__, "min_capacity", min_capacity)

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class FailoverGroupReadOnlyEndpointResponse(dict):
    """
    Read-only endpoint of the failover group instance.
    """
    def __init__(__self__, *,
                 failover_policy: Optional[str] = None):
        """
        Read-only endpoint of the failover group instance.
        :param str failover_policy: Failover policy of the read-only endpoint for the failover group.
        """
        if failover_policy is not None:
            pulumi.set(__self__, "failover_policy", failover_policy)

    @property
    @pulumi.getter(name="failoverPolicy")
    def failover_policy(self) -> Optional[str]:
        """
        Failover policy of the read-only endpoint for the failover group.
        """
        return pulumi.get(self, "failover_policy")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class FailoverGroupReadWriteEndpointResponse(dict):
    """
    Read-write endpoint of the failover group instance.
    """
    def __init__(__self__, *,
                 failover_policy: str,
                 failover_with_data_loss_grace_period_minutes: Optional[int] = None):
        """
        Read-write endpoint of the failover group instance.
        :param str failover_policy: Failover policy of the read-write endpoint for the failover group. If failoverPolicy is Automatic then failoverWithDataLossGracePeriodMinutes is required.
        :param int failover_with_data_loss_grace_period_minutes: Grace period before failover with data loss is attempted for the read-write endpoint. If failoverPolicy is Automatic then failoverWithDataLossGracePeriodMinutes is required.
        """
        pulumi.set(__self__, "failover_policy", failover_policy)
        if failover_with_data_loss_grace_period_minutes is not None:
            pulumi.set(__self__, "failover_with_data_loss_grace_period_minutes", failover_with_data_loss_grace_period_minutes)

    @property
    @pulumi.getter(name="failoverPolicy")
    def failover_policy(self) -> str:
        """
        Failover policy of the read-write endpoint for the failover group. If failoverPolicy is Automatic then failoverWithDataLossGracePeriodMinutes is required.
        """
        return pulumi.get(self, "failover_policy")

    @property
    @pulumi.getter(name="failoverWithDataLossGracePeriodMinutes")
    def failover_with_data_loss_grace_period_minutes(self) -> Optional[int]:
        """
        Grace period before failover with data loss is attempted for the read-write endpoint. If failoverPolicy is Automatic then failoverWithDataLossGracePeriodMinutes is required.
        """
        return pulumi.get(self, "failover_with_data_loss_grace_period_minutes")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class InstanceFailoverGroupReadOnlyEndpointResponse(dict):
    """
    Read-only endpoint of the failover group instance.
    """
    def __init__(__self__, *,
                 failover_policy: Optional[str] = None):
        """
        Read-only endpoint of the failover group instance.
        :param str failover_policy: Failover policy of the read-only endpoint for the failover group.
        """
        if failover_policy is not None:
            pulumi.set(__self__, "failover_policy", failover_policy)

    @property
    @pulumi.getter(name="failoverPolicy")
    def failover_policy(self) -> Optional[str]:
        """
        Failover policy of the read-only endpoint for the failover group.
        """
        return pulumi.get(self, "failover_policy")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class InstanceFailoverGroupReadWriteEndpointResponse(dict):
    """
    Read-write endpoint of the failover group instance.
    """
    def __init__(__self__, *,
                 failover_policy: str,
                 failover_with_data_loss_grace_period_minutes: Optional[int] = None):
        """
        Read-write endpoint of the failover group instance.
        :param str failover_policy: Failover policy of the read-write endpoint for the failover group. If failoverPolicy is Automatic then failoverWithDataLossGracePeriodMinutes is required.
        :param int failover_with_data_loss_grace_period_minutes: Grace period before failover with data loss is attempted for the read-write endpoint. If failoverPolicy is Automatic then failoverWithDataLossGracePeriodMinutes is required.
        """
        pulumi.set(__self__, "failover_policy", failover_policy)
        if failover_with_data_loss_grace_period_minutes is not None:
            pulumi.set(__self__, "failover_with_data_loss_grace_period_minutes", failover_with_data_loss_grace_period_minutes)

    @property
    @pulumi.getter(name="failoverPolicy")
    def failover_policy(self) -> str:
        """
        Failover policy of the read-write endpoint for the failover group. If failoverPolicy is Automatic then failoverWithDataLossGracePeriodMinutes is required.
        """
        return pulumi.get(self, "failover_policy")

    @property
    @pulumi.getter(name="failoverWithDataLossGracePeriodMinutes")
    def failover_with_data_loss_grace_period_minutes(self) -> Optional[int]:
        """
        Grace period before failover with data loss is attempted for the read-write endpoint. If failoverPolicy is Automatic then failoverWithDataLossGracePeriodMinutes is required.
        """
        return pulumi.get(self, "failover_with_data_loss_grace_period_minutes")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class JobScheduleResponse(dict):
    """
    Scheduling properties of a job.
    """
    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 end_time: Optional[str] = None,
                 interval: Optional[str] = None,
                 start_time: Optional[str] = None,
                 type: Optional[str] = None):
        """
        Scheduling properties of a job.
        :param bool enabled: Whether or not the schedule is enabled.
        :param str end_time: Schedule end time.
        :param str interval: Value of the schedule's recurring interval, if the ScheduleType is recurring. ISO8601 duration format.
        :param str start_time: Schedule start time.
        :param str type: Schedule interval type
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if end_time is None:
            end_time = '9999-12-31T11:59:59+00:00'
        if end_time is not None:
            pulumi.set(__self__, "end_time", end_time)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)
        if start_time is None:
            start_time = '0001-01-01T00:00:00+00:00'
        if start_time is not None:
            pulumi.set(__self__, "start_time", start_time)
        if type is None:
            type = 'Once'
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Whether or not the schedule is enabled.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="endTime")
    def end_time(self) -> Optional[str]:
        """
        Schedule end time.
        """
        return pulumi.get(self, "end_time")

    @property
    @pulumi.getter
    def interval(self) -> Optional[str]:
        """
        Value of the schedule's recurring interval, if the ScheduleType is recurring. ISO8601 duration format.
        """
        return pulumi.get(self, "interval")

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> Optional[str]:
        """
        Schedule start time.
        """
        return pulumi.get(self, "start_time")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        Schedule interval type
        """
        return pulumi.get(self, "type")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class JobStepActionResponse(dict):
    """
    The action to be executed by a job step.
    """
    def __init__(__self__, *,
                 value: str,
                 source: Optional[str] = None,
                 type: Optional[str] = None):
        """
        The action to be executed by a job step.
        :param str value: The action value, for example the text of the T-SQL script to execute.
        :param str source: The source of the action to execute.
        :param str type: Type of action being executed by the job step.
        """
        pulumi.set(__self__, "value", value)
        if source is None:
            source = 'Inline'
        if source is not None:
            pulumi.set(__self__, "source", source)
        if type is None:
            type = 'TSql'
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The action value, for example the text of the T-SQL script to execute.
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def source(self) -> Optional[str]:
        """
        The source of the action to execute.
        """
        return pulumi.get(self, "source")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        Type of action being executed by the job step.
        """
        return pulumi.get(self, "type")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class JobStepExecutionOptionsResponse(dict):
    """
    The execution options of a job step.
    """
    def __init__(__self__, *,
                 initial_retry_interval_seconds: Optional[int] = None,
                 maximum_retry_interval_seconds: Optional[int] = None,
                 retry_attempts: Optional[int] = None,
                 retry_interval_backoff_multiplier: Optional[float] = None,
                 timeout_seconds: Optional[int] = None):
        """
        The execution options of a job step.
        :param int initial_retry_interval_seconds: Initial delay between retries for job step execution.
        :param int maximum_retry_interval_seconds: The maximum amount of time to wait between retries for job step execution.
        :param int retry_attempts: Maximum number of times the job step will be reattempted if the first attempt fails.
        :param float retry_interval_backoff_multiplier: The backoff multiplier for the time between retries.
        :param int timeout_seconds: Execution timeout for the job step.
        """
        if initial_retry_interval_seconds is None:
            initial_retry_interval_seconds = 1
        if initial_retry_interval_seconds is not None:
            pulumi.set(__self__, "initial_retry_interval_seconds", initial_retry_interval_seconds)
        if maximum_retry_interval_seconds is None:
            maximum_retry_interval_seconds = 120
        if maximum_retry_interval_seconds is not None:
            pulumi.set(__self__, "maximum_retry_interval_seconds", maximum_retry_interval_seconds)
        if retry_attempts is None:
            retry_attempts = 10
        if retry_attempts is not None:
            pulumi.set(__self__, "retry_attempts", retry_attempts)
        if retry_interval_backoff_multiplier is None:
            retry_interval_backoff_multiplier = 2
        if retry_interval_backoff_multiplier is not None:
            pulumi.set(__self__, "retry_interval_backoff_multiplier", retry_interval_backoff_multiplier)
        if timeout_seconds is None:
            timeout_seconds = 43200
        if timeout_seconds is not None:
            pulumi.set(__self__, "timeout_seconds", timeout_seconds)

    @property
    @pulumi.getter(name="initialRetryIntervalSeconds")
    def initial_retry_interval_seconds(self) -> Optional[int]:
        """
        Initial delay between retries for job step execution.
        """
        return pulumi.get(self, "initial_retry_interval_seconds")

    @property
    @pulumi.getter(name="maximumRetryIntervalSeconds")
    def maximum_retry_interval_seconds(self) -> Optional[int]:
        """
        The maximum amount of time to wait between retries for job step execution.
        """
        return pulumi.get(self, "maximum_retry_interval_seconds")

    @property
    @pulumi.getter(name="retryAttempts")
    def retry_attempts(self) -> Optional[int]:
        """
        Maximum number of times the job step will be reattempted if the first attempt fails.
        """
        return pulumi.get(self, "retry_attempts")

    @property
    @pulumi.getter(name="retryIntervalBackoffMultiplier")
    def retry_interval_backoff_multiplier(self) -> Optional[float]:
        """
        The backoff multiplier for the time between retries.
        """
        return pulumi.get(self, "retry_interval_backoff_multiplier")

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> Optional[int]:
        """
        Execution timeout for the job step.
        """
        return pulumi.get(self, "timeout_seconds")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class JobStepOutputResponse(dict):
    """
    The output configuration of a job step.
    """
    def __init__(__self__, *,
                 credential: str,
                 database_name: str,
                 server_name: str,
                 table_name: str,
                 resource_group_name: Optional[str] = None,
                 schema_name: Optional[str] = None,
                 subscription_id: Optional[str] = None,
                 type: Optional[str] = None):
        """
        The output configuration of a job step.
        :param str credential: The resource ID of the credential to use to connect to the output destination.
        :param str database_name: The output destination database.
        :param str server_name: The output destination server name.
        :param str table_name: The output destination table.
        :param str resource_group_name: The output destination resource group.
        :param str schema_name: The output destination schema.
        :param str subscription_id: The output destination subscription id.
        :param str type: The output destination type.
        """
        pulumi.set(__self__, "credential", credential)
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "server_name", server_name)
        pulumi.set(__self__, "table_name", table_name)
        if resource_group_name is not None:
            pulumi.set(__self__, "resource_group_name", resource_group_name)
        if schema_name is None:
            schema_name = 'dbo'
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)
        if subscription_id is not None:
            pulumi.set(__self__, "subscription_id", subscription_id)
        if type is None:
            type = 'SqlDatabase'
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def credential(self) -> str:
        """
        The resource ID of the credential to use to connect to the output destination.
        """
        return pulumi.get(self, "credential")

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The output destination database.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="serverName")
    def server_name(self) -> str:
        """
        The output destination server name.
        """
        return pulumi.get(self, "server_name")

    @property
    @pulumi.getter(name="tableName")
    def table_name(self) -> str:
        """
        The output destination table.
        """
        return pulumi.get(self, "table_name")

    @property
    @pulumi.getter(name="resourceGroupName")
    def resource_group_name(self) -> Optional[str]:
        """
        The output destination resource group.
        """
        return pulumi.get(self, "resource_group_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The output destination schema.
        """
        return pulumi.get(self, "schema_name")

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> Optional[str]:
        """
        The output destination subscription id.
        """
        return pulumi.get(self, "subscription_id")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        The output destination type.
        """
        return pulumi.get(self, "type")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class JobTargetResponse(dict):
    """
    A job target, for example a specific database or a container of databases that is evaluated during job execution.
    """
    def __init__(__self__, *,
                 type: str,
                 database_name: Optional[str] = None,
                 elastic_pool_name: Optional[str] = None,
                 membership_type: Optional[str] = None,
                 refresh_credential: Optional[str] = None,
                 server_name: Optional[str] = None,
                 shard_map_name: Optional[str] = None):
        """
        A job target, for example a specific database or a container of databases that is evaluated during job execution.
        :param str type: The target type.
        :param str database_name: The target database name.
        :param str elastic_pool_name: The target elastic pool name.
        :param str membership_type: Whether the target is included or excluded from the group.
        :param str refresh_credential: The resource ID of the credential that is used during job execution to connect to the target and determine the list of databases inside the target.
        :param str server_name: The target server name.
        :param str shard_map_name: The target shard map.
        """
        pulumi.set(__self__, "type", type)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if elastic_pool_name is not None:
            pulumi.set(__self__, "elastic_pool_name", elastic_pool_name)
        if membership_type is None:
            membership_type = 'Include'
        if membership_type is not None:
            pulumi.set(__self__, "membership_type", membership_type)
        if refresh_credential is not None:
            pulumi.set(__self__, "refresh_credential", refresh_credential)
        if server_name is not None:
            pulumi.set(__self__, "server_name", server_name)
        if shard_map_name is not None:
            pulumi.set(__self__, "shard_map_name", shard_map_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The target database name.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="elasticPoolName")
    def elastic_pool_name(self) -> Optional[str]:
        """
        The target elastic pool name.
        """
        return pulumi.get(self, "elastic_pool_name")

    @property
    @pulumi.getter(name="membershipType")
    def membership_type(self) -> Optional[str]:
        """
        Whether the target is included or excluded from the group.
        """
        return pulumi.get(self, "membership_type")

    @property
    @pulumi.getter(name="refreshCredential")
    def refresh_credential(self) -> Optional[str]:
        """
        The resource ID of the credential that is used during job execution to connect to the target and determine the list of databases inside the target.
        """
        return pulumi.get(self, "refresh_credential")

    @property
    @pulumi.getter(name="serverName")
    def server_name(self) -> Optional[str]:
        """
        The target server name.
        """
        return pulumi.get(self, "server_name")

    @property
    @pulumi.getter(name="shardMapName")
    def shard_map_name(self) -> Optional[str]:
        """
        The target shard map.
        """
        return pulumi.get(self, "shard_map_name")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ManagedInstancePairInfoResponse(dict):
    """
    Pairs of Managed Instances in the failover group.
    """
    def __init__(__self__, *,
                 partner_managed_instance_id: Optional[str] = None,
                 primary_managed_instance_id: Optional[str] = None):
        """
        Pairs of Managed Instances in the failover group.
        :param str partner_managed_instance_id: Id of Partner Managed Instance in pair.
        :param str primary_managed_instance_id: Id of Primary Managed Instance in pair.
        """
        if partner_managed_instance_id is not None:
            pulumi.set(__self__, "partner_managed_instance_id", partner_managed_instance_id)
        if primary_managed_instance_id is not None:
            pulumi.set(__self__, "primary_managed_instance_id", primary_managed_instance_id)

    @property
    @pulumi.getter(name="partnerManagedInstanceId")
    def partner_managed_instance_id(self) -> Optional[str]:
        """
        Id of Partner Managed Instance in pair.
        """
        return pulumi.get(self, "partner_managed_instance_id")

    @property
    @pulumi.getter(name="primaryManagedInstanceId")
    def primary_managed_instance_id(self) -> Optional[str]:
        """
        Id of Primary Managed Instance in pair.
        """
        return pulumi.get(self, "primary_managed_instance_id")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ManagedInstancePecPropertyResponse(dict):
    """
    A private endpoint connection under a managed instance
    """
    def __init__(__self__, *,
                 id: str,
                 properties: 'outputs.ManagedInstancePrivateEndpointConnectionPropertiesResponse'):
        """
        A private endpoint connection under a managed instance
        :param str id: Resource ID.
        :param 'ManagedInstancePrivateEndpointConnectionPropertiesResponseArgs' properties: Private endpoint connection properties
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "properties", properties)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Resource ID.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def properties(self) -> 'outputs.ManagedInstancePrivateEndpointConnectionPropertiesResponse':
        """
        Private endpoint connection properties
        """
        return pulumi.get(self, "properties")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ManagedInstancePrivateEndpointConnectionPropertiesResponse(dict):
    """
    Properties of a private endpoint connection.
    """
    def __init__(__self__, *,
                 provisioning_state: str,
                 private_endpoint: Optional['outputs.ManagedInstancePrivateEndpointPropertyResponse'] = None,
                 private_link_service_connection_state: Optional['outputs.ManagedInstancePrivateLinkServiceConnectionStatePropertyResponse'] = None):
        """
        Properties of a private endpoint connection.
        :param str provisioning_state: State of the Private Endpoint Connection.
        :param 'ManagedInstancePrivateEndpointPropertyResponseArgs' private_endpoint: Private endpoint which the connection belongs to.
        :param 'ManagedInstancePrivateLinkServiceConnectionStatePropertyResponseArgs' private_link_service_connection_state: Connection State of the Private Endpoint Connection.
        """
        pulumi.set(__self__, "provisioning_state", provisioning_state)
        if private_endpoint is not None:
            pulumi.set(__self__, "private_endpoint", private_endpoint)
        if private_link_service_connection_state is not None:
            pulumi.set(__self__, "private_link_service_connection_state", private_link_service_connection_state)

    @property
    @pulumi.getter(name="provisioningState")
    def provisioning_state(self) -> str:
        """
        State of the Private Endpoint Connection.
        """
        return pulumi.get(self, "provisioning_state")

    @property
    @pulumi.getter(name="privateEndpoint")
    def private_endpoint(self) -> Optional['outputs.ManagedInstancePrivateEndpointPropertyResponse']:
        """
        Private endpoint which the connection belongs to.
        """
        return pulumi.get(self, "private_endpoint")

    @property
    @pulumi.getter(name="privateLinkServiceConnectionState")
    def private_link_service_connection_state(self) -> Optional['outputs.ManagedInstancePrivateLinkServiceConnectionStatePropertyResponse']:
        """
        Connection State of the Private Endpoint Connection.
        """
        return pulumi.get(self, "private_link_service_connection_state")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ManagedInstancePrivateEndpointPropertyResponse(dict):
    def __init__(__self__, *,
                 id: Optional[str] = None):
        """
        :param str id: Resource id of the private endpoint.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Resource id of the private endpoint.
        """
        return pulumi.get(self, "id")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ManagedInstancePrivateLinkServiceConnectionStatePropertyResponse(dict):
    def __init__(__self__, *,
                 actions_required: str,
                 description: str,
                 status: str):
        """
        :param str actions_required: The private link service connection description.
        :param str description: The private link service connection description.
        :param str status: The private link service connection status.
        """
        pulumi.set(__self__, "actions_required", actions_required)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter(name="actionsRequired")
    def actions_required(self) -> str:
        """
        The private link service connection description.
        """
        return pulumi.get(self, "actions_required")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        The private link service connection description.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The private link service connection status.
        """
        return pulumi.get(self, "status")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PartnerInfoResponse(dict):
    """
    Partner server information for the failover group.
    """
    def __init__(__self__, *,
                 id: str,
                 location: str,
                 replication_role: str):
        """
        Partner server information for the failover group.
        :param str id: Resource identifier of the partner server.
        :param str location: Geo location of the partner server.
        :param str replication_role: Replication role of the partner server.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "location", location)
        pulumi.set(__self__, "replication_role", replication_role)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Resource identifier of the partner server.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="replicationRole")
    def replication_role(self) -> str:
        """
        Replication role of the partner server.
        """
        return pulumi.get(self, "replication_role")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PartnerRegionInfoResponse(dict):
    """
    Partner region information for the failover group.
    """
    def __init__(__self__, *,
                 replication_role: str,
                 location: Optional[str] = None):
        """
        Partner region information for the failover group.
        :param str replication_role: Replication role of the partner managed instances.
        :param str location: Geo location of the partner managed instances.
        """
        pulumi.set(__self__, "replication_role", replication_role)
        if location is not None:
            pulumi.set(__self__, "location", location)

    @property
    @pulumi.getter(name="replicationRole")
    def replication_role(self) -> str:
        """
        Replication role of the partner managed instances.
        """
        return pulumi.get(self, "replication_role")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PrivateEndpointConnectionPropertiesResponse(dict):
    """
    Properties of a private endpoint connection.
    """
    def __init__(__self__, *,
                 provisioning_state: str,
                 private_endpoint: Optional['outputs.PrivateEndpointPropertyResponse'] = None,
                 private_link_service_connection_state: Optional['outputs.PrivateLinkServiceConnectionStatePropertyResponse'] = None):
        """
        Properties of a private endpoint connection.
        :param str provisioning_state: State of the private endpoint connection.
        :param 'PrivateEndpointPropertyResponseArgs' private_endpoint: Private endpoint which the connection belongs to.
        :param 'PrivateLinkServiceConnectionStatePropertyResponseArgs' private_link_service_connection_state: Connection state of the private endpoint connection.
        """
        pulumi.set(__self__, "provisioning_state", provisioning_state)
        if private_endpoint is not None:
            pulumi.set(__self__, "private_endpoint", private_endpoint)
        if private_link_service_connection_state is not None:
            pulumi.set(__self__, "private_link_service_connection_state", private_link_service_connection_state)

    @property
    @pulumi.getter(name="provisioningState")
    def provisioning_state(self) -> str:
        """
        State of the private endpoint connection.
        """
        return pulumi.get(self, "provisioning_state")

    @property
    @pulumi.getter(name="privateEndpoint")
    def private_endpoint(self) -> Optional['outputs.PrivateEndpointPropertyResponse']:
        """
        Private endpoint which the connection belongs to.
        """
        return pulumi.get(self, "private_endpoint")

    @property
    @pulumi.getter(name="privateLinkServiceConnectionState")
    def private_link_service_connection_state(self) -> Optional['outputs.PrivateLinkServiceConnectionStatePropertyResponse']:
        """
        Connection state of the private endpoint connection.
        """
        return pulumi.get(self, "private_link_service_connection_state")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PrivateEndpointPropertyResponse(dict):
    def __init__(__self__, *,
                 id: Optional[str] = None):
        """
        :param str id: Resource id of the private endpoint.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Resource id of the private endpoint.
        """
        return pulumi.get(self, "id")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PrivateLinkServiceConnectionStatePropertyResponse(dict):
    def __init__(__self__, *,
                 actions_required: str,
                 description: str,
                 status: str):
        """
        :param str actions_required: The actions required for private link service connection.
        :param str description: The private link service connection description.
        :param str status: The private link service connection status.
        """
        pulumi.set(__self__, "actions_required", actions_required)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter(name="actionsRequired")
    def actions_required(self) -> str:
        """
        The actions required for private link service connection.
        """
        return pulumi.get(self, "actions_required")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        The private link service connection description.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The private link service connection status.
        """
        return pulumi.get(self, "status")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ResourceIdentityResponse(dict):
    """
    Azure Active Directory identity configuration for a resource.
    """
    def __init__(__self__, *,
                 principal_id: str,
                 tenant_id: str,
                 type: Optional[str] = None):
        """
        Azure Active Directory identity configuration for a resource.
        :param str principal_id: The Azure Active Directory principal id.
        :param str tenant_id: The Azure Active Directory tenant id.
        :param str type: The identity type. Set this to 'SystemAssigned' in order to automatically create and assign an Azure Active Directory principal for the resource.
        """
        pulumi.set(__self__, "principal_id", principal_id)
        pulumi.set(__self__, "tenant_id", tenant_id)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> str:
        """
        The Azure Active Directory principal id.
        """
        return pulumi.get(self, "principal_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        """
        The Azure Active Directory tenant id.
        """
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        The identity type. Set this to 'SystemAssigned' in order to automatically create and assign an Azure Active Directory principal for the resource.
        """
        return pulumi.get(self, "type")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ServerInfoResponse(dict):
    """
    Server info for the server trust group.
    """
    def __init__(__self__, *,
                 server_id: str):
        """
        Server info for the server trust group.
        :param str server_id: Server Id.
        """
        pulumi.set(__self__, "server_id", server_id)

    @property
    @pulumi.getter(name="serverId")
    def server_id(self) -> str:
        """
        Server Id.
        """
        return pulumi.get(self, "server_id")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ServerPrivateEndpointConnectionResponse(dict):
    """
    A private endpoint connection under a server
    """
    def __init__(__self__, *,
                 id: str,
                 properties: 'outputs.PrivateEndpointConnectionPropertiesResponse'):
        """
        A private endpoint connection under a server
        :param str id: Resource ID.
        :param 'PrivateEndpointConnectionPropertiesResponseArgs' properties: Private endpoint connection properties
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "properties", properties)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Resource ID.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def properties(self) -> 'outputs.PrivateEndpointConnectionPropertiesResponse':
        """
        Private endpoint connection properties
        """
        return pulumi.get(self, "properties")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class SkuResponse(dict):
    """
    An ARM Resource SKU.
    """
    def __init__(__self__, *,
                 name: str,
                 capacity: Optional[int] = None,
                 family: Optional[str] = None,
                 size: Optional[str] = None,
                 tier: Optional[str] = None):
        """
        An ARM Resource SKU.
        :param str name: The name of the SKU, typically, a letter + Number code, e.g. P3.
        :param int capacity: Capacity of the particular SKU.
        :param str family: If the service has different generations of hardware, for the same SKU, then that can be captured here.
        :param str size: Size of the particular SKU
        :param str tier: The tier or edition of the particular SKU, e.g. Basic, Premium.
        """
        pulumi.set(__self__, "name", name)
        if capacity is not None:
            pulumi.set(__self__, "capacity", capacity)
        if family is not None:
            pulumi.set(__self__, "family", family)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if tier is not None:
            pulumi.set(__self__, "tier", tier)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the SKU, typically, a letter + Number code, e.g. P3.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def capacity(self) -> Optional[int]:
        """
        Capacity of the particular SKU.
        """
        return pulumi.get(self, "capacity")

    @property
    @pulumi.getter
    def family(self) -> Optional[str]:
        """
        If the service has different generations of hardware, for the same SKU, then that can be captured here.
        """
        return pulumi.get(self, "family")

    @property
    @pulumi.getter
    def size(self) -> Optional[str]:
        """
        Size of the particular SKU
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter
    def tier(self) -> Optional[str]:
        """
        The tier or edition of the particular SKU, e.g. Basic, Premium.
        """
        return pulumi.get(self, "tier")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class SyncGroupSchemaResponse(dict):
    """
    Properties of sync group schema.
    """
    def __init__(__self__, *,
                 master_sync_member_name: Optional[str] = None,
                 tables: Optional[Sequence['outputs.SyncGroupSchemaTableResponse']] = None):
        """
        Properties of sync group schema.
        :param str master_sync_member_name: Name of master sync member where the schema is from.
        :param Sequence['SyncGroupSchemaTableResponseArgs'] tables: List of tables in sync group schema.
        """
        if master_sync_member_name is not None:
            pulumi.set(__self__, "master_sync_member_name", master_sync_member_name)
        if tables is not None:
            pulumi.set(__self__, "tables", tables)

    @property
    @pulumi.getter(name="masterSyncMemberName")
    def master_sync_member_name(self) -> Optional[str]:
        """
        Name of master sync member where the schema is from.
        """
        return pulumi.get(self, "master_sync_member_name")

    @property
    @pulumi.getter
    def tables(self) -> Optional[Sequence['outputs.SyncGroupSchemaTableResponse']]:
        """
        List of tables in sync group schema.
        """
        return pulumi.get(self, "tables")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class SyncGroupSchemaTableColumnResponse(dict):
    """
    Properties of column in sync group table.
    """
    def __init__(__self__, *,
                 data_size: Optional[str] = None,
                 data_type: Optional[str] = None,
                 quoted_name: Optional[str] = None):
        """
        Properties of column in sync group table.
        :param str data_size: Data size of the column.
        :param str data_type: Data type of the column.
        :param str quoted_name: Quoted name of sync group table column.
        """
        if data_size is not None:
            pulumi.set(__self__, "data_size", data_size)
        if data_type is not None:
            pulumi.set(__self__, "data_type", data_type)
        if quoted_name is not None:
            pulumi.set(__self__, "quoted_name", quoted_name)

    @property
    @pulumi.getter(name="dataSize")
    def data_size(self) -> Optional[str]:
        """
        Data size of the column.
        """
        return pulumi.get(self, "data_size")

    @property
    @pulumi.getter(name="dataType")
    def data_type(self) -> Optional[str]:
        """
        Data type of the column.
        """
        return pulumi.get(self, "data_type")

    @property
    @pulumi.getter(name="quotedName")
    def quoted_name(self) -> Optional[str]:
        """
        Quoted name of sync group table column.
        """
        return pulumi.get(self, "quoted_name")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class SyncGroupSchemaTableResponse(dict):
    """
    Properties of table in sync group schema.
    """
    def __init__(__self__, *,
                 columns: Optional[Sequence['outputs.SyncGroupSchemaTableColumnResponse']] = None,
                 quoted_name: Optional[str] = None):
        """
        Properties of table in sync group schema.
        :param Sequence['SyncGroupSchemaTableColumnResponseArgs'] columns: List of columns in sync group schema.
        :param str quoted_name: Quoted name of sync group schema table.
        """
        if columns is not None:
            pulumi.set(__self__, "columns", columns)
        if quoted_name is not None:
            pulumi.set(__self__, "quoted_name", quoted_name)

    @property
    @pulumi.getter
    def columns(self) -> Optional[Sequence['outputs.SyncGroupSchemaTableColumnResponse']]:
        """
        List of columns in sync group schema.
        """
        return pulumi.get(self, "columns")

    @property
    @pulumi.getter(name="quotedName")
    def quoted_name(self) -> Optional[str]:
        """
        Quoted name of sync group schema table.
        """
        return pulumi.get(self, "quoted_name")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class VulnerabilityAssessmentRecurringScansPropertiesResponse(dict):
    """
    Properties of a Vulnerability Assessment recurring scans.
    """
    def __init__(__self__, *,
                 email_subscription_admins: Optional[bool] = None,
                 emails: Optional[Sequence[str]] = None,
                 is_enabled: Optional[bool] = None):
        """
        Properties of a Vulnerability Assessment recurring scans.
        :param bool email_subscription_admins: Specifies that the schedule scan notification will be is sent to the subscription administrators.
        :param Sequence[str] emails: Specifies an array of e-mail addresses to which the scan notification is sent.
        :param bool is_enabled: Recurring scans state.
        """
        if email_subscription_admins is None:
            email_subscription_admins = True
        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 is_enabled is not None:
            pulumi.set(__self__, "is_enabled", is_enabled)

    @property
    @pulumi.getter(name="emailSubscriptionAdmins")
    def email_subscription_admins(self) -> Optional[bool]:
        """
        Specifies that the schedule scan notification will be is sent to the subscription administrators.
        """
        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(name="isEnabled")
    def is_enabled(self) -> Optional[bool]:
        """
        Recurring scans state.
        """
        return pulumi.get(self, "is_enabled")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


