com.pulumi.azure.netapp.kotlin.inputs.AccountActiveDirectoryArgs.kt Maven / Gradle / Ivy

Go to download
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.azure.netapp.kotlin.inputs

import com.pulumi.azure.netapp.inputs.AccountActiveDirectoryArgs.builder
import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiNullFieldException
import com.pulumi.kotlin.PulumiTagMarker
import kotlin.Boolean
import kotlin.String
import kotlin.Suppress
import kotlin.collections.List
import kotlin.jvm.JvmName

/**
 *
 * @property aesEncryptionEnabled If enabled, AES encryption will be enabled for SMB communication. Defaults to `false`.
 * @property dnsServers A list of DNS server IP addresses for the Active Directory domain. Only allows `IPv4` address.
 * @property domain The name of the Active Directory domain.
 * @property kerberosAdName Name of the active directory machine.
 * @property kerberosKdcIp kdc server IP addresses for the active directory machine.
 * > **IMPORTANT:** If you plan on using **Kerberos** volumes, both `ad_name` and `kdc_ip` are required in order to create the volume.
 * @property ldapOverTlsEnabled Specifies whether or not the LDAP traffic needs to be secured via TLS. Defaults to `false`.
 * @property ldapSigningEnabled Specifies whether or not the LDAP traffic needs to be signed. Defaults to `false`.
 * @property localNfsUsersWithLdapAllowed If enabled, NFS client local users can also (in addition to LDAP users) access the NFS volumes. Defaults to `false`.
 * @property organizationalUnit The Organizational Unit (OU) within Active Directory where machines will be created. If blank, defaults to `CN=Computers`.
 * @property password The password associated with the `username`.
 * @property serverRootCaCertificate When LDAP over SSL/TLS is enabled, the LDAP client is required to have a *base64 encoded Active Directory Certificate Service's self-signed root CA certificate*, this optional parameter is used only for dual protocol with LDAP user-mapping volumes. Required if `ldap_over_tls_enabled` is set to `true`.
 * @property siteName The Active Directory site the service will limit Domain Controller discovery to. If blank, defaults to `Default-First-Site-Name`.
 * @property smbServerName The NetBIOS name which should be used for the NetApp SMB Server, which will be registered as a computer account in the AD and used to mount volumes.
 * @property username The Username of Active Directory Domain Administrator.
 */
public data class AccountActiveDirectoryArgs(
    public val aesEncryptionEnabled: Output? = null,
    public val dnsServers: Output>,
    public val domain: Output,
    public val kerberosAdName: Output? = null,
    public val kerberosKdcIp: Output? = null,
    public val ldapOverTlsEnabled: Output? = null,
    public val ldapSigningEnabled: Output? = null,
    public val localNfsUsersWithLdapAllowed: Output? = null,
    public val organizationalUnit: Output? = null,
    public val password: Output,
    public val serverRootCaCertificate: Output? = null,
    public val siteName: Output? = null,
    public val smbServerName: Output,
    public val username: Output,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.azure.netapp.inputs.AccountActiveDirectoryArgs =
        com.pulumi.azure.netapp.inputs.AccountActiveDirectoryArgs.builder()
            .aesEncryptionEnabled(aesEncryptionEnabled?.applyValue({ args0 -> args0 }))
            .dnsServers(dnsServers.applyValue({ args0 -> args0.map({ args0 -> args0 }) }))
            .domain(domain.applyValue({ args0 -> args0 }))
            .kerberosAdName(kerberosAdName?.applyValue({ args0 -> args0 }))
            .kerberosKdcIp(kerberosKdcIp?.applyValue({ args0 -> args0 }))
            .ldapOverTlsEnabled(ldapOverTlsEnabled?.applyValue({ args0 -> args0 }))
            .ldapSigningEnabled(ldapSigningEnabled?.applyValue({ args0 -> args0 }))
            .localNfsUsersWithLdapAllowed(localNfsUsersWithLdapAllowed?.applyValue({ args0 -> args0 }))
            .organizationalUnit(organizationalUnit?.applyValue({ args0 -> args0 }))
            .password(password.applyValue({ args0 -> args0 }))
            .serverRootCaCertificate(serverRootCaCertificate?.applyValue({ args0 -> args0 }))
            .siteName(siteName?.applyValue({ args0 -> args0 }))
            .smbServerName(smbServerName.applyValue({ args0 -> args0 }))
            .username(username.applyValue({ args0 -> args0 })).build()
}

/**
 * Builder for [AccountActiveDirectoryArgs].
 */
@PulumiTagMarker
public class AccountActiveDirectoryArgsBuilder internal constructor() {
    private var aesEncryptionEnabled: Output? = null

    private var dnsServers: Output>? = null

    private var domain: Output? = null

    private var kerberosAdName: Output? = null

    private var kerberosKdcIp: Output? = null

    private var ldapOverTlsEnabled: Output? = null

