com.pulumi.nomad.kotlin.CsiVolumeRegistrationArgs.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of pulumi-nomad-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.4.2.0
Show newest version
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.nomad.kotlin

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 com.pulumi.nomad.CsiVolumeRegistrationArgs.builder
import com.pulumi.nomad.kotlin.inputs.CsiVolumeRegistrationCapabilityArgs
import com.pulumi.nomad.kotlin.inputs.CsiVolumeRegistrationCapabilityArgsBuilder
import com.pulumi.nomad.kotlin.inputs.CsiVolumeRegistrationMountOptionsArgs
import com.pulumi.nomad.kotlin.inputs.CsiVolumeRegistrationMountOptionsArgsBuilder
import com.pulumi.nomad.kotlin.inputs.CsiVolumeRegistrationTopologyRequestArgs
import com.pulumi.nomad.kotlin.inputs.CsiVolumeRegistrationTopologyRequestArgsBuilder
import kotlin.Boolean
import kotlin.Pair
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.collections.Map
import kotlin.jvm.JvmName

/**
 *
 * @property capabilities `(``Capability``: )` - Options for validating the capability of a volume.
 * @property capacityMax `(string: )` - Option to signal a maximum volume size. This may not be supported by all storage providers.
 * @property capacityMin `(string: )` - Option to signal a minimum volume size. This may not be supported by all storage providers.
 * @property context `(map[string]string: )` - An optional key-value map of strings passed directly to the CSI plugin to validate the volume.
 * @property deregisterOnDestroy `(boolean: true)` - If true, the volume will be deregistered on destroy.
 * @property externalId `(string: )` - The ID of the physical volume from the storage provider.
 * @property mountOptions `(block: )` Options for mounting `block-device` volumes without a pre-formatted file system.
 * @property name `(string: )` - The display name for the volume.
 * @property namespace `(string: "default")` - The namespace in which to register the volume.
 * @property parameters `(map[string]string: )` - An optional key-value map of strings passed directly to the CSI plugin to configure the volume.
 * @property pluginId `(string: )` - The ID of the Nomad plugin for registering this volume.
 * @property secrets `(map[string]string: )` - An optional key-value map of strings used as credentials for publishing and unpublishing volumes.
 * @property topologyRequest `(``TopologyRequest``: )` - Specify locations (region, zone, rack, etc.) where the provisioned volume is accessible from.
 * @property volumeId `(string: )` - The unique ID of the volume.
 */
