com.pulumi.azurenative.azurestackhci.kotlin.inputs.InfrastructureNetworkArgs.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of pulumi-azure-native-kotlin Show documentation
Build cloud applications and infrastructure by combining the safety and reliability of infrastructure as code with the power of the Kotlin programming language.
There is a newer version: 2.82.0.0
Show newest version
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.azurenative.azurestackhci.kotlin.inputs

import com.pulumi.azurenative.azurestackhci.inputs.InfrastructureNetworkArgs.builder
import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.Boolean
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.jvm.JvmName

/**
 * The InfrastructureNetwork of a AzureStackHCI Cluster.
 * @property dnsServers IPv4 address of the DNS servers in your environment.
 * @property gateway Default gateway that should be used for the provided IP address space.
 * @property ipPools Range of IP addresses from which addresses are allocated for nodes within a subnet.
 * @property subnetMask Subnet mask that matches the provided IP address space.
 * @property useDhcp Allows customers to use DHCP for Hosts and Cluster IPs. If not declared, the deployment will default to static IPs. When true, GW and DNS servers are not required
 */
public data class InfrastructureNetworkArgs(
    public val dnsServers: Output>? = null,
    public val gateway: Output? = null,
    public val ipPools: Output>? = null,
    public val subnetMask: Output? = null,
    public val useDhcp: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.azurenative.azurestackhci.inputs.InfrastructureNetworkArgs =
        com.pulumi.azurenative.azurestackhci.inputs.InfrastructureNetworkArgs.builder()
            .dnsServers(dnsServers?.applyValue({ args0 -> args0.map({ args0 -> args0 }) }))
            .gateway(gateway?.applyValue({ args0 -> args0 }))
            .ipPools(
                ipPools?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .subnetMask(subnetMask?.applyValue({ args0 -> args0 }))
            .useDhcp(useDhcp?.applyValue({ args0 -> args0 })).build()
}

/**
 * Builder for [InfrastructureNetworkArgs].
 */
@PulumiTagMarker
public class InfrastructureNetworkArgsBuilder internal constructor() {
    private var dnsServers: Output>? = null

    private var gateway: Output? = null

    private var ipPools: Output>? = null

    private var subnetMask: Output? = null

    private var useDhcp: Output? = null

    /**
     * @param value IPv4 address of the DNS servers in your environment.
     */
    @JvmName("wtdixmvrwkcqoatt")
    public suspend fun dnsServers(`value`: Output>) {
        this.dnsServers = value
    }

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

    /**
     * @param values IPv4 address of the DNS servers in your environment.
     */
    @JvmName("rxisffcytnytrisn")
    public suspend fun dnsServers(values: List>) {
        this.dnsServers = Output.all(values)
    }

    /**
     * @param value Default gateway that should be used for the provided IP address space.
     */
    @JvmName("lfsgctnthnnxfvso")
    public suspend fun gateway(`value`: Output) {
        this.gateway = value
    }

    /**
     * @param value Range of IP addresses from which addresses are allocated for nodes within a subnet.
     */
    @JvmName("xxrjccvvbojxkgua")
    public suspend fun ipPools(`value`: Output>) {
        this.ipPools = value
    }

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

    /**
     * @param values Range of IP addresses from which addresses are allocated for nodes within a subnet.
     */
    @JvmName("hxbdxgyulvhtffgg")
    public suspend fun ipPools(values: List>) {
        this.ipPools = Output.all(values)
    }

    /**
     * @param value Subnet mask that matches the provided IP address space.
     */
    @JvmName("igoqnvljtiiamuep")
    public suspend fun subnetMask(`value`: Output) {
        this.subnetMask = value
    }

    /**
     * @param value Allows customers to use DHCP for Hosts and Cluster IPs. If not declared, the deployment will default to static IPs. When true, GW and DNS servers are not required
     */
    @JvmName("jaamdhblnntjyyim")
    public suspend fun useDhcp(`value`: Output) {
        this.useDhcp = value
    }

    /**
     * @param value IPv4 address of the DNS servers in your environment.
     */
    @JvmName("xqxaqrhuayxanjpg")
    public suspend fun dnsServers(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.dnsServers = mapped
    }

    /**
     * @param values IPv4 address of the DNS servers in your environment.
     */
    @JvmName("tbdlppffekfpttnq")
    public suspend fun dnsServers(vararg values: String) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.dnsServers = mapped
    }

    /**
     * @param value Default gateway that should be used for the provided IP address space.
     */
    @JvmName("khggcmiqjkbstbsf")
    public suspend fun gateway(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.gateway = mapped
    }

    /**
     * @param value Range of IP addresses from which addresses are allocated for nodes within a subnet.
     */
    @JvmName("gvsqwlqmricaheyg")
    public suspend fun ipPools(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.ipPools = mapped
    }

    /**
     * @param argument Range of IP addresses from which addresses are allocated for nodes within a subnet.
     */
    @JvmName("bhhtfdsfyxpqkatx")
    public suspend fun ipPools(argument: List Unit>) {
        val toBeMapped = argument.toList().map { IpPoolsArgsBuilder().applySuspend { it() }.build() }
        val mapped = of(toBeMapped)
        this.ipPools = mapped
    }

    /**
     * @param argument Range of IP addresses from which addresses are allocated for nodes within a subnet.
     */
    @JvmName("mngaokcacwuafobt")
    public suspend fun ipPools(vararg argument: suspend IpPoolsArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map { IpPoolsArgsBuilder().applySuspend { it() }.build() }
        val mapped = of(toBeMapped)
        this.ipPools = mapped
    }

    /**
     * @param argument Range of IP addresses from which addresses are allocated for nodes within a subnet.
     */
    @JvmName("suvwanksjkngxxhd")
    public suspend fun ipPools(argument: suspend IpPoolsArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(IpPoolsArgsBuilder().applySuspend { argument() }.build())
        val mapped = of(toBeMapped)
        this.ipPools = mapped
    }

    /**
     * @param values Range of IP addresses from which addresses are allocated for nodes within a subnet.
     */
    @JvmName("iafeuhcrbprybmdl")
    public suspend fun ipPools(vararg values: IpPoolsArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.ipPools = mapped
    }

    /**
     * @param value Subnet mask that matches the provided IP address space.
     */
    @JvmName("jbbifuyepvwjuhyh")
    public suspend fun subnetMask(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.subnetMask = mapped
    }

    /**
     * @param value Allows customers to use DHCP for Hosts and Cluster IPs. If not declared, the deployment will default to static IPs. When true, GW and DNS servers are not required
     */
    @JvmName("cbinvmamoymnothh")
    public suspend fun useDhcp(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.useDhcp = mapped
    }

    internal fun build(): InfrastructureNetworkArgs = InfrastructureNetworkArgs(
        dnsServers = dnsServers,
        gateway = gateway,
        ipPools = ipPools,
        subnetMask = subnetMask,
        useDhcp = useDhcp,
    )
}