    private var ldapSigningEnabled: Output? = null

    private var localNfsUsersWithLdapAllowed: Output? = null

    private var organizationalUnit: Output? = null

    private var password: Output? = null

    private var serverRootCaCertificate: Output? = null

    private var siteName: Output? = null

    private var smbServerName: Output? = null

    private var username: Output? = null

    /**
     * @param value If enabled, AES encryption will be enabled for SMB communication. Defaults to `false`.
     */
    @JvmName("pbsfxrrynivedcev")
    public suspend fun aesEncryptionEnabled(`value`: Output) {
        this.aesEncryptionEnabled = value
    }

    /**
     * @param value A list of DNS server IP addresses for the Active Directory domain. Only allows `IPv4` address.
     */
    @JvmName("nltaolfjymchpgrj")
    public suspend fun dnsServers(`value`: Output>) {
        this.dnsServers = value
    }

    @JvmName("obyiunkwalkubhbj")
    public suspend fun dnsServers(vararg values: Output) {
        this.dnsServers = Output.all(values.asList())
    }

    /**
     * @param values A list of DNS server IP addresses for the Active Directory domain. Only allows `IPv4` address.
     */
    @JvmName("jiktruyosamcnuwm")
    public suspend fun dnsServers(values: List>) {
        this.dnsServers = Output.all(values)
    }

    /**
     * @param value The name of the Active Directory domain.
     */
    @JvmName("lxqsqrctfwykgrdy")
    public suspend fun domain(`value`: Output) {
        this.domain = value
    }

    /**
     * @param value Name of the active directory machine.
     */
    @JvmName("lhoojlihcqaqqooj")
    public suspend fun kerberosAdName(`value`: Output) {
        this.kerberosAdName = value
    }

    /**
     * @param value kdc server IP addresses for the active directory machine.
     * > **IMPORTANT:** If you plan on using **Kerberos** volumes, both `ad_name` and `kdc_ip` are required in order to create the volume.
     */
    @JvmName("xasnsqkcvocrlkdi")
    public suspend fun kerberosKdcIp(`value`: Output) {
        this.kerberosKdcIp = value
    }

    /**
     * @param value Specifies whether or not the LDAP traffic needs to be secured via TLS. Defaults to `false`.
     */
    @JvmName("gmabihejpxglrbtd")
    public suspend fun ldapOverTlsEnabled(`value`: Output) {
        this.ldapOverTlsEnabled = value
    }

    /**
     * @param value Specifies whether or not the LDAP traffic needs to be signed. Defaults to `false`.
     */
    @JvmName("nnxbnadndofydwox")
    public suspend fun ldapSigningEnabled(`value`: Output) {
        this.ldapSigningEnabled = value
    }

    /**
     * @param value If enabled, NFS client local users can also (in addition to LDAP users) access the NFS volumes. Defaults to `false`.
     */
    @JvmName("dkehgkkgwpqiqgve")
    public suspend fun localNfsUsersWithLdapAllowed(`value`: Output) {
        this.localNfsUsersWithLdapAllowed = value
    }

    /**
     * @param value The Organizational Unit (OU) within Active Directory where machines will be created. If blank, defaults to `CN=Computers`.
     */
    @JvmName("palkfoybteffmorb")
    public suspend fun organizationalUnit(`value`: Output) {
        this.organizationalUnit = value
    }

    /**
     * @param value The password associated with the `username`.
     */
    @JvmName("coedkfclnsdxxcvq")
    public suspend fun password(`value`: Output) {
        this.password = value
    }

    /**
     * @param value When LDAP over SSL/TLS is enabled, the LDAP client is required to have a *base64 encoded Active Directory Certificate Service's self-signed root CA certificate*, this optional parameter is used only for dual protocol with LDAP user-mapping volumes. Required if `ldap_over_tls_enabled` is set to `true`.
     */
    @JvmName("jkcchfiflqwapvjs")
    public suspend fun serverRootCaCertificate(`value`: Output) {
        this.serverRootCaCertificate = value
    }

    /**
     * @param value The Active Directory site the service will limit Domain Controller discovery to. If blank, defaults to `Default-First-Site-Name`.
     */
    @JvmName("vaqddxayqehoycqx")
    public suspend fun siteName(`value`: Output) {
        this.siteName = value
    }

    /**
     * @param value The NetBIOS name which should be used for the NetApp SMB Server, which will be registered as a computer account in the AD and used to mount volumes.
     */
    @JvmName("dpifcplllvvkcuwk")
    public suspend fun smbServerName(`value`: Output) {
        this.smbServerName = value
    }

    /**
     * @param value The Username of Active Directory Domain Administrator.
     */
    @JvmName("wyjwrfwsyvymuwko")
    public suspend fun username(`value`: Output) {
        this.username = value
    }

    /**
     * @param value If enabled, AES encryption will be enabled for SMB communication. Defaults to `false`.
     */
    @JvmName("waqkouwkulkhqkbl")
    public suspend fun aesEncryptionEnabled(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.aesEncryptionEnabled = mapped
    }

