com.pulumi.azurenative.network.kotlin.inputs.InboundNatPoolArgs.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.network.kotlin.inputs

import com.pulumi.azurenative.network.inputs.InboundNatPoolArgs.builder
import com.pulumi.azurenative.network.kotlin.enums.TransportProtocol
import com.pulumi.core.Either
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 com.pulumi.kotlin.applySuspend
import kotlin.Boolean
import kotlin.Int
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.jvm.JvmName

/**
 * Inbound NAT pool of the load balancer.
 * @property backendPort The port used for internal connections on the endpoint. Acceptable values are between 1 and 65535.
 * @property enableFloatingIP Configures a virtual machine's endpoint for the floating IP capability required to configure a SQL AlwaysOn Availability Group. This setting is required when using the SQL AlwaysOn Availability Groups in SQL server. This setting can't be changed after you create the endpoint.
 * @property enableTcpReset Receive bidirectional TCP Reset on TCP flow idle timeout or unexpected connection termination. This element is only used when the protocol is set to TCP.
 * @property frontendIPConfiguration A reference to frontend IP addresses.
 * @property frontendPortRangeEnd The last port number in the range of external ports that will be used to provide Inbound Nat to NICs associated with a load balancer. Acceptable values range between 1 and 65535.
 * @property frontendPortRangeStart The first port number in the range of external ports that will be used to provide Inbound Nat to NICs associated with a load balancer. Acceptable values range between 1 and 65534.
 * @property id Resource ID.
 * @property idleTimeoutInMinutes The timeout for the TCP idle connection. The value can be set between 4 and 30 minutes. The default value is 4 minutes. This element is only used when the protocol is set to TCP.
 * @property name The name of the resource that is unique within the set of inbound NAT pools used by the load balancer. This name can be used to access the resource.
 * @property protocol The reference to the transport protocol used by the inbound NAT pool.
 */