public data class CsiVolumeRegistrationArgs(
    public val capabilities: Output>? = null,
    public val capacityMax: Output? = null,
    public val capacityMin: Output? = null,
    public val context: Output>? = null,
    public val deregisterOnDestroy: Output? = null,
    public val externalId: Output? = null,
    public val mountOptions: Output? = null,
    public val name: Output? = null,
    public val namespace: Output? = null,
    public val parameters: Output>? = null,
    public val pluginId: Output? = null,
    public val secrets: Output>? = null,
    public val topologyRequest: Output? = null,
    public val volumeId: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.nomad.CsiVolumeRegistrationArgs =
        com.pulumi.nomad.CsiVolumeRegistrationArgs.builder()
            .capabilities(
                capabilities?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .capacityMax(capacityMax?.applyValue({ args0 -> args0 }))
            .capacityMin(capacityMin?.applyValue({ args0 -> args0 }))
            .context(context?.applyValue({ args0 -> args0.map({ args0 -> args0.key.to(args0.value) }).toMap() }))
            .deregisterOnDestroy(deregisterOnDestroy?.applyValue({ args0 -> args0 }))
            .externalId(externalId?.applyValue({ args0 -> args0 }))
            .mountOptions(mountOptions?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .name(name?.applyValue({ args0 -> args0 }))
            .namespace(namespace?.applyValue({ args0 -> args0 }))
            .parameters(
                parameters?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.key.to(args0.value)
                    }).toMap()
                }),
            )
            .pluginId(pluginId?.applyValue({ args0 -> args0 }))
            .secrets(secrets?.applyValue({ args0 -> args0.map({ args0 -> args0.key.to(args0.value) }).toMap() }))
            .topologyRequest(topologyRequest?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .volumeId(volumeId?.applyValue({ args0 -> args0 })).build()
}

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

    private var capacityMax: Output? = null

    private var capacityMin: Output? = null

    private var context: Output>? = null

    private var deregisterOnDestroy: Output? = null

    private var externalId: Output? = null

    private var mountOptions: Output? = null

    private var name: Output? = null

    private var namespace: Output? = null

    private var parameters: Output>? = null

    private var pluginId: Output? = null

    private var secrets: Output>? = null

    private var topologyRequest: Output? = null

    private var volumeId: Output? = null

    /**
     * @param value `(``Capability``: )` - Options for validating the capability of a volume.
     */
    @JvmName("kvoqlotxeusirvly")
    public suspend fun capabilities(`value`: Output>) {
        this.capabilities = value
    }

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

    /**
     * @param values `(``Capability``: )` - Options for validating the capability of a volume.
     */
    @JvmName("tbifethwduecugrw")
    public suspend fun capabilities(values: List>) {
        this.capabilities = Output.all(values)
    }

    /**
     * @param value `(string: )` - Option to signal a maximum volume size. This may not be supported by all storage providers.
     */
    @JvmName("mtwmtqqspdhunqpp")
    public suspend fun capacityMax(`value`: Output) {
        this.capacityMax = value
    }

    /**
     * @param value `(string: )` - Option to signal a minimum volume size. This may not be supported by all storage providers.
     */
    @JvmName("raeiirbttiucpmfw")
    public suspend fun capacityMin(`value`: Output) {
        this.capacityMin = value
    }

    /**
     * @param value `(map[string]string: )` - An optional key-value map of strings passed directly to the CSI plugin to validate the volume.
     */
    @JvmName("agmbrecyinteavln")
    public suspend fun context(`value`: Output>) {
        this.context = value
    }

    /**
     * @param value `(boolean: true)` - If true, the volume will be deregistered on destroy.
     */
    @JvmName("gnfyawgloafwnaws")
    public suspend fun deregisterOnDestroy(`value`: Output) {
        this.deregisterOnDestroy = value
    }

    /**
     * @param value `(string: )` - The ID of the physical volume from the storage provider.
     */
    @JvmName("jhihwfteusgsqfhc")
    public suspend fun externalId(`value`: Output) {
        this.externalId = value
    }

    /**
     * @param value `(block: )` Options for mounting `block-device` volumes without a pre-formatted file system.
     */
    @JvmName("vhbisxurpllohees")
    public suspend fun mountOptions(`value`: Output) {
        this.mountOptions = value
    }

    /**
     * @param value `(string: )` - The display name for the volume.
     */
    @JvmName("hetuwtfsdhbvacgp")
    public suspend fun name(`value`: Output) {
        this.name = value
    }

    /**
     * @param value `(string: "default")` - The namespace in which to register the volume.
     */
    @JvmName("fnlgtvybinpxywki")
    public suspend fun namespace(`value`: Output) {
        this.namespace = value
    }

    /**
     * @param value `(map[string]string: )` - An optional key-value map of strings passed directly to the CSI plugin to configure the volume.
     */
    @JvmName("btrdfmyjofdtfrhg")
    public suspend fun parameters(`value`: Output>) {
        this.parameters = value
    }

    /**
     * @param value `(string: )` - The ID of the Nomad plugin for registering this volume.
     */
    @JvmName("grjdornbtkfepeof")
    public suspend fun pluginId(`value`: Output) {
        this.pluginId = value
    }

    /**
     * @param value `(map[string]string: )` - An optional key-value map of strings used as credentials for publishing and unpublishing volumes.
     */
    @JvmName("nkdclugiilkykcoj")
    public suspend fun secrets(`value`: Output>) {
        this.secrets = value
    }

    /**
     * @param value `(``TopologyRequest``: )` - Specify locations (region, zone, rack, etc.) where the provisioned volume is accessible from.
     */
    @JvmName("aknqnwnqhsjafnsv")
    public suspend fun topologyRequest(`value`: Output) {
        this.topologyRequest = value
    }

    /**
     * @param value `(string: )` - The unique ID of the volume.
     */
    @JvmName("iexlpqdqkneucaho")
    public suspend fun volumeId(`value`: Output) {
        this.volumeId = value
    }

    /**
     * @param value `(``Capability``: )` - Options for validating the capability of a volume.
     */
    @JvmName("ayxlusgpofuvhwua")
    public suspend fun capabilities(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.capabilities = mapped
    }

    /**
     * @param argument `(``Capability``: )` - Options for validating the capability of a volume.
     */
    @JvmName("jnunitvyhbcogvhx")
    public suspend fun capabilities(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            CsiVolumeRegistrationCapabilityArgsBuilder().applySuspend { it() }.build()
        }
        val mapped = of(toBeMapped)
        this.capabilities = mapped
    }

    /**
     * @param argument `(``Capability``: )` - Options for validating the capability of a volume.
     */
    @JvmName("ofugdksojqhikutk")
    public suspend fun capabilities(vararg argument: suspend CsiVolumeRegistrationCapabilityArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            CsiVolumeRegistrationCapabilityArgsBuilder().applySuspend { it() }.build()
        }
        val mapped = of(toBeMapped)
        this.capabilities = mapped
    }

    /**
     * @param argument `(``Capability``: )` - Options for validating the capability of a volume.
     */
    @JvmName("lxmrnrhlxixhwvkv")
    public suspend fun capabilities(argument: suspend CsiVolumeRegistrationCapabilityArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(
            CsiVolumeRegistrationCapabilityArgsBuilder().applySuspend {
                argument()
            }.build(),
        )
        val mapped = of(toBeMapped)
        this.capabilities = mapped
    }

    /**
     * @param values `(``Capability``: )` - Options for validating the capability of a volume.
     */
    @JvmName("tueoyqijkblyrwqw")
    public suspend fun capabilities(vararg values: CsiVolumeRegistrationCapabilityArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.capabilities = mapped
    }

    /**
     * @param value `(string: )` - Option to signal a maximum volume size. This may not be supported by all storage providers.
     */
    @JvmName("ooubjqixwowpmjll")
    public suspend fun capacityMax(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.capacityMax = mapped
    }

    /**
     * @param value `(string: )` - Option to signal a minimum volume size. This may not be supported by all storage providers.
     */
    @JvmName("xtkcirvcmfihwvcw")
    public suspend fun capacityMin(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.capacityMin = mapped
    }

    /**
     * @param value `(map[string]string: )` - An optional key-value map of strings passed directly to the CSI plugin to validate the volume.
     */
    @JvmName("ibexoxjhgcilwhjf")
    public suspend fun context(`value`: Map?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.context = mapped
    }

    /**
     * @param values `(map[string]string: )` - An optional key-value map of strings passed directly to the CSI plugin to validate the volume.
     */
    @JvmName("skeowfukyrgvhuwl")
    public fun context(vararg values: Pair) {
        val toBeMapped = values.toMap()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.context = mapped
    }

    /**
     * @param value `(boolean: true)` - If true, the volume will be deregistered on destroy.
     */
    @JvmName("bxgoohoyywucgjux")
    public suspend fun deregisterOnDestroy(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.deregisterOnDestroy = mapped
    }

    /**
     * @param value `(string: )` - The ID of the physical volume from the storage provider.
     */
    @JvmName("lcxsfqjjcfrttxem")
    public suspend fun externalId(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.externalId = mapped
    }

    /**
     * @param value `(block: )` Options for mounting `block-device` volumes without a pre-formatted file system.
     */
    @JvmName("jvpcpswssoshiagd")
    public suspend fun mountOptions(`value`: CsiVolumeRegistrationMountOptionsArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.mountOptions = mapped
    }

    /**
     * @param argument `(block: )` Options for mounting `block-device` volumes without a pre-formatted file system.
     */
    @JvmName("jhttdqqdqontwykx")
    public suspend fun mountOptions(argument: suspend CsiVolumeRegistrationMountOptionsArgsBuilder.() -> Unit) {
        val toBeMapped = CsiVolumeRegistrationMountOptionsArgsBuilder().applySuspend {
            argument()
        }.build()
        val mapped = of(toBeMapped)
        this.mountOptions = mapped
    }

    /**
     * @param value `(string: )` - The display name for the volume.
     */
    @JvmName("vuvugjvbbhadtmep")
    public suspend fun name(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.name = mapped
    }

    /**
     * @param value `(string: "default")` - The namespace in which to register the volume.
     */
    @JvmName("kmnsbycwtdhinfhk")
    public suspend fun namespace(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.namespace = mapped
    }

    /**
     * @param value `(map[string]string: )` - An optional key-value map of strings passed directly to the CSI plugin to configure the volume.
     */
    @JvmName("njwecdhgovunpejq")
    public suspend fun parameters(`value`: Map?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.parameters = mapped
    }

    /**
     * @param values `(map[string]string: )` - An optional key-value map of strings passed directly to the CSI plugin to configure the volume.
     */
    @JvmName("gwsgxofqbuhovlec")
    public fun parameters(vararg values: Pair) {
        val toBeMapped = values.toMap()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.parameters = mapped
    }

    /**
     * @param value `(string: )` - The ID of the Nomad plugin for registering this volume.
     */
    @JvmName("wgjrlfwsgatsulda")
    public suspend fun pluginId(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.pluginId = mapped
    }

    /**
     * @param value `(map[string]string: )` - An optional key-value map of strings used as credentials for publishing and unpublishing volumes.
     */
    @JvmName("ovgcyifplchswfjf")
    public suspend fun secrets(`value`: Map?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.secrets = mapped
    }

    /**
     * @param values `(map[string]string: )` - An optional key-value map of strings used as credentials for publishing and unpublishing volumes.
     */
    @JvmName("nbqvbjqqwvshxoro")
    public fun secrets(vararg values: Pair) {
        val toBeMapped = values.toMap()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.secrets = mapped
    }

    /**
     * @param value `(``TopologyRequest``: )` - Specify locations (region, zone, rack, etc.) where the provisioned volume is accessible from.
     */
    @JvmName("dfnrewylvysfrbru")
    public suspend fun topologyRequest(`value`: CsiVolumeRegistrationTopologyRequestArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.topologyRequest = mapped
    }

    /**
     * @param argument `(``TopologyRequest``: )` - Specify locations (region, zone, rack, etc.) where the provisioned volume is accessible from.
     */
    @JvmName("ueottqbciinldqeo")
    public suspend fun topologyRequest(argument: suspend CsiVolumeRegistrationTopologyRequestArgsBuilder.() -> Unit) {
        val toBeMapped = CsiVolumeRegistrationTopologyRequestArgsBuilder().applySuspend {
            argument()
        }.build()
        val mapped = of(toBeMapped)
        this.topologyRequest = mapped
    }

    /**
     * @param value `(string: )` - The unique ID of the volume.
     */
    @JvmName("kkrctvfcwfbrmbgy")
    public suspend fun volumeId(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.volumeId = mapped
    }

    internal fun build(): CsiVolumeRegistrationArgs = CsiVolumeRegistrationArgs(
        capabilities = capabilities,
        capacityMax = capacityMax,
        capacityMin = capacityMin,
        context = context,
        deregisterOnDestroy = deregisterOnDestroy,
        externalId = externalId,
        mountOptions = mountOptions,
        name = name,
        namespace = namespace,
        parameters = parameters,
        pluginId = pluginId,
        secrets = secrets,
        topologyRequest = topologyRequest,
        volumeId = volumeId,
    )
}