    /**
     * @param value A list of DNS server IP addresses for the Active Directory domain. Only allows `IPv4` address.
     */
    @JvmName("vgjnjueaaoecrgwx")
    public suspend fun dnsServers(`value`: List) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.dnsServers = mapped
    }

    /**
     * @param values A list of DNS server IP addresses for the Active Directory domain. Only allows `IPv4` address.
     */
    @JvmName("hxyxymnhnabtrrwu")
    public suspend fun dnsServers(vararg values: String) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.dnsServers = mapped
    }

    /**
     * @param value The name of the Active Directory domain.
     */
    @JvmName("uprkrhbvtibchbwr")
    public suspend fun domain(`value`: String) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.domain = mapped
    }

    /**
     * @param value Name of the active directory machine.
     */
    @JvmName("updkbrjfynmpscaa")
    public suspend fun kerberosAdName(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.kerberosAdName = mapped
    }

    /**
     * @param value kdc server IP addresses for the active directory machine.
     * > **IMPORTANT:** If you plan on using **Kerberos** volumes, both `ad_name` and `kdc_ip` are required in order to create the volume.
     */
    @JvmName("ylhecqwuxrghjmba")
    public suspend fun kerberosKdcIp(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.kerberosKdcIp = mapped
    }

    /**
     * @param value Specifies whether or not the LDAP traffic needs to be secured via TLS. Defaults to `false`.
     */
    @JvmName("dtkwxqikikpvuymy")
    public suspend fun ldapOverTlsEnabled(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.ldapOverTlsEnabled = mapped
    }

    /**
     * @param value Specifies whether or not the LDAP traffic needs to be signed. Defaults to `false`.
     */
    @JvmName("gkycplmegcwaqglj")
    public suspend fun ldapSigningEnabled(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.ldapSigningEnabled = mapped
    }

    /**
     * @param value If enabled, NFS client local users can also (in addition to LDAP users) access the NFS volumes. Defaults to `false`.
     */
    @JvmName("wycqduigpypihyjy")
    public suspend fun localNfsUsersWithLdapAllowed(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.localNfsUsersWithLdapAllowed = mapped
    }

    /**
     * @param value The Organizational Unit (OU) within Active Directory where machines will be created. If blank, defaults to `CN=Computers`.
     */
    @JvmName("hkatwysybmfkmxfb")
    public suspend fun organizationalUnit(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.organizationalUnit = mapped
    }

    /**
     * @param value The password associated with the `username`.
     */
    @JvmName("sdtpwryqnycfhgkb")
    public suspend fun password(`value`: String) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.password = mapped
    }

    /**
     * @param value When LDAP over SSL/TLS is enabled, the LDAP client is required to have a *base64 encoded Active Directory Certificate Service's self-signed root CA certificate*, this optional parameter is used only for dual protocol with LDAP user-mapping volumes. Required if `ldap_over_tls_enabled` is set to `true`.
     */
    @JvmName("cakwwerabbgfbhkc")
    public suspend fun serverRootCaCertificate(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.serverRootCaCertificate = mapped
    }

    /**
     * @param value The Active Directory site the service will limit Domain Controller discovery to. If blank, defaults to `Default-First-Site-Name`.
     */
    @JvmName("yfcdnmwsqqulfffh")
    public suspend fun siteName(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.siteName = mapped
    }

    /**
     * @param value The NetBIOS name which should be used for the NetApp SMB Server, which will be registered as a computer account in the AD and used to mount volumes.
     */
    @JvmName("rgilmpmpjwaokpea")
    public suspend fun smbServerName(`value`: String) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.smbServerName = mapped
    }

    /**
     * @param value The Username of Active Directory Domain Administrator.
     */
    @JvmName("lyybfxscpebnanxm")
    public suspend fun username(`value`: String) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.username = mapped
    }

    internal fun build(): AccountActiveDirectoryArgs = AccountActiveDirectoryArgs(
        aesEncryptionEnabled = aesEncryptionEnabled,
        dnsServers = dnsServers ?: throw PulumiNullFieldException("dnsServers"),
        domain = domain ?: throw PulumiNullFieldException("domain"),
        kerberosAdName = kerberosAdName,
        kerberosKdcIp = kerberosKdcIp,
        ldapOverTlsEnabled = ldapOverTlsEnabled,
        ldapSigningEnabled = ldapSigningEnabled,
        localNfsUsersWithLdapAllowed = localNfsUsersWithLdapAllowed,
        organizationalUnit = organizationalUnit,
        password = password ?: throw PulumiNullFieldException("password"),
        serverRootCaCertificate = serverRootCaCertificate,
        siteName = siteName,
        smbServerName = smbServerName ?: throw PulumiNullFieldException("smbServerName"),
        username = username ?: throw PulumiNullFieldException("username"),
    )
}