# 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, Callable, Mapping, Optional, Sequence, Union, overload
from .. import _utilities

__all__ = [
    'ServiceInitialReplicaSetArgs',
    'ServiceNotificationsArgs',
    'ServiceSecureLdapArgs',
    'ServiceSecurityArgs',
]

@pulumi.input_type
class ServiceInitialReplicaSetArgs:
    def __init__(__self__, *,
                 subnet_id: pulumi.Input[str],
                 domain_controller_ip_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 external_access_ip_address: Optional[pulumi.Input[str]] = None,
                 id: Optional[pulumi.Input[str]] = None,
                 location: Optional[pulumi.Input[str]] = None,
                 service_status: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] subnet_id: The ID of the subnet in which to place the initial replica set. Changing this forces a new resource to be created.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] domain_controller_ip_addresses: A list of subnet IP addresses for the domain controllers in the initial replica set, typically two.
        :param pulumi.Input[str] external_access_ip_address: The publicly routable IP address for the domain controllers in the initial replica set.
        :param pulumi.Input[str] id: A unique ID for the replica set.
        :param pulumi.Input[str] location: The Azure location where the Domain Service exists. Changing this forces a new resource to be created.
        :param pulumi.Input[str] service_status: The current service status for the initial replica set.
        """
        ServiceInitialReplicaSetArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            subnet_id=subnet_id,
            domain_controller_ip_addresses=domain_controller_ip_addresses,
            external_access_ip_address=external_access_ip_address,
            id=id,
            location=location,
            service_status=service_status,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             subnet_id: Optional[pulumi.Input[str]] = None,
             domain_controller_ip_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             external_access_ip_address: Optional[pulumi.Input[str]] = None,
             id: Optional[pulumi.Input[str]] = None,
             location: Optional[pulumi.Input[str]] = None,
             service_status: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if subnet_id is None and 'subnetId' in kwargs:
            subnet_id = kwargs['subnetId']
        if subnet_id is None:
            raise TypeError("Missing 'subnet_id' argument")
        if domain_controller_ip_addresses is None and 'domainControllerIpAddresses' in kwargs:
            domain_controller_ip_addresses = kwargs['domainControllerIpAddresses']
        if external_access_ip_address is None and 'externalAccessIpAddress' in kwargs:
            external_access_ip_address = kwargs['externalAccessIpAddress']
        if service_status is None and 'serviceStatus' in kwargs:
            service_status = kwargs['serviceStatus']

        _setter("subnet_id", subnet_id)
        if domain_controller_ip_addresses is not None:
            _setter("domain_controller_ip_addresses", domain_controller_ip_addresses)
        if external_access_ip_address is not None:
            _setter("external_access_ip_address", external_access_ip_address)
        if id is not None:
            _setter("id", id)
        if location is not None:
            _setter("location", location)
        if service_status is not None:
            _setter("service_status", service_status)

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> pulumi.Input[str]:
        """
        The ID of the subnet in which to place the initial replica set. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

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

    @property
    @pulumi.getter(name="domainControllerIpAddresses")
    def domain_controller_ip_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of subnet IP addresses for the domain controllers in the initial replica set, typically two.
        """
        return pulumi.get(self, "domain_controller_ip_addresses")

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

    @property
    @pulumi.getter(name="externalAccessIpAddress")
    def external_access_ip_address(self) -> Optional[pulumi.Input[str]]:
        """
        The publicly routable IP address for the domain controllers in the initial replica set.
        """
        return pulumi.get(self, "external_access_ip_address")

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

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[str]]:
        """
        A unique ID for the replica set.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter
    def location(self) -> Optional[pulumi.Input[str]]:
        """
        The Azure location where the Domain Service exists. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "location")

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

    @property
    @pulumi.getter(name="serviceStatus")
    def service_status(self) -> Optional[pulumi.Input[str]]:
        """
        The current service status for the initial replica set.
        """
        return pulumi.get(self, "service_status")

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


@pulumi.input_type
class ServiceNotificationsArgs:
    def __init__(__self__, *,
                 additional_recipients: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 notify_dc_admins: Optional[pulumi.Input[bool]] = None,
                 notify_global_admins: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] additional_recipients: A list of additional email addresses to notify when there are alerts in the managed domain.
        :param pulumi.Input[bool] notify_dc_admins: Whether to notify members of the _AAD DC Administrators_ group when there are alerts in the managed domain.
        :param pulumi.Input[bool] notify_global_admins: Whether to notify all Global Administrators when there are alerts in the managed domain.
        """
        ServiceNotificationsArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            additional_recipients=additional_recipients,
            notify_dc_admins=notify_dc_admins,
            notify_global_admins=notify_global_admins,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             additional_recipients: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             notify_dc_admins: Optional[pulumi.Input[bool]] = None,
             notify_global_admins: Optional[pulumi.Input[bool]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if additional_recipients is None and 'additionalRecipients' in kwargs:
            additional_recipients = kwargs['additionalRecipients']
        if notify_dc_admins is None and 'notifyDcAdmins' in kwargs:
            notify_dc_admins = kwargs['notifyDcAdmins']
        if notify_global_admins is None and 'notifyGlobalAdmins' in kwargs:
            notify_global_admins = kwargs['notifyGlobalAdmins']

        if additional_recipients is not None:
            _setter("additional_recipients", additional_recipients)
        if notify_dc_admins is not None:
            _setter("notify_dc_admins", notify_dc_admins)
        if notify_global_admins is not None:
            _setter("notify_global_admins", notify_global_admins)

    @property
    @pulumi.getter(name="additionalRecipients")
    def additional_recipients(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of additional email addresses to notify when there are alerts in the managed domain.
        """
        return pulumi.get(self, "additional_recipients")

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

    @property
    @pulumi.getter(name="notifyDcAdmins")
    def notify_dc_admins(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to notify members of the _AAD DC Administrators_ group when there are alerts in the managed domain.
        """
        return pulumi.get(self, "notify_dc_admins")

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

    @property
    @pulumi.getter(name="notifyGlobalAdmins")
    def notify_global_admins(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to notify all Global Administrators when there are alerts in the managed domain.
        """
        return pulumi.get(self, "notify_global_admins")

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


@pulumi.input_type
class ServiceSecureLdapArgs:
    def __init__(__self__, *,
                 enabled: pulumi.Input[bool],
                 pfx_certificate: pulumi.Input[str],
                 pfx_certificate_password: pulumi.Input[str],
                 certificate_expiry: Optional[pulumi.Input[str]] = None,
                 certificate_thumbprint: Optional[pulumi.Input[str]] = None,
                 external_access_enabled: Optional[pulumi.Input[bool]] = None,
                 public_certificate: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] enabled: Whether to enable secure LDAP for the managed domain. For more information, please see [official documentation on enabling LDAPS](https://docs.microsoft.com/azure/active-directory-domain-services/tutorial-configure-ldaps), paying particular attention to the section on network security to avoid unnecessarily exposing your service to Internet-borne bruteforce attacks.
        :param pulumi.Input[str] pfx_certificate: The certificate/private key to use for LDAPS, as a base64-encoded TripleDES-SHA1 encrypted PKCS#12 bundle (PFX file).
        :param pulumi.Input[str] pfx_certificate_password: The password to use for decrypting the PKCS#12 bundle (PFX file).
        :param pulumi.Input[str] certificate_expiry: The expiry time of the certificate.
        :param pulumi.Input[str] certificate_thumbprint: The thumbprint of the certificate.
        :param pulumi.Input[bool] external_access_enabled: Whether to enable external access to LDAPS over the Internet. Defaults to `false`.
        :param pulumi.Input[str] public_certificate: The public certificate.
        """
        ServiceSecureLdapArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            enabled=enabled,
            pfx_certificate=pfx_certificate,
            pfx_certificate_password=pfx_certificate_password,
            certificate_expiry=certificate_expiry,
            certificate_thumbprint=certificate_thumbprint,
            external_access_enabled=external_access_enabled,
            public_certificate=public_certificate,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             enabled: Optional[pulumi.Input[bool]] = None,
             pfx_certificate: Optional[pulumi.Input[str]] = None,
             pfx_certificate_password: Optional[pulumi.Input[str]] = None,
             certificate_expiry: Optional[pulumi.Input[str]] = None,
             certificate_thumbprint: Optional[pulumi.Input[str]] = None,
             external_access_enabled: Optional[pulumi.Input[bool]] = None,
             public_certificate: Optional[pulumi.Input[str]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if enabled is None:
            raise TypeError("Missing 'enabled' argument")
        if pfx_certificate is None and 'pfxCertificate' in kwargs:
            pfx_certificate = kwargs['pfxCertificate']
        if pfx_certificate is None:
            raise TypeError("Missing 'pfx_certificate' argument")
        if pfx_certificate_password is None and 'pfxCertificatePassword' in kwargs:
            pfx_certificate_password = kwargs['pfxCertificatePassword']
        if pfx_certificate_password is None:
            raise TypeError("Missing 'pfx_certificate_password' argument")
        if certificate_expiry is None and 'certificateExpiry' in kwargs:
            certificate_expiry = kwargs['certificateExpiry']
        if certificate_thumbprint is None and 'certificateThumbprint' in kwargs:
            certificate_thumbprint = kwargs['certificateThumbprint']
        if external_access_enabled is None and 'externalAccessEnabled' in kwargs:
            external_access_enabled = kwargs['externalAccessEnabled']
        if public_certificate is None and 'publicCertificate' in kwargs:
            public_certificate = kwargs['publicCertificate']

        _setter("enabled", enabled)
        _setter("pfx_certificate", pfx_certificate)
        _setter("pfx_certificate_password", pfx_certificate_password)
        if certificate_expiry is not None:
            _setter("certificate_expiry", certificate_expiry)
        if certificate_thumbprint is not None:
            _setter("certificate_thumbprint", certificate_thumbprint)
        if external_access_enabled is not None:
            _setter("external_access_enabled", external_access_enabled)
        if public_certificate is not None:
            _setter("public_certificate", public_certificate)

    @property
    @pulumi.getter
    def enabled(self) -> pulumi.Input[bool]:
        """
        Whether to enable secure LDAP for the managed domain. For more information, please see [official documentation on enabling LDAPS](https://docs.microsoft.com/azure/active-directory-domain-services/tutorial-configure-ldaps), paying particular attention to the section on network security to avoid unnecessarily exposing your service to Internet-borne bruteforce attacks.
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter(name="pfxCertificate")
    def pfx_certificate(self) -> pulumi.Input[str]:
        """
        The certificate/private key to use for LDAPS, as a base64-encoded TripleDES-SHA1 encrypted PKCS#12 bundle (PFX file).
        """
        return pulumi.get(self, "pfx_certificate")

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

    @property
    @pulumi.getter(name="pfxCertificatePassword")
    def pfx_certificate_password(self) -> pulumi.Input[str]:
        """
        The password to use for decrypting the PKCS#12 bundle (PFX file).
        """
        return pulumi.get(self, "pfx_certificate_password")

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

    @property
    @pulumi.getter(name="certificateExpiry")
    def certificate_expiry(self) -> Optional[pulumi.Input[str]]:
        """
        The expiry time of the certificate.
        """
        return pulumi.get(self, "certificate_expiry")

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

    @property
    @pulumi.getter(name="certificateThumbprint")
    def certificate_thumbprint(self) -> Optional[pulumi.Input[str]]:
        """
        The thumbprint of the certificate.
        """
        return pulumi.get(self, "certificate_thumbprint")

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

    @property
    @pulumi.getter(name="externalAccessEnabled")
    def external_access_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to enable external access to LDAPS over the Internet. Defaults to `false`.
        """
        return pulumi.get(self, "external_access_enabled")

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

    @property
    @pulumi.getter(name="publicCertificate")
    def public_certificate(self) -> Optional[pulumi.Input[str]]:
        """
        The public certificate.
        """
        return pulumi.get(self, "public_certificate")

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


@pulumi.input_type
class ServiceSecurityArgs:
    def __init__(__self__, *,
                 kerberos_armoring_enabled: Optional[pulumi.Input[bool]] = None,
                 kerberos_rc4_encryption_enabled: Optional[pulumi.Input[bool]] = None,
                 ntlm_v1_enabled: Optional[pulumi.Input[bool]] = None,
                 sync_kerberos_passwords: Optional[pulumi.Input[bool]] = None,
                 sync_ntlm_passwords: Optional[pulumi.Input[bool]] = None,
                 sync_on_prem_passwords: Optional[pulumi.Input[bool]] = None,
                 tls_v1_enabled: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] kerberos_armoring_enabled: Whether to enable Kerberos Armoring. Defaults to `false`.
        :param pulumi.Input[bool] kerberos_rc4_encryption_enabled: Whether to enable Kerberos RC4 Encryption. Defaults to `false`.
        :param pulumi.Input[bool] ntlm_v1_enabled: Whether to enable legacy NTLM v1 support. Defaults to `false`.
        :param pulumi.Input[bool] sync_kerberos_passwords: Whether to synchronize Kerberos password hashes to the managed domain. Defaults to `false`.
        :param pulumi.Input[bool] sync_ntlm_passwords: Whether to synchronize NTLM password hashes to the managed domain. Defaults to `false`.
        :param pulumi.Input[bool] sync_on_prem_passwords: Whether to synchronize on-premises password hashes to the managed domain. Defaults to `false`.
        :param pulumi.Input[bool] tls_v1_enabled: Whether to enable legacy TLS v1 support. Defaults to `false`.
        """
        ServiceSecurityArgs._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            kerberos_armoring_enabled=kerberos_armoring_enabled,
            kerberos_rc4_encryption_enabled=kerberos_rc4_encryption_enabled,
            ntlm_v1_enabled=ntlm_v1_enabled,
            sync_kerberos_passwords=sync_kerberos_passwords,
            sync_ntlm_passwords=sync_ntlm_passwords,
            sync_on_prem_passwords=sync_on_prem_passwords,
            tls_v1_enabled=tls_v1_enabled,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             kerberos_armoring_enabled: Optional[pulumi.Input[bool]] = None,
             kerberos_rc4_encryption_enabled: Optional[pulumi.Input[bool]] = None,
             ntlm_v1_enabled: Optional[pulumi.Input[bool]] = None,
             sync_kerberos_passwords: Optional[pulumi.Input[bool]] = None,
             sync_ntlm_passwords: Optional[pulumi.Input[bool]] = None,
             sync_on_prem_passwords: Optional[pulumi.Input[bool]] = None,
             tls_v1_enabled: Optional[pulumi.Input[bool]] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if kerberos_armoring_enabled is None and 'kerberosArmoringEnabled' in kwargs:
            kerberos_armoring_enabled = kwargs['kerberosArmoringEnabled']
        if kerberos_rc4_encryption_enabled is None and 'kerberosRc4EncryptionEnabled' in kwargs:
            kerberos_rc4_encryption_enabled = kwargs['kerberosRc4EncryptionEnabled']
        if ntlm_v1_enabled is None and 'ntlmV1Enabled' in kwargs:
            ntlm_v1_enabled = kwargs['ntlmV1Enabled']
        if sync_kerberos_passwords is None and 'syncKerberosPasswords' in kwargs:
            sync_kerberos_passwords = kwargs['syncKerberosPasswords']
        if sync_ntlm_passwords is None and 'syncNtlmPasswords' in kwargs:
            sync_ntlm_passwords = kwargs['syncNtlmPasswords']
        if sync_on_prem_passwords is None and 'syncOnPremPasswords' in kwargs:
            sync_on_prem_passwords = kwargs['syncOnPremPasswords']
        if tls_v1_enabled is None and 'tlsV1Enabled' in kwargs:
            tls_v1_enabled = kwargs['tlsV1Enabled']

        if kerberos_armoring_enabled is not None:
            _setter("kerberos_armoring_enabled", kerberos_armoring_enabled)
        if kerberos_rc4_encryption_enabled is not None:
            _setter("kerberos_rc4_encryption_enabled", kerberos_rc4_encryption_enabled)
        if ntlm_v1_enabled is not None:
            _setter("ntlm_v1_enabled", ntlm_v1_enabled)
        if sync_kerberos_passwords is not None:
            _setter("sync_kerberos_passwords", sync_kerberos_passwords)
        if sync_ntlm_passwords is not None:
            _setter("sync_ntlm_passwords", sync_ntlm_passwords)
        if sync_on_prem_passwords is not None:
            _setter("sync_on_prem_passwords", sync_on_prem_passwords)
        if tls_v1_enabled is not None:
            _setter("tls_v1_enabled", tls_v1_enabled)

    @property
    @pulumi.getter(name="kerberosArmoringEnabled")
    def kerberos_armoring_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to enable Kerberos Armoring. Defaults to `false`.
        """
        return pulumi.get(self, "kerberos_armoring_enabled")

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

    @property
    @pulumi.getter(name="kerberosRc4EncryptionEnabled")
    def kerberos_rc4_encryption_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to enable Kerberos RC4 Encryption. Defaults to `false`.
        """
        return pulumi.get(self, "kerberos_rc4_encryption_enabled")

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

    @property
    @pulumi.getter(name="ntlmV1Enabled")
    def ntlm_v1_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to enable legacy NTLM v1 support. Defaults to `false`.
        """
        return pulumi.get(self, "ntlm_v1_enabled")

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

    @property
    @pulumi.getter(name="syncKerberosPasswords")
    def sync_kerberos_passwords(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to synchronize Kerberos password hashes to the managed domain. Defaults to `false`.
        """
        return pulumi.get(self, "sync_kerberos_passwords")

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

    @property
    @pulumi.getter(name="syncNtlmPasswords")
    def sync_ntlm_passwords(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to synchronize NTLM password hashes to the managed domain. Defaults to `false`.
        """
        return pulumi.get(self, "sync_ntlm_passwords")

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

    @property
    @pulumi.getter(name="syncOnPremPasswords")
    def sync_on_prem_passwords(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to synchronize on-premises password hashes to the managed domain. Defaults to `false`.
        """
        return pulumi.get(self, "sync_on_prem_passwords")

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

    @property
    @pulumi.getter(name="tlsV1Enabled")
    def tls_v1_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to enable legacy TLS v1 support. Defaults to `false`.
        """
        return pulumi.get(self, "tls_v1_enabled")

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