public data class InboundNatPoolArgs(
    public val backendPort: Output,
    public val enableFloatingIP: Output? = null,
    public val enableTcpReset: Output? = null,
    public val frontendIPConfiguration: Output? = null,
    public val frontendPortRangeEnd: Output,
    public val frontendPortRangeStart: Output,
    public val id: Output? = null,
    public val idleTimeoutInMinutes: Output? = null,
    public val name: Output? = null,
    public val protocol: Output>,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.azurenative.network.inputs.InboundNatPoolArgs =
        com.pulumi.azurenative.network.inputs.InboundNatPoolArgs.builder()
            .backendPort(backendPort.applyValue({ args0 -> args0 }))
            .enableFloatingIP(enableFloatingIP?.applyValue({ args0 -> args0 }))
            .enableTcpReset(enableTcpReset?.applyValue({ args0 -> args0 }))
            .frontendIPConfiguration(
                frontendIPConfiguration?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .frontendPortRangeEnd(frontendPortRangeEnd.applyValue({ args0 -> args0 }))
            .frontendPortRangeStart(frontendPortRangeStart.applyValue({ args0 -> args0 }))
            .id(id?.applyValue({ args0 -> args0 }))
            .idleTimeoutInMinutes(idleTimeoutInMinutes?.applyValue({ args0 -> args0 }))
            .name(name?.applyValue({ args0 -> args0 }))
            .protocol(
                protocol.applyValue({ args0 ->
                    args0.transform({ args0 -> args0 }, { args0 ->
                        args0.let({ args0 -> args0.toJava() })
                    })
                }),
            ).build()
}

/**
 * Builder for [InboundNatPoolArgs].
 */
@PulumiTagMarker
public class InboundNatPoolArgsBuilder internal constructor() {
    private var backendPort: Output? = null

    private var enableFloatingIP: Output? = null

    private var enableTcpReset: Output? = null

    private var frontendIPConfiguration: Output? = null

    private var frontendPortRangeEnd: Output? = null

    private var frontendPortRangeStart: Output? = null

    private var id: Output? = null

    private var idleTimeoutInMinutes: Output? = null

    private var name: Output? = null

    private var protocol: Output>? = null

    /**
     * @param value The port used for internal connections on the endpoint. Acceptable values are between 1 and 65535.
     */
    @JvmName("chmhbpxwqogabgmg")
    public suspend fun backendPort(`value`: Output) {
        this.backendPort = value
    }

    /**
     * @param value Configures a virtual machine's endpoint for the floating IP capability required to configure a SQL AlwaysOn Availability Group. This setting is required when using the SQL AlwaysOn Availability Groups in SQL server. This setting can't be changed after you create the endpoint.
     */
    @JvmName("gmaukojkwdbocgxb")
    public suspend fun enableFloatingIP(`value`: Output) {
        this.enableFloatingIP = value
    }

    /**
     * @param value Receive bidirectional TCP Reset on TCP flow idle timeout or unexpected connection termination. This element is only used when the protocol is set to TCP.
     */
    @JvmName("cscutnxcrohjbkrp")
    public suspend fun enableTcpReset(`value`: Output) {
        this.enableTcpReset = value
    }

    /**
     * @param value A reference to frontend IP addresses.
     */
    @JvmName("djsqnmxwagktijsm")
    public suspend fun frontendIPConfiguration(`value`: Output) {
        this.frontendIPConfiguration = value
    }

    /**
     * @param value The last port number in the range of external ports that will be used to provide Inbound Nat to NICs associated with a load balancer. Acceptable values range between 1 and 65535.
     */
    @JvmName("ydsfbutuynnuskxo")
    public suspend fun frontendPortRangeEnd(`value`: Output) {
        this.frontendPortRangeEnd = value
    }

    /**
     * @param value The first port number in the range of external ports that will be used to provide Inbound Nat to NICs associated with a load balancer. Acceptable values range between 1 and 65534.
     */
    @JvmName("vbtcjemhodpxgxqa")
    public suspend fun frontendPortRangeStart(`value`: Output) {
        this.frontendPortRangeStart = value
    }

    /**
     * @param value Resource ID.
     */
    @JvmName("rqlgyoyqriiuechv")
    public suspend fun id(`value`: Output) {
        this.id = value
    }

    /**
     * @param value The timeout for the TCP idle connection. The value can be set between 4 and 30 minutes. The default value is 4 minutes. This element is only used when the protocol is set to TCP.
     */
    @JvmName("gajudsafqwdfwhrw")
    public suspend fun idleTimeoutInMinutes(`value`: Output) {
        this.idleTimeoutInMinutes = value
    }

    /**
     * @param value The name of the resource that is unique within the set of inbound NAT pools used by the load balancer. This name can be used to access the resource.
     */
    @JvmName("yfujasgdaasymddo")
    public suspend fun name(`value`: Output) {
        this.name = value
    }

    /**
     * @param value The reference to the transport protocol used by the inbound NAT pool.
     */
    @JvmName("jhrvjsnypilopwfl")
    public suspend fun protocol(`value`: Output>) {
        this.protocol = value
    }

    /**
     * @param value The port used for internal connections on the endpoint. Acceptable values are between 1 and 65535.
     */
    @JvmName("lstgyihkcqpsoepc")
    public suspend fun backendPort(`value`: Int) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.backendPort = mapped
    }

    /**
     * @param value Configures a virtual machine's endpoint for the floating IP capability required to configure a SQL AlwaysOn Availability Group. This setting is required when using the SQL AlwaysOn Availability Groups in SQL server. This setting can't be changed after you create the endpoint.
     */
    @JvmName("ovqmgoesxwxpsavw")
    public suspend fun enableFloatingIP(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enableFloatingIP = mapped
    }

    /**
     * @param value Receive bidirectional TCP Reset on TCP flow idle timeout or unexpected connection termination. This element is only used when the protocol is set to TCP.
     */
    @JvmName("xglchsssyyodruej")
    public suspend fun enableTcpReset(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.enableTcpReset = mapped
    }

    /**
     * @param value A reference to frontend IP addresses.
     */
    @JvmName("oropioyioqxjtslg")
    public suspend fun frontendIPConfiguration(`value`: SubResourceArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.frontendIPConfiguration = mapped
    }

    /**
     * @param argument A reference to frontend IP addresses.
     */
    @JvmName("subayufepjiobvkj")
    public suspend fun frontendIPConfiguration(argument: suspend SubResourceArgsBuilder.() -> Unit) {
        val toBeMapped = SubResourceArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.frontendIPConfiguration = mapped
    }

    /**
     * @param value The last port number in the range of external ports that will be used to provide Inbound Nat to NICs associated with a load balancer. Acceptable values range between 1 and 65535.
     */
    @JvmName("hwhcjnbbspcamqby")
    public suspend fun frontendPortRangeEnd(`value`: Int) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.frontendPortRangeEnd = mapped
    }

    /**
     * @param value The first port number in the range of external ports that will be used to provide Inbound Nat to NICs associated with a load balancer. Acceptable values range between 1 and 65534.
     */
    @JvmName("xgoisymnbvxbhlqk")
    public suspend fun frontendPortRangeStart(`value`: Int) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.frontendPortRangeStart = mapped
    }

    /**
     * @param value Resource ID.
     */
    @JvmName("liksriovrnloebef")
    public suspend fun id(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.id = mapped
    }

    /**
     * @param value The timeout for the TCP idle connection. The value can be set between 4 and 30 minutes. The default value is 4 minutes. This element is only used when the protocol is set to TCP.
     */
    @JvmName("gqckgemhjuvujsaj")
    public suspend fun idleTimeoutInMinutes(`value`: Int?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.idleTimeoutInMinutes = mapped
    }

    /**
     * @param value The name of the resource that is unique within the set of inbound NAT pools used by the load balancer. This name can be used to access the resource.
     */
    @JvmName("edhuwlxmvpajxkwv")
    public suspend fun name(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.name = mapped
    }

    /**
     * @param value The reference to the transport protocol used by the inbound NAT pool.
     */
    @JvmName("sjuqaswljhlwumck")
    public suspend fun protocol(`value`: Either) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.protocol = mapped
    }

    /**
     * @param value The reference to the transport protocol used by the inbound NAT pool.
     */
    @JvmName("vbxdehrbibywysdb")
    public fun protocol(`value`: String) {
        val toBeMapped = Either.ofLeft(value)
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.protocol = mapped
    }

    /**
     * @param value The reference to the transport protocol used by the inbound NAT pool.
     */
    @JvmName("cxuovvnppkrfrxcu")
    public fun protocol(`value`: TransportProtocol) {
        val toBeMapped = Either.ofRight(value)
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.protocol = mapped
    }

    internal fun build(): InboundNatPoolArgs = InboundNatPoolArgs(
        backendPort = backendPort ?: throw PulumiNullFieldException("backendPort"),
        enableFloatingIP = enableFloatingIP,
        enableTcpReset = enableTcpReset,
        frontendIPConfiguration = frontendIPConfiguration,
        frontendPortRangeEnd = frontendPortRangeEnd ?: throw
            PulumiNullFieldException("frontendPortRangeEnd"),
        frontendPortRangeStart = frontendPortRangeStart ?: throw
            PulumiNullFieldException("frontendPortRangeStart"),
        id = id,
        idleTimeoutInMinutes = idleTimeoutInMinutes,
        name = name,
        protocol = protocol ?: throw PulumiNullFieldException("protocol"),
    )
}